From e0a0661317b226c69e53590a3e50db6b85424d5d Mon Sep 17 00:00:00 2001 From: Tim Skov Jacobsen Date: Tue, 3 Dec 2019 09:57:24 +0100 Subject: [PATCH] Move styling cell to bottom of notebooks --- .../Session 2 - Data Structures.ipynb | 2789 +++++++------- .../Session 2 - Exercise solutions.ipynb | 711 ++-- .../Session 3 - Exercise Solutions.ipynb | 1035 +++--- .../Session 3 - Functions.ipynb | 1139 +++--- .../Session 4 - Exercise Solutions.ipynb | 954 ++--- .../Session 4 - Plotting.ipynb | 1601 ++++---- .../Session 5 - Dataframes.ipynb | 3301 +++++++++-------- .../Session 5 - Exercise Solutions.ipynb | 1611 ++++---- ...ssion 6 - Exercise (shear key plots).ipynb | 383 +- .../Session 6 - Exercise Solutions.ipynb | 613 +-- ...ession 7 - Coordinate Transformation.ipynb | 995 ++--- .../Session 7 - Exercise solutions.ipynb | 699 ++-- ...Session 8 - Exercise (Interpolation).ipynb | 391 +- .../Session 8 - Exercise Solutions.ipynb | 237 +- .../Session 9 - Exercise Solutions.ipynb | 1151 +++--- ... 9 - Heatmaps and merging operations.ipynb | 669 ++-- 16 files changed, 9207 insertions(+), 9072 deletions(-) diff --git a/Session 2 - Data Structures/Session 2 - Data Structures.ipynb b/Session 2 - Data Structures/Session 2 - Data Structures.ipynb index fd51fbc..6a63660 100644 --- a/Session 2 - Data Structures/Session 2 - Data Structures.ipynb +++ b/Session 2 - Data Structures/Session 2 - Data Structures.ipynb @@ -1,9 +1,1406 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# 2. Data Structures\n", + "\n", + "Data structures are constructs that can contain one or more variables. They are containers that can store a lot of data into a single entity.\n", + "\n", + "**Python's four basic data structures are**\n", + " * Lists\n", + " * Dictionaries\n", + " * Tuples\n", + " * Sets\n", + "\n", + " \n", + "## Lists \n", + "Lists are defined by square brackets `[]` with elements separated by commas. They can have elements of any data type.\n", + "\n", + "Lists are arguably the most used data structure in Python.\n", + "\n", + "### List syntax \n", + " L = [item_1, item_2, ..., item_n] \n", + "\n", + "\n", + "### Mutability\n", + "Lists are ***mutable***. They can be changed after creation.\n", + "\n", + "### List examples\n", + "Some examples of lists:" + ] + }, { "cell_type": "code", "execution_count": 1, "metadata": {}, + "outputs": [], + "source": [ + "# List with integers\n", + "a = [10, 20, 30, 40]\n", + "\n", + "# Multiple data types in the same list\n", + "b = [1, True, 'Hi!', 4.3] \n", + "\n", + "# List of lists\n", + "c = [['Nested', 'lists'], ['are', 'possible']] " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Dictionaries\n", + "Dictionaries have key/value pairs which are enclosed in curly brackets`{}`. A value can be fetched by querying the corresponding key. \n", + "This can for some problems be much easier than having two lists that relate to each other by index.\n", + "\n", + "### Dictionary syntax \n", + " \n", + " d = {key1: value1, key2: value2, ..., key_n, value_n} \n", + "\n", + " \n", + "Note that values can be of any data type like floats, strings etc., but they can also be lists or other data structures.\n", + "\n", + "**Keys must be unique within the dictionary**. Otherwise it would be hard to extract the value by calling out a certain key, see the section about indexing and slicing below.\n", + "\n", + "Keys also must be of an immutable type.\n", + " \n", + "### Mutability\n", + "Dictionaries are ***mutable***. They can be changed after creation.\n", + "\n", + "### Dictionary examples\n", + "Some examples of dictionaries:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Strings as keys and numbers as values\n", + "d1 = {'axial_force': 319.2, 'moment': 74, 'shear': 23} \n", + "\n", + "# Strings as keys and lists as values\n", + "d2 = {'Point1': [1.3, 51, 10.6], 'Point2': [7.1, 11, 6.7]} \n", + "\n", + "# Keys of different types (int and str, don't do this!)\n", + "d3 = {1: True, 'hej': 23} " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "The first two dictionaries above have a certain trend. For `d1` the keys are strings and the values are integers. For `d2` the keys are strings and the values are lists. These are well-structured dictionaries.\n", + "\n", + "However, `d3` has keys that are of mixed types! The first key is an integer and the second is a string. This is totally valid syntax, but not a good idea to do.\n", + "\n", + "As with most stuff in Python the flexibility is very nice, but it can also be confusing to have many different types mixed in the same data structure. To make code more readable, it is often preferred to keep the same trend throughout the dictionary. I.e. all keys are of same type and all values are of the same type as in `d1` and `d2`.\n", + "\n", + "The keys and values can be extracted separately by the methods `dict.keys()` and `dict.values()`:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "dict_keys(['axial_force', 'moment', 'shear'])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "d1.keys()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "dict_values([319.2, 74, 23])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "d1.values()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "See how to extract values from a dictionary [further down](#Extracting-values-from-dictionaries)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Tuples\n", + "Tuples are very comparable to lists, but they are defined by parentheses `()`. Most notable difference from lists is that tuples are **immutable**.\n", + "\n", + "### Tuple syntax \n", + " t = (item_1, item_2, ..., item_n) \n", + "\n", + "### Mutability\n", + "Tuples are ***immutable***. They cannot be changed after creation.\n", + "\n", + "### Tuple examples" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Simple tuple of integers\n", + "t1 = (1, 24, 56) \n", + "\n", + "# Multiple types as tuple elements\n", + "t2 = (1, 1.62, '12', [1, 2 , 3]) \n", + "\n", + "# Tuple of tuples\n", + "points = ((4, 5), (12, 6), (14, 9)) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Sets\n", + "Sets are defined with curly brackets `{}`. They are **unordered and don't have an index**. See description of indexing further down. Sets also have **unique items**.\n", + "\n", + "### Set syntax\n", + " \n", + " s = {item_1, item_2, ..., item_n} \n", + "\n", + "The primary idea about sets is the ability to perform set operations. These are known from mathematics and can determine the *union*, *intersection*, *difference* etc. of two given sets.\n", + "\n", + "See for example these links for explanations on set operations: https://en.wikipedia.org/wiki/Set_(mathematics)#Basic_operations or https://snakify.org/en/lessons/sets/.\n", + "\n", + "A list, string or tuple can be converted to a set by `set(sequence_to_convert)`. Since sets only have unique items, the set resulting from the operation has same values as the input sequence, but with duplicates removed. This can be a way to find all unique elements. \n", + "\n", + "For example:\n", + "~~~python\n", + "# Convert list to set and back to list again with now only unique elements\n", + "list_uniques = list(set(list_with_duplicates)) \n", + "~~~\n", + "\n", + "### Mutability\n", + "Sets are ***mutable***. They can be changed after creation.\n", + "\n", + "### Set examples" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{1, 3, 6, 7, 8, 21, 26, 32, 86}" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s1 = {32, 3, 1, 86, 6, 8}\n", + "s2 = {8, 6, 21, 7, 26}\n", + "\n", + "# Find the union of the two sets\n", + "s1.union(s2) " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{6, 8}" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Find the intersection of the two sets\n", + "s1.intersection(s2) " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{1, 2, 3, 4, 5}" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "list_with_duplicates = [1, 2, 3, 4, 5, 2, 2, 3, 1]\n", + "\n", + "# Create a set of the list (which removed duplicates)\n", + "s3 = set(list_with_duplicates) \n", + "s3" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If a `list` is wanted again:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1, 2, 3, 4, 5]" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "list(s3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The `in` operator\n", + "The `in` operator can be used to check whether a certain item is contained in a sequence. The result of the evaluation is a `boolean` (`True` or `False`): " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2 in [1, 2, 3]" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "'ma' in 'Denmark'" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "'er' in 'Denmark' " + ] + }, + { + "attachments": { + "image.png": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAh4AAACVCAYAAAAXK/N4AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAACmRSURBVHhe7Z0JmBXVlcdvs0izCbaiBBQIIBBUIEQZhgEkZKIGF4hbEIkSshlNjEPmU8IkImRCiDM6aAbFBUISNcQF0aBBYxiIhiAisghhUWSXfVGERra5v/PqPopHA728Lvo1/9/31Vf1qurVcuvee/7nnFvv5R30OCGEEEKIBKgSzYUQQgghyh0JDyGEEEIkhoSHEEIIIRJDwkMIIYQQiSHhIYQQQojEkPAQQgghRGJIeAghhBAiMSQ8hBBCCJEYEh5CCCGESAwJDyGEEEIkhoSHEEIIIRJDwkMIIYQQiSHhIYQQQojEkPAQQgghRGJIeAghhBAiMSQ8hBBCCJEYeQc90XLpWPy4cx8tjz4IIYQQolLS+EupqYyUXXjMGuLctnnRByGEEEJUSlr2d67FDdGH0qNUixBCCCESI6sRj4PdRjtXs4EtCyGEECLH2brQ5c0ellpWxEMIIYQQuYaEhxBCCCESQ8JDCCGEEIkh4SGEEEKIxJDwEEIIIURiSHgIIYQQIjEkPIQQQgiRGBIeQgghhEgMCQ8hhBBCJIaEhxBCCCESQ8JDCCGEEIkh4SGEEEKIxJDwEEIIIURiSHgIIYQQIjEkPIQQQgiRGBIeQgghhEgMCQ8hhBBCJEbeQU+0XDpmDXFu2zxbPNhttHM1G9iyENlkz56q0ZKvZxlVNi8vL1oqmrJW8aTgPnLlWkvL8Z6VEKL8oH/Jzz8QfSomWxe6vNnDUsst+zvX4obUchlQxEPkHBivYMBkyIQQIreQ8BA5RzwqUNkjBEIIUdmQ8BA5jSIeQgiRW0h45DAzZ85y06a97hYvXhqtOZzjbS+K9es32HeYKjJEOiQ6hBAi95DwyGGGD/+F69nzK65fvwHRmkNs377DdenS07ZPmvTHaO3xmTLlz/YdporItm3b3PPPP+/uvfde98tf/tJNnz7dFRYWRltT7HrvPbdm3Di3c9GiaE3uc8Df49Zp09z2v/3NHdi9O1p7JPs/+cRteuklt/7ZZ92BXbuitdlj7+bNbuOLL7rNr7zi9u3YEa1Nnr3bt9s1fPTOO9Ga7LDj7bet7lCHyoPtb77p1owf7/asXx+tqVxwbxsmTYo+ZReeybqnnnLb//53d2DfvmjtycOWqVPd2t/9zhWuXRutOcSTTz5p/SH94jPPPBOtrbhIeOQw119/jc3nzp3vVqxYacuBuNjo2/faaCn32bJli3vFG5ylS5e6WrVquerVqx8R+dj1wQfWQD9ZsiRak4JOa7lvnGFa99vfusI1a6KtFZv9XkRs/vOfTXzsP4bwoCw2/elPbsPEicfcr7Ts9cJv4x//6Lb4a9n/8cfR2hR7t251Kx98MF2+K0eNcrv9sygP7DomT3Y7Zs+O1mSHj+fPd6vGjHF7PvwwWpNddrz1lvvQ18M9GzZEa/y9eAG3+vHH3Zpf/9rtXr06tc7fHwIIIZRL45g+9AaQ+lce7F61yq31bfajOXN8g9gfrU2B4KY+vD9yZHo68Omn0dbKwbY33nBrxo4tUvDn5+dbfzhz5kwTIRUdCY8cpk+fK63CAZGKOK+++prNe/To5po1a2rLcUilZEYKsk2mGMoWderUcZdccon7wQ9+4Lp06eJq1KgRbUmRV7Wqq1q7tsvzoiQOhhtDWLdtW1erWTMzMit/9atyM44ngiq+86lyyimuCvWiHFJRedWq2fEpW5YDRGQQHYXr1ln5MtVu08ZV9c8ql6ji61JelSrldt32bPwzoo4GLErlxfSmKVPcx/NSP02wb+dOE3gmnnNIeFSl/tWsGX3KLvZsfLnZ8WN1+9NNm9w6b2xp36c0aJCuf+UVeTlRVPX3Td0sqnyvueYa6w87d+4cranYSHjkMPXr1zNhAS+++JLNAUERhEiIigBjPUi/VKlSx1IptWqd4Zo3P89NmPBstEfRsC/fGTjwlmhNCr7L+mHDRkRrUucI+7O9oKCxGzJk6BEih/QQ+40ceV+05tjg9WV6fvF18WU69+qnnZYyvjFotDWbN3cNrrzSneUb6llf/arb4w0lIUw6/8oCoqt6/fp2v9mGssW4YJgxBAE8+W1/+5tr4AUh5ct0xmWXmSHIJarVretvsorLP/vsaE12wWhULyg4QhRjVKqdeqr7ZOnSw6IhuUY13+6q1asXfcouJmp8udG2g/BA8G57/XVLvzS49FLX6IYb3JlXXWXTqR072j6VhWq0aX//Nc46K1qTu0h45DhBWMQjGDNnvmVjPICoSODqq/vagNOGDc9yAwb09+q4k0UlEBQlGYB6NBiY2qXLF9MDUxFGXAfiIlO0cI3st3TpsmhNdkB81O3QwbX62c9c/X/6p7QYyQRvvd5FF7m655/vdvnOfr/3MGHrX/7i5l53nU3vfvvbbuv//Z+th3VPPOFW/M//uOUjR9r2+Tfe6NY//bRt27VsmXvvnnvc6jFj3Dy//v2f/9yteewxN79/f7fx+edtH9j08stu/k03pY7/rW+5Lf58AdJDa8eOtfPwvXn9+rnVjzwSbT2Sf/zwh27BN75hYx3iNLn1VvfZH/0oZUSzzClnnuma3XGHO8dfe9zAIHIIAe9cvDhaczgLv/tdt+W1VBQuQGqGsiQ0f2DPHguNv3PttemJ8QJxCLXP9WXCNu79oyg6ECCCNd+XB9vn+fKjPAObXn3VfXD//TbN9cbpna99zS2/995o6yFO697dXTBunImD8qDB5Ze7c4cOdTWbZkQhffnVaNjQHdy711KFmVC2pIBC2cy/+eb0/VPHP/T1kLJkDEnYh/QNY2E+eOABt8JPmXz4zDNWvz7dssU+f3DffenvLhk8OP0s1/r6uPC22+xYAcZPLfmP/3BbYu0Dzh02zDW55fC2ni2IoLXx11jQs2c62kZKausbb7j8Jk1cwRe/aOIkULtly2jJC+N33nHvfu976ftb/9xzVueAerXspz916315LBkyxLYv8vWL6N3B/fvdMn9PpL1YT7smSkobX/3oo25flG5k3EU4NtPGlw45gjwH6t17vk9iG99lnBRsnzXLvZvRNkjzLf+v/7LvhePDWVdf7dr+7/8edo+5ioRHjhPSLYiOYPDjaRZEBiAsgrh46qnxbty4MW7GjKkmDvgu40TKyr333m9Cg+tZvnyh27p1rXvooVG2jagKoifQufNFdn2tWp0brSk7YaxHNe+N12zWzAzvsd58ySPs7T3NT70BxOjtmDnTjFFj36l/7sEH3ek9erjVXjxs9+uBAYF0TnRYbMer2vjCC+7juXNtwCdh8i3TprkzfMdImHzXypWubvv21jHu8R0Tx0HktLz7btfmv//b1W3XzsaZsA4+9Z7uat/B0Wm19Map+V132XHC+QOMS0GY+Jtzrb2xOa1bKuoVqPGZz7gajRt7F/FQOD9bmMflj30KXlcsolL38593jb/+dbfWi4W3r7giLcgCGEfEWRyEx84lS1IhZP8s5vbt6+p16mRle47vjDdPmWIGFQpXr3aLBw1yp/3zP9v2Ft7o1fGGKPDxu++aUbDt3sgivjZ447LuD3+w7RgoRB/GtNV//qeVLaH5TNFW3YspjhtPhWSTU7ygQXRUzYjGQa0WLUzw7PDiIT5+hvpGKgGvnvvm/k/15b18xAi3a/ly24e686G/V4xh0x/8wH3GCzTGBOxescJV9WVL+WRCihHRQRtZ58UF57ay9caX+sw4IcRGvQsvdLt9Xd42fbp9b99HH5lg3u/ntc89vP1yb/m+/pUH1BMrI/+MQrve7/survGU00+37UVBHVv18MOuXseOdn+f8cJz7W9+Y4KXekn5bvX3hqGv87nP2T6MqeL+iahQdggFHBnaMuNwavn7RjSQEmMsFaKP7zHRLyBsEDuAkKDfQCyx/XTfP6z3x/544UJX94ILLHq4KSY8EJ47/bZazZtb9DLAPWaWd64i4ZHjIBz69LnClkO6JQwsjadZ2rRp5Q4c2Ol27dpsn0nFEIUIkZHMVEhpCOIFQbFixSoTQowvCeNQ4ukgxM/UqX9ygwf/KFpTekJUo6joRlHrDsNvP3jggM03+8Z/6he+YB4V4VwiInTGiIZALe9F0flj3PO9uMnznV3wBDnO2QMGWHqBThABggg66EUNnhPHO/vb33b5keE+rWtXM77B4wS83lbDh1vHRrif8wTjAh8++6xb4M9R4EVR61/8wo5TETwgruEcb+wv9J15g698xX3ghdWc3r0tBQPc856NG63Txptc4zt+BlVW950p4flNkye7g94ANPFeKWV/Wpcudo8MJKTj3uC3U9ZnDxzo8hs1ssjLYame2bNddb+OiALPjE4bEfOJFxqhDiCYmt95p6XbQtkWVqC3SzBMGCKMXvzNBYwfAqnBZZeZkOX+G3rPGbFGRM48d3+PlAnlhxAlkkdagjdBKA+ECYLhfS9W8Oo/9c/i082b7XiUf8PrrrOJss8/5xyX7wVE+E7tVq1M6GyeOtWuh/qOgENsmsA90fB8IxG8euxYN+uSS9wM/+wXePFK2XzsBUCe3+f0L33J7u+MSy91ddq2dR8vWJD6rodxN0QUSNVQvojPXV608fYM9YxIWH3fXkl3UDfpB+zNGt/mSem28uXKsZksmuW37Y8NAq3jn8dn//3f7dg1P/tZE/CULf0EDs62v/7VHfTfoWy3z5hhIoNnWB7p0oqAhEcl4KqrUsIDMUHqhMgGxj6eZgEESdu2X7CxFb16fdWNH/9EtCU7IDYg/kou5wmihlRMeRCPaoRljM3xRAdhbTzh6qeeap0LuXW84DneY8FrX+gNKYaLcCfGwPAdQQjzciY7X+w86W2+Y7GoQAwGCpJmme2NI8f/x7/9m8u8wlq+UwopDIzy+Y895hp57zXAGApEyTbv/eJtVSSIEnDNTW67zX3eCyTExtpf/9qEA14wc8bSYNB2ezHFeAbKnY6bsi/005w+faxs3sZrjLzEAzwnL9BO8Z165tiIANsRKaRY+D7hbEtj+WfDNuBZYYzT9SVWbyoKGHlg7JEJYg/zvd5IISCCIUKg4g2baI32Y1wP0Qn24TjUHQQKImyv34/6YukDb+A2v/qq1V8EI6IYYfPWl79sZUca6sMJE9Lth+M19M/lo7fftpSPCRI/L/CGON72TgSMOarmy4FnTNTynG9+03Xy98b4Ld58oe4gshCmC7xo5f6CICZaEiA6WrNJk3T7JVX5OS+ecRyAuk05cK6qpDBj980r5ojp2V4YcvylP/mJ2/X++9HWFHyXupf6EH03Kt8zr7zS2v26J56w/ghxTtoIIVlZkfCoBBDxQGggOvhtD4inWYDIRr9+37B9eL124sTfu0WL5hy2T1nJz095oIwfIZqROd155yDbnm3oIOkAS9IJIjoYDEkHUd97MHgydDJ4ix1feMFd9Npr6anxgAFZiSoQBscwd5w40V3kO8dzhw+PthQfBiA2/f73bUzKivvvd/uiaEtx+cQbfl5Fft/f915fBuUFUR8boImh9M+nznnnWdj/I28ATvuXf7HwMsaAztiMh+/MTznjDNfBG7xOXjCEibQIBqGG74QxFHj/wZiEcTnA8yFM3m78eHtm4fvn3nOPeY/ZYrkXTHO8wNnpz308YVsaEBenduhgIi28NonRozxJd4RXRD9ZtszuH+/6eGkhIm1ERxAOIZW0w9/DQd9eKDfSWIxBIAVBmX3eCz7SBXGIBFK+REwQ50QAgkgqLh97Ab9gwQIrw2xBvSF6gai33/eIyieAwaeuEbE5//HH0/WCqfXPf27bywrjPyjD9r//vbvICzhSqSUdnIz4IP2Co4OQrJ8jb6eUFgmPSkAqupGKeoQoRjzNAkQ7iDywL+M7iIbwuSRRiPi+RFUyv9umTWubI24QPmFibMf06a978XPISJbmV1WPRqbgOJpBwHMkbYLgIN9PjpcQKKFTPO8GvXq5Qt+58zsL7MOEZxQ85rKC8eRKd8yaZb/HwTiItBdUAjDizbyHRR6YvHQ8FXM8lnmD9X0vXAZ4MbXad5bZYs+aNekyY+IHzBiLUuCFHJ44Y26IapDXLrj4YiuLT/7xDws1Y/wQfHTWGEDy6GEKv7OCMcbT3uBFIW8hMfYD7z1gHbV/vh/6zp+xDXyXsTHZ/p2WkSNHuov99f/FG67ygueL8MD7Berm6d4D3jZjhtVZ7o0xBDag0l8LouJ4IL4YL0RdRzAQUSENQdSEZ0DaCRHLsRkwWtQPszXq399EB8+NNGJJ+Yf/Xu/evd13vvOdrKR2ASFO6qSGrzsbnn8+XT7UDaJjoW5RhtRJtoWJMs6GeDTx5/sg2iHpWtp2SfuMhtdfb9FABq7yTBHhlZmq93ii5dKx1jfAwsgANb3cS/ZDg2FEcuzdu88991zqvXXExWOPjbZ5AJHw5JN/cPvIPe7f7z2PRW7QoMHpMR69e1/hOnRoZ+M0Xnhhsq0bOnSIzd98c7abPXuOe++95W7evAVeRLzhfvzju9PfDQKDNsw1kHJZuXKV27Ztu0VgRo9+xB/jLTsev8EB3btf4h54YLR54Jz7eOzblxIX/HLpbO8pN27c2J3nO2ig0afDwpEIYR6mAIYPL5EQPwYJT7DRjTdaFALoQOigd3jPkH3s1UbfgdU85xzzOOmY8Rjree8P6LgJW9f2niDpEdIxp7ZvnxoQ5q+nfqdOdl3mlflrxXNnnMNO3wEXrlplg9XI+ZLL5RrwcMkR48HRUR6GN6oMOMRAMMCMQXZ0uuTwq1SrZiP+i8Mp3khRfq/5DrJfv37uM/542YA0B2IulBu/rcDrjbxSywBerhVRh9FjrAIhbcqLsqzdurWlURAXDNgLx2Ci3HkupG0oVxvz4Z8Jz66e92IRK4SpST1QvgwE5I0LvkuEgPPymy2kGYis2PMheuXbAOXN9XD84rLJ39csf41neuHUo0ePw+pXaaEOke+v48uBe6COMWART506hGhjG/WNSAX3xjYGQdeMPGsbLxDtXxSMp+H+iWRQJhyLcxEJ4PVM6h1RA/vdkL177Tg1GOvg662Vl4dxHwxyZeyMpTJKSG3//F566SW3yD+fr3/96+5Ufx3ZgCgRbQahxptNlA+CHjFK26JN84wZ/B3qBlO+rzPUH6KfGH2cEOpRJkTXaHO2r39WRH4Qa1affJ1lnAwRD+oeUT3qG+NfrF77+mvpXH8N1FcIvzzMNaejcb6fsPFIn35qg7QR66Xhb17041D07ds3WnMk1aqVUGzt3uTy1qUGFruCdn66ILVcBvJ8x1g2yTfLG6dt0Wtd3Ub73ju33tuvLOBBFBScbfPLLvuye/nlQ69wAusbNWqRFgvA67REIYg6EAEh/ULEJLz6ymBUQLR07NjlsAgH50CksA5BEUTKoEF3uVGjfD2IwQBYBpPynQC/8UFkhLQMEZjjUViYCs6RInj44YddJ9/5Xe+9hAAGIBvey4kkiXvY6j2xn/zkJ5Yu+N3vfufOTXiUfDYM9Ylk/PjxDl+Nn6a+7rrrcv5+SgKRJt4cavvggyZISsrmzZtNcNAX8bcH9UtpXCsjDNZdNnSoiXUGUJcW6uWMGTPcpKP8eBr9S35+akxQsdm60OXNHpZabtnfuRY3pJbLgIRHJQIhgLBo1qxJkb9WisB49NGxtk/37l1trAfRCcQD4zMQIiyH9AdRjADfIUIBrVu3stQO5yss3HPE+UijvPJK6vWwet57Q1wgPuKwD99ljAlv3ByPuPAg3P2R9/A+5z2Pbt26ua5du1p0h6ocjHfcIJS1iidFeQuPhQsXmuFct26du8p7vlcyqC3yZpMiVw01kY4pU6aYWGvXrp376U9/anX7ZMDSK94wbpk+3d76aHjN4Wnc4vD666+bMWR8x/e+9z375WGReg2ct1iIshJtOYe33qIoVkkYO3asW7VqlXvzzTetL5TwECILBOGB4HjrrbfcypWpn2PHCLRv3/6w/2yhSkt4HMkHH3xg3lDTpk1dx44dExcdkKvCg8gg/4NBxOhS75WeHkLkJwGMcyJtFVI1pWHevHlu/vz53mlp7S688EJXJQuDOisDjAvhtV5SX7xeT+q1NEyePNlt2LDB2hdpaOpoUdC/SHgIUUyC8CiKYLCLmkNZq3hShOuuzIRnIoRIHvqXiiA8JDtFpSAYtMy5EEKIioWEh8h5UPFhEkIIUbGR8BBCCCFEYmiMhxBCCCGKRmM8hBBCCJHLSHgIIYQQIjEkPIQQQgiRGBIeQgghhEgMCQ8hhBBCJIaEhxBCCCESQ8JDCCGEEIkh4SGEEEKIxJDwyHHGj3/CValSx6Zp016P1paN+DHF0Vm/foMbMmSo69Klp2vbtqO79dY7svYMxOGMGfO469nzK1bmongsXrzUXX31DVY3mVhW/SwdU6b82epfo0YtrL0PGnSX6mIZkPAQohQUFhZaRz5y5H1u5sxZ1sljHHv1+qqbO3d+tJfIBpTnoEGDzWhS7uL4rFix0nXs2MVNmvRHq5tMLGM8cSxE8Rk1arS1a+ofYoP2zjoEyPbtO6K9REmQ8BCiFIwZM9Y6oPz8fHf//b90Tz013rVp08oMI96QKBt06JQjnTsGVIKjZBCJo8yokzNmTHVz5sxwHTq0S28TxYN6GMprxIhh7sCBnW7ixN/bZ8QdYk6UHAmPSgheOJ4NHTcqnc6btAkdOCHDOMFQsq2goLF58UdT8cFjqlXrjHRqIb7vsGEjbDtTCEPirYZ1RAQCeAzsn6sN98UXJ9u8b99r3R133GZzBAjMnPmWDGUZ2b59u9URxJ0oOUQ44Pbbb3WdO3cy0cEy0DYxmuL4UA9DW6adQ58+V6ZF3MqVq2wuSoaERyVk6dJlJjgmTZpsIcLQeSMCQsgwgNCgg2cbIgIhMHz4iGjrIQjPhhwxDTGkFhAgQWTcfPONZnTZJ3j9AwfeYp/Zv2/f62wdPPjgQyY8XnzxpWhNbhHKsF27C2wOzZo1tTnlo3RL2aAs8S6Zpk79U7RWFJebbrrRDR06xERH4GgOhTg68XpIdBMQbUG4tW9/qP2L4iPhUYmhcRAe3LVrs4VaQ8N5+unnbI7ICBGQAQP6u3Xr3nfjxo3xhnOPrQtgSEO4EbW/fPlCC9/SKBEdQWTw+e67f2zLEyY8a8IiGGCOW79+PVuuTMTvKT+/RrREmR1ehkIkCd45wiN45oiORx8da8ukX4JIFsWHvozocfPm51l50mfSH4qSI+FRiaGDoQNCcNABde58ka0PocN4tIE0QcOGZ1ljuuyyL0drUxDFCFENhAWdFp4UEQ4gshLgfKGzQ3hAUcdEvOBFIEiEEOUHRpJUJ1FHhPLEiROiLaIkUI7x1B99YuhLRcmQ8KjEICSORRATCIW45969e9doKUU8H8xYkPCqbRAWNL6wDyInLia4hjD2QQiRLBhK2izeOg4DkU8cElFyevTo5hYtmuMeemiU9XNEi4cP/0W0VZQECY+TmJKmPmhshG+LmurXrx/tlXrnPYC4Wbx4SfSp8hDSVkG8QTy9Ek+7CHEiYFxWz569zCkgJYDoUIqlZNC+Gc8VIh2Itltu+ZafvmmfMwfri+Ih4XES07p1yvPBG4pHNcIbG4GQOiGy0bv3FWmx8d3vftNdfHE3m4KIIZwbvIBgnBlgWtlCkng/MH/+AptDGM/CfYcyE+JEgLEM7W7w4B/ZK6AldTREqj8jTcXYjjisF6VHwuMkBuEQxAFvrDAgNLyCGweVH9I2bGc/lD5vyNAoeUMlEDo79g8DWuNiJMAALdI17J+LXH/9NTanLBh4S9opDMBlLE0oVyFOBPE2SXsOr7SHKR6pE0cHByK05X79BlhfFvo/iL81JIqPhMdJDOIgvIWCt07D4tXazHAsDY9xG8zpxNgv/EInDTOM6Qi/4gm8TZMKS6ZCkvFtlYH4iHbuDeFB1AivUgNmxYlm2rS/RkupcR602/hU2SKQ5QXtmb4MEBz8fAD9H9C/hW2iZFS9xxMtl461f3GuMFLPTS93rnrt1LJIDAQEoX8mxlocPHjQN4rWlgKJh/z9avt88cVdbTt07drFNW3axOXl5ZngGDLkTvfDH9522DGhZcsW7ppr+rj9+/e7OnVq2763336be/jhB/zn1H+6vPHG3+14l176r+77309FMriGatWq2XGYn39+W1vPteAtxK8l1yDt1LhxI1e3bh139tmN3cCBN7tf/eo+5dHLAep1qj52VzTpOCAq9u3bn26/RU8qx+KS6qe6uR07PrJ+MfR9jz02Ot33VWp2b3J566anlgu8PSko+2+X5Hkj5U1AGZg1xLlt82zxYLfRztVsYMtCCCGEyHG2LnR5s6PITsv+zrW4IbVcBpRqEUIIIURiSHgIIYQQIjEkPIQQQgiRGBIeQgghhEgMCQ8hhBBCJIaEhxBCCCESQ8JDCCGEEIkh4SGEEEKIxJDwEEIIIURiSHgIIYQQIjEkPIQQQgiRGBIeQgghhEgMCQ8hhBBCJEaFEx7bt+9w06a9btP69dHf7cdYvHipbZs5c1a0pmIxd+58uz6uMwkoo1BelF02iB9TCCGEyCYVTnhguHv2/IpNV1995N/v3nvv/batX79vRGtODHGBFDf4gwbdZdfHdSbBlCl/TpcXZZcN4scUxaNjxy6uSpU6NkmwZQcE8MCBt7hatc5Ily2fsyWwKzs4Z23bdkyXXUFBYzds2AhXWFgY7SFKC7aJMl2xYmW0RpSECp1qoeGMH/9E9KliERdI2TL4IjehjqoOZBeMI20rtP82bVrZnM9XX93XlsXRQbT17NkrHXlt2PAsE2wIj1tvvcPWidIxatRoN2nSH6NPojRU+DEeQ4YMLZFCL06Kg0ZZnGOyT0m916lT/+QOHNjpxo0bE60pOVxftr264hjG4qp3qfxD8Jyoo/Xr14vWiGwwadJka8sYzK1b17hFi+a4hx4aZdtok6qDx4aIK/1Xhw7t3PLlC20aMKC/bUO80ceI4hMcTaJvRLVF2ajQwiM/P98aCB37saCBoeIJfYXQIqGwzMZFZ0VIvFGjFukKhAfA/vG0ApEW9mMf1rO9efPz0iKEVES88rEcPLOwPyFh6NXrq0ccH9jOeq43MGHCs3ZtTIRFOSfnKinh2JwTdc59hPvhfuNQRuEaOR/Xs3Llqmjr4YwceV/6uti/S5eeh421CedlCkIHzyCsi5+7X78Bdn0cM5cZPnyEleGIEcOiNSIbLFmSciCIdNAPwGWXfdnmoHTLsQkOGGXWrFlTK8PvfGegrYOkxqBVNjp3vigdfROlp0ILj7vv/rE1mDFjxh6zoTDeY8yYx20ZDwkweBjb0EEhTjCUcc8fo/zAA6OjTynYD9HCfhwLLwGvAdGCgS6pp3D99dfYPHMsSAjVfe1r19qczxhjjs89M4Vzljasxz0gikKZcG8YfwRO+EyZxMUN5ZwpTgDxx8Q9BO8e0UE4N5Qpxjeca/jwX9jxmQNleNddg2wZZs58y8pk6dJl0Zrcg/umDvXte+1hRlGUnaFDh1jkkAhi4NFHx9mcOkZ9EkeHtkjZxcVGvO/Kz68RLYniQH2jPJnuvPNQPyZKR4UWHnQwGCsM2NHCW3T+wTATil237n0LK2K4aWh4pIB44TNGc+LE31undv/9vzzCc+J4oYFSyUiZhM6P68DYYmT4boDlEMbMBKPEtUAw8BwjnPfmm2+0eTDQffpcaaFlJpZh0KDBNi8pnOPll5+38ti1a3NaFPz1r2/YHAESQtbcA2UyZ86M9PUGKA8MLNxyy7f8ta21qXPnTlYmISLF8UO58EyCgON4lGP8uHgOPXp0c61anRutyT2IslGf4nVBZB+cCiJmITpGnRbHBkNJ+yLaAfQFoY/BY5dwEyeSCj/GA+GBQcNoF+X5B2OOUWvTpnWU/12VblghPfLqq6/ZHGMeDPodd9x2RNgMY4oBxlBjcDlnSJtAplA5HlxXnz5X2HK4hldeSc05Fx0D5wlRg+7du1o0gKl9+wtsHeKgNKFRjh888VT5pO4VsQBBgLDtllu+acuUW7jeAOcO3+H6KFOuNxyPZxC2x73/8Gx4hpkd3VNPjTdBN3jwj6I1FROMHSmh+ASk1hCQ8SiPKDmUY2b5hrYQKCzcEy2lePDBh6IlgUMWLzuippnQv4Rypa7S9uJOgDjE0dq7yC4VXnjQQMKgMjz/YOACGzdutDnr45UljD0IBjvMMZxxggiJQ2fIOAaOg9de2lRH4KqrUoY8GOIgPK666nKbhwgLxDuSeMojvk9xOV44NUQ7EAXxjiizjMJ+EMZmMIVxLRC/vngEAGEVT7HkGqSCEFrxCYjyUGYbNmy05xQ3hr/97ZPp/cSxYTxRZvlminscBByBMGCbelfWNllZQEzEyw6HJQ7rGLfFfrTzGTOmHuEEiEMcrb2L7FLhhQcgDggbYgAZ7R4nGEy875CDi08hLBuMcKZwiRtVQKAQ4cCQ4r2TliF9UxaIIBCS55hU5CCKQnombvRDaidzKo/OInjqmaIGYxonfn1FXRtT3OuPG+GinlkuQSqIuhefgDKjLiE6mEIqCjCM06erwyoOTZs2OaJ8aSu0Q9pKcBiog7SXEGUL0bqTHfqFeNmRwgxQJ3EQEHKUHaIjpF5E0RytvYvskhPCA4IXnSkc2rUL6YhV1imFyrJ9+3br/BcvXmLbg2F8+unnbB4IUYjAH/6QGnhJAyUkiegJQqG00GmGyMqtt/7Q5lxjuCauOxh3OolwD2znHpgy7zsbhMgG4iAuwF544XChEDr7QLg+xBzXRvmE68dYhIG+oZMjipMpbvhO3LBUVEgFZYosYPBjfMIrD9DJX3yxOqziQFllli/GlKgRRjO0F6Bt0M7hzDPPtPnJDv1ivOzos4C2FcbFUTczx1iJojlaexfZJWeEB51RvHMPBAONYeYNEIweYXDedImnKm6//Vab0yCJaIR0SmZY96yzUh0ahhiPgWMU9YM78TQGRjQzcpJJeLslGNrwOUB0BXj/nvNxH/xQEucnNROPKGQLOv1wXN5uodzCgNA4CI8QcaHsgofPvizH011hPAz7T536sh0f0ZE5OJjng2FJ6hdes02m8Aj1C2666Uarl6L0BFEc2isOAu0hCHC9RXRsEG4B2mp4pT1MlKsQJ4qcER7Aa0yZBpjPjAEhPIvBxGgzQIgOioF/vIUBRByCcUd0hHRKpoGIj/nAWGJYMaLhvC+++JLNGbgZjDEG+ze/OdTQi4LzcI2B+HkAz4XjcU2IDu4DkcJ5ymsUPx5Q8IQ4L+VG7pxzxmE7nhRlgMCiTEIUg/sIv2HBGJwgwLgfIh7h1TPeoAmv8QpxPBAWYeAx7RWnIhjL0FbE0cl0HoSoSOQd9ETLpWPWEOe2zbPFg91GO1ezgS2XFiIQodHgaWcKDYwxBo+IQ9xAsu6RR8ZGn1KvqRaVz8Swzpu3wJZ7977CfhsAQ09HFww81zBhwjM21qF161YmWLgm1sfPyzk5HvsRWkdchP247swURVHHyIRrCWMseKslU6BkwjWEKAqdcciPs57leAd9tGtj/5BiuvTSf7VyC8eMCzPEHK8l79iRihKFew4EwxC/P74TBrzFr4coEW8rFFVOuUj8PsNzEGWHOhtP/fG7N5WhvpQ3x4toqI6Wnnify5iaSp/C2rrQ5c2OfiCxZX/nWhz5H2olpcIJj/KCqATGDkMXvHyMBb8SijEmjRPGkQghhBDCUw7CI6dSLWWhU6cLzQsg3N+27RdsfEFBwdnpCIB+jU4IIYQof04a4UHKgldjSakQKkOEEG4k0sGvdSI+hBBCCFG+nDSpFiGEEEKUEKVahBBCCJHLSHgIIYQQIjEkPIQQQgiRGBIeQgghhEgMCQ8hhBBCJIaEhxBCCCESQ8JDCCGEEIkh4SGEEEKIxJDwEEIIIURiSHgIIYQQIjEkPIQQQgiRGBIeQgghhEgMCQ8hhBBCJEZ2/522SS/nqte2ZSGEEELkOLs3ubx101LLWfp32qwKDyGEEEJUUiqW8Hg3+iCEEEKISklLLzoqhPBY+xfnCjdGH4QQQghRKTntfOcKLog+lJ6yCw8hhBBCiGKit1qEEEIIkRgSHkIIIYRIDAkPIYQQQiSGhIcQQgghEkPCQwghhBCJIeEhhBBCiMSQ8BBCCCFEYkh4CCGEECIxJDyEEEIIkRgSHkIIIYRIDAkPIYQQQiSGhIcQQgghEkPCQwghhBCJIeEhhBBCiMSQ8BBCCCFEYkh4CCGEECIhnPt/oMQeSrt5v8oAAAAASUVORK5CYII=" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Indexing \n", + "When elements are put into a sequences (strings, lists, tuples etc.), the individual elements gets an index assgined to them. This enables each element to be extracted. \n", + " \n", + "> **Indexing in Python** starts from `0`, while the negative index starts from `-1`.\n", + "\n", + "![image.png](attachment:image.png)\n", + "\n", + "### Use square brackets `[]`\n", + "To extract an element by indexing, use sqaure brackets `[]`. This is the general way and works for all sequences. Strings, lists and tuples are all sequences." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'a'" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "example_list = ['a', 'b', 'c', 'd']\n", + "\n", + "# Extract first element\n", + "example_list[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'c'" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Extract second to last element\n", + "example_list[-2]" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "40" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "example_tuple = (10, 20, 30, 40)\n", + "\n", + "# Extract fourth element\n", + "example_tuple[3]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### `IndexError`\n", + "When trying to refer to an index that is **not** present in the data structure, an `IndexError` is raised:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "ename": "IndexError", + "evalue": "tuple index out of range", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mIndexError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mexample_tuple\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;31mIndexError\u001b[0m: tuple index out of range" + ] + } + ], + "source": [ + "example_tuple[10]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Remember this error. You will get it a lot!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Extracting values from dictionaries\n", + "Dictionaries differ from data structures like strings, lists and tuples since **they do not have an index**. Instead, a value is extracted by indexing the corresponding key:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "154" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "d = {'N': 83, 'My': 154, 'Mz': 317}\n", + "d['My']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that this means that **keys in a dictionary must be unique!**\n", + "\n", + "See demonstation below, where the key `'a'` is defined twice. The second defintion overwrites the first one." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'a': 4, 'b': 2, 'c': 3}" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "{'a': 1, 'b': 2, 'c':3, 'a': 4}" + ] + }, + { + "attachments": { + "image.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Slicing\n", + "Slicing is the operation of extracting multiple elements at once by calling out the index range. An example for slicing of a list is shown below: \n", + "![image.png](attachment:image.png)\n", + "\n", + "> **When slicing**, the stop point of the slice is not included.\n", + "\n", + "Examples is this section are shown for lists, but the same concept works for strings and tuples. Set objects do not support indexing/slicing since they are unordered, and dictionaries cannot be sliced either as they have the key functionality instead.\n", + "\n", + "### Common slicing operations \n", + "Suppose a list `n` has been defined along with two integers `n` and `n`:\n", + "\n", + "\n", + "```python\n", + "n = [3, 25, 83, 31, 14, 47, 1, 23, 57]\n", + "start = 2\n", + "stop = 6\n", + "```\n", + "\n", + "\n", + "The list `n` can then be sliced as:\n", + "\n", + "```python\n", + "# Elements from start to stop-1\n", + "n[start:stop] -> [83, 31, 14, 47]\n", + "\n", + "# Elements from start to the end of the list\n", + "n[start:] -> [83, 31, 14, 47, 1, 23, 57]\n", + "\n", + "# Elements from the beginning to stop-1\n", + "n[:stop] -> [3, 25, 83, 31, 14, 47]\n", + "\n", + "# Copy of the whole list (alternative: list.copy())\n", + "n[:] -> [3, 25, 83, 31, 14, 47, 1, 23, 57] \n", + "```\n", + "The same concept works for other sequence like strings and tuples.\n", + "\n", + "\n", + "As seen, the last one creates a copy. This can be useful when working with mutable objects. For example for copying a list to mutate the copy while keeping the original list unchanged.\n", + "\n", + "There is also a step mechanism. Continuing from above:\n", + "\n", + "~~~python\n", + "step = 2\n", + "\n", + "# Extract from start to stop-1, by step\n", + "n[start:stop:step] -> [83, 14]\n", + "~~~" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## List methods\n", + "Lists have many methods for performing common manipulations. Methods are recognized by the 'dot'-notation, so if a method was called `method_name()`, it would be used like `list.method_name()`.\n", + "\n", + "Suppose a list called `L` has been defined. Some of the most common list methods are:\n", + "\n", + "~~~python\n", + "# Insert val at the end of L\n", + "L.append(val) \n", + "\n", + "# Remove i'th element from L and return it (if i is not provided, it defaults to last element)\n", + "L.pop([i]) \n", + "\n", + "# Reverse all elements in list\n", + "L.reverse() \n", + "~~~\n", + "Note that these all mutate the list `L` in-place.\n", + "\n", + "The `len()` function which was used for strings in Session 1 also works for lists, dictionaries, tuples and sets. This is a function since it does not use 'dot'-notation. \n", + "\n", + "Many websites have explanations about string manipulations. This is from the Python documentation itself: https://docs.python.org/3/tutorial/datastructures.html#data-structures\n", + "\n", + "**Note:** Methods also exist for common operations on dictionaires, tuples and sets and many other objects. " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Copying mutable objects\n", + "When copying objects that are mutable like, lists or dictionaries, there are some things to be aware of. This is demonstrated by a list example below." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1, 2, 3]" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x = [1, 2, 3] \n", + "y = x # <-- This does not make y a copy of x \n", + "y # It makes y a pointer to the same underlying object (or id) as x has" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1964944755848" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "id(x) # Behind the scenes, the variable x gets assigned a unique object id" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1964944755848" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "id(y) # y is seen to have the same underlying object id" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This means that when we mutate (or modify) `y`, the original list `x` gets changed as well, which is often not desired. This is because it's a pointer to the same object as y." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "code_folding": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[1, 2, 3, 89]" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Put 89 at the end of y\n", + "y.append(89)\n", + "y" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1, 2, 3, 89]" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# x also got 89 appended to it\n", + "x" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is often not the intention!\n", + "\n", + "> **When copying** a mutable object `K` use `K.copy()` or `K[:]`.\n", + "\n", + "An example is shown below by using the `list.copy()`method:" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1, 2, 3]" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Redefining x since it was mutated above\n", + "x_new = [1, 2, 3] \n", + "\n", + "# Copy to new list\n", + "y_new = x_new.copy()\n", + "\n", + "# Show list\n", + "y_new" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1, 2, 3, 327]" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Append a value to y_new \n", + "y_new.append(327)\n", + "\n", + "# Show list\n", + "y_new" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1, 2, 3]" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# x has not changed\n", + "x_new" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "x_new has object id: 1964944643784 \n", + "y_new has object id: 1964945169544\n" + ] + } + ], + "source": [ + "# Print object id's as f-string \n", + "print(f'x_new has object id: {id(x_new)} \\ny_new has object id: {id(y_new)}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## `for` loops\n", + "The general syntax in a `for` loop is\n", + " \n", + "### Syntax of `for`-loops\n", + " \n", + "~~~python\n", + " for item in iterable:\n", + " # Code goes here (must be indented!)\n", + "~~~\n", + "\n", + "\n", + "\n", + "\n", + "Recall that an `iterable` is a fancy word for something that can be iterated over. Like strings, lists, tuples etc.\n", + "\n", + "So, printing numbers from 0-5 can be done like this:" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "2\n", + "3\n", + "4\n", + "5\n" + ] + } + ], + "source": [ + "# Printing numbers from 0-5\n", + "for i in [0, 1, 2, 3, 4, 5]:\n", + " print(i)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "> **Remember:** All code inside a `for`-block must be indented!\n", + "\n", + "A common way of quickly generating the numbers from 0-5 instead of typing the list `[0, 1, 2, 3, 4, 5]` is by the `range()` function, which has two forms:\n", + "\n", + "~~~python\n", + " range(stop) # Generates numbers from 0 to stop-1\n", + "~~~\n", + "\n", + "~~~python\n", + " range(start, stop[, step]) # Generates numbers from start to stop-1 (step is optional) \n", + "~~~" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "4\n", + "9\n", + "16\n", + "25\n" + ] + } + ], + "source": [ + "# Printing numbers from 0-5\n", + "for i in range(6):\n", + " print(i**2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here is an example where each element of a list of strings is accessed in turn and named `string`." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "superman\n", + "spiderman\n", + "green lantern\n" + ] + } + ], + "source": [ + "strings = ['batman', 'superman', 'spiderman', 'ironman', 'green lantern']\n", + "h = []\n", + "for string in strings: # This would be like saying: for each string in the list strings\n", + " if len(string) > 7: # If the current string has more than seven characters \n", + " print(string) # Print it" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## `while` loops\n", + "A `while` loop is a loop that continues until some condition is no longer satisfied.\n", + " \n", + "### Syntax of `while`-loops \n", + "~~~python\n", + " while condition: \n", + " # Code goes here (must be indented!)\n", + "~~~\n", + "\n", + "Where evaluation of `condition` must return a boolean (`True` or `False`).\n", + "\n", + "\n", + "\n", + "There must be some kind of change in `condition` for every loop. If there isn't, the loop becomes an **infinite loop** and runs forever (or until you stop it). \n", + "\n", + "**An example of an infinite loop is**\n", + "\n", + "~~~~python\n", + "counter = 0\n", + "while counter < 3: \n", + " print(counter) # The variable counter is never updated. 0 < 3 is always True => prints forever\n", + "~~~~\n", + "\n", + "**The counter should be updated within the loop**, e.g. like this:" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The count is 1\n", + "The count is 2\n", + "The count is 3\n", + "The count is 4\n" + ] + } + ], + "source": [ + "counter = 1\n", + "while counter < 5: \n", + " print(f'The count is {counter}')\n", + " counter += 1 # Update counter (equivalent to: counter=counter+1)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "\n", + " > **Remember:** All code inside a `while`-block must be indented!\n", + "\n", + "A `while`-loop can be good when the number of iterations are unknown beforehand. This could be when searching for a root of an equation (e.g finding the neutral axis of a reinforced concrete section).\n", + "\n", + "When iterating, convergence is not always guaranteed. A common way of exiting the `while`-loop is to define a max number of iterations and then check in each loop whether this number has been reached. If it has, then the loop should `break`.\n", + "\n", + "A similar logic to `while`-loops could be done with by `for`-loops, but a `while`-loop is cleaner for some purposes and can help to clarify the intent of the code." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## List comprehensions\n", + "List comprehensions are other ways of writing `for`-loops. They can be done in one line and are often cleaner and more readable for simple iteration.\n", + "\n", + "### General form of list comprehensions\n", + "The general form of the simplest list comprehension is\n", + "~~~~python\n", + " result_list = [expression for item in iterable]\n", + "~~~~\n", + "\n", + "\n", + "* iterable is a sequence that can be iterated over, this could be a list, a string, a tuple etc. \n", + "* item is the counter for the iterable, think of this as the i'th element \n", + "* expression can be anything, but will often include the item\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A basic example for multiplying all elements by 2:" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[24, 430, 62, 874, 102]" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Define a list (iterable)\n", + "L1 = [12, 215, 31, 437, 51]\n", + "\n", + "# List comprehension to multiply each element of L1 by 2\n", + "L2 = [2*i for i in L1] \n", + "L2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that `2 * L1` will not create the same output, but instead repeat the list as seen below." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[12, 215, 31, 437, 51, 12, 215, 31, 437, 51]" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2 * L1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To get a vectorized behavior like that we could have use `numpy`, which is a third party library for numerical compuations similar to Matlab. Later sessions will explore `numpy` further." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### List comprehension with `if`-statement \n", + "The general form of a list comprehension with a conditional is\n", + "~~~~python\n", + " result_list = [expression for item in iterable if condition]\n", + "~~~~\n", + " * `iterable` is a sequence that can be iterated over, this could be a list, a string, a tuple etc. \n", + " * `condition` is a logical condition, e.g. `item > 3`, which returns a boolean (`True`/`False`). This can act as as filter.\n", + " * `result_list` is a new list containing `expression` for each `item` that fulfilled the `condition`\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "An example where a list is filtered:" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[4, 5]" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Define a list (iterable)\n", + "x = [1, 2, 3, 4, 5] \n", + "\n", + "# Filter list with list comprehension by use of condition\n", + "result_list = [i for i in x if i > 3]\n", + "result_list" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### List comprehension with `if`-statement\n", + " \n", + "~~~~python\n", + " result_list = [expression1 if condition else expression2 for item in iterable]\n", + "~~~~\n", + "\n", + "* `iterable` is a sequence that can be iterated over, this could be a list, a string, a tuple etc. \n", + "\n", + "* `condition` is a logical condition, e.g. `item > 3`, which returns a boolean (`True`/`False`). This can act as as filter.\n", + "\n", + "* `result_list` is a new list containing elements where each `item` depends on `condition`. If it is `True`, `expression1` is put in. Else `expression2` is put in. \n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The added `else` allows us to retain the elements for which `condition` returns `False`:" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[0, 0, 182, 0, 151, 174]" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Define a list (iterable)\n", + "v = [3, 62, 182, 26, 151, 174]\n", + "\n", + "# Set all elements of v that are less than 100 equal to 0\n", + "w = [0 if i < 100 else i for i in v]\n", + "w" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "### Benefits of list comprehensions\n", + "List comprehensions can be done in one line and are often cleaner and more readable for simple iteration. \n", + "They are also generally computationally faster than regular `for`-loops and also faster to type." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 1\n", + "Extract the last and first element from the list\n", + "~~~python\n", + "L1 = [10, 20, 30, 40, 50, 60]\n", + "~~~" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 2\n", + "Extract the following list from `L1` defined above by use of slicing.\n", + "\n", + "~~~python\n", + "[20, 30, 40]\n", + "~~~" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 3\n", + "Create a list of the unique values from the following list:\n", + "\n", + "~~~python\n", + "L2 = ['Hi', 'Hello', 'Hi!', 'Hey', 'Hi', 'hey', 'Hey']\n", + "~~~" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 4\n", + "Given the dictionary\n", + "\n", + "~~~python\n", + "d = {2: 122, 3: 535, 't': 'T', 'rum': 'cola'}\n", + "~~~\n", + "Play around with extracting the values by calling out the keys for all key/value pairs. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 5\n", + "Given the list\n", + "\n", + "~~~python\n", + "n = [23, 73, 12, 84]\n", + "~~~\n", + "\n", + "\n", + "Create a `for` loop that prints:\n", + "\n", + "~~~python\n", + "'23 sqaured is 529'\n", + "'73 sqaured is 5329'\n", + "'12 sqaured is 144'\n", + "'84 sqaured is 7056'\n", + "~~~\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 6\n", + "Use a list comprehension to create a new list with areas of the circles that have diameters defined by\n", + "\n", + "~~~python\n", + "diameters = [10, 12, 16, 20, 25, 32]\n", + "~~~" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 7\n", + "From the following list, create a new list containing only the elements that have exactly five characters. \n", + "~~~python\n", + "phonetic_alphabet = ['Alpha', 'Bravo', 'Charlie', 'Delta', 'Echo', 'Foxtrot']\n", + "~~~" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 8\n", + "Find the intersection of the two sets (elements that occur in both sets)\n", + "~~~python\n", + "s1 = {'HE170B', 'HE210B', 'HE190A', 'HE200A', 'HE210A', 'HE210A'}\n", + "\n", + "s2 = {'HE200A', 'HE210A', 'HE240A', 'HE200A', 'HE210B', 'HE340A'}\n", + "~~~" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 9\n", + "Create a variable `fy` and set it equal to 435.\n", + "\n", + "Given the tuple below, create a list where each value is:\n", + "* The value itself if the value is below `fy`\n", + "* `fy` if the value is larger than `fy`\n", + "\n", + "~~~python\n", + "rebar_stresses = (125, 501, 362, 156, 80, 475, 489)\n", + "~~~" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 10\n", + "Given the tuple below, create a list where each value is:\n", + "* 0 if the value is positive\n", + "* The value itself is the value is negative and larger than -25\n", + "* -25 if the value is lower than -25\n", + "\n", + "~~~python\n", + "T1 = (-18, -27, 2, -21, -15, 5)\n", + "~~~" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# End of exercises\n", + "\n", + "*The cell below is for setting the style of this document. It's not part of the exercises.*" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, "outputs": [ { "data": { @@ -275,7 +1672,7 @@ "" ] }, - "execution_count": 1, + "execution_count": 36, "metadata": {}, "output_type": "execute_result" } @@ -284,1394 +1681,6 @@ "from IPython.display import HTML\n", "HTML(''.format(open('../css/cowi.css').read()))" ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "# 2. Data Structures\n", - "\n", - "Data structures are constructs that can contain one or more variables. They are containers that can store a lot of data into a single entity.\n", - "\n", - "**Python's four basic data structures are**\n", - " * Lists\n", - " * Dictionaries\n", - " * Tuples\n", - " * Sets\n", - "\n", - " \n", - "## Lists \n", - "Lists are defined by square brackets `[]` with elements separated by commas. They can have elements of any data type.\n", - "\n", - "Lists are arguably the most used data structure in Python.\n", - "\n", - "### List syntax \n", - " L = [item_1, item_2, ..., item_n] \n", - "\n", - "\n", - "### Mutability\n", - "Lists are ***mutable***. They can be changed after creation.\n", - "\n", - "### List examples\n", - "Some examples of lists:" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "# List with integers\n", - "a = [10, 20, 30, 40]\n", - "\n", - "# Multiple data types in the same list\n", - "b = [1, True, 'Hi!', 4.3] \n", - "\n", - "# List of lists\n", - "c = [['Nested', 'lists'], ['are', 'possible']] " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Dictionaries\n", - "Dictionaries have key/value pairs which are enclosed in curly brackets`{}`. A value can be fetched by querying the corresponding key. \n", - "This can for some problems be much easier than having two lists that relate to each other by index.\n", - "\n", - "### Dictionary syntax \n", - " \n", - " d = {key1: value1, key2: value2, ..., key_n, value_n} \n", - "\n", - " \n", - "Note that values can be of any data type like floats, strings etc., but they can also be lists or other data structures.\n", - "\n", - "**Keys must be unique within the dictionary**. Otherwise it would be hard to extract the value by calling out a certain key, see the section about indexing and slicing below.\n", - "\n", - "Keys also must be of an immutable type.\n", - " \n", - "### Mutability\n", - "Dictionaries are ***mutable***. They can be changed after creation.\n", - "\n", - "### Dictionary examples\n", - "Some examples of dictionaries:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "# Strings as keys and numbers as values\n", - "d1 = {'axial_force': 319.2, 'moment': 74, 'shear': 23} \n", - "\n", - "# Strings as keys and lists as values\n", - "d2 = {'Point1': [1.3, 51, 10.6], 'Point2': [7.1, 11, 6.7]} \n", - "\n", - "# Keys of different types (int and str, don't do this!)\n", - "d3 = {1: True, 'hej': 23} " - ] - }, - { - "cell_type": "markdown", - "metadata": { - "collapsed": true - }, - "source": [ - "The first two dictionaries above have a certain trend. For `d1` the keys are strings and the values are integers. For `d2` the keys are strings and the values are lists. These are well-structured dictionaries.\n", - "\n", - "However, `d3` has keys that are of mixed types! The first key is an integer and the second is a string. This is totally valid syntax, but not a good idea to do.\n", - "\n", - "As with most stuff in Python the flexibility is very nice, but it can also be confusing to have many different types mixed in the same data structure. To make code more readable, it is often preferred to keep the same trend throughout the dictionary. I.e. all keys are of same type and all values are of the same type as in `d1` and `d2`.\n", - "\n", - "The keys and values can be extracted separately by the methods `dict.keys()` and `dict.values()`:" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "dict_keys(['axial_force', 'moment', 'shear'])" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "d1.keys()" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "dict_values([319.2, 74, 23])" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "d1.values()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "See how to extract values from a dictionary [further down](#Extracting-values-from-dictionaries)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Tuples\n", - "Tuples are very comparable to lists, but they are defined by parentheses `()`. Most notable difference from lists is that tuples are **immutable**.\n", - "\n", - "### Tuple syntax \n", - " t = (item_1, item_2, ..., item_n) \n", - "\n", - "### Mutability\n", - "Tuples are ***immutable***. They cannot be changed after creation.\n", - "\n", - "### Tuple examples" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "# Simple tuple of integers\n", - "t1 = (1, 24, 56) \n", - "\n", - "# Multiple types as tuple elements\n", - "t2 = (1, 1.62, '12', [1, 2 , 3]) \n", - "\n", - "# Tuple of tuples\n", - "points = ((4, 5), (12, 6), (14, 9)) " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Sets\n", - "Sets are defined with curly brackets `{}`. They are **unordered and don't have an index**. See description of indexing further down. Sets also have **unique items**.\n", - "\n", - "### Set syntax\n", - " \n", - " s = {item_1, item_2, ..., item_n} \n", - "\n", - "The primary idea about sets is the ability to perform set operations. These are known from mathematics and can determine the *union*, *intersection*, *difference* etc. of two given sets.\n", - "\n", - "See for example these links for explanations on set operations: https://en.wikipedia.org/wiki/Set_(mathematics)#Basic_operations or https://snakify.org/en/lessons/sets/.\n", - "\n", - "A list, string or tuple can be converted to a set by `set(sequence_to_convert)`. Since sets only have unique items, the set resulting from the operation has same values as the input sequence, but with duplicates removed. This can be a way to find all unique elements. \n", - "\n", - "For example:\n", - "~~~python\n", - "# Convert list to set and back to list again with now only unique elements\n", - "list_uniques = list(set(list_with_duplicates)) \n", - "~~~\n", - "\n", - "### Mutability\n", - "Sets are ***mutable***. They can be changed after creation.\n", - "\n", - "### Set examples" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{1, 3, 6, 7, 8, 21, 26, 32, 86}" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "s1 = {32, 3, 1, 86, 6, 8}\n", - "s2 = {8, 6, 21, 7, 26}\n", - "\n", - "# Find the union of the two sets\n", - "s1.union(s2) " - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{6, 8}" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Find the intersection of the two sets\n", - "s1.intersection(s2) " - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{1, 2, 3, 4, 5}" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "list_with_duplicates = [1, 2, 3, 4, 5, 2, 2, 3, 1]\n", - "\n", - "# Create a set of the list (which removed duplicates)\n", - "s3 = set(list_with_duplicates) \n", - "s3" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "If a `list` is wanted again:" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[1, 2, 3, 4, 5]" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "list(s3)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## The `in` operator\n", - "The `in` operator can be used to check whether a certain item is contained in a sequence. The result of the evaluation is a `boolean` (`True` or `False`): " - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "2 in [1, 2, 3]" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "'ma' in 'Denmark'" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "False" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "'er' in 'Denmark' " - ] - }, - { - "attachments": { - "image.png": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAh4AAACVCAYAAAAXK/N4AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAACmRSURBVHhe7Z0JmBXVlcdvs0izCbaiBBQIIBBUIEQZhgEkZKIGF4hbEIkSshlNjEPmU8IkImRCiDM6aAbFBUISNcQF0aBBYxiIhiAisghhUWSXfVGERra5v/PqPopHA728Lvo1/9/31Vf1qurVcuvee/7nnFvv5R30OCGEEEKIBKgSzYUQQgghyh0JDyGEEEIkhoSHEEIIIRJDwkMIIYQQiSHhIYQQQojEkPAQQgghRGJIeAghhBAiMSQ8hBBCCJEYEh5CCCGESAwJDyGEEEIkhoSHEEIIIRJDwkMIIYQQiSHhIYQQQojEkPAQQgghRGJIeAghhBAiMSQ8hBBCCJEYeQc90XLpWPy4cx8tjz4IIYQQolLS+EupqYyUXXjMGuLctnnRByGEEEJUSlr2d67FDdGH0qNUixBCCCESI6sRj4PdRjtXs4EtCyGEECLH2brQ5c0ellpWxEMIIYQQuYaEhxBCCCESQ8JDCCGEEIkh4SGEEEKIxJDwEEIIIURiSHgIIYQQIjEkPIQQQgiRGBIeQgghhEgMCQ8hhBBCJIaEhxBCCCESQ8JDCCGEEIkh4SGEEEKIxJDwEEIIIURiSHgIIYQQIjEkPIQQQgiRGBIeQgghhEgMCQ8hhBBCJEbeQU+0XDpmDXFu2zxbPNhttHM1G9iyENlkz56q0ZKvZxlVNi8vL1oqmrJW8aTgPnLlWkvL8Z6VEKL8oH/Jzz8QfSomWxe6vNnDUsst+zvX4obUchlQxEPkHBivYMBkyIQQIreQ8BA5RzwqUNkjBEIIUdmQ8BA5jSIeQgiRW0h45DAzZ85y06a97hYvXhqtOZzjbS+K9es32HeYKjJEOiQ6hBAi95DwyGGGD/+F69nzK65fvwHRmkNs377DdenS07ZPmvTHaO3xmTLlz/YdporItm3b3PPPP+/uvfde98tf/tJNnz7dFRYWRltT7HrvPbdm3Di3c9GiaE3uc8Df49Zp09z2v/3NHdi9O1p7JPs/+cRteuklt/7ZZ92BXbuitdlj7+bNbuOLL7rNr7zi9u3YEa1Nnr3bt9s1fPTOO9Ga7LDj7bet7lCHyoPtb77p1owf7/asXx+tqVxwbxsmTYo+ZReeybqnnnLb//53d2DfvmjtycOWqVPd2t/9zhWuXRutOcSTTz5p/SH94jPPPBOtrbhIeOQw119/jc3nzp3vVqxYacuBuNjo2/faaCn32bJli3vFG5ylS5e6WrVquerVqx8R+dj1wQfWQD9ZsiRak4JOa7lvnGFa99vfusI1a6KtFZv9XkRs/vOfTXzsP4bwoCw2/elPbsPEicfcr7Ts9cJv4x//6Lb4a9n/8cfR2hR7t251Kx98MF2+K0eNcrv9sygP7DomT3Y7Zs+O1mSHj+fPd6vGjHF7PvwwWpNddrz1lvvQ18M9GzZEa/y9eAG3+vHH3Zpf/9rtXr06tc7fHwIIIZRL45g+9AaQ+lce7F61yq31bfajOXN8g9gfrU2B4KY+vD9yZHo68Omn0dbKwbY33nBrxo4tUvDn5+dbfzhz5kwTIRUdCY8cpk+fK63CAZGKOK+++prNe/To5po1a2rLcUilZEYKsk2mGMoWderUcZdccon7wQ9+4Lp06eJq1KgRbUmRV7Wqq1q7tsvzoiQOhhtDWLdtW1erWTMzMit/9atyM44ngiq+86lyyimuCvWiHFJRedWq2fEpW5YDRGQQHYXr1ln5MtVu08ZV9c8ql6ji61JelSrldt32bPwzoo4GLErlxfSmKVPcx/NSP02wb+dOE3gmnnNIeFSl/tWsGX3KLvZsfLnZ8WN1+9NNm9w6b2xp36c0aJCuf+UVeTlRVPX3Td0sqnyvueYa6w87d+4cranYSHjkMPXr1zNhAS+++JLNAUERhEiIigBjPUi/VKlSx1IptWqd4Zo3P89NmPBstEfRsC/fGTjwlmhNCr7L+mHDRkRrUucI+7O9oKCxGzJk6BEih/QQ+40ceV+05tjg9WV6fvF18WU69+qnnZYyvjFotDWbN3cNrrzSneUb6llf/arb4w0lIUw6/8oCoqt6/fp2v9mGssW4YJgxBAE8+W1/+5tr4AUh5ct0xmWXmSHIJarVretvsorLP/vsaE12wWhULyg4QhRjVKqdeqr7ZOnSw6IhuUY13+6q1asXfcouJmp8udG2g/BA8G57/XVLvzS49FLX6IYb3JlXXWXTqR072j6VhWq0aX//Nc46K1qTu0h45DhBWMQjGDNnvmVjPICoSODqq/vagNOGDc9yAwb09+q4k0UlEBQlGYB6NBiY2qXLF9MDUxFGXAfiIlO0cI3st3TpsmhNdkB81O3QwbX62c9c/X/6p7QYyQRvvd5FF7m655/vdvnOfr/3MGHrX/7i5l53nU3vfvvbbuv//Z+th3VPPOFW/M//uOUjR9r2+Tfe6NY//bRt27VsmXvvnnvc6jFj3Dy//v2f/9yteewxN79/f7fx+edtH9j08stu/k03pY7/rW+5Lf58AdJDa8eOtfPwvXn9+rnVjzwSbT2Sf/zwh27BN75hYx3iNLn1VvfZH/0oZUSzzClnnuma3XGHO8dfe9zAIHIIAe9cvDhaczgLv/tdt+W1VBQuQGqGsiQ0f2DPHguNv3PttemJ8QJxCLXP9WXCNu79oyg6ECCCNd+XB9vn+fKjPAObXn3VfXD//TbN9cbpna99zS2/995o6yFO697dXTBunImD8qDB5Ze7c4cOdTWbZkQhffnVaNjQHdy711KFmVC2pIBC2cy/+eb0/VPHP/T1kLJkDEnYh/QNY2E+eOABt8JPmXz4zDNWvz7dssU+f3DffenvLhk8OP0s1/r6uPC22+xYAcZPLfmP/3BbYu0Dzh02zDW55fC2ni2IoLXx11jQs2c62kZKausbb7j8Jk1cwRe/aOIkULtly2jJC+N33nHvfu976ftb/9xzVueAerXspz916315LBkyxLYv8vWL6N3B/fvdMn9PpL1YT7smSkobX/3oo25flG5k3EU4NtPGlw45gjwH6t17vk9iG99lnBRsnzXLvZvRNkjzLf+v/7LvhePDWVdf7dr+7/8edo+5ioRHjhPSLYiOYPDjaRZEBiAsgrh46qnxbty4MW7GjKkmDvgu40TKyr333m9Cg+tZvnyh27p1rXvooVG2jagKoifQufNFdn2tWp0brSk7YaxHNe+N12zWzAzvsd58ySPs7T3NT70BxOjtmDnTjFFj36l/7sEH3ek9erjVXjxs9+uBAYF0TnRYbMer2vjCC+7juXNtwCdh8i3TprkzfMdImHzXypWubvv21jHu8R0Tx0HktLz7btfmv//b1W3XzsaZsA4+9Z7uat/B0Wm19Map+V132XHC+QOMS0GY+Jtzrb2xOa1bKuoVqPGZz7gajRt7F/FQOD9bmMflj30KXlcsolL38593jb/+dbfWi4W3r7giLcgCGEfEWRyEx84lS1IhZP8s5vbt6+p16mRle47vjDdPmWIGFQpXr3aLBw1yp/3zP9v2Ft7o1fGGKPDxu++aUbDt3sgivjZ447LuD3+w7RgoRB/GtNV//qeVLaH5TNFW3YspjhtPhWSTU7ygQXRUzYjGQa0WLUzw7PDiIT5+hvpGKgGvnvvm/k/15b18xAi3a/ly24e686G/V4xh0x/8wH3GCzTGBOxescJV9WVL+WRCihHRQRtZ58UF57ay9caX+sw4IcRGvQsvdLt9Xd42fbp9b99HH5lg3u/ntc89vP1yb/m+/pUH1BMrI/+MQrve7/survGU00+37UVBHVv18MOuXseOdn+f8cJz7W9+Y4KXekn5bvX3hqGv87nP2T6MqeL+iahQdggFHBnaMuNwavn7RjSQEmMsFaKP7zHRLyBsEDuAkKDfQCyx/XTfP6z3x/544UJX94ILLHq4KSY8EJ47/bZazZtb9DLAPWaWd64i4ZHjIBz69LnClkO6JQwsjadZ2rRp5Q4c2Ol27dpsn0nFEIUIkZHMVEhpCOIFQbFixSoTQowvCeNQ4ukgxM/UqX9ygwf/KFpTekJUo6joRlHrDsNvP3jggM03+8Z/6he+YB4V4VwiInTGiIZALe9F0flj3PO9uMnznV3wBDnO2QMGWHqBThABggg66EUNnhPHO/vb33b5keE+rWtXM77B4wS83lbDh1vHRrif8wTjAh8++6xb4M9R4EVR61/8wo5TETwgruEcb+wv9J15g698xX3ghdWc3r0tBQPc856NG63Txptc4zt+BlVW950p4flNkye7g94ANPFeKWV/Wpcudo8MJKTj3uC3U9ZnDxzo8hs1ssjLYame2bNddb+OiALPjE4bEfOJFxqhDiCYmt95p6XbQtkWVqC3SzBMGCKMXvzNBYwfAqnBZZeZkOX+G3rPGbFGRM48d3+PlAnlhxAlkkdagjdBKA+ECYLhfS9W8Oo/9c/i082b7XiUf8PrrrOJss8/5xyX7wVE+E7tVq1M6GyeOtWuh/qOgENsmsA90fB8IxG8euxYN+uSS9wM/+wXePFK2XzsBUCe3+f0L33J7u+MSy91ddq2dR8vWJD6rodxN0QUSNVQvojPXV608fYM9YxIWH3fXkl3UDfpB+zNGt/mSem28uXKsZksmuW37Y8NAq3jn8dn//3f7dg1P/tZE/CULf0EDs62v/7VHfTfoWy3z5hhIoNnWB7p0oqAhEcl4KqrUsIDMUHqhMgGxj6eZgEESdu2X7CxFb16fdWNH/9EtCU7IDYg/kou5wmihlRMeRCPaoRljM3xRAdhbTzh6qeeap0LuXW84DneY8FrX+gNKYaLcCfGwPAdQQjzciY7X+w86W2+Y7GoQAwGCpJmme2NI8f/x7/9m8u8wlq+UwopDIzy+Y895hp57zXAGApEyTbv/eJtVSSIEnDNTW67zX3eCyTExtpf/9qEA14wc8bSYNB2ezHFeAbKnY6bsi/005w+faxs3sZrjLzEAzwnL9BO8Z165tiIANsRKaRY+D7hbEtj+WfDNuBZYYzT9SVWbyoKGHlg7JEJYg/zvd5IISCCIUKg4g2baI32Y1wP0Qn24TjUHQQKImyv34/6YukDb+A2v/qq1V8EI6IYYfPWl79sZUca6sMJE9Lth+M19M/lo7fftpSPCRI/L/CGON72TgSMOarmy4FnTNTynG9+03Xy98b4Ld58oe4gshCmC7xo5f6CICZaEiA6WrNJk3T7JVX5OS+ecRyAuk05cK6qpDBj980r5ojp2V4YcvylP/mJ2/X++9HWFHyXupf6EH03Kt8zr7zS2v26J56w/ghxTtoIIVlZkfCoBBDxQGggOvhtD4inWYDIRr9+37B9eL124sTfu0WL5hy2T1nJz095oIwfIZqROd155yDbnm3oIOkAS9IJIjoYDEkHUd97MHgydDJ4ix1feMFd9Npr6anxgAFZiSoQBscwd5w40V3kO8dzhw+PthQfBiA2/f73bUzKivvvd/uiaEtx+cQbfl5Fft/f915fBuUFUR8boImh9M+nznnnWdj/I28ATvuXf7HwMsaAztiMh+/MTznjDNfBG7xOXjCEibQIBqGG74QxFHj/wZiEcTnA8yFM3m78eHtm4fvn3nOPeY/ZYrkXTHO8wNnpz308YVsaEBenduhgIi28NonRozxJd4RXRD9ZtszuH+/6eGkhIm1ERxAOIZW0w9/DQd9eKDfSWIxBIAVBmX3eCz7SBXGIBFK+REwQ50QAgkgqLh97Ab9gwQIrw2xBvSF6gai33/eIyieAwaeuEbE5//HH0/WCqfXPf27bywrjPyjD9r//vbvICzhSqSUdnIz4IP2Co4OQrJ8jb6eUFgmPSkAqupGKeoQoRjzNAkQ7iDywL+M7iIbwuSRRiPi+RFUyv9umTWubI24QPmFibMf06a978XPISJbmV1WPRqbgOJpBwHMkbYLgIN9PjpcQKKFTPO8GvXq5Qt+58zsL7MOEZxQ85rKC8eRKd8yaZb/HwTiItBdUAjDizbyHRR6YvHQ8FXM8lnmD9X0vXAZ4MbXad5bZYs+aNekyY+IHzBiLUuCFHJ44Y26IapDXLrj4YiuLT/7xDws1Y/wQfHTWGEDy6GEKv7OCMcbT3uBFIW8hMfYD7z1gHbV/vh/6zp+xDXyXsTHZ/p2WkSNHuov99f/FG67ygueL8MD7Berm6d4D3jZjhtVZ7o0xBDag0l8LouJ4IL4YL0RdRzAQUSENQdSEZ0DaCRHLsRkwWtQPszXq399EB8+NNGJJ+Yf/Xu/evd13vvOdrKR2ASFO6qSGrzsbnn8+XT7UDaJjoW5RhtRJtoWJMs6GeDTx5/sg2iHpWtp2SfuMhtdfb9FABq7yTBHhlZmq93ii5dKx1jfAwsgANb3cS/ZDg2FEcuzdu88991zqvXXExWOPjbZ5AJHw5JN/cPvIPe7f7z2PRW7QoMHpMR69e1/hOnRoZ+M0Xnhhsq0bOnSIzd98c7abPXuOe++95W7evAVeRLzhfvzju9PfDQKDNsw1kHJZuXKV27Ztu0VgRo9+xB/jLTsev8EB3btf4h54YLR54Jz7eOzblxIX/HLpbO8pN27c2J3nO2ig0afDwpEIYR6mAIYPL5EQPwYJT7DRjTdaFALoQOigd3jPkH3s1UbfgdU85xzzOOmY8Rjree8P6LgJW9f2niDpEdIxp7ZvnxoQ5q+nfqdOdl3mlflrxXNnnMNO3wEXrlplg9XI+ZLL5RrwcMkR48HRUR6GN6oMOMRAMMCMQXZ0uuTwq1SrZiP+i8Mp3khRfq/5DrJfv37uM/542YA0B2IulBu/rcDrjbxSywBerhVRh9FjrAIhbcqLsqzdurWlURAXDNgLx2Ci3HkupG0oVxvz4Z8Jz66e92IRK4SpST1QvgwE5I0LvkuEgPPymy2kGYis2PMheuXbAOXN9XD84rLJ39csf41neuHUo0ePw+pXaaEOke+v48uBe6COMWART506hGhjG/WNSAX3xjYGQdeMPGsbLxDtXxSMp+H+iWRQJhyLcxEJ4PVM6h1RA/vdkL177Tg1GOvg662Vl4dxHwxyZeyMpTJKSG3//F566SW3yD+fr3/96+5Ufx3ZgCgRbQahxptNlA+CHjFK26JN84wZ/B3qBlO+rzPUH6KfGH2cEOpRJkTXaHO2r39WRH4Qa1affJ1lnAwRD+oeUT3qG+NfrF77+mvpXH8N1FcIvzzMNaejcb6fsPFIn35qg7QR66Xhb17041D07ds3WnMk1aqVUGzt3uTy1qUGFruCdn66ILVcBvJ8x1g2yTfLG6dt0Wtd3Ub73ju33tuvLOBBFBScbfPLLvuye/nlQ69wAusbNWqRFgvA67REIYg6EAEh/ULEJLz6ymBUQLR07NjlsAgH50CksA5BEUTKoEF3uVGjfD2IwQBYBpPynQC/8UFkhLQMEZjjUViYCs6RInj44YddJ9/5Xe+9hAAGIBvey4kkiXvY6j2xn/zkJ5Yu+N3vfufOTXiUfDYM9Ylk/PjxDl+Nn6a+7rrrcv5+SgKRJt4cavvggyZISsrmzZtNcNAX8bcH9UtpXCsjDNZdNnSoiXUGUJcW6uWMGTPcpKP8eBr9S35+akxQsdm60OXNHpZabtnfuRY3pJbLgIRHJQIhgLBo1qxJkb9WisB49NGxtk/37l1trAfRCcQD4zMQIiyH9AdRjADfIUIBrVu3stQO5yss3HPE+UijvPJK6vWwet57Q1wgPuKwD99ljAlv3ByPuPAg3P2R9/A+5z2Pbt26ua5du1p0h6ocjHfcIJS1iidFeQuPhQsXmuFct26du8p7vlcyqC3yZpMiVw01kY4pU6aYWGvXrp376U9/anX7ZMDSK94wbpk+3d76aHjN4Wnc4vD666+bMWR8x/e+9z375WGReg2ct1iIshJtOYe33qIoVkkYO3asW7VqlXvzzTetL5TwECILBOGB4HjrrbfcypWpn2PHCLRv3/6w/2yhSkt4HMkHH3xg3lDTpk1dx44dExcdkKvCg8gg/4NBxOhS75WeHkLkJwGMcyJtFVI1pWHevHlu/vz53mlp7S688EJXJQuDOisDjAvhtV5SX7xeT+q1NEyePNlt2LDB2hdpaOpoUdC/SHgIUUyC8CiKYLCLmkNZq3hShOuuzIRnIoRIHvqXiiA8JDtFpSAYtMy5EEKIioWEh8h5UPFhEkIIUbGR8BBCCCFEYmiMhxBCCCGKRmM8hBBCCJHLSHgIIYQQIjEkPIQQQgiRGBIeQgghhEgMCQ8hhBBCJIaEhxBCCCESQ8JDCCGEEIkh4SGEEEKIxJDwyHHGj3/CValSx6Zp016P1paN+DHF0Vm/foMbMmSo69Klp2vbtqO79dY7svYMxOGMGfO469nzK1bmongsXrzUXX31DVY3mVhW/SwdU6b82epfo0YtrL0PGnSX6mIZkPAQohQUFhZaRz5y5H1u5sxZ1sljHHv1+qqbO3d+tJfIBpTnoEGDzWhS7uL4rFix0nXs2MVNmvRHq5tMLGM8cSxE8Rk1arS1a+ofYoP2zjoEyPbtO6K9REmQ8BCiFIwZM9Y6oPz8fHf//b90Tz013rVp08oMI96QKBt06JQjnTsGVIKjZBCJo8yokzNmTHVz5sxwHTq0S28TxYN6GMprxIhh7sCBnW7ixN/bZ8QdYk6UHAmPSgheOJ4NHTcqnc6btAkdOCHDOMFQsq2goLF58UdT8cFjqlXrjHRqIb7vsGEjbDtTCEPirYZ1RAQCeAzsn6sN98UXJ9u8b99r3R133GZzBAjMnPmWDGUZ2b59u9URxJ0oOUQ44Pbbb3WdO3cy0cEy0DYxmuL4UA9DW6adQ58+V6ZF3MqVq2wuSoaERyVk6dJlJjgmTZpsIcLQeSMCQsgwgNCgg2cbIgIhMHz4iGjrIQjPhhwxDTGkFhAgQWTcfPONZnTZJ3j9AwfeYp/Zv2/f62wdPPjgQyY8XnzxpWhNbhHKsF27C2wOzZo1tTnlo3RL2aAs8S6Zpk79U7RWFJebbrrRDR06xERH4GgOhTg68XpIdBMQbUG4tW9/qP2L4iPhUYmhcRAe3LVrs4VaQ8N5+unnbI7ICBGQAQP6u3Xr3nfjxo3xhnOPrQtgSEO4EbW/fPlCC9/SKBEdQWTw+e67f2zLEyY8a8IiGGCOW79+PVuuTMTvKT+/RrREmR1ehkIkCd45wiN45oiORx8da8ukX4JIFsWHvozocfPm51l50mfSH4qSI+FRiaGDoQNCcNABde58ka0PocN4tIE0QcOGZ1ljuuyyL0drUxDFCFENhAWdFp4UEQ4gshLgfKGzQ3hAUcdEvOBFIEiEEOUHRpJUJ1FHhPLEiROiLaIkUI7x1B99YuhLRcmQ8KjEICSORRATCIW45969e9doKUU8H8xYkPCqbRAWNL6wDyInLia4hjD2QQiRLBhK2izeOg4DkU8cElFyevTo5hYtmuMeemiU9XNEi4cP/0W0VZQECY+TmJKmPmhshG+LmurXrx/tlXrnPYC4Wbx4SfSp8hDSVkG8QTy9Ek+7CHEiYFxWz569zCkgJYDoUIqlZNC+Gc8VIh2Itltu+ZafvmmfMwfri+Ih4XES07p1yvPBG4pHNcIbG4GQOiGy0bv3FWmx8d3vftNdfHE3m4KIIZwbvIBgnBlgWtlCkng/MH/+AptDGM/CfYcyE+JEgLEM7W7w4B/ZK6AldTREqj8jTcXYjjisF6VHwuMkBuEQxAFvrDAgNLyCGweVH9I2bGc/lD5vyNAoeUMlEDo79g8DWuNiJMAALdI17J+LXH/9NTanLBh4S9opDMBlLE0oVyFOBPE2SXsOr7SHKR6pE0cHByK05X79BlhfFvo/iL81JIqPhMdJDOIgvIWCt07D4tXazHAsDY9xG8zpxNgv/EInDTOM6Qi/4gm8TZMKS6ZCkvFtlYH4iHbuDeFB1AivUgNmxYlm2rS/RkupcR602/hU2SKQ5QXtmb4MEBz8fAD9H9C/hW2iZFS9xxMtl461f3GuMFLPTS93rnrt1LJIDAQEoX8mxlocPHjQN4rWlgKJh/z9avt88cVdbTt07drFNW3axOXl5ZngGDLkTvfDH9522DGhZcsW7ppr+rj9+/e7OnVq2763336be/jhB/zn1H+6vPHG3+14l176r+77309FMriGatWq2XGYn39+W1vPteAtxK8l1yDt1LhxI1e3bh139tmN3cCBN7tf/eo+5dHLAep1qj52VzTpOCAq9u3bn26/RU8qx+KS6qe6uR07PrJ+MfR9jz02Ot33VWp2b3J566anlgu8PSko+2+X5Hkj5U1AGZg1xLlt82zxYLfRztVsYMtCCCGEyHG2LnR5s6PITsv+zrW4IbVcBpRqEUIIIURiSHgIIYQQIjEkPIQQQgiRGBIeQgghhEgMCQ8hhBBCJIaEhxBCCCESQ8JDCCGEEIkh4SGEEEKIxJDwEEIIIURiSHgIIYQQIjEkPIQQQgiRGBIeQgghhEgMCQ8hhBBCJEaFEx7bt+9w06a9btP69dHf7cdYvHipbZs5c1a0pmIxd+58uz6uMwkoo1BelF02iB9TCCGEyCYVTnhguHv2/IpNV1995N/v3nvv/batX79vRGtODHGBFDf4gwbdZdfHdSbBlCl/TpcXZZcN4scUxaNjxy6uSpU6NkmwZQcE8MCBt7hatc5Ily2fsyWwKzs4Z23bdkyXXUFBYzds2AhXWFgY7SFKC7aJMl2xYmW0RpSECp1qoeGMH/9E9KliERdI2TL4IjehjqoOZBeMI20rtP82bVrZnM9XX93XlsXRQbT17NkrHXlt2PAsE2wIj1tvvcPWidIxatRoN2nSH6NPojRU+DEeQ4YMLZFCL06Kg0ZZnGOyT0m916lT/+QOHNjpxo0bE60pOVxftr264hjG4qp3qfxD8Jyoo/Xr14vWiGwwadJka8sYzK1b17hFi+a4hx4aZdtok6qDx4aIK/1Xhw7t3PLlC20aMKC/bUO80ceI4hMcTaJvRLVF2ajQwiM/P98aCB37saCBoeIJfYXQIqGwzMZFZ0VIvFGjFukKhAfA/vG0ApEW9mMf1rO9efPz0iKEVES88rEcPLOwPyFh6NXrq0ccH9jOeq43MGHCs3ZtTIRFOSfnKinh2JwTdc59hPvhfuNQRuEaOR/Xs3Llqmjr4YwceV/6uti/S5eeh421CedlCkIHzyCsi5+7X78Bdn0cM5cZPnyEleGIEcOiNSIbLFmSciCIdNAPwGWXfdnmoHTLsQkOGGXWrFlTK8PvfGegrYOkxqBVNjp3vigdfROlp0ILj7vv/rE1mDFjxh6zoTDeY8yYx20ZDwkweBjb0EEhTjCUcc8fo/zAA6OjTynYD9HCfhwLLwGvAdGCgS6pp3D99dfYPHMsSAjVfe1r19qczxhjjs89M4Vzljasxz0gikKZcG8YfwRO+EyZxMUN5ZwpTgDxx8Q9BO8e0UE4N5Qpxjeca/jwX9jxmQNleNddg2wZZs58y8pk6dJl0Zrcg/umDvXte+1hRlGUnaFDh1jkkAhi4NFHx9mcOkZ9EkeHtkjZxcVGvO/Kz68RLYniQH2jPJnuvPNQPyZKR4UWHnQwGCsM2NHCW3T+wTATil237n0LK2K4aWh4pIB44TNGc+LE31undv/9vzzCc+J4oYFSyUiZhM6P68DYYmT4boDlEMbMBKPEtUAw8BwjnPfmm2+0eTDQffpcaaFlJpZh0KDBNi8pnOPll5+38ti1a3NaFPz1r2/YHAESQtbcA2UyZ86M9PUGKA8MLNxyy7f8ta21qXPnTlYmISLF8UO58EyCgON4lGP8uHgOPXp0c61anRutyT2IslGf4nVBZB+cCiJmITpGnRbHBkNJ+yLaAfQFoY/BY5dwEyeSCj/GA+GBQcNoF+X5B2OOUWvTpnWU/12VblghPfLqq6/ZHGMeDPodd9x2RNgMY4oBxlBjcDlnSJtAplA5HlxXnz5X2HK4hldeSc05Fx0D5wlRg+7du1o0gKl9+wtsHeKgNKFRjh888VT5pO4VsQBBgLDtllu+acuUW7jeAOcO3+H6KFOuNxyPZxC2x73/8Gx4hpkd3VNPjTdBN3jwj6I1FROMHSmh+ASk1hCQ8SiPKDmUY2b5hrYQKCzcEy2lePDBh6IlgUMWLzuippnQv4Rypa7S9uJOgDjE0dq7yC4VXnjQQMKgMjz/YOACGzdutDnr45UljD0IBjvMMZxxggiJQ2fIOAaOg9de2lRH4KqrUoY8GOIgPK666nKbhwgLxDuSeMojvk9xOV44NUQ7EAXxjiizjMJ+EMZmMIVxLRC/vngEAGEVT7HkGqSCEFrxCYjyUGYbNmy05xQ3hr/97ZPp/cSxYTxRZvlminscBByBMGCbelfWNllZQEzEyw6HJQ7rGLfFfrTzGTOmHuEEiEMcrb2L7FLhhQcgDggbYgAZ7R4nGEy875CDi08hLBuMcKZwiRtVQKAQ4cCQ4r2TliF9UxaIIBCS55hU5CCKQnombvRDaidzKo/OInjqmaIGYxonfn1FXRtT3OuPG+GinlkuQSqIuhefgDKjLiE6mEIqCjCM06erwyoOTZs2OaJ8aSu0Q9pKcBiog7SXEGUL0bqTHfqFeNmRwgxQJ3EQEHKUHaIjpF5E0RytvYvskhPCA4IXnSkc2rUL6YhV1imFyrJ9+3br/BcvXmLbg2F8+unnbB4IUYjAH/6QGnhJAyUkiegJQqG00GmGyMqtt/7Q5lxjuCauOxh3OolwD2znHpgy7zsbhMgG4iAuwF544XChEDr7QLg+xBzXRvmE68dYhIG+oZMjipMpbvhO3LBUVEgFZYosYPBjfMIrD9DJX3yxOqziQFllli/GlKgRRjO0F6Bt0M7hzDPPtPnJDv1ivOzos4C2FcbFUTczx1iJojlaexfZJWeEB51RvHMPBAONYeYNEIweYXDedImnKm6//Vab0yCJaIR0SmZY96yzUh0ahhiPgWMU9YM78TQGRjQzcpJJeLslGNrwOUB0BXj/nvNxH/xQEucnNROPKGQLOv1wXN5uodzCgNA4CI8QcaHsgofPvizH011hPAz7T536sh0f0ZE5OJjng2FJ6hdes02m8Aj1C2666Uarl6L0BFEc2isOAu0hCHC9RXRsEG4B2mp4pT1MlKsQJ4qcER7Aa0yZBpjPjAEhPIvBxGgzQIgOioF/vIUBRByCcUd0hHRKpoGIj/nAWGJYMaLhvC+++JLNGbgZjDEG+ze/OdTQi4LzcI2B+HkAz4XjcU2IDu4DkcJ5ymsUPx5Q8IQ4L+VG7pxzxmE7nhRlgMCiTEIUg/sIv2HBGJwgwLgfIh7h1TPeoAmv8QpxPBAWYeAx7RWnIhjL0FbE0cl0HoSoSOQd9ETLpWPWEOe2zbPFg91GO1ezgS2XFiIQodHgaWcKDYwxBo+IQ9xAsu6RR8ZGn1KvqRaVz8Swzpu3wJZ7977CfhsAQ09HFww81zBhwjM21qF161YmWLgm1sfPyzk5HvsRWkdchP247swURVHHyIRrCWMseKslU6BkwjWEKAqdcciPs57leAd9tGtj/5BiuvTSf7VyC8eMCzPEHK8l79iRihKFew4EwxC/P74TBrzFr4coEW8rFFVOuUj8PsNzEGWHOhtP/fG7N5WhvpQ3x4toqI6Wnnify5iaSp/C2rrQ5c2OfiCxZX/nWhz5H2olpcIJj/KCqATGDkMXvHyMBb8SijEmjRPGkQghhBDCUw7CI6dSLWWhU6cLzQsg3N+27RdsfEFBwdnpCIB+jU4IIYQof04a4UHKgldjSakQKkOEEG4k0sGvdSI+hBBCCFG+nDSpFiGEEEKUEKVahBBCCJHLSHgIIYQQIjEkPIQQQgiRGBIeQgghhEgMCQ8hhBBCJIaEhxBCCCESQ8JDCCGEEIkh4SGEEEKIxJDwEEIIIURiSHgIIYQQIjEkPIQQQgiRGBIeQgghhEgMCQ8hhBBCJEZ2/522SS/nqte2ZSGEEELkOLs3ubx101LLWfp32qwKDyGEEEJUUiqW8Hg3+iCEEEKISklLLzoqhPBY+xfnCjdGH4QQQghRKTntfOcKLog+lJ6yCw8hhBBCiGKit1qEEEIIkRgSHkIIIYRIDAkPIYQQQiSGhIcQQgghEkPCQwghhBCJIeEhhBBCiMSQ8BBCCCFEYkh4CCGEECIxJDyEEEIIkRgSHkIIIYRIDAkPIYQQQiSGhIcQQgghEkPCQwghhBCJIeEhhBBCiMSQ8BBCCCFEYkh4CCGEECIhnPt/oMQeSrt5v8oAAAAASUVORK5CYII=" - } - }, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Indexing \n", - "When elements are put into a sequences (strings, lists, tuples etc.), the individual elements gets an index assgined to them. This enables each element to be extracted. \n", - " \n", - "> **Indexing in Python** starts from `0`, while the negative index starts from `-1`.\n", - "\n", - "![image.png](attachment:image.png)\n", - "\n", - "### Use square brackets `[]`\n", - "To extract an element by indexing, use sqaure brackets `[]`. This is the general way and works for all sequences. Strings, lists and tuples are all sequences." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'a'" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "example_list = ['a', 'b', 'c', 'd']\n", - "\n", - "# Extract first element\n", - "example_list[0]" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'c'" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Extract second to last element\n", - "example_list[-2]" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "40" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "example_tuple = (10, 20, 30, 40)\n", - "\n", - "# Extract fourth element\n", - "example_tuple[3]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### `IndexError`\n", - "When trying to refer to an index that is **not** present in the data structure, an `IndexError` is raised:" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "ename": "IndexError", - "evalue": "tuple index out of range", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mIndexError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mexample_tuple\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[1;31mIndexError\u001b[0m: tuple index out of range" - ] - } - ], - "source": [ - "example_tuple[10]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Remember this error. You will get it a lot!" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Extracting values from dictionaries\n", - "Dictionaries differ from data structures like strings, lists and tuples since **they do not have an index**. Instead, a value is extracted by indexing the corresponding key:" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "154" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "d = {'N': 83, 'My': 154, 'Mz': 317}\n", - "d['My']" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that this means that **keys in a dictionary must be unique!**\n", - "\n", - "See demonstation below, where the key `'a'` is defined twice. The second defintion overwrites the first one." - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'a': 4, 'b': 2, 'c': 3}" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "{'a': 1, 'b': 2, 'c':3, 'a': 4}" - ] - }, - { - "attachments": { - "image.png": { - "image/png": "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" - } - }, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Slicing\n", - "Slicing is the operation of extracting multiple elements at once by calling out the index range. An example for slicing of a list is shown below: \n", - "![image.png](attachment:image.png)\n", - "\n", - "> **When slicing**, the stop point of the slice is not included.\n", - "\n", - "Examples is this section are shown for lists, but the same concept works for strings and tuples. Set objects do not support indexing/slicing since they are unordered, and dictionaries cannot be sliced either as they have the key functionality instead.\n", - "\n", - "### Common slicing operations \n", - "Suppose a list `n` has been defined along with two integers `n` and `n`:\n", - "\n", - "\n", - "```python\n", - "n = [3, 25, 83, 31, 14, 47, 1, 23, 57]\n", - "start = 2\n", - "stop = 6\n", - "```\n", - "\n", - "\n", - "The list `n` can then be sliced as:\n", - "\n", - "```python\n", - "# Elements from start to stop-1\n", - "n[start:stop] -> [83, 31, 14, 47]\n", - "\n", - "# Elements from start to the end of the list\n", - "n[start:] -> [83, 31, 14, 47, 1, 23, 57]\n", - "\n", - "# Elements from the beginning to stop-1\n", - "n[:stop] -> [3, 25, 83, 31, 14, 47]\n", - "\n", - "# Copy of the whole list (alternative: list.copy())\n", - "n[:] -> [3, 25, 83, 31, 14, 47, 1, 23, 57] \n", - "```\n", - "The same concept works for other sequence like strings and tuples.\n", - "\n", - "\n", - "As seen, the last one creates a copy. This can be useful when working with mutable objects. For example for copying a list to mutate the copy while keeping the original list unchanged.\n", - "\n", - "There is also a step mechanism. Continuing from above:\n", - "\n", - "~~~python\n", - "step = 2\n", - "\n", - "# Extract from start to stop-1, by step\n", - "n[start:stop:step] -> [83, 14]\n", - "~~~" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## List methods\n", - "Lists have many methods for performing common manipulations. Methods are recognized by the 'dot'-notation, so if a method was called `method_name()`, it would be used like `list.method_name()`.\n", - "\n", - "Suppose a list called `L` has been defined. Some of the most common list methods are:\n", - "\n", - "~~~python\n", - "# Insert val at the end of L\n", - "L.append(val) \n", - "\n", - "# Remove i'th element from L and return it (if i is not provided, it defaults to last element)\n", - "L.pop([i]) \n", - "\n", - "# Reverse all elements in list\n", - "L.reverse() \n", - "~~~\n", - "Note that these all mutate the list `L` in-place.\n", - "\n", - "The `len()` function which was used for strings in Session 1 also works for lists, dictionaries, tuples and sets. This is a function since it does not use 'dot'-notation. \n", - "\n", - "Many websites have explanations about string manipulations. This is from the Python documentation itself: https://docs.python.org/3/tutorial/datastructures.html#data-structures\n", - "\n", - "**Note:** Methods also exist for common operations on dictionaires, tuples and sets and many other objects. " - ] - }, - { - "cell_type": "markdown", - "metadata": { - "collapsed": true - }, - "source": [ - "## Copying mutable objects\n", - "When copying objects that are mutable like, lists or dictionaries, there are some things to be aware of. This is demonstrated by a list example below." - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[1, 2, 3]" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "x = [1, 2, 3] \n", - "y = x # <-- This does not make y a copy of x \n", - "y # It makes y a pointer to the same underlying object (or id) as x has" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "1946077813640" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "id(x) # Behind the scenes, the variable x gets assigned a unique object id" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "1946077813640" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "id(y) # y is seen to have the same underlying object id" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This means that when we mutate (or modify) `y`, the original list `x` gets changed as well, which is often not desired. This is because it's a pointer to the same object as y." - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": { - "code_folding": [] - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[1, 2, 3, 89]" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Put 89 at the end of y\n", - "y.append(89)\n", - "y" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[1, 2, 3, 89]" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# x also got 89 appended to it\n", - "x" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This is often not the intention!\n", - "\n", - "> **When copying** a mutable object `K` use `K.copy()` or `K[:]`.\n", - "\n", - "An example is shown below by using the `list.copy()`method:" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[1, 2, 3]" - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Redefining x since it was mutated above\n", - "x_new = [1, 2, 3] \n", - "\n", - "# Copy to new list\n", - "y_new = x_new.copy()\n", - "\n", - "# Show list\n", - "y_new" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[1, 2, 3, 327]" - ] - }, - "execution_count": 26, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Append a value to y_new \n", - "y_new.append(327)\n", - "\n", - "# Show list\n", - "y_new" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[1, 2, 3]" - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# x has not changed\n", - "x_new" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "x_new has object id: 1946078486344 \n", - "y_new has object id: 1946078485960\n" - ] - } - ], - "source": [ - "# Print object id's as f-string \n", - "print(f'x_new has object id: {id(x_new)} \\ny_new has object id: {id(y_new)}')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## `for` loops\n", - "The general syntax in a `for` loop is\n", - " \n", - "### Syntax of `for`-loops\n", - " \n", - "~~~python\n", - " for item in iterable:\n", - " # Code goes here (must be indented!)\n", - "~~~\n", - "\n", - "\n", - "\n", - "\n", - "Recall that an `iterable` is a fancy word for something that can be iterated over. Like strings, lists, tuples etc.\n", - "\n", - "So, printing numbers from 0-5 can be done like this:" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0\n", - "1\n", - "2\n", - "3\n", - "4\n", - "5\n" - ] - } - ], - "source": [ - "# Printing numbers from 0-5\n", - "for i in [0, 1, 2, 3, 4, 5]:\n", - " print(i)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "> **Remember:** All code inside a `for`-block must be indented!\n", - "\n", - "A common way of quickly generating the numbers from 0-5 instead of typing the list `[0, 1, 2, 3, 4, 5]` is by the `range()` function, which has two forms:\n", - "\n", - "~~~python\n", - " range(stop) # Generates numbers from 0 to stop-1\n", - "~~~\n", - "\n", - "~~~python\n", - " range(start, stop[, step]) # Generates numbers from start to stop-1 (step is optional) \n", - "~~~" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0\n", - "1\n", - "4\n", - "9\n", - "16\n", - "25\n" - ] - } - ], - "source": [ - "# Printing numbers from 0-5\n", - "for i in range(6):\n", - " print(i**2)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Here is an example where each element of a list of strings is accessed in turn and named `string`." - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "superman\n", - "spiderman\n", - "green lantern\n" - ] - } - ], - "source": [ - "strings = ['batman', 'superman', 'spiderman', 'ironman', 'green lantern']\n", - "h = []\n", - "for string in strings: # This would be like saying: for each string in the list strings\n", - " if len(string) > 7: # If the current string has more than seven characters \n", - " print(string) # Print it" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## `while` loops\n", - "A `while` loop is a loop that continues until some condition is no longer satisfied.\n", - " \n", - "### Syntax of `while`-loops \n", - "~~~python\n", - " while condition: \n", - " # Code goes here (must be indented!)\n", - "~~~\n", - "\n", - "Where evaluation of `condition` must return a boolean (`True` or `False`).\n", - "\n", - "\n", - "\n", - "There must be some kind of change in `condition` for every loop. If there isn't, the loop becomes an **infinite loop** and runs forever (or until you stop it). \n", - "\n", - "**An example of an infinite loop is**\n", - "\n", - "~~~~python\n", - "counter = 0\n", - "while counter < 3: \n", - " print(counter) # The variable counter is never updated. 0 < 3 is always True => prints forever\n", - "~~~~\n", - "\n", - "**The counter should be updated within the loop**, e.g. like this:" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The count is 1\n", - "The count is 2\n", - "The count is 3\n", - "The count is 4\n" - ] - } - ], - "source": [ - "counter = 1\n", - "while counter < 5: \n", - " print(f'The count is {counter}')\n", - " counter += 1 # Update counter (equivalent to: counter=counter+1)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "collapsed": true - }, - "source": [ - "\n", - " > **Remember:** All code inside a `while`-block must be indented!\n", - "\n", - "A `while`-loop can be good when the number of iterations are unknown beforehand. This could be when searching for a root of an equation (e.g finding the neutral axis of a reinforced concrete section).\n", - "\n", - "When iterating, convergence is not always guaranteed. A common way of exiting the `while`-loop is to define a max number of iterations and then check in each loop whether this number has been reached. If it has, then the loop should `break`.\n", - "\n", - "A similar logic to `while`-loops could be done with by `for`-loops, but a `while`-loop is cleaner for some purposes and can help to clarify the intent of the code." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## List comprehensions\n", - "List comprehensions are other ways of writing `for`-loops. They can be done in one line and are often cleaner and more readable for simple iteration.\n", - "\n", - "### General form of list comprehensions\n", - "The general form of the simplest list comprehension is\n", - "~~~~python\n", - " result_list = [expression for item in iterable]\n", - "~~~~\n", - "\n", - "\n", - "* iterable is a sequence that can be iterated over, this could be a list, a string, a tuple etc. \n", - "* item is the counter for the iterable, think of this as the i'th element \n", - "* expression can be anything, but will often include the item\n", - "\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "A basic example for multiplying all elements by 2:" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[24, 430, 62, 874, 102]" - ] - }, - "execution_count": 33, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Define a list (iterable)\n", - "L1 = [12, 215, 31, 437, 51]\n", - "\n", - "# List comprehension to multiply each element of L1 by 2\n", - "L2 = [2*i for i in L1] \n", - "L2" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that `2 * L1` will not create the same output, but instead repeat the list as seen below." - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[12, 215, 31, 437, 51, 12, 215, 31, 437, 51]" - ] - }, - "execution_count": 34, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "2 * L1" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To get a vectorized behavior like that we could have use `numpy`, which is a third party library for numerical compuations similar to Matlab. Later sessions will explore `numpy` further." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### List comprehension with `if`-statement \n", - "The general form of a list comprehension with a conditional is\n", - "~~~~python\n", - " result_list = [expression for item in iterable if condition]\n", - "~~~~\n", - " * `iterable` is a sequence that can be iterated over, this could be a list, a string, a tuple etc. \n", - " * `condition` is a logical condition, e.g. `item > 3`, which returns a boolean (`True`/`False`). This can act as as filter.\n", - " * `result_list` is a new list containing `expression` for each `item` that fulfilled the `condition`\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "An example where a list is filtered:" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[4, 5]" - ] - }, - "execution_count": 35, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Define a list (iterable)\n", - "x = [1, 2, 3, 4, 5] \n", - "\n", - "# Filter list with list comprehension by use of condition\n", - "result_list = [i for i in x if i > 3]\n", - "result_list" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### List comprehension with `if`-statement\n", - " \n", - "~~~~python\n", - " result_list = [expression1 if condition else expression2 for item in iterable]\n", - "~~~~\n", - "\n", - "* `iterable` is a sequence that can be iterated over, this could be a list, a string, a tuple etc. \n", - "\n", - "* `condition` is a logical condition, e.g. `item > 3`, which returns a boolean (`True`/`False`). This can act as as filter.\n", - "\n", - "* `result_list` is a new list containing elements where each `item` depends on `condition`. If it is `True`, `expression1` is put in. Else `expression2` is put in. \n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The added `else` allows us to retain the elements for which `condition` returns `False`:" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[0, 0, 182, 0, 151, 174]" - ] - }, - "execution_count": 36, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Define a list (iterable)\n", - "v = [3, 62, 182, 26, 151, 174]\n", - "\n", - "# Set all elements of v that are less than 100 equal to 0\n", - "w = [0 if i < 100 else i for i in v]\n", - "w" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "collapsed": true - }, - "source": [ - "### Benefits of list comprehensions\n", - "List comprehensions can be done in one line and are often cleaner and more readable for simple iteration. \n", - "They are also generally computationally faster than regular `for`-loops and also faster to type." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 1\n", - "Extract the last and first element from the list\n", - "~~~python\n", - "L1 = [10, 20, 30, 40, 50, 60]\n", - "~~~" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 2\n", - "Extract the following list from `L1` defined above by use of slicing.\n", - "\n", - "~~~python\n", - "[20, 30, 40]\n", - "~~~" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 3\n", - "Create a list of the unique values from the following list:\n", - "\n", - "~~~python\n", - "L2 = ['Hi', 'Hello', 'Hi!', 'Hey', 'Hi', 'hey', 'Hey']\n", - "~~~" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 4\n", - "Given the dictionary\n", - "\n", - "~~~python\n", - "d = {2: 122, 3: 535, 't': 'T', 'rum': 'cola'}\n", - "~~~\n", - "Play around with extracting the values by calling out the keys for all key/value pairs. " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 5\n", - "Given the list\n", - "\n", - "~~~python\n", - "n = [23, 73, 12, 84]\n", - "~~~\n", - "\n", - "\n", - "Create a `for` loop that prints:\n", - "\n", - "~~~python\n", - "'23 sqaured is 529'\n", - "'73 sqaured is 5329'\n", - "'12 sqaured is 144'\n", - "'84 sqaured is 7056'\n", - "~~~\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 6\n", - "Use a list comprehension to create a new list with areas of the circles that have diameters defined by\n", - "\n", - "~~~python\n", - "diameters = [10, 12, 16, 20, 25, 32]\n", - "~~~" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 7\n", - "From the following list, create a new list containing only the elements that have exactly five characters. \n", - "~~~python\n", - "phonetic_alphabet = ['Alpha', 'Bravo', 'Charlie', 'Delta', 'Echo', 'Foxtrot']\n", - "~~~" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 8\n", - "Find the intersection of the two sets (elements that occur in both sets)\n", - "~~~python\n", - "s1 = {'HE170B', 'HE210B', 'HE190A', 'HE200A', 'HE210A', 'HE210A'}\n", - "\n", - "s2 = {'HE200A', 'HE210A', 'HE240A', 'HE200A', 'HE210B', 'HE340A'}\n", - "~~~" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 9\n", - "Create a variable `fy` and set it equal to 435.\n", - "\n", - "Given the tuple below, create a list where each value is:\n", - "* The value itself if the value is below `fy`\n", - "* `fy` if the value is larger than `fy`\n", - "\n", - "~~~python\n", - "rebar_stresses = (125, 501, 362, 156, 80, 475, 489)\n", - "~~~" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 10\n", - "Given the tuple below, create a list where each value is:\n", - "* 0 if the value is positive\n", - "* The value itself is the value is negative and larger than -25\n", - "* -25 if the value is lower than -25\n", - "\n", - "~~~python\n", - "T1 = (-18, -27, 2, -21, -15, 5)\n", - "~~~" - ] } ], "metadata": { @@ -1691,7 +1700,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.1" + "version": "3.7.4" }, "latex_envs": { "LaTeX_envs_menu_present": true, diff --git a/Session 2 - Data Structures/Session 2 - Exercise solutions.ipynb b/Session 2 - Data Structures/Session 2 - Exercise solutions.ipynb index 1fe43b5..ff982ff 100644 --- a/Session 2 - Data Structures/Session 2 - Exercise solutions.ipynb +++ b/Session 2 - Data Structures/Session 2 - Exercise solutions.ipynb @@ -1,9 +1,367 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 2. Exercise solutions\n", + "There are often many ways to do the same thing, so these are just one way of solving the problems. \n", + "\n", + "# Exercise 1" + ] + }, { "cell_type": "code", "execution_count": 1, "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "First element of L1 is 10 and last elements of L1 is 60\n" + ] + } + ], + "source": [ + "L1 = [10, 20, 30, 40, 50, 60]\n", + "first_elem = L1[0]\n", + "last_elem = L1[-1]\n", + "print(f'First element of L1 is {first_elem} and last elements of L1 is {last_elem}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[20, 30, 40]\n" + ] + } + ], + "source": [ + "L1_sliced = L1[1:4]\n", + "print(L1_sliced)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 3" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Hi!', 'Hello', 'hey', 'Hey', 'Hi']\n" + ] + } + ], + "source": [ + "L2 = ['Hi', 'Hello', 'Hi!', 'Hey', 'Hi', 'hey', 'Hey']\n", + "L2_unique = list(set(L2))\n", + "print(L2_unique)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 4" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "122\n" + ] + } + ], + "source": [ + "d = {2: 122, 3: 535, 't': 'T', 'rom': 'cola'}\n", + "print(d[2]) # Print value corresponding to key 2" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "T\n" + ] + } + ], + "source": [ + "print(d['t']) # Print value corresponding to key 't'" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "I like rom and cola, but mostly the rom\n" + ] + } + ], + "source": [ + "print(f\"I like rom and {d['rom']}, but mostly the rom\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 5" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "23 squared is 529\n", + "73 squared is 5329\n", + "12 squared is 144\n", + "84 squared is 7056\n" + ] + } + ], + "source": [ + "n = [23, 73, 12, 84]\n", + "\n", + "# By using conventional for loop\n", + "for elem in n:\n", + " print(f'{elem} squared is {elem**2}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 6" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[78.64750000000001, 113.25240000000001, 201.3376, 314.59000000000003, 491.546875, 805.3504]\n" + ] + } + ], + "source": [ + "diameters = [10, 12, 16, 20, 25, 32]\n", + "areas = [3.1459 * dia**2 / 4 for dia in diameters] # To use pi the math module would need to be imported\n", + "print(areas)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['79', '113', '201', '315', '492', '805']\n" + ] + } + ], + "source": [ + "# Convert elements to strings and round down\n", + "print([f'{area:.0f}' for area in areas])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 7" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Alpha', 'Bravo', 'Delta']\n" + ] + } + ], + "source": [ + "phonetic_alphabet = ['Alpha', 'Bravo', 'Charlie', 'Delta', 'Echo', 'Foxtrot']\n", + "words_of_5_chars = [word for word in phonetic_alphabet if len(word) == 5]\n", + "print(words_of_5_chars)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 8" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'HE210A', 'HE210B', 'HE200A'}\n" + ] + } + ], + "source": [ + "s1 = {'HE170B', 'HE210B', 'HE190A', 'HE200A', 'HE210A', 'HE210A'}\n", + "s2 = {'HE200A', 'HE210A', 'HE240A', 'HE200A', 'HE210B', 'HE340A'}\n", + "s_intersection = s1.intersection(s2)\n", + "print(s_intersection)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 9" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[125, 435, 362, 156, 80, 435, 435]\n" + ] + } + ], + "source": [ + "rebar_stresses = (125, 501, 362, 156, 80, 475, 489)\n", + "fy = 435\n", + "sigma_s = [stress if stress <= 435 else fy for stress in rebar_stresses]\n", + "print(sigma_s)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 10" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-18, -25, 0, -21, -15, 0]\n" + ] + } + ], + "source": [ + "T1 = (-18, -27, 2, -21, -15, 5)\n", + "\n", + "T2 = []\n", + "for val in T1:\n", + " if val > 0:\n", + " T2.append(0)\n", + " elif 0 > val > -25:\n", + " T2.append(val)\n", + " else:\n", + " T2.append(-25)\n", + "\n", + "print(T2)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-18, -25, 0, -21, -15, 0]\n" + ] + } + ], + "source": [ + "# Alternative by list comprehension with chained if's\n", + "T3 = [0 if val > 0 else val if 0 > val > -25 else -25 for val in T1]\n", + "print(T3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# End of exercises\n", + "\n", + "*The cell below is for setting the style of this document. It's not part of the exercises.*" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, "outputs": [ { "data": { @@ -275,7 +633,7 @@ "" ] }, - "execution_count": 1, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -284,355 +642,6 @@ "from IPython.display import HTML\n", "HTML(''.format(open('../css/cowi.css').read()))" ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# 2. Exercise solutions\n", - "There are often many ways to do the same thing, so these are just one way of solving the problems. \n", - "\n", - "# Exercise 1" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "First element of L1 is 10 and last elements of L1 is 60\n" - ] - } - ], - "source": [ - "L1 = [10, 20, 30, 40, 50, 60]\n", - "first_elem = L1[0]\n", - "last_elem = L1[-1]\n", - "print(f'First element of L1 is {first_elem} and last elements of L1 is {last_elem}')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 2" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[20, 30, 40]\n" - ] - } - ], - "source": [ - "L1_sliced = L1[1:4]\n", - "print(L1_sliced)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 3" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['hey', 'Hello', 'Hi!', 'Hi', 'Hey']\n" - ] - } - ], - "source": [ - "L2 = ['Hi', 'Hello', 'Hi!', 'Hey', 'Hi', 'hey', 'Hey']\n", - "L2_unique = list(set(L2))\n", - "print(L2_unique)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 4" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "122\n" - ] - } - ], - "source": [ - "d = {2: 122, 3: 535, 't': 'T', 'rom': 'cola'}\n", - "print(d[2]) # Print value corresponding to key 2" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "T\n" - ] - } - ], - "source": [ - "print(d['t']) # Print value corresponding to key 't'" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "I like rom and cola, but mostly the rom\n" - ] - } - ], - "source": [ - "print(f\"I like rom and {d['rom']}, but mostly the rom\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 5" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "23 squared is 529\n", - "73 squared is 5329\n", - "12 squared is 144\n", - "84 squared is 7056\n" - ] - } - ], - "source": [ - "n = [23, 73, 12, 84]\n", - "\n", - "# By using conventional for loop\n", - "for elem in n:\n", - " print(f'{elem} squared is {elem**2}')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 6" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[78.64750000000001, 113.25240000000001, 201.3376, 314.59000000000003, 491.546875, 805.3504]\n" - ] - } - ], - "source": [ - "diameters = [10, 12, 16, 20, 25, 32]\n", - "areas = [3.1459 * dia**2 / 4 for dia in diameters] # To use pi the math module would need to be imported\n", - "print(areas)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['79', '113', '201', '315', '492', '805']\n" - ] - } - ], - "source": [ - "# Convert elements to strings and round down\n", - "print([f'{area:.0f}' for area in areas])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 7" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['Alpha', 'Bravo', 'Delta']\n" - ] - } - ], - "source": [ - "phonetic_alphabet = ['Alpha', 'Bravo', 'Charlie', 'Delta', 'Echo', 'Foxtrot']\n", - "words_of_5_chars = [word for word in phonetic_alphabet if len(word) == 5]\n", - "print(words_of_5_chars)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 8" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'HE210A', 'HE200A', 'HE210B'}\n" - ] - } - ], - "source": [ - "s1 = {'HE170B', 'HE210B', 'HE190A', 'HE200A', 'HE210A', 'HE210A'}\n", - "s2 = {'HE200A', 'HE210A', 'HE240A', 'HE200A', 'HE210B', 'HE340A'}\n", - "s_intersection = s1.intersection(s2)\n", - "print(s_intersection)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 9" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[125, 435, 362, 156, 80, 435, 435]\n" - ] - } - ], - "source": [ - "rebar_stresses = (125, 501, 362, 156, 80, 475, 489)\n", - "fy = 435\n", - "sigma_s = [stress if stress <= 435 else fy for stress in rebar_stresses]\n", - "print(sigma_s)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 10" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[-18, -25, 0, -21, -15, 0]\n" - ] - } - ], - "source": [ - "T1 = (-18, -27, 2, -21, -15, 5)\n", - "\n", - "T2 = []\n", - "for val in T1:\n", - " if val > 0:\n", - " T2.append(0)\n", - " elif 0 > val > -25:\n", - " T2.append(val)\n", - " else:\n", - " T2.append(-25)\n", - "\n", - "print(T2)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[-18, -25, 0, -21, -15, 0]\n" - ] - } - ], - "source": [ - "# Alternative by list comprehension with chained if's\n", - "T3 = [0 if val > 0 else val if 0 > val > -25 else -25 for val in T1]\n", - "print(T3)" - ] } ], "metadata": { @@ -652,7 +661,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.1" + "version": "3.7.4" }, "latex_envs": { "LaTeX_envs_menu_present": true, diff --git a/Session 3 - Functions/Session 3 - Exercise Solutions.ipynb b/Session 3 - Functions/Session 3 - Exercise Solutions.ipynb index 8b11853..7854f9e 100644 --- a/Session 3 - Functions/Session 3 - Exercise Solutions.ipynb +++ b/Session 3 - Functions/Session 3 - Exercise Solutions.ipynb @@ -1,9 +1,529 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 3. Exercise solutions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 1" + ] + }, { "cell_type": "code", "execution_count": 1, "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "314.1592653589793\n" + ] + } + ], + "source": [ + "def circle_area(r):\n", + " '''Return circle area'''\n", + " return pi * r**2 / 4 \n", + "\n", + "\n", + "# Import pi from the math library\n", + "from math import pi\n", + "\n", + "# Test function with input with r=20, save returned value\n", + "A20 = circle_area(r=20)\n", + "\n", + "# Print the result\n", + "print(A20)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* **Note**: Calling the funtion as `circle_area(20)` and `circle_area(r=20)` is the same." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[78.53981633974483, 113.09733552923255, 201.06192982974676, 314.1592653589793, 490.8738521234052, 804.247719318987]\n" + ] + } + ], + "source": [ + "def circle_areas(radii):\n", + " # Use list comprehension to return a list of radii\n", + " return [circle_area(r) for r in radii]\n", + "\n", + "\n", + "# Define list of radii\n", + "list_of_radii = [10, 12, 16, 20, 25, 32]\n", + "\n", + "# Call function with input list\n", + "print(circle_areas(list_of_radii))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* **Note 1:** Call to function `circle_area` defined in Exercise instead of defining the expression `pi * r**2 / 4` again. The concept of functions calling other functions can be used to make modular programs that are easy to follow and maintain. Each function only needs to do a small thing in itself.\n", + "\n", + "* **Note 2:** The input parameter when the function was *defined* was a list called `radii`, but the when the function was *called*, the input list was called `list_of_radii`. Thus, the input parameters passed into a function do not need to have the same name as when the function is defined." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 3" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[False, True, False, True, True, False, True]\n" + ] + } + ], + "source": [ + "def is_pile_long(pile_lengths):\n", + " \n", + " # Create True or False value by list comprehension with if/else\n", + " return [True if length >= 5 else False for length in pile_lengths]\n", + "\n", + "\n", + "# Define a list of some pile lengths to test\n", + "piles = [4.51, 6.12, 4.15, 7.31, 5.01, 4.99, 5.00]\n", + "\n", + "# Call function \n", + "print(is_pile_long(piles))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* **Note:** The built-in boolean values `True` and `False` *must* be capitalized to be recognized by Python. If for example `true` is used, Python will assume that it is a variable that you have named `true` and give an error if it is not defined. All editors will highlight the special words recognized by Python, so if the editor does not highlight, it's a sign that something is wrong." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 4" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4.608176875690327\n", + "6.3728037317960675\n" + ] + } + ], + "source": [ + "# Import sqrt from the math library\n", + "from math import sqrt\n", + "\n", + "\n", + "def dist_point_to_line(x, y, x1, y1, x2, y2):\n", + " '''Return distance between a point and a line defined by two points.\n", + "\n", + " Args:\n", + " x : x-coordinate of point \n", + " y : y-coordinate of point\n", + " x1 : x-coordinate of point 1 defining the line\n", + " y1 : y-coordinate of point 1 defining the line\n", + " x2 : x-coordinate of point 2 defining the line\n", + " y2 : y-coordinate of point 2 defining the line\n", + "\n", + " Returns:\n", + " The distance between the point and the line \n", + " '''\n", + " return abs( (y2 - y1) * x - (x2 - x1) * y + x2 * y1 - x1 * y2) / sqrt((x2 - x1)**2 + (y2 - y1)**2)\n", + "\n", + "\n", + "# Call the function with the two test cases\n", + "print(dist_point_to_line(2, 1, 5, 5, 1, 6))\n", + "print(dist_point_to_line(1.4, 5.2, 10.1, 2.24, 34.142, 13.51))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* **Note:** `abs()` used to get the numerical value." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 5\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[3.4114062067851583, 28.899880223334442, 2.745765971314884, 25.405268987115498, 3.466876226407682, 6.157172178100044]\n" + ] + } + ], + "source": [ + "# Two points defining the line\n", + "x1, y1, x2, y2 = 2, 3, 8, 7\n", + "\n", + "# Define points for distance to line calculation\n", + "x_coords = [4.1, 22.2, 7.7, 62.2, 7.8, 1.1]\n", + "y_coords = [0.3, 51.2, 3.5, 12.6, 2.7, 9.8]\n", + "\n", + "# Call function dist_point_to_line for all (x, y) points\n", + "distances = [dist_point_to_line(x_coords[i], y_coords[i], x1, y1, x2, y2) for i in range(len(x_coords))]\n", + "\n", + "# Print new list\n", + "print(distances)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A way that is more Pythonic than the above is using `zip`, which takes the two coordinate lists and puts \n", + "them side by side, almost like a zipper. It is often more clean and expressive than using a loop counter `i` over the length of one of the lists." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[3.4114062067851583, 28.899880223334442, 2.745765971314884, 25.405268987115498, 3.466876226407682, 6.157172178100044]\n" + ] + } + ], + "source": [ + "# Solution using zip\n", + "distances_zip = [dist_point_to_line(x, y, x1, y1, x2, y2) for x, y in zip(x_coords, y_coords)]\n", + "print(distances_zip)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[3.41, 28.9, 2.75, 25.41, 3.47, 6.16]\n" + ] + } + ], + "source": [ + "# Results rounded to two decimals using the round() function\n", + "print([round(dist, 2) for dist in distances])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 6" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "12.0\n" + ] + } + ], + "source": [ + "def polygon_area(xv, yv, signed=False):\n", + " ''' Return the area of a non-self-intersecting polygon given the coordinates of its vertices'''\n", + "\n", + " # Perform shoelace multiplication\n", + " a1 = [xv[i] * yv[i+1] for i in range(len(xv)-1)]\n", + " a2 = [yv[i] * xv[i+1] for i in range(len(yv)-1)]\n", + "\n", + " # Check if area should be signed and return area\n", + " if signed: # <--- Same as \"if signed == True:\"\n", + " return 1/2 * ( sum(a1) - sum(a2) )\n", + " else:\n", + " return 1/2 * abs( sum(a1) - sum(a2) )\n", + "\n", + "\n", + "# Define the polygon vertices to test\n", + "x = [3, 4, 7, 8, 8.5, 3]\n", + "y = [5, 3, 0, 1, 3, 5]\n", + "\n", + "# Calculate area by calling the function\n", + "A = polygon_area(x, y)\n", + "\n", + "# Print the area\n", + "print(A)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 7" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6.083333333333333 2.5833333333333335\n" + ] + } + ], + "source": [ + "def polygon_centroid(x, y):\n", + "\n", + " # Initialize empty lists for holding summation terms\n", + " cx, cy = [], []\n", + " \n", + " # Loop over vertices and put the summation terms in the lists\n", + " for i in range(len(x)-1):\n", + " \n", + " # Compute and append summation terms to each list\n", + " cx.append((x[i] + x[i+1]) * (x[i] * y[i+1] - x[i+1] * y[i]))\n", + " cy.append((y[i] + y[i+1]) * (x[i] * y[i+1] - x[i+1] * y[i]))\n", + "\n", + " # Calculate the signed polygon area by calling already defined function\n", + " A = polygon_area(x, y, signed=True) \n", + " \n", + " # Sum summation terms and divide by 6A to get coordinates\n", + " Cx = sum(cx) / (6*A)\n", + " Cy = sum(cy) / (6*A)\n", + " \n", + " return Cx, Cy \n", + "\n", + "\n", + "# Define lists of vertex coordinates for testing\n", + "x = [3, 4, 7, 8, 8.5, 3]\n", + "y = [5, 3, 0, 1, 3, 5]\n", + "\n", + "# Compute centroid by calling function, store in two variables\n", + "cx, cy = polygon_centroid(x, y)\n", + "\n", + "# Print result\n", + "print(cx, cy)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Polygon centroid is at (Cx, Cy) = (6.1, 2.6)\n" + ] + } + ], + "source": [ + "# Print result as text with formatted decimals\n", + "print(f'Polygon centroid is at (Cx, Cy) = ({cx:.1f}, {cy:.1f})')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Appetizer for next time - Plotting\n", + "\n", + "### Plotting the solution for the polygon centroid exercise:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# Plot polygon from exercises with centroid and area\n", + "plt.plot(x, y, '.-', label='Polygon')\n", + "plt.plot(cx, cy, 'x', label='Centroid')\n", + "\n", + "# Plot coordinates of centroid as text\n", + "plt.annotate(f'({cx:.1f}, {cy:.1f})', xy=(cx, cy),\n", + " xytext=(cx, cy), textcoords='offset points')\n", + "\n", + "# Set labels, titles and legend\n", + "plt.xlabel('x')\n", + "plt.ylabel('y')\n", + "plt.title(f'Polygon with A={A}')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Function for plotting an arbitrary polygon\n", + "The plotting code above could be turned into a function to plot an arbitrary polygon together with its center of gravity and put its area in the title: " + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "def plot_polygon(xv, yv, plot_centroid=True): \n", + " '''Plot the polygon with the specified vertex coordinates. \n", + " \n", + " The plot is created with legend and the computed area of the \n", + " polygon shown in the title. The plot shows the centroid of \n", + " the polygon by default, but this can be turned off by setting \n", + " plot_centroid=False.\n", + " \n", + " Args:\n", + " xv (list) : x-coordinates of polygon vertices\n", + " yv (list) : y-coordinates of polygon vertices\n", + " plot_centroid (bool) : Plot centroid of polygon (Cx, Cy).\n", + " Defaults to plotting the centroid. \n", + " '''\n", + " \n", + " # Compute area of polygon\n", + " A = polygon_area(xv, yv)\n", + " \n", + " # Compute polygon centroid\n", + " cx, cy = polygon_centroid(xv, yv)\n", + " \n", + " # Plot the polygon\n", + " plt.plot(xv, yv, '.-', label='Polygon')\n", + " \n", + " # Plot the centroid with coordinates if that was chosen\n", + " if plot_centroid: # <- Eqiuvalent to: if plot_centroid == True:\n", + " plt.plot(cx, cy, 'x', label='Centroid')\n", + " plt.annotate(f'({cx:.1f}, {cy:.1f})', xy=(cx, cy),\n", + " xytext=(cx, cy), textcoords='offset points')\n", + " \n", + " # Set labels, titles and legend\n", + " plt.xlabel('x')\n", + " plt.ylabel('y')\n", + " plt.title(f'Polygon with A={A}')\n", + " plt.legend()\n", + " plt.show()\n", + " \n", + " \n", + "# Define vertices of some random polygon\n", + "x_polygon = [-5, 2, 5, 7, 8, 5, 1, -5]\n", + "y_polygon = [-2, -15, -13, -10, -6, 2, 5, -2]\n", + "\n", + "# Call function to plot polygon with area and centroid shown\n", + "plot_polygon(x_polygon, y_polygon)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* **Note 1:** Optional input parameter `plot_centroid` has `True` as default argument. `True` is immutable.\n", + "* **Note 2:** The area of the polygon is actually calculated both in the `polygon_area()` function and in the `polygon_centroid()` function, which is maybe not so clean. A way to overcome this could be to have `polygon_centroid()` return the area. Thereby running the `polygon_area()`function alone would not be necessary." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# End of exercises\n", + "\n", + "*The cell below is for setting the style of this document. It's not part of the exercises.*" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, "outputs": [ { "data": { @@ -275,7 +795,7 @@ "" ] }, - "execution_count": 1, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -284,517 +804,6 @@ "from IPython.display import HTML\n", "HTML(''.format(open('../css/cowi.css').read()))" ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# 3. Exercise solutions" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 1" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "314.1592653589793\n" - ] - } - ], - "source": [ - "def circle_area(r):\n", - " '''Return circle area'''\n", - " return pi * r**2 / 4 \n", - "\n", - "\n", - "# Import pi from the math library\n", - "from math import pi\n", - "\n", - "# Test function with input with r=20, save returned value\n", - "A20 = circle_area(r=20)\n", - "\n", - "# Print the result\n", - "print(A20)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "* **Note**: Calling the funtion as `circle_area(20)` and `circle_area(r=20)` is the same." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 2" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[78.53981633974483, 113.09733552923255, 201.06192982974676, 314.1592653589793, 490.8738521234052, 804.247719318987]\n" - ] - } - ], - "source": [ - "def circle_areas(radii):\n", - " # Use list comprehension to return a list of radii\n", - " return [circle_area(r) for r in radii]\n", - "\n", - "\n", - "# Define list of radii\n", - "list_of_radii = [10, 12, 16, 20, 25, 32]\n", - "\n", - "# Call function with input list\n", - "print(circle_areas(list_of_radii))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "* **Note 1:** Call to function `circle_area` defined in Exercise instead of defining the expression `pi * r**2 / 4` again. The concept of functions calling other functions can be used to make modular programs that are easy to follow and maintain. Each function only needs to do a small thing in itself.\n", - "\n", - "* **Note 2:** The input parameter when the function was *defined* was a list called `radii`, but the when the function was *called*, the input list was called `list_of_radii`. Thus, the input parameters passed into a function do not need to have the same name as when the function is defined." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 3" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[False, True, False, True, True, False, True]\n" - ] - } - ], - "source": [ - "def is_pile_long(pile_lengths):\n", - " \n", - " # Create True or False value by list comprehension with if/else\n", - " return [True if length >= 5 else False for length in pile_lengths]\n", - "\n", - "\n", - "# Define a list of some pile lengths to test\n", - "piles = [4.51, 6.12, 4.15, 7.31, 5.01, 4.99, 5.00]\n", - "\n", - "# Call function \n", - "print(is_pile_long(piles))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "* **Note:** The built-in boolean values `True` and `False` *must* be capitalized to be recognized by Python. If for example `true` is used, Python will assume that it is a variable that you have named `true` and give an error if it is not defined. All editors will highlight the special words recognized by Python, so if the editor does not highlight, it's a sign that something is wrong." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 4" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "4.608176875690327\n", - "6.3728037317960675\n" - ] - } - ], - "source": [ - "# Import sqrt from the math library\n", - "from math import sqrt\n", - "\n", - "\n", - "def dist_point_to_line(x, y, x1, y1, x2, y2):\n", - " '''Return distance between a point and a line defined by two points.\n", - "\n", - " Args:\n", - " x : x-coordinate of point \n", - " y : y-coordinate of point\n", - " x1 : x-coordinate of point 1 defining the line\n", - " y1 : y-coordinate of point 1 defining the line\n", - " x2 : x-coordinate of point 2 defining the line\n", - " y2 : y-coordinate of point 2 defining the line\n", - "\n", - " Returns:\n", - " The distance between the point and the line \n", - " '''\n", - " return abs( (y2 - y1) * x - (x2 - x1) * y + x2 * y1 - x1 * y2) / sqrt((x2 - x1)**2 + (y2 - y1)**2)\n", - "\n", - "\n", - "# Call the function with the two test cases\n", - "print(dist_point_to_line(2, 1, 5, 5, 1, 6))\n", - "print(dist_point_to_line(1.4, 5.2, 10.1, 2.24, 34.142, 13.51))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "* **Note:** `abs()` used to get the numerical value." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 5\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[3.4114062067851583, 28.899880223334442, 2.745765971314884, 25.405268987115498, 3.466876226407682, 6.157172178100044]\n" - ] - } - ], - "source": [ - "# Two points defining the line\n", - "x1, y1, x2, y2 = 2, 3, 8, 7\n", - "\n", - "# Define points for distance to line calculation\n", - "x_coords = [4.1, 22.2, 7.7, 62.2, 7.8, 1.1]\n", - "y_coords = [0.3, 51.2, 3.5, 12.6, 2.7, 9.8]\n", - "\n", - "# Call function dist_point_to_line for all (x, y) points\n", - "distances = [dist_point_to_line(x_coords[i], y_coords[i], x1, y1, x2, y2) for i in range(len(x_coords))]\n", - "\n", - "# Print new list\n", - "print(distances)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "A way that is more Pythonic than the above is using `zip`, which takes the two coordinate lists and puts \n", - "them side by side, almost like a zipper. It is often more clean and expressive than using a loop counter `i` over the length of one of the lists." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[3.4114062067851583, 28.899880223334442, 2.745765971314884, 25.405268987115498, 3.466876226407682, 6.157172178100044]\n" - ] - } - ], - "source": [ - "# Solution using zip\n", - "distances_zip = [dist_point_to_line(x, y, x1, y1, x2, y2) for x, y in zip(x_coords, y_coords)]\n", - "print(distances_zip)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[3.41, 28.9, 2.75, 25.41, 3.47, 6.16]\n" - ] - } - ], - "source": [ - "# Results rounded to two decimals using the round() function\n", - "print([round(dist, 2) for dist in distances])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 6" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "12.0\n" - ] - } - ], - "source": [ - "def polygon_area(xv, yv, signed=False):\n", - " ''' Return the area of a non-self-intersecting polygon given the coordinates of its vertices'''\n", - "\n", - " # Perform shoelace multiplication\n", - " a1 = [xv[i] * yv[i+1] for i in range(len(xv)-1)]\n", - " a2 = [yv[i] * xv[i+1] for i in range(len(yv)-1)]\n", - "\n", - " # Check if area should be signed and return area\n", - " if signed: # <--- Same as \"if signed == True:\"\n", - " return 1/2 * ( sum(a1) - sum(a2) )\n", - " else:\n", - " return 1/2 * abs( sum(a1) - sum(a2) )\n", - "\n", - "\n", - "# Define the polygon vertices to test\n", - "x = [3, 4, 7, 8, 8.5, 3]\n", - "y = [5, 3, 0, 1, 3, 5]\n", - "\n", - "# Calculate area by calling the function\n", - "A = polygon_area(x, y)\n", - "\n", - "# Print the area\n", - "print(A)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 7" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "6.083333333333333 2.5833333333333335\n" - ] - } - ], - "source": [ - "def polygon_centroid(x, y):\n", - "\n", - " # Initialize empty lists for holding summation terms\n", - " cx, cy = [], []\n", - " \n", - " # Loop over vertices and put the summation terms in the lists\n", - " for i in range(len(x)-1):\n", - " \n", - " # Compute and append summation terms to each list\n", - " cx.append((x[i] + x[i+1]) * (x[i] * y[i+1] - x[i+1] * y[i]))\n", - " cy.append((y[i] + y[i+1]) * (x[i] * y[i+1] - x[i+1] * y[i]))\n", - "\n", - " # Calculate the signed polygon area by calling already defined function\n", - " A = polygon_area(x, y, signed=True) \n", - " \n", - " # Sum summation terms and divide by 6A to get coordinates\n", - " Cx = sum(cx) / (6*A)\n", - " Cy = sum(cy) / (6*A)\n", - " \n", - " return Cx, Cy \n", - "\n", - "\n", - "# Define lists of vertex coordinates for testing\n", - "x = [3, 4, 7, 8, 8.5, 3]\n", - "y = [5, 3, 0, 1, 3, 5]\n", - "\n", - "# Compute centroid by calling function, store in two variables\n", - "cx, cy = polygon_centroid(x, y)\n", - "\n", - "# Print result\n", - "print(cx, cy)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Polygon centroid is at (Cx, Cy) = (6.1, 2.6)\n" - ] - } - ], - "source": [ - "# Print result as text with formatted decimals\n", - "print(f'Polygon centroid is at (Cx, Cy) = ({cx:.1f}, {cy:.1f})')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Appetizer for next time - Plotting\n", - "\n", - "### Plotting the solution for the polygon centroid exercise:" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "# Plot polygon from exercises with centroid and area\n", - "plt.plot(x, y, '.-', label='Polygon')\n", - "plt.plot(cx, cy, 'x', label='Centroid')\n", - "\n", - "# Plot coordinates of centroid as text\n", - "plt.annotate(f'({cx:.1f}, {cy:.1f})', xy=(cx, cy),\n", - " xytext=(cx, cy), textcoords='offset points')\n", - "\n", - "# Set labels, titles and legend\n", - "plt.xlabel('x')\n", - "plt.ylabel('y')\n", - "plt.title(f'Polygon with A={A}')\n", - "plt.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Function for plotting an arbitrary polygon\n", - "The plotting code above could be turned into a function to plot an arbitrary polygon together with its center of gravity and put its area in the title: " - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "\n", - "def plot_polygon(xv, yv, plot_centroid=True): \n", - " '''Plot the polygon with the specified vertex coordinates. \n", - " \n", - " The plot is created with legend and the computed area of the \n", - " polygon shown in the title. The plot shows the centroid of \n", - " the polygon by default, but this can be turned off by setting \n", - " plot_centroid=False.\n", - " \n", - " Args:\n", - " xv (list) : x-coordinates of polygon vertices\n", - " yv (list) : y-coordinates of polygon vertices\n", - " plot_centroid (bool) : Plot centroid of polygon (Cx, Cy).\n", - " Defaults to plotting the centroid. \n", - " '''\n", - " \n", - " # Compute area of polygon\n", - " A = polygon_area(xv, yv)\n", - " \n", - " # Compute polygon centroid\n", - " cx, cy = polygon_centroid(xv, yv)\n", - " \n", - " # Plot the polygon\n", - " plt.plot(xv, yv, '.-', label='Polygon')\n", - " \n", - " # Plot the centroid with coordinates if that was chosen\n", - " if plot_centroid: # <- Eqiuvalent to: if plot_centroid == True:\n", - " plt.plot(cx, cy, 'x', label='Centroid')\n", - " plt.annotate(f'({cx:.1f}, {cy:.1f})', xy=(cx, cy),\n", - " xytext=(cx, cy), textcoords='offset points')\n", - " \n", - " # Set labels, titles and legend\n", - " plt.xlabel('x')\n", - " plt.ylabel('y')\n", - " plt.title(f'Polygon with A={A}')\n", - " plt.legend()\n", - " plt.show()\n", - " \n", - " \n", - "# Define vertices of some random polygon\n", - "x_polygon = [-5, 2, 5, 7, 8, 5, 1, -5]\n", - "y_polygon = [-2, -15, -13, -10, -6, 2, 5, -2]\n", - "\n", - "# Call function to plot polygon with area and centroid shown\n", - "plot_polygon(x_polygon, y_polygon)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "* **Note 1:** Optional input parameter `plot_centroid` has `True` as default argument. `True` is immutable.\n", - "* **Note 2:** The area of the polygon is actually calculated both in the `polygon_area()` function and in the `polygon_centroid()` function, which is maybe not so clean. A way to overcome this could be to have `polygon_centroid()` return the area. Thereby running the `polygon_area()`function alone would not be necessary." - ] } ], "metadata": { @@ -814,7 +823,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.1" + "version": "3.7.4" }, "latex_envs": { "LaTeX_envs_menu_present": true, diff --git a/Session 3 - Functions/Session 3 - Functions.ipynb b/Session 3 - Functions/Session 3 - Functions.ipynb index eff03b4..46c171a 100644 --- a/Session 3 - Functions/Session 3 - Functions.ipynb +++ b/Session 3 - Functions/Session 3 - Functions.ipynb @@ -1,9 +1,581 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": { + "cell_style": "center" + }, + "source": [ + "\n", + "# 3. Functions\n", + "A **function** is a block of code that is first defined, and thereafter can be called to run as many times as needed. A function might have arguments, some of which can be optional if a default value is specified.\n", + "\n", + "A function is called by parentheses: `function_name()`. Arguments are placed inside the parentehes and comma separated if there are more than one.\n", + "Similar to `f(x, y)` from mathematics.\n", + "\n", + "A function can return one or more values to the caller. The values to return are put in the `return` statement. When the code hits a `return` statement the function terminates. If no `return` statement is given, the function will return `None`.\n", + "\n", + "The general syntax of a function is:\n", + "\n", + "~~~python\n", + "def function_name(arg1, arg2, default_arg1=0, default_arg2=None):\n", + " '''This is the docstring \n", + " \n", + " The docstring explains what the function does, so it is like a multiline comment. It does not have to be here, \n", + " but it is good practice to use them to document the code. They are especially useful for more complicated \n", + " functions, although functions should in general be kept as simple as possible.\n", + " Arguments could be explained together with their types (e.g. strings, lists, dicts etc.).\n", + " '''\n", + " \n", + " # Function code goes here\n", + " \n", + " # Possible 'return' statement terminating the function. If 'return' is not specified, function returns None.\n", + " return return_val1, return_val2\n", + "~~~\n", + "\n", + "If multiple values are to be returned, they can be separated by commas as shown. The returned entity will by default be a `tuple`.\n", + "\n", + "Note that when using default arguments, it is good practice to only use immutable types. An example further below will demonstrate why this is recommended. \n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Basic functions\n", + "A simple function with one argument is defined below." + ] + }, { "cell_type": "code", "execution_count": 1, "metadata": {}, + "outputs": [], + "source": [ + "def f(x):\n", + " return 6.25 + x + x**2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + ">**Note:** No code has been executed yet. It has merely been defined so it's ready to run when the function is called.\n", + "\n", + "Calling the function with the argument `5` returns:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "36.25" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f(5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If we define a function without returning anything, it returns `None`:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "None\n" + ] + } + ], + "source": [ + "def first_char(word):\n", + " word[0] # <--- No return statement, function returns None\n", + " \n", + " \n", + "# Variable a will be equal to None\n", + "a = first_char('hello') \n", + "\n", + "# Printing the returned value\n", + "print(a)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Often a return value is wanted from a function, but there could be scenarios where it is not wanted. E.g. if you want to mutate a list by the function. Consider this example:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello Anders\n", + "Hello Anders\n", + "None\n" + ] + } + ], + "source": [ + "def say_hello_to(name):\n", + " ''' Say hello to the input name '''\n", + " print(f'Hello {name}')\n", + " \n", + "\n", + "say_hello_to('Anders') # <--- Calling the function prints 'Hello {name}'\n", + "\n", + "r = say_hello_to('Anders') # <--- Calling the function prints 'Hello {name}' and assigns None to r\n", + "\n", + "print(r) # <--- Prints None, since function had no return statement " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The function was still useful even though it did not return anything. Another example could be a function that creates a plot instead of returning a value." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "cell_style": "center" + }, + "source": [ + "### Using `enumerate` for looping in index/value pairs\n", + "The built-in `enumerate` is useful when you want to loop over an iterable together with the index of each of its elements:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 a\n", + "1 b\n", + "2 c\n", + "3 d\n", + "4 c\n" + ] + } + ], + "source": [ + "# Define a list of strings\n", + "letters = ['a', 'b', 'c', 'd', 'c']\n", + "\n", + "# Loop over index and elements in pairs\n", + "for idx, letter in enumerate(letters):\n", + " print(idx, letter)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 a\n", + "2 b\n", + "3 c\n", + "4 d\n", + "5 c\n" + ] + } + ], + "source": [ + "# Starting at 1 (internally, enumerate has start=0 set as default)\n", + "for idx, letter in enumerate(letters, start=1): \n", + " print(idx, letter)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`enumerate` solves a commonly encountered scenario, i.e. looping in index/value pairs. \n", + "\n", + "Similar functionality could be obtained by looping over the index and indexing the list value inside each loop (**Not recommended**): " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 a\n", + "1 b\n", + "2 c\n", + "3 d\n", + "4 c\n" + ] + } + ], + "source": [ + "# Loop over index and elements in pairs\n", + "for i in range(len(letters)):\n", + " print(i, letters[i])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The Pythonic way is to use `enumerate` in this scenario since most people find it more readable. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Using `zip` for looping over multiple iterables\n", + "The built-in `zip`is useful when you want to put two lists up beside each other and loop over them element by element in pairs." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10 78.5\n", + "12 113.04\n", + "16 200.96\n", + "20 314.0\n", + "25 490.625\n" + ] + } + ], + "source": [ + "# Define a list of circle diameters\n", + "diameters = [10, 12, 16, 20, 25] \n", + "\n", + "# Compute circle area by list comprehension\n", + "areas = [3.14 * (d/2)**2 for d in diameters]\n", + "\n", + "# Print (diameter, area) pairs\n", + "for d, A in zip(diameters, areas):\n", + " print(d, A)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`zip` can be used for more than two iterables:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a h o\n", + "b i p\n", + "c j q\n" + ] + } + ], + "source": [ + "# Use zip with three strings\n", + "for x, y, z in zip('abc', 'hij', 'opq'):\n", + " print(x, y, z)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`zip` stops when the shortest iterable is exhausted. So if if `c` is removed from the first string in the example above, we have iterables of lengths 2, 3 and 3. \n", + "\n", + "Thus, only two iterations are performed:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a h o\n", + "b i p\n" + ] + } + ], + "source": [ + "# Use zip with three strings\n", + "for x, y, z in zip('ab', 'hij', 'opq'):\n", + " print(x, y, z)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Local vs. global variables\n", + "\n", + "* **Global variables**: Variables defined outside a function\n", + "* **Local variables**: Variables defined inside a function\n", + "\n", + "Local variables cannot be accessed outside the function. By returning a local variable and saving it into a global variable we can use the result outside the function, in the global namespace." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Imports\n", + "\n", + "### Libraries\n", + "A quick overview of imports of libraries in Python, here shown for the math library:\n", + "\n", + "---\n", + "~~~python\n", + "import math # Lets you access everything in the math library by dot-notation (e.g math.pi) \n", + "from math import pi # Lets you use pi directly\n", + "from math import * # Lets you use everything in the math library directly \n", + "~~~\n", + "The last one is not considered good practice, since variables will be untraceable. It can be good for making quick tests though.\n", + "\n", + "### Your own modules\n", + "You can also import your own `.py` files this way and access the functions inside them. It is easiest if the file to import is located in the same folder as the `.py` file you want to import to. \n", + "\n", + "An example:\n", + "\n", + "~~~python\n", + "import my_module # my_module could be your own python file located in same directory\n", + "~~~\n", + "If you have a function inside `my_module` called `my_func`, you can now call it as `my_module.my_func()`.\n", + "\n", + "> Python files that are meant to be executed directly are called **scripts** and files that are imported into other files are called **modules**." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 1\n", + "Finish the function below that takes a radius `r` as input and make it return the circle area.\n", + "\n", + "~~~python\n", + "def circle_area(r):\n", + " '''Return circle area'''\n", + " # Your code goes here\n", + "~~~\n", + "\n", + "Try to call it to see if it works. If you want to access `pi` to avoid typing it out yourself, put the line `from math import pi` at some point before calling the `circle_area` function.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 2\n", + "Write a function that takes a list `radii` as input and returns a list of the corresponding circle areas. Try to set it up from scratch and test it.\n", + "\n", + "You can use the function from the previous exercise if you want." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 3\n", + "Write the function described in the docstring below.\n", + "\n", + "~~~Python\n", + "def is_pile_long(pile_lengths):\n", + " ''' Return a list with elements `True` for all piles longer than or equal to 5m, `False` otherwise.\n", + " \n", + " Args:\n", + " pile_lengths: A list containing pile lengths \n", + " \n", + " Example: \n", + " is_pile_long([4.51, 6.12, 4.15, 7.31, 5.01, 4.99, 5.00])\n", + " ---> [False, True, False, True, True, False, True] \n", + " '''\n", + " # Your code goes here\n", + " \n", + "~~~" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 4\n", + "Finish the function below so it does as described in the docstring. Remember to import the `sqrt` function from the math module.\n", + "\n", + "---\n", + "~~~python\n", + "def dist_point_to_line(x, y, x1, y1, x2, y2):\n", + " '''Return distance between a point and a line defined by two points.\n", + " \n", + " Args:\n", + " x : x-coordinate of point \n", + " y : y-coordinate of point\n", + " x1 : x-coordinate of point 1 defining the line\n", + " y1 : y-coordinate of point 1 defining the line\n", + " x2 : x-coordinate of point 2 defining the line\n", + " y2 : y-coordinate of point 2 defining the line\n", + " \n", + " Returns:\n", + " The distance between the point and the line \n", + " '''\n", + " # Your code goes here\n", + "~~~\n", + "---\n", + "The distance between a point $(x, y)$ and a line passing through points $(x_1, y_1)$ and $(x_2, y_2)$ can be found as\n", + "\n", + "\\begin{equation*}\n", + "\\textrm{ distance}(P_1, P_2, (x, y)) = \\frac{|(y_2-y_1)x - (x_2-x_1)y + x_2 y_1 - y_2 x_1|}{\\sqrt{ (x_2-x_1)^2 + (y_2-y_1)^2 }}\n", + "\\end{equation*}\n", + "\n", + "Use `abs()` to get the numeric value.\n", + "\n", + "Call the function to test if it works. Some examples to test against:\n", + "\n", + "~~~python\n", + "dist_point_to_line(2, 1, 5, 5, 1, 6) --> 4.61 \n", + "dist_point_to_line(1.4, 5.2, 10.1, 2.24, 34.142, 13.51) --> 6.37 \n", + "~~~\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 5\n", + "Given a line defined by two points $(x_1, y_1)=(2, 3)$ and $(x_2, y_2)=(8, 7)$, compute the distance to the points with coordinates `x_coords` and `y_coords` below.\n", + "\n", + "Put the results into a list.\n", + "\n", + "~~~python\n", + "# x- and y-coordinates of points\n", + "x_coords = [4.1, 22.2, 7.7, 62.2, 7.8, 1.1]\n", + "y_coords = [0.3, 51.2, 3.5, 12.6, 2.7, 9.8]\n", + "~~~\n", + "\n", + "You can either use a list comprehension or create a traditional `for`-loop where results get appended to the list in every loop.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 6\n", + "Create a function that calculates the area of a simple (non-self-intersecting) polygon by using the so-called **Shoelace Formula**\n", + "\n", + "$$ A_p = \\frac{1}{2} \\sum_{i=0}^{n-1} (x_i y_{i+1} - x_{i+1} y_i) $$\n", + "\n", + "The area is **signed** depending on the ordering of the polygon being clockwise or counter-clockwise. The numerical value of the formula will always be equal to the actual area.\n", + "\n", + "The function should take three input parameters:\n", + "\n", + "* `xv` - list of x-coordinates of all vertices\n", + "* `yv` - list of y-coordinates of all vertices\n", + "* `signed` - boolean value that dictates whether the function returns the signed area or the actual area. Default should be actual area.\n", + "\n", + "Assume that the polygon is closed, i.e. the first and last elements of `xv` are identical and the same is true for `yv`.\n", + "\n", + "A function call with these input coordinates should return `12.0`: \n", + "~~~python \n", + "x = [3, 4, 7, 8, 8.5, 3]\n", + "y = [5, 3, 0, 1, 3, 5]\n", + "~~~\n", + "\n", + "Source: https://en.wikipedia.org/wiki/Polygon#Area" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 7\n", + "Write a function that calculates and returns the centroid $(C_x, C_y)$ of a polygon by using the formula:\n", + "\n", + "$$ C_x = \\frac{1}{6A} \\sum_{i=0}^{n-1} (x_i+x_{i+1}) (x_i y_{i+1} - x_{i+1} y_i) $$\n", + "\n", + "$$ C_y = \\frac{1}{6A} \\sum_{i=0}^{n-1} (y_i+y_{i+1}) (x_i y_{i+1} - x_{i+1} y_i) $$\n", + "\n", + "`x` and `y` are lists of coordinates of a closed simple polygon.\n", + "\n", + "Here, $A$ is the **signed** area. When you need $A$, call the function from the previous exercise to get it. Be sure to call it with the non-default `signed=True`. \n", + "\n", + "A function call with the input coordinates below should return (`6.083`, `2.583`):\n", + "~~~python\n", + "x = [3, 4, 7, 8, 8.5, 3]\n", + "y = [5, 3, 0, 1, 3, 5]\n", + "~~~\n", + "\n", + "Source: https://en.wikipedia.org/wiki/Centroid#Of_a_polygon" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# If you are up for more\n", + "Try to write a function that can calculate the elastic centroid of a section with materials of two different stiffness values. E.g. a reinforced concrete section with polygon shape." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# End of exercises\n", + "\n", + "*The cell below is for setting the style of this document. It's not part of the exercises.*" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, "outputs": [ { "data": { @@ -275,7 +847,7 @@ "" ] }, - "execution_count": 1, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -284,569 +856,6 @@ "from IPython.display import HTML\n", "HTML(''.format(open('../css/cowi.css').read()))" ] - }, - { - "cell_type": "markdown", - "metadata": { - "cell_style": "center" - }, - "source": [ - "\n", - "# 3. - Functions\n", - "A **function** is a block of code that is first defined, and thereafter can be called to run as many times as needed. A function might have arguments, some of which can be optional if a default value is specified.\n", - "\n", - "A function is called by parentheses: `function_name()`. Arguments are placed inside the parentehes and comma separated if there are more than one.\n", - "Similar to `f(x, y)` from mathematics.\n", - "\n", - "A function can return one or more values to the caller. The values to return are put in the `return` statement. When the code hits a `return` statement the function terminates. If no `return` statement is given, the function will return `None`.\n", - "\n", - "The general syntax of a function is:\n", - "\n", - "~~~python\n", - "def function_name(arg1, arg2, default_arg1=0, default_arg2=None):\n", - " '''This is the docstring \n", - " \n", - " The docstring explains what the function does, so it is like a multiline comment. It does not have to be here, \n", - " but it is good practice to use them to document the code. They are especially useful for more complicated \n", - " functions, although functions should in general be kept as simple as possible.\n", - " Arguments could be explained together with their types (e.g. strings, lists, dicts etc.).\n", - " '''\n", - " \n", - " # Function code goes here\n", - " \n", - " # Possible 'return' statement terminating the function. If 'return' is not specified, function returns None.\n", - " return return_val1, return_val2\n", - "~~~\n", - "\n", - "If multiple values are to be returned, they can be separated by commas as shown. The returned entity will by default be a `tuple`.\n", - "\n", - "Note that when using default arguments, it is good practice to only use immutable types. An example further below will demonstrate why this is recommended. \n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Basic functions\n", - "A simple function with one argument is defined below." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "def f(x):\n", - " return 6.25 + x + x**2" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - ">**Note:** No code has been executed yet. It has merely been defined so it's ready to run when the function is called.\n", - "\n", - "Calling the function with the argument `5` returns:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "36.25" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "f(5)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "If we define a function without returning anything, it returns `None`:" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "None\n" - ] - } - ], - "source": [ - "def first_char(word):\n", - " word[0] # <--- No return statement, function returns None\n", - " \n", - " \n", - "# Variable a will be equal to None\n", - "a = first_char('hello') \n", - "\n", - "# Printing the returned value\n", - "print(a)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Often a return value is wanted from a function, but there could be scenarios where it is not wanted. E.g. if you want to mutate a list by the function. Consider this example:" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Hello Anders\n", - "Hello Anders\n", - "None\n" - ] - } - ], - "source": [ - "def say_hello_to(name):\n", - " ''' Say hello to the input name '''\n", - " print(f'Hello {name}')\n", - " \n", - "\n", - "say_hello_to('Anders') # <--- Calling the function prints 'Hello {name}'\n", - "\n", - "r = say_hello_to('Anders') # <--- Calling the function prints 'Hello {name}' and assigns None to r\n", - "\n", - "print(r) # <--- Prints None, since function had no return statement " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The function was still useful even though it did not return anything. Another example could be a function that creates a plot instead of returning a value." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "cell_style": "center" - }, - "source": [ - "### Using `enumerate` for looping in index/value pairs\n", - "The built-in `enumerate` is useful when you want to loop over an iterable together with the index of each of its elements:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0 a\n", - "1 b\n", - "2 c\n", - "3 d\n", - "4 c\n" - ] - } - ], - "source": [ - "# Define a list of strings\n", - "letters = ['a', 'b', 'c', 'd', 'c']\n", - "\n", - "# Loop over index and elements in pairs\n", - "for idx, letter in enumerate(letters):\n", - " print(idx, letter)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1 a\n", - "2 b\n", - "3 c\n", - "4 d\n", - "5 c\n" - ] - } - ], - "source": [ - "# Starting at 1 (internally, enumerate has start=0 set as default)\n", - "for idx, letter in enumerate(letters, start=1): \n", - " print(idx, letter)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "`enumerate` solves a commonly encountered scenario, i.e. looping in index/value pairs. \n", - "\n", - "Similar functionality could be obtained by looping over the index and indexing the list value inside each loop (**Not recommended**): " - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0 a\n", - "1 b\n", - "2 c\n", - "3 d\n", - "4 c\n" - ] - } - ], - "source": [ - "# Loop over index and elements in pairs\n", - "for i in range(len(letters)):\n", - " print(i, letters[i])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The Pythonic way is to use `enumerate` in this scenario since most people find it more readable. " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Using `zip` for looping over multiple iterables\n", - "The built-in `zip`is useful when you want to put two lists up beside each other and loop over them element by element in pairs." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "10 78.5\n", - "12 113.04\n", - "16 200.96\n", - "20 314.0\n", - "25 490.625\n" - ] - } - ], - "source": [ - "# Define a list of circle diameters\n", - "diameters = [10, 12, 16, 20, 25] \n", - "\n", - "# Compute circle area by list comprehension\n", - "areas = [3.14 * (d/2)**2 for d in diameters]\n", - "\n", - "# Print (diameter, area) pairs\n", - "for d, A in zip(diameters, areas):\n", - " print(d, A)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "`zip` can be used for more than two iterables:" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "a h o\n", - "b i p\n", - "c j q\n" - ] - } - ], - "source": [ - "# Use zip with three strings\n", - "for x, y, z in zip('abc', 'hij', 'opq'):\n", - " print(x, y, z)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "`zip` stops when the shortest iterable is exhausted. So if if `c` is removed from the first string in the example above, we have iterables of lengths 2, 3 and 3. \n", - "\n", - "Thus, only two iterations are performed:" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "a h o\n", - "b i p\n" - ] - } - ], - "source": [ - "# Use zip with three strings\n", - "for x, y, z in zip('ab', 'hij', 'opq'):\n", - " print(x, y, z)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Local vs. global variables\n", - "\n", - "* **Global variables**: Variables defined outside a function\n", - "* **Local variables**: Variables defined inside a function\n", - "\n", - "Local variables cannot be accessed outside the function. By returning a local variable and saving it into a global variable we can use the result outside the function, in the global namespace." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Imports\n", - "\n", - "### Libraries\n", - "A quick overview of imports of libraries in Python, here shown for the math library:\n", - "\n", - "---\n", - "~~~python\n", - "import math # Lets you access everything in the math library by dot-notation (e.g math.pi) \n", - "from math import pi # Lets you use pi directly\n", - "from math import * # Lets you use everything in the math library directly \n", - "~~~\n", - "The last one is not considered good practice, since variables will be untraceable. It can be good for making quick tests though.\n", - "\n", - "### Your own modules\n", - "You can also import your own `.py` files this way and access the functions inside them. It is easiest if the file to import is located in the same folder as the `.py` file you want to import to. \n", - "\n", - "An example:\n", - "\n", - "~~~python\n", - "import my_module # my_module could be your own python file located in same directory\n", - "~~~\n", - "If you have a function inside `my_module` called `my_func`, you can now call it as `my_module.my_func()`.\n", - "\n", - "> Python files that are meant to be executed directly are called **scripts** and files that are imported into other files are called **modules**." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 1\n", - "Finish the function below that takes a radius `r` as input and make it return the circle area.\n", - "\n", - "~~~python\n", - "def circle_area(r):\n", - " '''Return circle area'''\n", - " # Your code goes here\n", - "~~~\n", - "\n", - "Try to call it to see if it works. If you want to access `pi` to avoid typing it out yourself, put the line `from math import pi` at some point before calling the `circle_area` function.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 2\n", - "Write a function that takes a list `radii` as input and returns a list of the corresponding circle areas. Try to set it up from scratch and test it.\n", - "\n", - "You can use the function from the previous exercise if you want." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 3\n", - "Write the function described in the docstring below.\n", - "\n", - "~~~Python\n", - "def is_pile_long(pile_lengths):\n", - " ''' Return a list with elements `True` for all piles longer than or equal to 5m, `False` otherwise.\n", - " \n", - " Args:\n", - " pile_lengths: A list containing pile lengths \n", - " \n", - " Example: \n", - " is_pile_long([4.51, 6.12, 4.15, 7.31, 5.01, 4.99, 5.00])\n", - " ---> [False, True, False, True, True, False, True] \n", - " '''\n", - " # Your code goes here\n", - " \n", - "~~~" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 4\n", - "Finish the function below so it does as described in the docstring. Remember to import the `sqrt` function from the math module.\n", - "\n", - "---\n", - "~~~python\n", - "def dist_point_to_line(x, y, x1, y1, x2, y2):\n", - " '''Return distance between a point and a line defined by two points.\n", - " \n", - " Args:\n", - " x : x-coordinate of point \n", - " y : y-coordinate of point\n", - " x1 : x-coordinate of point 1 defining the line\n", - " y1 : y-coordinate of point 1 defining the line\n", - " x2 : x-coordinate of point 2 defining the line\n", - " y2 : y-coordinate of point 2 defining the line\n", - " \n", - " Returns:\n", - " The distance between the point and the line \n", - " '''\n", - " # Your code goes here\n", - "~~~\n", - "---\n", - "The distance between a point $(x, y)$ and a line passing through points $(x_1, y_1)$ and $(x_2, y_2)$ can be found as\n", - "\n", - "\\begin{equation*}\n", - "\\textrm{ distance}(P_1, P_2, (x, y)) = \\frac{|(y_2-y_1)x - (x_2-x_1)y + x_2 y_1 - y_2 x_1|}{\\sqrt{ (x_2-x_1)^2 + (y_2-y_1)^2 }}\n", - "\\end{equation*}\n", - "\n", - "Use `abs()` to get the numeric value.\n", - "\n", - "Call the function to test if it works. Some examples to test against:\n", - "\n", - "~~~python\n", - "dist_point_to_line(2, 1, 5, 5, 1, 6) --> 4.61 \n", - "dist_point_to_line(1.4, 5.2, 10.1, 2.24, 34.142, 13.51) --> 6.37 \n", - "~~~\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 5\n", - "Given a line defined by two points $(x_1, y_1)=(2, 3)$ and $(x_2, y_2)=(8, 7)$, compute the distance to the points with coordinates `x_coords` and `y_coords` below.\n", - "\n", - "Put the results into a list.\n", - "\n", - "~~~python\n", - "# x- and y-coordinates of points\n", - "x_coords = [4.1, 22.2, 7.7, 62.2, 7.8, 1.1]\n", - "y_coords = [0.3, 51.2, 3.5, 12.6, 2.7, 9.8]\n", - "~~~\n", - "\n", - "You can either use a list comprehension or create a traditional `for`-loop where results get appended to the list in every loop.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 6\n", - "Create a function that calculates the area of a simple (non-self-intersecting) polygon by using the so-called **Shoelace Formula**\n", - "\n", - "$$ A_p = \\frac{1}{2} \\sum_{i=0}^{n-1} (x_i y_{i+1} - x_{i+1} y_i) $$\n", - "\n", - "The area is **signed** depending on the ordering of the polygon being clockwise or counter-clockwise. The numerical value of the formula will always be equal to the actual area.\n", - "\n", - "The function should take three input parameters:\n", - "\n", - "* `xv` - list of x-coordinates of all vertices\n", - "* `yv` - list of y-coordinates of all vertices\n", - "* `signed` - boolean value that dictates whether the function returns the signed area or the actual area. Default should be actual area.\n", - "\n", - "Assume that the polygon is closed, i.e. the first and last elements of `xv` are identical and the same is true for `yv`.\n", - "\n", - "A function call with these input coordinates should return `12.0`: \n", - "~~~python \n", - "x = [3, 4, 7, 8, 8.5, 3]\n", - "y = [5, 3, 0, 1, 3, 5]\n", - "~~~\n", - "\n", - "Source: https://en.wikipedia.org/wiki/Polygon#Area" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 7\n", - "Write a function that calculates and returns the centroid $(C_x, C_y)$ of a polygon by using the formula:\n", - "\n", - "$$ C_x = \\frac{1}{6A} \\sum_{i=0}^{n-1} (x_i+x_{i+1}) (x_i y_{i+1} - x_{i+1} y_i) $$\n", - "\n", - "$$ C_y = \\frac{1}{6A} \\sum_{i=0}^{n-1} (y_i+y_{i+1}) (x_i y_{i+1} - x_{i+1} y_i) $$\n", - "\n", - "`x` and `y` are lists of coordinates of a closed simple polygon.\n", - "\n", - "Here, $A$ is the **signed** area. When you need $A$, call the function from the previous exercise to get it. Be sure to call it with the non-default `signed=True`. \n", - "\n", - "A function call with the input coordinates below should return (`6.083`, `2.583`):\n", - "~~~python\n", - "x = [3, 4, 7, 8, 8.5, 3]\n", - "y = [5, 3, 0, 1, 3, 5]\n", - "~~~\n", - "\n", - "Source: https://en.wikipedia.org/wiki/Centroid#Of_a_polygon" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# If you are up for more\n", - "Try to write a function that can calculate the elastic centroid of a section with materials of two different stiffness values. E.g. a reinforced concrete section with polygon shape." - ] } ], "metadata": { @@ -866,7 +875,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.1" + "version": "3.7.4" }, "latex_envs": { "LaTeX_envs_menu_present": true, diff --git a/Session 4 - Plotting/Session 4 - Exercise Solutions.ipynb b/Session 4 - Plotting/Session 4 - Exercise Solutions.ipynb index 4d2e03e..b9d2d1c 100644 --- a/Session 4 - Plotting/Session 4 - Exercise Solutions.ipynb +++ b/Session 4 - Plotting/Session 4 - Exercise Solutions.ipynb @@ -1,9 +1,492 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 4. Exercise solutions" + ] + }, { "cell_type": "code", "execution_count": 1, "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 1.1 - 1-5" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAEhCAYAAAB89xvjAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOydd1hUx9eA32HpFhApBpViLzRFLLFhCSqWxMSaGKNJ1OAvapqmJ0Zjem8aTYxJNPZoPjVqYo+KGin2rtgFLEiHBeb74y4ElYVd2IJy3+fZB3bvzJlz7+6enXvmzDlCSomKioqKyr2PjbUVUFFRUVGxDKrBV1FRUakiqAZfRUVFpYqgGnwVFRWVKoJq8FVUVFSqCKrBV1FRUakiqAZfRUVFpYqgGnwVFRWVKoKttRVQUVFRsTZCiLt6B6qUUhjSTqg7bVVUVKoyQogGQAsp5Wpr62JuVJeOiopKVacnsNHaSlgC1eCrqKhUdZyllFnWVsISqAZfRUWlyiKEcAVuWFsPS6EafBUVlapML2C9oY2FEB2EENFCiK1CiIVCCDsz6mbyMe85gy+EOCSECC/leIIQoue9Or6xCCHmCSHetbYelqSs96gCcpsKIeKEEGlCiImmll9snEr1GbrLqSOlvGJE+7NAdyllV+A08KAplBBCnBdCtDb3mHddWKYQIr3YU2cgB8jXPR8npWxZrG0C8LSUcoOl9Cs+vrV0UPmPkq7/7e+RCZkCbJFStjKTfBUTIoSwBXKN6SOlvFTsaR5QYAI9XAFv4Ki5x7zrZvhSyuqFD+Ac0L/YawusrZ850X1AVSovvsAhYzup76v5EULYCCHeEkK8VezlLsA/5ZTnD/QBSg3lFEJMFUJMLUNcIHBOSplpijFL464z+GVReLsrhPgV8AFWCSHShRBTSmjrLYRYLoRIFkKc0XcbLoQYLYRYVez5SSHEkmLPzwshQoqPr/tfnw4hQoj9QoibQojFQgjHMs7nZSHEfiBDCGErhHhFCHFK5zo4LIQYeFv7l/TJF0K0EkLE6vouBoofay6E2CKESNG5PQaUoMtknewMIcSPQggvIcRanbwNQohaes5D77W+XSchxKLibiYhhBRCNCr2fN5tx0u8Hvqu/23vkd5zLuta3nZ+m4BuwDe6sZoYIPuW97UEmS8LIS7qzuuYEKJHscN6P0P6xjXyc1xfCPG77v26JoT4pqzrXZrOpb3/+hBCDBdCxOjO8ZSouBvuWxSffSEBUsqDJYzrKYT4PyFEohAiVQixSghRs9jxmsDPwONSSqPuEPQQCBwTQnwmhLghhDghhOh0m06mGVNKedc+gASgp77XSjuO8mMXA7wF2AMNUPxjvUoYpwGQoutzH4pP7WKxYzcAm5LG1PN8D8otnBtwBHimjHOMB+oDTrrXBuv62wBDgQzgvrLk687zLPA8YAcMArTAu7rnJ4HXdO26A2lA09t02QV4AXWBJCAWaAU4AJuAt0s4B73XujSdivWXQKNiz+fddrys66HvM1DqOZfjvdqC4j7CQNm3vK+3yWoKnAe8dc/9gIYGvMd6x8XAzzGgAfYBnwPVUCYFncq63vp0Lu39L+Vavohyt9Ra1z8Q8Ct2fLXuXEp6rC5F7krAV/f/RD1tGgEPoHym3YBoYLLumC2wBsWnboiNmgpMLaPNLN21f0j3/r0NHCl23KgxS3vcczN8IwgDPKSU06SUuVLK08AcYNjtDXXH0oAQoCvKqv5FIUQz3fN/pJTG+NW+klJeklJeB1bp5JbV/rzUxQpLKZfq+hdIKRcDJ4C2Bshvj/KB+kJKqZVSLgP+LXasOvCB7npsQvlSDb9Nl6+llIlSyosot8O7pZRxUsocYAWK8b+d0q51aToZhAHXQx+GnLOx75Wxsove19vIRzE4LYQQdlLKBCnlKQP00juuEZ/jtigGfbKUMkNKmS2l3F44cCnXW5/OBn/XAIQQHihG71EpZaxunANSyoRiOvSTUrrqefTT/7bwf8CDQoiW6HG/SSlPSin/llLm6K7v30DhnetwoB3wlu4uamgpYxlKIPC5lHKllFIL/AA0LXbXZ7Ixq7Lv0BfwFkKkFHtNg36f3lYgHOXXfyvKTKIr0EH33BiKRwVkony5SuN88SdCiJHACygzKFC+4O4GyPdGmdEVz6dxttix87f9cJ1FmckXJ7HY/1klPK9egv6lXevSdDIIA66HPgw5Z2PfK2Nkn0cPUsqTQojnUGaILYUQ64EX5H8LeKW9x6WNa8jnuD5wVkqZV5Ju+q63Pp0x/rvWEzggpdyn53hFWA0sQFms/bGkBkKIwcBzQGOUOxJnYCyAlPJX4NfSBhBCrAYKXTKOutee0z3fXsIPUgAwpthzd+Bm4fU3ZExDuddn+KUlCjoPnLltZlBDShmpp33hF6Wz7v+tKF+UrpRu8E2RrKhIhhDCF2V29CxQW0rpChwEDEmedBmoK4Qo3tZH9/cSUF8IYXPbsYsVUVxHade6NJ0KyUT50hVSp/AfA65HadffnOdsiOxSPxtSyt+klJ1QDKYEPjTBuIZ8js8DPnrWFUq93np0Nva75obyQ6QXoawbpet5rNXXT0qZhGLEa+tm07fL7a7T+TmUH093FNdlfGn63DZG0d0H8AHK3VaJdx+661kTSC728sNUYGG2NO51g5+I4i8siT1Aqm6RyUkIoRFCBAghwvS034qyKOckpbyAMjvpDdQG4sqpQ3mohvJFSgZlIQ5lhmAI0ShhXROFsvj7MP+5Pnaj+GKnCCHsdAtk/YFFJtC5tGtdmk6FxAOP6vr1RjFOhZR1PUq7/uY85wrJFkpMf3chhAOQjXL3lF9GN0PGNeRzvAflh/gDIUQ1IYSjEKKj7pje612KzsZ+1+KATkKIYKHQWAjRvHgDKWUfWSxi77ZHnzKu0Z8oawglEYzyA3UUxY0zF/AEDpchs7wEonz+HxVKJFEkMA6YZo7B7nWD/z7whlCiFV4qfkBKmY/yRQgBzgBXUXxnLiUJklIeB9LR3YZKKVNRPjQ7dLKM1qE8SCkPA5+iGMpElA/MDgP75qLMHkahLBINBX4vdmwAStjXVeA7YKSUssTYYCN11nutS9OpGJN0/VOAx1AW3gpll3U9SvsMmPOcKyrbAWV2eBXFfeOJshBboXEN+RwXe78aoYQ+X0B5X8q63iXqXI7v2k6UQILVKGsOKwCnss7dCH5E8eWXxAKUNaUruvFPAIelaaJxSiIQ+AXoiPL5nwo8KKU8YY7B1PTIKpUOIcQ84IKU8g1r66Kici9xr8/wVVRUVFR0qAZfRUVFpYqgunRUVFRUqgjqDF9FRUWliqAafBUVFZUqQqXeaevu7i79/PysrYaKiorKXUNMTMxVKaVHSccqtcH38/Nj79691lZDRUVF5a5BCKE3NYnq0lFRUVGpIqgGX0VFRaWKoBp8FRUVlSpCpfbhq6ioWAetVsuFCxfIzs62tioqenB0dKRevXrY2dkZ3Ec1+CoqKndw4cIFatSogZ+fH7dmrlapDEgpuXbtGhcuXMDf39/gfhZ16QghJgkhDgqlzuZzZfdQUVGxBtnZ2dSuXVs19pUUIQS1a9c2+g7MYgZfCFFY1aUtSs7pfkKIxpYaX0VFxThUY1+5Kc/7Y8kZfnNgl5QyU1e6ayswsIw+RpOtzWfOttPsPHXV1KJVVFRU7mosafAPAl2EELWFEM5AJErtzFsQQowVQuwVQuxNTk6+Q0hZaGwEc/45zext+graqKio3A1cuHCBBx98kMaNG9OwYUMmTZpEbm7JdUguXbrEoEGDypQZGRlJSkqp1RP1MnXqVD755JNy9a0sWMzgSymPoNSK/BtYB+xDKe11e7vZUso2Uso2Hh4l7g4uFTuNDcPa+rD1eDLnr2dWVG0VFRUrIKXk4Ycf5qGHHuLEiRMcP36c9PR0Xn/99Tva5uXl4e3tzbJly8qU++eff+Lq6moOlctFXl6JdeLNhkUXbaWUP0opW0spuwDXUcqHmZzhbetjIwQLdp8zh3gVFZUSiI6O5v333yc6OrrCsjZt2oSjoyOjR48GQKPR8PnnnzN37lwyMzOZN28egwcPpn///kRERJCQkEBAgFLKODMzkyFDhhAUFMTQoUNp165dUYoWPz8/rl69SkJCAs2bN2fMmDG0bNmSiIgIsrKyAJgzZw5hYWEEBwfzyCOPkJlZ+sQxMTGRgQMHEhwcTHBwMDt37rxFH4BPPvmEqVOnAhAeHs5rr71G165dmTFjBn5+fhQUFBTpXr9+fbRaLadOnaJ3796EhobSuXNnjh6tcOVNy4ZlCiE8pZRJQggflDqmHcwxzn0uTvRo5smSved5/oHGONhqzDGMikqV4LnnniM+Pr7UNjdv3mT//v0UFBRgY2NDUFAQLi4llqwFICQkhC+++ELv8UOHDhEaGnrLazVr1sTHx4eTJ08Cyg/M/v37cXNzIyEhoajdd999R61atdi/fz8HDx4kJCSkxDFOnDjBwoULmTNnDkOGDGH58uWMGDGChx9+mDFjxgDwxhtv8OOPPzJhwgS9uk6cOJGuXbuyYsUK8vPzSU9P58aNG3rbA6SkpLB161YAYmNj2bp1K926dWPVqlX06tULOzs7xo4dy6xZs2jcuDG7d+9m/PjxbNq0qVS5ZWHpOPzlQojagBb4n5Sy9KtSAUa09+Wvw4msO3iFB0PqmmsYFRUVFINfOEstKCjg5s2bpRr8spBSlhiFUvz1Bx54ADc3tzvabN++nUmTJgEQEBBAUFBQiWP4+/sX/RiEhoYW/WgcPHiQN954g5SUFNLT0+nVq1epum7atIlffvkFUO5EXFxcyjT4Q4cOveX/xYsX061bNxYtWsT48eNJT09n586dDB48uKhdTk5OqTINwaIGX0rZ2VJjdWrkjm9tZ+bvOqsafBWVClDaTLyQ6OhoevToQW5uLvb29ixYsIAOHcp/A9+yZUuWL19+y2upqamcP3+ehg0bEhMTQ7Vq1Ursa2gVPwcHh6L/NRpNkUtn1KhRrFy5kuDgYObNm8eWLVuM1t/W1rboBxC4I16+uO4DBgzg1Vdf5fr168TExNC9e3cyMjJwdXUt887KWO7ZXDo2NoLH2vnwb8INjl5JtbY6Kir3NB06dGDjxo1Mnz6djRs3VsjYA/To0YPMzMyimXN+fj4vvvgio0aNwtnZudS+nTp1YsmSJQAcPnyYAwcOGDV2Wloa9913H1qtlgULFhik68yZM4v0TE1NxcvLi6SkJK5du0ZOTg6rV6/W27969eq0bduWSZMm0a9fPzQaDTVr1sTf35+lS5cCyo/Yvn37jDqPkrhnDT7A4ND62NvaMH+X3vTQKioqJqJDhw68+uqrFTb2oGwqWrFiBUuXLqVx48Y0adIER0dH3nvvvTL7jh8/nuTkZIKCgvjwww/LXE+4nenTp9OuXTseeOABmjVrVmb7L7/8ks2bNxMYGEhoaCiHDh3Czs6Ot956i3bt2tGvX78y5QwdOpT58+ff4upZsGABP/74I8HBwbRs2ZI//vjD4HPQR6UuYt6mTRtZ0QIoLyyJZ/3BK+x+vSfVHdTUQSoqhnDkyBGaN29ubTXKRX5+PlqtFkdHR06dOkWPHj04fvw49vb21lbN5JT0PgkhYqSUbUpqf89bwBHtffk99iIr4y4yor2vtdVRUVExM5mZmXTr1g2tVouUkpkzZ96Txr483PMGv1V9V1rcV5P5u87yWDsfNT+Iiso9To0aNdTSqHq4p334oPgCR7T35eiVNGLPmS0KVEVFRaXSc88bfIAHQ7yp7mDL/F3qzlsVFZWqS5Uw+NUcbHm4dV3W7L/M9YySky+pqKio3OtUCYMPyuJtbn4BS/eet7YqKioqKlahyhj8Jl41aOvnxoLd5ygoqLyhqCoqKgozZsygZcuWBAUFERISwu7duy2uw5YtW+jXr5/FxzUX93yUTnFGdPBl4sI4tp1IJrypp7XVUVFR0UN0dDSrV68mNjYWBwcHrl69qjcX/t1GXl4etrbWMb1VZoYP0LtlHdyr26uLtyoqlZzLly/j7u5elO/G3d0db29vAGJiYujatSuhoaH06tWLy5cvA3Dy5El69uxJcHAwrVu35tSpU0gpmTx5MgEBAQQGBrJ48WJAmbmHh4czaNAgmjVrxmOPPVaUg2fdunU0a9aMTp068fvvv5eoX35+Pi+99BKBgYEEBQXx9ddfA/+lXwbYu3cv4eHhgFI8ZezYsURERDBy5EjatWvHoUOHiuSFh4cTExNDRkYGTz75JGFhYbRq1coku2uLU6Vm+Pa2NgxpU59ZW09xMSWLuq5O1lZJRaXS886qQxy+ZNp8VC28a/J2/5Z6j0dERDBt2jSaNGlCz549GTp0KF27dkWr1TJhwgT++OMPPDw8WLx4Ma+//jpz587lscce45VXXmHgwIFkZ2dTUFDA77//Tnx8PPv27ePq1auEhYXRpUsXAOLi4jh06BDe3t507NiRHTt20KZNG8aMGcOmTZto1KjRLakOijN79mzOnDlDXFwctra2XL9+vcxzjomJYfv27Tg5OfH555+zZMkS3nnnHS5fvsylS5cIDQ3ltddeo3v37sydO5eUlBTatm1Lz5499SaKM5YqNcMHGN7WBwks2qPO8lVUKivVq1cnJiaG2bNn4+HhwdChQ5k3bx7Hjh3j4MGDPPDAA4SEhPDuu+9y4cIF0tLSuHjxIgMHKmWyHR0dcXZ2Zvv27QwfPhyNRoOXlxddu3bl33//BaBt27bUq1cPGxsbQkJCSEhI4OjRo/j7+9O4cWNlD8+IESXqt2HDBp555pki10xJaZpvZ8CAATg5KZPMIUOGFCVGW7JkSVEa5L/++osPPviAkJAQwsPDyc7O5tw509mqKjXDB6jv5ky3pp4s+vc8E3s0xk5T5X7zVFSMorSZuDnRaDSEh4cTHh5OYGAgP//8M6GhobRs2fKOqlqpqSXfgZSWK+z29MiF5QYN2Y2vL19/8bTIpaVErlu3LrVr12b//v0sXryY77//vkju8uXLadq0aZk6lIcqae1GtPchOS2Hvw4lWlsVFRWVEjh27BgnTvxXATU+Ph5fX1+aNm1KcnJykcHXarUcOnSImjVrUq9ePVauXAkoxUIyMzPp0qULixcvJj8/n+TkZLZt20bbtm31jtusWTPOnDnDqVOnAFi4cGGJ7SIiIpg1a1bRj0ShS8fPz4+YmBiAO/L5386wYcP46KOPuHnzJoGBgQD06tWLr7/+uuiHKi4urvQLZSQWNfhCiOeFEIeEEAeFEAuFEI6WHL+Qrk08qevqpKZNVlGppKSnp/PEE0/QokULgoKCOHz4MFOnTsXe3p5ly5bx8ssvExwcTEhICDt37gTg119/5auvviIoKIj777+fK1euMHDgQIKCgggODqZ79+589NFH1KlTR++4jo6OzJ49m759+9KpUyd8fUtOuPj000/j4+NTJPu3334D4O2332bSpEl07twZjab00qqDBg1i0aJFDBkypOi1N998E61WS1BQEAEBAbz55pvGXrpSsVh6ZCFEXWA70EJKmSWEWAL8KaWcp6+PKdIj6+PbzSf5eP0xNrzQlUae1c0yhorK3crdnB75nkBKMMC1ZGx6ZEu7dGwBJyGELeAMXLLw+EUMDauPnUawYLflZ/knb5zkhS0vkKnNtPjYKioqlRQpITsVbpyFa6fMMoTFDL6U8iLwCXAOuAzclFL+dXs7IcRYIcReIcTe5ORks+njXt2BPgH3sSzmApm5eWYbpyRWn17N32f/ZuO5jRYdV0VFpZIhJeSkw83zkHgQrp+C7BTQ2IEsKLu/kVjM4AshagEPAv6AN1BNCHFHzJOUcraUso2Uso2Hh4dZdRrR3pe07DxW7bPsjUZckrIQ8+eZPy06roqKSiVAStBmQupFSDoM105AxjWwrwa1/MErEGr5gjC9ebakS6cncEZKmSyl1AK/A/dbcPw7CPOrRROv6hbdeZuTn8OBqwdw1DgSfSmaa1nXLDa2ioqKFcnLhrQrkHwUko9BehLYOoCrD9QJBLcG4OQKNuYzy5Y0+OeA9kIIZ6EEsPYAjlhw/DsoLI5y4OJN9p1PsciYh68dRlug5enAp8mX+fx19g6vloqKyr1Cfq5i2JOPQdIRSLsMNhpwqQdeAVC7ETjXVl6zAJb04e8GlgGxwAHd2LMtNb4+Braqi7O9xmIhmrGJsQAMbjqYxrUa8+dp1a2jonJPkZ8HGVfh6glIPKS4bpBQ0xs8W4J7E6jmofjpLYxFo3SklG9LKZtJKQOklI9LKXMsOX5J1HC048GQuqzaf4mbmVqzjxeXFIdfTT/cHN2I9I8kPjmeC2kXzD6uisrdxLVr1wgJCSEkJIQ6depQt25dQkJCcHV1pUWLFiX2eeutt9iwYUOZshMSEggICDCtwgX5kHldia5JPKgswuZroUYd8GgOHs2guhfYWreYepXcaXs7I9r7kK0tYFmseQ1vgSwgLimO1l6tAejj3weAdQnrzDquisrdRu3atYmPjyc+Pp5nnnmG559/vui5jR4f97Rp0+jZs+cdr+fn55tHSVkAWSlw/Qx5F+Ih5Sxos5TZu3tT8GwONe4DO6vsLy0R1eADLb1daOXjyoJdZ0vNvVFRTqecJjU3ldaeisGvW70urTxbseb0GrONqaJyr5Gfn8+YMWNo2bIlERERZGVlATBq1CiWLVsGKCkOpk2bRqdOnVi6dCkxMTEEBwfToUMHvv32W72yP/roIwIDAwkODuaVV14BlNTFhRtAryYn4+frCzfOMu/LGQwePJj+w0YRMWIiQye9y58xZ8GlLtg7M2r0aJYvX05+fj6TJ08mLCyMoKCgorw51qDKJU/Tx4h2vry4dB87T12jYyN3s4wRm6T47wsNPkCkfyQzds/g+I3jNKnVxCzjqqhUiLWvwJUDppVZJxD6fFCuridOnGDhwoXMmTOHIUOGsHz58hKzWjo6OrJ9+3aAopz1Xbt2ZfLkySXKXbt2LStXrmT37t04OzvfmvI4N1Nx0ySdgQKtEitv50R03GH279+HW213VqxYweIlS4js25fc3Fw2btzIzJkz+fHHH3FxceHff/8lJyeHjh07EhERgb+/f7nOvyKoM3wdfYPuw9XZzqyLt3FJcbg7uVOvRr2i1yL8ItAIjbp4q6JiIP7+/oSEhAAQGhpKQkJCie0Kc9nfvHmTlJQUunbtCsDjjz9eYvsNGzYwevRonJ2dQUrcajhB6iXIzVCMfcY1sHcGG1slVr6aOw9EROBWW5kg9unTh02bNpGTk8PatWvp0qULTk5O/PXXX/zyyy+EhITQrl07rl27dktiOEuizvB1ONppGNKmPj9uP0NiajZeNU3vd4tLiqOVZ6tb0qq6ObrRwbsDa8+sZWLridiYYbOFikqFKOdM3Fzcnta40KVzO4XpiPWlMr4dKSWiIE+Jlc+6ocTNA7Z29hRU84Q6gWRfuqxsiNKtIxRPeezo6Eh4eDjr169n8eLFDB8+vEju119/Ta9evcp3wiZEtS7FeLStD/kFkkV7zptc9pWMK1xMv3iLO6eQSP9ILmVcYl/yPpOPq6JS1XF1dcXFxaXIvbNgwYJbG+hi5SPatWDunFlkJp0GGw3X86uBVwB+jZsTc+gk2GiK1gj0MWzYMH766Sf++eefIgPfq1cvZs6ciVarRAEeP36cjIwM05+oAagGvxh+7tXo3NidhXvOkZdv2jwW8UnxALTyanXHse4+3XHUOKqLtyoqZuKnn37if//7Hx06dCiqOnV7rHzvbp0Y0L8/bfo/RUjPIXwycx5o7HjppZeYOXMm999/f1G9Wn1ERESwbds2evbsib29EoL59NNP06JFC1q3bk1AQADjxo0ryqNvaSyWHrk8mDM9sj7WH7rCuF9j+P7xUHq11J8321hm7JrBH6f+YOfwndja3OlJm7J1Crsu72LjkI3Y2Vh+Q4aKSnHuyfTIBfmQfVNx1+SkARI0DuBUS3lUovBJQ6ns6ZErPT2aeXKfi6PJF2/jkuII9ggu0dgDRDaI5EbODaIvRZd4XEVFpRwUi5XnysGSY+VrVq5YeXOiGvzbsNXYMCzMh39OXCXhqmn8bGm5aRy/cbxE/30hHb07UtO+pppBU0WlohTmlU85qxj5G2eUGb2zG9RuDF4ti2LlDSkyci+hGvwSGNa2PhobwW97TJNFc1/yPiSyRP99IXYaOyL8Ith0bpNaGEVFxVik1IVPXvgvr3xWCji6gFtDqBMArvXBoXqVM/LFUQ1+CXjVdCSihRdL9p4nW1vxbdmxibFohIYg96BS20X6R5KVl8XWC1srPKaKSpVAm6XEyicdhqvHlYVY+2pQy++/vPKONc2SW/5uRL0KehjR3peUTC1r9l+usKy4pDiauTXD2c651HahXqF4Onuqm7BUVEojL0eJlU86ouSWT08sllc+QJdXvpZZ88rfrahXRA/3N6xNA49qzK9gzVttvpYDVw/QylO/O6cQG2FDpH8k2y9uJyXbMvn5VVTuCm7JK3+4lLzy6l7S0lANvh6EEDzWzpe4cykcunSz3HIOXz9MTn5OUYbMsoj0jyRP5vH3ub/LPaaKyr2ARqMhJCiAkIDmhAQFknDoX8VXX8G88l988QWZmf+tk1WvXt3UqldaLFnTtqkQIr7YI1UI8Zylxi8Pg1rXw9HOpkIlEOMSlfq1hszwAZq5NcPfxV9166hUTYrllXdydCB+3a/Eb1xOfPQW/Fr3AM+K5ZXPz8+/w+CbG2ttsioJS1a8OialDJFShgChQCawwlLjlwcXZzv6B3nzR/xF0rLLVxwlNikW35q+uDsZloFTCEGkfyQxiTFcybhSrjFVVO4qisfKJxaLlRfijlj57OxsRo8eTWBgIK1atWLz5s0AzJs3j2effbZIZL9+/diyZQugzODfeust2rVrx4wZM7h06RLdunWjW7duRe1ff/11goODad++PYmJiXeomJ6eXjRuUFAQy5cvL5JdyLJlyxg1ahSgpGp+4YUX6NatG5MnT8bPz4+UlP/ctI0aNSIxMZHk5GQeeeQRwsLCCAsLY8eOHSa7rCVhLYdXD+CUlNIsqSnXr1/PP//8Q9++fenQoYzicBwAACAASURBVEOFZI1o78vSmAusiLvIyA5+RvWVUhKXFEd4/XCj+vX178u38d+y9sxaRgeMNqpvZWXnzp1s2rSJHj16VPg9UbEsH+75kKPXj5pUZjO3prwc/D9l12tWCsh8EBpwclMWXO2rkZWVTUjb+wElQ+aKFSuKctkfOHCAo0ePEhERwfHjx0sdKyMjg4CAAKZNmwbA3Llz2bx5M+7u7kXH27dvz4wZM5gyZQpz5szhjTfeuEXG9OnTcXFx4cABJU30jRs3yjzH48ePs2HDBjQaDQUFBaxYsYLRo0eze/du/Pz88PLy4tFHH+X555+nU6dOnDt3jl69enHkiPlKfVvL4A8DFppD8IYNG+jduzdCCD777DM2btxYIQMTXN+VwLouzN91lsfb+xqUda+QM6lnSMlJKXXDVUnUr1mfIPcg/jzz5z1h8KOjo+natSt5eXm89957FX5PVO5iZL6u5us1uHZSCZd0dFWMvEP1W8InnZyciI+Pv6X79u3bmTBhAgDNmjXD19e3TIOv0Wh45JFH9B63t7enX79+gJJu+e+/71w/27BhA4sWLSp6XqtWrTJPdfDgwWg0SnHyoUOHMm3aNEaPHs2iRYuKUjdv2LCBw4cPF/VJTU0lLS2NGjVqlCm/PFjc4Ash7IEBwKt6jo8FxgL4+PgYLf/ff/8FlNl1bm4uW7ZsMcEs34eXlx/g34QbtPV3M7ifsf774kQ2iOSDPR9wKuUUDV0bGt2/MrF48eIiP2ZOTo5J3hMVy/Fy25crJkCbpZvJ31CibRBKbLxTLXBwMSp8Ul/uL1tbWwoK/kt4mJ2dXfS/o6NjkeEtCTs7u6KJnEajKdHnri/FcvHXio8Jt6ZO7tChAydPniQ5OZmVK1cW3UEUFBQQHR39X0I3M2ONKJ0+QKyU8k5HGSClnC2lbCOlbOPh4WG08PDw8KJ82RqNhvDw8IroCkD/YG9qONryq5H5dWKTYnFzdMO3pq/RY/by64WNsLnrUy0UFBQU+VlB+eIUFqJQuYcxU6x8ly5ditIbHz9+nHPnztG0aVP8/PyIj4+noKCA8+fPs2fPHr0yatSoQVpamlHjRkRE8M033xQ9L3TpeHl5ceTIkSKXjT6EEAwcOJAXXniB5s2bU7t27RLl3n5HY2qsYfCHYyZ3Dii/pBs3bqR27do0bdrUJDNJZ3tbHmldj3UHL5OclmNwv5IKnhiKu5M77eq048/Tf5q1zq65mTdvHvv37+e1117joYceMrgYhcpdSL72zlh5YdpY+fHjx5Ofn09gYCBDhw5l3rx5ODg40LFjR/z9/QkMDOSll16idWv9btSxY8fSp0+fWxZty+KNN97gxo0bBAQEEBwcXDSJ+eCDD+jXrx/du3fnvvvuK1XG0KFDmT9/fpE7B+Crr75i7969BAUF0aJFC2bNmmWwTuVCSmmxB+AMXANcDGkfGhoqy8unn34qAblv375yyyjOicQ06fvyavnNphMGtU/KSJIB8wLkvIPzyj3mihMrZMC8ALkvyTTnYGmSk5Olm5ub7Ny5s8zPz5dpaWmyRo0acsSIEdZWTaUMDh8+bFjDfK2U6clSJh+X8mKs8kg8ImXqFSm12eZVUqXE9wnYK/XYVIvO8KWUmVLK2lLK8u9kMpBRo0bh6OjIzJkzTSKvkWd1OjSozW+7z5FfUPaMu6SC5cbSw6cH9jb2d61b5+WXXyY1NZWZM2diY2ND9erVGTlyJEuWLCmzkIRKJaZYrDxXDir1XvO1UL0OeDRXYuVreCkuHJVKhcEGXwixQQgRbE5lTImbmxvDhg1j/vz5Rvvr9DGivS8XU7LYejypzLZxSXE4ahxpVrtZucerYV+DrvW7su7MOvIKKs/mDUP4559/mDt3Li+++CItW7Ysej0qKorc3Fx++uknK2qnYjSyALJuwvWEW2Plq2he+bsVY2b4U4DPhRA/CSFKd1ZVEqKiokhPT2f+/PkmkRfR0guPGg4G7byNTYwlyCOowtWrIv0juZZ9jT1X9C9CVTa0Wi1RUVH4+vry5ptv3nKsZcuWdO7cme+///6WqAqVyocsKFDyyKec0+WVPw05qcpia+1GVTqvfGVAlmNtz2CDL6WMlVJ2B1YD64QQbwshLBNLVE7CwsJo3bo13333nUkWPu00NgwLq8/mY0mcv65/a3aGNoNjN46VKxzzdjrX60x1u+p3VaqFzz//nEOHDvHNN9/cEppWSFRUFKdOnSox3lnFykgJF/bimHqGa6fikFdPKOGUjjWVyJo6AUqkjUMN1chbESkl165dw9HRuDsqo5bLhRJecQyYCbwLjBFCvCql/NWoUS2EEIKoqCjGjBnDjh076NSpU4VlDm/rw7ebT7Jwzzmm9C7ZXbMveR8FsqBC/vtCHDQO9PTtyd9n/+aNvDdwtK3ct8wJCQlMnTqVhx56qGgzy+08/PDDeHh4MHPmTHr16mVhDVVKJPEwHFwGB5fDjQTqOXlyoeMHJNf0A1tbEFlAlrW1VCmGo6Mj9erVM6qPwQZfCLEdaAAcAnYBo4CjwCQhRGcp5VijRrYQw4cPL6o6bwqD7+3qRPdmXiz+9zyTejbGwfbODR1xSXHYCBuCPEoveGIofRv0ZeXJlWy7sI0IvwiTyDQXEydOxMbGhi+//FJvGwcHB5566ik++ugjzp8/T/369S2ooUoRNxLggM7IJx1Wdrk2CIcuU7Br3g9/RxcrK6hiaozx4T8D1JVSPiClfFNKuVpKeVJKOQHobCb9Kky1atUYOXIky5YtIzk52SQyR7T34VpGLusOlpzcLC4xjqa1mlLd3jRpV8O8wnB3cq/00Tp//PEHq1at4p133ilzl/S4ceOQUjJnzhwLaacCKJuhds2EOT3gy2DYNF1xz0R+Ai8eh8dXQKvHlNKAKvccxvjwD0r9jvC+JtLHLDzzzDPk5uYyd+5ck8jr0tgDHzdnFpSweKst0LL/6n6T+O8L0dho6O3Xm20XtpGam2oyuaYkPT2dCRMmEBgYyMSJE8ts7+fnR58+fZgzZw5abfkykaoYSNYNiP0Ffh4AnzWHda8oO2F7ToXnDsBTf0HbMVDd+J3tKncXJonDl1KeNoUcc9GiRQu6du1qssgQGxvBo+182JNwnWNXbg35PHb9GFl5WaUWLC8PfRv0RVugZePZjSaVayreeecdzp8/z6xZs7CzMywyKSoqiitXrrBy5Uoza1cFyc1Q3DULh8PHjeH/Jijx8p1fgv/tgajt0Ol5ZQFWpcpQZSpeRUVFcebMGdavX28SeUPa1Mfe1oYFt5VAjE2s+IarkmhZuyU+NXxYc2aNSeWaggMHDvD5558zZswY7r//foP79enTB19fX5Ntjqvy5OXCsbWw7Cn4uBEsfwouxUO7cTBmM0yIhe6vg0dTa2uqYiWqjMEfOHAgXl5eJjMubtXs6Rt4H7/HXiQj579NUXFJcdSrXg9PZ0+TjFOIEILIBpHsubyH5EzTrEWYgoKCAp555hlq1arFBx98YFRfjUbDuHHj2Lx5M0ePmjbfepWhIB9Ob1Vm8J80hoXD4NRGCBoKo9bA84eg1wyo21oNo1Qp2+ALIdJ05QhTdf+nFfu/cjqUS8De3p6nn36aNWvWcPasaequjGjvQ3pOHn/EXwKU2NjYpFiD69caSx//Pkgk6xLWmUV+eZg7dy47d+7kk08+wc3N8NTRhTz11FPY2dmZP2nUvYQuVp61r8BnLeCXAXBgOTTpBY8uhZdOQP8vwK+T0dkoVe5tyvw0SClrSClr6h41ij2vIaWsaQklTcXYsUrk6OzZs00ir7VPLZrVqcH8XWeRUnIu7RzXs6+bdMG2OA1cGtDcrXml2YSVnJzMyy+/TNeuXRk5cmS5ZHh6evLII4/w888/W7TO6F1J0hHYOB2+CoEfesDeH6FeGxj0E0w+CQ/PhiYRRhf1Vqk6GJNLRwghRggh3tQ9ry+EaGs+1UyPj48Pffv25YcffiA3N7fC8oQQjGjvy+HLqcSdTzGb/744fRv05eC1g5xNNUt1SKOYMmUKqampfPfddxVKeRwVFUVKSsotFYVUdNxIgH8+he/uh+/aw/bPoJY/PPitMpMftgACHlbSG6iolIEx93vfAR2AR3XP04FvTa6RmYmKiiIpKanUYgXG8FCrulSz1zA/+ixxSXG4Orji7+JvEtkl0duvNwJh9Zj8bdu2MW/ePCZPnkyLFi0qJKtz5860bNlSXbwtJC0Rds2CH3oqsfIbpynl//p8DC8eg5ErodUIcHK1tqYqdxnGGPx2Usr/AdkAUsobgL1ZtDIjvXr1wt/f32TGpbqDLQNb12X1gcv8eyWGEM8Qsxb48KrmRVidMKsWRsnNzSUqKgo/P787ij2XByEEzzzzDHv37i0qUVnluCVWvhmsexm02bfGyrcbC9VNGwygUrUwxuBrhRAaQAIIITyAuy7doY2NDePGjWPr1q23FA+uCCPa+6KVN7mQfs6s7pxCIv0jSUhN4PB10+hvLJ999hmHDx/mm2++wdnZNK6Exx9/HGdn56o1y8/NVNIaLHwUPmlya6z8+N1qrLyKyTHG4H8FrAC8hBAzgO3Ae8YMJoRwFUIsE0IcFUIcEUJYpZL1k08+ib29vckiQ5rVqUkTX6WgR4iHeRZsi9PTtye2NrZWWbw9c+YM06ZN4+GHH6ZvX9NtsHZxceGxxx5j0aJFRfVC70nycuHYOlj+tBIrv+xJuBQLYWNgzKb/YuU9y19HQUVFH8akVliAkhP/PeAS8JCUcqmR430JrJNSNgOCgSNG9jcJHh4eDBo0iJ9//pmMjAyTyPSrm4QssOX6DfNvT3dxcKFz3c6sO7OO/IJ8s49XiJSSCRMmoNFoSk2OVl6ioqLIysri559/Nrlsq1KQD2e2wf9NhE+bwMKhcHIDBA2GJ1YrsfK934O6oWqsvIpZMSZKxxGIBHoC3YHeutcM7V8T6AL8CCClzJVSphinrumIiooiNTWVhQtNU089RR7HJteHxXsul904NxMSdijx1OUkskEkSVlJxCTGlFuGsaxcuZI1a9bwzjvvGJ2W1RBatWpF+/btmTVr1l1duL2IlPOw7lUlVv7n/kqqg0YPwKNLlERl/b8E/85gc2fGVZWqy9lrGfwRf9Esso1x6fwCtERx7XwDNAeMyYPfAEgGfhJCxAkhfhBC3FEdQwgxVgixVwix11TZLUuiY8eOBAYGmqQ4SqY2k2PXj9LCLZgNRxK5fLOUvOEF+bBsNMyLhMPlzyHTtV5XnG2dLRatk56ezsSJEwkODjYoOVp5iYqK4tixY2zevNlsY1iEfC0sGAz//nBrrPwjc5QNUrZ3XbyDipmRUrJwzzn6fPkP01cfJjPX9GVNjTH4TaWUT0kpN+seY4EmRvS3BVoDM6WUrYAM4JXbG0kpZ0sp20gp23h4mM89UlgcJS4ujj17KlY+8MDVA+TLfIYEdEECC/ec199407twfB0411Z2SmaXb7Oyk60TPXx68NfZv8jNr/iegrKYOnUqFy9eZNasWdjaGlU3xyiGDBmCm5vb3b94G/0tJB+BwT+rsfIqZZKclsOYX/by6u8HaOXjyv892wlne9N/z4wx+HFCiPaFT4QQ7YAdRvS/AFyQUu7WPV+G8gNgNUaMGEH16tUrbFxik2IRCHo2bEvXJh4s2nMObX4JAUwHlikbZ0JHwWNLIT0RNs8o97iRDSJJy01j+8Xt5VfeAPbt28cXX3zBmDFjaN++fdkdKoCjoyOjR49m5cqVXL5sgHusMpJyDrZ+CE37QrNIa2ujUsn5+3Aivb/YxrYTV3mrXwt+fbId3q7mqR5rSC6dA0KI/UA7YKcQIkEIkQBEo/jkDUJKeQU4L4QoTNXXA7BOXKGOGjVqMGLECBYvXsz169fLLScuMY7GtRpT074mI9r5kpSWw9+HE29tdDEG/vgf+NyvbKCpGwphT8Ge2UpGw3LQ7r52uDm6mdWtU5gczc3Njffff99s4xRn3Lhx5OXl8cMPP1hkPJOz9mXlb58PrauHSqUmPSePl5ftZ8wve6nj4siaCZ14spM/NjbmW7g3ZIbfD+gP9Ab8ga66hz/GFz6ZACzQ/YCEYGRYpzmIiooiOzubefPmlat/XkEe+5L3FcXfd2vmSV1XJ+bvKpb6IO0KLHoMqnnC0F//8992fxOc3WH184pv30jsbOyI8I1gy/ktZGhNE210Oz/88AO7du3i008/LVdytPLQuHFjHnjgAWbPnk1enun9mGbl6Bo49ieEvwKuaulGlZLZm3CdyC//YWnMecaHN2TF+I409qph9nENSZ52tvABpAJegG+xh8FIKeN1/vkgKeVDut26ViUoKIj777+fWbNmlas4yvEbx8nMyyzKkKmxEQxvW5+dp65xKjld2S256DHFVz98IVRz/6+zkyv0fl+Jw95bvmpcfRv0JSc/h43nTF8YJSkpiVdeeYXw8HBGjBhhcvmlERUVxYULF1i9erVFx60QOenw5xTwbAHtx1tbG5VKSG5eAR+vP8qQ76ORSBaP68CU3s2wt7VMVlNjwjKfBrYB64F3dH+nmkctyxIVFcWJEyfYtGmT0X3jkuIAbsmQOSSsPrY2ggXRZ2HVJLi4FwbOgjoBdwoIeAT8uypZENMS7zxeBsEewdStXtcsm7AmT55Menp6hZOjlYf+/ftTt27du2vxduuHkHoB+n2uZqxUuYMTiWkM/G4H324+xeDQ+qyd1IUwP8vcNRdizM/KJCAMOCul7Aa0QgmzvOsZNGgQtWvXLpdxiU2MxbuaN3Wq1Sl6zbOGI70D6uAcOxP2L4Lw16DFgJIFCAF9P4O8LPjrdaPHF0IQ6R/Jrsu7uJp11ej++tiyZQu//PILU6ZMoXnz5iaTayi2traMGTOGv/76i5MnT1p8fKNJPKRE5rR6HHzMu7CtcndRUCCZu/0Mfb/ezpWb2cx+PJQPBwVR3cF80W76MMbgZ0spswGEEA5SyqPAPVErzdHRkSeffJI//viDixcN3/AgpSQuKa7E+rXP1j/D83I+5++LgC6TSxfk3gg6vQAHlsIp4+PPI/0jyZf5/JXwl9F9S6IwOZq/vz+vv278j5CpGDNmDBqNhu+//95qOhhEQYGyDuPoAg9Ms7Y2KpWIyzezeHzubqatPkznRu6se64LES3rlN3RTBhj8C8IIVyBlcDfQog/UFIs3BOMGzeOgoICoyJDLqRfIDkr+c6EacnHabr9Oc5o/Hgxd5xhVYc6PQ9uDWDNi4rf3wga1WpEk1pNTBat88knn3D06FG++eYbnJzMEx5mCN7e3jz00EP89NNPZGcbd00sSvx8OL8bIt4FZ8veoqtUXv6Iv0ivz7cRdy6FDx4O5Icn2uBRw8GqOhmTS2eglDJFSjkVeBMlRcJD5lLM0jRs2JBevXoxe/ZstFqtQX0KC57cUuEq6wYsHIbQ2BN3/3fsuZjD/gsGZJCwc4TIT+D6KdhhfJ6aSP9I9iXv43xaKZu+DOD06dNMnz6dQYMGERlp/RjyqKgorl27xtKlxqZtshAZV+Hvt5Rw25BHy26vcs9zM1PLhIVxTFoUTyPP6vw5sTPD2vpYfB2sJMq1NCyl3Cql/D8ppfm3eFqQqKgoLl26xKpVqwxqH5cURw37GjR0bai8kJ8HS0crG2+GzqdXpzCc7DS3hmiWRqMeyiLuP5/CtVNG6d7Hvw8A686Uv96tlJJnn30WW1tbvvjii3LLMSXdu3enSZMmlXfx9u+3ICcN+n2mJj5TYfuJq/T6YhtrD1zmpYgmLBnXAT/3OzLIWA1jipgXL2Z+1xUxN4S+fftSv359g41LbFIsrTxbYSN0l/HvN+H0ZuXL79uBmo52PBjizf/tu8TNTMPuGuj1Htg6wJ8vGZVczbu6N609W7Pm9Jpy5wb6/fffWbt2LdOnT6du3brlkmFqCoujREdHs2/fPmurcysJOyB+Adw/ATwtv7CtUnnI1ubzzqpDjPhxN9UcNKwY35FnuzfGVlO5isgbU8S8eDHzu7KIeVloNBrGjh3Lhg0bOHHiRKltr2df58zNM/+5c2J/hV3fQbsoaP1fQe8R7X3J1hawPPaCYUrUqKNsyDq1CQ79bpT+kf6RnLp5iuM3jhvVDyAtLY1JkyYREhLCs88+a3R/c/LEE0/g6OhYuWb5ebmw5gVw8YEuU6ytjYoVOXjxJv2+3s5POxIYdb8fqyd0JrCei7XVKhFj4vCf1S3a3tM8/fTT2NrallkcJT5JSYfQ2rM1nNulRGk0CFcW7ooRUNeF4PquLNh91vCZd9hTcF+Iklo3+6bBukf4RWArbMu1ePv2229z6dIlsydHKw9ubm4MGzaM+fPnk5paSW4qo7+B5KMQ+bGaFK2Kkl8g+XbzSR76dgdp2Vp+ebItUwe0xMm+8qa7NuZ+ow6wVwixRAjRW1SGFQgzUKdOHQYOHMhPP/1EVpb+NMdxSXHY2djR0tYFFo9QttEP+gk0dxrLEe18OJWcQfTpa4YpYaNRNu+kJ8Emw5Or1XKsRQfvDqw9s5YCafiu4bi4OL788kvGjRtHu3btDO5nSaKiosjIyODXX43JyG0mbpyFrR9Bs37QtLe1tVGxAueuZTLk+2g+Xn+MXgF1WP9cF7o0MX/xo4piTJTOG0BjlOicUcAJIcR7QoiGZtLNakRFRXHjxg2WLFmit01sUiwBbs1xWDpKCaMcvkhvSF7/YG9cnOxYsOuc4UrUbQ1tx8C/c+BirMHd+jboy+WMy0U7gMuioKCAqKgo3N3dee89q6c20ktYWBitW7dm5syZ1i2OIiX8ORmEjZocrQoipWTxv+fo8+U2jiem8eWwEL4Z3gpX57ujvoFRKwpS+aZd0T3ygFrAMiHER2bQzWqEh4fTrFkzvT7jrLwsDl87TKuURLhyAAbNBQ/9e9Ac7TQMDq3H+kNXSEo1Ip68+xtQzcOo5Grd6nfDydbJ4FQLc+bMYffu3Xz66afUqlXLcN0sjBCC8ePHc+jQIbZvN2866FI5uhpOrIdur4KL6at+qVRerqbnMOaXGF5efoDg+q6sf64LD4bUrRThloZijA9/ohAiBvgIJQ9+oJQyCggFHjGTflahsDjK7t27iYu7c6Z88OpB8gryaH3hADzwDjSJKFPmY+19ySuQLP7XiDh5RxclaudyvMHJ1ZztnAmvH876s+vR5pceGZSYmMgrr7xCt27deOyxxwzXy0oMGzYMFxcX6y3e5qQrqY+9AqDdM9bRQcUq/H04kV6fb2PbiWTe7NeC+U+ZL2e9OTFmhu8OPCyl7CWlXCql1AJIKQtQUijfU4wcORJnZ+cSjUvcIaUObkijvnC/YeX+/N2r0amROwv3nCOvpOIo+gh4BBp0g43TlDTLBtDXvy83c24SfTm61HYvvfQSmZmZzJw5866YpVSrVo0nnniCZcuWkZSUZHkFtrwPqReV3EdqcrQqQXpOHq8sV3LWe9V0ZPWETjxl5pz15sQYH/5buhTJJR07YjqVKgeurq4MHz6cBQsWcPNmsUiZxEPEnlxDowINLgO+M2qzzYj2Ply6mc2mo0YYKyGg76eQlwPrXzOoy/3e9+Pi4MKa02v0ttm8eTPz589nypQpNG1696REeuaZZ9BqtcydW7500uXmykHYNRNaPwE+lXNhW8W0xJxVctYv3nueqPCGrPxfR5pYIGe9OalcuwIqGVFRUWRmZvLLL78oL2RcJX/hMPbZ29G6YR8lHYIR9GzuhVdNB+bvNmLxFqB2Q+j8AhxcrsTnl4GdRimMsvn8ZjK1mXccz8nJISoqigYNGvDaa4b9iFQWmjdvTnh4ON9//z35+cYXjSkXhcnRnFyh51TLjKliNQpz1g+eFU2BlCwZ14GXLZiz3pxY9Ax05REPCCHihRB7LTl2eQgNDSUsLEyJDMnLgSUjOZl9jXQbQat6HY2WZ6uxYViYD9uOJ3P2mpEVqjo+B24NDU6uFukfSVZeFlvOb7nj2Mcff8yxY8f49ttvrZocrbxERUWRkJDA+vXrLTNg3C9wYY+aHK0KcDIpjYdnKjnrB4XWY+2kzhbPWW9OjFm0FUKIEUKIt3TPfYQQbcsxZjcpZYiUsk05+lqcqKgojhw5wuW5I+HsDmLDlMXNOzJkGsjwtj5obAS/GTvLt3NUXDvXT8P2z8ts3tqrNV7OXndswjp16hQzZsxg8ODB9O59d8aQP/TQQ3h5efHdd9+Zf7D0ZPj7bfDtBMHDzT+eilUoKJD8tOMMfb/azqWUbGaNCOWjQcHUcLT8Wk10dDTvv/8+0dGlr8GVB2O2VH4HFADdgWlAGrAcpSjKPcvQoUM5+NPzeF9aBx2fI842Cy9nL+6rdl+55NVxcaRnc09+232Oc9fvdLeUTk2erN6dkK2fMv1MC5LtSw8LtC1ozbYLf/H0r1uxE9WRwI7t26nVbzLOD0QQNT+mXOdQXvzcq/HiA00qnF/E3t6ep59+mvfee4+EhAT8/PxMo2BJ/P0W5GaoydHuYS7fzGLy0v1sP3mV7s08+eCRQDxrGOeuNRU7d+4kPDycvLw8HB0d2bhxIx06dDCZfGMMfjspZWshRByAlPKGEMLY3QYS+EsIIYHvpZSzb28ghBgLjAXw8fExUrzpcU7cy0fdYM2JfELHjiVmx0hCPUMrFNUyPrwR569nKTVvjeQT8QQ/spuHLn3KK87TSjVCWk0w0mUtR9K2Uy2nEzdvpnJNa8d9TVtxKT0f0o0fv7wUSFh78ArZ2nze7t+ywvLGjh3L+++/z+zZs823YezMP7DvN6U4TSn7LFTuXlbtu8TrKw6gzZe8NzCQ4W3rWy1iLTk5mTFjxhSlZ8/NzWXLli0mNfhIKQ16ALsBDRCre+4BxBnaX9fHW/fXE9gHdCmtfWhoqLQq105L+YGvzP40WNawR776wasyYF6A/O3Ib9bVa/dsKd+uKeX+paU2KygokANWDJAj/xwpwd2avwAAIABJREFUb968Kb29vWWrVq2kVqu1kKK3Mm3VIen78mq5aM9Zk8gbMGCA9PT0lDk5OSaRdwvaHCm/DpPy8wApczJML1/FqqRk5MqJC2Ol78ur5UPfbpdnktOtqs+qVaukp6entLW1lXZ2dlKj0UgnJye5c+dOo2UBe6Uem2rMvfVXwArAUwgxA9gOGDW1klJe0v1N0skqzxqAZchJg4XDQUocnlhOWKfuLNmupFoor//eZLR5ErxbKWGaWfqLqwgh6NugL7FJsUyZPoXLly9bNTnaq32a0bmxO2+sPMjehOsVlhcVFUVSUhK//25cVlGDiP4arh6DyE/V5Gj3GDtOXqX3l9tYs/8yLz7QhKVWzFmfnp7OuHHj6N+/P3Xq1CEuLo6tW7cyffp0k7tzAMNn+MoPB82A/wHPAs2N7FsNqFHs/51A79L6WG2Gn58v5W/DpJxaS8pTm6WUUi5btkx6P+EtQ38OlXn5edbRqzgXY6Wc6irl6hdLbXYu9ZwMmBcgPSI95Pjx4y2knH5SMnJl+MebZej0v+SFG5kVkpWfny8bNGggu3TpYiLtdFw7LeV0TykXPWZauSpWJSs3T77zf8pdZrdPNst9529YVZ+dO3fKhg0bSiGEnDJliszOzjaJXEw0w0dKeVRK+a2U8htp/GYrL2C7EGIfsAdYI6Usf3kmc7J5Bhz7E3q/r6Q8BgYMGEDN5jURlwQam0qQ/tS7FbQdC//+ABf1L756O3sjrghqd6rNjBmGZ940Fy7OdswZ2YYcbQFjft5LZm5euWXZ2Ngwbtw4tm3bxqFDh0yjoJSwdgrY2EJvNTnavcLBizfp//V25u44wxMdfFkzoTNB9ayT7V2r1fLmm2/SqVMn8vLy2LJlCx9++CEODuavd2tMWKaDEOJRIcRrQoi3Ch+G9pdSnpZSBuseLaWU1rc+JXFwOfzziVLEpO3YopczCzKxrWPL2Z1nOXPmjBUVLEa316G6V6nJ1WbPns3FDRex9bblqrxqYQVLppFndb56tBVHr6Ty0tJ9Fcp+OXr0aOzt7cusX2AwR1bBib+g22vgUjmqfqmUn8Kc9QO/28HNLC0/P9mWdx4MsFrO+qNHj9KhQwfeffddRo4cyf79++nSpYvFxjdmhv8H8CBKlsyMYo97h0txsHI8+HRQfLfFVusLC55kn8zm+++/t5aGt+JYU7kLubxPmenfxpUrV3j11VcJcgjCRtiUqzCKuejW1JNX+zTnzwNX+HrTyXLL8fDwYPDgwfz888+kVzTqKCft/9s7z7AqjjYM30MRUEGwYG8UK6gIFuy9gJ8xxho10cSGpthiYkk0xiSaoiaxoIli1xhLYgR7L7EgKGpsKAYLiqggKv3M9+McFJTO4SzC3te1F7A7O/OIh3dnpzyvzhzNGRqPyF1dKooT+uAZfXWe9Z3qaD3rWyvkWa/RaJg/fz4uLi7cuHGDTZs24ePjg5WVgZMGpjfW8/IBnM9qWX0dBh3Df3xXyh9qSTmnrpTR4a9cnuM/RzZY2UB2f6u7LF26tN7G23KNRiPlyjel/LqilFF3Ul0aMGCALFKkiLx8+bIcvmu47Lyxs9RoNAoJfRWNRiPH/h4oq366TW4/F5bjeo4cOSIBuXjx4twJ2j5JymklpAw9mbt6VBRFo9HI30+Gyjqfb5dO03bILQG3FP3c37p1S3bq1EkC0sPDQ4aF5fyznhXQ0xj+MSGEc148dBQnMQ5+HwCxkdBvLRR/tRcQGB5InVJ1GD18NBEREWzatEkBoWkghDbNXlJ8KnO1vXv3smbNGj777DNq1KiBR3UPbj+5TVBEkIJiUyOE4Js3nWlQ2ZpxG85wMSxn6QubNWuGs7Nz7pKjhAXBCW9wHQyVC/RewgJNxJM4hq86zcRNQdSrZM2OMa3o4aKcZ/2GDRtwdnbmyJEjeHt7s23bNsqVK6eIFiDzHj5wDggC/gUSgMu6n88BQZndn5vDID18jUbKLV7ade0X/kyzSGxirHRZ6SJ/PPWjTEpKkvb29rJFixZ5ry07HJit/Tdc3S1jY2NljRo1pL29vYyJiZFSShkdFy0brmwovzn+jcJCX+VeVIxs8vUe2ezbvTIiOmdvTgsXLpSA/Oeff7J/c1KSlEvaSTnbTspnD3PUvory7L5wV7p+tUs6TvaTvx66JpOSlOvVP3r0SA4cOFACskmTJvLKlSsGa5tc9vC7Af8DugIOQCfdz8nnX2/+WQBn1kCbSVDnjTSLXIi4QIImARdbF4yMjBg5ciRHjhzh3LlzBhabAc0/hlIO4DuBObO/5sqVKyxcuBBzc+0W8eJFitO6cmt23NhBoibnK2PyAlsrc5a840rEkzi81gQQn5iNfAE6Bg4cSPHixXOWHCVgOdz2h85fg0X+zfqlkjZP4xKZtDmIoSv9KWNpzt8ftmBoSzvFPOv3799PvXr1WLduHV9++SVHjhzB0dFRES0vk2nAl1L+J7U++KOSv095Lu8l5iFX98Duz6F2d2g1Md1iAeHanLINbBsA2pUhZmZm+lsZog9MzLSJOR6FoDn0I3379qVTp9SZuDyre/Iw9iEnwk4oJDJ96lWy5rte9TgZ8pBpWy9ke2jG0tKSQYMG8fvvv/PgQRaTxYPWHG3PdKjWEur1zZ5oFcU5/d8jPH4+zPpTNxnZ2p4/RzejZjllPOtjY2MZP3487dq1w8LCgn/++YcvvvhCsY2OaZGdMfyOaZzrqi8hBifiKmx8D2zrwpveYJT+ryIwPBC7EnbYmGt7f6VKlaJv376sWrUq9ytD9Iis3oq990szoakJP33x4SvXW1RqgaWpZb5arZOSNxpUZFQbe9adDGX18TRz7WSIl5cXcXFxLF++POs37ZoK8c+0D0vVHO21ISFJw4+7LtPb+xhJGsnvw935rGstzEyUWW555swZ3NzcmDNnDqNHjyYwMJBGjfLfXFCmAV8I4SWEOAfUFEIEpThC0I7lv37ERMK6fto0df3XQpH0t1VrpIbA8EBcbF1Snffy8iI6Opo1a9bktdos88cff/D2ihAwNafsqVnaTUQpMDM2o2O1juz5bw+xidlIpm5AJnSqSYfatkz/+1+OBWdv34CzszPNmzfH29sbjSYLw0IhhyBovXY4rEyNHCpWMTTB4dH0XHiMX/YF07Oh1rO+cXVlPOuTkpKYPXs2jRs35sGDB2zfvp358+dTtGg+teNIb3A/+QBKANWAdUDVFEfJzO7N7ZEnk7ZJidpljF+WkvJG5sZEVx5ekU7LneRfwX+lOq/RaGSDBg1kvXr18sVSx8jISFm+fHnp6uoqk47rzNXObnil3PE7x6XTcie5I2SHAiqzxuOYeNlxzgFZ/8ud8kZE9kytVq9eLQG5a9eujAsmxEr5s6uU8+pJGZ87iwcVw5CUpJE+R67LGlP8ZIMvd8rt5+5kflMecv36ddmiRQsJyLfeektGREQoqicZcjNpK6WMklLekFL2l6nH8HPvfqUEu7+Aa3u1yUSqZm5MFBgeCPBKD18IgZeXF0FBQXmSqCC7fP7559y9exdvb2+MGr0HFV1h5ySIeZSqnFtZN8pYlMHvev4c1gGwNNfaLwAMXeFPdGxClu/t1asXpUuXzjw5yrGf4cFV8PgBTF+/rF+FjbtRsbzrc5Lpf/9LM/tS7Bzbii5OOctJkVuklPj4+FCvXj2CgoJYuXIlf/zxB6VKlVJET3Z4/ZM0ZofANfDPfO0uStd3s3TL6XunKWNRhkrFX0028vbbb2NpaZmzlSF65PTp0yxYsIDRo0fj5uYGRsbQbS48ewB7v0pV1tjImC7Vu3D49mGi4qLSqVF5qpYqxsK3G3I94iljfz+DRpO1SVwzMzPee+89tm7dyq1bt9Iu9DAEDv2gXZXlmNbUlEp+YlvQHTrPO4T/jUd8/aYTywY3UixByf3793nrrbd47733cHV1JSgoiEGDBim2zj+7FJ6Af/MkbBsD1VtD56y7OieP36f1H1q8eHHeeecdNmzYQESEMj41SUlJjBw5EltbW2bOnPniQvn62geb/zK4ldpczbO6JwmaBPaG7jWw2uzRzKE00/5Xhz0Xw/lh1+Us3zdixAiklPz666+vXpQS/CbozNFm6VGtir6JiklgzPpAPlgbSPXSxfD7uCUDmlRVLLj6+vri7OyMr68vP/zwA/v27aNq1aqKaMkp2TFP6y2EsNR9P1UIsVkIobAxfBaJug3rB4BVRei9HIyztkwq7EkYYU/DaFg2/X+ml5cX8fHx+Pj46Els9vD29sbf35+5c+dSokSJ1BfbTgbLctoHXdKLtfd1StWhqlXVfD2sk8ygplXp37gKCw9c468zt7N0j52dHZ07d+bXX399nj3oOf/+BcF7tMZzVhXyQLGKPjgWHEGXeYf4OyiMcR1rsHGkO9UV8qx/+vQpXl5edOvWjbJly+Lv78/48eMxymBlX74lvcH9lw90u2qBFsBhtEZqJ7J6f04OvUzaxj2V0rul1mvm3sVs3ep7zVc6LXeSFyIuZFiuZcuW0t7eXiYlJeVGabYJCwuTVlZWsmPHjulPHJ/fop3A/WdhqtMLAhdI5+XO8t7TewZQmjviEpJkb+9jssYUvyx7mG/dulUCcuPGjS9OxkRJ+UNNKRc1lzJRmaxfKhkTE5/4PDNa2+/3yzOhynrWHz9+XDo4OEghhPzkk0/yj4dWBqAnL51k/11PYJGU8i8guzltDYuU8NdorU/KW7+Bba1s3R4QHkBRk6LUsMl4yZ6XlxfXrl1j9+7duVGbbcaNG0dcXBwLFixI/zW3zhvg0AH2fQ2P7zw/3bV6VySSHSH5MyVBSoqYGLFoQENKFzdj+MrThD/OfEmph4cHVapUST2/cuBbiL4L3eZl+S1PxXBcuBNF9/lHWHokhHfcq+L7UUvqV1bOs37atGk0b96c+Ph49u/fz3fffWcQz/q8JDsB/7YQYjHQB/ATQphl834AhBDGQohAIcS27N6bbQ7/CBc2Q4dpULNLtm8PDA+kfpn6mBhlHBx69uyJra2tQSdvd+/ezbp165g0aVLG27aTzdU0CbBj0vPT1UtUp06pOvl2E9bLlCpuxm/vuvE4NoHhq04Tm5C2/38yxsbGDB8+nL1793LlyhWthfQJb3AbApXcDKRaJSskaSSLDlyjx4KjRD5LYPmQRsxQ0LP+8uXLNGvWjBkzZjBw4ECCgoJo3bq1Ilr0Tnpd/5cPoCjQE3DU/Vwe6JTV+1PUMw5YC2zLrGyuhnQubtMOZWwcqjVIyyZRcVHSebmzXHhmYeaFpZSTJk2SRkZGMjQ0NNttZZeYmBjp6OgoHR0dn5ujZcrB77S/jyu7n59afn65dFruJEMiQ/JGaB6w/dwdWfXTbXLs+sBM9z+EhYVJExMTOW7sx1IuaSvld/aqOVo+I/TBU9lr0VFZ9dNtcuQqf/nwSR4kpM8iGo1Gzp8/X1pYWMhSpUqlHg58jUAfQzpSymdSys1Syqu6n8OklLuy83ARQlRCOyT0arYOfXLvX9g8HCo0hO4/52jL/Nnws0hklhOWDx8+PP2VIXpm9uzZXL16NZU5WqY0+whKOYLfeEiIAbTDOgLx2vTyAbo4lWdshxpsDrzNb4czzjxWrlw5evbsifRfrk0D2fkb1RwtnyClZIP/TbrMO8SlsGjm9KnPwgENsSmmzCjxnTt36Nq1Kx988AFt2rTh3LlzvPXWW4poyUuyYq1wRPc1WgjxOMURLYTIroH5PGAikH07xKwS80hrm1CkOPRbk+NNNYHhgZgIE5xLZy0FQLVq1fDw8Eh7ZYgeuXr1Kt988w39+/enQ4cOWb/RxAy6zYFHN7RDXYBtUVsal2uMX4hfts3KlOTDdg54OJfj2+0X2X85PMOyH73fny+aabhj7gjOvQ2kUCUjHjyJY8Sq00zcGIRTxRJsH9OSng0rKbbc8o8//sDZ2ZlDhw6xcOFCfH19KV9emU1deU1Wdtq20H21lFJapTgspZRZzs8lhOgGhEsp08+4rS03XAjhL4Twv3//flarf4FZCa3rYb81uVp2FxAeQO1StSlqmnVPDC8vL+7evcuff/6Z43YzQkrJ6NGjsbCwYM6cOdmvoHorqNcPjsyD+1cA8LDz4L/H//Hvg3/1rDbvMDIS/NC7PrXKWfHR2kCCw9M3sGsW7UtRU8FHOxNVc7R8wL5L9+g87xAHLt9nikdt1g1rSiUbZXxnIiMjGTRoEH369MHe3p4zZ87g5eX12myiyhHpjfXo+wC+BW4BN4C7wDNgdUb3GDTFYQriEuOk6ypX+d3J77J1X2Jioqxataps27Ztnuhat26dBOT8+fNzXkl0uJTfVpbSx1NKjUZGxkZKl5UucvbJ2foTaiBuPXomG87YJdt8v19GPo1/tcC1A1JOs5LHv+0uAenv7294kSpSSimfxCbISZuDZNVPt8nOcw/Ki2FRiurZv3+/rFy5sjQ2NpbTp0+X8fFpfH5eU9DTsszcPlgmSSkrSSmrAf2AfVLKgYZqPzv8++Bf4pLisjx+n4yxsTEjRoxg//79XLp0Sa+aoqKiGDt2LG5ubowcOTLnFRUvAx2mw43DELSBEmYlaFmxJTtCdpCkyXjlS36jorUF3oNcufXoGR+sCyAxKcVIYWIc+I4Dm2rUHLqYokWLKm6BUVgJCH2E58+HWXcylBGt7fjrg+bUKmfg5N06YmNjmTBhAu3atcPc3Jxjx44xbdo0TE1NFdFjaF7DrWJ5T7JhWnLCk+zw/vvvY2pqqvfkKFOnTiU8PBxvb2+MjXO5XK3hYKjUSJsDN+YRHnYe3I+5j/89f71oNSSNqpVkZg8nDl+N4NvtKR6yR3+CB8Hg8SPWpcvRv39/1q5dS2RkpHJiCxkJSRrm7LpMr0XHSEiSrB/WlEldayvmWR8UFETjxo358ccfGTlyJIGBgTRu3FgRLUqhiLWClPKAlLJbTu41BAHhAVSzqkYpi+y739na2vLWW2+xYsUKnj17phc9/v7+z83RXF1dc1+hkZE24UfMQ9g7g9aVWlPUpOhrtVonJX0bVWFws2osPRLCBv+b8OCa1hyt7pvgqJ3YHjVqFDExMaxcuVJhtYWD4PAn9Fx4jJ/3BfOmSyW2j2lJEztl3CSTkpL4/vvvadSoEffv38fPz4+FCxdSrJgyVg2Kkt5Yz8sHr6u1QjZJ0iTJFutayM+PfJ7jOg4ePCgBuXTp0lzrSUxMlK6urrJ8+fIyMjIy1/WlYvskKaeVkDL0pJx8eLJ0X+Mu4xKVWwedGxISk+SAX49Lx8m+MnKxp9ZKIyq1X3rjxo1l7dq180X+goKKRqORy4+GPPes9wtS1rM+JCREtmrVSgKyZ8+e8v79+4rqMQQUWmuFHBASFUJkXOQr/vfZoWXLltStW1cvY8aLFi3i9OnTzJs371VztNzSdhJYlodtY/Go2pnohGgO3z6s3zYMhImxEfPfduHt4qcpcecwke6fglXqpXVeXl5cvHiRgwcPKqSyYHPvcSzvLDvJtK0XcLcvxc4xrejqrJxn/YoVK6hXrx6BgYGsWLGCjRs3Urp0aUX05BcMbq2Q30lOWJ6RQ2ZmJCdH8ff359SpUzmu586dO0yePJlOnTrRu3cerCE3s4Sus+DeOZrcDKKkeUl8r/vqvx0DYW0Uy1TjVfwrqzMoyJmY+NST0H379sXGxibz5Cgq2cY3KIxOcw9x6sZDvurhhM/gRthaKeNZHxERQa9evRg8eDAuLi4EBQXxzjvvFOzlllkkOwG7D7AT6CKljARKAp/kiSoFCbwXSEnzklSxrJKregYNGkSxYsVy1csfN24c8fHxGZuj5Zba3cGxEyYHvqVz+RYcvHmQJ/H5JzF7ttj/NSbPwnna6TvO333KhI1nU20os7CwYPDgwWzZsoWwsDAFhRYcomISGPv7GUavDaBaqaL4fdSSQU2V86z38/PDycmJbdu28f3337Nv3z6qVaumiJb8iEGtFV4HAsIDaGjbMNcfWCsrKwYMGMD69et59OhR5je8xK5du/j999+ZMmUKDg4OudKSIc/N1RLxvH2ReE18vk+MkiZ3zsDJJdDofRo178SnXWrhGxTG/H3BqYqNHDmSxMREli5dqpDQgsOxaxF0nXeIrWfvMKaDIxu9mmFXprgiWpI96z09PbG1teXUqVNMmDAh9yvaChg5sVaITnFk11ohX3Pv6T1uP7mdq/H7lHh5eRETE8OKFSuydV9MTAyjRo2iRo0aTJw4US9aMsSmGrT6hHqX91LRrOTrt1pHkwTbxkLR0tDucwBGtLLjTZeK/Lj7CjvO331etEaNGrRv354lS5aQlPR67TvIL8QmJDFz27+8/esJzEyN2eTVjDEdamBqrMwI74kTJ3BxcWHx4sVMmDCBkydPUq9ePUW05HdyYq1gmeJQZvdEHhF4X7v+Pjfj9ylp0KABTZs2xdvbO1teNbNmzeLatWssXLjQcP7bzT5ClK6JR+RDjocdJyJGmZSNOcJ/GdwJ0Jmjaf3ThRB829OZ+pWtGbfhDJfuvuibeHl5cfPmTXx9X9/5CqX4985j3ph/lN+OhDCoaVV8P2pBAwU966dPn07z5s2Ji4tj3759fP/991k3FCyEZGcdvpkQ4m0hxGQhxBfJR16KMzSB9wKxMLGgZsmaeqvTy8uLy5cvs3///iyVv3LlCrNmzWLAgAG0b99ebzoyxaQIdJuD54M7aKSGnTd2Gq7t3BB9D/bO0OYqdu6V6pK5qTFLBrlS3MyEoSv8efg0HoDu3btTvnx5dedtNkjSSLwPXuONBUd4+CwenyGN+KqHE0WLKJNI5vLlyzRv3pwvv/ySt99+m6CgINq0aaOIlteJ7LyD/YV27X0i8DTFUWAIDA+kXul6mBrpb5t1nz59KFmyZJaCi5SSUaNGYWFhwY8//qg3DVmmWgvs6/SmZnwCflc2G779nLBrCiTGajeSpTHvUtbKnCXvuBEeHYfX6tPEJ2owNTVl+PDh7Ny5k+vXrysg+vXi5sNn9F9ynFnbL9G+Vll2jmlF25q2imiRUrJw4UJcXFy4du0aGzZsYOXKlfpfslxQSW+B/ssHcD6rZfV1GHLjVXRctKy3op5cELhA73WPHz9empiYyDt3Mt6EsmbNGgnIhQuzlnQlT4gOl0t/dpBOy51kaFTeJ3PJFcH7tEld9n2dadEtAbdk1U+3ycmbg6SUUt66dUsaGxvLiRMn5rXK1xaNRiM3nAqVdb/YIet+sUNu9L+p6Ka1O3fuyC5dukhAdu7cWd6+fVsxLfkZ9LTx6pgQImvm8K8hQfeD0EiN3iZsU5K8MuS339LP+xIZGcnYsWNp3Lgxw4cP17uGLFO8DF3dPgRg+z+zldORGQmx4DsebKpDi3GZFu/hUpGRre1ZcyKUVcf/o2LFinTv3p1ly5YRG5t5jtzCxoMncYxcfZpPNgZRp4IV2z9uyVuuynnWb9q0CScnJw4ePMiCBQvYvn07FSrk3P68sJKVVTrnhBBBaC0VAoQQl4UQQSnOFwgCwgMwFsbUK6P/2X0HBwc6derEkiVLSExMTLPMlClTiIiI0I85Wi4p3+QDGmpM8b21H/n0gaJa0uXoT/DwGnj+CKZZm6T7pHNN2tWy5cutFzh2LQIvLy8iIiLYuHFjHot9vdB61h9m/6X7TPaoxbphTalcUhnP+qioKN5991169eqFvb09gYGBjBo1St1ElUOy0sPvCfwP6Ao4AJ10P3fTfS0QBIYHUrNkTYqZ5o2hkpeXF7du3UpzZcjJkydZtGgRH374IS4u+n/DyDZGRng6DeK6iRFXduXDvXUPrmmzdtXtCQ5Zn9g2NhL81K8B1UoXY/SaABxd3HFwcFAnb3U8i09kypZzvLfcn9LFi/DXB80Z3soeYyNlguvBgwepV68ea9asYdq0aRw9epSaNfW3oKIwkpWA/7uU8r/0jjxXaAASNAkE3Q/Ktv99dujWrRuVKlV6ZVt/YmIiI0eOpHz58syYMSPP2s8uHZ0HY4LAN3Qv3DyptJwXSKkdyjEx0y7DzCaW5qb89o4bGgkjVgXw3vBRHDt2jKCgAvOymiMCQx/h8dNh1p4MZXgrO/4c3Zza5ZVZdR0XF8cnn3xC27ZtMTMz4+jRo0yfPr3QeNbnJVkJ+AX+3enSg0vEJsXmyfh9MiYmJgwbNoxdu3YRHPxi9+fChQsJDAxk3rx5WFnln20NNuY2NK/QDD9LSzTbxkBS2kNRBufCZri+H9pNfcUcLatUK12MhQMaEnz/CZdsmmBmZl5oe/kJSRrm7L5CL+9/SEiSrB3alMketTE3Vc6zvlGjRvzwww+MGDGCwMBAmjRpooiWgkhWAn4ZIcS49I48V2gAkg3T8jLgAwwdOhRjY2MWL14MwO3bt5k6dSpdunShV69emdxteDzsu3PPWBAQFQwn9JvQJUfERsGOSVC+ATQamquqmjuU5nPP2hwMfkTj92ewevVqoqOj9ST09eDa/Se8tegYP++9yhsNKrB9TEvc7ZX3rA8PD2fbtm0sWrSocHrW5yFZCfjGQHHAMp0jSwghzIUQJ4UQZ4UQF4QQX+ZEcF4QGB5IZcvKlClaJk/bqVChAj169MDHx4fY2FjGjh1LQkIC8+fPz5eTUG0qt8HCxBy/irVg/zcQdUtZQftmwpNw6DYXjHLfA323WTX6NapMqGUdNJVcWL16tR5E5n+klKz65waePx8m9OEzFg5oyJw+DbAyV2bI5L///qN9+/ZMnDgRT09Pzp07h6enpyJaCjzprddMPoCAzMpk5UA7NFRc970pcAJomtE9hliHr9FoZKv1reTkw5PzvC0ppdyzZ48EpIuLiwTkV199ZZB2c8rEgxNl8zXuMv6rslKuH6CckFunpZxuLeW28XqtNi4hSb616KisOmGLrNO8c4FPjnI3KkYOWnpCVv10mxy09IS8GxWjmBaNRiNXrFghrayspKWlpfRIyaESAAAgAElEQVTx8Snwv39DQC7X4eul66nTkuy7a6o7sm4wk0fceHyDh7EP83TCNiUWFhYIIQgMDEQIQcuWLQ3Sbk7xtPMkKiGaY2794eLfcHmH4UUkm6MVKwPtP9dr1UVMjPAe6IqVmSCqfn/89h3RW91P4p9w6eElYhJj9FZnbvA7F0bneYc4GfKAr96oy4ohjSiroGd97969effdd6lfvz5nz55l8ODB+fJNtyCRFSMMvRm6CCGMgdNol3cukFKeSKPMcGA4QJUqufOkzwrJCctdyhpmOWTKbEtCCI4dO0br1q0N0nZOcK/gjrWZNb7mxrQuUwu2fwLVW0ERA67LPrUUws7AW0vBXP9b6EsXN2PZkCa8tfAon227TofWzXKdaPvfB//y8f6Pufv0LgJBFasqOFg74Gjj+PxrFcsqmBjlvRfN49gEpv91gc2Bt6lfqQRz+jbAXiEbY4AdO3YwZMgQHjx4wOzZsxk/frzie08KC5l+2qSUD/XVmJQyCWgghLAGtgghnKSU518qswRYAuDm5pbnbwAB9wKwNrOmulX1vG4KgDZt2mBubk58fDxFihTJ94ZPpkamdKraib+v/82zLt9SdFVPOPQ9dJhmGAHRd2HfV2DXBpzeyrNm3OzL4ZZ0kdPmLoxf588vAxvnuLfpd92PL459gY25DTOazSDsaRhXH10lODKY/Tf3o5EaAIoYFcHO2i7Vg6CGTQ3KFi2rt57uP9ceMOGPs9x9HMvH7R35oJ2DYjbGT58+ZeLEiSxcuBAnJyd27NhB/fr1FdFSWFHE6k5KGSmEOAB0Ac5nUjxPCQwPxMXWxWCvku7u7uzdu5cDBw7Qpk0b3N3dDdJubvCw82DDlQ3sF7F4NhgAx36Gen3AtnbeN75zMiTGpWuOpk9mDHuT5iO+YRtv0+BICENb2mXr/iRNEj8F/oTPeR8a2jZkTps5lLJIveolNjGW61HXnz8Arj66ysm7J9l2fdvzMpamljjYOOBo7fj8q6ONIyXMsv52E5uQxI+7LvPbkRCqlSrGxpHuuFSxyda/R5+cPHmSQYMGcfXqVcaPH8/MmTNVG2MFMFjAF0KUARJ0wd4C6AAoatYSERNBaHQovWvkQb7YDHB3d38tAn0yLrYulCtWDr8QPzw7zoDLftrNT4N98zYIX9sH5zdBm0lQyj7v2tFRt25d6hnfIvTWGb7xAwfb4rTJoivk4/jHTDw0kaO3j9KnRh8+a/wZpsavrnoxNzGnTqk61ClVJ9X5qLio5w+A5K/bQ7YTfeXFUlFbC9vUDwIbR+xK2GFhYpGqrothjxn7+xku3Y1mQJMqTPGsrZiNcUJCAt988w1fffUVFSpUYO/evbRt21YRLSqG7eGXB1boxvGNgA1Sym2Z3JOnGHr8/nXFSBjRtXpXVl1YxSNjY2w6fAl/fwRn10GDt/Om0WRztJJ20HxM3rSRBqO8vHj7nSG4f76RD9cF8ufo5pmOd1+Pus5H+z7idvRtPm/6OX1q9sl2uyXMSuBa1hXXsq7Pz0kpuffsXqqHQHBkMOsurSNeo/X2Tzk/YG/tQGhYCbae1FDcpBw+gxvRtpYyNsagze0waNAgTp48ycCBA/nll1+wtlYmWYqKFiGzkYnJ0Li5uUl/f/88q3/2ydlsvLKRY/2PpdkbU3nB5YeX6fV3L6Y2mUrfGr3Bpws8CIYP/KFoSf03uP9bODgLBm0B+3b6rz8d4uPjqVy5Mi4t2nO/wRBKWJiyZXRzSlik/fk4ePMgnx3+jCLGRZjTZk6qgJ1XJGoSuRl9M9WD4OKDK9x+chOE9u85eX7g5WEhfc4PpIeUEm9vb8aPH4+5uTne3t706ZP9h6BKzhBCnJZSuqV5rTAH/H7b+lHUtCjLOi/LszYKClJKem7tiVURK1Z0XQH3LoB3S3AZAN1/0W9jEcGwyB1qd4dehk82PnnyZGbPns2fR88zdmsIzRxK4zO4USoTMSklv537jV8Cf6FWyVr81PYnyhfPmdVDbpBSsjngNtO2XgCRwIgOxalcLpJrkde4+ugqVyOvEv4s/Hn5lPMDKVcMZWd+ICPCwsJ4//332b59O506dWLZsmVUrFhRL3WrZI2MAr4yA3v5gGcJz7j08BLvO7+vtJTXAiEEHtU9+DnwZ+48uUOFsnXBfRQc+wUaDIQqevI7kRL8xoOJeY7M0fTBiBEjmDVrFie2reGrHsOZtPkc3/pdZGo37bj7s4RnfHHsC3be2EnX6l35stmXr4yjG4KHT+OZsuUc28/fpXG1kvzYp36aNsZRcVGvDAttD9nOhisbnpextbBN9QBwsHHAvoQ95iZZn1jdvHkzw4cP5+nTp8yfP1+1Mc6HFNqAHxQRRJJMMtiGq4JA1+pd+TnwZ7aHbNc+KFt/Bue3aDdFjTgI+hgWO78Jrh8Ajx/Asmzu68sBVatWxdPTk99++43QL77gUthjfjsSQs1yljSrZcTH+z7myqMrjHUdy5C6QxQJavsvhzNxYxCRz+L5rGsthrW0S9fGuIRZCdzKueFW7kWnLyvzA0bCiMqWlVMNCznYOLyyfyAqKoqPP/6YFStW4ObmxqpVq6hVq1be/gJUckShDfiB9wIxEkbUL6OuA84qlSwrUb9MffxC/LQB36w4eHwH69+G44ug+Ue5ayAmUmuOVsEF3N7Tj+gc4uXlxbZt29iyZQtTe/XmavgTpu74i1JX1gMaFrRfQMtKht8l/Sw+kW/8LrL6eCg1y1qyYkhj6lTIvsuqEIJyxcpRrli5VP+OtOYHrkZeZW/oXiQv5gfsre1xsHbA+JExa39ey60zt5j6+VS++PwL1cY4H1Nox/CH7RpGZFwkf/zvjzypv6Cy9uJavj35LZu7b8bRxlF3sh+EHILRJ8C6cs4r950A/kth2D5t0FeQpKQkHBwcqFq1Kvv378fn3BrmBnyPSCzN0q4LaFTR8D3YwNBHjNtwlhsPnjK0RXXGd6ppMBvj2MRYrkVdI/iR9iFw5eEVAm4GEGca97yMZRFL7VvASzuK9TU/oJI11DH8l0jUJHL2/ll6OPRQWsprR6dqnfju1HdsD9n+IuB7fAcLmsCOz6DfmpxVfPs0nPoNGg9XPNgDGBsbM2LECCZPnczY7WPZe38vrrbN8D/ZlS833+ePEY5YFDFMsE1I0jB/XzDz9wdT1tKMNUOb0My+tEHaTsbcxJy6pepSt1Rdzp07x6qJqwgKCuK90e8xePxgbsfdznR+IOVDwK6EXbbmB1T0Q6EM+JcfXSYmMUYdv88BpS1K07R8U/xC/PjQ5UPt+LV1FWj9KeyZBpe3Q82u2as02RyteFloNyVvhOeAHgN68NvT39h7fy/DnIcxusFo9leLYNgqfz7ZeJZf+uf9Du1r958w7vcznL0VRU+XikzrXjfdJaJ5jUajYe7cuUyePBlra2u2bduWpo1xyvmBq5FXtW8FkVc5dfFUqvmBKpav+gtVtqxsEH+hwkqh/M0G3NMmPGlg20BhJa8nHnYeTDkyhbP3z774HbqPhrPrwW+izlwtG4krTv0GYWeh17I8MUfLCRciLvDR8Y8oWr0o933u877v+xgbGdOhTlk+6VyT73ZcpnZ5K0a3dciT9qWUrD7+H1/7XcTc1JgFbzfEs57hl30m899//zF48GAOHDhAjx49WLJkCWXKpJ0/IqP5gdDo0OcPgOSvac0PpFoxZO1gkP0DhYFCGfADwwOpWLwi5YqVU1rKa0m7yu0wMzbD97rvi4BvbArd5oBPVzj4HXTMYn6bx2Gw9yvt5qq6PfNOdDb4+9rffPnPl5QyL8VnVT5jwMEBrFu3jqFDtVm2vFrbc/luNN/vvIyjbXE61dXv5yj8cSyfbAzi4JX7tHQszQ+96ytmYyylZPXq1XzwwQdoNBqWLVuWYxtjEyMT7ErYYVfCjk50en4+JjGG61HXn88PBEcGc/zOcbZe2/q8TPL8wMsPAnV+IHsUuklbKSVtN7TFvYI737b8Vq91FybGHxiP/z1/9vTeg6lRiiGGv3Q9/RGHoWyd9CtI5o/BcMkPRv1jEL+cjEjSJDEvYB7LLyzHrawbP7b5ERszG5ydnTEzM8Pf3/95oItNSKLP4n+4Fv6ETaOaUaucfvIRbz8XxqQt54iJT2KKZ20GNa2qWM/2wYMHeHl58ccff9CiRQtWrlxJ9eqGcZWFF/sHUr4NBD8KJjohhb9QUdvnD4Lkh0Bhnx9QJ21TcDP6Jg9iH+R5/tqCjqedJ7v+28WJsBO0qNjixYUOM+CSL/iOg8F+YJSBFW/wHriwBdpMVjzYR8VFMfHQRI7dOUa/mv2Y2Hji8wfZqFGjGD16NKdOnaJx48YAmJsas2SQG/+bf4RhK/35a3QLShYrkuP2H8cmMH3rBTYH3KZepRLM6dMAB1vlPOt37tzJkCFDiIiIYNasWUyYMMHgnvWZ7R/IbH7g5beBKpZVMNZDaszXmULXw/8z+E8+P/o5W7pvwcEmb8ZfCwPxSfG02dCGNpXa8E3Ll3bEBqyCrR/AGwvAZWDaFSTEwEJ3bW5ar2NgYpb3otPhWuQ1Ptr3EXee3mFKkyn0qpE6ofzjx4+pUKECvXv3xsfHJ9W1wNBH9F1ynIZVrFn1fpMcec0fv/6A8RvOEhYVwwdtHfiwvaNinvXPnj1j4sSJLFiwgLp167J69WoaNMj/c10vzw8kDw2FPg59Pj9gZmyGXQm7Aj8/oPbwUxAYHohVESvsrLPnda6SmiLGRehUtRPbQ7YTkxiT2lqgwQA4swZ2fQ41PdI2Vzs8Bx6FwDt/KRrs94fuZ9KRSZgbm7Os87I03/ysrKwYOHAgK1as4Mcff6RkyRf/HpcqNszq6cy4DWeZ8fe/fNXDKcttxyUmMWfXFZYcvk7VkkXZ6NWMhgp61p86dYqBAwdy5coVxo0bx9dff/3aeNZnNj9w9dGLt4GM5geSdxMX1PmBQhfwA+4F4GLrgpFQpgdVkPCo7sGmq5s4eOsgXap1eXHByEibsGRxS9j9BbwxP/WNEVfh6Dxw7q3NZKUAUkqWBC1h/pn51ClVh5/a/pThJL6XlxeLFy9m+fLljBs3LtW1ng0rcfluNIsPXadmOUsGNq2aafspPevfblKFKR61KWamzJ9jYmIi33zzDTNmzKB8+fLs3buXdu0M51Cal1iYWDzfP5CSyNhI7U7iFMNCftf9Xp0f0D0ECsr8QKEK+A9jH3Lj8Q11w5WecC3riq2FLX7X/VIHfNBO2LqPhqM/aXv8VXUJX6TUju+bWECnrw0vGq352dSjU9n932662XVjmvu0TP+I69evj7u7O97e3owZMwajl+YmJnapxeV70UzfegH7MsVxty+VZj1JGsnSI9f5YecVrCxMWTbYjXa1lPEMArh69SqDBg3ixIkTDBgwgPnz5xcKz3prc+t05weuPLqSyl/oVFja8wMpPYYqW1Z+LeYHClXAT054YgjP8sKAsZExXap3Ye2ltUTFRb36Ctz6Uzi/WRvgRxzSLt0894fWhsHzR0XM0W5F3+Lj/R8THBnMBLcJvFPnnSyP33p5efHOO++wb98+OnTokOqasZHg5/4u9FhwlFFrTrP1gxavOFfeevSM8RvOciLkIZ3qlOXbns6UKq7McJaUkiVLljBu3DiKFCnC+vXr6du3ryJa8gsp9w+0qtTq+fnk+YGU/kJXHl1hz3970pwfSPkgsC1qm6/mBww2aSuEqAysBMoBGmCJlPKnjO7R96TtD6d+YN2ldfzz9j8UMc75igqVF1x4cIF+2/ox3X06b9VII8n4JT9Y3x86zoCG78D8RlCiMgzdo52wNSAnwk4w4eAEkmQS37f6nuYVm2fr/tjYWCpVqkTr1q3ZtGlTmmWu339CjwVHKV/Cgk2jmlHczOS5Z/30rReQwLT/1aGXayXFAsHdu3d5//338fPzo2PHjvj4+Kie9TkgrfmB4EfBhMe8yD9gVcTq+QTx86EhGwesiuhnGW9a5JdJ20RgvJQyQAhhCZwWQuyWUv5rKAGB4YE4lXZSg70eqVOyDtWsquEX4pd2wK/lATU94cAsuHUKnj2AARsNGuyllKy9tJbvT31PVauq/NzuZ6paZT7O/jLm5uYMGTKEuXPncvv27TSDpF2Z4sx/uyGDfU4y7vczfNvTmal/nmf7+bs0qmbDnD4N0vSsNxRbtmxh2LBhPH36lJ9//pnRo0e/MjylkjUymh+4Gpnadtr3ui9PEp48L1O2aFkcbByoYV3j+duAnbUdZsZ5+8an2LJMIcRfwHwp5e70yuizhx+TGEOztc0Y7DSYjxt+rJc6VbQsOrOIRWcXsbvXbsoWS2OYJvImLGgMCc+giRd0nWUwbfFJ8cw8PpMtwVtoU7kN37b4luJFcr6+PTg4GEdHR6ZPn860adPSLbfsSAgztv2LhakxiRoN4zrWZHir9D3r85rHjx8zZswYfHx8aNiwIatXr6Z27dqKaCmMpDc/cC3yGgmaBOCl+QEbR0bWG5mjt8CMevhIKQ1+ANWAUMAqjWvDAX/Av0qVKlJfnAw7KZ2WO8mDNw/qrU4VLSGRIdJpuZNcfn55+oX8l0v5a3spY6IMpiv8abh82/dt6bTcSf4S8ItM0iTppd7OnTvLihUryoSEhHTLaDQaOe2v87L7L4fl+duRemk3pxw6dEhWq1ZNGhkZyalTp8q4uDhF9ai8ICEpQV6LvCZ3hOyQ8wPny4/3fSw9NnlIj00eOa4T8Jfpxd70LuTVARQHTgM9Myvr6uqa43/0y3if8ZbOy51lZKyyf3wFlb5/95W9t/ZWWsZzgsKDZLvf28lGqxvJnSE79Vr3n3/+KQG5efNmvdarb2JjY+Wnn34qhRDS3t5eHjt2TGlJKlkkPik+x/dmFPANOngnhDAFNgFrpJSbDdl2YHggDjYFczNFfsDTzpOLDy9yPeq60lLYem0rg3cMxtTYlFVdV9GpWqfMb8oGnp6eVKpUiYULF+q1Xn1y/vx5mjRpwuzZsxk2bBhnzpzB3d1daVkqWSSVP5UeMVjAF9rBqKXARSnlHEO1C1pTrDP3z6j+93lIl2pdEAi2h2xXTEOiJpHvTn3HlCNTaGDbgHWe66hZsqbe2zExMWH48OHs2bOHq1ev6r3+3KDRaJgzZw6urq6EhYXx999/s3jxYooXV86XRyX/YMgefnNgENBOCHFGd3gYouErj67wNOGpapiWh5QpWobG5Rvjd90veejOoETFReG1x4tV/65iQO0BeHf0xsY872wKhg4diomJCd7e3nnWRnYJDQ2lQ4cOjB8/ni5dunDu3Dm6deumtCyVfITBAr6U8oiUUkgp60kpG+gOP0O0HRCuTXii9vDzFs/qnoRGh3LhwQWDtnv10VX6bevH6XunmdFsBp81/izPXomTKV++PD169MDHx4eYmJg8bSszpM6z3tnZmVOnTrF06VL+/PNPbG1tFdWlkv8oFAtwA8MDKVesHOWLK5cxqDDQvmp7TI1M8b3ua7A29/63lwF+A4hNimVZ52W86fimwdr28vLi0aNHbNiwIfPCecTDhw/p27cvgwYNwtnZmbNnz/Lee+/lq92dKvmHAh/wpZQE3gtUh3MMgFURK1pVasWOGztI0iTlaVsaqWHR2UWMOTAGB2sH1nuuN3jKyrZt21KzZk0WLVpk0HaT2bVrF05OTmzZsoVvvvmGgwcPYmenusCqpE+BD/i3n9wmPCZcHc4xEB7VPYiIieDUvVN51sbThKeMOzCOhWcW0t2+Oz5dfNLe8JXHCCEYOXIkJ06cIDAw0GDtPnv2jA8//JDOnTtjY2PDyZMnmTRpksETlKi8fhT4gJ9smKb28A1Dq0qtKGZaDL/reTM9czP6JgP9BrL/5n4mNprIzOYz83w7eka8++67WFhYGKyX7+/vj6urK/Pnz2fMmDH4+/vj4qJ+tlWyRoEP+AHhAViaWuJgrWa3MgTmJua0r9Ke3f/tJi4pTq91Hw87Tn/f/oQ/C8e7gzeD6gxSfKzaxsaG/v37s2bNGqKiovKsncTERGbOnIm7uztPnjxhz549zJ07FwsLi8xvVlHRUeADfuC9QBrYNngtvKoLCp7VPXmS8ITDtw7rpT4pJav+XcXI3SMpY1GG9Z7rca+QfzYReXl58ezZM1auXJkn9QcHB9OyZUs+//xz+vTpQ1BQEO3bt8+TtlQKNgU64EfGRnIt6hoNy6rj94akcfnGlDQviV9I7od14pLimHp0Kt+d+o7WlVqz2mM1la0q60Gl/nBzc8PNzY1FixbpdQ+C1HnW169fn0uXLrFu3TrWrFmDjY1yaRBVXm8KdMA/c/8MoI7fGxoTIxO6Vu/KwZsHiY6PzvyGdAh/Fs6QHUPYem0ro+qPYm7buRQzLaZHpfrDy8uLixcvcujQIb3Ud/fuXf73v/8xYsQI3N3dOXfuHP369dNL3SqFlwId8APCAzA1MsWpdNYTS6voB4/qHsRr4tkbujdH95+9f5Z+2/oRHBnMvDbz8Grgla/zEPfr1w9ra2u9TN7++eefODs7s3fvXn766Sd27dpFpUqV9KBSpbCTf/+C9EDgvUDqlqqr6CqOwopzaWcqFa+Uo9U6W65uYciOIZgZm7HaYzXtq+b/8eqiRYvy7rvvsnnzZu7du5ejOh4/fsx7773Hm2++SeXKlTl9+jQfffSRmqBERW8U2E9SbGIs5x+cx6WsOpyjBEIIPOw8OHH3BBExEVm6J1GTyOyTs/ni2Be4lnVlfbf11LCpkcdK9cfIkSNJSEhg6dKl2b73yJEj1K9fnxUrVjBlyhSOHz9OnTp18kClSmGmwAb8Cw8ukKhJVDdcKYhndU80UsPOGzszLRsZG8nI3SNZfXE1A2sPZFGHRa+dlXWtWrVo27YtixcvJikpazuN4+PjmTRpEq1atcLIyIhDhw4xc+ZMihRR03Cq6J8CG/CTN1w1KGPY7fYqL7CztqNWyVqZDutceXSFfr79CAwPZGbzmXza+FNMjAyZbll/eHl5ERoayvbtmdtEX7hwgSZNmjBr1izef/99zpw5Q/Pm2UusrqKSHQpswD997zT2JeyxNrdWWkqhxqO6B0ERQdx8fDPN67v/281Av4HEJ8Xj08WHNxzeMLBC/dKjRw/KlSuXYXIUjUbD3LlzcXV15fbt2/z111/8+uuvWFpaGlCpSmGkQAb8JE0SZ8PPquP3+YCu1bsCvLImXyM1LDizgHEHxuFo7cj6buupV6aeEhL1iqmpKcOGDWPHjh2EhIS8cv3mzZt07NiRcePG0blzZ86fP0/37t0VUKpSGDFkxqtlQohwIcT5vG4rODKY6IRodfw+H1CuWDlcy7riG+L7fFPS04SnjNk/Bu+z3vRw6MGyLsuwLVpwvNuHDRuGEILFixc/PyelZO3atTg7O3PixAl+/fVX1bNexeAYsoe/HOhiiIZUw7T8hUd1D0KiQrj08BKhj0MZ4DuAQ7cO8Vnjz5jRbEaBWzZbuXJl/ve//7F06VLi4uJ4+PAh/fv3Z8CAAdSpU4ezZ88ydOhQxX2AVAofhsx4dQh4aIi2AsIDsLWwpWLxioZoTiUTOlXthImRCfMC5tHftz8RsREs7riYAbUHFNig5+XlRURExHPP/E2bNvH1119z6NAh7O3tlZanUkh5PZdCZEJgeCAuZV0KbDB53bA2t6ZFhRYcuHUARxtHfmr7E5Ut85cfjr4pXrw4Qgj++ecfhBAsW7aMwYMHKy1LpZCT7wK+EGI4MBygSpUq2b4/PimepuWb0rR8U31LU8kFH7h8gKONI0Odh1LUtKjScvKcQ4cOIYRASomRkRFhYWFKS1JRyX8BX0q5BFgC4Obmlm3rwSLGRfiq+Vd616WSO2qWrEnNkjWVlmEw2rRpg5mZGfHx8RQpUoQ2bdooLUlFJf8FfBWVgoC7uzt79+7lwIEDtGnTBnf3/OPfr1J4MVjAF0KsA9oApYUQt4BpUsrsm46oqLwmuLu7q4FeJV9hsIAvpexvqLZUVFRUVF6lQO60VVFRUVF5FTXgq6ioqBQS1ICvoqKiUkhQA76KiopKIUEN+CoqKiqFBJHsYJgfEULcB/5TWoeO0kDWcvUpR37XmN/1Qf7XmN/1gapRH+RGX1UpZZm0LuTrgJ+fEEL4SyndlNaREfldY37XB/lfY37XB6pGfZBX+tQhHRUVFZVCghrwVVRUVAoJasDPOkuUFpAF8rvG/K4P8r/G/K4PVI36IE/0qWP4KioqKoUEtYevoqKiUkhQA34mCCEqCyH2CyEuCiEuCCE+VlpTWgghjIUQgUKIbUprSQshhLUQYqMQ4pLud5mvbCSFEGN1/7/nhRDrhBDm+UDTMiFEuBDifIpzJYUQu4UQV3VfbfKhxu91/89BQogtQgjr/KQvxbUJQggphCithLYUOtLUKIT4UAhxWfe5/E4fbakBP3MSgfFSytpAU2C0EKKOwprS4mPgotIiMuAnYIeUshZQn3ykVQhREfgIcJNSOgHGQD9lVQGwHOjy0rnPgL1SSkdgr+5nJVnOqxp3A05SynrAFWCSoUWlYDmv6kMIURnoCIQaWlAaLOcljUKItsAbQD0pZV3gB300pAb8TJBShkkpA3TfR6MNVPkqO7oQohLgCfymtJa0EEJYAa2ApQBSyngpZaSyql7BBLAQQpgARYE7CutBSnkIePjS6TeAFbrvVwA9DCrqJdLSKKXcJaVM1P14HKhkcGEvtKT1OwSYC0wEFJ/ETEejFzBLShmnKxOuj7bUgJ8NhBDVABfghLJKXmEe2g+vRmkh6WAH3Ad8dMNOvwkhiiktKhkp5W20PahQIAyIklLuUlZVupSVUoaBtjMC2CqsJzPeA7YrLSIlQojuwG0p5VmltWRADaClEOKEEOKgEKKRPipVA34WEUIUBzYBY6SUj5XWk4wQohsQLqU8rbSWDDABGgKLpJQuwFOUH4p4jm4c/A2gOlABKCaEGOY+yDoAAATySURBVKisqtcfIcQUtEOia5TWkowQoigwBfhCaS2ZYALYoB1G/gTYIIQQua1UDfhZQAhhijbYr5FSblZaz0s0B7oLIW4A64F2QojVykp6hVvALSll8pvRRrQPgPxCByBESnlfSpkAbAaaKawpPe4JIcoD6L7q5VVf3wgh3gW6AQNk/lr7bY/2wX5W9zdTCQgQQpRTVNWr3AI2Sy0n0b6953pyWQ34maB7qi4FLkop5yit52WklJOklJWklNXQTjTuk1Lmq96plPIucFMIUVN3qj3wr4KSXiYUaCqEKKr7/25PPppUfomtwLu6798F/lJQS5oIIboAnwLdpZTPlNaTEinlOSmlrZSymu5v5hbQUPcZzU/8CbQDEELUAIqgB7M3NeBnTnNgENqe8xnd4aG0qNeQD4E1QoggoAHwjcJ6nqN789gIBADn0P5dKL4TUwixDvgHqCmEuCWEeB+YBXQUQlxFu8pkVj7UOB+wBHbr/l6885m+fEU6GpcBdrqlmuuBd/XxpqTutFVRUVEpJKg9fBUVFZVCghrwVVRUVAoJasBXUVFRKSSoAV9FRUWlkKAGfBUVFZVCghrwVVRUVAoJasBXUVFRKSSoAV9FEYQQpVJsZLsrhLid4ucaafmX6+47lo02slRW59U/KsXP1dJrP7cIIZ5kcj3bbWdWp4pKMmrAV1EEKeUDKWUDKWUDwBuYm+Ln+Azuy7LHTTbKWgOjMi2lovKaowZ8lfyKsRDiV122n11CCAt40ZsVQhQTQvgKIc7qslT1fbmCbJSdBdjr3i6+z6h9XX0DhRAndeUXCyGMX2q3kS7bk7mu7QtCCKc09P0phDituz48xSUTIcQKXR0bdQ6PmbabRv37hRAddd/PFEL8nFF5lYKPGvBV8iuOwAJdtp9I4K2XrncB7kgp6+uyVO3IoK7Myn4GXNO9YXySUftCiNpAX6C57m0kCRiQsjIp5Sm0Jmczge+A1VLKtIZp3pNSugJuwEdCiFK68zWBJbqMUY+BUVlpNw2mAVOEEAPQ5nEYm0l5lQKOidICVFTSIURKeUb3/Wmg2kvXzwE/CCFmA9uklIczqCs7ZTNrvz3gCpzS2ZNbkLZF8QzgFBCLNn1iWnwkhHhT931ltA+Zu8BNKeVR3fnVuvtjs9juc6SUh3Tun+OANlLKpIzKqxR81ICvkl+JS/F9EtoA9xwp5RUhhCvgAXwrhNglpZyRVkXZKZuF9gWwQkqZWZ7WkkBxwBQwR5v05TlCiDZoffjdpZTPhBAHdOXg1bR7MhvtpmzDGSgPROjSc6oUctQhHZXXEiFEBeCZlHI12vSE6SZUyULZaLR2vllhL9BLCGGrq7ukEKJqGuWWAJ+jzfY0O43rJYBHumBfC21mo2SqCCHcdd/3B45ko11018vr2n4DeCqE6JzFf59KAUbt4au8rjgD3wshNEAC2qTPOSorpXwghDiqWw65HViQXkVSyn+FEFOBXUIII119o4H/kssIId4BEqWUa3UTq8eEEO2klPtSVLUDGKnLD3AZbbLvZC4C7wohFgNX0aaGfJZZuynaL4o2a9d4KeVFIcRXaB86OzP4HakUAlQ/fBUVFZVCgjqko6KiolJIUAO+ioqKSiFBDfgqKioqhQQ14KuoqKgUEtSAr6KiolJIUAO+ioqKSiFBDfgqKioqhQQ14KuoqKgUEv4PSrFhrA8Js2UAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# --- EXERCISE 1.1 ---\n", + "x = [1, 3, 6, 9, 16]\n", + "y = [7, 3, 7, 1, 5]\n", + "\n", + "plt.plot(x, y, 'k.-', label='Original curve')\n", + "\n", + "\n", + "# --- EXERCISE 1.2 ---\n", + "plt.title('Title with random equation for showcase $c = \\sqrt{a^2+b^2}$')\n", + "\n", + "\n", + "# --- EXERCISE 1.3 ---\n", + "plt.xlabel('This is the xlabel $x$')\n", + "plt.ylabel('This is the ylabel $y$')\n", + "\n", + "\n", + "# --- EXERCISE 1.4 ---\n", + "y2 = [9, 5, 5, 2, 6]\n", + "y3 = [4, 6, 2, 6, 8]\n", + "y4 = [1, 8, 1, 3, 2]\n", + "\n", + "plt.plot(x, y2, label='Second curve')\n", + "plt.plot(x, y3, label='Third curve')\n", + "plt.plot(x, y4, label='Fourth curve')\n", + "\n", + "# --- EXERCISE 1.5 ---\n", + "# The labels in the plot commands above were\n", + "# added as part of this exercise\n", + "\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Some addtional info\n", + "Almost every aspect of the figure can be modified. For instance, the legend is located on top of the plot. It placed it in the location where there is least overlap, but still not ideal.\n", + "\n", + "An explicit location can be specified as shown in the documentation: https://matplotlib.org/api/_as_gen/matplotlib.pyplot.legend.html\n", + "\n", + "It basically says that you can do:\n", + "\n", + "~~~python \n", + "plt.legend(loc='inset_location_string_or_code')\n", + "~~~\n", + "\n", + "The available location strings/codes from the documentaion are shown in the table below. If not specified it will be set to `loc='best'`.\n", + "\n", + "Location String |\tLocation Code\n", + "----------------| -------------\n", + " 'best' |\t0\n", + "'upper right' |\t1\n", + "'upper left' |\t 2\n", + "'lower left' |\t3\n", + "'lower right' |\t4\n", + "'right' |\t5 \n", + "'center left' |\t6\n", + "'center right' |\t7\n", + "'lower center' |\t8\n", + "'upper center' |\t9\n", + "'center' |\t10\n", + "\n", + "However, these locations are all inside the `Axes` (i.e. the actual plotting area). If we want the legend outside the plot, we could do it like this:\n", + "\n", + "*Note that I did not know how to do this myself before making the exercise. I just googled for the solution.*" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x = [1, 3, 6, 9, 16]\n", + "y = [7, 3, 7, 1, 5]\n", + "y2 = [9, 5, 5, 2, 6]\n", + "y3 = [4, 6, 2, 6, 8]\n", + "y4 = [1, 8, 1, 3, 2]\n", + "plt.plot(x, y, 'k.-', label='Original curve')\n", + "plt.plot(x, y2, label='Second curve')\n", + "plt.plot(x, y3, label='Third curve')\n", + "plt.plot(x, y4, label='Fourth curve')\n", + "\n", + "# Set legend location via 'bbox_to_anchor'\n", + "plt.legend(bbox_to_anchor=(1.0, 0.5), loc='center left')\n", + "# The numbers in paranthesis are in fractions of figure width and height\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 1.6\n", + "Since we did not save the plot from Exercise 1.1-1.5 to a figure object, we need to repeat the code to create a new plot. This is becuase the `plt.show()` command shows and 'exhausts' the plot so it is inaccessible afterwards, unless it is saved in a figure object.\n", + "\n", + "So, we repeat the code, this time saving the plots to a figure object." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Create figure object to store plots inside\n", + "fig = plt.figure()\n", + "\n", + "# ---REPEAT CODE FROM EXERCISE 1.1-1.5 ---\n", + "x = [1, 3, 6, 9, 16]\n", + "y = [7, 3, 7, 1, 5]\n", + "y2 = [9, 5, 5, 2, 6]\n", + "y3 = [4, 6, 2, 6, 8]\n", + "y4 = [1, 8, 1, 3, 2]\n", + "plt.plot(x, y, 'k.-', label='Original curve')\n", + "plt.title('Title with random equation for showcase $c = \\sqrt{a^2+b^2}$')\n", + "plt.xlabel('This is the xlabel $x$')\n", + "plt.ylabel('This is the ylabel $y$')\n", + "plt.plot(x, y2, label='Second curve')\n", + "plt.plot(x, y3, label='Third curve')\n", + "plt.plot(x, y4, label='Fourth curve')\n", + "plt.legend(bbox_to_anchor=(1.0, 0.5), loc='center left')\n", + "\n", + "# Save figure to a file \n", + "fig.savefig('myfig.png')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the saved png file, the legend appears to have been cut off. I dont' know why it cannot handle this. This would not have been a problem if it had stayed inside the plotting area.\n", + "\n", + "A way to get it to show correctly could be to create a new `Axes` object to the right of the `Axes` object that contains the plots. Recall the `Axes` is the \"plotting area\". \n", + "\n", + "So:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Create figure object to store plots inside\n", + "fig2 = plt.figure(figsize=(14, 6))\n", + "\n", + "# Create new axes object (plotting area) for putting legend\n", + "ax_leg = fig2.add_axes([0.1, 0.1, 0.6, 0.75])\n", + "\n", + "# ---REPEAT CODE FROM EXERCISE 1.1-1.5 ---\n", + "x = [1, 3, 6, 9, 16]\n", + "y = [7, 3, 7, 1, 5]\n", + "y2 = [9, 5, 5, 2, 6]\n", + "y3 = [4, 6, 2, 6, 8]\n", + "y4 = [1, 8, 1, 3, 2]\n", + "plt.plot(x, y, 'k.-', label='Original curve')\n", + "plt.title('Title with random equation for showcase $c = \\sqrt{a^2+b^2}$')\n", + "plt.xlabel('This is the xlabel $x$')\n", + "plt.ylabel('This is the ylabel $y$')\n", + "plt.plot(x, y2, label='Second curve')\n", + "plt.plot(x, y3, label='Third curve')\n", + "plt.plot(x, y4, label='Fourth curve')\n", + "\n", + "# Add legend to new axes object\n", + "ax_leg.legend(bbox_to_anchor=(1.0, 0.5), loc='center left')\n", + "\n", + "# Save figure to a file \n", + "fig2.savefig('myfig2.png')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now the png file look alright." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 2.1" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(18, 5))\n", + "x = [1, 3, 6, 9, 16]\n", + "y = [7, 3, 7, 1, 5]\n", + "y2 = [9, 5, 5, 2, 6]\n", + "y3 = [4, 6, 2, 6, 8]\n", + "y4 = [1, 8, 1, 3, 2]\n", + "\n", + "plt.subplot(141)\n", + "plt.plot(x, y)\n", + "\n", + "plt.subplot(142)\n", + "plt.plot(x, y2)\n", + "\n", + "plt.subplot(143)\n", + "plt.plot(x, y3)\n", + "\n", + "plt.subplot(144)\n", + "plt.plot(x, y4)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 2.2\n", + "Only difference from the code in Exercise 2.1 is to change `plt.plot()` to `plt.bar()`" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(18, 5))\n", + "x = [1, 3, 6, 9, 16]\n", + "y = [7, 3, 7, 1, 5]\n", + "y2 = [9, 5, 5, 2, 6]\n", + "y3 = [4, 6, 2, 6, 8]\n", + "y4 = [1, 8, 1, 3, 2]\n", + "\n", + "plt.subplot(141)\n", + "plt.bar(x, y)\n", + "\n", + "plt.subplot(142)\n", + "plt.bar(x, y2)\n", + "\n", + "plt.subplot(143)\n", + "plt.bar(x, y3)\n", + "\n", + "plt.subplot(144)\n", + "plt.bar(x, y4)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 3.1" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "xx = np.linspace(-100, 100, 100)\n", + "yy = xx**2-3027\n", + "plt.plot(xx, yy)\n", + "plt.fill_between(xx, yy, where= yy<0, color='darkorchid', alpha=.25)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 4.1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Note:** The output of the code cell below is suppressed so it doesn't show all the figures." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "%%capture \n", + "# %%capture prevent plots from showing as cell output \n", + "# ------------------------------------------------------\n", + "\n", + "# Solution:\n", + "\n", + "# Define x-values\n", + "x_arr = np.linspace(1, 10, 10)\n", + "\n", + "# Copied y-values from exercise\n", + "y_arr1 = np.random.rand(10)\n", + "y_arr2 = np.random.rand(10)\n", + "y_arr3 = np.random.rand(10)\n", + "y_arr4 = np.random.rand(10)\n", + "y_arr5 = np.random.rand(10)\n", + "\n", + "# Create list of the y-arrays\n", + "y_arrays = [y_arr1, y_arr2, y_arr3, y_arr4, y_arr5]\n", + "\n", + "# Define names for the png files for each plot\n", + "names = ['plot1', 'plot2', 'plot3', 'plot4', 'plot5']\n", + "\n", + "# Loop over all graphs and save as png file with their names \n", + "for y_arr, name in zip(y_arrays, names):\n", + " \n", + " # Create a figure object\n", + " plt.figure()\n", + " \n", + " # Create plot for current y-array\n", + " plt.plot(x_arr, y_arr)\n", + " \n", + " # Save to figure and name file with current name\n", + " plt.savefig(f'{name}.png')\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Some notes to the solution\n", + "\n", + "`zip()` puts two or more iterables (in this case lists) up beside eachother so it becomes easier to iterate over them:\n", + "\n", + "~~~python\n", + "for y_arr, name in zip(y_arrays, name):\n", + " # Inside the loop, the i'th elements of the lists\n", + " # can be referred to as 'y_arr' and 'name'\n", + "~~~\n", + "\n", + "The same outcome could be obtained by looping over the index of one of the arrays and use that index to refer to the i'th element of the lists:\n", + "\n", + "~~~python\n", + "for i in range(len(y_array)):\n", + " # Inside the loop, the i'th elements of the lists \n", + " # can be referred to as 'y_array[i]' and 'names[i]' \n", + "~~~\n", + "\n", + "Choose whatever method you find the easiest. The more Pythonic way is using `zip`.\n", + "\n", + "If a new figure object is not created in each loop as `plt.figure()`, consecutive plots will be added to eachother. So, first png file will contain first plot, second png file will contain the first two and the last file will contain all the plots. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# End of exercises\n", + "\n", + "*The cell below is for setting the style of this document. It's not part of the exercises.*" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, "outputs": [ { "data": { @@ -275,7 +758,7 @@ "" ] }, - "execution_count": 1, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -284,473 +767,6 @@ "from IPython.display import HTML\n", "HTML(''.format(open('../css/cowi.css').read()))" ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 1.1 - 1-5" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# --- EXERCISE 1.1 ---\n", - "x = [1, 3, 6, 9, 16]\n", - "y = [7, 3, 7, 1, 5]\n", - "\n", - "plt.plot(x, y, 'k.-', label='Original curve')\n", - "\n", - "\n", - "# --- EXERCISE 1.2 ---\n", - "plt.title('Title with random equation for showcase $c = \\sqrt{a^2+b^2}$')\n", - "\n", - "\n", - "# --- EXERCISE 1.3 ---\n", - "plt.xlabel('This is the xlabel $x$')\n", - "plt.ylabel('This is the ylabel $y$')\n", - "\n", - "\n", - "# --- EXERCISE 1.4 ---\n", - "y2 = [9, 5, 5, 2, 6]\n", - "y3 = [4, 6, 2, 6, 8]\n", - "y4 = [1, 8, 1, 3, 2]\n", - "\n", - "plt.plot(x, y2, label='Second curve')\n", - "plt.plot(x, y3, label='Third curve')\n", - "plt.plot(x, y4, label='Fourth curve')\n", - "\n", - "# --- EXERCISE 1.5 ---\n", - "# The labels in the plot commands above were\n", - "# added as part of this exercise\n", - "\n", - "plt.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Some addtional info\n", - "Almost every aspect of the figure can be modified. For instance, the legend is located on top of the plot. It placed it in the location where there is least overlap, but still not ideal.\n", - "\n", - "An explicit location can be specified as shown in the documentation: https://matplotlib.org/api/_as_gen/matplotlib.pyplot.legend.html\n", - "\n", - "It basically says that you can do:\n", - "\n", - "~~~python \n", - "plt.legend(loc='inset_location_string_or_code')\n", - "~~~\n", - "\n", - "The available location strings/codes from the documentaion are shown in the table below. If not specified it will be set to `loc='best'`.\n", - "\n", - "Location String |\tLocation Code\n", - "----------------| -------------\n", - " 'best' |\t0\n", - "'upper right' |\t1\n", - "'upper left' |\t 2\n", - "'lower left' |\t3\n", - "'lower right' |\t4\n", - "'right' |\t5 \n", - "'center left' |\t6\n", - "'center right' |\t7\n", - "'lower center' |\t8\n", - "'upper center' |\t9\n", - "'center' |\t10\n", - "\n", - "However, these locations are all inside the `Axes` (i.e. the actual plotting area). If we want the legend outside the plot, we could do it like this:\n", - "\n", - "*Note that I did not know how to do this myself before making the exercise. I just googled for the solution.*" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "x = [1, 3, 6, 9, 16]\n", - "y = [7, 3, 7, 1, 5]\n", - "y2 = [9, 5, 5, 2, 6]\n", - "y3 = [4, 6, 2, 6, 8]\n", - "y4 = [1, 8, 1, 3, 2]\n", - "plt.plot(x, y, 'k.-', label='Original curve')\n", - "plt.plot(x, y2, label='Second curve')\n", - "plt.plot(x, y3, label='Third curve')\n", - "plt.plot(x, y4, label='Fourth curve')\n", - "\n", - "# Set legend location via 'bbox_to_anchor'\n", - "plt.legend(bbox_to_anchor=(1.0, 0.5), loc='center left')\n", - "# The numbers in paranthesis are in fractions of figure width and height\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 1.6\n", - "Since we did not save the plot from Exercise 1.1-1.5 to a figure object, we need to repeat the code to create a new plot. This is becuase the `plt.show()` command shows and 'exhausts' the plot so it is inaccessible afterwards, unless it is saved in a figure object.\n", - "\n", - "So, we repeat the code, this time saving the plots to a figure object." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Create figure object to store plots inside\n", - "fig = plt.figure()\n", - "\n", - "# ---REPEAT CODE FROM EXERCISE 1.1-1.5 ---\n", - "x = [1, 3, 6, 9, 16]\n", - "y = [7, 3, 7, 1, 5]\n", - "y2 = [9, 5, 5, 2, 6]\n", - "y3 = [4, 6, 2, 6, 8]\n", - "y4 = [1, 8, 1, 3, 2]\n", - "plt.plot(x, y, 'k.-', label='Original curve')\n", - "plt.title('Title with random equation for showcase $c = \\sqrt{a^2+b^2}$')\n", - "plt.xlabel('This is the xlabel $x$')\n", - "plt.ylabel('This is the ylabel $y$')\n", - "plt.plot(x, y2, label='Second curve')\n", - "plt.plot(x, y3, label='Third curve')\n", - "plt.plot(x, y4, label='Fourth curve')\n", - "plt.legend(bbox_to_anchor=(1.0, 0.5), loc='center left')\n", - "\n", - "# Save figure to a file \n", - "fig.savefig('myfig.png')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In the saved png file, the legend appears to have been cut off. I dont' know why it cannot handle this. This would not have been a problem if it had stayed inside the plotting area.\n", - "\n", - "A way to get it to show correctly could be to create a new `Axes` object to the right of the `Axes` object that contains the plots. Recall the `Axes` is the \"plotting area\". \n", - "\n", - "So:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAvoAAAGMCAYAAACrjAaUAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzs3Xd4VNXWwOHfTk/oJbQACSGV3jvSFRAFBIQELFhAuSLKFSuC5fNelSJN0Gu9eqUpqIiI1ACh914SQg0t1ISSkLK/P85EI6ZNkpkzGdb7PPPInDmz95ozg6xZs84+SmuNEEIIIYQQwrm4mB2AEEIIIYQQouhJoi+EEEIIIYQTkkRfCCGEEEIIJySJvhBCCCGEEE5IEn0hhBBCCCGckCT6QgghhBBCOCFJ9IUQQgghhHBCkugLIYQQQgjhhNzMDkAIIYRwVEqpYn1VSa21MjsGIYR5lFwZVwghhPg7pVQgUEdrvdjsWIQQoiCkdUcIIYTIXldgpdlBCCFEQUmiL4QQQmTPR2t9y+wghBCioCTRF0IIIe6glCoLXDE7DiGEKAxJ9IUQQoi/uw/4Pb87K6VaK6U2KqXWKKXmKKXcbRibaXMKIYoXSfTFXUMptV8p1TGXx48rpbo66/zWUkp9rZT6P7PjsKe83qNCjBuqlNqplEpSSj1f1ONnmcehPkPFXBWt9Tkr9j8BdNZadwDigN5FEYRS6pRSqok95xRCOA9ZXlM4DaXU9Sx3fYAUIN1yf7jWum6WfY8DT2mtV9grvqzzmxWD+FN2x//O96gIvQxEaa0b22h8UYSUUm7AbWueo7U+k+VuGpBRBHGUBaoBh+w1pxDCuUhFXzgNrXXJzBtwEnggy7bvzI7PliyJiXBc/sB+a58k76vtKaVclFLjlFLjsmy+B1hXwPFqAT2AXJfkVEq9pZR6K4/h6gMntdY3i2JOIcTdRxJ9cdfIbGtQSn0L1AR+UUpdV0q9nM2+1ZRSC5RSCUqpYzm1WyilhiqlfslyP1YpNT/L/VNKqUZZ57f8OacYGiml9iilriml5imlvPJ4Pa8opfYAN5RSbkqpV5VSRy0tIgeUUn3v2P+lnMZXSjVWSu2wPHcekPWxcKVUlFLqqqW95cFsYhljGfuGUuoLpVRlpdRvlvFWKKXK5fA6cjzWd8aklJqbtZ1IKaWVUkFZ7n99x+PZHo+cjv8d71GOrzmvY3nH61sFdAJmWOYKycfYf3lfsxnzFaVUvOV1HVZKdcnycI6foZzmtfJzXEMptdDyfl1SSs3I63jnFnNu739OlFIRSqntltd4VBW+3epjjJ78TPW01vuymbeSUmqRUuq8UipRKfWLUqp0lsdLA/8FHtFaW/WLQA7qA4eVUpOVUleUUjFKqXZ3xFTUcwohnInWWm5yc7obcBzomtO23B7H+AK8HRgHeACBGP2v92UzTyBw1fKcqhg9s/FZHrsCuGQ3Zw73t2D8VF8eOAg8k8dr3AXUALwt2wZYnu8CDARuAFXzGt/yOk8ALwLuQH8gFfg/y/1Y4HXLfp2BJCD0jlg2AZUBP+ACsANoDHgCq4Dx2byGHI91bjFleb4GgrLc//qOx/M6Hjl9BnJ9zQV4r6Iw2oTI59h/eV/vGCsUOAVUs9wPAGrn4z3OcV7y+TkGXIHdwEdACYwvg+3yOt45xZzb+5/Lsfwnxq8jTSzPrw8EZHl8seW1ZHdbnMu4PwH+lj8/n8M+QUA3jM90eWAjMMbymBvwK0bPfH7+H/UW8FYe+3xiOfZ9LO/feOBglsetmlNucpPb3XeTir4Qf9cc8NVav6O1vq21jgM+AwbduaPlsSSgEdABY5WOeKVUmOX+Oq21NX2z07TWZ7TWl4FfLOPmtf8pbVnrW2v9veX5GVrreUAM0CIf47fCSCSmaK1TtdY/AFuzPFYSeN9yPFZhJFMRd8QyXWt9Xmsdj9H2sFlrvVNrnQL8iJH03ym3Y51bTPmSj+ORk/y8ZmvfK2vH/uN9vUM6RqJZRynlrrU+rrU+mo+4cpzXis9xC4xEfozW+obWOllrHZ05cS7HO6eY8/13DUAp5YuR7EZqrXdY5tmrtT6eJYZeWuuyOdx65fy2sAjorZSqSw5tVlrrWK31cq11iuX4Lgcyf6mKAFoC4yy/mgzMZa78qg98pLX+SWudCnwOhGb5lccWcwohnIj0fwrxd/5ANaXU1SzbXMm5Z3cN0BGj2rcGo3LYAWhtuW+NrKt83MRIqnJzKusdpdSjwGiMiikYiV3FfIxfDaOCq7M8fiLLY6fu+MJyAqNyn9X5LH++lc39ktnEn9uxzi2mfMnH8chJfl6zte+VNWOfIgda61il1AsYFeG6SqnfgdH6zxMzc3uPc5s3P5/jGsAJrXVadrHldLxzihnr/651BfZqrXfn8HhhLAa+wzgJ94vsdlBKDQBeAIIxfoHwAYYBaK2/Bb7NbQKl1GIgs/XGy7LtBcv96Gy+iNQDns5yvyJwLfP452dOIcTdTSr64m6lc3nsFHDsjkpgKa11zxz2z0yQ2lv+vAYjQepA7ol+bjHk1x9jKKX8MaqhzwEVtNZlgX2Aysc4ZwE/pVTWfWta/nsGqKGUcrnjsfjCBG6R27HOLaZMNzGSrUxVMv+Qj+OR2/G35WvOz9i5fja01rO11u0wEmUNfFAE8+bnc3wKqJnDeQO5Hu8cYrb271p5jC8gOVLGeSHXc7j9ltPztNYXMJL3Cpbq+Z3jdrbE/ALGl6aKGC1qu3KL5445/vi1AXgf49eVbH9tsBzP0kBCls0PISfcCiGsIIm+uFudx+gHzs4WINFy8qC3UspVKVVPKdU8h/3XYJxs6a21Po1RjewOVAB2FjCGgiiBkUAlgHGCJUZFMD82YizP97wyTup9iD9bXDZj9Fq/rJRyt5z4+AAwtwhizu1Y5xZTpl1ApOV53TGS0kx5HY/cjr8tX3OhxlbGmvydlVKeQDLGryXpeTwtP/Pm53O8BeML2PtKqRJKKS+lVFvLYzke71xitvbv2k6gnVKqoTIEK6XCs+6gte6hs6zAdcetRx7HaAnGOQLZaYjxxeQQRrvOl0Al4EAeYxZUfYzPf6QyVgbqCQwH3rHRfEIIJySJvrhb/RsYq4zVR17K+oDWOh0jAWoEHAMuYvTGlsluIK31EeA6lnYDrXUiRrKw3jKW1TEUhNb6ADAJI0E+j5EorM/nc29jVAsfxzj5byCwMMtjD2Is33cRmAk8qrXOdm1vK2PO8VjnFlMWoyzPvwoMxjihMnPsvI5Hbp8BW77mwo7tiVENvojRplMJ4wTbQs2bn89xlvcrCGMJ29MY70texzvbmAvwd20DxgniizHOKfgR8M7rtVvhC4xe/ex8h3HOyDnL/DHAAW27lW7qA98AbTE+/28BvbXWMTaaTwjhhNRf21+FEMJxKaW+Bk5rrceaHYsQQgjh6KSiL4QQQgghhBOSRF8IIYQQQggnJK07QgghhBBCOCGp6AshhBBCCOGEJNEXQgghhBDCCUmiL4QQQgghhBP629UNHUnFihV1QECA2WEIIYQQQjit7du3X9Ra+5odhyh6Dp3oBwQEsG3bNrPDEEIIIYRwWkqpE2bHIGxDWneEEEIIIYRwQpLoCyGEEEII4YQk0RdCCCGEEMIJSaIvhBBCCCGEE5JEXwghhBBCCCckib4QQgghhBBOSBJ9IYQQQgghnJAk+kIIIYQQQjghSfSFEEIIIYRwQnZN9JVSo5RS+5RS+5VSL9hzbiGEEEIIIe4mdkv0lVL1gKeBFkBDoJdSKthe8wshhBBCCHE3sWdFPxzYpLW+qbVOA9YAfe04f44u37jNrlNXzQ5DCCGEEEKIImPPRH8fcI9SqoJSygfoCdSw4/w5+sd3O3hu9g5S0zPMDkUIIYQQQogiYbdEX2t9EPgAWA4sBXYDaXfup5QappTappTalpCQYJfYnr6nFqev3GLhjtN2mU8IIYQQQghbs+vJuFrrL7TWTbTW9wCXgZhs9vmP1rqZ1rqZr6+vXeLqFFqJBtXLMGN1rFT1hRBCCCGEU7D3qjuVLP+tCTwEzLHn/DlRSjGqSzCnLt/ixx3xZocjhBBCCCFEodl7Hf0FSqkDwC/AP7TWV+w8f446h1Wivp9U9YUQQgghhHOwd+tOe611Ha11Q631SnvOnZfMqv7Jyzf5aadU9YUQQgghRPEmV8bNokt4Jer5lWbG6ljSpKovhBBCCCGKMUn0szCq+iGcuHSTn3adMTscIYQQQgghCkwS/Tt0Da9E3Wqlmb4qRqr6QgghhBCi2JJE/w5KKZ7vEsyJSzf5War6QgghhBCimJJEPxv31qlMnapS1RdCCCGEEMWXJPrZyKzqH790k0W7paovhBBCCCGKH0n0c3BvncqEVy3NjFWyAo8QQgghhCh+JNHPgYuLYlSXIOIu3uCXPVLVF0IIIYQQxYsk+rm4t04VwqqUYvrKWNIztNnhCCGEEEIIkW+S6OfCqOoHG1V96dUXQgghhBDFiCT6ebivrlHVn7YqRqr6QgghhBCi2JBEPw8uLsYKPHEJN1gsvfpCCCGEEKKYkEQ/H7rXrUJo5VJMWylVfSGEEEIIUTxIop8PmVX9owk3+HXvWbPDEUIIIYQQIk+S6OdTj3pVCKlcUqr6QgghhBCiWJBEP58yq/qxF66zRKr6QgghhBDCwUmib4We9aoSXMmo6mdIVV8IIYQQQjgwSfStkFnVj7lwnSX7pKovhBBCCCEclyT6VupZvypBUtUXQgghhBAOThJ9K7m6KEZ2DuLI+ev8tu+c2eEIIYQQQgiRLUn0C6BXg2rU9i3B1JVHpKovhBBCCCEckiT6BeBq6dU/cv46S/dLVV8IIYQQQjgeSfQLqFeDagT6lpBefSGEEEII4ZAk0S8gVxfF852DOXQuid+lqi+EEEIIIRyMJPqF8EDDagRWLMFUqeoLIYQQQggHI4l+Ibi6KEZ2CeLQuSSWHZCqvhBCCCGEcByS6BfSAw2qUatiCaaujJWqvhBCCCGEcBh2TfSVUi8qpfYrpfYppeYopbzsOb8tuLm6MLJzEAfPJrLswHmzwxFCCCGEEAKwY6KvlPIDngeaaa3rAa7AIHvNb0sPNqxGQAUfpq2MQWup6gshhBBCCPPZu3XHDfBWSrkBPsAZO89vE0ZVP5gDZxNZLlV9IYQQQgjhAOyW6Gut44GJwEngLHBNa73MXvPbWu9GRlV/qpNW9ZPTkll3ep1TvjYhhBDCYSRfg/0/QdwasyMRTsCerTvlgN5ALaAaUEIpNSSb/YYppbYppbYlJCTYK7xCc3N14bnOwew/k8iKgxfMDqfIzTs8jxErR7Dl3BazQxFCCCGch9Zwbh+smwxf9YQPasH3j8HWz82OTDgBe7budAWOaa0TtNapwEKgzZ07aa3/o7VuprVu5uvra8fwCq9Po2r4V/BhyoojTlf5Xnd6HQCzD842ORIhhBCimEtOhAOLYNFImFwHPmkLK9+GlERoOwqGLoX+X5kdpXACbnac6yTQSinlA9wCugDb7Di/zbm5uvBcpyDG/LCHlQcv0LVOZbNDKhI3Um+w/cJ2SrqXJOp0FPHX4/Er6Wd2WEIIIUTxoDVcOAixyyFmOZzcCBlp4FkaaneCoG4Q1BVKVzU7UuFk7Jboa603K6V+AHYAacBO4D/2mt9e+jb2Y/qqWKasPEKX8EoopcwOqdA2n91MWkYar7Z+lfEbxjPv0DxGNxttdlhCCCGE40q5DsfWQMwyiFkBiaeN7ZXrQevnIPheqNECXN3NjVM4NXtW9NFajwfG23NOe8us6r+8YA+rDl2gS3jxr+qvj1+Pj5sPPWv1ZM3pNSyIWcCzjZ7F283b7NCEEEIIx6A1JBz+s2p/YgNkpIJHKQjsAB1eNqr2ZeQXcWE/dk307xZ9m/gxfXUMU1fG0DmseFf1tdZEx0fTsmpL3F3diQiLYPmJ5SyJW0K/kH5mhyeEEEKY5/YNOLb2z6r9tZPGdt9waPUsBHeDGq3AzcPcOMVdSxJ9G3C3VPVfWbCX1Ycv0Dms+Fb1j107xpkbZ3iy/pMANKvcjOBywcw+NJuHgh8q1l9ihBBCCKtoDZdiLYn9cjixHtJvg3sJCOwI7V80+u3L1jA7UiEASfRt5qEm1Zm+KpapK2LoFFp8q/rr4o3Vdtr5tQNAKUVkWCRvb3ybbee30bxKczPDE0IIIWzr9k04vs5I7GOWwdUTxvaKodBimFG1r9ka3DzNjVOIbEiibyOZVf1XF+4l6nACncIqmR1SgUTHRxNYJpBqJav9se3+wPv5aPtHzDk0RxJ9IYQQzufS0T8T++PRkJ4C7j5QqwO0fd6o2pfzNztKIfIkib4NPdSkOjNWxzJlZQwdQ32LXVX/ZupNtp/fTkRYxF+2e7t50y+4H98c+IZzN85RpUQVkyIUQgghikDqLSOhj1lunEx7Oc7YXiEYmj9pqdq3AXcvc+MUwkqS6NuQh5sL/+gUxGsL9xJ1JIFOocWrqr/13FZSM1L/aNvJamDYQP574L/MOzyPUU1GmRCdEEIIUQiX44wTaGOWGa05acng5g212kOrEcYKOeVrmR2lEIUiib6N9WtSnRmWXv2OIcWrqr8ufh3ebt40rdz0b4/5lfSjQ/UO/HDkB4Y3GI6Xm1Q5hBBCOLDUZOPk2cyq/aVYY3v52tD0caMdJ6AtuMvS0cJ5SKJvY5lV/dd/3MvamIt0CPE1O6R8+WNZzSot8XDNflmwweGDWX1qNb8d+42+wX3tHKEQQgiRhyvHLYn9CmMZzNSb4OYFAe2ME2mDukKF2mZHKYTNSKJvB/2bVufj1bFMWXGEe4IrFouq/vHE48Rfj2do3aE57tOiSguCygYx59Ac+gT1KRavSwghhBNLSzEuVBVracm5eMTYXi4AGg+xVO3bgYePqWEKYS+S6NuBh5sLIzrV5o0f97Eu5iL3FIOq/vr49QC09Wub4z5KKSLCInh307vsSthF40qN7RWeEEIIYbh68s+qfdwaSL0Brh5GQt90KATfa1TtpRgl7kKS6NvJgKY1+HiVUdVvXwyq+tHx0QSUDqB6qeq57tcrsBdTtk9h9sHZkugLIYSwvbTbcHKj0WcfsxwSDhnby9aEhoOMxL5We/AoYW6cQjgASfTtxKjqBzH2p31Ex16kfbDjVvVvpd1i67mtPBz6cJ77+rj70Ce4D7MPzub8jfNULlF8rwIshBDCQV2L/zOxj4uC29fBxd04ebbxI8bylxVDpGovxB0k0bejAc0ye/VjaBfkuFX9ree2cjvjNu392udr/4jQCP534H/MPzKfkY1H2jg6IYQQTi89FU5tNvrsY1bAhf3G9jI1oP4AS9X+HvAsaW6cQjg4SfTtyNPNlRGdgnjzp32sj71Eu+CKZoeUrej4aLxcvWha5e/LamanRuka3FP9nj+W2sxplR4hhBAiR4ln/1q1T0kEFzeo2Rq6vWtU7X3DpGovhBUk0bezh5tVZ6ZlBZ62QRUcsqofHR9N8yrN8XT1zPdzIsMiGb5iOL8f/50Haj9gw+iEEEI4hfQ0OL3lz6r9+b3G9lLVoG5fI7Gv1QG8SpsbpxDFmCT6dubp5sqzHWsz7uf9bDh6ibZBjlXVP5l4klNJpxgSPsSq57Wq1oqA0gF8d/A7egX2csgvMEIIIUyWdM6y9OVyOLoaUq6BcjWq9l3fMlpyKtWRqr0QRUQSfRM83KwGM1cfZeqKGNrUdqyq/rr4dQD57s/P5KJciAyP5F+b/8Wei3to6NvQFuEJIYQoTtLTIH6bkdjHLINze4ztJatAnQeNqn1gR/AqY2aUQjgtSfRN4OVuVPXHL9rPxqOXaONAVf3o+Gj8S/tTo3QNq5/7YO0HmbpjKrMPzpZEXwgh7lbXL0DsSiOxP7oKkq8aVfsaLaHLOKNqX7meVO2FsANJ9E0ysHkNZkbFMmVlDK0dpKqfnJbM1nNb6R/Sv0DPL+Fegj5BfZh3eB5jbo2horfjfIERQghhIxnpEL/DSOxjl8OZncb2kpUh7H5L1b4TeJc1N04h7kKS6JvEy92VZzvU5q1fDrAx7hJtapufFG87v42U9BTa+bUr8BiDQgfx3cHv+P7w9zzb6NkijE4IIYTDuHHRqNrHLjf+e+syKBeo3hw6j4WgblClAbi4mB2pEHc1SfRNNKhFTWZGZfbqm5/or49fj6erJ80qNyvwGAFlAmjn1475R+bzVP2ncHd1L8IIhRBCmCIjw6jUZ1bt43cAGnwqQsh9ENQVancGn/JmRyqEyEISfRNl9uq//csBNh69ROvaFUyNJzo+mmZVmuHl5lWocSLDIhmxcgTLTizj/sD7iyg6IYQQdnXzcpaq/Qq4eQlQUL0ZdHrdSO6rNpKqvRAOTBJ9k0VkVvVXHqF17damxXEq6RTHE48zKGxQocdq69cW/9L+zD40WxJ9IYQoLjIy4Owuy/KXyyB+O+gM8KlgJPVB3YyqfQlzi1JCiPyTRN9kmb367yw+wKa4S7QKNOd/oNHx0QCF6s/P5KJcGBQ6iA+2fsD+i/upW7FuoccUQghhA7euGCvjxFiq9jcSAAV+TeCel40Vcqo1AhdXsyMVQhSAJPoOILJlTWatMXr1Ww0zL9GvUaoG/qX9i2S83kG9mbZzGrMPzea9du8VyZhCCCEKKSPDWMs+drlxNdrTW4yqvXc5qN3FSOyDukAJ888bE0IUniT6DsDL3ZVnOtTm3cUH2Bx3iZZ2ruqnpKew5ewW+gT1KbIxS3mUonft3iyIWcDopqOp4C0/9QohhCluXYW41X9W7a+fN7ZXbQTtXzKWv/RrKlV7IZyQJPoOYnDLmsyKOsrUlTHMtnOiv/38dpLTk2lf3bqr4eYlIjyCuYfn8sORHxjecHiRji2EECIHWsP5fUaffcwKOLUZdDp4lTV67DOr9iUrmR2pEMLGJNF3EEZVP5D/+/UgW45dpkUt+y1RFh0fjYeLB82rNC/ScQPLBNK6amvmH57PE/WfwN1FltoUQgibSL4GcVF/Vu2TzhrbqzSAdi9aqvbNwFX+2RfibmK3v/FKqVBgXpZNgcA4rfUUe8Xg6Aa39OeTNXFMXXmE755qZbd5M5fV9HbzLvKxI8MjGblqJCtPrqR7QPciH18IIe5KWsOFA0ZiH7McTm2CjDTwLAO1OxmJfVBXKFXF7EiFECayW6KvtT4MNAJQSrkC8cCP9pq/OPD2cGX4PYG8t+Qg245fplmA7av68dfjOXbtGANCBthk/PZ+7alesjqzD86WRF8IIQojJemvVfvEeGN75frQZqTRklO9OciFCoUQFmb9htcFOKq1PmHS/H+xceNGoqKi6NixI61bm7eWPcDgVjX5dK3Rq//tky1tPl/06aJbVjM7ri6uDAobxMRtEzl46SDhFcJtMo/IniN9toUQVtIaEg5ZqvbL4OQmyEgFj1JQuyN0fNWo2peuZnakQggHZVaiPwiYY9Lcf7Fx40Y6dOhAWloaXl5erFy50tSEyMfDjWH3BPKvJYfYfuIyTf1tW9WPPhONX0k/AkoH2GyOvsF9+XjXx8w+NJt3275rs3nEX23cuJHOnTuTkpLiEJ9tIUQ+pFyHY2uNxD52BVw7ZWyvVBdajzCq9jVaStVeCJEvdr9utVLKA3gQ+D6Hx4cppbYppbYlJCTYPJ6oqCjS0tLQWnP79m2ioqJsPmdehrTyp0IJD6asiLHpPLfTb7P57Gba+bVDKWWzeUp7lKZXYC+WxC3hSvIVm80j/mr58uUkJyejtSYlJcUhPttCiDtoDQlHYMMM+KY3fFgL5kbA3u+hakN4YCq8uB9GbIBu70BAO0nyhRD5ZkZFvwewQ2t9PrsHtdb/Af4D0KxZM23rYDp27IinpyfJyckopejYsaOtp8xTZlX/378dYvuJKzT1L2eTeXZc2MGttFs2a9vJKjIsku+PfM+CmAU8Vf8pm88nYMeOHX/8WWtN+/ZFu3yqEKKAbt+AY+ssF61aBldPGtt9w6DlcAjqBjVbg5uHuXEKIYo9u1f0gQgcpG0HoHXr1qxatYqmTZuilMLfv2iuDFtYj7T2p3wJD6autF1VP/p0NO4u7rSo0sJmc2QKKhdEyyotmXd4HmkZaTaf7243d+5cfv75Z4YMGcKgQYPQWhMfH292WELcnbSGi7GwcSZ82xc+qAVzBsKuOVC5HvT6CF7YC//YDPf+HwR2kCRfCFEklNY2L5r/OZlSPsApIFBrfS2v/Zs1a6a3bdtm+8CAuLg4QkJCeO6555gyxTFW/PxkzVHe/+0QC0e0oUnNoq/q9/mpD74+vnx272dFPnZ2Vp5cyQurX2Byx8l08+9mlznvRjExMTRp0oQGDRoQFRWFi4sLDRo0AGDv3r24uJjx/V6Iu8ztm3A8+s+q/ZXjxvaKIZYLVnUF/zbg5mlqmEIAKKW2a62bmR2HKHp2/Rdfa31Ta10hP0m+vQUGBvLoo4/y6aefcvbsWbPDAeCRVpaqvg169c9eP8vRa0ft0raTqWP1jlQrUY3ZB2fbbc67TXJyMgMGDMDDw4O5c+fi7u6Oq6srb775JgcOHOCHH34wO0QhnNelo7D5U/hfP6PXfvYA2PGt0ZLTcyKM2g3PbYX73jPWupckXwhhY1Lay+KNN94gNTWVDz/80OxQACjh6cbT7QNZcySBnSeL9iTW6DO2XVYzO64urgwMG8i289s4fPmw3ea9m4wePZrdu3fz3//+lxo1avyxfcCAAYSFhfHOO++QkZFhYoRCOJHUZGNlnN9egWlNYHoT+O1lo3rfdCgMWQivHIfIedDiaSgXYHLAQoi7jST6WdSuXZshQ4bwySefOExV/9HW/pTzcS/yXv3o09FULVGVwDKBRTpuXvoF98PL1Ys5hxzmNA2nMX/+fGbNmsVLL71Er169/vKYq6sr48aNY//+/SxYsMCkCIVwApePwZbP4LsB8EGAUb3f/jVUqA09JsDzO2HkdujxPgR1AXcvsyMWQtzF7Nqjby179uhnio2NJSwsjOeff57Jkyfbde6czIyK5cOlh/npH21pVKNsocdLTU+l3dx23B94P+NajyuCCK3z1oa3+DXuV1YMWEEZzzJ2n98ZHT16lMaNG1O3bl3Wrl2Lu/u7G/hNAAAgAElEQVTfl99LT0+nXr16uLm5sXv3bunVFyI/0lLgxHrLRauWwyVL0aVcLaPXPvheCGgL7t7mxilEIUiPvvOSf+nvEBQUxODBg/nkk084d+6c2eEA8GjrAMr6uDN1xZEiGW/nhZ3cTLtp17adrCLCIkhOT2ZhzEJT5nc2KSkpPPzww7i5uf3Rl5+dzF79ffv2sXChHHshcnTlBGz9HGYPMqr23/aFrV9A2ZrQ/QMYuQNG7YKeH0JwV0nyhRAOSxL9bIwdO5aUlBQmTJhgdigAlLT06q8+nMDuU1cLPV50fDRuLm60rNqyCKKzXmj5UJpWbsq8w/NIz0g3JQZnMmbMGHbs2MFXX32V5/KwAwcOJDQ0VHr1hcgqLQXiouD3N2BGC5jaAH79J1w4AI0GQ+R8o9f+kYXQ6hmjTUcIIYoBSfSzERwczODBg5k1axbnz2d7XS+7e6yNpapfBL360WeiaVKpCSXcSxRBZAUzOHww8dfjWXN6jWkxOIOFCxcyffp0XnjhBXr37p3n/plV/b179/Ljjz/aIUIhHNTVU7DtS5gTaaxr/01v2PIfKF0N7vsXPLfNWCXn/okQch94+JgdsRBCWE169HNw5MgRwsPDefHFF5k4caIpMdzp49WxTPj9MIuea0uD6gXr1T934xzdfujG6KajGVpvaBFHmH9pGWn0WNgD/1L+fH7f56bFUZzFxcXRpEkTQkJCiI6OxsMjfxfYSU9Pp06dOnh5ebFz507p1Rd3h7TbcGrTn732CQeN7WVqQnA34xbQHjxLmhunECaQHn3nJf/C5yAkJITIyEhmzpzJhQsXzA4HMFbgKePtXqh19dfHrwfsu6xmdtxc3BgYOpDN5zYTeyXW1FiKo9u3bzNo0CAA5s2bl+8kH4yq/tixY9mzZw8//fSTrUIUwnyJZ2D7f2HuYPgwEP77AGyaBSUrGVeg/ccWeGEP9JoMoT0kyRdCOB1J9HPhaL36pbzceapdLVYeusDe0wW75lh0fDSVfSoTVDaoiKOzXr/gfni4eMhSmwXwyiuvsHXrVr766itq1apl9fMjIiIIDg6WXn3hXNJT4fh6WD4eZrWFyeHwy/NwZhfU7weDZsMrx+CxRdBmJPiGglJmRy2EEDYjiX4uQkNDiYiIcKiq/mNtA4yqfgF69VMzUtl0dhPt/NqhHOAft3Je5ehRqwe/xP1C4u1Es8MpNn7++WemTJnCyJEj6du3b4HGcHNzY+zYsezevZtFixYVcYRC2FHiWePqs/MeMar2X/eEjTPAuxx0ewee3Qgv7oMHpkLY/eBZyuyIhRDCbiTRz8PYsWO5desWkyZNMjsUAEp7ufNku1qsOHieffHWVfV3X9jN9dTrprftZBUZHsmttFv8GCMnhubHiRMnePzxx2natGmhf2mKjIwkKCiIt99+G0c+V0eIv0hPgxMbYcXb8Ek7mBwGi56D01uhbh94+Ft4+Rg8vhjajoLKdaRqL4S4a0min4ewsDAiIiKYMWMGCQkJZocDwONtAyjt5WZ1VT86Pho35Uarqq1sFJn16lSoQ+NKjZl7aK4stZmH1NRUBg0aREZGBvPmzcPT07NQ42VW9Xft2iVVfeHYks7Dzu/g+8dhQiB81R3WTwXP0tD1LXhmPYw+CA9OhzoPgldpkwMWQgjHIIl+PjhmVT+Q5Qesq+pHx0fTqFIjSno41glnkWGRnL5+muj4aLNDcWivv/46mzZt4vPPP6d27aJZx3vw4MHUrl1bqvrCsWSkw8nNsOr/4NN7YFII/DzCqOSHPwAD/gsvx8HQJdDuRahST6r2QgiRDUn08yE8PJxBgwYxY8YMLl68aHY4wJ9V/Wn5rOpfuHmBw1cOO1TbTqYu/l2o5F2J2Ydmmx2Kw1q8eDETJ07k2WefZcCAAUU2bmZVf+fOnfzyyy9FNq4QVrueALvnwg9PwITa8OW9sG4SuPtA5zdh+Dr45yHo/bHRouNdsCWGhRDibiKJfj69+eab3Lx502Gq+mW83XmiXS2WHTjP/jN5V/UdZVnN7Li7uPNw6MNsOLOBuGtxZofjcE6dOsVjjz1Go0aNmDx5cpGPP2TIEAIDA6WqL+wrIx1ObYXV/4L/dISJwfDjcDi2DkJ6QP+vjKr9E0vhnpegagOp2gshhJUk0c+n8PBwBg4cyPTp0x2mqj+0bS1K5bOqvy5+HZW8KxFSLsQOkVmvf0h/3F3cmXNQltrMKrMv//bt28yfPx8vL68inyOzqr9jxw4WL15c5OML8Ycbl2DPfFjwFEwIgi+6wtoJ4OIOnd6AYVHwz8PQdxbUe8hYOUcIIUSBSaJvhcyqvi2qqgVRxtudJ9rW4vf95zlwJuflKdMy0th0ZhNt/do6xLKa2angXYHuAd1ZdHQR129fNzsch/Hmm2+yYcMGPvvsM4KDg202z5AhQ6hVq5ZU9UXRysiA+O0Q9T581sVoyVn4NBxdDcH3Qr8vYMxReGo5dBgD1RqDXKlZCCGKjPwf1Qp16tRhwIABTJ8+nUuXLpkdDgBPtK1FKc/cq/p7EvaQlJrkkG07WUWGR3Iz7SY/H/3Z7FAcwm+//cYHH3zAsGHD/rgKrq24u7szduxYtm/fzq+//mrTuYSTu3kZ9v4AC4cb7TifdTYSfYCOr8HTq+ClGHjoU6jfH3zKmxuvEEI4MeXI1btmzZrpbdu2mR3GX+zbt48GDRrw2muv8d5775kdDgCTlx9h2soYfhvVnvCqf19WbtqOaXy570vWDlpLaQ/HXnZu8JLBXEu5xqI+i3BRd+/30NOnT9O4cWOqVavGpk2b8Pb2tvmcqamphIaGUqFCBbZs2eKwv/4IB5ORAed2Q8wKiFkG8dtAZ4B3eQjqCsHdoHYXKFHB7EiFEDlQSm3XWjczOw5R9O7eTKqA6tWrR//+/R2qqv9kHlX96PhoGvo2dPgkH4ylNk8knvjj5OG7UVpaGhEREdy6dYv58+fbJckHo6r/xhtvsG3bNpYsWWKXOUUxdesK7FsAPz4Lk0KNk2lX/x9kpME9Y+CplTAmFvp9Bg0eliRfCCFMIol+AYwbN46kpCQ++ugjs0MBoIyPO0PbBvDbvnMcOvfXXv2Lty5y8PJB2ldvb1J01rnX/14qele8q5faHD9+PNHR0XzyySeEhobade5HH32UgIAA6dUXf6U1nN0NayfCF/fBh4HGMpiHl0Ct9tD3U3gpFoathk6vQ/Vm4OJqdtRCCHHXk0S/ADKr+tOmTePy5ctmhwPAE+1qUTKbqn5mZbxttbZmhGU1d1d3BoQMIDo+mhOJJ8wOx+6WLVvGv//9b5588kmGDBli9/nd3d15/fXX2bp1K0uXLrX7/MKBJF+D/T/BT/+ASWHGhatWvQtpydD+n/DkcmP5y/5fQsNBUNLX7IiFEELcQXr0C2jv3r00aNCAsWPH8u6775odDgCTlh1m+qpYfn/hHkKrlAJgzJoxbDu/jVUDVhWbnuuEmwnc+8O9DAobxCstXjE7HLs5c+YMjRo1onLlymzevBkfHx9T4rh9+zYhISFUrlyZTZs2FZvPjSgkreH8fqPPPnYFnNwEOh28ykDtzsYqObW7QKnKZkcqhChi0qPvvKSiX0D169enX79+DlXVfzKzqr/KqOqnZaSx4cwG2lZz3GU1s+Pr48u9AffyY+yP3Ei9YXY4dpGens7gwYO5ceMG8+fPNy3JB/Dw8OD1119ny5Yt/P7776bFIewgOREOLIJFI2FyHfikLax8G1ISod0LMHQpjImDAV9Do0hJ8oUQopjJd6KvlFqhlGpoy2CKm3HjxpGYmMiUKVPMDgWAsj4ePNbGnyV7z3LkfBL7Lu4j8XYi7ao79rKa2YkMj+RG6g0WHV1kdih28c477xAVFcXMmTMJDw83Oxwef/xxatasyVtvvSW9+s5Eazh/AKKnwNe94MNaMP8Ro0WnRnN4cAaMPgTPREOXceDfGlzdzI5aCCFEAeW7dUcp1QSYCJwAXtdan7VlYODYrTuZ+vXrx4oVKzh+/Djlypl/FccrN27T7oNVdAqrRGj4ej7f+zlrB66ljGcZs0OzitaaiF8jjHX1e/9crH6RsNbKlSvp1q0bjz76KF9//bXZ4fzh008/5ZlnnmHp0qXcd999ZocjCiolCeLWQOxyYwnMxNPG9sr1LMtf3gs1WoCru7lxCiFMI607zsvqHn2lVD9gHLAQ+FBrfcsWgUHxSPR3795No0aNGD9+PG+99ZbZ4QDw4dJDzFpzlIYtvqaUpxff9vzW7JAKZNHRRbwR/QafdvuUNtXamB2OTZw7d45GjRpRvnx5tm7dSokSJcwO6Q+3b98mKCgIPz8/NmzY4NRftpyK1pBw2JLYL4MTGyEjFTxKQe2OENTNSPDL+JkdqRDCQUii77ys6tFXxr/0h4FZwEggRin1iC0CKy4aNmxI3759mTJlClevXjU7HACeah+Ij9ctjiYecvir4eame0B3ynuVZ87BOWaHYhOZffmJiYnMnz/foZJ8+LNXf9OmTSxfvtzscERubt+Aw7/B4hdhSgOY2RKWjYUbF6HVs/DYYmOFnIH/g6aPSZIvhBB3CWt69KOBeOAjwA94HOgItFBK/SefY5RVSv2glDqklDqolGptfciOZ9y4cVy7do2pU6eaHQoA5Ut40K6BcTEvf+8mJkdTcB6uHvQP6c+a02s4lXTK7HCK3HvvvceqVauYMWMG9erVMzucbA0dOpTq1avLuvqORmtIOAIbP4Zv+sAHATBnEOyeB1XqQ68p8MI+GLER7n3XWOvezcPsqIUQQtiZNT369YD9OpsnKKUOaq3zPINQKfVfYJ3W+nOllAfgo7XOsQxeHFp3MvXt25fVq1dz/PhxypYta3Y4vLDqJVYcW08n7xlMj2xqdjgFdv7Gebov6E5keCRjmo8xO5wiExUVRZcuXYiMjOSbb75x6LaYWbNmMWLECJYtW0a3bt3MDufudfsmHF9ntOPELIerlutMVAyF4G7GrWZrcPM0N04hRLEjrTvOq0jW0VdKBWqt4/LYpzSwGwjM7stCdopTor9z506aNGnC22+/zbhx40yNJT0jnQ7zO1BeNWLvrh4sf/EegiqVMjWmwnhpzUtsOLOBFf1X4ONu3rKTReXChQs0atSI0qVLs23bNkqWLGl2SLlKSUkhKCgIf39/1q1b59BfSpzOpaN/JvbHoyE9Bdx9oFYHCO5q9NuX8zc7SiGEDWit7fb/W0n0nVeRrKOfV5JvEQgkAF8ppXYqpT5XSjlWU3IhNG7cmN69e/PRRx9x7do1U2PZd2kf11KuMaTBvXi5uTJ9VWzhBz2+HhY8BTftf82AyLBIkm4nsThusd3nLmoZGRk88sgjXLlyhfnz5zt8kg/g6enJa6+9xvr161m5cqXZ4dwdjq2FaY1hehNY+ipcPQnNn4JHfoSXj0HkXOO+JPlCOJ1Tl28y4rvtzIw6anYowgnY84JZbkATYJbWujFwA3j1zp2UUsOUUtuUUtsSEhLsGF7hjRs3jqtXrzJt2jRT41gfvx4X5cK9te7h0Tb+/LL7DLEXrhd8wOPR8F1/2Ps9/DTC6A+2o8aVGhNePpw5h+YU+z7x999/n2XLljF16lQaNGhgdjj59uSTT+Ln5ye9+vaQeAa+fxxQ0HMiPL8LRm6D7v8yrlDr7mV2hEIIG7ieksaHSw/RZfIaVh9KwMNVrmkqCs+en6LTwGmt9WbL/R8wEv+/0Fr/R2vdTGvdzNfX147hFV6TJk144IEHTK/qR8dHU69iPcp6lWVY+0A83VyZYblartWOR8N3A6BsTejwChz5zTgB0I6UUkSERRB7NZYt57bYde6itHbtWt58800GDRrE008/bXY4Vsms6kdHR7Nq1Sqzw3Fe6Wnww5OQmgyR86DF01C+ltlRCSFsKCND8/22U3SaGMXMqKPcX78qq17qwNP3BJodmnACeSb6SqkkpVSi5ZaU5X6SUioxvxNprc8Bp5RSoZZNXYADBYzbYY0fP54rV64wffp0U+a/nHyZfRf3/bGsZoWSnjza2p9Fu89wNMHKqv7x9UaSX6YGPPYLdHwNwnrBivFw2r7nTvSo1YOynmWZfXC2XectKgkJCURERBAYGMinn35aLPvcn3zySapVqyZVfVuK+jec3AC9PoKKwWZHI4SwsW3HL9Nn5nrG/LAHv7LeLBzRho8GNqJqGW+zQxNOIs9EX2tdSmtd2nIrleV+Ka11aSvnGwl8p5TaAzQC/lWQoB1Z06ZN6dWrF5MnTyYxMd/fg4rMhjMb0Gja+7X/Y9vT92RW9a3o1T+xwZLkVzeS/JKVQCnoPQNKV4Pvh8KtKzZ4BdnzcvOiX3A/ok5Hceb6GbvNWxQyMjJ49NFHuXTpEvPnz6d0aWv/2jgGLy8vXn31VdatW0dUVJTZ4Tif2JWwbhI0HgINB5odjRDChuKv3mLknJ30/2QjFxJT+GhgQxY+24YmNcuZHZpwMtaso6+UUkOUUm9a7tdQSrWwZjKt9S5LW04DrXUfrbX9MkU7MrOqHx0fTTnPctSpUOePbRVLevJIa39+3hVPXH6q+ic2wv/6GxfVeWwxlKr852Pe5aD/V5B0Bn76h1379QeGDkShmHt4rt3mLAoTJkxg6dKlfPTRRzRu3NjscArl6aefpmrVqg5zFWinkXgWFg4D3zDoMcHsaIQQNnLzdhqTlx+hy6Qolu0/x/Odg1j1Ugf6Nq6Oi0vx+6VXOD5r1tGfBWQAnbXW4UqpcsAyrXVzWwVXnJbXvFOvXr3YuHEjx44ds1sFN0Nn0HFeR9r4teH99u//5bGEpBTaf7iKnvWqMnlgo5wHObkJ/tcPSlWFxxdDqSrZ77dhBix7A7q/b1x5005GR41m89nNrBiwAm83x/9pc/369XTo0IGHHnqIefPmFcuWnTtNmzaNUaNGsXr1ajp27Gh2OMVfRjp80xvit8PTq6FSmNkRCSGKmNaan3ed4f3fDnEuMZleDaryao8wqpdzjCWjs1tec/v27ZXc3Nw+B+ph33M6Rf5lAPvS0tKeatq06YXsdnCzYrCWWusmSqmdAFrrK5aLXolsjB8/nhYtWjBjxgxef/11u8x54NIBrqRc+aM/PyvfUp480sqfL6KPMbJLMLUqZrOyaX6TfIDW/zBO1F32JtRoAX72uShXRFgEy08sZ0ncEvqF9LPLnAV16dIlBg0ahL+/P5999plTJPlgVPXff/993nrrLWnhKQprPjAuhNVnliT5QjihXaeu8vYv+9l58ir1/cowPbIxzQPKmx1Wntzc3D6vUqVKuK+v7xUXFxc5McsBZWRkqISEhDrnzp37HHgwu32s+YaWqpRyBTSAUsoX45uEyEbz5s3p2bMnkyZNIikpyS5zrotfh0LRtlrbbB8fdk9tPNxcsu/VP7nZkuRXyTvJB6Nfv89MY7/vh8KtHC9wXKSaVW5GcLlgZh+a7dAnhGZkZPDYY49x4cIF5s+fT5kyZcwOqch4e3vzyiuvsGbNGkn0CysuCtZ8CA0joVGk2dEIIYrQuWvJjJ63iz4fr+f0lVtM6N+An//Rtlgk+Rb1fH19EyXJd1wuLi7a19f3GsavLtnvY8V404AfgcpKqfeAaJzwZNqiNH78eC5fvszHH9tnOcrMZTXLeWV/Mo9vKU8Gt/Tnp13xHL94488HTm35M8l/LB9Jfiaf8tD/S0iMh0Uj7dKvr5RicNhgjlw5wvbz220+X0FNnjyZX3/9lYkTJ9K0qX1+7bCnYcOGUaVKFd5++22zQym+ks7DgqehYgjcP9HsaIQQRSQ5NZ3pK2PoNDGKxXvPMqJjbVa/1JEBzWoUtz58F0nyHZ/lPcoxn893oq+1/g54GSO5PwP00Vp/X+gInViLFi3o0aMHEydO5Pr1QlywKh+uJl9lb8LebNt2shreIRA3F8WM1Zaq/qkt8O1Dxqo6jy2G0lWtm7hGC+gyDg4ugq2fFzB66/QM7Elpj9LMPuSYS21u2rSJ1157jYceeojnnnvO7HBsIrOqHxUVxdq1a80Op/jJSIeFT0NKEgz4Gjyc5iLhQty1tNYs3nOGLpPWMGn5ETqG+rJydAde7h5GSU9rOqVFpqNHj7p36dKltr+/f70aNWrUGzp0aI3k5ORsvy0dP37cvXv37nlefKBDhw5BFy9edC1IPKNHj642bty4ynnv6TisWXXHC+gJdAU6A90t20Quxo8fz6VLl2xe1c9cVjOvRL9SKS8Gt/Tnx53xnN2/1pLk+xrtOtYm+Zlaj4Tge+H31+HMroKNYQVvN2/6Bfdj1clVnLtxzubzWePy5csMHDiQ6tWr88UXXzhNX352hg8fLlX9glo7EY6tgZ4fQuU6ee8vhHBoe09f4+FPN/Lc7J2U9nZnztOtmDWkKTXKO8bJtsVRRkYGffr0CXrwwQevnjhxYt+xY8f23bhxw2XUqFF+d+6bmppKQEBA6tKlS+PyGnfNmjWxFStWTLdN1NZLTU216fjWtO58A9TFaOGZAYQD39oiKGfSsmVLunfvzoQJE2xa1V9/Zj1lPctSt0LdPPd9pkMgTVxiKbtgEJSoaKnkVyv45C4u0OcT8KkI3z8Oyba/fsDAsIFoNPMOz7P5XPmltWbo0KGcPXuW+fPnU7ZsWbNDsilvb29efvllVq1axbp168wOp/g4tg7WvA/1H4bGj5gdjRCiEC4kJTPm+908+HE0cQk3+PdD9Vk8sh2ta1cwO7Ri75dffinl6emZMWrUqEsAbm5ufPLJJ6fmzZtXMSkpyWXatGkVevToEdi5c+eg9u3bhxw+fNgjODi4LkBSUpJLz549A0NCQurcf//9gQ0aNAhbu3atD4Cfn1/9s2fPuh0+fNgjMDCw7qBBg/yDgoLqtm3bNvj69esKYNKkSRXr1asXHhoaWue+++6rnZSUlGu+fOrUKbdu3brVDg0NrRMaGlpn+fLlJbLGAzBu3LjKo0ePrgbQokWL0Oeee86vefPmoa+++mpVPz+/+unpxnePpKQklypVqjRISUlR+/fv92zfvn1w3bp1w5s2bRq6c+dOqwvs1iT6oVrrJ7XWqy23YUCItRPejTKr+jNnzrTJ+Bk6g+j4aFpXa42rS96/RlVK3M+3Hu9zIb0kp/t8b6yXX1glKhj9+ldPwi/P27xf36+kHx2qd2DBkQWkpKfYdK78mjp1KosWLeLDDz+keXObrTrrUIYPH07lypWlqp9f1xNgwVNQPhB6TTZOahdCFDvJqenMjIql04QoftoVz9PtA1k9piMRLWriWrz68IvUihUrSrz22mtVVqxYUeh+xL1793o3bNjwZtZt5cuXz6hatertAwcOeALs2LGj5Jw5c45t2rTpSNb9JkyY4Fu2bNn0I0eOHHjrrbfOHDhwINt4Tp486fX8889fiI2N3V+mTJn0b775phzA4MGDr+zbt+/g4cOHD4SGht6aNm1axdxifeaZZ2q2b98+6fDhwwf2799/oEmTJsl5vb6rV6+6bt269fCkSZPOhoWF3VyyZEkpgLlz55bp0KHDNU9PT/3UU0/5z5w58+T+/fsPTpgw4fSzzz5bM69x72RN09hOpVQrrfUmAKVUS2C9tRPejVq1asV9993HhAkTGDFiBCVLlizS8Q9ePsjl5Mt/uRpujuK3w7d9cS9VkUcvjaHl1pt86F9Egfi3hs5jYeXbENAemj9ZRANnb3D4YFafWs1vx36jT1Afm86Vl61bt/Lyyy/Tu3dvRo0aZWos9uTj48PLL7/MP//5T6Kjo2nXLvfWsbtaRgb8OAySr8KQBeBZyuyIhBBW0lrz+/5zvLfkIKcu36JreGXeuD88+yWrncgTTzxRY9++fbn2ISUlJbkcPnzYR2vNBx98QGho6M1SpUrluDpjvXr1bn755Zencnpca41S6m9VQ8t2ANq3b59YuXLlv7XhbNiwoeSoUaMuADRv3jw5JCTk5p37APj5+aW0adPmFkDjxo1vHj9+3BNg+/bt3uPGjfNLSkpyvXHjhmuHDh2u5fbaN2zYUOqHH344BsYvDxUqVEjP6zyAiIiIy5l/HjBgwJU5c+aUe+CBB5Lmz59ffsSIEQnXrl1z2blzZ8kBAwbUztzv9u3bVn+LzLOir5Taq5TaA7QENiiljiuljgMbgXusnfBuNX78eC5evMisWbOKfOzo09EAtKnWJvcd47fDN33BpxyuTyyhU4smLNwRz8lL2X7+C6btCxDUFZa+Bmf3FN242WhRpQVBZYOYfdDcpTavXr3Kww8/TNWqVfnyyy+dui8/O8888wyVKlWSqn5eoifD0VXGReaq5LgSmhDCQR04k0jEZ5t45n878HZ35dsnW/D5Y82cPsnPr6SkJLfMf4u11iQlJRXqDOT69evf2rVr118O7uXLl13OnTvnER4engLg4+OT7ReJ/OYEHh4ef+zo6uqq09LSFMCwYcNqzZgx4+SRI0cOvPLKK2dSUlKsvmCYm5ubzsj4M7zk5OS/jJH1S1BERMTVqKioMufPn3fdt2+fzwMPPJCYnp5OqVKl0g4dOnQg8xYXF7ff6jjysU8vawcVf9e6dWu6dev2R1W/RImi+x9DdHw0dSvUpYJ3Lj2B8TuMJN+7rNGTX6Y6z3asyOwtJ/l4dSwf9G9QNMG4uEDfT+GTdka//vA1NqtcKqWICIvg3U3vsithF40rNbbJPLnRWvPEE09w+vRp1q1bR/nyxWZ95CKTWdV/6aWXWL9+PW3bZn8dh7vaiQ2w+j2o1w+aPm52NEIIK1y8nsKkZUeYt/UkZbzdebd3XSJa1MTN9e65WGxulfdMK1asKNGrV6+QtLQ0Fzc3t4yvv/46rmvXrjfyel5OHnzwwaSxY8e6zJgxo8Jzzz13KS0tjREjRtQYMGDAxdx+KQBo06bN9blz55Z74IEHkrZv3+515MgRb2vmvnnzpkvNmjVTU1JS1Ny5c8tXrVo11zNm27ZtmzRhwpf32cQAACAASURBVATfcePGXUhLSyMxMdGlevXqaZcvX3Y7d+6ca5kyZTJ+//33Ml26dMn2JMYyZcpkNGzY8Mbw4cNrdunS5Zqbmxvly5fPqF69+u0vv/yy3BNPPHElIyODzZs3e7du3fqWNa8lz0+p1vpE5g1IBCoD/lluIp/Gjx9PQkJCkVb1r6VcY8/FPbT1yyW5OrMTvu1jJPmP/wplawBQubQXkS1qsmDHaU5dLsKqfomK0O8LuHIMfnnBpv36vQJ7Ucq9FLMPmrPU5owZM/jxxx/597//TatWrUyJwRE888wz+Pr6SlU/Ozcuwg9PQrkA6DVF+vKFKCZup2Xw2do4Ok2I4vttp3isTQBRL3XikdYBd1WSn19du3a9sXjx4iNjxoyJX7x48ZHCJPkALi4u/PTTT7ELFy4s5+/vX69WrVr1PD09M6ZNmxaf13PHjBmTcOnSJbeQkJA67733XpXQ0NBb5cqVy/dKO6+++uqZFi1ahLdv3z4kODg4z377WbNmnVyzZk2pkJCQOvXq1auzY8cOb09PT/3Pf/7zbIsWLcK7dOkSFBQUlOs4Dz/88JWff/65fNaWnjlz5sR99dVXFUNDQ+sEBwfXXbBggdWrfKj8/ryhlHoKGAVUB3YBrYCNWuvO1k6aX82aNdPbtm2z1fCm6NatG3v27CEuLq5IqvpLjy9lzJoxfNvjWxpVavT3Hc7sgm8eBK8yliT/r+dx/D975xkV1dWF4efSO2IBFFBUugUNil2xa6yxInZji11j1CSWiLFFk5iosSt2xIolUWMHu6ig0sSKFFFBAelwvx8DifkstIEB5j5rzQJuOecFhuGdffbZO/pNCi1/Okuvz8xY0ltOUf0czi+Dsz9Ct9+KNIq57PoydgXt4njv45joFl95Wz8/P5o2bUqHDh3w9vZGRUW5X/iXL1/ON998w8WLF2naNJc0MmUhKwt29YVHF2DkKajsqGhFEhISuSCKIqeDYlj4ZxCPXr7FxbYSs7s4YGUs3/11JQlBEPxEUWzw7jF/f//Hjo6OLxWlqTBkZGSQlpYm6OjoiPfu3dPs0KGDzYMHD+5qaWmVyQZg/v7+FR0dHS0/dC4/zmQy0BB4Iopia6A+8KLw8pSLefPmERMTw9q1a+Uynu8zXww0DKhTsc77JyNvw7YeoGkoS9cp9/5mbVNDLQY4W7DPT85RfYAW06CGC/w1E6Lvynfsd3C1cyVTzMQr1KvI5vh/3rx5Q79+/TAxMcHDw0PpTT7AV199JUX1/59Lv0HYKei4SDL5EhKlgNDnCQzZfI2R226gIsCW4Q3xGO5cpk1+WSQhIUHF2dnZztbW1uGLL76o+euvvz4pqyY/N/LjTlJEUUwBEARBUxTFYMC2aGSVXZo3b07btm356aefSEoqnLHOErO4GHmRplWavl9WM8o/2+QbyJphGX08y2qsS01UBIE/zoUVSs97qKhCrw2y1YS9wyC1aPoIWOhb0NK8JftC95GWmVYkc7yLKIqMGjWKJ0+e4OnpSYUKUr1kAF1dXaZPn87Jkye5fPmyouUonqdX4PQCcOgBDUcqWo2EhMQniHubxlzvu3T+zQf/8NfM7erA8SktaW1rrGhpEgXAyMgoK6c8ZmhoaGC/fv2KvsFPCSU/Rv+ZIAjlgEPA34IgeAORRSOrbCOvqH5IbAgvk1++3w03KiDb5OvnavIBKhtq4+pswd4bz3gWJ+eovp4x9N4IsQ/g2NdFlq/vZudGbEosJx6fKJLx32Xt2rXs3buXhQsXSikq/8e4ceOoWLGiFNVPioV9I2T7YbqvlPLyJSRKKOmZWWz2fUSrZWfZceUJbs5VOfdNa0Y0r466lIcvUQbI87NYFMUvRFF8LYriD8AcYBOg2OLlpZQWLVrQpk2bQkf1fSNkZTX/sxE3KkCWk6+hlyeTn8NX2VH91WcfFFjPR6neElrNhABPuL1T/uMDjas0xtLAssg35d66dYupU6fSuXNnvvnmmyKdqzSip6fH9OnTOXHiBFeuXFG0HMUginDoK3j7Avp6yFa0JCQkShxnQ2LotOIC7kcDqWtejr8mt2RBz9qU19VQtDQJCblRoLeroiieF0XxsCiKRZ8nUUaZN28ez58/Z/369QUewzfCF/vy9lTUzm7YFn1HZvLVdWHoEVmVjzxS2VCbfg3N2ecXTsTrfFVuyhstv5EZ/mPTISZI7sOrCCq42btx99VdAl4UTf3++Ph4+vXrR4UKFdi6dauUl/8Rxo8fT4UKFZQ3qn95FYQehw4/QpXiL/kqISHxacJiEhm25RrDt1wnM0tk45AGbP/SGVtTqYmdRNkjLw2zEgRBiH/nY/y7XxeHyLJIy5Ytad26NUuXLiU5Of/GOj4tHv8X/v+m7UTfga3dQV1HFskvXz3fY45zsQLgj7NyztWH7Hz9jaCpJ8vXTytU1a0P0r1md3TVddkZJP9VA1EUGTNmDA8fPmT37t1UqlRJ7nOUFXKi+sePH+fatWuKllO8hF+HUz+AfTdwHq1oNRISEu/wJimd+Ufu0WnFBfwex/H95/acnNqKdg4mStfoUEJ5yEsdfX1RFA3e+Wjw7tfFIbKsMm/ePKKjowsU1b8SeYVMMVNm9KPvZpt87QKbfIAq5bTp18ACrxtFFNXXN5Ftzn0RAn/KP+1FV12XnlY9OfnkJC+T5VsRbMOGDXh6erJgwQJatpQaQueGUkb1k2Jh33AwqALdV0l5+RISJYSMzCy2X36My/KzeFx6TN8GFpz9xoVRLWugoSatzJZkZs6caWplZVXLxsbGwc7OzuHMmTPF3ob46NGj+q1bt7Yq7nnlRZ6f4YIgTMjejCshJ1q1aoWLiwtLlizJd1TfN8IXfQ196mapydJ11LRk6TrlaxRK07js5/IaeVfgyaFma2g5XZarf3u33Id3tXUlIyuDvSF75TZmQEAAkydPpkOHDsyaNUtu45Zl9PX1+frrr/nzzz+VI6oviuA9HhKioY+HrDmdhISEwvG9/5Iuv/syx/setqb6HJvYgsW96lBRT1PR0iRy4dSpU7onTpwod+fOncDQ0NDAs2fPhtaoUaNMpIynp3+y0a5cyc9bWVPghiAIXoIgdBKkdS65kBPV37BhQ57vEUWRixEXaVK+Fmrbe4KqpiySX6FmofWYldOmbwML9lwPJ7IoovoArWZBtWZwbJosui9HLA0taW7WHK9QL9IzC/+HlJiYSL9+/TAyMmL79u1SXn4+mDBhAuXLl8fd3V3RUoqeK2sg5E9oPx/MnRStRkJC6Xn08i0jt95g0KarJKVnsHbQZ+we1RiHKlIiQmkhIiJCvXz58hna2toiQOXKlTMsLS3TAXx8fHQaNmxoW6tWLfvmzZtbP3nyRB3g7t27mk2bNrWxtbV1cHBwsL93755mVlYWY8aMMbe2tq5lY2PjsGHDBiOQReqdnZ1tO3XqVKN69eq1unfvXj0rKwuAffv2GVSvXr2Wk5OT7b59+z4YucnIyGD06NHmNjY2DtkdeI0BzMzM6kRFRakBXLhwQcfZ2dkWYNq0aVUGDBhQrVmzZta9evWqXrduXbsbN25o5Yzn7Oxs6+PjoxMfH6/St29fy9q1a9vb29s77Nixo1CRo/xU3ZkNWCOrtjMMuC8IwiJBEArvLpUYFxcXWrVqxZIlS0hJybXLMgChcaHEJMfQPOQ8qGrIzeTnMM5FNtaac0VQgQdAVQ16b5LtJ9g7DNLkW9LTzc6Nl8kvOfnkZKHGEUWRr776ivv377Nr1y6MjaV6yvkhJ6p/7Ngxrl+/rmg5RUeEH/w9F2w/h8bjFK1GQkKpiU9JZ9GfQXT49TyXH7xkRidb/p7aik61K0t5+KWMnj17xkdGRmpYWlrWHjRoUNVjx47pAaSmpgqTJk2q6u3t/eDevXtBQ4cOfTl9+nQzADc3t+pjx46NCQkJCbxx40Zw1apV07dt21buzp072kFBQfdOnz4dOnfuXPOcNwZBQUHaq1evDg8LC7v39OlTzb///lsvKSlJmDBhguXhw4fDrl+/HhITE6P+IX0///xzpSdPnmjeu3cvMDQ0NHDkyJGvcvueAgICdE6cOBF25MiRR717947duXNneYAnT56ox8TEqLdo0SLpu+++q9y6dev4u3fvBvn4+ITMnj3bPD4+vsBRRrX8XCyKoigIQjQQDWQARsA+QRD+FkVxRkFFKDvz5s2jTZs2bNiwgYkTJ+Z6vW/IAQCaZarAsGNyNfkA5kY69HGSRfXHta5JZUNtuY4PgEFl6LUOdvSG4zNltcblRDOzZlQzqMau4F10qdGlwONs2bKFHTt2MH/+fFxcXOSmT5mYMGECy5cvx93dnSNHjihajvxJfi17s6pvCj1WS3n5EhIKIjNLxOtGOMtPhBCblEafz8z5pqMtxgZaud8skSvf7PO3CI1O0JHnmDam+knL+jiGf+y8oaFh1t27dwOPHz+uf/r0af2hQ4fWnDt37rMmTZq8vX//vnabNm1sALKysqhUqVJ6XFycyvPnzzWGDBnyGkBHR0cERB8fH/1+/frFqqmpYWFhkdGoUaNEX19fHUNDw6w6deq8rVmzZjpArVq1kh48eKChr6+faW5unlqnTp1UgIEDB77auHHjexU4zpw5YzB27NgX6uqy9wEmJiaZuX3PnTp1eq2npycCDBkyJK5du3Y2v/76a+S2bduMunXrFgdw7tw5gxMnTpT7/fffTUH2xiYsLEzjs88+y1s0+P/IT47+JEEQ/ICfgItAHVEUvwKcgN4FmVxChouLCy1btsxbVD8mGN+727HNyMJ4sHwj+e8yvnVNskSx6KL6AFbtoPk0uLkNAuSXU68iqOBq60rAiwDuvbxXoDHu3r3LhAkTaNOmDd9//73ctCkbBgYGfP311xw9ehQ/Pz9Fy5EvogiHJ0B8JPTZAjrlFa1IQkIpufzgFV1X+vLtgTtUr6jL4fHNWdbXUTL5ZQA1NTW6du2a8Ouvv0YuW7bs6aFDh4xEURSsrKySg4ODA4ODgwNDQ0MDL168eF/8SEPOjx0H0NTU/OekqqoqGRkZApCn1R9RFBEE4b3BVVVVxZwUoOTk5P/4bF1d3aycz6tXr55erly5jKtXr2ofOHCg/ODBg2Nzxt23b19YzvcXFRV1p6AmH/IX0a8I9BJF8cm7B0VRzBIEoWtBBUjInlDz5s2jbdu2bNy4kQkTJnz4wphgErd15XZFLYZa9YaKRbcJ3NxIh74NzPG8Fs44FytMDYvoBbP19/D0MhydAlXqQUVruQzbw6oHK2+tZFfwLhY2X5ive9++fUu/fv0wMDBg586dqKqqykWTsjJx4kR+/vln5s+fz+HDhxUtR35c2wBBR6D9ArBoqGg1EhJKx9NXSSz6M4jj96IxK6fNygH16VpXStEpCj4VeS8q/P39NVVUVMiJrN+6dUvb3Nw8rW7duimxsbFqp06d0m3Xrt3b1NRU4c6dO5oNGjRIMTU1Tdu+fXu5wYMHv05OThYyMjKEVq1aJWzYsKHShAkTXsXExKhdu3ZN7/fffw8PCAj4YLpCvXr1Up49e6Zx7949zVq1aqV6enp+MIrTrl27+LVr11bq0qVLgrq6Os+fP1c1MTHJNDc3T7t48aJOv3794r28vIw+9T326dMndtGiRaYJCQmqzs7OyQCtW7eO//nnn008PDyeqqiocPHiRe1mzZoVeNNkfnL05/6/yX/nnPw7ICkZrVu3pnnz5h+P6r8Iga3duKKhRoYg0NyqW5FrGudilR3VL6IKPPBvvr6qhiwFIl0+G4D1NfTpXrM7fz36i1fJuabN/Yfx48cTHBzMzp07MTU1lYseZcbAwIBp06Zx5MgRbt68qWg58iHyFpz8Hqw7QpOPvDGXkJAoEhJTM1h6PJh2v5znfOgLprW34fTXrejmWEUy+WWI+Ph41SFDhlSvWbNmLRsbG4fg4GDtpUuXRmppaYmenp4PZs2aZW5ra+tQq1Yth/Pnz+sB7Nix49Hq1auNbWxsHBo0aGAXHh6uNnjw4Ne1atVKtre3r+Xi4mIzf/78Z1WrVs342Lw6OjriypUrn3Tt2tXKycnJ1sLC4oOVfqZOnfrC3Nw8zc7Orpatra3Dpk2bygPMnTs3csaMGVWdnJxsVVVVP76cAAwaNCju2LFj5Xv06BGbc2zJkiWRGRkZgp2dnYO1tXWt2bNnmxXsJyhD+NSShqJp0KCBeOPGDUXLKDZOnz5Nu3btWLVqFePHj//3xIsQ8OgKgsAPn3XhRPQVLrheQF3lg/tD5Mqs/QEcuBXBhW9aF11UHyD0JOzqC07DodsKuQz58M1DehzqwYR6ExjjOCZP92zdupVhw4Yxd+5c5aoBX8S8efMGS0tLWrZsibe3t6LlFI6UN7CuJWSmw1hfKWVHQqKYyMoS2XfzGctOhPAiIZVe9c2Y0cmuaP83KQmCIPiJotjg3WP+/v6PHR0d5duURqJI8Pf3r+jo6Gj5oXPFWitQEITHgiDcEQThtiAIyuPg80ibNm1o1qwZixcvJjU1VXbwRajM5APikCP4vrpD48qNi8XkA4xvbUVWlsja80WYqw9g0wGaTgK/LXB3v1yGrGFYgyaVm+AV4kV6Vu6lNgMDAxk3bhwuLi7MnTtXLhokZBgaGjJ16lQOHz7MrVu3FC2n4IgiHJ4Er8Ohz2bJ5EtIFBPXH8fSY/VFZuwLwNxIm4PjmvJL/3qSyZeQyIX8bMYVBEEYJAjC3OyvqwqC4FyAOVuLoljv/985Sshy9X/44QciIiLYtGkTvLwPW7O3Pww7Spi6Cs+Tnsu64RYTFuV16P2ZObuuPeV5fIH3guSNtnPB3BkOT4ZX8nlj4WbvRkxyDKefnv7kdUlJSfTr1w9dXV0pL7+ImDRpEuXKlSvdKyU3NkHgIWg7B6o2VrQaCYkyT8TrZCbsuknftZd5kZDKiv712D+2KfWrfjL1WUJCIpv8RPT/AJoAA7K/TgBWy12RktO2bVuaNm3Knj9+RPToAmKWrONtJVt8I3wBWfnI4mR8aysys4q4Ag+AqrosSqqimp2vX/g3Fi3MWmCuZ87uoE934Z00aRKBgYHs2LGDKlWqFHpeifcpV64cU6ZMwdvbm9u3bytaTv6JCoDj34FVe2g6WdFqJCTKNElpGfxyMoQ2y8/xd+BzJrW15sz0VvSsb4aKStnPw/fx8WH+/PlcvnxZ0VIkSjl5ztEXBOGmKIqfCYJwSxTF+tnH/EVRdMzzZILwCIgDRGCdKIrrP3W9suXo53Dx8Faqn59AOUMDdMaeBmM7AL488SVxqXEc6H6g2DXN2OfPXr9n6KgXfaTbBT9Wq/zELrEjC8URhR/Q8DwqFY+SFT4F0t7f05KekUFKcjIamppoamgUfr4SRiV9Tf4Y6FQiOkK+fv0aS0tL2rRpw4EDxf88LjAp8bDeBdKTZHn5uhUVrUhCokySlSXi7R/B0r9CiI5PoZtjFWZ1tsOsXBH0cymhrFixgmnTpgGgpaXF6dOnadKkSZHOKeXol24+laOfn/Ka6YIgqCIz6QiCUAnI+vQt79FMFMVIQRCMgb8FQQgWRfHCuxcIgjAaGA1QtWrVfA5fBnj1gKb3F/NaU53u++DYzOpoAm/T33Iz5iaDHQYrRNb0jraU19UkIzO/v/KCUJUr4eG4Pd+NRs2WBJdvU6jR0rJ6cTjub6pb3cZZ778vlrFxsezcsRNjE2P69u2LilCs21aKhaMBUQzceIVdoxpjX1mxZj8nqj9//nz8/f1xdMxznEBxiKKs/GvcIxh6VDL5EhJFxK2nccw/Esjt8NfUMTNklVt9Glgqzz6Y0NDQf/qO5JCWlsa5c+eK3OhLlF3yY/R/Bw4CxoIgLAT6ALPzM5koipHZH2MEQTgIOAMX/u+a9cB6kEX08zN+qefVA/DogpCZTlDDnzi9eBQeHh6MGTOGq1FXycjKoHmV4svPfxdjfS1mdbYrvgkzfoctofSJWApdP4fyNQo1nNrl7niHeTO+nTtGWrLczuTkZBo1ciUrKorjt29jZlaoClYllkGNq+G6/goDN15l16hG2Jkq1uxPmTKFFStW4O7uzv798tl4XaT4ecg2iLeZDZbFmzYnIaEMRL9JYenxYA7eiqCSvibL+tSl92fmSpGiA7KVTnd3d1auXIm2tjbjx49n8+bNpKWloaGhIXVmlygU+amjvxOYASwGooCeoijmuZ2pIAi6giDo53wOdADu5k9uGebVA1l1ncw0GHqEJj2/pHHjxixatIi0tDR8I3zRUdOhvnF9RSstHtQ0ZN1GBQH2DoeM1EIN52bnRlpWGvvv/2ssp0yZwp07d9i+fXuZNfkAlhV12T26MeqqAm4brhISnaBQPeXKlWPy5MkcOHCAgIAAhWrJlei7cHwW1GgNzb9WtBoJiTJFclomv526T+vl5zh2J4pxLjU5O92Fvg0slMLkZ2ZmsnbtWqytrVmxYgXDhg3j/v37rFq1itOnT7NgwYJiSdspqURHR6va2dk52NnZOVSsWNHR2Ni4rp2dnYO+vn69mjVr1vrQPVOmTKly6NAh/dzGDgkJ0bC2tv7gGGWNfOUpiKIYLIrialEUVxWgSZYJ4CsIgj9wDTgmiuLxfI5RNvnH5KfKNt6aOPzTLffp06ds8diCb4SvrKymavGU1SwRGFWDHn9A1G34u3DlLq2MrGhk2og9IXvIyMrA09OT9evXM3PmTDp16iQnwSWX6hV18RzdJNvsX1G42Z8yZQoGBga4u7srVMcnSU2UbQrXKge9NoBK2UvrkpBQBKIoctg/krY/n+PXU6G42Fbi9LRWzOhkh55mfhINSi9nzpyhfv36fPXVVzg4OODn58eGDRswMTEBoEmTJnz77bdKa/IBTE1NM4ODgwODg4MDhwwZ8mLs2LHPg4ODA2/cuBGo8pHX4xUrVkT27NnzvX9wGRkf7Y8lN9LTcy/jrQjyU15TUxAEN0EQvhMEYW7OI6/3i6L4UBRFx+xHLVEUFxZMchkj9iFs7QYZKTDkMJj8+wazY8eONGrUiCXrlxD1Norm5opJ21Eo9l2h0VdwdS0EHSnUUAPsBxD9Nppd13YxatQomjZtyoIFC+QktORTvaIuu0c1RlVFZvZDnyvO7BsZGTF58mT2799fMqP6ogjHpkHsA+i9EfQqKVqRhESZIODZa/quvcyk3bcw1NHAc3Rj1gxywqK8jqKlFQsPHjzgiy++oG3btiQkJLB3717OnTtH/fpKslovJzIzM3F1da1mZWVVq1mzZtaJiYkCQO/evS23bNliBGBmZlZn+vTplZ2cnGw3b95s5OPjo2Nra+tQr149u19++cX4Y2PPnj3bxMbGxsHW1tZh3LhxZgDOzs62Fy5c0AGIiopSMzMzqwPw+++/V+jcuXONNm3aWLVo0cKmS5cuNfbs2WOYM1bv3r0tPTw8ymVkZDBmzBjz2rVr29vY2DgsW7as2DZ75SdE5Q30ADKAt+88JApK7CPw6AbpybJIvmnt/5zOieonVJIZMkXl5yuc9u5QpT54j4e4JwUexsXchco6lVl2ahkaGhp4enqirq5EKyRAjUp67B79r9m/r0CzP2XKFPT19Uvmm61bOyBgD7SaBdVbKFqNhESpJyY+hel7/emx+iKPX71lSa86HJ3YnMY1KihaWrEQHx/PzJkzcXBw4O+//2bhwoUEBQXRp08fBKHspynJm6dPn2pNmjQpJiws7J6hoWHmtm3bPthYQUtLK8vPzy9k9OjRcV9++aXlL7/88vT27dvBHxvXy8vL4NixY0Z+fn7BISEhgfPmzYvOTcvNmzf1du/e/ejKlSuh/fv3j92zZ48RQEpKinDx4kWDPn36vFmxYkVFQ0PDzLt37wb5+/sHbd26tVJwcHCxlPnLzxqZuSiKZT/HobiIfSRL10lPgqGH3zP5OXTq1AkzPzPSY9KpoKEcL4jvkZOvv64l7BsOw4/LjuUTVRVVNIM1oSos2bQECwuLIhBb8qmZbfZd119hwIYr7B7VGGuTXFMa5U758uWZPHkyP/74I3fv3qV27Q//DRQ7zwPhz2+gektoOV3RaiQkSjUp6Zls8n3EH2fDSMvMYnSLGoxvY4WBlnIEWTIzM/Hw8OD777/n+fPnDB06lEWLFpW+fi2HxlsQEyjfZRdjhyR6rg4vyK1mZmapTZs2TQaoX79+0uPHjzU/dN2QIUPiAF69eqWakJCg2qVLl0SAESNGvDpz5ozh/1//999/GwwaNOilvr5+FoCJiUlmblpatGgRn3Ndnz593syYMaNqcnKysH//fkNnZ+cEPT098dSpUwbBwcE6hw8fNgJISEhQDQwM1LKzs0sryPefH/IT0b8kCEKdIlOiTMQ9lqXrpL+FId5g+vEfa3JGMoKFQJxfHNu2bSs+jSWN8tWhxyqI8INTPxRoCC8vL/5a+hcqWSpEGEfIV18po2YlPXaPaowgCAzYcJWwGMVE9qdOnYq+vn7JydVPeyvLy9fUh14bZc3bJCQk8o0oivx1J4r2v55n2YkQmlpV5O+prfj2c3ulMfk+Pj40bNiQkSNHUrNmTa5fv46Hh0fpM/klEA0NjX+qMqqqqooZGRkfXBbJMeyiKOZp5eRj16mpqYmZmTLPn5SU9J8LdHR0st75XGzcuHHCgQMHDPbs2WPk6uoamz2u8PPPPz/N2XMQERFxp1evXvF5+mYLSa4RfUEQ7iCrna8GDBcE4SGQCgiAKIpi3aKVWMaIeyyL5KcmyCL5lT/947sWfY1MMqmSVoWFCxcydOhQpUs3+QeHHtBwFFxZDZbNwe7zPN/64MEDRo4cScM6DWlv3Z5jD48x1WkqhprvvaFXGqyMZWbfdf0VXNdfxXN0Y6yM9YpVQ/ny5Zk0aRKLFi0qGVH9Y9PhZSgMOQT6JorVIiFRSrkX+Qb3I4FcfRSLrYk+O0c2opmV8vSfePz4MTNmzGDv3r1YWFiwe/duK2jIYwAAIABJREFU+vfvX7pTdAoYeS8pVKxYMVNPTy/zxIkTeh07dkz08PD4YIOGTp06xS9cuLDKqFGjYvX19bOeP3+uamJikmlhYZF67do13datWyft3Lnzg2lCObi6usZu2rSp4p07d3T37t37GKB9+/Zv1qxZU6lr164JmpqaYkBAgKalpWW6gYFBkTcnyktEvyvQDegMWCEri9ntneMSeSXuiSwn/x+Tn3uzIN8IX7TVtJk7Yi6PHz9W7qg+QIcfwbQuHPoKXj/N0y2pqan069cPNTU1PD09GegwkJTMFA7cL0WdWYsIK2M9PEc3AmDAhiuExSQWu4apU6eiq6ur+Fz927vAfxe0/AZquChWi4REKeRlYirfHgig60pfQp8nsKBnbY5Naq40Jj8xMZHZs2djZ2fH0aNHmT9/PsHBwbi6upZuk19G2LRp0+NJkyZVrVevnp22tvYH+zT16dMnvnPnzq/r1atnb2dn57BgwQJTgFmzZj3ftGlTpfr169u9fPnyk0HyL774Iv769ev6zZs3j9fS0hIBpk6d+tLOzi6lTp069tbW1rVGjRpVLT09vVieFIIo5q0nlSAIS0VRnJnbMXnSoEED8caNG0U1fPES9yQ7kh8vS9epUi/XW0RRpPOBzlgbWfN7699xdnbm1atXhISEKG9UH2TlSNe1AmM7GP4X5FJydNKkSaxcuZJDhw7Ro0cPAIYdH0b022iOfXEMVSk9g/vPExiw4QqCIOA5ujE1KxVvZP+7775jyZIl3Llzh1q1FFDaOCYYNrQGMyfZ36f0nJCQyDNpGVl4XHrEytNhJKdnMqSJJZPbWmOooxz/p7Kysti+fTvffvstUVFRDBw4kCVLlmBubq5oaXlGEAQ/URQbvHvM39//saOj40tFaZLIO/7+/hUdHR0tP3QuPzn67T9wrHOBFCkbr5/C1q6Q+ibPJh/gUfwjIhIjaGHW4p8KPI8ePWL79u1FLLiEU6EmdP8dnl2H05/O7T5w4AArV65kypQp/5h8gIH2A4lIjOD8s/NFrbZUYG2iz+5RjcnKEhmw/goPXhRvZH/atGmKi+qnJcny8tV1suvlSyZfQiIviKLI34HP6fDreRb9GUwDSyOOT2nJ3G4OSmPyL126ROPGjRk2bBgWFhZcvnyZHTt2lCqTL1G2ydXoC4LwVXaevq0gCAHvPB4BJbAAdgnjdbgskp+SP5MPcDHiIgDNzJoB0KVLF5ycnFi4cGGJbcxQbNTuBQ1GwKXfIfTEBy95+PAhI0aMoGHDhixduvQ/51pbtMZU15RdwbuKQ22pwNpEn92jG5OZbfYfFqPZr1ixIhMmTMDLy4vAwMBimxeAv2bAi2DotR4MKhfv3BISpZSQ6AQGb7rGqG03UFUR8BjekC3DnYt9n4+iCA8Px83NjWbNmhEREcG2bdu4fPkyjRs3VrQ0CYn/kJeI/i5kufiHsz/mPJxEURxUhNpKP6/DwaMLpLyGwYdkteDzgW+EL9UNq2OmZwb8W1f/4cOH7NixoygUly46LgaTOnBwLLx59p9TaWlpuLq6ArBnzx40NP5bjlNNRY3+tv25GnWVsLiwYpNc0rEx0WfXqGyzv+EKj14WX6uMr7/+Gh0dHX788cdimxP/PXBrO7SYBlZti29eCYlSSuzbNGYfukPn3y5wJ+IN87o5cHxKS1xsP9p/qEyRlJTEDz/8gK2tLQcPHmT27NmEhIQwePBgPtatVUJCkeT6rBRF8Y0oio9FURwgiuKTdx6xxSGw1PLmmSxdJ/k1DD4IZp/l6/bkjGRuRN+gudl/m2R17dqVzz77jIULFxZLS+cSjboW9PWAzDTY9yVk/rvKMXPmTK5fv87mzZupXr36B2/vbd0bDRUNdgfvLibBpQNbU5nZT88UcV1/udjMfk5U39PTk6CgoKKf8EUoHJ0KVZuCy3dFP5+ERCkmPTOLTb6PcFl2lt3XwhncuBrnprswvFl11FXLvsEVRZFdu3Zha2vL/Pnz6datG8HBwSxYsAA9PeVYxZAonZT9v05F8OaZLJKfFJtt8p3yPcT16OukZaW9Z/RzovoPHjxg586d8lJceqloBV1XQPgVOLsQAG9vb1asWMHEiRPp1avXR2810jLi8xqfc+ThEeLTiqWcbalBZvYbkZ4pS+N5XExmv9ii+unJsrx8NU3ovRFU89M7UEJCuTgbHEPHFRdYcDQQR4ty/DW5BfN71MZIt1gaeyqc69ev06xZMwYOHIixsTEXLlxgz549VKtWTdHSJCRyRTL68uZNhCwnPylWlq5jnn+TD+DzzAdtNW2cTN6/v1u3btSvX58FCxZIUX2Aun3hsyHg+yvPL+5k2LBhODk5sWzZslxvdbNzIzkjmUP3DxWD0NKFnakBO0c2IjUjkwEbrvDkVdGb/UqVKjF+/Hh2795NcPBHu5QXnuOzIOaeLC/f0Kzo5pGQKMWExSQwdPM1hntcRxRh09AGbBvhjI0COmkrgsjISIYOHYqzszMPHz5k06ZNXL9+nRYtWihamoREnsmz0RcEoa8gCPrZn88WBOGAIAj5y0cp67yJyI7kv5JF8gto8gEuRl6koWlDNFXf7+osCAJz587lwYMH7NolbSYFoPNPiMYOaBybiIl2Fnv27EFT84Mdsf+DfQV76hvXZ3fwbjKzcu10rXTYVzZg16jGpKRn4rq+eMz+9OnT0dbWLrqo/p194OcBzaaA9YeKiUlIKDevk9L44fA9Oq7w4ebTOGZ3sefElJa0tTdRinrwycnJLFy4EBsbGzw9PZk1axb3799nxIgRUh5+MaOqqupkZ2fnkPMICQmRyzKSu7u7cUJCwj+/TB0dnfxtoixF5OcZO0cUxQRBEJoDHYGtwJqikVUKiY+U5eS/fQmDDoB5g9zv+QhP4p8QnhD+XtrOu/To0YN69epJUf0c1LVZ9rg26mTgM8WGmpZ5X1J1s3PjWeIzfCN8i1Bg6cW+sgE7RzYmOT2TAeuv8PRVUpHO925UPyQkRL6Dv3oARyaDRSNoM1u+Y0tIlHIyMrPYdvkxLsvPse3yY/o3tODcdBdGtqiBhlrZN7iiKLJ3717s7e2ZPXs2HTt2JCgoiMWLF6OvrxyrGCUNTU3NrODg4MCch62tbVphx8zIyGDdunUmiYmJxfakVmSlxPx8kznhzi7AGlEUvQHlSNDLjfhIWbpO4gtZJN+iYaGGyzGcnzL6OVH9sLAwdu+WNpMePXqUmcs2si+lKZWSQuH8kjzf27ZaW4y1jaVSm5/AoYosjScpPRPX9ZeL3OxPnz4dLS0t+Ub101Ng71BZg7U+m3NttCYhoUz43H/B57/7MNf7HvamBhyb1IJFX9Shgl7uK6NlgVu3btGqVSv69euHoaEhZ86cYf/+/dSoUUPR0iT+j6SkJKFPnz6WNjY2Dvb29g5HjhzRB/j9998rDBkypGrOda1bt7Y6evSoPsgi9lOmTKlSt25du1mzZlWOiYlRb9WqlU2jRo1scq6fOHGima2trYOjo6NdeHj4exu33rx5o5Izr42NjYOHh0e5nLFzrtmyZYtR7969LQF69+5tOXLkSPNGjRrZjB071sLMzKzOy5cv/2nUUrVq1drh4eFqkZGRah07dqxZu3Zt+9q1a9ufPHlSV54/r/wY/QhBENYB/YA/BUHQzOf9ZZP4qGyTHwODDxTa5AP4RPhgaWCJhb7FJ6/r0aMHjo6OSh/VDw8PZ+jQodSrVw/XRYeg3iC4sBwenMnT/eoq6vSz7celyEs8evOoiNWWXmpVMWTHl414mybL2Q+PLTqzb2xszLhx49i1axehoaHyGfTk9xB9B3quBUOpmY2EBMCjl28ZufU6gzddIyU9i7WDnNg1qhH2lQ0ULa1YiI6O5ssvv8TJyYng4GDWrVvHzZs3ad26taKlSQCpqakqOWk77du3rwmwdOlSY4DQ0NDAXbt2PRw9erRlUlLSJ3PKkpOTVWrXrp0cEBAQvHz58ihjY+P08+fPh169ejU053yTJk0SQ0JCAps0aZK4cuXKSv8/xqxZsyobGBhkhoaGBoaGhgZ26dIlITf9Dx480Lp48WLopk2bwjt06PB6586d5QDOnDmja25unmZhYZExZswYi2nTpj2/e/du0MGDBx+MHTvWsgA/qo+Sn1IT/YBOwHJRFF8LglAZ+EaeYkod8VGydJ3E57J0HQvnQg+ZkpHCjegb9LXpm+u1KioqzJ07l969e+Pp6cmgQcrX1iA9PR1XV1fS0tLw8vJCS0sLPv8JIm7A/lHw1UXQN811nD42fVgXsI7dwbv5rpFUavFj1DYzZOfIRgzceBXX9VfwHN0Yi/I6RTLX9OnTWb16NT/++CPbtm0r3GB3D8D1jdBkAth2ko9ACYlSzJvkdFaduY/HpcdoqKows5MdI5pboqmmHJ2hU1NTWbFiBQsXLiQlJYVp06YxZ84cDA0NFS2tRDLn4hyLsLgwub7YWxlZJS1otiD8U9fkpO68e+zSpUt6EydOjAGoX79+SpUqVdLu3Lmj9alxVFVVGTZsWNzHzqurq4uurq5vAJycnN6eOnXqvXe6Fy5cMPD09HyY83WlSpVy3djXq1evODU1mdV2c3OLdXd3rzJ58uRXO3fuLN+7d+9YgIsXLxrcv39fO+eexMRE1bi4OBUjI6Os3MbPC3mOyIuimCSK4gFRFO9nfx0liuJJeYgolSREy0x+QjQM2g9VG8ll2BvPb5CamfrJtJ136dmzJ3Xr1mXBggVkZirfZtI5c+Zw6dIlNmzYgLW1teyghq6svn7aW9g/EvKwybaCdgU6WXbCO8ybxLTi6whbGskx+4mpGbiuL7rIvomJCePGjWPnzp3cv3+/4APFPoTDk8CsAbT7QV7yJCRKJZlZIjuvPqHN8nNs9H3EF/XNOPuNC1+51FQKky+KIgcPHsTBwYFZs2bh4uLCvXv3WL58uWTySwmiKH7wuJqampiV9a83Tk1N/cfjamhoZOUY7o/dm7PRWk1NjYyMjPdWCERR/OBm9HePJScn/+cCPT29fwS1bdv27ZMnTzQjIyPVjh8/Xm7gwIFxOePeuHEjKGcfQkxMTIC8TD7kIaIvCIKvKIrNBUFIAN796QoyfaJyrO+9S0K0LF0nPirb5Muv5bVvhC+aqpofLKv5IXKi+n369MHT05OBAwfKTUtJ56+//mLp0qWMHj36ny64/2BsD12Wg/d4OP8TtP421/Hc7N048vAI3g+8GWivPD/HgpBj9t02XMF1/RX2jGmMuZH8I/vffPMNf/zxBz/++CNbt27N/wAZqbJ6+SoqUl6+hNJz6cFL3I8EEhydQENLI7Z2c6a2mfKY24CAAKZMmcLZs2epVasWJ0+epH17qfJWXsgt8l6cNG/ePHHHjh3lu3fvnhAQEKAZFRWlUbdu3ZTXr1+rbtiwQSczM5NHjx6pBwQEfDTXXVdXN/PNmzcqlStXzvO8Li4u8b/88ovx5s2bwwFevHihWqlSpcwKFSqk37x5U8vR0THF29vbSE9P74PRRRUVFTp37vx63LhxFlZWVsmmpqaZ2d9P/NKlS40XLFjwHODSpUvaTZs2Tc7XD+UT5KUzbvPsj/qiKBq889BXTpP/HLZ2k23AHbQfqjWR6/C+Eb40NG2IltonV6H+wxdffEGdOnWUKqofERHBkCFDqFu3LitWrPjwRfUGguMAOL8UHp7PdczaFWtTt1JddgfvJkuU25vpMovM7DcmISUd1/VXeBYn/8i+iYkJY8eOZefOnYSFheV/gJNzIMofeq4BI6m5jYRy8vRVEmO238Btw1USUjJY7fYZXmOaKI3Jf/HiBWPHjqV+/fr4+/uzatUqbt++LZn8UsqMGTNiMjMzBRsbG4f+/fvXXLdu3WNtbW2xffv2iRYWFqm2tra1Jk+ebOHg4PDRf0pDhw592blzZ+t3N+PmxuLFi6Nev36tam1tXcvW1tbhzz//1AeYP39+RI8ePayaNGlia2Ji8snyOgMHDoz19vYu36dPn3/SiNavXx9+8+ZNXRsbG4eaNWvWWrVq1Xv7AwqD8LElkJJAgwYNxBs3bihaxr8kPJel67yJgEH7oFpTuQ4fHh/O5wc/Z5bzrHxHlPft20ffvn3ZuXMnbm5uctVV0sjIyKBNmzbcvHkTPz8/bG1tP35xaiJsaA0pb2CsL+gZf3LsYw+PMctnFmvarclz+pSyE/DsNQM3XqWcjjqeo5tgVk4795vyQXR0NNWrV6d///54eHjk/cbAw+A1GBqPg06L5apJQqI0kJiawaozYWz2fYSaqsA4l5qMbFEDLfWyn6IDkJaWxqpVq3B3dycxMZHx48czb948ypcvr2hpJQ5BEPxEUfxPXXB/f//Hjo6OLxWlSSLv+Pv7V3R0dLT80Dmpak5eSYyRRfLfRMDAvXI3+SCrtgPQwiz/Xfd69epF7dq1lSKqP2/ePHx8fFi7du2nTT6App4sXz/lDRwYlWu+fodqHaioXZGdQTvlJ7iMU9e8HDu+bMTrpHRc118m4rXcVhwBMDU1ZezYsezYsYMHDx7k7aa4x+A9Aap8Bu3my1WPhERJJytLxOt6OC7LzrH2/AO6Olbm7HQXJrSxVgqTL4oiR48epU6dOnz99dc0adKEO3fu8Ntvv0kmX0LpkIx+XvjH5IfLTL5lsyKZxjfCl6r6ValqUDX3i/+PnFz94OBgvLy8ikBdyeDkyZMsXryYESNG5L3KkEkt6PwTPDwHPr988lJ1VXX62vTFN8KXJ/FPCi9YSXC0KMf2Lxvx+m06A9ZfIVLOZn/GjBmoq6uzcOHC3C/OSIO9w2Wf990CalK7Dwnl4dqjWLqv9mXG/gCqltfm0Phm/NKvHiYGeU8HLc0EBgbSqVMnunXrhiAI/Pnnn/z111/Y29srWpqEhELIs9EXBKGvIAj62Z/PFgThgCAInxWdtBJC4guZyX/9tEhNfmpmKtejr9PMrODj9+7dm1q1apXZqH5kZCSDBg3CwcGBlStX5u/mz4ZAnb5wbhE8/nQH3L42fVFTUcMz2LMQapWPehbl2D6yEXFv03CVs9mvXLkyY8aMYdu2bblH9U/Ng8ib0GMVGFnKTYOEREnmWVwS43fdpN+6y7xKTOM313rs/6op9SzKKVpasfDq1SsmTpxI3bp1uXbtGitWrODOnTt07txZ0dIkJBRKfiL6c0RRTBAEoTnQEdgKrCkaWSWEHJMf9wTcvMCy6HK2/aL9SMlMKVReeE5UPygoiH379slRneLJzMxk4MCBvH37lr1796Kjk88KL4IAXX+F8jVg35ey3+1HqKRTiQ7VOnAo7BBv098WUrlyUc+iHNu+dCbubRoDNlwh6o38zP7MmTNRV1dn0aJFH78o+Bhc+QOcR4NDd7nNLSFRUnmbmsHPJ0No+/N5Tgc9Z3Jba05/3Yoe9cw+WAqwrJGens7KlSuxtrbmjz/+YMyYMdy/f5/Jkyejri5V2SokWVlZWWX/SVTKyf4dfbSCSH6Mfk6IuAuwRhRFb6Dsrom/fQnbustyfQd6QfX8583nB58IHzRUNGhoWrjOun369MHBwQF3d3ferSdb2nF3d+fcuXP88ccfBV+C1dSX5esnx8HB0fCJn4+bvRuJ6YkcfnC4YHMpMfWrGrH1S2deJcoi+9FvUuQybuXKlRk9ejRbt27l4cOH71/w+ikc+goqO0KHH+Uyp4RESSUrS+TAzWe0+fkcK8+E0bGWKWe+dmFqext0NPLTC7P0cvz4cRwdHZk0aRJOTk74+/uzevVqKlasqGhpZYW7L168MJTMfsklKytLePHihSFw92PX5LnqjiAIR4EIoB3gBCQD10RRdJSD1g+isKo7b1/KIvmxj8BtD9RoVeRTdjvYDTM9M9a2X1vosfbs2YOrqyt79uyhX79+clCnWE6fPk379u0ZMmRI/qqufIwbm+HoVGg7F1p8/cFLRFFkwLEBJGUk4d3DWykiY/Lm5tM4hmy6RkU9DTxHN8HUsPA5wpGRkdSoUYNBgwaxcePGf09kpsOWzvAiBMacl63cSEiUUW4+jWP+kUD8w19T19yQed0ccKqmPJtMQ0JCmDZtGn/++SdWVlb8/PPP/+TkSxSMD1Xd8fPzM1ZTU9sI1Eba01lSyQLuZmRkjHRycor50AX5Mfo6QCfgjiiK9wVBqAzUKcruuAox+m9fwtbuEPsg2+S7FPmUzxKe0flAZ2Y2nMkghzxuMP0EmZmZ1KlTBxUVFQICAsjp9lYaiY6Opl69epQvX57r16+jq/vR/hd5RxRh3wgI9IZhxz7aC+Hwg8N87/s969qvo2kV+VdZUgb8nsQxZNNVjA202D2qsVzM/qRJk1izZg2hoaFUr15ddvDkbLi0UrZiU+uLQs8hIVESiXqTzJK/gvG+HYmxviYzOtnRq74ZKirKYXDj4uJwd3dn1apV6OjoMGfOHCZOnIimpqaipZV6PmT0JcoGeXaAoigmiaJ4QBTF+9lfRxXE5AuCoCoIwq3sFYKSxdtXsK1HsZp8gIsRFwHkVrddVVWVOXPmcO/ePfbv3y+XMRVBTl5+fHw8Xl5e8jH5IMvX7/abrIHSvhGy3/sH6GTZifJa5dkdtFs+8yohTtWM2PalMzHxKQzYcIXn8YVP45k5cyYqKir/5uqHHJeZ/AZfSiZfokySnJbJilOhtF5+jr/uRjO+dU3OTnehj5O5Upj8jIwM1qxZg7W1Nb/99hvDhw/n/v37TJ8+XTL5EhK5kKvRFwTBN/tjgiAI8dkfcx7xBZhzMhBUgPuKlqRYmcl/FQYDPIvN5IOsrKaZnhnVDOTXubNfv37Y2dkxf/78Upurv3DhQs6cOcPKlSupXbu2fAfXMpBFf5NewsExH8zX11DVoI9NH84/O094Qonp/l3qcKpWnq0jss3++sKbfTMzM0aPHo2Hhwfh967AobFgWgc6fmKTroREKUQURbxvR9D253OsOHWftnYmnJ7Wim862qGrqRx5+KdPn6Z+/fqMGzeO2rVrc/PmTdavX4+x8aebH0pISMjI1eiLotg8+6O+KIoG2R9zHgb5mUwQBHNkm3k35nZtsZIUK0vXeRkKA3ZDzdbFNnVaZhpXo6/S3Ky5XPML343qHzhwQG7jFhfnzp1j/vz5DBo0iBEjRhTNJJUdZeYw7G+49PsHL+ln0w9VQVUqtVlIGliWx2OEM9HZZj+mkGZ/5syZaKipkLrTTZaf33crqCtHnXAJ5cA//DV91l5msudtjHQ12DO6MasHfoZF+XxWHCulhIWF0bNnT9q1a0diYiL79u3j7Nmz1KtXT9HSJCRKFfmpo68pCIKbIAjfCYIwN+eRz/lWADP4RBkghbB32Dsmv02xTu333I/kjOQCdcPNjf79+2Nra1vqKvDExMTg5uaGtbU1a9asKdoNVg1HgkMPOO0OT6++d9pE14S21dpyMOwgSelJRadDCWhoKYvsR8en4LqhcGbf3NycgxOdsNJ4xYsms6FCTTkqlZBQHM/jU/jay58eqy/y5NVblvauw+EJzWlUo4KipRUL8fHxzJgxAwcHB06fPs2iRYsICgqid+/e0mZbCYkCkJ9dmt5ADyADePvOI08IgtAViBFF0S+X60YLgnBDEIQbL158vNa5XOmwQGbyrdoWz3zv4Bvhi7qKeqHLan6InKj+nTt3OHjwoNzHLwqysrIYPHgwcXFxeHl5oaenV7QTCgJ0XwnlLGT5+kmx710y0H4gCWkJHH1Y8raVlDYaWpbHY7gz0W9kOfsxCQU0+/f/poPOPTbeymC25235ipSQUAAp6ZmsPhtG6+XnOOIfyZhWNTg73YX+DauiqgR5+JmZmWzcuBFra2uWL1/OoEGDCA0N5dtvv0VLS1qtk5AoKPmpunNXFMUCJ0oLgrAYGIzsjYIWYAAcEEXxo2VmFFZesxjpcagHJjomrO+wvkjGz8zMxMHBAS0tLW7dulXiK/AsWrSI77//nnXr1jF69OjimzjiJmzqAFbtZG/63okciaJI/6P9Sc9K50D3A1JUSQ5cffiK4R7XqWyohefoJlTSz8eGuvhIWNsc9Csz+U4t1mz0ICwsjKpVqxadYAmJIkIURf66G82iP4N4FpdMBwcTvu9iT7UKcio+UAq4cOECkydP5vbt2zRr1ozffvsNJycnRctSKqSqO2WX/Li+S4Ig1CnoRKIofiuKorkoipaAK3DmUyZfGYhMjOThm4c0M2tWZHPkRPUDAgI4dOhQkc0jD3x8fJgzZw6urq6MGjWqeCc3+0zWZCn0L7i8+j+nBEFggN0Awl6HcS36WvHqKqM0qlGBzcMaEvlaFtl/kZCatxszM2SdjdNToK8H07+dA8DixYuLUK2ERNFwN+IN/ddfYdzOm+hpqrFrZCPWD2mgNCb/0aNH9O3bl1atWhEbG4unpyc+Pj6SyZeQkCN5qbpzRxCEAKA5cFMQhBBBEALeOS5RQHwjfAGKJD//XVxdXbG2ti7RufovXrzA1dWVGjVqsG7dOsVEzRuNAbuucGoePPvvSlLn6p0pp1mOXUG7il9XGaVxttmPiEvGLa9m/9xieHoJuv4KFa2xsLDgyy+/ZNOmTTx9+rToRUtIyIEXCanM2h9At1W+hMUk8mPP2hyd2JymVsrR0TUhIYHvvvsOe3t7/vzzT9zd3QkODqZ///7SiqmEhJzJS0S/F9AN6AxYAR2yv+6a/THfiKJ4ThTFrgW5tyzhG+FLFd0qVDesXqTzqKmpMWfOHPz9/fH29i7SuQpCVlYWQ4YM4eXLl3h5eWFgkK9iTvJDEKDHKjCoAnuHQ3LcP6e01LTobd2bc8/OEZkYqRh9ZZAmNWVmPzwuCbcNV3iZ+AmzH3YafH6G+oPAsf8/h7/99lsAlixZUtRyJSQKRWpGJuvOP6D18nPs83vGiGbVOTvdhUGNq6GmWrLTKuVBVlYWHh4e2NjYsHjxYvr27UtISAhz5sxBW1tb0fIkJMqHCttjAAAgAElEQVQkeXll2SOK4pOPPYpcYRklPTOdq1HyL6v5MQYMGICVlRXu7u7kdV9GcbFs2TKOHz/OihUrqF+/vmLFaBtBny2QEAmHxsu66GbT37Y/AgKeIVKpTXmSJ7MfHwUHRkMlO+i87D+nqlatyogRI9i4cSPh4VK/A4mShyiKnLgXTYdfL7D4r2Ccq5fnxNSWzOnqgKG2uqLlFQsXL16kUaNGDB8+nGrVqnH58mW2b9+Oubm5oqVJSJRp8mL0pXW0IuBmzE2SMpLk1g03N3Ki+rdv3+bw4cPFMmdeuHjxIt9//z19+/Zl7NixipYjw7wBtJsPIcfg6tp/DlfWq0ybqm04cP8AyRnJChRY9mhasyKbhzbkaWwSAzdc5dW7Zj8rEw6MgvQkWZMzjffriEtRfYmSSnB0PIM2XWXMdj/UVVXYOsKZzcMaUrNSEVcUKyE8ffqUAQMG0Lx5c6Kioti+fTuXLl2icePGipYmIaEU5Fp1RxCEZ8AvHzsviuJHzxWWslx155cbv7A9aDsXXS+io148DVAyMjKwt7dHX18fPz8/hedCvnr1inr16qGhocHNmzcxNDRUqJ7/IIqwewCEnYIvT4CZbHPY9ejrjDgxgh+a/EBvm94KFln2uBj2khEe17GsoMuuUY2ooKcJZxfB+aXQcw3Uc/vovWPGjMHDw4MHDx5IUUIJhfMqMZVf/g5l97Wn6GupM629DW6NqqKuBCk6AG/fvuWnn35i2bJliKLIN998w8yZM9HVVY6NxqUNqepO2SUvrziqgB6g/5GHRAHwifDBydip2Ew+yKL6s2fP5tatWxw5cqTY5v0QoigybNgwYmJi8PLyKlkmH2T5+j3/AH3T7Hz91wA0MGmAtZE1u4J3lbgUqLJAM6uKbB7WkMev3jJw41XiA0/B+Z/A0e2TJh9kUf2srCwpqi+hUNIystjo8xCX5efwvB7OkCaWnP/GhaFNLZXC5IuiyM6dO/9p1ti9e3eCg4Nxd3eXTL6EhALIy6tOlCiK7qIozv/Qo8gVlkGi30YT9jqs2NJ23mXgwIHUrFmTH374QaFG9ZdffuHo0aMsX7685JZS0ykPfTZDfAQcngiiiCAIDLQbSGhcKH7PP9n7TaKANLOqyKahDUl4GUHG3i/JrGANXZbnep+lpSXDhw9nw4YNREREFINSCYl/EUWRM8HP6bTiAj8eC6J+VSOOT27BD91rUU5HQ9HyioVr167RtGlTBg0ahKmpKT4+Pnh6elKtWjVFS5OQUFqkHH0FkFNWUxFG/92o/tGjiun0euXKFWbNmkWvXr2YMGGCQjTkGQtnaDsXgg7D9Y0AfF7jcww0DNgVLJXaLCqa1zTiqNk2tLOSGJ8+ibj0vG1Y/O6776SovkSxc/95AkO3XGeEhyzVdPOwBmwd3hBrE+VY9I6IiGDIkCE0atSIx48fs2XLFq5du0bz5sX/P05CQuK/5MXoty1yFUqGb4Qvprqm1CxXUyHzDxo0iBo1aigkqh8bG0v//v0xNzdn06ZNCt8nkCeaTATrDnDiO4i8jbaaNr2te3Pm6Rmi30YrWl3Z5MJyjJ5fIrzxD5yJrYjbxqvEvU3L9TZLS0uGDRsmRfUlioXXSWn8cPgenX7z4dbTOGZ3sef4lJa0sTMpHa9thSQ5OZkff/wRGxsbvLy8+PbbbwkNDWXYsGElvgu7hISykOtfoiiKscUhRFlIz0rnStSVYiur+SHU1NT4/vvvuXnzJseOHSu2eUVRZPjw4URFReHl5UW5cuWKbe5CoaICPdeCTkXYOwxS4ulv1x8RkT0hexStruzxyAfOL4E6/bDpNI4NQxrw4EUiA/No9r/77jsyMzNZunRpMYiVUEYyMrPYeukxLsvPse3yY1wbWnBuugsjW9RAQ63sG1xRFPHy8sLe3p45c+bQuXNngoKCWLRoEfr6yrGKISFRWij7r0gljNsxt3mb/j/27ju+pvuP4/jrZA9JEEEixEgQexMz9l4/qkQp2lKlVm0xWqVqVu1ZWrO2mrUlofaWECNDbEFCZJ/fHyGVWkFyz83N5/l49FHcc+959zSSz/dzvuf7fUp1J21vaXbq1IkCBQrotKs/ffp0Nm/ezMSJE6lYsaJOzplmrO2T5us/CoG/+pDH2glPZ0/WXV5HTEIqdnQVqfPkHqz7ErIXhGZTQVGoVdiB+Z3Kc+XeEz5bdIRHUW8v9gsUKMDnn3/O/PnzuXlTNjcTaevg5Xs0nu7D6M0XKOZoy9Y+NRjXumTSClGZwIkTJ6hZsyaffvopWbNmZd++faxdu5YCBdJ340chxIeRQl/HfMN8MVFMqOxYWdMcpqamjBgxghMnTrBt27Z0P9+xY8cYPHgwLVu2pG/fvul+vnTh4gF1vOHCBji+GC93Lx7GPGT79e1aJzMMiYmwoTtEP4JPloL5v51BzyI5md+pPIF3kjr77yr2hw8fTnx8vHT1RZq5du8JXyw5RufFR4lNSGRep/Is/7Iy7o4a7eStY7dv36Zbt25UrFiRS5cuMX/+fE6cOIGnp6fW0YQQb/HOdfS1ZIjr6LfZ3AY7czsWN1ysdRTi4uIoXLgwDg4OHDlyJN2mEj169IiyZcuSmJjIqVOnyJ49e7qcRycSE2HFJ3DdB/WLXfzv2BhMjUxZ3Wx1ppiTm64OToa9Y6HZL1Ch62sP2XfpLj1+P0Hh3FlY/kUV7Kze/JBut27dWLlyJdeuXcPR0TG9UgsD9/hZHL/uCWTpoSAsTI3pXceVrtXyY25irHU0nYiOjuaXX35h3LhxxMTE0LdvX7y9vfVvSWTxUWQdfcMlHX0duvP0DpcfXtZktZ3XedHVP3bsGNu3p09XWlVVvvjiC27cuMHq1aszdpEPSfP1W88Dq+woa7vSwbU1/uH+nL53WutkGVvwIdg3Dkq0gfJd3nhY7SI5mdepPJdvJ03jeRwV98ZjR4wYQVxcHBMnTkyHwMLQJSSqLPsnmNqT97PY7zptyjmzb6AnX9cqlCmKfFVVWb9+PcWKFWPYsGHUqVOHCxcuMGnSJCnyhchApNDXIb+bfoA2y2q+SefOncmfPz/ff/99uszVnzlzJuvXr+enn34ynC3PrXNAm0Xw8DrNLu7FxtSGFf6y1OYHe3of1n4B2fIndfPfcWekdtGczPmsHAG3I+i0+AiPn72+2C9UqBCdOnVi7ty53Lp1Kx2CC0N16Mp9mv7qg/fG87jmzMJfvavzc9tSONhkjnn4Z86coU6dOrRp0wYrKyt27drFpk2bcHNz0zqaEOI9SaGvQ75hvuS0yolbVv35ZmlmZsbw4cM5evQoO3bsSNPPPnHiBAMHDqRZs2YMGDAgTT9bc/mrgedwrC5soLVtYXYH7+Zu1F2tU2U8iYmwoQdE3YdPloBF6uY713XPxdzPyuN/K4JOi95c7L/o6k+aNCkNQwtDFfzgKd1/P47XwiM8iYlndsdyrO5ehRJ5MkcH++7du/To0YNy5cpx7tw5Zs2axenTp6lXr57W0YQQH0gKfR2JT4znn5vaLqv5Jp9//jn58uVL067+48ePadeuHbly5WLJkiWGuaZyjQFQ0JP253aSoCbw56U/tU6U8RyaDld2Q8Px4Fj6vd5a1z0XczomFfud31Dsu7q68tlnnzFnzhxu35Y9D8TrRUbH8dN2f+pPPYjvlfsMaliE3QNq0aSko959v04PsbGxTJkyBTc3NxYvXkyfPn0IDAzkm2++wcTEROt4QoiPYIDVl346c+8MkXGRejVt5wUzMzNGjBjBkSNH2Llz50d/nqqqfPXVVwQHB7Nq1Srs7e3TIKUeMjKG/y0gr6kNNeMU1lz6k9iEd6/zLp4L+Qf2jIViLaHilx/0EfWK5WJ2x/JcvBVB58VHiYh+tdj39vaWrr54rYREldXHQqg9+QDzDlyjeWkn9g30pFdtVyxMM8c8/L/++osSJUowcOBAqlevzrlz55g2bRrZsmXTOp4QIg1Ioa8jL5bVrOKon/PUu3TpkmZd/blz57JmzRrGjRtH1apV0yihnsqSE9osxOvBHcJjHrLzetpOfzJYUeGwthtkzQstZrxzXv7b1C+Wi1le5bh48zGdFr1a7Lu6utKxY0fmzJnDnTt3Pja5MBBHr4fTYqYvQ9adw8Xeik29qjGlXWly2VpoHU0nLly4QMOGDWnRogXGxsZs376drVu3UrRoUa2jCSHSkBT6OuIb5kvpnKWxMdPPXQNfzNX/559/2LVr1wd/zqlTp+jfvz+NGzdm0KBBaZhQjxWoiUelvhSIjWPFyZlap9F/qgobe8LTe8/n5X/8/OcGxXMzy6scF8Ie0/k1xb63tzcxMTHS1ReEhkfRa/lJ2s07TPjTWKa3L8Parz0onTeD7NT9kR48eEDv3r0pXbo0x44dY/r06Zw9e5ZGjRppHU0IkQ6k0NeBe1H3CAgP0MtpOy/r2rUrefPm/eDdciMiImjXrh329vYsXbrUMOflv4FSazAdzHJx/tktzl7erHUc/XZ4JlzeAQ1+BKeyafaxDYrnZqZXOc6HPebzxUeJfKnYd3Nzo2PHjsyePZu7d+Wh6czoaUw8k3deou7UA+wJuEO/em7s/c6TlmXyZIp5+HFxcUyfPh1XV1fmzp3L119/zZUrV+jTpw+mpm/ej0IIkbFlnkpMQ/q4rObrvOjqHz58mN27d7/Xe1VVpUePHly7do2VK1fi4OCQTin1lJExLZovwTpRZcXBURD7VOtE+in0GOweA+7NoVL3NP/4RiVyM9OrLOduvFrsS1c/c0pMVFl74ga1J+9n5r4rNC6Rm73fedKvXmEszQx/Hj7A9u3bKVWqFP369aNixYqcOXOGmTNnGu7zU0KIZFLo64BvmC8Olg4UyVZE6yjv1LVrV5ydnd+7q79gwQJWrVrF2LFjqVmzZjom1F/W2QvQKo8nO03iub+lr9Zx9E9UOKztCrZO0GLmR83Lf5tGJRyZ0aEsZ248pstvx3gSEw9A4cKF8fLykq5+JnIiOJzWs/0YuOYMjnYWrOtZlenty+KU1VLraDoREBBAkyZNaNKkCQkJCWzevJmdO3dSvHhxraMJIXRECv10Fp8Yz6Gbh6iWp1qGuD1sbm7O8OHDOXToEHv27EnVe86ePUvfvn1p0KABQ4cOTeeE+q195YHEKwprQnbC6ZVax9EfqgqbekHkbWi7BCzTdz5045KOzOxQltOhj/h88dHkYt/b25vo6GgmT56crucX2rr56Bl9Vp6izZzD3HoczZRPSrPhm2qUd8kcK8k8fPiQfv36UbJkSfz8/Jg8eTLnz5+nefPmGeLnkBAi7Uihn87O3T9HZKx+Lqv5Jt26dUt1V//Jkye0a9eObNmy8ccff2Sqefmvk98uP9WdqvFn1uzEbR0A9y5pHUk//DMHLm2D+t+Dc3mdnLJxyaTO/unQR3R5XuwXKVKEDh06MGvWLO7du6eTHEJ3nsUmMG3XZepM2c/OC7f5to4r+wZ60qa8M0ZGhl/gxsfHM3v2bNzc3JgxYwbdunUjMDCQ7777DjMzM63jCSE0kLmrMh3wueGDsWKMh5OH1lFSzdzcnKFDh+Ln58fevXvfeJyqqvTs2ZPAwEBWrFhBzpw5dZhSf3m5d+S+ksguGxtY0wVio7SOpK2wE7BrFBRpAlW+0empm5R05Nf2ZTkV+oiuvyUV+97e3jx79ky6+gZEVVU2nQ6jzpT9TN8TSF33XOz5rhbfNSiCtXnm2PBp9+7dlC1bll69elGyZElOnjzJvHnz5PuyEJmcFPrpzO+mH6UdSmNrZqt1lPfyxRdfkCdPnreuq//bb7+xbNkyRo8ejaenp24D6rFqearhYuvCcufCcPci7BiidSTtPHuUNNixyQ0tZ6XbvPy3aVrKkenty3AyJKnYz1vAlfbt2zNr1izu37+v8zwibZ0JfUSbOYfou+o09lnM+LOHB7O8yuGczUrraDoRGBhIy5YtqV+/PlFRUaxfv569e/dSuvT77TQthDBMUuino/vP7nPxwUWq5ammdZT3ZmFhwdChQ/Hx8WHfvn2vvH7+/Hl69+5NnTp1GDFihAYJ9ZeRYkT7Iu05GxnMhUpd4OTvcHaN1rF0T1Vhc2+IuAltfwOr7JpFaVbKiV8+LcOJ4Id0/e0YA4eOICoqiilTpmiWSXycOxHRDPjzNC1n+RES/oyJbUqxqVd1KhXQ7utMlx4/fsygQYMoXrw4e/fuZcKECVy4cIHWrVvLPHwhRDIp9NPRoZuHAP1fVvNNvvzyS5ycnF7p6j99+pR27dpha2vL8uXLMTbOHEvUvY+Wri2xMrFihY0V5POALf3gfqDWsXTr6ALw/wvqjoa8FbVOQ/PSTvzSvizHg8OZcDiCtu29mDFjhnT1M5jouARm7g2k9uT9bDlzi69rFWLfwFq0q5gX40wwDz8hIYH58+fj5ubGlClT6NSpE4GBgQwZMgQLi8yxq68QIvWk0E9Hvjd8sbewp2j2jLml+Iuu/sGDB9m/f3/yn/fq1YuAgACWL19O7ty5tQuox2zMbGhRqAXbg3byoNkUMDZLmsIS90zraLpx8xT8PQLcGoJHb63TJGtR2olpn5bheFA4zyp25VlcAlOnTtU6lkgFVVXZevYWdaccYPLfl6nhloNdA2oytHFRbCwyx4ZP+/fvp3z58vTo0YMiRYpw7NgxFi1aJN+HhRBvpLNCX1EUC0VRjiqKckZRlAuKonyvq3NrISExgUO3kpbVNFIy7njqq6++wtHRke+/T/rftXTpUpYuXcrIkSOpW7euxun0Wwf3DsQlxrHuth+0ngd3zsOOYVrHSn/Rj5MGNdYO0Hou6NlKTC3L5GHap2W4cDea4l/PZMac+Tx48EDrWOItzoc95tN5/9BrxUlsLExY8VVl5nWqgIu9tdbRdOLatWu0adOG2rVr8/DhQ1avXs3BgwcpX143K1gJITIuXf4EjgHqqKpaGigDNFIUpYoOz69T5x+c53HMY2rkqaF1lI/yoqt/4MABWrZsSY8ePfD09GTUqFFaR9N7Be0K4uHoweqA1cS51oZqfeHEb3B+ndbR0o+qwuY+8CgU2i7WdF7+27Qsk4ep7crwxCo31o0GMHHKL1pHEq9xNzKawWvP0HymL1fuPWFc6xJs7VODqoVyaB1NJyIjIxk2bBju7u7s2LGDsWPHEhAQQLt27WQevhAiVXS27piaNMn7yfPfmj7/J/Vbr2YwvmG+GClGGWpZzTcpVaoUAJs3bwagf//+Mi8/lTq6d6T33t7sCdlDozojIeQf2NwXHMuAfSGt46W944vg4kaoNwby6fc4vlXZPKio9F+VyLKQi3x7+y7OufVjKcKncU85e+8sua1z45zFGVPjzDE15YWY+AQW+wYxa98VouMS+KJaAb6t64adZea4DomJiSxdupThw4dz+/ZtOnXqxE8//USePHm0jiaEyGB0usCwoijGwAnAFZilquqR1xzTHegOkC9fPl3GS1O+N3wpmaMkduZ2Wkf5aIcPH0ZRFFRVxcjIiAsXLtCiRQutY2UI1fNUxzmLMyv9V9IofyNoswjmVk+a2vLFLjA1oIfnbp2FHcPBtT5U7at1mlRpXdaZG6E3mOxXjLbTd7Pv+0+xNNN2EHv45mFGHxrNrae3gKRVnJysnchnm498NvlwsXVJ/nUemzyYGhlO8auqKjsv3GH8Nn9CwqOo556T4U3cKeiQRetoOuPr60vfvn05efIkVapUYePGjVSuXFnrWEKIDEqnhb6qqglAGUVRsgIbFEUpoarq+f8cMx+YD1ChQoUM2fEPjw7nwoMLfFNGt5sDpRdPT08sLCyIjY3FzMxM1sx/D8ZGxrQv2p7Jxyfj/8Afd3v3pHnrK9vD397Q1EA2bYqOSBq8WGXXy3n5b/Ntiyps2DiUqw7V+HzRYX7/0gMLU90X+0/jnjLl+BTWXF5Dftv8/OL5C1HxUQRHBBMSEUJwZDBn753lSdyT5PcYK8Y4ZfnPIOD5vx2zOGaoQYD/rQh++Osih689wC1nFn7vVomahR20jqUzwcHBDB48mD///JM8efKwbNkyvLy8ZIqOEOKjaLJloKqqjxRF2Q80As6/4/AMxy/MDxU1w8/Pf8HDw4M9e/awf/9+PD098fDI+NORdKm1W2tmnZ7FioAVjK02Foo0TlqJ5vBMyF8dirfSOuLHUdWk5UMfXofPt4B1xps/Pb1/Rzy8+nG0aX++XHqchZ9X0Gmx/8+tfxjtl9TF71K8C73K9MLC5NW7Paqq8jDmYVLhHxFMSGRI8q9P3z3N07inyceaKCYpBgH5bJMGAC42SYMAEyP92DH2wZMYpuy6zKqjIdhamvJDy+J4VcqHiXHGGSx+jKdPnzJhwoTknZpHjRrF4MGDsbbOHA8aCyHSl86+0yuK4gDEPS/yLYF6wM+6Or8u+d30I7tF9qTurYHw8PCQAv8D2ZrZ0qxgMzZd2cSA8gPIZpEtaW35kMOw+VtwLAXZC2od88OdWJL0gHEdb8if8TaHAyhZsiSNi2Zn/955+PE1X/1+nAWd07/Yj4qLYuqJqay+tJr8tvn5vfHvlMlZ5o3HK4pCdovsZLfI/spxqqoSHh1OSGRI8l2AFwOBk3dOEhUflXysiWJCHps8yQOAl6cEOVrrZhAQG5/I74eDmL4nkKjYBDp75KdfPTeyWpml+7n1QWJiIsuXL2fo0KHcvHmTDh06MGHChAw9ZVUIoX902dJxBJY+n6dvBPypquoWHZ5fJxLVRA6FZfxlNUXa8irqxZrLa1gXuI4vS34JJmZJu8XOqwFrusIXf4OJudYx39/t87BjKBSsDdW/0zrNRxk1ahRrS5Wifv36+F4h3Yv9Y7ePMdJvJDef3KRzsc58W/bb13bxU0tRFOwt7bG3tKdszrIpXlNVlQfRD165ExASGcLxO8d5Fv/v/g4mRiY4Z3FOeSfA5t9BgLHRx10PVVXZG3CXcVv9uXb/KbUKOzCymTuuOW0+6nMzkn/++Yd+/fpx5MgRKlSowJo1a6hatarWsYQQBkiXq+6cBcq+88AM7sL9CzyMeZhhd8MV6cM1myuVc1dm9aXVdCneJaljms0FWs6G1R1h1yhonMFucMU8SZqXb5EV/rcgQ83Lf52SJUvSpk0bts4cyS+bj/DDjqt0/+ME8zuVT9NiPyouil9O/sLKgJXks8nHkkZLKJerXJp9/usoikIOyxzksMzxyrleDAKSnwV4aSBw7Pax1w4CXnT/XWxcyGubFxdbF3Jb5X7nICDwTiQ/bLmIT+B9CjpY81uXitQuqh8rHenCjRs3GDp0KMuXL8fR0ZElS5bQqVMnjDL43x0hhP7Sj0maBsQ3zBcFhapO0p0RKXVw70C/ff3YH7qfei71kv7QvRlU7glH5iTN13dvrm3I1FJV2DoAwq9C582QxTAemhw1ahTr1q0jaO9Kfv7flwxedzZNi/3jt48z0m8kYU/C+Mz9M/qU64OliWUaJP9wLw8CyudKuQGTqqrce3YvufsfHBFMaGQowRHBHL19NMUgwNTIFGcb5+Tuv4utC3ltkgYB5mTn1z1XWHYkBGszY0Y2K0ZnDxdMM8k8/KioKCZPnszPP/9MQkICw4cPZ9iwYWTJknlWExJCaENJWt5eP1WoUEE9fvy41jHeS8etHQFY3nS5xkmEvklITKDJ+iY4ZXHit0a//ftCfCwsbgDh16CHT1KnX9+d/AM29wbP4eA5ROs0aep///sfe/fuJSgoiJ2BEQxZd45ahR2Y9xHFflRcFL+e+pXl/svJa5OXsdXGvlJUZzSqqnI36u6/DwRH/vtcQGhEKNEJ0S8dbEJibHacrPNSq4A7he0LJK8QlMs6l8FOc1RVldWrVzN48GBCQ0Np27YtEydOpECBAlpHEyIFRVFOqKpaQescIu1JRz8NPYx+yLn75+hZuqfWUYQeerHU5tQTU7kUfoki2YskvZA8X78mrO0KXXck/Zm+unMRtg2CAjWh5kCt06S5UaNGsWHDBqZPn87o0aNJVGHY+nN8vewEcz97/2L/xJ0TjPQbSWhkKF5Fvehbri9WplbplF53FEUhl3UuclnnomLuiileS1QT2XTOn2n7D3Er6gZ5cz4lf95nPIy9ycZra4gJjEk+1tzYnLw2eZO7/y8/E5DTKmeGHQQcP36cfv364efnR5kyZfjjjz+oVauW1rGEEJmMdPTT0LZr2xjiM4QVTVZQ0qGk1nGEHnoc85h6a+rRtGBTxlQdk/LFi5vgz85QpRc0Gq9JvneKfQrza8Ozh/C1L9jk0jpRumjdujX79u0jKCiIrFmzsuJICMM3nKN2EQfmdiqPucm7i/1n8c/49WRSF98pixNjq419pSA2RFfvPeHHLRfZd+keLvZWjGjiTv1iuZLXg09UE7kbdfeV5UFDIkIIjQwlNjE2+bMsjC2SpgM97/6/PCVIXwcBt27dYvjw4SxZsoScOXMyfvx4unTpIruJC70mHX3DJR39NOQb5ktW86wUsy+mdRShp+zM7WhasClbr22lf/n+KXdOLtYSKn4F/8xKmq9ftIl2Qd9k60C4fxk6bzTYIh+SuvobN27k119/ZdSoUXhVzoeKyogN5+m57CRzPiv31mL/1N1TjPQbSXBEMO2LtKd/+f4G0cV/m8dRcUzfE8jvh4OwNDVmeJOifF41/yvXyUgxIrd1bnJb56ayY8odXxPVRO48vfPvNKDnU4KuP77OwRsHiUuMSz7Wwtgi6UHgFw8Ev/RsgIOlg843moqOjmbq1KmMHz+euLg4Bg8ezIgRI7C1tdVpDiGEeJl09NNIoppI7T9rU8WxCj/XzGCrpwiduhR+ibZ/tWVA+QF0LdE15Ytx0bCoPjwKga99IKseral9egVs7Ak1B0OdEVqnSXetWrXiwIEDBAUFYWeXNCBb9k8w3hvPU7doTma/ptiPjo9mxqkZ/HHxD5yyOPFD1R+o5FhJi/g6E2oFoEkAACAASURBVJ+QyMpjoUz9+xKPnsXRvmJeBtQvgoNN2i4Xm5CYwJ2oOyl2Cg6NCCU4MpgbkTdSDAIsTSz/nQr0n70CcljmSNNBgKqqrFu3jkGDBhEUFESrVq2YPHkyhQoVSrNzCJHepKNvuKSjn0b8H/gTHh0uy2qKdyqSvQjlc5Vn9aXVdC7WOeWShKYW8MkSmFcL1naDrtvB2FSzrMnuBsDW7yB/DfAcqnUanRg9ejTlypXj119/ZeTIkQB8VsUFFRi58Ty9lp9kVsd/i/3Td08z0m8kQRFBtCvcjgEVBmBtati7m/pduc8Pf13k0p1IKhfIzqjmxSjuZPfuN34AYyNjnLI44ZTFCQ+nlJv3JSQmcDvqdoolQkMjQwl8GMi+0H3EJ8YnH2tpYpliGtDLv7a3sH+vQcDp06fp168fBw4coGTJkuzZs4c6deqk2X+zEEJ8LOnop5G5Z+Yy+/Rs9n+6n+wW2bWOI/TcruBdDNg/gOm1p1Mn32sKg/Prkx7MrdoHGozVfcCXxUbBgjrw9F7SvHxbR23z6FDLli3x8fHh+vXryV19gD8OBzFy0wXquedkWvsSLDg3h6UXl5LLKhc/VPuBKo5VtAutA0H3nzJumz+7Lt7BOZslI5q406hEbp1Pl0mN+MR4bj29ldz9f3kgcCPyBvHqv4MAKxOrFN3/lx8QfnkQcOfOHby9vVm0aBH29vaMHTuWL7/8EhMT6Z2JjEk6+oZLCv000mlbJ+IT41nZbKXWUUQGEJ8YT+P1jXGxdWFhg4WvP2hLfzi+GLz+hMINdRvwZZt6w6ll8Nk6cK2rXQ4NnDhxggoVKjB27Fi8vb1TvPb74SDG7NyOfYENRHOLtoXb8l3578hiZrhro0dGxzFz7xUW+13H1NiIXrVd+aJ6gXTbPTi9xSfGc+vJreQ9Al7eKyAsMizFIMDa1BrnLM5E34rm7P6zPL35lJY1WjLy25Hkz5lfLwc5QqSWFPqGSwr9NPA45jE1V9fkq5Jf0btsb63jiAxi4bmFTD85nY0tN1Io62vm88ZFw8J6EBGWNF/fzln3Ic+shg3docZ3UHeU7s+vB1q0aIGvry9BQUHJD1bGJMQw+/Rsfju/hIQ4G4qZfsnyjp0xM9G/VWDSQkKiyprjoUz++xL3n8TStrwzgxsWIaethdbR0k1cYhy3ntxKng60/8x+/C76EW8Tj7mDObz0vzqLaZbkOwH/nRKUzTybDAKE3pNC33BJoZ8GdlzfwaCDg/ij8R+UyVlG6zgig3gY/ZB6a+rRyrUVIz1Gvv6g+1dgfi3IVQK6bNHtfP17l2G+JziWhs//AuPMOS3hRVf/xx9/ZMSIEZy/fx5vX2+uPr5KG7c2OMa35adtwTQolotZHcsZ3G6vR6494Pu/LnLxVgQVXLIxqnkxSjln1TqWzpw7d47+/fuzZ88e3N3dmTZtGnXq1+Hmk5spdgp+MSXo5tObJKqJye+3MbV5dRDw/PdZzbPKIEDoBSn0DVfm/MmdxnzCfLAzt6NkDlk7X6ReNotsNCnYhL+u/UXf8n2xNXvNMnw5XKHZL7D+S9g3DuqN0U24uGewpguYmEObhZm2yAcoX748zZo1Y+r0qZjWMWVF4ApyWOZgTr05yQ/fmxlb8/1fF+m94iQzvQyj2A8Nj+Kn7f5sO3cbJzsLfu1QlualHDNNYXr//n1GjRrFvHnzsLOzY8aMGfTo0QNT06TBtoutCy62r+5iHZcQR9iTsH+nAz3fLfjs/bPsDN6ZchBgZpO8LOjLzwbks8lHVovMM5gSQqSfzPvTO40kqon4hflR1bFqytVThEgFr6JebLyykY2BG+lcvPPrDyr1CQQdBN9p4FId3Oqlf7AdQ+HuBei4FuzypP/59FznwZ0JOBjAH5f/oLVrawZVHISNmU3y612rFUBV4YctF/l2xSlmeJXNsMX+k5h4Zu+7wkLf6xgrCv3rFaZ7zYJYmmWO729xcXHMmjWL77//nsjISHr16sWYMWPInj11iyyYGpuS3y4/+e3yv/rZCXHceHLj303Cnm8YdubeGbZf347Kv3fYbc1sU3T/X94xOMX+G0II8RZS6H+kgPAAHkQ/oLqzLKsp3p+7vTtlc5ZlZcBKOrp3fPNgsfFEuHEiab78175g65R+oc6thRNLoFo/cKuffufJAOIS4ph7di6Lri/C2t6auwvuMmh7yiL/hW7VC6ACY7dcpM/KU/zaIWMV+4mJKutO3mDizkvci4yhVRknhjQuiqOdpdbRdGbbtm0MGDCAS5cu0bBhQ6ZOnUqxYmm3AaKpsSkF7ApQwK7AK6/FJsSmHAQ8vxNw6s4ptl3blmIQYGdu9/o7Abb5Xn9nUAiRaUmh/5H8wvwAqOpUVeMkIqPyKurFoIOD8A3zpVbeWq8/yNQyaX39+Z6w7kvovDl9ptM8uAp/9YW8laGO97uPN2AXH1zE28+bwIeBtCjUgvom9andszazZs1i6NDX7yXwRfUCqKrKj1v96bvqFNPbZ4xi/3hQOD9sucjZG48pnTcr8zqVp1y+bFrH0hl/f38GDBjAjh07KFy4MFu2bKFJkyY6naZkZmxGQbuCFLQr+MprMQkxhEWGpVgZKCQyhBN3TrD12tYUg4Cs5llTdP9fHgS8boAqhDBs8jDuR/p8++c8i3/Gn83/1DqKyKDiEuNotLYRrtlcmVd/3tsPPrMKNvSAmoPSvhCPi4ZF9eDxjaS7Blqs8qMH4hLimH9uPgvOLiC7RXbGVB1DTeeaADRp0oSjR48SFBRElixvXkZzoc81ftzqT9OSjvzSvozeFvthj54xYXsAf525SS5bc4Y2LkrL0nkwMsoc8/DDw8MZM2YMs2fPJkuWLIwePZpevXphZmamdbRUi0mIITQiNHka0Iu9AkIiQ7j99HaKY7NbZH91x+DngwJDXhZWvJs8jGu4pKP/ESJiIzhz7wzdSnTTOorIwEyNTGlXpB0zT8/k+uPrr72tn6x0e7juAwcng0tVKJSGu3D+PQJun4MOqzNtkR8QHoC3rzeXHl6iecHmDKk0JMV86NGjR1OlShVmzZrFkCFD3vg5X9YoiKrCuG3+AExvXwYTPSr2o2LjmXvgGvMPXkVVoU8dV772LISVWeb4kRAfH8/cuXMZPXo0jx49onv37vzwww84ODhoHe29mRub45rNFddsrq+8Fh0fTWhkaHLh/+JOwJFbR9h8dXOKY7NbZH/tykAuti4Gv8OzEIZMOvofYWfQTgYeGMjvjX+nbM6yWscRGdiDZw+ov7Y+bQu3ZXjl4W8/OPbp851q70NPP7DJ/fEBXuzE69EbGo77+M/LYOIS41h4diHzz84nq0VWRlUZRe18tV97bOPGjTl27Ng7u/oA8w5c5aftATQr5cgvn2pf7KuqyqbTN5mwPYDbEdE0K+XI0MZFcc5mpWkuXfr777/p378/Fy9epE6dOkybNo1SpUppHUvnnsU/SzEIePnZgLvP7qY41t7C/pWdgl8MAqxMM8/XjiGTjr7hyhztm3TiG+aLjZmNLKspPpq9pT2N8jdi05VN9Cnb5+230c2sn8/Xr/18vv4m+JgVn8KvweY+kKeC7pbv1COXwi8x0m8k/uH+NC3YlGGVhr11VZPRo0fj4eHB7NmzGTx48Fs/u0etQqjAhO0BKIrCtHalNSv2T4c+4vu/LnAq5BEl89gxw6ssFfOnbiUZQ3D58mW+++47tmzZQqFChdiwYQMtW7bMNMuF/peliSWFsxWmcLbCr7wWFReVNAh4aafg4IhgDt08xKarm1Icm8Myxysbhb0YFMggQAjtSUf/A6mqSt01dSmXqxyTa03WOo4wAOfvn6fD1g4MrTSUju4d3/2GU8tgUy+oNRRqD/uwk8bHwKL68DAIevhAtlfXBTdUcYlxLDq3iHln52FrZssoj1HUzVc3Ve9t1KgRJ06c4Pr16+/s6gPM2X+Vn3cE0KK0E1N1XOzffhzNxB0BrD8VhoONOYMaFqFtOedMMw//0aNHjB07lhkzZmBhYYG3tzd9+/bF3Nxc62gZ0otBwMvLg7749f1n91Mc62DpkDwAePnZABkE6B/p6Bsu6eh/oMsPL3Pv2T2qOVXTOoowECVylKCUQylWBqykQ9EOGCnvKAbLdIQgXzjwc9J8/YJvWLHnbf4eCbfOQPsVmarID3wYyAjfEfiH+9M4f2OGVR5GNovUrzIzevRoqlatypw5cxg0aNA7j+/pWQgVlYk7LqEoMOWT9C/2o+MSWHDwGrP3XyUhUaWnZyF61XYli3nm+LafkJDAwoUL8fb25sGDB3Tr1o1x48aRK1curaNlaFamVhTJXoQi2Yu88trTuKev7BQcGhnKgdADPIh+kOLYnJY5Xx0E2CYNAixNMs+SrkKkt8zxHT8d+IT5ACTvjClEWvAq6sVQn6Ecunno3V9bigJNJkPYCVj/VdJKOVlypv5kFzfD0XlQ5Rso2vTjgmcQ8YnxLD6/mDln5mBrZss0z2nUc3n/Dcg8PDxo0KABkyZN4ptvvsHa+t0PK37j6YqqwqSdlwCY2q4MxunQVVdVla3nbvHTtgDCHj2jUfHcDG/iTj77zNNB3bdvH/369ePs2bPUrFmTX375hbJl5Tmq9GZtak3R7EUpmr3oK689iX2SdAfgpbsAoZGh7AvdR3h0eIpjc1rlTLEy0IulQvPa5MXCxEJX/zlCGASZuvOBuuzowtO4p6xpvkbrKMKAxCXE0WBdA9yzuzO73uzUvenOhaSHc/NVgc/Wp26+/sMgmFsT7AtBt51gknGWE/xQVx5ewdvPmwsPLtAwf0OGVx5OdosPn6N+6NAhqlWrxqRJkxg4cGCq3zdr3xUm7bxEqzJOTEnjYv/cjcf8sOUCx4Ie4u5oy6hmxfAoZJ9mn6/vrl27xsCBA9mwYQP58+dn0qRJtGnTJtPOw88oImMjCYkMITQi5ZSgkMiQVwYBuaxyJXf/XWxcyGubN/nf5sYyHetDydQdwyUd/Q8QGRvJ6bun6Vqiq9ZRhIExNTblk8KfMOfMHIIjgnGxTcV0mlzFk3bO/asP+EyFWu+YShIfC2uef+1+8pvBF/nxifEsubCE2adnk8U0C5NrTaZh/oYf/blVq1alfv36TJo0iZ49e6aqqw/Qq7Yrqqoy+e/LKIrC5E9Kf3Sxfzcymkk7LrH25A2yW5kxvnVJPq2YN13uGOijiIgIxo8fz7Rp0zA1NWXcuHEMGDAACwvp/mYENmY2FLcvTnH74q+8FhEbkbxPQPKUoMhg9gTv4WHMw+TjFBRyW+d+5cHgfLb5cLZxlkGAyLSk0P8A/9z6hwQ1QabtiHTxSeFPWHBuAasCVjGk0pvXak+hXGcI8oH948HFA/K/5Wtz92i4eRLa/QHZ8qdJZn119dFVRvqN5Nz9c9R3qc+IyiOwt0y7Dvfo0aOpXr06c+fO5bvvvkv1+3rXcSNRham7LqMAkz6w2I+OS2Cx33Vm7b1CbEIiX9UoSO86rthamL73Z2VECQkJLFmyhBEjRnDnzh0+//xzxo8fj5OTk9bRRBqxNbOleI7iFM/x6iDgcczjVx4MDokIYVfwLh7FPEo+TkHB0doxufv/8kDA2cYZM2PDbnaIzE0K/Q/gF+aHjakNpR1Kax1FGCAHKwcauDRg45WNfFv229StTqEo0Gwa3DwFa794Pl//NZv/BGyFf2ZDpe5QrEXah9cTCYkJLL24lFmnZmFlasWkmpNomL9hmk/hqFatGvXq1WPixIn07NkTK6vUz4PvU9cNVYVpuy+DApPapr7YV1WVnRduM26bP6Hhz6jnnosRTd0pkCPzbGzk4+ND3759OXXqFFWrVuWvv/6iYsWKWscSOmRnboeduR0lcpR45bXHMY+Tu/+hEaHJOwbvCNpBRGxE8nFGihGO1o7/7hT8YnlQ27zkzZIXU+PMMWgWhksK/fekqio+YT5UcaqCiZFcPpE+vNy92HZ9G5uvbqZ90fape5O5TdL6+gvqwobu0HEdGL20ssujENjYExxLQ4Mf0yW3Prj2+Boj/UZy9t5Z6uari3cVb3JY5ki3840ePZoaNWowd+5cBgwY8F7v7VvPDRWVX3YHYqQo/Nym1DuL/Ys3I/hhywX+uRZO4VxZ+OOLStRwy3g7un6ooKAgBg8ezJo1a3B2dmbFihW0b99e5uGLFOzM7SjpUJKSDq/uc/M45jHBEcGv3AnYdn0bkbGRyce9GAS8vDLQizsBebLkkUGAyBB0VqkqipIX+B3IDSQC81VVna6r86eVwEeB3I26K9N2RLoqlaMUxe2LsyJgBZ8W+TT1RUzuktB4AmzpD37ToMbz6SQJcbC2G6hq0mDAxPDmqyYkJvDHxT+YcWoGlqaW/FzjZxoXaJzuBWD16tWpW7cuEydO5Ouvv36vrj5Av3qFUVWYvicQBfi5TanXrnF//0kMU/6+zOpjIdhZmjK2ZXE6VMqn+W67uvLkyRMmTJjA5MmTMTIyYsyYMQwaNOi9r7cQduZ2lHIoRSmHlDsiq6rKo5hHr+wPEBIRwrl754iM+3cQYKwYvzIIeDElyCmLE6ZGMggQ+kGXLel44DtVVU8qimIDnFAUZZeqqhd1mOGj+Yb5Asj6+SJdKYpCR/eODPcdzuFbh6nqVDX1by7fFa77wN5xkK9q0pz9Pd/DjWNJRX72gumWWytBj4Pw9vPmzL0z1M5bm1Eeo9K1i/9fo0ePpmbNmsyfP59+/fq99/v71y+MCvy6JxBIWezHxiey9FAQv+4J5FlcAp9XzU+/uoWxs8ochURiYiLLli1j2LBh3Lx5Ey8vLyZMmEDevHm1jiYMjKIoZLPIRjaLbK9MzVVVlYcxD5NXA3rxYHBIZAhn7p3hSdyT5GONFWOcsjilWBr0xZQgpyxOMhtA6JRmy2sqirIJmKmq6q43HaOPy2t229mNxzGPWddindZRhIGLTYil/tr6lMpRihl1Z7zfm6MjYH4tiIuGuiOTpuxU+AKaTU2fsBpJSExguf9yfj31K+bG5gyrPIymBZpqMo2jTp06+Pv7c+3aNSwt33/DH1VVmbbrMr/uvUK7Cs5M+F8p9gbcZdw2f67ff4pnEQe8mxbDNee7d+I1FIcPH6Zfv34cPXqUihUrMn36dDw8PLSOJUQKqqoSHh3+2jsBwRHBRMVHJR9ropj8Owj4z14BjlkcNRsEyPKahkuTryhFUfIDZYEjWpz/Qz2Ne8qpO6foXLyz1lFEJmBmbEbbwm1ZcHYBoZGh5LV5jw6mhW1S935hvaQiP3dJaDg+3bJqITgimJF+Izl19xSezp6M8hiFg5V2c9VHjx6Np6cn8+fPp2/fvu/9fkVRkjv7M/Ze4Z9r4YSER1HIwZrfulakdpH32AwtgwsNDWXo0KGsWLECR0dHli5dymeffYaRUeaYpiQyFkVRsLe0x97SnrI5U27MpqoqD6IfJHf/Xx4InLxz8pVBQB6bPMnd/wq5K1A3X11d/+cIA6Pzjr6iKFmAA8A4VVXXv+b17kB3gHz58pUPDg7Wab632ROyh377+rG44WIq5pbVHUT6u/P0Do3WNaKje0cGVkz9pkzJTv4OBydDpw1Jm2MZgEQ1kRX+K5h+cjqmxqYMrTSU5gWb68XDmLVr1yYgIOCDu/rwvLO/O5AVR0L4xrMQnTxcMM0k8/CjoqKYNGkSP//8M6qqMnDgQIYMGUKWLJnnLobIPF4MAl6eBvTyr5sUaMKYqmN0kkU6+oZLp4W+oiimwBZgp6qq75xDoG9Td74//D3br2/Hp72PPGgjdGbggYEcunmI3W13p26pzf9S1aTlNw1ASEQII/1GcvLuSWo612RUlVHkss6ldaxk+/fvp3bt2kyfPp0+ffpoHSfDUFWVVatWMWTIEEJDQ2nXrh0TJ07ExSUVG8YJYYBUVSUmIQYLE91s+iaFvuHSWZtISWq3LQL8U1Pk6xtVVfEN86WKYxUp8oVOdXTvSGRsJFuubfmwDzCAIj9RTWS5/3La/tWWwIeBjK02lpl1ZupVkQ/g6elJrVq1mDBhAtHR0VrHyRCOHTtG9erV8fLywsHBgYMHD7J69Wop8kWmpiiKzop8Ydh0eT+4GtAJqKMoyunn/zTR4fk/ytVHV7n99LYsqyl0roxDGdyzu7MyYCVaPTyvpdDIUL7Y+QUTjk6gXK5yrG+5nlaurfRiqs7rjBkzhlu3brFgwQKto+i1mzdv8vnnn1OpUiWuXr3KokWLOHr0KDVq1NA6mhBCGAydFfqqqvqqqqqoqlpKVdUyz//Zpqvzfyy/m34AUugLnVMUhQ5FO3Dl0RWO3T6mdRydSVQTWRmwkjab2xAQHsAPVX9gTt055LbOrXW0t/L09KRmzZrS1X+DZ8+eMW7cOAoXLpw8Xefy5ct069YNY2NjreMJIYRByRxPeKUBnzAfXLO66n2RIQxT4wKNyWqeleX+y7WOohNhT8L46u+vGH9kPGVzlmVDyw20dmutt138/xo9ejQ3b95k4cKFWkfRG6qqsmbNGtzd3fH29qZBgwZcvHiRCRMmYGtrq3U8IYQwSFLop0JUXBQn75yUbr7QjIWJBW0Lt2X/jf3cfHJT6zjpJlFNZHXAalpvas2FBxcY4zGGufXmZrgBdu3atalRo4Z09Z87deoUnp6etGvXDjs7O/bu3cv69espVMgwVoISQgh9JYV+Khy5dYS4xDgp9IWmPi3yKQoKqy6t0jpKurj55Cbdd3XnxyM/UtqhNBtabKBN4TYZpov/MkVRGD16NGFhYSxatEjrOJq5c+cOX375JeXLl+fixYvMnTuXkydPUrt2ba2jCSFEpiCFfir4hvliZWJFuZzltI4iMrHc1rmpk68O6wPXEx1vOF1iVVVZc3kNrTe15ty9c4ysMpL59efjmMVR62gfpU6dOlSvXp2ffvqJmJgYrePoVExMDBMnTsTNzY2lS5fSv39/AgMD6dGjh8zDF0IIHZJC/x1eLKtZ2bEypsayrKbQVoeiHXgc85ht1zPMc+xvdevJLXrs6sEPh3+gZI6SrG+5nnZF2mXILv5/ZcauvqqqbNy4keLFizNkyBA8PT25cOECU6ZMIWvWrFrHE0KITEcK/Xe4HnGdm09vyrQdoRcq5KqAWzY3lvsvz9BLbaqqyrrL62i9uTWn753Gu7I38xvMJ0+WPFpHS1N169alWrVqmaKrf+7cOerVq0fr1q0xNzdn586dbN68mcKFC2sdTQghMi0p9N/B94YvIMtqCv2gKAodi3bk8sPLnLhzQus4H+T209v03N2TMYfHUMy+GOtbrOfTop9ipBjet6MXXf0bN27w22+/aR0nXdy7d4+ePXtSpkwZTp8+zcyZMzlz5gwNGjTQOpoQQmR6hveTNY35hvlS0K4gTlmctI4iBABNCjbB1syWFQErtI7yXlRVZUPgBlpvas3JuycZXnk4CxssxNnGWeto6apevXp4eHgwfvx4g+rqx8bGMm3aNNzc3FiwYAG9e/cmMDCQXr16YWJionU8IYQQSKH/VlFxURy/c1y6+UKvWJpY0satDXtD9nL76W2t46TKnad36LWnF6MOjaJI9iKsa76ODkU7GGQX/78URWHMmDGEhoayZMkSreN8NFVV2bJlCyVLlmTAgAF4eHhw7tw5pk+fTvbs2bWOJ4QQ4iWG/1P2Ixy7fUyW1RR66dOin6KisvrSaq2jvJWqqmy6sonWm1pz7PYxhlYayuKGi8lrm1fraDpVv359qlSpwvjx44mNjdU6zge7ePEijRo1onnz5iiKwtatW9m+fTvu7u5aRxNCCPEaUui/hW+YL5YmlpTPVV7rKEKkkCdLHjydPVl3eR0xCfo5HeRu1F167+2Nt583btncWNdiHR3dO2aKLv5/vejqh4SEZMiufnh4ON9++y2lSpXi6NGjTJs2jXPnztGkSROtowkhhHiLzPcTN5WSl9XMXRkzYzOt4wjxCi93Lx7GPGT79e1aR0lBVVX+uvoXrTa14uitowyuOJjfGv1GPtt8WkfTVIMGDahcuTLjxo3LMF39uLg4ZsyYgaurK7Nnz6Z79+4EBgbSr18/TE1luWEhhNB3Uui/QXBEMDee3KBanmpaRxHitSrlroRrVldW+K/Qm6U270Xdo8/ePgz3HU4hu0Ksab6GTsU6Zcou/n+93NVfunSp1nHeaefOnZQuXZo+ffpQrlw5Tp8+zezZs8mRI4fW0YQQQqSS/PR9A98wWVZT6DdFUehQtAP+4f6cuXdG0yyqqrLl2hZabWrF4VuHGVhhIEsaLSG/XX5Nc+mbhg0bUqlSJb2eq3/p0iWaNWtGo0aNiI2NZePGjezatYuSJUtqHU0IIcR7kkL/DXzDfMlvm9/gl/4TGVuzgs2wMbVhuf9yzTLcf3affvv6McxnGPnt8rOm+Ro+L/45xkbGmmXSVy/W1Q8KCuL333/XOk4Kjx49YsCAAZQoUQIfHx8mTZrEhQsXaNmypUHsVCyEEJmRFPqv8Sz+GcduH5NuvtB7VqZWtHZrze7g3dyNuqvTc6uqyrZr22i1qRW+Yb58V/47fm/0OwXsCug0R0bTuHFjKlasyLhx44iLi9M6DvHx8cydOxc3Nzd++eUXunbtyuXLlxk4cCDm5uZaxxNCCPERpNB/jeO3jxObGEuNPDW0jiLEO7Uv2p4ENYE/L/2ps3M+ePaAAfsHMMRnCPls8rGm+Rq6lOgiXfxU0Keu/t69eylXrhw9e/akePHinDx5kvnz55MrVy5NcwkhhEgbUui/hm+YLxbGFpTPLctqCv2X1yYvNZ1rsubyGmIT0n/e946gHbTe1JoDNw7Qr1w/fm/8OwWzFkz38xqSJk2aUKFCBc26+leuXKF169bUrVuXyMhI1q5dy759+yhTpozOswghhEg/Uui/hm+YLxVzV8TcWG5bi4zBq6gX4dHh7AzamW7nCI8OZ8D+AQw6MIg8WfKwpvkavij5BSZG/OQqNQAADstJREFUJul2TkP1oqt//fp1li1bprPzRkREMHjwYIoXL86uXbsYP348/v7+tGnTRubhCyGEAZJC/z9CIkIIiQyR+fkiQ/Fw8qCAXQFW+K9Il8//O+hvWm9qzb7QffQt15c/mvxBoayF0uVcmUXTpk0pX748P/74Y7p39RMSEli4cCFubm5MmjQJLy8vAgMDGTZsGBYWFul6biGEENqRQv8/fMJ8AGR+vshQXiy1ef7Bec7eO5tmn/sw+iGDDgziuwPfkds6N382+5MvS34pXfw08KKrf+3aNZYvT79Vkw4ePEjFihX56quvcHNz49ixY/z22284Ojqm2zmFEELoByn0/8MvzA8XWxfy2ubVOooQ76VFoRZYm1qzIiBtuvq7g3fTalMrdofs5tuy37KsyTLcsrmlyWeLJM2aNaNcuXL8+OOPxMfHp+lnBwUF8cknn1CrVi3u37/PypUr8fHxoUKFCml6HiGEEPpLCv2XxCTEyLKaIsOyNrWmlWsrdgbt5P6z+x/8OY+iHzH44GD67+9PLqtcrGq6iu6lumNqZJqGaQX829W/evVqmnX1nzx5wogRIyhatCjbtm3j+++/JyAggPbt28s8fCGEyGSk0H/J8dvHiU6IpppTNa2jCPFBOhTtQHxiPGsurfmg9+8N2UurTa3YFbSLb8p8w/KmyymSvUgapxQva968OWXLlmXs2LEf1dVPTExk6dKlFC5cmPHjx9O2bVsuXbrEqFGjsLKySsPEQgghMgop9F/iG+aLubE5FXNX1DqKEB/ExdaF6nmq8+flP4lLSP0Dno9jHjPUZyh99/XFwcqBVc1W0bN0T+ni68DLXf0VKz5s2tWhQ4eoUqUKXbp0IW/evBw+fJhly5bh7Cw7ewshRGYmhf5LfMN8qZC7AhYmsgqFyLi8inpx/9l9dgXvStXx+0L20WpTK3Ze30nP0j1Z0WSFdPF1rEWLFpQpU+a95+qHhobi5eVFtWrVCAsL448//uDw4cNUqVIlHdMKIYTIKKTQfy40MpSgiCBZbUdkeNXyVMPF1uWdD+U+jnnMcJ/h9NnXh2wW2VjRdAXflPkGU2Pp4uvai65+YGAgK1eufOfxUVFRjBkzhiJFirBhwwZGjhzJ5cuX+eyzzzAykm/rQgghkshPhOf8wvwA5EFckeEZKUa0L9KeM/fOcOH+hdcec/DGQf636X9su76NHqV6sLrpatzt3XWcVLysZcuWlC5d+q1dfVVVWb58OUWKFOH777+nRYsWBAQE8MMPP2Btba3jxEIIIfSdzgp9RVEWK4pyV1GU87o65/vwDfPFOYsz+WzyaR1FiI/W0rUlViZWr3T1I2Ij8Pb1pteeXtia27K86XJ6l+0tXXw9oCgKo0aN4vLly6xateqV148ePUrVqlX57LPPyJUrFz4+PqxatQoXFxcN0gohhMgIdNnRXwI00uH5Ui0mIYajt49SPU91WX5OGAQbMxtaFGrB9uvbefDsAQA+N3xovak1W65t4auSX7G62WqK2xfXOKl4WatWrShVqhRjx44lISEBgLCwMDp37kzlypUJCgpi8eLFHD16lOrV5e6jEEKIt9PZ9paqqh5UFCW/rs73Pk7cOcGz+GfUcJb5+cJwdHDvwKpLq1h6cSmPoh+x4coGCtkVYnrt6ZTIUULreOI1jIyMGDVqFG3btqVdu3bY29uzfPly4uPjGTp0KMOHD8fGxkbrmEIIITII2ceepGk7ZkZmsqymMCgF7Qri4ejBb+d/w0gx4osSX9CzTE/Mjc21jibeInfu3CiKwvr16wGoVasWixcvpmDBghonE0IIkdHoXaGvKEp3oDtAvny6mS+fqCZS07kmliaWOjmfELrSu2xvjIyM6FW6FyUdSmodR6TCwYMHURQFVVUxMjKiYcOGUuQLIYT4IIqqqro7WdLUnS2qqqZq3kCFChXU48ePp2smIYTQJ4cPH6Zu3brExsZiZmbGnj178PDw0DqWEMKAKYpyQlXVClrnEGlP7zr6QgiRmXl4eLBnzx7279+Pp6enFPlCCCE+mM4KfUVRVgKeQA5FUW4Ao1VVXaSr8wshREbh4eEhBb4QQoiPpstVdzro6lxCCCGEEEJkdrIzrhBCCCGEEAZICn0hhBBCCCEMkBT6QgghhBBCGCAp9IUQQgghhDBAUugLIYQQQghhgKTQF0IIIYQQwgBJoS+EEEIIIYQBkkJfCCGEEEIIAySFvhBCCCGEEAZICn0hhBBCCCEMkKKqqtYZ3khRlHtAsNY5NJQDuK91CD0n1+jd5Bqljlynd5Nr9G5yjVJHrtO76fIauaiq6qCjcwkd0utCP7NTFOW4qqoVtM6hz+QavZtco9SR6/Ruco3eTa5R6sh1eje5RiItyNQdIYQQQgghDJAU+kIIIYQQQhggKfT123ytA2QAco3eTa5R6sh1eje5Ru8m1yh15Dq9m1wj8dFkjr4QQgghhBAGSDr6QgghhBBCGCAp9PWMoih5FUXZpyiKv6IoFxRF6at1Jn2lKIqxoiinFEXZonUWfaUoSlZFUdYqihLw/GvKQ+tM+kZRlP7P/66dVxRlpaIoFlpn0geKoixWFOWuoijnX/qz7Iqi7FIUJfD5v7NpmVFrb7hGk57/fTurKMoGRVGyaplRa6+7Ri+9NlBRFFVRlBxaZNMnb7pOiqJ8qyjKpeffoyZqlU9kXFLo65944DtVVd2BKkAvRVGKaZxJX/UF/LUOoeemAztUVS0KlEauVwqKouQB+gAVVFUtARgD7bVNpTeWAI3+82dDgT2qqroBe57/PjNbwqvXaBdQQlXVUsBlYJiuQ+mZJbx6jVAUJS9QHwjRdSA9tYT/XCdFUWoDLYFSqqoWByZrkEtkcFLo6xlVVW+pqnry+a8jSSrM8mibSv8oiuIMNAUWap1FXymKYgvUBBYBqKoaq6rqI21T6SUTwFJRFBPACripcR69oKrqQSD8P3/cElj6/NdLgVY6DaVnXneNVFX9W1XV+Oe//Qdw1nkwPfKGryOAacBgQB4U5I3XqScwQVXVmOfH3NV5MPH/9u4/9K66juP485UzdFPyB6wmVt+UNkVX+6GgjkA2JRGZiMKImV9QiJw0+oHUWBqY1EypiMQfpSFsJTGHiaJNNC1/j8l+pKMkLP0u5y9MbcMfzVd/nI96vdzv/d6bf5xzT68HjO+59/M+n/f7e+F79j7nfO69Iy+NfoNJGgPmA4/WW0kj/ZTqP4l36i6kwY4AXgR+VZY4/VLSjLqLahLbO6mukj0DPAe8antjvVU12sdtPwfVRQlgZs31NN35wJ11F9E0kpYCO21vrbuWhpsNfEHSo5Lul3R83QXF6Emj31CSDgBuAb5u+7W662kSSWcAL9jeXHctDTcNWABcY3s+sJsstfiAssb8TOAzwGHADEnn1ltVtIGk1VRLMdfVXUuTSJoOrAYurbuWETANOJhqGe/FwG8lqd6SYtSk0W8gSftSNfnrbG+ou54GWgQslfR34GZgsaS19ZbUSBPAhO137witp2r8432nAE/bftH228AG4KSaa2qy5yXNAig/s5SgB0njwBnAcuczrLsdSXVivbUcww8HHpf0iVqraqYJYIMrj1Hdwf6/f+NyDCeNfsOUs/UbgB22f1x3PU1ke5Xtw22PUb1x8l7buQrbxfYu4FlJc8pTS4AnayypiZ4BTpA0vfztLSFvWO7nNmC8bI8Dv6uxlkaSdBrwbWCp7T1119M0trfbnml7rBzDJ4AF5XgVH3QrsBhA0mzgo8BLtVYUIyeNfvMsAr5MdZV6S/l3et1Fxcj6GrBO0jZgHvCDmutplHK3Yz3wOLCd6piYb6MEJP0GeBiYI2lC0gXAGuBUSU9RfWLKmjprrNskr9HPgQOBu8vx+9pai6zZJK9RdJnkdboROKJ85ObNwHjuEMWw8s24EREREREtlCv6EREREREtlEY/IiIiIqKF0uhHRERERLRQGv2IiIiIiBZKox8RERER0UJp9CMiIiIiWiiNfkREREREC6XRj4hGkXRox5fF7ZK0s+Px7PLlMb32e2iIHAPFSjpI0oqOx2OT5f+wJP17ivGhc081Z0REtFsa/YhoFNsv255nex5wLfCTjsdv9dnvpCFyDBp7ELBiyqiIiIgGSqMfEaNmH0m/kPSEpI2S9of3r15LmiHpDklbJf1Z0rLuCYaIXQMcWe4mXNkvf5nvXEmPlfjrJO3Tlfd4Sdsk7VdyPyHp2B713Sppcxn/SsfQNEk3lTnWS5o+SN4e8/9B0qll+3JJP+sXHxERoymNfkSMms8CV9s+BvgXcHbX+GnAP21/3vaxwF195poq9jvA38odhYv75Zd0NLAMWFTuPuwFlndOZnsTcBtwOfAjYK3tXstxzre9EDgOWCnp0PL8HOB6258DXgNWDJK3h+8BqyUtB+YD35giPiIiRtC0uguIiBjS07a3lO3NwFjX+HbgKklXALfb/lOfuYaJnSr/EmAhsEkSwP7ACz32vwzYBLwBrJwkx0pJZ5XtT1KdXOwCnrX9YHl+bdn/jQHzvsf2H1UFfxM42fbefvERETGa0uhHxKh5s2N7L1Vj+x7bf5W0EDgd+KGkjbYv6zXRMLED5Bdwk+1VU+x/CHAAsC+wH7C7c1DSycApwIm290i6r8QBuPtXGCJvZ465wCzgJduvD7pfRESMlizdiYhWkXQYsMf2WuAqYMGHiH0dOHDA1PcA50iaWeY+RNKne8RdD1wCrAOu6DH+MeCV0uQfBZzQMfYpSSeW7S8BDwyRlzI+q+Q+E9gt6YsD/n4RETFickU/ItpmLnClpHeAt4EL/9dY2y9LerB8rOWdwNWTTWT7SUnfBTZK+kiZ7yLgH+/GSDoP+I/tX5c3zD4kabHtezumugv4qqRtwF+ARzrGdgDjkq4DngKuKScEffN25J8ObAC+ZXuHpO9TnWz8vs9rFBERI0p2953giIiIiIgYdVm6ExERERHRQmn0IyIiIiJaKI1+REREREQLpdGPiIiIiGihNPoRERERES2URj8iIiIiooXS6EdEREREtFAa/YiIiIiIFvov7hL+45xIJ0AAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Create figure object to store plots inside\n", - "fig2 = plt.figure(figsize=(14, 6))\n", - "\n", - "# Create new axes object (plotting area) for putting legend\n", - "ax_leg = fig2.add_axes([0.1, 0.1, 0.6, 0.75])\n", - "\n", - "# ---REPEAT CODE FROM EXERCISE 1.1-1.5 ---\n", - "x = [1, 3, 6, 9, 16]\n", - "y = [7, 3, 7, 1, 5]\n", - "y2 = [9, 5, 5, 2, 6]\n", - "y3 = [4, 6, 2, 6, 8]\n", - "y4 = [1, 8, 1, 3, 2]\n", - "plt.plot(x, y, 'k.-', label='Original curve')\n", - "plt.title('Title with random equation for showcase $c = \\sqrt{a^2+b^2}$')\n", - "plt.xlabel('This is the xlabel $x$')\n", - "plt.ylabel('This is the ylabel $y$')\n", - "plt.plot(x, y2, label='Second curve')\n", - "plt.plot(x, y3, label='Third curve')\n", - "plt.plot(x, y4, label='Fourth curve')\n", - "\n", - "# Add legend to new axes object\n", - "ax_leg.legend(bbox_to_anchor=(1.0, 0.5), loc='center left')\n", - "\n", - "# Save figure to a file \n", - "fig2.savefig('myfig2.png')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now the png file look alright." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 2.1" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(18, 5))\n", - "x = [1, 3, 6, 9, 16]\n", - "y = [7, 3, 7, 1, 5]\n", - "y2 = [9, 5, 5, 2, 6]\n", - "y3 = [4, 6, 2, 6, 8]\n", - "y4 = [1, 8, 1, 3, 2]\n", - "\n", - "plt.subplot(141)\n", - "plt.plot(x, y)\n", - "\n", - "plt.subplot(142)\n", - "plt.plot(x, y2)\n", - "\n", - "plt.subplot(143)\n", - "plt.plot(x, y3)\n", - "\n", - "plt.subplot(144)\n", - "plt.plot(x, y4)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 2.2\n", - "Only difference from the code in Exercise 2.1 is to change `plt.plot()` to `plt.bar()`" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(18, 5))\n", - "x = [1, 3, 6, 9, 16]\n", - "y = [7, 3, 7, 1, 5]\n", - "y2 = [9, 5, 5, 2, 6]\n", - "y3 = [4, 6, 2, 6, 8]\n", - "y4 = [1, 8, 1, 3, 2]\n", - "\n", - "plt.subplot(141)\n", - "plt.bar(x, y)\n", - "\n", - "plt.subplot(142)\n", - "plt.bar(x, y2)\n", - "\n", - "plt.subplot(143)\n", - "plt.bar(x, y3)\n", - "\n", - "plt.subplot(144)\n", - "plt.bar(x, y4)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 3.1" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "import numpy as np\n", - "xx = np.linspace(-100, 100, 100)\n", - "yy = xx**2-3027\n", - "plt.plot(xx, yy)\n", - "plt.fill_between(xx, yy, where= yy<0, color='darkorchid', alpha=.25)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 4.1" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Note:** The output of the code cell below is suppressed so it doesn't show all the figures." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "%%capture \n", - "# %%capture prevent plots from showing as cell output \n", - "# ------------------------------------------------------\n", - "\n", - "# Solution:\n", - "\n", - "# Define x-values\n", - "x_arr = np.linspace(1, 10, 10)\n", - "\n", - "# Copied y-values from exercise\n", - "y_arr1 = np.random.rand(10)\n", - "y_arr2 = np.random.rand(10)\n", - "y_arr3 = np.random.rand(10)\n", - "y_arr4 = np.random.rand(10)\n", - "y_arr5 = np.random.rand(10)\n", - "\n", - "# Create list of the y-arrays\n", - "y_arrays = [y_arr1, y_arr2, y_arr3, y_arr4, y_arr5]\n", - "\n", - "# Define names for the png files for each plot\n", - "names = ['plot1', 'plot2', 'plot3', 'plot4', 'plot5']\n", - "\n", - "# Loop over all graphs and save as png file with their names \n", - "for y_arr, name in zip(y_arrays, names):\n", - " \n", - " # Create a figure object\n", - " plt.figure()\n", - " \n", - " # Create plot for current y-array\n", - " plt.plot(x_arr, y_arr)\n", - " \n", - " # Save to figure and name file with current name\n", - " plt.savefig(f'{name}.png')\n", - " " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Some notes to the solution\n", - "\n", - "`zip()` puts two or more iterables (in this case lists) up beside eachother so it becomes easier to iterate over them:\n", - "\n", - "~~~python\n", - "for y_arr, name in zip(y_arrays, name):\n", - " # Inside the loop, the i'th elements of the lists\n", - " # can be referred to as 'y_arr' and 'name'\n", - "~~~\n", - "\n", - "The same outcome could be obtained by looping over the index of one of the arrays and use that index to refer to the i'th element of the lists:\n", - "\n", - "~~~python\n", - "for i in range(len(y_array)):\n", - " # Inside the loop, the i'th elements of the lists \n", - " # can be referred to as 'y_array[i]' and 'names[i]' \n", - "~~~\n", - "\n", - "Choose whatever method you find the easiest. The more Pythonic way is using `zip`.\n", - "\n", - "If a new figure object is not created in each loop as `plt.figure()`, consecutive plots will be added to eachother. So, first png file will contain first plot, second png file will contain the first two and the last file will contain all the plots. " - ] } ], "metadata": { @@ -770,7 +786,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.1" + "version": "3.7.4" }, "latex_envs": { "LaTeX_envs_menu_present": true, diff --git a/Session 4 - Plotting/Session 4 - Plotting.ipynb b/Session 4 - Plotting/Session 4 - Plotting.ipynb index 130e919..137db26 100644 --- a/Session 4 - Plotting/Session 4 - Plotting.ipynb +++ b/Session 4 - Plotting/Session 4 - Plotting.ipynb @@ -1,8 +1,811 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 4. Plotting\n", + "\n", + "## Plotting with `matplotlib`\n", + "There are many plotting libraries in the Python ecosystem, and more being added all the time. The most widely known is called `matplotlib`, which is the one we are going to focus on.\n", + "\n", + "`matplotlib` is a third party library, which means that it is developed and maintained by the Python Community and not the core developers of the Python language itself. This means that it doesn't ship with the Python installation and has to be installed separately before we can import it and use it in our programs. `matplotlib` is one of the oldest, most known and well documented third party libraries in Python.\n", + "\n", + "---\n", + "\n", + "If `matplotlib` is not yet installed you can install it in a way that suits your setup. \n", + "\n", + "> If you are using the **Standard Python** installation, go to the Windows cmd and type `pip install matplotlib`\n", + "\n", + "> If you are using an **Anaconda Python** distribution go to Anaconda Prompt and type `conda install matplotlib`\n", + "\n", + "---\n", + "\n", + "*The lines in the code cell below are just some setup code for showing plots inside this notebook environment. These are not relevant in an editor.*" + ] + }, { "cell_type": "code", "execution_count": 1, + "metadata": { + "cell_style": "center" + }, + "outputs": [], + "source": [ + "# Enable for plots to be shown inside Jupyter Notebook cells \n", + "# (Note: This line is not needed when using an editor) \n", + "%matplotlib inline \n", + "\n", + "# The lines below sets the figure size throughout the notebook\n", + "import matplotlib as mpl\n", + "mpl.rcParams['figure.figsize'] = 7, 5" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Importing `matplotlib` to the script\n", + "\n", + "The `matplotlib` library needs to be imported in a script in order to access its functions and methods:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Import the plotting library and refer to it as plt later on\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It is customary to import `as plt` so referencing can be done as \n", + "\n", + "~~~python\n", + "plt.do_something() # plt replaces matplotlib.pyplot\n", + "~~~\n", + "Where `do_something()` is some function/method inside `matplotlib`. This is much shorter than typing\n", + "~~~python\n", + "matplotlib.pyplot.do_something() # Long and cumbersome to type\n", + "~~~\n", + "\n", + "In fact, the `plt` part could be named differently, but **it is widely accepted to use this naming**, which makes it easier to read other people's code." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Simple plotting API\n", + "The simple API for plotting in `matplotlib` uses commands which deliberately were chosen very similar to the `Matlab` syntax. \n", + "\n", + "API stand for *Application Programming Interface*. It is basically a simplified way of interacting with more complex underlying code. Here, we will type fairly simple plotting commands, which do a lot of low level work in the background.\n", + "\n", + "Below we define some $x$- and $y$-coordinates to be plotted: " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Create x- and y-coordinates for f(x) = x^2 \n", + "x = [i for i in range(-100, 105, 5)]\n", + "y = [i**2 for i in x]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once the coordinates are there, creating a simple line plot is easy:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Create basic plot\n", + "plt.plot(x, y)\n", + "\n", + "# Show plot\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Given a list of data for `x` and `y`, a line graph can be produced in a single command `plt.plot(x,y)`, while actually showing the plot has its own command. \n", + "\n", + "It might seem wierd that the `plt.show()` is needed, but it is not always desired to have the plot shown. Sometimes it is desired to produce the graph and have it saved to a png-file or do something else with it instead of showing it. \n", + "For more complex plots there might be many different plotting commands to build the plot, but only a single showing command is needed at the end. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Customization of graphs\n", + "The plot of $f(x)=x^2$ from above can be made much nicer by a little customization. The command names should make the code self-explanatory." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAEhCAYAAACz9e1lAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3deXxU1dnA8d+TSQKBACELAQIKKmpd4pa64QpVkVq2Sosrigpa3GpdUOtSrdq64dIKoiK41aoFwQ2kbi0qalgMKtoEEAlZSCAhCYSsz/vHvck7xuxM5s4kz5fPfDL33HvnPnMzzJN7zrnniKpijDHGBFKE1wEYY4zpfCy5GGOMCThLLsYYYwLOkosxxpiAs+RijDEm4Cy5GGOMCThLLsYYYwLOkosxxpiAs+RijAkLItJdRF4XkXUiskZElorIPl7HZRpnycUYE05mqerPVPVw4A3gaa8DMo2z5GJCiogcJyIvi0i2iFSKSImIfCEid4vIAA/iuVNEVEQi9+A1pohIpvt+igMZXxPHSxGRBSJSICK1IvKwiDwuIm+047V+LyIZIuL5d4Wq7lbVpX5FKwC7cglR7f4PY0ygicgfgAeAD4A/AhuAWOB4YCqQBpzpWYDtICIDgTnAi8DFwO4gHHYeMBCYDGwHfDjn9Ph2vNZs4Cb3tZ4NUHyBchWwyOsgTOMsuZiQICKn4iSWR1X19w1Wvy0i9wETW3iNbqpa0VExttMwnC/3+aq6fE9frKX3KCL9gZHARar6tlv2OPClqqa39XiqWi4izwHXE0LJRURuBvbHea8mBHl+qWuM6yag0P35E6q6U1Xn1S37VVcd4jbslgGviMh+IvK8iGwUkXIR2SAis0Skr//r+e1/qIh8ICK7RCRXRO5qogpoqIi8JSJlIrJJRG5vqapIROYBH7qL77nHm+euGyUin7ox7nAbqg9oIsYfvcdmjrcAyAUEmO/uex9wPvBSI9vvJyJVIvKnBuWzRKRURNLcopeBg0SkPVc+rdKGWBCR64FfA2eq6q6OisnsGUsuxnNue8bJwDJVrWzj7ouAj4AxwEyc6qBs4FrgDOAunL9u325i/9eBfwPjcL6AbwNub2S7hcD77navA3/CqSpqzt3A1e7z6cBxwN0iMgp4CygDfgtcARwCLBeRlFa8x6bchtPAXeYe6zhgCRAH/Lfhxqqa5W7/exFJBBCR24EpwHi/K501QAkwqrGDiiOyFQ9fU4G3NhYRuQ44BzhNVTu8/crsAVW1hz08fQDJgAL3NbIu0v/hV36nu881Lbx2JHCCu+0Rjew/o8H2TwGlQFyD7S5usN1a4N1WvLdfuPuf4leWDmQ2eD9DgSrg4ba+xwbHexX42G/5JqAWiG5i+/7ATpwqyUuAGuA3jWz336beL3CKG2dLjw9biL3ZWIBB7uusx0l4a4B0rz+/9mj8YW0uJhRIo4VO+0Fug7IoVa32K1rYYH00TvvAhcDeQHe/1QcAqxscpmE108vApbhXEn7lbzXY7ivgiMbibo6I9ASOBO71fx+qulFEPsa5gmtoYSNlTTkc8O9RNRAo0SauCFU1T0QeAf6Ak4ivVtXGqt4KcNo4GrMS+HkrYittbmVLsahqNk18VkzoseRiQkEhTi+qvRopr/vSmgpc1si+uQ2W78PpRXQX8AnOF9ogYAE/TjR18ptYblg9tb3BckUTr9eSvjhfkA3jBsjDSYgNNbbtT4hIL2BffpxAu+PE2pxMoBuwXFX/3sQ25UBME+vKcK4iWtKaaW9bE4sJA9bmYjzn/gX/H+A098qjvlxV09Wpb89pavcGy5OA51T1z6r6vqp+ATRXN5/cxPKW1r+DNinCibl/I+v6A9saKW/tXOSH4yQu/+SyDSehNUpERgBPAp8Cw0XksCY2jcdJ9o05GadKr6XHe80F34ZYTBiw5GJCxf1AIvDXPXydHjhfZP4ubmb73zRYnoTzl/hXexhHo1R1J0410kT/Bm4R2RvnPpSP9uDlj8B571/7lX0LRInIoIYbi8iROJ0TnsZpN/kBuLeJ1x4KfNfEurpqsZYe05oKvI2xmDBg1WImJKjqeyIyA/iLiKQCzwEbcap19sf50t9Jy3/FLwEmi8haIAuYQPM3D17mdin+Aqd32aXAndqxPZFuw2nDeVNEnsC5UfRPwA7goT143SOAb/TH98H8x/15NE4vOsDp+gu8A7wLXKWqtW434LkicpKq/sdv2zic38GDjR1UVUtxOim0S1tiMeHDrlxMyFDV+4ETcapy7sXpIvwaTpfffwLDVLWmhZe5ClgM3OPu0wun62pTxgKnufucD/wZpwtxh1HVJcAvcboIv4JzF/w64ARVbar6rzWOoEHbh6p+D3wO/KquzO0o8a57zPNUtdZd9RzOlc5fGrzuL4FK2taxoFXaEYsJE6La2upcYzoPEbkTuANo2Pus0xGRi4BHgQHajpsOReQdoFBVLwh0bKbzsisXYzq/53E6KPyurTuKyOHAqTjVdsa0miUXYzo5typxCtCeoVL649xAmhXYqExnZ9VixhhjAs6uXIwxxgScJRdjjDEBZ/e5uBITE3XIkCFeh2GMMWFj5cqVhaqa1Ng6Sy6uIUOGkJ7e7vvAjDGmyxGRTU2ts2oxY4wxAWfJxRhjTMBZcjHGGBNwllyMMcYEnCUXY4wxARf05CIic0Vkq4h85VcWLyLLRCTT/dnXLRcReUxEskQkw53zoW6fye72mSIy2a/8KBFZ6+7zmIjYtKjGGBNkXly5zANGNSibAbynqsNwZqub4ZafCQxzH1OBWeAkI5wRbY/BmafijrqE5G4z1W+/hscKqIyyDObmzSWjLKMjD2OMMQHXkd9fQb/PRVX/IyJDGhSPxZl9DmA+8CFwk1v+nDoDoK0QkTgRGeBuu0xVtwOIyDJglIh8CPRW1U/d8ueAcTgTEQVcemk607OmU6M1REs0s4fNJjU2tSMOZYwxAZVRlsHUzKlUa3WHfH+FSptLsqrmArg/+7nlKcBmv+2y3bLmyrMbKW+UiEwVkXQRSS8oKGhz0GvK1lCt1ShKtVaTXmY3YRpjwkN6WTpVWtVh31+hklya0lh7ibajvFGqOkdV01Q1LSmp0REMmnV0r6Px4UyD7hMfabFpbX4NY4zxQkq083e3IERKZMC/v0IlueS71V24P7e65dnAYL/tBgE5LZQPaqS8Q6TGpnLv0HsBGB0/2qrEjDFhY92udUQQwUXJF3VIlX6oJJfFOPOk4/5c5Fd+odtr7Fhgh1ttthQ4XUT6ug35pwNL3XWlInKs20vsQr/X6hC/6PsLjul1DCtKV1DT4vTuxhjjvcraSt7Y/ganxJ3ClSlXdsgfxl50Rf4H8ClwgIhki8glwF+A00QkEzjNXQZ4G9gAZAFP4U7T6jbk3w184T7uqmvcB64Annb3WU8HNeb7G5c4jrzKPD4r+ayjD2WMMXvswx0fUlxdzPiE8R12DC96i53TxKqRjWyrwPQmXmcuMLeR8nTgkD2Jsa1O6XMKcZFxLNy2kOP7HB/MQxtjTJu9Xvg6/aP7c0zvYzrsGKFSLRbWoiOiOSv+LD4q/ohtVdu8DscYY5qUXZHNZ6WfMTZhLD7xddhxLLkEyLjEcdRQwxvb3vA6FGOMadKiwkVEEMHYhLEdehxLLgEytPtQjog9gte3vY5Tm2eMMaGlWqtZvH0xx/c+nuTo5A49liWXABqfMJ7NFZvtZkpjTEhavmM5hVWFjE/suIb8OpZcAmhk35H08vViYeFCr0MxxpifWFi4kMSoRE7oc0KHH8uSSwB1j+jO6PjRvF/8PsXVxV6HY4wx9fIr8/mk5BPGxI8hUjq+o7AllwAbnzieKq3i7e1vex2KMcbUW7RtEbXUMi5xXFCOZ8klwIbFDOOQHoewsHChNewbY0JCjdawaNsijul1DCndmhzLN6AsuXSA8Ynj2bB7Axk7bY4XY4z3Piv5jLzKvKA05Nex5NIBTu97Oj0ieljDvjEmJCzctpC+kX05pc8pQTumJZcO0MPXg1Hxo3i36F1Kq0u9DscY04UVVhXyUfFHnBV/FlERUUE7riWXDjI+YTwVWsE7RR0+bqYxxjTpjW1vUENN0Bry61hy6SA/6/Ez9orei2dyn+HLsi+9DscY0wXVai3/LPgnA6MHUlJdEtRjW3LpIGt3riWnKofC6kIuz7ycjDJr3DfGBNcrW1+hoKqA3MrcoH8PWXLpIOll6dRqLQCVWmlDwhhjgu5fhf8CQFGqtTqo30OWXDpIWmwaUfL/jWcHxBzgYTTGmK4mvzKfjRUb8bn/IiWStNi0oB0/6JOFdRWpsanMHjabpUVLebngZdbvXs/wPsO9DssY00XUXbXcN/Q+NlVsIi02rUOmM26KJZcOlBqbSmpsKv8r/x+vFbzG+f3OJ0LsYtEY07Gqaqt4vfB1Tuh9AiP7/mSS36Cwb7ogmJg4kS2VW/ik5BOvQzHGdAHvF7/PtuptTEya6FkMllyC4NS4U0mITODVgle9DsUY0wW8WvgqKdEpHNf7OM9isOQSBFERUYxPHM/HJR+zpWKL1+EYYzqxzPJMVpet5uyksz2thrfkEiQTEicQQUR9I5sxxnSEVwtepZt0Y0zCGE/jsOQSJMnRyZwcdzKvF75ORW2F1+EYYzqhspoy3t7+Nqf3PZ24yDhPY7HkEkQTkyayo2YHy4qWeR2KMaYTemvbW5TXlvObpN94HYoll2D6eezPGdJtiDXsG2MCTlV5tfBVDu5xMAf1PMjrcCy5BJOIMDFpIl/t+op1u9Z5HY4xphNJL0tn4+6NnnY/9mfJJch+mfBLYiJi7OrFGBNQrxa8Sh9fH07re5rXoQCWXIKul68Xo+NHs2T7EnZU7/A6HGNMJ7C1cisfFn/I2ISxdI/o7nU4gCUXT0xMnEiFVvDGtje8DsUY0wksLFxILbX8OunXXodSz5KLB4b1GMbhPQ/n1cJX64flN8aY9qjSKhZsW8DxvY9nULdBXodTL6SSi4j8XkS+FpGvROQfItJdRIaKyGcikiki/xSRaHfbbu5ylrt+iN/r3OyWfyciZ3j1fpozMWki2RXZ3LXpLptIzBjTbvPz5lNYVUhar+ANp98aIZNcRCQFuBpIU9VDAB8wCfgrMFNVhwFFwCXuLpcARaq6HzDT3Q4ROcjd72BgFPCEiPiC+V5ao19UPwDe2P6GzVRpjGmXjLIMZufOBmB2zuyQ+h4JmeTiigRiRCQS6AHkAiOA19z184Fx7vOx7jLu+pEiIm75y6paoaobgSzg6CDF32prdq5BEMC5rLWZKo0xbfVO0TsoChD0mSZbEjLJRVW3AA8CP+AklR3ASqBYVavdzbKBFPd5CrDZ3bfa3T7Bv7yRfUJGWmwa0U4NH4IEdYY4Y0znkL07G4AIIoI+02RLQia5iEhfnKuOocBAoCdwZiObat0uTaxrqryxY04VkXQRSS8oKGh70HugbqbKA2MOxCc+hnYfGtTjG2PCW0FVAZ+Xfc7IuJFcMfAKZg+bHdSZJlsSMskF+AWwUVULVLUKWAAcD8S51WQAg4Ac93k2MBjAXd8H2O5f3sg+P6Kqc1Q1TVXTkpKSAv1+WpQam8rte99OpVaycNvCoB/fGBO+Xi14lRqt4aqBVzGl/5SQSiwQWsnlB+BYEenhtp2MBL4BPgDOdreZDCxyny92l3HXv6+q6pZPcnuTDQWGAZ8H6T202QE9DuCo2KN4eevLVNfX/hljTNN21+7mX4X/4qQ+JzG4++CWd/BAyCQXVf0Mp2F+FbAWJ7Y5wE3AdSKShdOm8oy7yzNAglt+HTDDfZ2vgVdwEtMSYLqq1gTxrbTZef3OI78qn/eL3/c6FGNMGHhn+zsUVxdzbr9zvQ6lSeL8sW/S0tI0Pd2bnhY1WsOEbybQN7Iv8w6Y50kMxpjwoKr8dt1v8YmPlw58CaeixxsislJVG+1FEDJXLl2ZT3yck3QOa3euZe3OtV6HY4wJYZ+Vfsb63es5t9+5niaWllhyCRFjEsYQ64vlpa0veR2KMSaEvbT1JRIiEzijb0gOPlLPkkuI6OHrwbiEcbxX9B65lbleh2OMCUEbyzfyccnHnJ10NtER0V6H0yxLLiFkUtIkFLW5XowxjfpHwT+IlmjOTjy75Y09ZsklhAzoNoARcSNYULiAXTW7vA7HGBNCiquLeXPbm5wZfybxUfFeh9MiSy4h5tx+51JaU8qb29/0OhRjTAhZULiACq3gnH7neB1Kq1hyCTGpPVM5uMfB/GPrP2yuF2MM4Axu+0rBKxzT6xiGxQzzOpxWseQSYkSE8/qdxw8VP7C8ZLnX4RhjQsC/i/5NQVVBSN802VBky5uYYBvRdwTJW5KZkzuHrPIs0mLTQm7cIGNMcHxZ9iWPbXmM/lH9Ob738V6H02qWXEJQlERxYp8Tea3wNb7b9R1REhVyI54aYzpeRlkG0zKnUaVVREokX+38Kmy+B6xaLETFRcYBUEttyE0CZIwJjvSydKq0CoBarQ2r7wFLLiFqeO/h+HBmZ/aJL6QmATLGBMeAqAGAM6FglESF1feAJZcQlRqbyl/3+SuCcGKfE8PmUtgYEzgrSlcQRRQX97847KrGrc0lhJ0adypnxZ/Fu0XvUlRdRN/Ivl6HZIwJkrzKPN7Z/g4TkyYyfeB0r8NpM7tyCXGTkydToRW8svUVr0MxxgRR3SC25/c73+NI2seSS4gbGjOUk/uczD8L/kl5TbnX4RhjgmBH9Q4WFC5gVPwoBnQb4HU47WLJJQxclHwRO2p2sHDbQq9DMcYEwSsFr1BeW86FyRd6HUq7WXIJA6mxqRwZeyQv5L9Q3y3RGNM5ldeW83LBy5zY+0T2i9nP63DazZJLmJicPJn8qnyWbl/qdSjGmA60uHAxxdXFTO4/2etQ9ogllzAxvPdw9uu+H/Pz59uAlsZ0UlVaxfNbn+ewnodxROwRXoezRyy5hAkRYXL/yWzYvYHlO2xAS2M6o2VFy8itzOWi5Iu8DmWPWXIJI6f3PZ0B0QOYlz/P61CMMQGmqszPm88+3ffhhD4neB3OHrPkEkYiJZIL+l3Alzu/ZHXZaq/DMcYE0MclH5O1O4vJyZOJkPD/ag7/d9DFjEkcQ1xkHPPz5nsdijEmgObnzyc5Kpkz4s/wOpSAsOQSZmIiYpiUNIn/lvyXBzY/QEZZhtchGWP20IKCBawqW8WIuBFESZTX4QSEJZcwdHCPgwF4ueBlLs+83BKMMWEsoyyD+zbfB8CCwgWd5v+zJZcw9G35t/XPq7QqrOZ4MMb82NKipdTi3F7QmeZusuQShtJi0+gm3X60bIwJT1nlWQBEEEGkRHaa/8825H4YSo1NZfaw2Ty85WG+3vk1iVGJXodkjGmH9eXrWVm2krPiz2Lv7nuTFpsWVnO2NMeuXMJUamwq9w+9H5/4mJs31+twjDHt8HTe08RExPD7Qb9nSv8pnSaxgCWXsNYvuh/jE8ezeNticipyvA7HGNMGG8o3sKxoGb9N+i1xkXFehxNwIZVcRCRORF4TkW9FZJ2IHCci8SKyTEQy3Z993W1FRB4TkSwRyRCRI/1eZ7K7faaIhPfoby24KPkiIiSCZ/Of9ToUY0wb1F21nJd8ntehdIiQSi7Ao8ASVT0QOAxYB8wA3lPVYcB77jLAmcAw9zEVmAUgIvHAHcAxwNHAHXUJqTNKjk5mXMI4Fm9bTG5lrtfhGGNaYWP5Rt4tepffJP2m005fHjLJRUR6AycBzwCoaqWqFgNjgbrb0ecD49znY4Hn1LECiBORAcAZwDJV3a6qRcAyYFQQ30rQXdT/IgCezbOrF2PCwdN5T9M9ojvnJ4fnFMatETLJBdgHKACeFZHVIvK0iPQEklU1F8D92c/dPgXY7Ld/tlvWVPlPiMhUEUkXkfSCgoLAvpsg6h/dn7EJY1m0bRF5lXleh2OMacb3u7/v9FctEFrJJRI4EpilqkcAO/n/KrDGSCNl2kz5TwtV56hqmqqmJSUltTXekHJx/4sBmJc3z9tAjDHNeibvGaIjormg3wVeh9KhQim5ZAPZqvqZu/waTrLJd6u7cH9u9dt+sN/+g4CcZso7tQHRAxiTMIbXt71OfmW+1+EYYxqxafcmlmxfwsTEifSN6rxXLRBCyUVV84DNInKAWzQS+AZYDNT1+JoMLHKfLwYudHuNHQvscKvNlgKni0hftyH/dLes07s4+WJqtZb5+TZisjGh6Jm8Z4iSKC5I7txXLRB6d+hfBbwoItHABuBinAT4iohcAvwATHS3fRsYDWQBu9xtUdXtInI38IW73V2quj14b8E7A7sNZEzCGBYWLuSi5IvoF92v5Z2MMUGxefdmlmxfwjn9ziEhKsHrcDpcSCUXVV0DNDawzshGtlVgehOvMxfokretT+k/hcXbFjMvfx43Dr7R63CMMa6n854mUiK5MPlCr0MJipBKLmbPDew2kLMSzuJfBf8iJiKGk/uc3KmGlDAmHC0rWsZb29/itL6ndYmrFgihNhcTOMf3Pp5qqpmXP8/mezHGYxllGdyy8RYU5aPij7rM/0dLLp3QDxU/1D+3+V6M8dayomWdcr6Wllhy6YTSYtOIlugfLRtjvPHtLmdyv842X0tL2tzmIiLdgIFADFCgquF7a3snlRqbypPDnuSxLY+xeudqevh6eB2SMV3S2p1rWbVzFeMTxjOw28BONV9LS1p15SIivUTkChH5D7ADp/vvV0CeiGwWkadE5OcdGahpm9TYVB7a9yFifbE8kfOE1+EY0+WoKo9veZz4yHiuG3Rdp5uvpSUtJhcR+T3wPTAFZxDIscDhwP7AcTgjEEcCy0RkiYgM67BoTZv0iezD5OTJfLSj6zQiGhMqVpSuYGXZSi7tf2mXrD1ozZXL8cDJqvpzVb1bVZeq6lpVzVLVz1V1rqpeDCTj3DV/codGbNrknKRzSIhM4PGcx3FuDTLGdLRareVvW/7GwOiBTEic4HU4nmgxuajqRFX9CkBEmhzdUVUrVPUJVX06kAGaPRPji+HSAZeyqmwVn5Z86nU4xnQJ/y7+N9+Wf8sVA64gKiLK63A80dbeYp+IyD4dEonpMOMTxpMSncLfcv5GrdZ6HY4xnVqVVjErZxb7dt+XM+LP8Docz7Q1ubyNk2CO9C8UkZNE5OPAhWUCKSoiissHXs535d+xrGiZ1+EY06m9se0Nfqj4gSsHXolPfF6H45k2JRdVvQZ4EPhARE4XkcNFZAnwAc6gkiZEjeo7imExw3gi9wmqtMrrcIzplMpry5mTO4fDeh7GiX1O9DocT7X5JkpVfRC4F3gTZ+ThUiBVVc8JcGwmgCIkgukDp5Ndkc2iwkUt72CMabNXtr5CQVUBV6VchUhj8xZ2HW1KLiIyWESeBO7CSSwVwFuq+nVHBGcC64TeJ3B4z8OZkzuH8tpyr8MxplMpqS7h2fxnGd57OEfEHuF1OJ5r65VLJnAEcJaqDgfGADNF5NaAR2YCTkS4MuVKtlVv4/r119u9L8YE0IObH6S0ppTT+57udSghoa3J5XxVPVpVlwGo6vvAKcAVImK3gYcBHz4iiGBF6QobMdmYAPmo+CPeKnoLgHt/uNf+X9H2Bv3XGin7EhiOk2RMiPMfkbVSK7vMCK3GdKSn8p6qf96VRj5uTkBGRVbVTTgJxoS4tNg0osS5qUtRBkYP9DgiY8Lbul3rWLdrHT73X1ca+bg5rRlbbGhrXkhVi8QxeM/DMh0lNTaV2cNmMyV5Ct2lO+9sf8frkIwJW6rKQ9kP0TeyL4/t9xiXD7yc2cNmd6kBKpvSmiuXT0XkGRE5rqkNRKSviFwBfIMzsKUJYamxqUxPmc60gdNYXrKcT0o+8TokY8LSe8XvsbpsNVcMuIJjex/b5UY+bk5r5nN5HdgFvCUiNcBKIBfYDfQFDgJ+BnwOXKuqSzsoVhNgk5Im8VrBa8zMnsnRPzuaSGnz9D7GdFkVtRU8uuVR9uu+H2MT7W/qhlpz5TIF+CswCEgAcoA4YChQDcwHjlDV4ZZYwkt0RDTXDrqWDbs3sKBwgdfhGBNWXtr6EjmVOfxh0B/sD7NGtOaMbAaOUdXF7h2nM1R1a8eGZYLl1D6nclTsUczOmc2ovqPoHdnb65CMCXmFVYXMzZvLyX1O5ujeR3sdTkhqzZXLX4B/icgqQIEpInKiiNi3UCcgIvxh0B8oqSnh6TybLcGY1ngi5wkqtZJrU671OpSQ1Zr5XJ4CDgFeBgS4CHgPKBKRDSKyQERuF5ExHRqp6TAH9DiAsQljeXnry2zavcnrcIwJad/u+pbF2xbz26Tfslf3vbwOJ2S16j4XVf1OVe/HGf7lBKAXcDRwD7AFOA14rqOCNB3vdwN/R/eI7jyy5RGvQzEmZKkqD2c/TG9fby7rf5nX4YS0NrVCqeoBfosr3YfpBBKiEpjSfwqP5zzOipIVHNv7WK9DMibkfFD8ASvLVjJj8Ax6RfbyOpyQFpA79E3ncE6/c0iJTuHeH+7l6dynbXwkY/ysLF3J3T/cTUp0CuMTx3sdTsiz5GLqdYvoxriEcWyp3MLs3Nk2sKUxroyyDH6X+TtKakrYWrWVb3Z+43VIIc+Si2mUolRplQ3AZwzw4Y4PqaYagFqttf8XrRByyUVEfCKyWkTedJeHishnIpIpIv8UkWi3vJu7nOWuH+L3Gje75d+JyBnevJPwlNYrjWjnFDvLNgCfMXy905kPMYIIG5iylUIuuQDXAOv8lv8KzFTVYUARcIlbfglQpKr7ATPd7RCRg4BJwMHAKOAJEfEFKfawlxqbypPDnuTI2COppZYaarwOyRhPLd+xnPSydCYkTOCKgVfYwJStFFLJRUQGAb8EnnaXBRgB1M0jMx8Y5z4f6y7jrh/pbj8WeFlVK1R1I5CF023atFJqbCqP7fsY/aP7c98P91FVW+V1SMZ4ory2nPs338+QbkO4YfANNjBlG4RUcgEeAW4Eat3lBKBYVavd5WwgxX2egjM0De76He729eWN7GNaKcYXw02DbmL97vW8uPVFr8MxxhNzc+eypXILN+91M9ER0S3vYOqFTHIRkbOArarqf++MNLKptrCuuX0aHnOqiKSLSHpBQUGb4u0KToo7iYFzRdEAABh5SURBVJP7nMyc3DnkVOR4HY4xQbWxfCPPbX2OX8b/krRe1sbSViGTXHBmshwjIt/jDDUzAudKJk6kfsjRQTijMoNzRTIYwF3fB9juX97IPj+iqnNUNU1V05KSkgL7bjqJGwbfgIhw/+b7UW00RxvT6agq922+j5iIGBs/rJ1CJrmo6s2qOkhVh+A0yL+vqucBHwBnu5tNBha5zxe7y7jr31fn228xMMntTTYUGIYz14xphwHRA5g2YBr/LfkvH+740OtwjAmKt7a/xcqylVydcjXxUfFehxOWQia5NOMm4DoRycJpU3nGLX8GSHDLrwNmAKjq18ArOLNiLgGmq6p1edoD5/Q7h32778sDmx9gV80ur8MxpkPtqN7BI1se4dCehzIuYVzLO5hGiVV1ONLS0jQ93W6MasqasjVc8r9LuKDfBVw7yKoJTOd1zw/3sKhwES8c+AL799jf63BCmoisVNVGG6TC4crFhIDDYw9nXMI4Xtr6EpnlmV6HY0yHyCjLYEHhAib1m2SJZQ9ZcjGtdlXKVfSK7MUfN/6RZ3KfsXHHTKeyumw112+4nr6+vkwbMM3rcMKeJRfTanGRcUxInEDW7ixm5c6ygS1Np5FRlsHlmZezrXobZbVlrC9f73VIYc+Si2mTGIkBbGBL07ksK15GtdrAlIFkycW0ScOBLY+KPcrDaIzZczVaw4odKwAbmDKQ2jQTpTF1A1vOz5/Phzs+JLM8k8NiD/M6LGPa7YX8F9hQsYFp/acRGeEkFhs/bM9ZcjFtlhqbyoM9H2R61nQe2fIIx/U+jpRuNnybCT8byzcyO3c2I+JGcNmAy3DGvjWBYNVipl1EhNv2vo0IIrhr013Uam3LOxkTQqq1mjs23UFMRAwzBs+wxBJgllxMuw2IHsC1g64lvSyd1wpfa3kHY0LI8/nP8/Wur5kxeAYJUQleh9PpWHIxe2R8wniO7XUsj255lOyKbK/DMaZV1pev58ncJxkZN5LT+p7mdTidkiUXs0fqqsd8+Kx6zISFaq3mzk130tPX06rDOpAlF7PH+kf357pB17GybCWvFrzqdTjGNOu5/Of4Ztc3zBg8w0Y87kDWW8wExNiEsbxX/B6PbHmEnMocRsaNtO6cJuS8ve1tZuXM4uexP7fqsA5mVy4mIESEXyf+mkqt5IWtL9jQMCbkrCpbxe2bbqeWWjJ2Ztjns4NZcjEBs2H3BsSdZbpSK20IDRNSZuXMQt0Zz6u12j6fHcySiwmYtNj/HxpGUXr7ensckTGOT0s+ZVXZKnzuPxvipePZZGEumywsMDLKMvik5BMWFi7EJz7+8bN/0Ceyj9dhmS6ssKqQc9adQ9/Ivtw4+EYydmbYEC8B0txkYZZcXJZcAuubnd9w8f8u5sTeJ/LAPg9Yd0/jiVqt5cqsK1lTtobnD3yefWP29TqkTsVmojRBd1DPg7hq4FV8sOMDXi207snGG/Pz5/NZ6WfcMPgGSyxBZsnFdJhz+53L8N7DmZk9k//t+p/X4ZguJqMsg1k5szgt7jTGJYzzOpwux5KL6TAREsGde99J78je3LzxZspryr0OyXQRpdWl3PL9LSRHJ3Pr3rdatawHLLmYDhUfFc/dQ+5mU8UmHsh+wOtwTBegqtz9w91srdzKvUPvpZevl9chdUl2h77pcEf3Opop/afwTN4z9I/qbxMymQ6TUZZRP5Hd1QOv5tCeh3odUpdlycUExdQBU/mo+COezHuSCCKIkihmD5ttCcYETEZZBtMyp1GplUQQYTOkesyqxUxQREokx/c5HoBaaqnSKrtD2gTUJyWfUKmV9curylZ5GI2x5GKC5tQ+pxIlUfXLR8Ue5WE0pjOp0RpWlKwAqL8ytjvwvWXVYiZoUmNTmTNsDnNy5/BpqTMch1VdmECYlTOLtbvWckG/C+gd2dva9EKAJRcTVKmxqTy+3+Pc+v2t/D3n7+wXsx8n9jnR67BMGHt3+7s8m/8sExIncE3KNdbtOERYtZgJurrZK/eP2Z9bN97K97u/9zokE6a+2/Udd266k8N6HsaNg260xBJCLLkYT8RExPDQvg8RHRHNdeuvo7Sm1OuQTJgpqiriug3XERcZxwP7PEBURFTLO5mgseRiPDMgegD3D72f7Ips/rjxj9RojdchmTBRpVXctPEmiqqKeHCfB0mISvA6JNNAyCQXERksIh+IyDoR+VpErnHL40VkmYhkuj/7uuUiIo+JSJaIZIjIkX6vNdndPlNEJnv1nkzLjux1JDcMvoHlJcuZlTPL63BMmHg4+2FWlq3kj3v9kYN6HuR1OKYRodSgXw38QVVXiUgvYKWILAMuAt5T1b+IyAxgBnATcCYwzH0cA8wCjhGReOAOIA1Q93UWq2pR0N+RaZWzE8/mu13f8Wz+s+RU5DCp3yTr6WMalVGWwXP5z/HBjg84v9/5jE4Y7XVIpgkhc+Wiqrmqusp9XgqsA1KAscB8d7P5QN3wpmOB59SxAogTkQHAGcAyVd3uJpRlwKggvhXTRiLC6PjRCMLS4qVMy5xm85ubn8goy2Bq5lQ+2PEBEURwStwpXodkmhEyycWfiAwBjgA+A5JVNRecBAT0czdLATb77ZbtljVV3thxpopIuoikFxQUBPItmDZas3MNgtPTp1Ir+Xfxvz2OyISapUVLqdKq+uXVZas9jMa0JOSSi4jEAv8CrlXVkuY2baRMmyn/aaHqHFVNU9W0pKSktgdrAiYtNo0oiSLC/Ugu3b6UgipL+MaRU5HDO9vfAewO/HARSm0uiEgUTmJ5UVUXuMX5IjJAVXPdaq+tbnk2MNhv90FAjlt+SoPyDzsybrPnUmNTmT1sNull6cRHxvNg9oNcnXU1c/afY0Omd3FF1UVcmXUltdRy9953k1eVZ3fgh4GQSS7i3P30DLBOVR/2W7UYmAz8xf25yK/8ShF5GadBf4ebgJYC99b1KgNOB24OxnsweyY1NrX+CyM5Oplrsq7hD+v/wOP7PU63iG4eR2e8sKtmF9dkXUNeZR5/H/Z3jog9wuuQTCuFUrXYcOACYISIrHEfo3GSymkikgmc5i4DvA1sALKAp4DfAajqduBu4Av3cZdbZsLIcb2P409D/sTKspXc9v1tdg9MF1SlVdy48UbW7VrHfUPvs8QSZkS10eaILictLU3T020I+FDz0taXeCj7Ic5OPJsZg2fY8B5dRK3WcsemO3h7+9vcttdtjEsc1/JOJuhEZKWqNtr4FTLVYsY05tx+51JYVcj8/PlUazUp3VKsvr2TyyjL4NEtj7Jm5xqmD5xuiSVMWXIxIe+qgVeRtSuL17e9jiBES7TNYtlJZZRlcFnmZVRrNT58NudPGAulNhdjGiUi9YlEUSq10max7KSeynuKaq2uX15ZttLDaMyesORiwsLRvY6mmzg9xhSluKrY44hMoM3Nm8snJZ8QQQQ+fERKpN3LEsasWsyEhbr7YD4v/ZwVJSt4seBFkqKTuCD5Aq9DM3tIVZmTO4c5eXMYHT+aCYkTWF222trWwpwlFxM26u6Dmdx/MrdtvI1HtjxClVYxpf8Ur0Mz7aSq/C3nb8zLn8eYhDH8ca8/4hOfdTvuBCy5mLATJVH8eeifidoUxd9z/k5VbRVTB0y1bsphRlWZuWUmL259kV8n/poZg2cQIVZT31lYcjFhKVIiuXPvO4mUSObkzaFSK7ly4JWWYMJErdbyQPYDvFLwCpOSJnH9oOvtd9fJWHIxYcsnPm7b6zaiJIp5+fPIqcxhWPdhpPWyuvpQtqZsDQ9lP8Q3u77hgn4XcE3KNZZYOiFLLiasRUgENw++meLqYt4tepd3eZdued3sPpgQlV6azhWZV1BLLT58nBp3qiWWTsoqOE3YExEOjDmwfj6YCq1geclyj6MyDRVWFXLb97dRS219md3H0nlZcjGdQlqvNKIluj7BvLHtDb7f/b23QZl6mbsyufDbCymuLiZKouw+li7ABq502cCV4S+jLIP0snT6+PowK3cW1VrN/UPv5+jeR3sdWpf2nx3/4daNt9LT15OZ+86kqraK9LJ0u4+lE2hu4EpLLi5LLp3LlootXLv+Wjbt3sSMvWYwIXGC1yF1OarKS1tfYuaWmRwQcwAz951Jv+h+Le9owoaNimy6nJRuKcw9YC63bLyFe364hy9Kv2C/7vvx814/t7+Wg2BV2SoeyX6Er3d9zYi4Edy1913E+GK8DssEkSUX02n18vVi5r4zuWXjLdaTLIiWFy/n9xt+X98j7Lx+51li6YKsQd90apESyYE9ftyTbNG2RS3sZdrr4x0fM+P7GT/qEbaqbJWHERmvWHIxnV5arNOTLIIIBOH1ba/z+JbHqaqt8jq0TqOitoIHNj/A1euvJj4ynmiJth5hXZxVi5lOr25E5fSydA7tcShLipYwL38en5d+zj1D7mGv7nt5HWJYyyrP4taNt5K1O4tJSZO4OuVqvtv1nfUI6+Kst5jLeot1Le8Vvceff/gzVVrFDYNuYEzCGLtTvI1UlVcKXuGRLY8Q64vlzr3vZHif4V6HZYLIeosZ08DIviM5pOch3P797dz1w128vf1tDo89nOG9h9tf2q2wvHg5D295mE0Vmxjeezh37H0HCVEJXodlQoi1uZguKzk6mSeGPcHZiWeTXpbO03lPc1nmZawuW+11aCGrWqt5ePPDXLPhGjZVbCJSIrmk/yWWWMxPWHIxXZpPfCRHJxPh/leo1mpu3ngzX5Z96XFkoefz0s85d925vFjwYn2Zqtr4YKZRllxMl5cWm1Y/3lWURFFdW82U/03htu9vo6CywOvwPJdbkcuNG27kiswrKK8tZ/qA6XSTbtYbzDTL2lxMl+ffmywtNo39Yvbj2bxneX7r83xQ/AGX9r+UQ3seypc7v+wyvZ8yyjJYUbqCvIo8lhQtAeDyAZdzQfIFdI/oTlqvNOsNZpplvcVc1lvMNLS5YjMzs2fy0Y6P6m/CjJboTn+Hf3ppOtOzplOt1QAc0+sYbt/7dvpH9/c4MhNqmustZtVixjRhcLfBPLzvw/wq/leo+69CK3gy90lKq0u9Di/giqqLmJM7h2vWX1OfWCKIIK1XmiUW02ZWLWZMCyYkTuDdonepUueO/hWlKxj91WjGJY7j3KRzKagqCMsqoropCgZHD2Zl2UoWb1tMhVZwWI/D+Kb8G2q11tpUTLtZtZjLqsVMc+q+iNNi0+ge0Z0Xtr7Aku1LUJz/P4qGVZXZmrI1XJ55eX3C9OHjrISzOL/f+ewTs8+P3m84vB/jDZvPpRUsuZi2yqvM49aNt7Jm55r6ssN6HsZVKVdxWM/DiJDQqnWu1mrWlK3h/eL3eXPbm+ys3QmAIExOnsxVKVd5HKEJN13yDn0RGQU8CviAp1X1Lx6HZDqZ/tH9uSblGi7PvJxKrUQQvtr5FZf+71ISIhM4Ne5URsaNJCoiitVlq4N+FZBRlsHnpZ8TExHDxt0b+XDHhxRVF9FNunFwj4PJ2JVBrdYSJVGc3OfkoMVluoZOeeUiIj7gf8BpQDbwBXCOqn7T1D525WLay78KaZ+YfVi+YznvF7/PxyUfs7t2d/12PnxcmXIlZ8afSVJU0k/2bU/i8d//0J6HsrVqK9/u+paPij/ije1v1A993026cUrcKYyIG8Hw3sOJ8cVY1ZfZY12uWkxEjgPuVNUz3OWbAVT1vqb2seRiAq28tpx7Nt3DO0Xv/GRdQmQCA6MH8s2ub6jFaTi/Za9bOCr2KHr5ehHriyVCIn6UAA7ueTA7a3ZSUlNCaU0pX5Z+ySM5j1Ct1QhCT19PSmt+2otNEKYNmMZlAy4Lxts2XUhXrBZLATb7LWcDx3gUi+miYiJi+E3Sb3i/+H2qtZpIieS6QddRqZV8u+tbPi35lBpqAKjSKv606U/1+wpCTEQMu2p3tepYijKo2yB+Ff8rDuxxIBW1FVy7/tr64x7Tyz7+Jrg6a3JpbOz0n1yiichUYCrAXnvZnB4m8Bre/e9f/ZRRllHfY8snPqYNmEZCVAKl1aWU1JTwWelnrN25FnCSTVpsGifFnUSsL5bevt5srdzKzC0zqdZqoiSKGwfd+KPXb+q4xgSDVYu5rFrMeKG5do+65FN39dFYN2drNzFe6optLpE4DfojgS04DfrnqurXTe1jycWEIkseJpR1uTYXVa0WkSuBpThdkec2l1iMCVWpsamWVExY6pTJBUBV3wbe9joOY4zpikLrFmJjjDGdgiUXY4wxAWfJxRhjTMBZcjHGGBNwllyMMcYEXKe8z6U9RKQA2NTO3ROBwgCGEygWV9tYXG1jcbVNZ4xrb1VNamyFJZcAEJH0pm4k8pLF1TYWV9tYXG3T1eKyajFjjDEBZ8nFGGNMwFlyCYw5XgfQBIurbSyutrG42qZLxWVtLsYYYwLOrlyMMcYEnCWXNhCRiSLytYjUikhag3U3i0iWiHwnImf4lY9yy7JEZEYQYvyniKxxH9+LyBq3fIiIlPutm93RsTSI604R2eJ3/NF+6xo9d0GK6wER+VZEMkRkoYjEueWeni83hqB+dpqJY7CIfCAi69zP/zVueZO/0yDH972IrHVjSHfL4kVkmYhkuj/7BjmmA/zOyxoRKRGRa704ZyIyV0S2ishXfmWNnh9xPOZ+5jJE5Mh2H1hV7dHKB/Az4ADgQyDNr/wg4EugGzAUWI8z1L/Pfb4PEO1uc1AQ430IuN19PgT4ysNzdydwfSPljZ67IMZ1OhDpPv8r8NcQOV+efnYaxDIAONJ93gtnrqSDmvqdehDf90Big7L7gRnu8xl1v1cPf5d5wN5enDPgJOBI/89zU+cHGA28gzOb77HAZ+09rl25tIGqrlPV7xpZNRZ4WVUrVHUjkAUc7T6yVHWDqlYCL7vbdjgREeA3wD+Ccbw90NS5CwpVfVdVq93FFcCgYB27BZ59dhpS1VxVXeU+LwXWASlexNIGY4H57vP5wDgPYxkJrFfV9t6kvUdU9T/A9gbFTZ2fscBz6lgBxInIgPYc15JLYKQAm/2Ws92ypsqD4UQgX1Uz/cqGishqEflIRE4MUhz+rnQvtef6VVN4eY4amoLzV1sdL89XKJ2XeiIyBDgC+Mwtaux3GmwKvCsiK0VkqluWrKq54CRHoJ9HsQFM4sd/5IXCOWvq/ATsc2fJpQER+beIfNXIo7m/GqWRMm2mPBgxnsOPP9C5wF6qegRwHfCSiPTe01jaENcsYF/gcDeWh+p2a+SlAtqFsTXnS0RuBaqBF92iDj9fLYXdSJmnXTtFJBb4F3CtqpbQ9O802Iar6pHAmcB0ETnJozh+QkSigTHAq25RqJyzpgTsc9dpZ6JsL1X9RTt2ywYG+y0PAnLc502Vt1tLMYpIJDABOMpvnwqgwn2+UkTWA/sD6XsaT2vj8ovvKeBNd7G5cxeUuERkMnAWMFLdiudgnK8WdPh5aQsRicJJLC+q6gIAVc33W+//Ow0qVc1xf24VkYU4VYr5IjJAVXPdap2tXsSGk/BW1Z2rUDlnNH1+Ava5syuXwFgMTBKRbiIyFBgGfA58AQwTkaHuXzCT3G072i+Ab1U1u65ARJJExOc+38eNcUMQYqk7vn+97XigrudKU+cuWHGNAm4CxqjqLr9yT88X3n12fsJtv3sGWKeqD/uVN/U7DWZsPUWkV91znA4aX+Gcq8nuZpOBRcGOzfWjGoRQOGeups7PYuBCt9fYscCOuuqzNvOqB0U4PnA+DNk4f9HmA0v91t2K07vnO+BMv/LROL1r1gO3BinOecDlDcp+DXyN0+toFfCrIJ+754G1QIb7AR7Q0rkLUlxZOHXMa9zH7FA4X159dpqI4wScqpEMv/M0urnfaRBj28f9HX3p/r5udcsTgPeATPdnvAex9QC2AX38yoJ+znCSWy5Q5X5/XdLU+cGpFvu7+5lbi1+v2LY+7A59Y4wxAWfVYsYYYwLOkosxxpiAs+RijDEm4Cy5GGOMCThLLsYYYwLOkosxxpiAs+RijDEm4Cy5GGOMCThLLsaEIHEmpqsQkb39yh4VkfUikuxlbMa0ht2hb0wIcsfz+gJYraqXicj1wI04IwBnNr+3Md6zUZGNCUGqqiJyC/CWOyLzrcAISywmXNiVizEhTEQ+wRlC/leq+k5L2xsTKqzNxZgQJSIjgMNwRqrNb2FzY0KKXbkYE4JE5DDgI5xZMH8JxKrqGd5GZUzrWXIxJsS4PcQ+AZ5U1btE5BCc+T9GqOqHngZnTCtZcjEmhIhIPPAx8B9VneZX/k9gL1U9zrPgjGkDSy7GGGMCzhr0jTHGBJwlF2OMMQFnycUYY0zAWXIxxhgTcJZcjDHGBJwlF2OMMQFnycUYY0zAWXIxxhgTcJZcjDHGBNz/AREGuuEse5V1AAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.title('Graph for $f(x) = x^2$', fontsize=16)\n", + "plt.xlabel('$x$', fontsize=14)\n", + "plt.ylabel('$f(x)$', fontsize=14)\n", + "plt.plot(x, y, '.-', color='limegreen', markersize=6)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plotting multiple graphs in the same plot\n", + "It is possible to plot many graphs in the same plot. It can also be styled with a grid and a legend:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Create x-coordinates for graphs \n", + "x = [i for i in range(-10, 10, 1)]\n", + "\n", + "# Produce y-values for different graphs\n", + "y1 = [i**2 for i in x] # f(x) = x^2\n", + "y2 = [10*i**2 for i in x] # f(x) = 10x^2\n", + "y3 = [i**3 for i in x] # f(x) = x^3\n", + "y4 = [2*i**3 for i in x] # f(x) = 2x^3\n", + "\n", + "# Create plots with legend labels for each graph\n", + "plt.plot(x, y1, label='$f(x)=x^2$')\n", + "plt.plot(x, y2, label='$f(x)=10x^2$')\n", + "plt.plot(x, y3, label='$f(x)=x^3$')\n", + "plt.plot(x, y4, label='$f(x)=2x^3$')\n", + "\n", + "# Set titles, grid and legend\n", + "plt.title('Different graphs', fontsize=16)\n", + "plt.xlabel('$x$', fontsize=14)\n", + "plt.ylabel('$y$', fontsize=14)\n", + "plt.grid(linestyle=':')\n", + "plt.legend(fontsize=14)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "> * Graphs are automatically colorized, but this can of course be customized.\n", + "> * Legend will by default try to position itself so it does not overlap with the graphs, but it can be forced into a certain position if need be. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Fill between\n", + "Plot areas can be filled based on conditions. \n", + "\n", + "The code in the next cell serves only to create dummy data for an example graph. " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# The code in this cell is just for creating a dummy graph\n", + "import numpy as np\n", + "x1 = np.linspace(1, 10, 100)\n", + "x2 = np.linspace(10, 15, 100)\n", + "x3 = np.linspace(15, 20, 100)\n", + "y1 = 2 * np.sin(1.98*x1)\n", + "y2 = 3 * np.sin(-x2)\n", + "y3 = 1 * np.sin(2.2 * x3)\n", + "y = np.append(np.append(y1, y2), y3)\n", + "x = np.append(np.append(x1, x2), x3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plotting this dummy graph and filling areas between the graph and $y=0$ with green color:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot line graph in black\n", + "plt.plot(x, y, color='black', linewidth=1)\n", + "\n", + "# Put green/purple fill between the graph y=0\n", + "plt.fill_between(x, y, color='limegreen', alpha=.25)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can make differentiated colors by given a conditional statement in the keyword argument `where`:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXIAAAD4CAYAAADxeG0DAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO2dd1hc17nu30WThEBCiCJgmAoMDMNQhKhCvVu2Zct27OQ6TnGcOE5x2olLcnLuKTftnNQTJ8dxfGLHjmvsWJaLrI6QBAgQfYDpM3TUCyqA1v0DxsEIxJTdZli/59EjmNn7W+/eM7x77299ay1CKQWDwWAwApcQsQUwGAwGwz+YkTMYDEaAw4ycwWAwAhxm5AwGgxHgMCNnMBiMACdMjEbj4uKoUqkUo2kGg8EIWOrr609RSuOnvi6KkSuVStTV1YnRNIPBYAQshBDHdK+z1AqDwWAEOMzIGQwGI8BhRs5gMBgBDjNyBoPBCHCYkTMYDEaA47eRE0LmE0JqCSFNhJA2Qsj/5UIYg8FgMDyDi/LDawDWUUovEULCAVQRQj6glFZzEJvBYDAYs+D3HTkd59LEr+ET/9jcuIygo7PdhEN7K3H+3AWxpTAYn4CTHDkhJJQQ0ghgEMBeSmnNNNs8QgipI4TUDQ0NcdEsgyEI3c4ebKjYjJUrV+KbX3scSrkSP/u3X4DN5c+QCpwYOaV0jFKaB0AGoIgQop9mm2cppYWU0sL4+JtGmDIYkqS3uw8V5auglelx4r12fPDyYex6bj+e/9/n8b2vPyG2PAYDAMdVK5TScwAOAdjCZVwGQwxGR0dx712fwraVO/D0d/4FEeERAACNOg2v//5dvPHWG3j5f18RWSWDwU3VSjwhJGbi5wUANgDo8DcugyE2v/3PZ3B1+Dq+/80f3PRe3NI4/PpHz+Lx7zyOwT6WKmSICxd35EkADhJCmgGcwHiOfDcHcRkM0Tg9dAb//pN/xU+f+BXCwqYv7ipaXowtK2/HD77/zwKrYzA+CRGjw6awsJCy2Q8ZUuZ7X38CDlMPfvXvz9xyu6FTQ1h933K0trRCpkgRSB1jrkIIqaeUFk59nY3sZDCmcOniZTz/l+fw9S98Z9Zt4+PicfuanfjlT38tgDIGY3qYkTMYU/jzsy8iV7scGrXGo+0fefAx/Pmvz+Pi+Uuzb8xg8AAzcgZjEpRSPPOHZ/D5+77s8T4aVRoK9aV47vfP86iMwZgZZuQMxiQO7zuCa1evYm3Feq/2+8yOz+PFl17kSRWDcWuYkTMYk/jLCy/jro33IyTEuz+N1eVr0NPrQluTkSdlDMbMMCNnMCYYuT6Cd957Czu23eP1vuHh4bhtzV148X9f4kEZg3FrmJEzGBPs2b0PKQlyqJVqn/a/57YH8Oobf2VzsDAEhxk5gzHBKy+/gu1r7/Z5/zxDPkJIKGqOnuBQFYMxO8zIGQwAIyMjeH/fbty59S6fYxBCsL5kM/7+t10cKmMwZocZOYMBoPLAUSTHyyBLSfUrzsbV2/D+B2yGCoawMCNnMADs/vt7WL1io99xSgpL4ep1wmF1caCKwfAMZuQMBoAP976Pjav9n305PDwcFYXr8M5bLL3CEA5m5Iw5j83swMBQP5bn3TQXkU9sKNuC3e+y9ApDOJiRM+Y8u995DxXL1804Xa23rKlYj+N1R3H92nVO4jEYs8GMnDHn2bd3H1auWMtZvLilcUhNUuL4kZuWrmUweIEZOWNOc+PGDRytOYKKklWcxi3NXYm9e/ZzGpPBmAlm5Iw5TVN9CyIXREGequA07sqiNThw8ACnMRmMmWBGzpjT7NtzACWGlZzHLS9eieb2Bly+NMx5bAZjKszIGXOaQ4cOorSggvO4UVHRyFTpcXj/Ec5jMxhTYUbOmLOMjY3hWG0VKkpX8xK/yFCGwwcreYnNYEyGGTljztJU34LF0TFITkrmJf6KvBIcO3aUl9gMxmSYkTPmLEcrj6Egq4i3+CsKinGytZ7VkzN4hxk5Y85y7NhxFOj5M/LYJbFISUxFffVJ3tpgMABm5Iw5TG19DVbk82fkAFCgK0ZlZRWvbTAYfhs5ISSVEHKQEGIkhLQRQr7JhTAGg0+G+k9hYKgPukw9r+0UGUpwtIoZOYNfuLgjHwXwHUppFoASAI8RQnQcxGUweKOq8hgM2nyEhoby2k5RYQmq646z5d8YvOK3kVNK+yilDRM/XwRgBJDib9xg5NyZ8zh7+pzYMvxmbGwMZ0+fw9UrV8WW4jPHqo4jL5Ob2Q5vhVKuwo0bN2C3OHlvizF34TRHTghRAsgHcNNsQYSQRwghdYSQuqGhIS6blTyUUmzbcDuSk5ORlamDy94ttiSfuTJ8BTlZeZDJZMjTF+DSxctiS/KJ6prjWG7gNz8OjC//lpORj+qjbAItBn9wZuSEkCgAfwPwOKX0wtT3KaXPUkoLKaWF8fHxXDUbEDz/hxfgdDjRftCJT9/2Ody94x5cu3pNbFk+8eR3fgh5ggpdlb3QKrLxja88LrYkrxkdHUVjawNWFBQL0p5Bm4/aGrYgM4M/ODFyQkg4xk38ZUrpW1zEDBbOnTmPp374JP79u/+FiPAIfOvRfwJGCV5/+U2xpXlNy8k2vPTqi/jxU78AIQQ/fvoX+OCj9wNu1fjmhlbELUlA3NI4QdrLyy5AXX1gnSNGYMFF1QoB8CcARkrpL/yXFFy89vKbyM0oQNHy8bu/0NBQfPqOz+PPf35RZGXe879/egF3b7wfiQmJAICYxTG4Z9On8cLzfxFZmXccPXIM+Vn858fdFOQWoqntJMbGxgRrkzG34OKOvBzAgwDWEUIaJ/5t4yBuUPDmm2/gtnV3feK127fcgbrGmoDKlVNK8eZbr2PHlns+8frO7Z/Cm39/HaOjoyIp856a6loYMgsEay8+Lh6LFi6GsaVTsDYZcwsuqlaqKKWEUmqglOZN/HufC3FT2fXWbjx4/+f4CM0LZ0+fQ3XdMWxa98lFfSMjF2Jz+e3483OBc1d+/EgNQkkocnPyPvF6RroWy5YmYc/ufSIp857mlkbk6YUzcgAwaAtQc6xW0DYZc4eAGtmZodFiz94PAqYm963X/45iQzkWL1p803u3rd+B3e8FzgK9r/zlVWxfczfGM2mfZPvanXj1lddEUOU9V69cg8neBX0WvwOBpmLQ5qO2lhk5gx8CysgVciXmRSxA88lWsaV4xK53dmFTxfZp3ytdUYrWjuaAKd/bd3AfNqzaMu17a8rXoepYYEzX2nKyFSmJqYiMXChou3k5y1HfUC9om4y5Q0AZOQAUZZdjXwCshUgpxfETx1BePP3qM1FR0dCqdKg6dExgZd5zeugMXL125Brypn0/S6vD2XNnAiLnX3+iAdkag+Dt5ufkw2hqYzMhMngh4Iy8OHslDuyX/lqIpg4LCMZH9s1EsaEcB/YfFE6Uj1QeqIIhowAR4RHTvh8aGopCfQkO7T8ssDLvaag/iex04Y08OnoRkuJT0NTQInjbjOAn4Iy8dHkFjtYekXyVROWhIyjQFU+bU3ZTsnwljhyRfkqisvIICvWlt9xmRU5grIbT2HQSObpcUdo2aPNxorpOlLYZwU3AGXlSYjKWLIqVfJ786JGjWK6/9cjB0hWlaG5vxPBlaS/Qe/RoFYryb23kZStWouq4tGf5GxsdQ7u5FYZscYxcl2bAyQY2NzmDewLOyAEgOy0PdTXS7jg6XnMcxQW3Nr+oqGgoktVoqG0USJX3XBm+gtaOZhQtv/W8JAZ9Lrr7HDg9dEYgZd7T0daFJdGxWBITK0r7+kwDmlqaRGmbEdwEpJHnpOeivr5BbBkzcvb0Obh6HcjRz56LzU4zoL5OusfSUNsIZYoGUVHRt9wuPDwcWlU26k9I946zrrYeWZoc0drX63JgNLWyEZ4MzglMI9flobFRuoZRf+IkMpRZM3YOTkaXniPpx+2G+pPI0nhWc52l1uNkvYSPpe4k9CJ0dLqJXRKLxVFL0GU0i6aBEZwEpJEb9Llo62yR7J1NY0MjMtWemZ9Bl4vGZummVppONnls5Lr0HDSelO6xNDadhD5TnPy4myyNHg0SfmphBCYBaeSxS2KxZPFSdLR2iS1lWpqampGp9myRpBydAV2WDly/Ls364ubWZugzPbuLzcnKRXNrM8+KfINSitaOZhiyp6+FF4pMtR4nG6R7sWMEJgFp5ACQrTGgrlaapVwtrc3QZ3mWi42KisayuCS0NrXzrMp7xsbGYDS1Qq/z7FiytDpYnWZJzrVutzgREhKKpGVJourQaw1oamJGzuCWwDXydAPqJNhJODo6ii5rh1eL+uo0BtTXSu9YzJ1WLIqKQewSz6o8IiMjkbpMIcnS0PraBug0Obes6xcCvS4HrUZpPrUwApeANfLMNB3a26V3F9vZZsLSmPhpJ8qaCV1ajiQftxtONCBTle3VPllqPRrqJHgs9eNGLjZKuQqXr1zGQN+g2FIYQUTgGnl6FjrNRrFl3ERjQyMyVZ7lx91kaDLR0dnBkyLfOXmyyeNOWzeZ6mw0NUqvVrq5uRm6dGFnPJwOQggyVXo0nJDexY4RuASskSvkSpw+ewoXL1wSW8onaGxshtbLu1htWia6LNIz8va2NmRqsrzaJ12tleRFqcvShQxNptgyAIxXrki5TJMReASskYeFhUGZrEZbs7TSK8b2dmjV3hmGVC9KJovJa/PTpmXCZJHWSjgjIyNw9tiRpkkXWwoAIFviZZqMwCNgjRwANHIt2lqkZeQmiwlp6gyv9gkLC4MiSYX2FumkikZGRuDosUGjTvNqP3mqAkNnBiU1z7rJaEHC0mVYsGCB2FIAANmZOWhuYx2eDO4IcCPPQHubdIx8dHQU9m4r0rw0P2D8WKR0UbJ02RAfm4jIyEiv9gsPD4ciWQVjq3TSK20t7VCnev+Z8IU2PRP2bqskyzQZgUlAG3mGWgujUTp3sZYuG+KWxGPhwiiv99WkZsDYLp1jaW8xQi3zzfzUsnS0t0rnomRsNyIt1bunJD6JjIxEcnwKjK3SSkExApeANnKtJhOdJunc+RlbO6BK8c380lUZkrooGY2+G7lGngFju3Q+l/Z2IzQK6Rg5AKQrs9DcyBaZYHBDQBu5Rp2G7n4Xrl65KrYUAON3fupU3zrUMjSZ6DRL5w7N2N4BjULr075pSmldlLrMncjQ+HYsfJGhzEJzEzNyBjcEtJHPmzcPSfHJMHdaxZYCAOjs7IRa7ttdbJomHc4eO0ZGRjhW5Rtdpk6ke9lp6yZDo0WXWRrz4FBKYbJ1IiNNGqWHbrLSs9HaJr0RsIzAJKCNHAAUyWp0dZjElgEA6OzqRJrSN/NbsGAB4pckwGZ2cKzKN8y2LmSk+XYXm65Jh81lkcRyfL3dfQgPjcDS2KViS/kEWRk6dHRJpx+BEdhwYuSEkOcJIYOEEMFvMRTJanR1SePuz2wzISPN91ysIlmFTqP4xzLUfwojoyNIiE/waf+FC6MQs2gJnLZujpV5T5fRBGWKWmwZN6FWatA/1IeL56U1doARmHB1R/5nAFs4iuUVyhQVzF3iT9R/7sx5XB6+hJRkmc8x5MlqmLrEf7ro6hg3P38mmJInqSTxpNTVaYY8SSm2jJsIDw+HSpaG1sY2saUwggBOjJxSWglAlMUaVXINTBbxjbyrwwR5ktIv81OmqGGSwEWpq9MERbJ/d7GKJJUkLkpmk//HwhcZikw0NwdWh+e7b72PUwOnxZbhMZRS7PvwIHb97T3JzvnPBYLlyAkhjxBC6gghdUNDQ5zF1ajSYHNYOIvnK6ZOE+TJSr9iqOQaWCRwUTKb/L+LVaSoYDJJ4FjMZihTJWrkqsAqQTx7+hzuvGc7MrOycGDPIbHlzMrw5WFsWrMNj375Ufzz0z9CXnYBerv7xJbFC4IZOaX0WUppIaW0MD4+nrO4crkC/af6RB8lZzZZIV+m9CuGWqGGzSF+BY7ZbIFS5p/5qVLVsFrEv8BabRaoFNI08sw0HdraA6dyhVKKqMho/NeTv8enHvgUrCa72JJuySOf/yrCbszDvleP4f2XDmJDyW24fesdkuiE55qAr1qJCI9AUlyK6CWIZrMZCj/NT6lQwdXnFP2LZrVZoJSr/IqhlKthtYv7mVBKYXNZoVFJZ3j+ZLIz9eiQ4FTMs7Fx7SZ8ZvsX8M2vPS62lBnZ894+HDp8AL/6198hPDwcAPC9rz2J8JD5+MVPfiOyOu4JeCMHpFHtYbNZoZT7Z+SRkZFYsigWdouTI1W+YXfZoFJo/IqhUqph77aCUsqRKu9x53I9XeFIaFJlcly6fBFDA6fEluI1X3v4cdSfrMPRQ8fFlnITlFI8/eRT+O7DP0R09KKPXw8NDcX//dZP8J+//JnkZhr1F67KD18BcByAlhDSTQj5IhdxPUUpgRJEm9MClZ9GDox3eIpZ7XH+3AVcGr6I5KRkv+LELI7BgnmR6HH1cqTMezqNXVAkq0Rf3m0mCCFIV2RKcmm82YiMjMQX7vkqfvaTn4st5SYOfnQYZ86cwc477r3pvRy9AXmZhfjj7/4kgjL+4Kpq5QFKaRKlNJxSKqOUCnqWUpOVsFlsQjb5Ca5euYqhs0NIlaX6HUuRpEZXp3gXJVOH2e/qGzeKZBW6jOJdlLo6TVAkSTM/7iZDmYWWAB2q/+C9D+HQ0QNw2cUfLzCZ3/zqt3jwzocRGho67fufv/fL+J/n/kfUp0WuCY7UikwJm108Izd3WpEcn/JxLs4fUpMVsFrFOxZTpwmKZP/y424UySp0dYpXuWI2mf2uJOKbDFVWwJUguomOXoTN5bfjz8+9KLaUjzk9eAb7K/fivrs+PeM2q8pX4/q16zh2uFpAZfwSFEYulyngcIk3tN3UaYY8iRvzkycrYLeJeFEyWTgbQJO6TAmrVbwOT6vVBnmKUrT2PSErXYd2Y+AOCrrv9k/j5VdeFlvGx/z1L69iZcFaLIlZMuM2hBBsrbgTr778uoDK+CUojFwhV6C7zynao5LJZOLM/OQyJZwiXpSsNhtSOToWWbIcdhGfLpwuBxQypWjte0KWNhsd5vaAfcwvLizFmbOnJDO3+htvvIk7N94z63Z3brkLb7/7N9y4cUMAVfwTFEa+eFEMwsPCMdA3KEr7NqudM/NTyJVw9ohn5A6HA3KZgpNY8hRxn5Sc3Q6kcnQsfJEQn4AQEopuR4/YUnwiNDQU64q34K3X3hZbCs6eOoeG5lqsW7V+1m31OgPCwyJQXVkrgDL+CQojBwDZMjksItWSOxx2pKbIOYkVHxePq9eu4vzZC5zE8xZnN3dGrkhVwNktjpGPXB/B4JkBpCSniNK+p3xcudIYeJUrbrasvQ273t0ltgzs/vv7WK4rQVRU9KzbjqdX7sCrrwZHeiV4jDxRAYtFHCPn8hGeEIKUxFRYTMIfy40bN9DT74Jcxs1FKTkpBafPnxJl4Q+H1YW4mHjMi5gneNvekq7QorUlcI28omwNjOY29PX0i6pj1653sb7M87n7tq2/Ax98+B6PioQjeIx8mRw2kToJXX1OyFO5e4RPSZTDKkI5ZX/PACLnL/RpzdHpCA8PR+LSJFHmWLeYrEhJ5OaCxDfpyky0tQZuh+eC+QtQnr8Gf3/zXdE0jIyMYP/hj7Bl/TaP9zHoc3H67CnJrAHgD0Fj5KnJCtgsdsHbPTN0FmNjo5yOHkxdJhelLt5qskGW6H8t/GRkiamwmoU/FpuN+2PhC21aFto7AnuRiVVF67Bv717R2j966DgS45IhS/H8Mw8LC0NpXgU+3L2HR2XCEDRGLk9RwO4QwfwsNqQkyjkdPShbJs4duftYuESWqIBNhMoVm9UeMHfkWRk6dFk6ArZyBQBWla1B5bHDolWB7N2zD+X5q73er2LFOuz9SLwLEFcEjZEr5EpROtb4MD95ihJ2h53TmJ5gtXKfjpAtk4sywMlus0OeIu2KFTfx8fEID4uAyyGtEZLeoFKoMX/eAjTXi5PrP3joEMpXrPJ6vzXl63D42EGMjY3xoEo4gsbI5TI5ega6MTYq7Adit9o5f4SXpyrgdNk5jekJdpsDqUkcX5SSFbDb7ZzG9ASHy4HUADFyAAE758pkyvJW4aMP9wne7uVLw2hqa0BZUbnX+8pTFYiJXoK66gYelAlH0Bh55IKFWBS1GN0OYSdpslltSFnGrfkpUhVwiTDAyeHkrozSjTxVAYfTzmlMT3D1OKDgsAOab9IVWrQFcOUKAJQXrsKBA/sFb/fIgaPIUGZ9YqZDbyjNW4UDew9yrEpYgsbIAUCWKIfFLOxiBnaHA/Jkbg1jSUwsKKU4PSTs6nnOHm6rbwBAnqqEq1fYaXmvXbmOoTODfq2fKjTpyky0BnDlCgCsKluLYyeqBJ9Pf/++AyjNq/B5/xW5paiqquJQkfAEl5EvkwteueLicACNG0LI+EWpS7ha8htj3NaQu0lKTML5i+dw+eIwp3Fvhd3mQHxsAsLD/J/ETCi0aVkwBnjlSkJ8AuJjE3HyRJOg7R6uPISyQu/z427KispRXX88oIfrB5eRJwrfsebqc0Ih5/4RXujKlV5XPxYuiMLCSG5qyN2EhIQgOUEmaAmizWxHSoCUHrrJytCh0xrYlSsAsFxXjMqDRwRr78rwFbR2NKO4sNjnGCnJMiyIWID25g4OlQlLUBl5arJC0EFBp4fOYGxsFEtiuF+BJiVBLmjZntVi5a3uOiUxFVaTgEZutUGWGDj5cQCIi4vD/IgFcNpcYkvxi0JDMY5WHRWsvZpjJ6CRp/s9iG15trAXIK4JKiNXyIQt2xu/8+O2htzN+EXJznncmeCz7lqWKOwF1mazQ8ZxB7QQpCu0aG4MzLnJ3ZQUlqGmXrjl36oqjyI/q8jvOCtyy1BZyYxcEshTFXAJOHOg1WJDSgI/hpGarIBdwMUybFYbb+YnW5Yq6EXJbrNzXkYpBGlybUAP1QcAjSoNV69dg80kzN/hsaPHsSLX97SKm5LlpaiuPcaBInEIKiOXpaRi4HQ/Rq6PCNKe3cZ9Dbmb8ZkDhav2GK8h5ycdIfRFyemS/vS105GuCPzKFUIIluuKUHmI/7vbGzduoK6xFkUFJX7HyszIwvmL5+CyB+Z0wkFl5PMi5iEuJh52qzAGaLPakMLTnZ8iVdjFMvioIXejSFUKOi+5szewasjdaNMDv3IFAJbri1F1hP88ubnTihBCvJpfZSZCQkJQoCtG5cFKDpQJT1AZOQDIlikEmwKWjxpyN4sWLUZEeAT6ewd4iT8VZ4+T8zJKN0KmvK5euYZTZwaRkhQ4NeRuxudc6Qz4ypWiglJU1/Cfpqg6NJ4f56qPqlBfjMrDgVlPHnxGnpgq2MyBfNSQT0a2TC5ItQfX85BPJTE+EcNXh3Hh3EVe4k/GbnUgIXYZwsLCeG+La2JjY7FgXiQcNmEHUHFNbk4erE4L74ujHK06huV6/zs63RQXlOJ4tXAVN1wShEYu3PJifNWQu0lJkMMqwGIZPc4+REVGIzJyIS/xCSFITpDBYub/WGzmwKxYAdyrBQV+5cr8efOh0+Sg6jC/d+U1J45jRZ7/+XE3uTn5MNtNuHjhEmcxhSLojDw5USbI4sXuecj5qCF3I1uWCruD/2Oxmq28D6BJXaYQ5OnCZuV+NkohSVNkoq0t8PPkBdlFqKrkL01x/swF2FxWGHJyOYu5YMECZKqzcbyqhrOYQsGJkRNCthBCOgkhZkLIE1zE9BVZolyQag8+5iGfSkqiHC4BjsXGwwyOU0lJTIXDyf9FyeFyQBbARp6u1MLYEdiVK8D4wKDj1dW8xT9+rAZZaj3nS/nlZxXiqAAdtVzjt5ETQkIB/A7AVgA6AA8QQnT+xvWVlES5IHfkfMxDPhXBzM/pEOBYhPlcnC4HUhICa3j+ZNIVmTB2GsWW4TdFBSVoaD7B2wRa1dXHka/jLj/upiC7CDU1/F2Arl27xktcLnqEigCYKaVWACCEvArgTgC8PB+OXb+BK2dnrhOPj16GgcF+9F7uRVg4Px1eBAR2ux3JcbJbavGXpNhUOFx2DF0fAgU/lQwEBA6nHfKlWl6PJXlpKg4Z3+P3WMj4sWzLu4/XY+ETdVIGjB3tGLg2wOvTni+cvX4OFPDo3EaFxWBpTDyqThyDbnkm51qOVFdiZ/FDnH/OOapC/OC33+bl/I9cH4EuRYeuBjsSNUs4jc2F06UAmDxBRDeAm4ZaEUIeAfAIAMjlvt39hUeGIiF7IW7tAwuQmJiIPZ17kKxM9qmd2biBG3D02aA1pCFWvYCXNgAgN1EL5z85UHuxFmGEn4sSpRSOXju2fHo7r8eiL0nHC3vtqLtYhxDCT9cMpRSObjtyKzIRm8LfsfBJbFoK5kfNxwcdHyApNUlsOZ/gwtWLoCFjHn9PSktK8U7V27iq3QwC7kxx7MYYautq8Mz/ew6xS7n9nGPVGkRGLcBbJ9+COkPNaez2+nbIlXJELojkNC7AjZFP9wndZLWU0mcBPAsAhYWFPt2Shc0LwRIPvkRypRxD3UPISc/xpZlZOT1yGq5uJ9Y9uBZLNPwZxhIsQGRkJC6dugRNsoaXNk6PnIbL5UROqZbXY8mJ0sLpdCCEhGBp+FJe2ui91ItTp05BV6YJyPJDN+osNYa6hqBX68WW8glCw0IBAo+/J2s3r8Ib+9/A/V++H6EklDMdHe0dWBy7GNoiJWcxJ1NQWgBrvRUrsldwGrerrgtFJUWITuY2rw9w09nZDWByUlIGQNhleqagUCgw4OR3II3D4YBSqeS1DQBIVaTyeiw3btyAy+mCQsHvSMiEhARcGb6CK5eu8NbGqZ5TSE5JDmgTBwCtTgtzu1lsGX5TVlaGtlruO24bqhtQWFLIeVw3JaUlaK3lfrWm9tp2FJf6Py/MdHBh5CcApBNCVISQCAD3A9jFQVyfUSgVGHDxa+ROu1MQI1coFBjo5u9Yzg6exaJFixAZyf3j3mQIIeMXJR6PZcA5IMhnwjc52Tmwdgi3qAhfZGVl4cKZCzg9eJrTuG21bSgrLeM05mQqyitgrOW+w9l4wojS0lLO4wIcGDmldBTA1wDsAWAE8DqlVNT6KYVCgUHXIG/xL52/hNHRUcTG8ldD7gwldTkAACAASURBVIbvp4sB1wDkSmHK9YQ4Fr6fLITAoDfA0SHc3DR8ERISAsMKAxpquF3YuL22HRVlvi/tNhvFecUYdA3i/NnznMXs7e7F9avXkZ2ezVnMyXDS60QpfZ9SmkEp1VBK/4OLmP4gV8h5vSMfdA1CoVQIUlWgUPJsfk7hzE+ulPN/LMrAN/Lc7Fy4TK6AXnrMTUlZCZpquFv67dTQKZwZOIMVudzmryczL2IesvKzcPLESc5i1lfXI68oDyEh/HT0B93ITkAY85MrhLmL5fuiJKT5KRT8prz6nf1BcUeeGJuIqEVR6HWI2tXECRXlFWiv5a4Sua66DnnFebz3g5SUlqCxppGzeC21LSgr4y8dFJRGrparcab/DEZG+KklHnAJZ35yBc93sQKmI/i+Ix90DgbFHXkICYE6Sw1Th0lsKX6zqmQVLC0WXLvKzUCYpuomlJbxk2eeTEVZBYwnuMuTG08YsbJsJWfxphKURj5/3nzExMWgv7efl/hCpiM0Kg0GXAO8TW064BDwoiTnP7USDJ2dAJCRlQGzMfArV2IXxUKukaO1iZsqkLbqNqyuWM1JrFuxqmwVOuo7MDY25nesK1euwGa0oaKYv7x+UBo5ACTLk9Ht6OYltpDpiKUxSxEREYEzp8/wEn/AJZz5aVQaDHbz0wl95coVXDhzAYoAXBloOvTZeliNgV+5AgBFZUU4We1/vvnK8BVY26xYVbKKA1W3JjkhGUsTl6KrvcvvWC0NLVBlqBC9MJoDZdMTtEaeqkhFj5OfZZsGXANIlQs3n0eSPAkuB/erq4+NjWGwexBpqjTOY0+HbJkMVy5dweVLlzmP3e3sRkJKQsDXkLvJ1ecGReUKAKwsW4nWGv/vyJvqm6DJ0mBx1GIOVM1OYUkhJxU3DdUNKCrlfl6YyQStkSuVSvQ6ue8sopSiz96HNI0w5gdMXJQc3F+U+nv7sWjJIizkaR7yqYSEhGBZ6jJ0O7l/UnLZXEhVBe5kWVMxZBvgNDmDonJlzco1aD/R7nd6sOF4A4rL+BlQMx3lpeWcXIBajrdg3ep1HCiamaA1crVSzUuFxNkzZwEAiUsTOY89Ewqlgpc0kdPmRIoihfO4tyJFkcLLsXQ7uoOio9NN4pJERMdEo9ce+JUrWpUWISQETj9XPmqtacXqlfznx92sWbkGbTX+DYkZHR1Fe007NqzewJGq6QlaI1cpVRh0cp+PdTlcSFGmCDoznUqh4qWTsNvRLdhgIDcKhYKXlFevoxdqFbeTHIlJKAmFOkuNLqP/OVqxIYSgoLgA9TX1PscYGxuD8YQR6yr4vbOdTF52HoYvDvv1BGlsMWJp4lKkLOP3hilojdxd7cE1LptLcPNTqVS8HEuPvQdqtbDmp1Kq0Ofs4zxuv6M/qIwcALRZ2qCoXAGAipUVaDzme112l7ELMbExSE0SLn0WGhqK4opi1BzxfcWgE0dPoLSC/3LJoDXyNEUaTvWd4nxi+x57D1RqFacxZ0Oj1PAy5UC/ox8aFT+zKs6EUqHk5eliwDkAjVrYY+GbHH1O0FSubFq/CY2Vvht5bVUtisr57TCcjjVr1qChyvcOz+ZjzVizag13gmYgaI18wfwFWBy7GAN93JqGGI/waao0DDi5ryXvd/YLfkeuVql5uyhpNVrO44pJjj4Hjq7gqFwpNBTiysUrcNp9y5PXH6zH5o2bOVY1OxvXbkTLUd8Ww6aUorW6FRvW8JsfB4LYyAF+asn7Hf3QaIS984tbEofQsNCPO1q5ot/ejwxNBqcxZyNdlc55muj82fMYGxnDsrhlnMYVG4POEDRzroSGhqJkdQmqD3u/jNrIyAiajzZj64atPCi7NQX6Aly5dMWn8t/WplZEL46GRs6/XwS1kcsVcl6MPF2VzmlMT+C6lvzqlau4cOYCVDJh00SyZTIMXxzG8OVhzmK67C4kKZJ4m5BILBJiErBoySL02PgZDyE069etR32l9x2ezQ3NSEpNEjQ/7iYkJATFFcWorvT+AlS1rwprN67lQdXNBNc3fwpqtZrT+mv3AJp0tfBGnqpIhcvGnZF3O7uRIEtAeFg4ZzE9ITQ0FImyRE5ryV0OF1KVwVND7iaMhEGVqYLJGPhzrgDAto3b0FjZ6HWK8PiB41i9Xriyw6ls3rwZNfu87/CsP1CPbZu38aDoZoLeyPvs3FVI9Pf0Y/HSxYhaEMVZTE/h+qLktDkhU8g4i+cNMoXM51zpdHTbu4NmjpWpZOoyg8bIs9KyMG/ePBhbvZuMqqGyQZT8uJsdt+1A/cF6rybhu3TxErpOdmHL+i08KvsHQW3k6ep09Du4mzjLaXNCphTH/DRqDaeDQ7od3VCoxBlAo1Kp0G3n7o68z9EneL+FUOj1wTPnCiEEm7ZvwoH3Dni8z7mz52BpsmDT6k08Krs1KpkKyfJk1Fd7nhY6fvg4spdnIyY6hkdl/yC4jVzDrZG77C7RRg+madI4PZZeR6/gpYduuL4o9Tv7BZsvRmgMegMcncFRuQIAd++4G8c/OO7x9gc+OIAVFSuwOFqY+VVmYvO2zaj8sNLj7Y/tO4ZNm4S7+AS1katkKpw/fR5XrnCz4K8YA2jccH1R6rcLX3roJk2Thn47t8cSbDXkbgzZBnSbuzmZTlUKbF69GX32PvT1eJbyPPzuYezcuZNnVbNz5/Y7Ubu31qNtR0dHcfS9o/jUzk/xrOofBLWRh4WFITGFu461XkevaIaRrkzHUPcQZwOc+p39SFOLcxebrklHn4ObvgtKKQZcA8hQC1tGKRTxi+KxOG4xum38TMksNPMi5mHN5jXY996+Wbe9fOkyGisbce+d9wqg7NasLl6Ni2cvwtQ5e39FTVUNEpYlwJBpEEDZOEFt5ACQquKu2mPAMSCa+UUuiERMXAx6u7lJSQw4BkQbQJOhyUC/o5+TAU6D/YOIjIoULBcpNGEkDOpMddAM1QeAnTt2onLX7GmKQ3sPIacwRxLjA8LCwnDX/Xdh18u7Zt12z9/2YOd9wj5FBL2Rq1QquOzcGHm/ox/pGuFLD92kqlI5qfY4d+YcbozdEHQGx8ksjVmKiHkRGBoc8juW0y78DI5Co9Vpg6ZyBQDuuf0eWFossz4p731zL+69R/y7cTdf+tyXsPe1vbdMc41cH8HRd4/isw98VkBlc8TIuXiMH748jEvnL0GZrPRflI8oVApOqj2cdidSlCmiDqCRKWVwWP3vxHPZXZCrhJ3ETGj02XpYO4KjcgUAFkYuxO07b8fbL7894zaDA4NoqmzC5z/zeQGV3ZrivGLEJ8aj6kDVjNvs37MfqgwVtCphn3aD3sjT1Gmc1JI77U4kyZMQGhrKgSrf0Kg16LH7X0suhQE0CrWCkyelXntwTV87HQa9IWhWC3Lzja9+A7uf341r16ZflPm151/D1h1bEbs4VmBlt+bBhx7E31/4+4zvv/n7N/Hoo48KqGicoDfyjLQMTozcZXOJVkPuRqPWcFK50m3rhlKl9DuOP2jUGk468PqcfcFv5DoDeiw9QVO5AgDF+cXIyM7A3176203vXbp4Cbue24Wn/ukpEZTdmse++Bhaj7VOO098XXUd+mx9eOhTDwmuyy8jJ4TcSwhpI4TcIIQUciWKS3QZOvTaev3uWHM5XFCphJ2XZCrpmnT0Wv3v7Ox3iF+up9FoOLnASuFY+CZ+UTxi4mPgsnK/bquY/PQ/fooXf/oiLpy/8InXf//T36NiXQXydHkiKZuZxdGL8di3HsMvf/DLT3jK6OgofvvD3+Lpf3ka8+fNF1yXv3fkrQDuBuB5pbzAxCyKQWRUpMd1qzPRa+8VrWLFjU6rQ6/V/4tSv1N888vQZKDX5v9Fqc/WB21acE1fOxX3akGm9uDp8ASAVSWrsOm2TfjR1370cVlt5YFK7H1lL/77v/5bZHUz84Pv/ABne87ixf958ePXnvnpM5gXOg9f/dxXRdHk15LjlFIjAEGXPfMFhUYBm8WGZFmyzzEGHANQrxP3Ed5dhnXm9BksjVvqc5xeW6/o5ue+KPnD8PAwzp8+jzRFcI7qnIw2Swtzhxkb79wothRO+eNv/oh129bhi1u/CGWWEkffPYpXXn8F8hTpdmDPnzcfu3ftxuo1q9FS3YLR66Po7uzGwf0HERbml6X6jGA5ckLII4SQOkJI3dCQ/2Vn3qBOU8Nh9q+zqNfai4w0cQedEEKgSFPA0mXxOca1a9cw1DOETE0mh8q8R5GiwNXhqzh/7rzPMewWO5IVyaL98QiJQW8IqsoVNwsjF+LIR0fw+GOPo1BbiJraGmxdJ/y8496SqclEW3MbNldsxo4tO9BwogGqVPFSr7P+BRBC9gGYriL/aUrpO542RCl9FsCzAFBYWMjtUjezoM3QwmTx/bF0dHQUfY4+ZGuzOVTlG+o0NRwWB4rKfFv2yml3IjElUZQ83mQIIZCr5bBZbMhb7lsu1GayQZUmbr+FUBj0Bvz2l78VWwYvRERE4EsPfklsGV4TtyQOTz7+pNgyAHhg5JRS/tcp4pmMtAwcPn7Y5/2dDidi42MRvTCaQ1W+kZ6eDqfF90FBUjI/VZoKNpPvRu60OJGREZxD86eSq8tFj6UHo6Ojc+IJhOEdQV9+CADadC16rL7XX9tNdijTldwJ8oOM9Az0WPw4FrMdaRnSyClnZGT4dVHqtnTPGSOPjYpFbGJs0FWuMLjB3/LDuwgh3QBKAbxHCNnDjSxu0WXo0Gfv87kO1262S8YwdFqdXxelbks3MjPEzY+70WZo/boodVu6kZWRxaEi6RJCQqDJ1KCr/eb6ZQbDLyOnlL5NKZVRSudRShMppeIt43ELFkcvRnRMtM8TTjlNTmgzpFHi5m8JYre5G5laaRh5ZkYmus2+DwrqtfbOGSMHgMzszKCaPIvBHXMitQIAyjQlrGbfev17LD3IypSGYSyNWYr5C+ajr9e3uvgec48kOm0BIDsz2+eL0rmz53B1+CoUKeIs9CEGhmwDbB02sWUwJMicMXJtlhYWo29le93mbui0Oo4V+Y4yXQmryfuL0sULF3H5wmUoZUruRfnAsrhlCA0NhS/lqDaLDXKNXPJjGLgkGOdcYXDDnDFyvU4PR5f3fwSXL13GhTMXJDXoJDPLt0dsq9kKmVom6sRfU1GkK2Du8P5YzB1myXTaCkWuLhe9tl6MjnCzuAgjeJg7Rp6th7PT+woJq9mKFFWKpEq+9Nl62IzeP2KbO8zIyJJGp60bXbbOp7m2bUYb9Ho9D4qkS8zCGMQlxXEy/S8juJgzRp6XnQdHh8PrfGxXexe0Oml0dLrJ0efA1eV9GZqlzQJ9trTMT5+th91o93o/R4cDOfoc7gVJGEII0rLSWOUK4ybmjJHLkmQAhdf5WEubRXKGka/P9+miZO+wI9eQy5Mq3zDk+Jb3tXfYkZ+Tz4MiaaPT6VjlCuMm5oyRE0KgydJ4/RhvN0rP/GRJMtAb1Oul0hxGh+TMryCnwOuL0sULF3H+1Hlo1dJ6UhKCnOwc2DvsYstgSIw5Y+TARCehlx1rtnYbCgwFPCnyDfdFqbO90+N9Lpy/gPNnpGd+KcvG19scHBj0eJ8uYxcU6QpJ9VsIBatcYUzHnDLybF22V/nYc2fP4fKFy8hQSauDEACydFlePWJ3tndCrVVLqmIFGL8opevS0dHW4fE+JqMJWdnSqOsXmjxdHvrsfRi5PiK2FIaEmFNGbsgxwNbuebVHZ1snNJkayZkfMNFJ6MUjtqlduuaXqcv0qsbfarQiWy+NQU1CExUZhYTkBJhNLE/O+AdzyshLC0thbbF+vBrJbHS1d0nW/AryCmBt8XxQkNVoRU6OtDpt3Rj0BljbPT8We7sdBr2BR0XSRmfQoaPF8ycYRvAzp4w8PjYeS+KXeDwq0tJmgSFHmoZRWlgKm9E24yrkU7G0WpBnkN4aiABQVFgEU5NnndCUUpiaTCgrLONZlXQpKChAZ5Pn/SOM4GdOGTkA5OTnoOVki0fbmpvMKCyQ5JrSWBy9GMnyZI86PEdGRmBpsmBl8UoBlHlPcX4xesw9GL48POu2NosNkQsjkZqcKoAyaVK4vBDmJpZaYfyDOWfkywuXw3jSOOt2V65cgb3DjvKicgFU+Ubu8ly0NrTOul2nsRPxyfGIWxIngCrvWTB/AdSZarQ2zn4szfXNMCyX5lOSUBQXFMPcbPZ7EW5G8DDnjLy4sNiju5nWxlYo05WSWBVoJooKizy6KLXUtSC/UFr141PJL8xHS8PsT0pt9W1YsWKFAIqki2yZDJFRkXDYWBkiY5w5Z+Sedng2nWhCYbE00ypuilcUw9Q4e265vb4dJcUlAijynZLiEnQ0zN6B13WyCyVF0j4WIcjOy0ZbY5vYMhgSYc4ZeXxsPJYmLkWX8dbzVRjrjCgvkW5aBRjPLXebujE8fOvccmdDJ8qKpd05WLaiDF0nb/2ZjIyMwNpqlXS6SyjyC/LRfrJdbBkMiTDnjBwAyleXo/pw9S236ajrQHmptA1jYeRCpOnS0FDbMOM2ly9dRq+tF0X5RQIq855cXS7ODZ7DqaFTM25jbDUiMSURS2OWCqhMmqwoWAFzM+vwZIwzJ41804ZNqD9cP+P7vd29uHr5KnK00qy7nsz6jetxfP/xGd+vqaqBLk+H+fPmC6jKe8LCwlBUUYSqA1UzbnN031GsWrdKQFXSpbiQdXgy/sGcNPKtG7ei9VjrjMOcD354EBUbKgJi9Zltm7eh4dDMd+RVe6qwZesWARX5ztatW1G9d+YnpRMHTuC2rbcJqEi6qGQqhIaE+rwOLSO4mJNGnhSfBJlShpN1J6d9/9ieY9hxxw6BVfnG2rK16LX2TpuSoJSidm8t7tp+lwjKvOeObXeg/mA9xsbGbnrvwvkLMDeasXXdVhGUSQ9CCLLystDS6NmYCEZwMyeNHADWrF+D4wduTklcvnQZrUdbseO2wDDyiIgIFFcUT5uS6DR2go5RFOZKu/rGTaYmE4tiFqG16eZ68mOHjyG3OBeLohaJoEya5Ofno6ORDdVnzGEjv2/nfdj/xv6b7v6OHDwC/XK9ZAfPTMe2bdtw6J1DN71++MPD2LB1Q0CkiNys27QOB98/eNPrRz44gs2bN4ugSLoUFxbPWunDmBvMWSNfV74O0VHROHLgyCde3/PaHuzYERh3424efvBhNB9thtP+jzVJR0dH8f5f3sdn7v+MiMq858tf+DI+eOEDXL169ePXBgcHcWz3MTz84MMiKpMeq8pWoaO+g3V4MvwzckLIzwkhHYSQZkLI24SQGK6E8Q0hBF/+6pfx1nNvffxa88lmGGuNeOzhx0RU5j0xi2Jw34P34ZU/vvLxa7v/thsJ8QkBl1MuKShBliELb//17Y9fe/kPL2P7zu3jy/UxPkaRokBkVKTHk8Axghd/78j3AtBTSg0AugA86b8k4Xj4/zyMjroO7Hl3D8bGxvD7f/s9vv39bwdkHva73/gu9ry0B8ZWIy5euIi//Odf8MMf/jCg0ipunvr+U3j1N6/i9KnTcNqceO/P7+HJ7wXUV0sw8ovy0VAzc9USl1w4fwHzI6VdxjpX8WutLErpR5N+rQZwj39yhGVR1CK88+47uPP2O/HMPz+DxIREfOsr3xJblk9kajLxs1/+DF+/4+sIjwjH+s3rcdfWwKhWmcrWdVtx59134jPln8HoyCi+99T3YMic2xNlzURpSSlqT9Ti3gfv5b2t5vpm6PP1vLfD8B4uFz38AoDXZnqTEPIIgEcAQC6Xc9isf1QUV+Dg4YPo6+/D5jWbA/IO1s1XHvoKDNkGXL12FevK14ktx2cIIXjm58/g7jvuxsLIhShdXiq2JMlSXlKOF198UZC2WutaUVLC5rmRImS2jhJCyD4Ay6Z562lK6TsT2zwNoBDA3dSDnpfCwkJaV1fng1wGgzGZ4avDiF0aiw9NHyIqOorXtj636XP48b/+GLdvvJ3XdhgzQwipp5TeVE886x05pXTDLIEfArAdwHpPTJzBYHBH5PxIpGeno7mhGWWr+ZsY7erVq7C0WFBRXMFbGwzf8bdqZQuA7wO4g1I6+/IuDAaDcwqLC9FU28RrG80NzVCkKRCzKGAK0+YU/lat/DeAaAB7CSGNhJA/cKCJwWB4wcrSlWg/we+Utg3HG1BSzvLjUsUvI6eUplFKUymleRP/vsKVMAaD4RlCDAxqrWnFqpVs5kmpMmdHdjIYwUKaIg3h4eGwmCy8xL9x4wbaa9qxriJwK6GCHWbkDEaAQwhBcUUxao/U8hK/y9iF6MXRUMqUvMRn+A8zcgYjCFi/dj0ajzbyErvueB2KyqS9wtRchxk5gxEEbFy3EU1HmnjJk588chJr1qzhPC6DO5iRMxhBgC5Nh9DQUM7z5Ddu3EBjZSO2bdzGaVwGtzAjZzCCAEIIylaXoaayhtO47S3tWBSzCOnKdE7jMriFGTmDESSsXbsWDUe4nQnx+MHjbMHrAIAZOYMRJGzfvB0nD53E6OgoZzEbDjdg4/qNnMVj8AMzcgYjSNDINUhITkBjHTfVK9euXUN7TTu2bgisxUnmIszIGYwgYv3m9Tjy0ZHZN/SA6qpqqLQqJC5N5CQegz+YkTMYQcQd2+7Aib0nOIlV+X4ltt+xnZNYDH5hRs5gBBEbKjag19aLwYFBv+JQSlH9YTXuvvNujpQx+IQZOYMRRMyLmIfydeXY/95+v+IYW4wICw1DYc5NaxgwJAgzcgYjyPjUfZ/CoXcO+RVj/3v7sXn7ZoSEMIsIBNinxGAEGTtv34nO+k6cGjrlc4yqd6twz46AWkt9TsOMnMEIMhZHLUbFxgrseWePT/u3N7fj0tlL2LxmM8fKGHzBjJzBCEIeuO8BHHz7oE/7vvvqu9j56Z0IDQ3lWBWDL5iRMxhByM7tO2Fvt8NutXu13+joKA68cQAPf/ZhfoQxeIEZOYMRhCyMXIh7/s89eP1Pr3u1X+X+SiQkJaBAX8CTMgYfMCNnMIKUb331W9jz1z0YHh72eJ9Xf/cqHn3sUR5VMfiAGTmDEaRkZ2TDsNyAd99416PtWxpa4Op04UsPfolnZQyuYUbOYAQxT/zTE3jpP1/CtavXZt32hV+/gK984ytYMG+BAMoYXMKMnMEIYm5bfxvSM9Px0rMv3XK71qZWNFc141uPfksgZQwuYUbOYAQ5v/j5L/DKr16ZcYDQ6Ogofv7dn+OJHz6B2MWxAqtjcIFfRk4I+TdCSDMhpJEQ8hEhJJkrYQwGgxsKcwrxwGcfwA+//MNpF5145mfPIDI8Et9+9NsiqGNwgb935D+nlBoopXkAdgP4Zw40MRgMjvn1j3+N0NFQPPXIUx9XsVBK8aff/Al7X96LN155A2FhYSKrZPiKX58cpfTCpF8XAqD+yWEwGHwQERGBPbv24NNf+DR2FuxE7spc2NptmBc+D4cOHYJSphRbIsMPCKX+eS8h5D8AfBbAeQBrKaVDM2z3CIBHAEAuly93OBx+tctgMHyjuqEaNfU1UCvV2LZuGxuKH0AQQuoppTfNLTyrkRNC9gFYNs1bT1NK35m03ZMA5lNKfzSbmMLCQlpXVze7agaDwWB8zExGPmtqhVK6wcM2/grgPQCzGjmDwWAwuMPfqpX0Sb/eAaDDPzkMBoPB8BZ/u6l/QgjRArgBwAHgK/5LYjAYDIY3+Fu1spMrIQwGg8HwDTayk8FgMAIcZuQMBoMR4DAjZzAYjACHGTmDwWAEOH6P7PSpUUKGMF7lIkXiAEw/TZw0YPr8g+nzD6bPf/zRqKCUxk99URQjlzKEkLrpRk5JBabPP5g+/2D6/IcPjSy1wmAwGAEOM3IGg8EIcJiR38yzYguYBabPP5g+/2D6/IdzjSxHzmAwGAEOuyNnMBiMAIcZOYPBYAQ4c9LICSGphJCDhBAjIaSNEPLNabZZQwg5P7GwdCMhRND1SAkhdkJIy0TbN63CQcb5DSHEPLEAdoGA2rSTzksjIeQCIeTxKdsIev4IIc8TQgYJIa2TXoslhOwlhJgm/l8yw74PTWxjIoQ8JKC+nxNCOiY+v7cJITEz7HvL7wKP+v6FENIz6TPcNsO+WwghnRPfxScE1PfaJG12QkjjDPsKcf6m9RTBvoOU0jn3D0ASgIKJn6MBdAHQTdlmDYDdImq0A4i7xfvbAHwAgAAoAVAjks5QAP0YH6gg2vkDsApAAYDWSa/9DMATEz8/AeCn0+wXC8A68f+SiZ+XCKRvE4CwiZ9/Op0+T74LPOr7FwDf9eDztwBQA4gA0DT1b4kvfVPe/y8A/yzi+ZvWU4T6Ds7JO3JKaR+ltGHi54sAjABSxFXlNXcCeJGOUw0ghhCSJIKO9QAslFJRR+pSSisBnJny8p0AXpj4+QUAO6bZdTOAvZTSM5TSswD2AtgihD5K6UeU0tGJX6sByLhu11NmOH+eUATATCm1UkqvA3gV4+edU26ljxBCANwH4BWu2/WUW3iKIN/BOWnkkyGEKAHkA6iZ5u1SQkgTIeQDQki2oMIACuAjQkj9xMLVU0kB4Jr0ezfEuRjdj5n/gMQ8fwCQSCntA8b/0AAkTLONVM7jFzD+hDUds30X+ORrE6mf52dIC0jh/FUAGKCUmmZ4X9DzN8VTBPkOzmkjJ4REAfgbgMcppRemvN2A8XRBLoDfAvi7wPLKKaUFALYCeIwQsmrK+2SafQStJSWERGB8ib83pnlb7PPnKVI4j08DGAXw8gybzPZd4IvfA9AAyAPQh/H0xVREP38AHsCt78YFO3+zeMqMu03zmlfncM4aOSEkHOMn/GVK6VtT36eUXqCUXpr4+X0A4YSQOKH0UUp7J/4fBPA2xh9hJ9MNIHXS7zIAvcKo+5itABoopQNT3xD7/E0w4E43Tfw/OM02op7HiY6t7QA+QycSplPx4LvAC5TSAUrpGKX0BoA/ztCu2OcvDMDdAF6baRuhzt8MDXAGewAAAYJJREFUniLId3BOGvlETu1PAIyU0l/MsM2yie1ACCnC+Lk6LZC+hYSQaPfPGO8Ua52y2S4An52oXikBcN79CCcgM94JiXn+JrELgLsC4CEA70yzzR4AmwghSyZSB5smXuMdQsgWAN8HcAeldHiGbTz5LvClb3Kfy10ztHsCQDohRDXxhHY/xs+7UGwA0EEp7Z7uTaHO3y08RZjvIJ89uVL9B2Alxh9dmgE0TvzbhvHFo78ysc3XALRhvBe+GkCZgPrUE+02TWh4euL1yfoIgN9hvGKgBUChwOcwEuPGvHjSa6KdP4xfUPoAjGD8DueLAJYC2A/ANPF/7MS2hQCem7TvFwCYJ/59XkB9ZoznRt3fwT9MbJsM4P1bfRcE0veXie9WM8YNKWmqvonft2G8SsMipL6J1//s/s5N2laM8zeTpwjyHWRD9BkMBiPAmZOpFQaDwQgmmJEzGAxGgMOMnMFgMAIcZuQMBoMR4DAjZzAYjACHGTmDwWAEOMzIGQwGI8D5/017fH3+x9amAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot line graph in black\n", + "plt.plot(x, y, color='black', linewidth=1)\n", + "\n", + "# Put green/purple fill between the graph y=0\n", + "plt.fill_between(x, y, where= y <= 0, color='limegreen', alpha=.25)\n", + "plt.fill_between(x, y, where= y > 0, color='darkorchid', alpha=.25)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " > **Note:** The sequences to be plotted has to be `numpy` arrays in order to make element wise comparison like `where= y > 0`. Trying this with standard Python lists will throw a `TypeError: '<' not supported between instances of 'list' and 'int'`. This is one of the many benefits of `numpy`. See a little more info about `numpy` later in this text." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Subplots\n", + "Creating subplots is also straight forward:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Create a figure for holding subplots and set size\n", + "plt.figure(figsize=(14,3))\n", + "\n", + "# Create first plot as line plot\n", + "plt.subplot(131)\n", + "plt.plot([1, 2, 3, 4], [1, 2, 3, 4])\n", + "\n", + "# Create second plot as scatter plot\n", + "plt.subplot(132)\n", + "plt.plot([1, 2, 3, 4], [1, 2, 3, 4], '.', markersize=12)\n", + "\n", + "# Create third plot as bar plot\n", + "plt.subplot(133)\n", + "plt.bar([1, 2, 3, 4], [1, 2, 3, 4])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "> * The `subplot` argument conatins three digits, where the first one is the number of rows, the second the number of columns and the third the current plot to manipulate. \n", + "> * For making more complicated grid formations, shared axis tick marks etc. The **Object Oriented API** should be used instead." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Object Oriented API\n", + "Almost every aspect of a visualization can be controlled. However, in order to access more complex controls, the way of interaction with the graph elements also becomes a little more complex. \n", + "\n", + "In order to use the more powerful `matplotlib` API, we get into so-called *Object Oriented Programming*. We access each element of a figure as an *object* and manipulate that object.\n", + "\n", + "The figure below gives an overview of the objects that can be controlled in a figure to enable very high customizability of plots.\n", + "\n", + "![title](matplotlib_objects_anatomy_of_a_figure.png)\n", + "\n", + "Source: [Anatomy of a figure](https://matplotlib.org/3.1.1/gallery/showcase/anatomy.html)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Subplots" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* Note especially that the `Axes` object is the actual content of the plot, and therefore does not refer to `x`- or `y`-axis themselves.\n", + "\n", + "The Object Oriented API is recommended for more complex plotting like creation of larger grids of subplots where each plot needs independent adjustments. \n", + "\n", + "In the example below we still run the `plt.` command, but we save it to two variables `fig` and `ax`: " + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Create a 2 by 3 subplot grid with shared x- and y-axis\n", + "fig, ax = plt.subplots(2, 3, sharex='col', sharey='row')\n", + "\n", + "# Put content on the plot at grid spot 1,1 (0 indexed)\n", + "ax[1, 1].plot([1, 2, 3], [1 ,2, 3], 'g-.')\n", + "ax[1, 1].plot([3, 2, 1], [1, 2, 3], 'm:')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "> * The figure that is created is saved in the variable `fig` \n", + "> * The axes for all the subplots are saved in an array variable `ax`\n", + "> * Individual subplots can be manipulated by indexing into the `ax` variable. Indexing starts from `0`, so `ax[1,1]` is the middle plot in the bottom row as seen above.\n", + "> * There are many other plot types where the *Object Orientated API* is preferred compared to the simple Matlab style one." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Online help and plotting galleries\n", + "Instead of creating a figure from scrath, it can be quicker to serch the web for the graph style of choice, fetch a piece of code and modify it. \n", + "\n", + "Here are some useful links:\n", + "\n", + "* Plotting gallery for `matplotlib` with code examples: https://matplotlib.org/gallery/index.html\n", + "\n", + "\n", + "* Some more examples with `matplotlib`: https://www.machinelearningplus.com/plots/top-50-matplotlib-visualizations-the-master-plots-python/\n", + "\n", + "\n", + "* Predefined styles `matplotlib`: https://matplotlib.org/gallery/style_sheets/style_sheets_reference.html\n", + "\n", + "\n", + "* Predefined color names for `matplotlib`: https://matplotlib.org/gallery/color/named_colors.html. Colors can also be defined as hexidecimal or RGB.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Numerical computation library: `numpy`\n", + "Another very well known and broadly used third party library is `numpy` (short for Numerical Python), which contains many useful features for fast and efficient numerical calculations. This library has a lot of the same functionality as `Matlab` and utilizes vectorization to perform calculations.\n", + "\n", + "It can be installed in the same way as every other third party library, namely by entering `pip install numpy` or `conda install numpy` from the relevant Prompt.\n", + "\n", + "Once installed `numpy` can be used as shown below. Like with the `matplotlib` import, `numpy`also has a community accepted standard of importing as `np`:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The basic data structure in `numpy` is called an array, which can be compared to a normal Python list.\n", + "\n", + "A numpy array can be created, for example from a list, like this:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# A normal Python list\n", + "L = [1, 2, 3, 4, 5] \n", + "\n", + "# List converted to numpy array\n", + "arr = np.array(L) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Printing the array looks like a normal list:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1 2 3 4 5]\n" + ] + } + ], + "source": [ + "print(arr) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "But it is in fact a `numpy` array, which can be seen by inspecting the type:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "print(type(arr))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The fact that `numpy` uses verctorization can be seen for example by performing mulitplication:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 2 4 6 8 10]\n" + ] + } + ], + "source": [ + "# Multiply all array elements by 2 and print result\n", + "arr_double = 2 * arr\n", + "\n", + "print(arr_double)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Recall that doing the same operation with a normal Python list is a little more complicated. Here shown with a list comprehension, but a normal `for` loop could also be used. " + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2, 4, 6, 8, 10]\n" + ] + } + ], + "source": [ + "# Multiply all list elements by 2 and print result\n", + "L_double = [2*i for i in L]\n", + "\n", + "print(L_double)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Function: `np.linspace()`\n", + "\n", + "As mentioned, `numpy` has many useful functions and methods. One of the most used functions is \n", + "\n", + "~~~python\n", + "numpy.linspace(start, stop, num=50) \n", + "~~~\n", + "\n", + "which will generate an array of `num` numbers evenly spaced between `start` and `end`. As we day from Session 3 about functions, the `num=50` means that `num` is an optional argument, the default value of which is 50. So, if `num` is not specified, the generated array will have 50 evenly spaced numbers between `start`and `end`.\n", + "\n", + "**Note** that the `numpy.linspace()` function has more arguments, which are not shown here. See the documention for more info: https://docs.scipy.org/doc/numpy/reference/generated/numpy.linspace.html\n", + "\n", + "An example:" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0. , 0.11111111, 0.22222222, 0.33333333, 0.44444444,\n", + " 0.55555556, 0.66666667, 0.77777778, 0.88888889, 1. ])" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.linspace(0, 1, 10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `numpy.linspace()` function can especially be useful when generating $x$-values for plotting purposes." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Benefits of `numpy`\n", + "* In general `numpy` operations are **much** faster than equivalent operations in standard Python. When handling large amounts of data or computationally intensive tasks, `numpy` should be therefore preferred. \n", + "\n", + "\n", + "* Many useful functions and methods for working with data are predefined and optimized in the library. Before starting to reinvent the wheel for array manipulations, check if a `numpy` solution exists. `np.linspace()` is just one example of this.\n", + "\n", + "\n", + "* A lot of other libraries are built on top of or uses `numpy`. In fact `matplotlib` uses it for its plotting operations.\n", + "\n", + "\n", + "* Using `numpy`'s predefined functions and methods often lead to more readable than using other ways. Consider e.g. the example from above with element-wise multiplication. The Matlab-style syntax is just more reable for numeric computation." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# Exercise 1.1\n", + "All exercises use the simple API described above.\n", + "\n", + "Plot a black line graph with dots at the points with these coordinates:\n", + "\n", + "~~~python\n", + "x = [1, 3, 6, 9, 16]\n", + "y = [7, 3, 7, 1, 5]\n", + "~~~\n", + "\n", + "Remember to `import matplotlib.pyplot as plt` and to call `plt.show()`. \n", + "\n", + "The color can be set by `plt.plot(..., color='black')` or by a shortcut `plt.plot(..., 'k')`, where `'k'` is black becuase `'b'` is blue. \n", + "\n", + "# Exercise 1.2\n", + "Set the plot title on the graph from Exercise 1.1. You choose what the title should be.\n", + "\n", + "# Exercise 1.3\n", + "Set the title of the $x$- and $y$-axis on the graph from Exercise 1.1. You choose what the title should be.\n", + "\n", + "# Exercise 1.4\n", + "Add the graphs with the following $y$-values to the plot from Exercise 1.1. Use the same $x$-values for all curves.\n", + "\n", + "~~~python\n", + "y2 = [9, 5, 5, 2, 6]\n", + "y3 = [4, 6, 2, 6, 8]\n", + "y4 = [1, 8, 1, 3, 2]\n", + "~~~\n", + "\n", + "# Exercise 1.5\n", + "Go back through the code from the previous exercises and add a `label` to the plots that were produced. Choose a label text freely.\n", + "Afterwards, add a legend to the plot. \n", + "\n", + "# Exercise 1.6 \n", + "Save the figure to a png-file. This can be done by the command `plt.savefig(desired_filename.png)`. This will save it in the same folder as you have your script.\n", + "\n", + "\n", + "*If you are dissatisfied with the size of the saved figure, this can be adjusted by explicitly creating the figure object before any of the graphs are created. Creating the figure object and setting a size is done by `plt.figure(figsize=(width, height))`. Both `width` and `height` are in inches. Try with different values.*\n", + "\n", + "\n", + "*Note: When using the simple API it is not necessary to explicitly create the figure object before starting the plotting with `plt.plot()`, as the figure is automatically created in the background with default settings. When saving to a file where it is not possible to drag the plot after creation, it is often useful to set the figure size beforehand*\n", + "\n", + "# Exercise 2.1\n", + "Create a new figure by the command `plt.figure()`. This will create a new figure object that subsequent commands will tie to. This is to avoid having the commands in this exercise be plotted in the plot from the previous exercises. \n", + "\n", + "\n", + "Redo the graphs from the previous exercises, this time split into four subplots instead. You choose how to structure the grid and how to style the graphs with colors, titles, line types etc.\n", + "\n", + "\n", + "# Exercise 2.2\n", + "Create a new figure and replicate the same subplots as in Exercise 2.1. But this time, turn the plots into bar plots. The only difference is that the plotting call should now be `plt.bar(...)`.\n", + "\n", + "\n", + "# Exercise 3.1\n", + "Create plot that is filled with some color of your choice between $y=0$ and the curve defined by $xx$ and $yy$ below:\n", + "\n", + "~~~python \n", + "import numpy as np\n", + "xx = np.linspace(-100, 100, 100)\n", + "yy = xx**2-3027 # <- Element-wise multiplication and subtraction (numpy)\n", + "~~~\n", + "\n", + "\n", + "# Exercise 4.1\n", + "Use `numpy.linspace()` to create an array with 10 values from 1-10. Save the array in a a variable called `x_arr`.\n", + "\n", + "Use the code below to create the $y$-values for five graphs. \n", + "\n", + "~~~python \n", + "y_arr1 = np.random.rand(10)\n", + "y_arr2 = np.random.rand(10)\n", + "y_arr3 = np.random.rand(10)\n", + "y_arr4 = np.random.rand(10)\n", + "y_arr5 = np.random.rand(10)\n", + "~~~\n", + "\n", + "\n", + "*The `numpy.random.rand()` function creates random values between 0 and 1 (see documentation for more: https://docs.scipy.org/doc/numpy/reference/generated/numpy.random.rand.html)*\n", + "\n", + "\n", + "Create a loop that goes through the five graphs. Each loop should create a figure with your chosen size and settings for the current graph and save it to a png-file.\n", + "You should end up with five png-files each containing only a single graph/curve." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# If you are up for more \n", + "Take the polygon plotting function `plot_polygon()` from the exercise solutions from Session 3. Create different polygons, run them through a for loop and save them to png-files. Remember that `plot_polygon()` calls the other functions `polygon_area()` and `polygon_centroid`, which also have to be copied." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# End of exercises\n", + "\n", + "*The cell below is for setting the style of this document. It's not part of the exercises.*" + ] + }, + { + "cell_type": "code", + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -275,7 +1078,7 @@ "" ] }, - "execution_count": 1, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -284,800 +1087,6 @@ "from IPython.display import HTML\n", "HTML(''.format(open('../css/cowi.css').read()))" ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# 4. Plotting\n", - "\n", - "## Plotting with `matplotlib`\n", - "There are many plotting libraries in the Python ecosystem, and more being added all the time. The most widely known is called `matplotlib`, which is the one we are going to focus on.\n", - "\n", - "`matplotlib` is a third party library, which means that it is developed and maintained by the Python Community and not the core developers of the Python language itself. This means that it doesn't ship with the Python installation and has to be installed separately before we can import it and use it in our programs. `matplotlib` is one of the oldest, most known and well documented third party libraries in Python.\n", - "\n", - "---\n", - "\n", - "If `matplotlib` is not yet installed you can install it in a way that suits your setup. \n", - "\n", - "> If you are using the **Standard Python** installation, go to the Windows cmd and type `pip install matplotlib`\n", - "\n", - "> If you are using an **Anaconda Python** distribution go to Anaconda Prompt and type `conda install matplotlib`\n", - "\n", - "---\n", - "\n", - "*The lines in the code cell below are just some setup code for showing plots inside this notebook environment. These are not relevant in an editor.*" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "cell_style": "center" - }, - "outputs": [], - "source": [ - "# Enable for plots to be shown inside Jupyter Notebook cells \n", - "# (Note: This line is not needed when using an editor) \n", - "%matplotlib inline \n", - "\n", - "# The lines below sets the figure size throughout the notebook\n", - "import matplotlib as mpl\n", - "mpl.rcParams['figure.figsize'] = 7, 5" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Importing `matplotlib` to the script\n", - "\n", - "The `matplotlib` library needs to be imported in a script in order to access its functions and methods:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "# Import the plotting library and refer to it as plt later on\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "It is customary to import `as plt` so referencing can be done as \n", - "\n", - "~~~python\n", - "plt.do_something() # plt replaces matplotlib.pyplot\n", - "~~~\n", - "Where `do_something()` is some function/method inside `matplotlib`. This is much shorter than typing\n", - "~~~python\n", - "matplotlib.pyplot.do_something() # Long and cumbersome to type\n", - "~~~\n", - "\n", - "In fact, the `plt` part could be named differently, but **it is widely accepted to use this naming**, which makes it easier to read other people's code." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Simple plotting API\n", - "The simple API for plotting in `matplotlib` uses commands which deliberately were chosen very similar to the `Matlab` syntax. \n", - "\n", - "API stand for *Application Programming Interface*. It is basically a simplified way of interacting with more complex underlying code. Here, we will type fairly simple plotting commands, which do a lot of low level work in the background.\n", - "\n", - "Below we define some $x$- and $y$-coordinates to be plotted: " - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "# Create x- and y-coordinates for f(x) = x^2 \n", - "x = [i for i in range(-100, 105, 5)]\n", - "y = [i**2 for i in x]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Once the coordinates are there, creating a simple line plot is easy:" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAD8CAYAAACcjGjIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3Xl8VOW9x/HPL3sCISEQIISEsIYdgbCjooiAC+h1AdxwablWu129bvXeq9Xq1ba2aqtQKliwFtyvqChQdhQJAdkhZCUJCUkgkIQlZJnn/pGDHckGWebMZH7v12teM/PMOZkvZ4b8cs7znOeIMQallFLKmY/dAZRSSrkfLQ5KKaVq0OKglFKqBi0OSimlatDioJRSqgYtDkoppWrQ4qCUUqoGLQ5KKaVq0OKglFKqBj+7AzRWx44dTVxcnN0xlFLKY2zfvv2YMSbyYpb12OIQFxdHUlKS3TGUUspjiMjhi11WDysppZSqQYuDUkqpGrQ4KKWUqkGLg1JKqRq0OCillKqhweIgIotEpEBE9jq1RYjIahFJse7bW+0iIq+LSKqI7BaR4U7rzLGWTxGROU7tI0Rkj7XO6yIizf2PVEopdWkuZs/hb8DUC9qeBNYYY/oAa6znANOAPtZtLjAPqosJ8AwwGhgFPHO+oFjLzHVa78L3Ukop5WINFgdjzEag6ILmGcBi6/Fi4Can9iWm2rdAuIhEAVOA1caYImPMCWA1MNV6rZ0xZoupvl7pEqef1ezKKqpYsDGNb9KOtdRbKKVUi1l3sIBFmzMor3S0+Hs1ts+hszEmD8C672S1RwPZTsvlWG31tefU0l4rEZkrIkkiklRYWHjJof18hLc2ZbBwU8Ylr6uUUnabtyGNJVsy8fdt+aPvzd0hXVti04j2WhljFhhjEowxCZGRF3UG+A/4+fpwW0I31iUXkFd89pLXV0opu6QVniIxo4iZI2NxRddsY4tDvnVICOu+wGrPAWKclusG5DbQ3q2W9hYzMyEWh4EPknIaXlgppdzEe9uy8fMRbh3RreGFm0Fji8Ny4PyIoznAp07t91ijlsYAxdZhp5XAtSLS3uqIvhZYab1WKiJjrFFK9zj9rBYR2yGECb078t62bKocde6kKKWU2zhXWcWH23O4pn9nIkMDXfKeFzOUdSmwBYgXkRwReQB4CZgsIinAZOs5wAogHUgF/go8BGCMKQKeB7ZZt+esNoCfAG9Z66QBXzbPP61us0bFcOTkWTalXHq/hVJKudrq/fkUnS5n1qiYhhduJg3OymqMmV3HS5NqWdYAD9fxcxYBi2ppTwIGNZSjOU0e0JmINgEsS8xmYnynhldQSikbLUvMJjo8mMv7XHpfa2N55RnSgX6+3DI8mn8eyKew9JzdcZRSqk5Zx8+wOfUYtyfE4OvjunOEvbI4AMwcGUulw/Dhdu2YVkq5r/eSsvARuH2kazqiz/Pa4tC7U1tGxUXw3rYsqo+GKaWUe6mscvBBUg4T4zsRFRbs0vf22uIA1R3TmcfPsCX9uN1RlFKqhrUHCygoPceska7riD7Pq4vDdYOjaBfkx7LE7IYXVkopF1u2LZtOoYFc3c/1A2e8ujgE+fty87Bovtp7lBOny+2Oo5RS38srPsv65AJuS+iGn6/rf1V7dXEAmD06lvIqBx9/d8TuKEop9b33t+XgMDBrZKwt7+/1xaFfl3ZcFhPOskTtmFZKuYcqh+H9pGwu79ORmIgQWzJ4fXEAmD0qhpSCU+zIOmF3FKWUYlNKIUdOnrVtrwG0OABww5CutAnwZal2TCul3MCyxGw6tAlg8oDOtmXQ4gC0CfRj+mXRfL47l+KzFXbHUUp5sYLSMv55IJ9bRnQjwM++X9FaHCyzR8VQVuFg+U7tmFZK2efD7TlUOgwzbTi3wZkWB8vg6DAGRLVjaWK2dkwrpWzhcBje25bNqB4R9Ipsa2sWLQ4WEWH2qBj255WwK6fY7jhKKS+0Jf04h4+fYbYLp+auixYHJzcNi6ZNgC/vbDlsdxSllBdasiWTiDYBTBsUZXcULQ7OQoP8uXl4NJ/tztUzppVSLpVXfJbV+/O5PSGGIH9fu+NocbjQ3WPiKK908H6SDmtVSrnOP7ZmYYA7R9t3boMzLQ4XiO8SyqgeEfx962Eceo1ppZQLlFc6WJqYzdXxnWw7I/pCWhxqcfeY7mQXnWXDIb3GtFKq5X217yjHTp3jrrHd7Y7yPS0OtZgysAuRoYG88612TCulWt7ftxwmNiKEK114jeiGaHGoRYCfD7NHxrAuuYDsojN2x1FKtWIHj5aQmFnEXWNi8XHhNaIbosWhDrNHx+Ijwt+36t6DUqrlvLPlMIF+Ptw2wv5zG5xpcahDVFgwk/t35v1t2ZRVVNkdRynVCpWWVfDJd0e4cWhX2rcJsDvOD2hxqMc9Y7tz4kwFX+zOszuKUqoV+njHEc6UV3GPG3VEn6fFoR5je3WgV2Qb7ZhWSjU7YwzvfHuYod3CGNIt3O44NWhxqIeIcPeY7uzMPskenW9JKdWMtqQfJ7XgFHePjbM7Sq20ODTg30Z0IyTAl3e+zbQ7ilKqFfn7t4cJD/HnhiH2z6NUGy0ODWgX5M9Nw6L5dGcuJ8/ofEtKqaY7WlzGyn35zHSTeZRqo8XhItw9pjvnKh18uD3H7ihKqVZgaWIWDmO4c7T7dUSfp8XhIvSPasfIuPa8863Ot6SUapqKKgdLE7OY2DeS2A7uMY9SbZpUHETkP0Rkn4jsFZGlIhIkIj1EZKuIpIjIeyISYC0baD1PtV6Pc/o5T1ntySIypWn/pJZx15juHD5+hk2px+yOopTyYKv25VNQeo673XD4qrNGFwcRiQZ+DiQYYwYBvsAs4GXgj8aYPsAJ4AFrlQeAE8aY3sAfreUQkQHWegOBqcCbIuJ2B+GmDYqiY9sAlnyTaXcUpZQHW7wlk5iIYK7s28nuKPVq6mElPyBYRPyAECAPuBr40Hp9MXCT9XiG9Rzr9UkiIlb7MmPMOWNMBpAKjGpirmYX4OfDHaO7sza5gIxjp+2Oo5TyQHuPFJOYUcTdY7rj60bzKNWm0cXBGHME+D2QRXVRKAa2AyeNMZXWYjlAtPU4Gsi21q20lu/g3F7LOm7lrjGx+Pv48LevM+yOopTyQIu+ziAkwJeZI93jgj71acphpfZU/9XfA+gKtAGm1bLo+R7c2sqkqae9tvecKyJJIpJUWOj6ay10Cg3ixqFd+WB7DsVnK1z+/kopz1VQUsZnu3K5PSGGsGB/u+M0qCmHla4BMowxhcaYCuBjYBwQbh1mAugG5FqPc4AYAOv1MKDIub2WdX7AGLPAGJNgjEmIjLRn3vP7J8RxpryKZYlZtry/UsozvfPtYSodhnvHxdkd5aI0pThkAWNEJMTqO5gE7AfWAbday8wBPrUeL7eeY72+1hhjrPZZ1mimHkAfILEJuVrUwK5hjOkZweJvMqmsctgdRynlAcoqqnh3axaT+nUmrmMbu+NclKb0OWylumN5B7DH+lkLgCeAR0Qkleo+hYXWKguBDlb7I8CT1s/ZB7xPdWH5CnjYGOPWc2Q/MKEnucVlfLXvqN1RlFIe4P++O0LR6XIemNDD7igXTar/ePc8CQkJJikpyZb3rnIYrn5lPRFtAvjkofG2ZFBKeQZjDFNe3Yivjw8rfj6B6gMt9hCR7caYhItZVs+QbgRfH+G+cXF8l3WSHVkn7I6jlHJjm1OPcSj/FA9M6GFrYbhUWhwa6baEGEKD/Fi0WYe1KqXqtnBzBh3bBnLjUPecfbUuWhwaqU2gH7NGxvDl3qMcOXnW7jhKKTeUWlDK+uRC7h7TnUA/t5v4oV5aHJpgzrg4jDEs2ZJpdxSllBt6++tMAvx8uHOM+5/0diEtDk3QrX0I0wZFsXRrFqfPVTa8glLKa5w4Xc5HO3K4+bJoOrYNtDvOJdPi0ET3T4ijpKySj3botR6UUv/yj8Qsyioc3Dchzu4ojaLFoYmGx7ZnaEw4b3+dqdd6UEoB1ddsWLIlkwm9O9KvSzu74zSKFocmEhEemNCDjGOnWZdcYHccpZQbWLEnj/yScx510tuFtDg0g2mDuhAVFsRCHdaqlNczxrBwcwY9I9twZV975oBrDlocmoG/rw/3jI3jm7Tj7M8tsTuOUspGSYdPsDunmPvG98DHza/ZUB8tDs3kjlGxhAT48tdN6XZHUUrZ6C8b0gkP8eeW4W55WZqLpsWhmYSF+DN7VCzLd+WSc+KM3XGUUjZIyS/lnwfymTM2jpAAv4ZXcGNaHJrRAxN6IMBbm7TvQSlvNH9DOkH+PszxkGs21EeLQzPqGh7MTcOiWbYti6LT5XbHUUq5UO7Js3y68wizRsYS0SbA7jhNpsWhmT14ZU/KKhws/ibT7ihKKRdauDkDA/zocs8dvupMi0Mz690plMkDOrN4SyZnynVKDaW8wckz5SxNzGLG0K50ax9id5xmocWhBTx4ZS9OnqlgWWK23VGUUi6wZMthzpRX8e9X9rI7SrPR4tACRnRvz6geEby1KZ0Kvc60Uq3a2fIq/vZNJpP6dSK+S6jdcZqNFocW8pMre5FbXMbynbl2R1FKtaD3k7IpOl3OgxNbz14DaHFoMRPjI+nXJZT5G9J0Qj6lWqmKKgcLNqaT0L09I+Mi7I7TrLQ4tBAR4cEre5FScIq1B3VCPqVaoy9253Hk5FkebEV9DedpcWhBNwyJIjo8mHkb0uyOopRqZsYY5m9Io0+ntlzdr5PdcZqdFocW5Ofrw9wrerL98Am2ZRbZHUcp1YzWJxdy8GgpD17Zy6Mn2KuLFocWdntCDBFtApi/XvcelGpN5m1Io2tYENMv62p3lBahxaGFBQf4cu+4ONYcLCD5aKndcZRSzWD74RMkZhTxo8t74u/bOn+Nts5/lZu5Z2x3QgJ8+Yv2PSjVKszfkEZ4iD+zRsXYHaXFaHFwgfCQAGaPiuXTXblkHdfpvJXyZAePlrB6fz73tIJpueujxcFF5l7RE18f4Y11qXZHUUo1wZ/WpNI20I/7x8fZHaVFaXFwkc7tgrhjVCwf7cghu0j3HpTyRIfyS1mxN497x8URHuL503LXR4uDCz14ZS98RHhzve49KOWJXl+TQoi/Lw9MaB3TctdHi4MLdQkLYtaoGD5I0r0HpTxNSn4pX+zJY864ONq3gov5NKRJxUFEwkXkQxE5KCIHRGSsiESIyGoRSbHu21vLioi8LiKpIrJbRIY7/Zw51vIpIjKnqf8od/aTief3HnTkklKe5PW1qYT4+/Kjy3vaHcUlmrrn8BrwlTGmHzAUOAA8CawxxvQB1ljPAaYBfazbXGAegIhEAM8Ao4FRwDPnC0prFBUWzMyRMXy4PZsjJ8/aHUcpdRFSC0r5fHcu94yLaxWXAL0YjS4OItIOuAJYCGCMKTfGnARmAIutxRYDN1mPZwBLTLVvgXARiQKmAKuNMUXGmBPAamBqY3N5gp9YU/u+qSOXlPIIf1qbSrC/Lz/2kr0GaNqeQ0+gEHhbRL4TkbdEpA3Q2RiTB2Ddn5+RKhpwvjRajtVWV3sNIjJXRJJEJKmwsLAJ0e3VNTyY2xNieD8pm1zde1DKraUVnuKzXbncPba71+w1QNOKgx8wHJhnjBkGnOZfh5BqU9vMVKae9pqNxiwwxiQYYxIiIyMvNa9beeiq3gDM074Hpdzan9emEujny1wv2muAphWHHCDHGLPVev4h1cUi3zpchHVf4LS887nm3YDcetpbtejwYG4dEcN727LJK9a9B6XcUXrhKT7deYS7x3anQ9tAu+O4VKOLgzHmKJAtIvFW0yRgP7AcOD/iaA7wqfV4OXCPNWppDFBsHXZaCVwrIu2tjuhrrbZW76GJvXAYozO2KuWm/rwulQA/H6/qazivqROD/Ax4V0QCgHTgPqoLzvsi8gCQBdxmLbsCuA5IBc5Yy2KMKRKR54Ft1nLPGWO84uIHMREh3JbQjaXbsvnJxN50CQuyO5JSypJ57DSf7szl/vFxRIZ6114DNLE4GGN2Agm1vDSplmUN8HAdP2cRsKgpWTzVQxN780FSDvM3pPHs9IF2x1FKWf60NhV/X2HuFa3vEqAXQ8+QtllMRAi3DO/GPxKzyC8pszuOUgo4fPw0/7fzCHeO7u6Vew2gxcEtPHxVb6ocRkcuKeUm/rQ2FT8f4d+v9L6+hvO0OLiB2A4h3J7QjX9szdI5l5SyWUp+KR/vyOGesd3pFOq9/YBaHNzEzyf1QQRe/WeK3VGU8mq/X5VMmwA/HprY2+4ottLi4CaiwoK5d1wcH3+Xo9eaVsom32WdYOW+fOZe0dMrZl6tjxYHN/KTib1oG+jH71cl2x1FKa9jjOHlrw7SsW0A93vB9RoaosXBjYSHBPDglb1YvT+f7YdP2B1HKa+yKeUY36YX8bOr+9AmsPVeG/piaXFwM/eNj6Nj20Be/uog1aeGKKVamsNh+O3Kg3RrH8zsUbF2x3ELWhzcTEiAH7+Y1JvEjCI2HPLcmWeV8iQr9uax90gJj17blwA//bUIWhzc0syRscREBPPbr5JxOHTvQamWVFHl4JVVh4jvHMr0obVeLcAraXFwQwF+Pjw6OZ79eSV8vifP7jhKtWofJOWQcew0j02Jx9entisIeCctDm5q+tCu9OsSyiurkqmoctgdR6lW6Wx5Fa+tOcSI7u2Z1L9Twyt4ES0ObsrHR3h8ajyHj5/hvW3ZDa+glLpki7dkkl9yjiem9kNE9xqcaXFwY1fFd2JkXHteW5PC2fIqu+Mo1aoUn6ngzXWpXBUfyageEXbHcTtaHNyYiPD41H4Ulp7j7W8y7I6jVKvyl41plJRV8tiUfnZHcUtaHNzcyLgIJvXrxLz1aZw8U253HKVahYKSMhZ9ncGMy7oyoGs7u+O4JS0OHuCxqfGcPlfJa2t0Uj6lmsPvViZT5TA8Mrmv3VHclhYHD9CvSztmjozlnS2HSS04ZXccpTzanpxiPtyRw33je9C9Qxu747gtLQ4e4tFr+xLk78uLKw7YHUUpj2WM4fnP9xMREsBPr/buKbkbosXBQ3RsG8jPru7N2oMFOq2GUo305d6jJGYW8ci1fWkX5G93HLemxcGD3Ds+jtiIEH7z+X4q9cQ4pS5JWUUVL644QL8uocxMiLE7jtvT4uBBAv18+dV1/UkpOMXSxCy74yjlURZ9nUHOibP89w0D8PPVX30N0S3kYaYM7MyYnhH8YfUhis9U2B1HKY9QUFrGG2tTuaZ/Z8b37mh3HI+gxcHDiAj/fcMATp6t4PW1OrRVqYvxyspDlFc5ePr6/nZH8RhaHDzQwK5hzEyIYfE3maQX6tBWpeqz90gx72/PZs7YOHp01KGrF0uLg4d69Np4HdqqVAPOD10ND/bnZ5P62B3Ho2hx8FCRoYE8fFVv/nmggE0pOrRVqdqs3HeUrRlFPHJtPGHBOnT1Umhx8GD3jY8jJiKY33x+QIe2KnWBc5VVvLDiAH07t2X2SB26eqm0OHiwIH9ffjWtP8n5pSzTaz4o9QNvf51JdpEOXW0s3WIebuqgLozuEcHvVyVTdFpnbVUKIK/4LH9ak8Kkfp24vE+k3XE8UpOLg4j4ish3IvK59byHiGwVkRQReU9EAqz2QOt5qvV6nNPPeMpqTxaRKU3N5E1EhOdmDOJUWSX/q53TSgHw3Gf7qXQYnrlxoN1RPFZz7Dn8AnD+rfQy8EdjTB/gBPCA1f4AcMIY0xv4o7UcIjIAmAUMBKYCb4qIbzPk8hrxXUJ54PIefLA9h8SMIrvjKGWrdQcL+HLvUX52dW9iO4TYHcdjNak4iEg34HrgLeu5AFcDH1qLLAZush7PsJ5jvT7JWn4GsMwYc84YkwGkAqOakssb/WJSH6LDg/mv/9tDeaV2TivvdLa8iv9ZvpdekW348RU97Y7j0Zq65/Aq8Dhw/rdRB+CkMabSep4DRFuPo4FsAOv1Ymv579trWUddpJAAP349fSCH8k+xcLNeUlR5pz+vSyG76Cy/uWkwgX56AKIpGl0cROQGoMAYs925uZZFTQOv1bfOhe85V0SSRCSpsFDH9l/omgGdmTygM6+tOUR20Rm74yjlUqkFpSzYmM6/DYtmbK8OdsfxeE3ZcxgPTBeRTGAZ1YeTXgXCRcTPWqYbkGs9zgFiAKzXw4Ai5/Za1vkBY8wCY0yCMSYhMlJHINTm2ekDEYRnl+/DmFprrFKtjjGGpz/ZS7C/L7/S+ZOaRaOLgzHmKWNMN2NMHNUdymuNMXcC64BbrcXmAJ9aj5dbz7FeX2uqf3stB2ZZo5l6AH2AxMbm8nbR4cH8x+Q+rDlYwKr9+XbHUcolPt5xhK0ZRTw5rT8d2wbaHadVaInzHJ4AHhGRVKr7FBZa7QuBDlb7I8CTAMaYfcD7wH7gK+BhY0xVC+TyGveN70F851B+vXwfp89VNryCUh7s5JlyXlxxgGGx4czSM6GbTbMUB2PMemPMDdbjdGPMKGNMb2PMbcaYc1Z7mfW8t/V6utP6Lxhjehlj4o0xXzZHJm/m7+vDCzcPIre4jNfW6LTeqnV7+atkTp6t4IWbBuPjU1sXpmoMPUO6lUqIi2DWyBgWbs7g4NESu+Mo1SK2Hz7B0sQs7hsXx4Cu7eyO06pocWjFnpjaj7Bgf57+ZC8Oh3ZOq9alssrB05/sISosiF9O7mt3nFZHi0Mr1r5NAE9N61f919U2vea0al2q94pLeebGAbQN9Gt4BXVJtDi0creO6Ma4Xh148YsD5JzQcx9U65BacIpXVh9i8oDOTBnYxe44rZIWh1ZORHj5liEAPPHRbj33QXm8KofhPz/YRUiALy/cPIjqWXhUc9Pi4AViIkL41fX9+Tr1OO9u1cNLyrP9dVM6O7NP8uvpA+kUGmR3nFZLi4OXuGNULBN6d+TFFQd0ag3lsVILSvnD6kNMHdiF6UO72h2nVdPi4CVEhJdvHYKPCI9/uFtHLymPU1nl4NEPdtMmwJfnb9LDSS1Ni4MXiQ4P5unr+7Ml/Tjvbj1sdxylLsmCTensyj7JczMGERmqU2S0NC0OXmbWyBgu79ORF1ccJOu4Hl5SnuFQfimvrk7husFduGFIlN1xvIIWBy9zfvSSn4/w2Ie79PCScnuVVQ7+84NdtA3y47kZejjJVbQ4eKGu4cH81w392ZpRxDvf6uEl5d7+sjGd3TnFPD9jkM646kJaHLzU7QkxXNk3kpe+PMjh46ftjqNUrZKPlvLqPw9x/ZAortfDSS6lxcFLiQgv3TIYP1/hsQ92U6WHl5SbqbAOJ7UL8ue56QPtjuN1tDh4saiwYJ65cSCJmUXMW59qdxylfuCVVYfYc6SYF24eRAc9nORyWhy83C3Do5k+tCt//GcK2zKL7I6jFAAbDxUyf0Mad4yOZeogPZxkBy0OXk5EeOHmQUSHB/OLpd9x8ky53ZGUlysoLeOR93cS3zmU/7lhgN1xvJYWB0VokD9/vmMYhafO6eR8ylYOh+GR93Zx6lwlf7pjGEH+vnZH8lpaHBQAQ7qF88TUfqzcl8/fdXirssn8jWlsTj3GszcOpG/nULvjeDUtDup794/vwcT4SJ7/4gD7c/XSosq1th8+wSurqoetzhwZY3ccr6fFQX3Px0f4/W1DCQ/252dLd3CmvNLuSMpLFJ+t4OdLvyMqLIj//bfBeha0G9DioH6gY9tAXp15GenHTvPs8n12x1FewBjDkx/tJr+kjD/NHka7IH+7Iym0OKhajOvdkYcn9ub9pBw+3XnE7jiqlftHYhZf7j3Kf06JZ1hse7vjKIsWB1WrX17Th4Tu7Xn6k706vYZqMclHS3nus/1c3qcjcy/vaXcc5USLg6qVn68Pr80eho/Ag3/X/gfV/IrPVvCTv28nNMifP9x+GT4+2s/gTrQ4qDpFhwfz2uxhHDxawuMf6vkPqvlUOQy/XPYdWUVneOOOYXrxHjekxUHV66r4Tjw+pR+f785j3oY0u+OoVuKVVcmsSy7kmekDGd2zg91xVC20OKgGPXhlT24c2pXfrUxm7cF8u+MoD/fZrlzeXJ/G7FGx3DU61u44qg5aHFSDRITf3jKEAVHt+MXSnaQVnrI7kvJQ+3KLeezDXSR0b8+vpw/U8xncmBYHdVGCA3xZcE8CAX4+/HhJEiVlFXZHUh7m+KlzzF2ynfYhAcy7awQBfvrrx53pp6MuWnR4MG/eOZys42f45bKdeoEgddEqqhw89O4Ojp06x1/uHqEd0B6g0cVBRGJEZJ2IHBCRfSLyC6s9QkRWi0iKdd/eahcReV1EUkVkt4gMd/pZc6zlU0RkTtP/WaqljO7ZgWemD2TtwQJeWZVsdxzlIZ7/fD9bM4p46ZbBDOkWbnccdRGasudQCTxqjOkPjAEeFpEBwJPAGmNMH2CN9RxgGtDHus0F5kF1MQGeAUYDo4BnzhcU5Z7uGh3L7FExvLk+jc925dodR7m5ZYlZLNlymB9f3oObh3WzO466SI0uDsaYPGPMDutxKXAAiAZmAIutxRYDN1mPZwBLTLVvgXARiQKmAKuNMUXGmBPAamBqY3Oplici/Hr6IBK6t+exD3exK/uk3ZGUm9qafpz//nQvl/fpyBNT+9kdR12CZulzEJE4YBiwFehsjMmD6gICdLIWiwaynVbLsdrqaq/tfeaKSJKIJBUWFjZHdNVIAX4+zLtrBB3bBnLf37aRriOY1AUO5JXwoyVJxEaE8KfZw/Dz1S5OT9LkT0tE2gIfAb80xtR3EYDaxqyZetprNhqzwBiTYIxJiIyMvPSwqllFhgay5P5RANyzKJGCkjKbEyl3kV10hjmLEmkT4MeSB0YTHhJgdyR1iZpUHETEn+rC8K4x5mOrOd86XIR1X2C15wDOV/DoBuTW0648QM/Itrx970iKTpcz5+1tOsRVVX8XFiVSVlHF4vtHER0ebHck1QhNGa0kwELggDHmD04vLQfOjziaA3zq1H6PNWppDFBsHXZaCVwrIu2tjuhrrTblIYbGhDP/rhGk5Jcyd0kSZRVVdkdSNjl9rpL7/raNIyfPsvDekcR30Ut9eqqm7DmMB+4GrhaRndbtOuAlYLKIpACTrecAK4B0IBX4K/AQgDGmCHge2GbdnrPZ/vP3AAAOcElEQVTalAe5om8kr9w+lG/Ti/iP9/QcCG9UUeXgJ+/uYE/OSf58x3BGxkXYHUk1gXjqTJsJCQkmKSnJ7hjqAgs3Z/D85/u5a0wsz88YpNMjeAmHw/DoB7v45LsjvHzLYGaO1DmT3JGIbDfGJFzMsn4tHUZ5lwcm9KCw9BzzN6TRKTSIn0/qY3ck5QIvfXWQT747wmNT4rUwtBJaHFSze2JqPIWl5/jD6kN0aBvAnaO72x1JtaAFG9NYsDGde8fF8dDEXnbHUc1Ei4NqdiLCS7cM5uSZcp7+ZC+CcIdOzdwq/XVjOi+uOMgNQ6L4nxsG6GHEVkTPSlEtwt/XhzfuHM7V/Trxq0/2sPibTLsjqWb2xrpUXlhxgOuHRPHHmXqZz9ZGi4NqMUH+vsy/awTXDujMM8v38deN6XZHUs3AGMMfVx/idyuTuXlYNK/NvAx/Pfu51dFPVLWoAL/qPYjrh0TxwooDvLEu1e5IqgmMMfx2ZTKvrUnhthHd+P1tQ3VajFZK+xxUi/P39eG1mZcR4OvD71YmU17p4JfX9NHj0x7GGMNvvjjAws0Z3Dm6eqiyHkpqvbQ4KJfw8/Wp/ivTR3htTQrlVQ4enxKvBcJDOByGZz/bx5Ith7l3XBzP3Kidz62dFgflMr4+wsu3DMHfz4d569Mor3TwX9f3118ybs7hMPzqkz0s25bN3Ct68tS0fvqZeQEtDsqlfHyEF24aRICvDws3Z1BytoIXbh6s1xN2U2UVVTz6wS6+2J3HT6/qzaPX9tXC4CW0OCiXExGeuXEA7YL9eX1NCllFZ5h/1wjat9Fpnd1JQWkZP16ynd05J3lqWj/+/Uo9wc2b6J9ryhYiwiOT+/LqzMv4LuskN7/5NWl6wSC3cSCvhJv+/DWHjpYy/64RWhi8kBYHZaubhkWzdO5oSssqufmNr/k69ZjdkbzemgP53DrvG6qM4YMHxzJlYBe7IykbaHFQthvRPYL/e3g8ndsFMWdRIksTs+yO5JWMMby1KZ0fLUmiR2QbPn14AoOiw+yOpWyixUG5hZiIED56aBzje3fkqY/38JvP9+s1IVyoosrBrz7Zy2++OMCUAV14/9/H0iUsyO5YykZaHJTbaBfkz8I5Cdw7Lo63Nmcwd0kSJ8+U2x2r1Tt26hz3vl29x/bQxF68eedwQgJ0rIq30+Kg3Iqfrw/PTh/I8zMGsuFQIdNe28SWtON2x2q11iUXMPXVjWzLPMHvbh3C41P76VnPCtDioNzU3WPj+OSh8QT7+3LHW9/y8lcHKa902B2r1SirqOLZ5fu47+1tdGgTyGc/ncBtCTF2x1JuRIuDcluDu4Xx+c8nMDMhhnnr07h1/jdkHDttdyyPl3y0lJve+Jq/fZPJvePi+PSn44nvEmp3LOVmtDgotxYS4MdLtwxh3p3DOXz8DNe/von3t2Xjqdc+t5MxhsXfZHLjnzdz7NQ53r5vJM9OH0iQv6/d0ZQb0l4n5RGmDY7isthwHnlvF49/tJv1hwp48ebBhIfoWdUX49ipczz+4W7WHizgqvhIfnvrUCJDA+2OpdyYFgflMaLCgvn7j0azYGM6r6xKZmt6EY9Niee2hBh8tRO1VpVVDt7dmsUrq5Ipq3Tw7I0DmDMuTudHUg0ST909T0hIMElJSXbHUDbZl1vMM5/uI+nwCQZHh/Hs9AGM6B5hdyy38k3qMX792X6S80sZ37sDz944kD6dtW/Bm4nIdmNMwkUtq8VBeSpjDMt35fK/Kw5ytKSMm4dF8+S0fnRu590nb+WcOMOLKw6wYs9RurUP5r+u78+UgV10b0FdUnHQw0rKY4kIMy6L5pr+nXlzfSp/3ZjByn1H+dnVfbh/QhyBft7V0Xq2vIr5G9KYvyENEXhkcl/mXtFTO5xVo+ieg2o1Dh8/zW++OMDq/fnEdQjhoat6M+Oyrq2+SJRVVPHRjhzeXJfGkZNnuXFoV56a1o+u4cF2R1NuRg8rKa+28VAh//vlQQ7kldApNJB7x8dx5+juhAX72x2tWRWdLuedLYdZsiWT46fLGdotjF9d15/RPTvYHU25KS0OyusZY9iceowFG9PZlHKMNgG+zBwZy/0T4ujWPsTueE2Seew0Czdn8MH2bMoqHEzq14kfX9GT0T0itF9B1UuLg1JO9ueW8NamdJbvysUA1w+O4t7xcQyLCfeYX6YOhyHp8AkWbc5g5f6j+Pv4cPOwaH50eQ8dgaQumhYHpWqRe/Isf/smk39szeLUuUqiw4OZMrAL0wZ3YURse7ebcK6yysG2zBN8tTePr/YdJb/kHGHB/tw1JpY5Y+Po5OWjstSl88jiICJTgdcAX+AtY8xL9S2vxUE1VklZBav25fPlnjw2pRyjvMpBZGggUwZ2ZtqgKEb3iMDP156ZZcorHWxJP85Xe/NYtS+f46fLCfTzYWJ8JNMGRTF5QGfaBOogQ9U4HlccRMQXOARMBnKAbcBsY8z+utbR4qCaQ2lZBWsPFvDV3qOsTy7kbEUV7UP8GRkXwaDoMAZFt2NQ17AW+SvdGMPRkjL2Hilh75Fi9uWWkJhxnJKyStoE+HJ1/85MG9SFifGRen0F1Sw88TyHUUCqMSYdQESWATOAOouDUs0hNMifGZdFM+OyaM6WV7HhUAGr9uWzM/skq/bnf79cZGggg7q2Y1B0GH07hxLRJoCwYH/Cgv1pF+RPaJBfjcNSVQ7DqbJKis9WUHy2gpKyCo6fLudgXgl7c0vYd6SY46erL2YkAr0i23LtwC5MGdiFy/t01PMTlK3cpThEA9lOz3OA0TZlUV4qOMCXqYOimDooCqjeqziQV8reI8XszS1m35ESNhwqpLarl4pAaKAf7YL9Mab60NWpc5XUtmPu5yP06RzK1f06fb930q9LOz1cpNyKu3wba+sJrPHfSkTmAnMBYmNjWzqT8nKhQf6M6hHBqB7/mrOprKKKjGOn/7U34HRfYu0lCNAu2J923+9Z+FXfB/sTHuJPXIc2uleg3J67FIccwPkyVN2A3AsXMsYsABZAdZ+Da6Ip9S9B/r70j2pndwylWpy7XOxnG9BHRHqISAAwC1hucyallPJabrHnYIypFJGfAiupHsq6yBizz+ZYSinltdyiOAAYY1YAK+zOoZRSyn0OKymllHIjWhyUUkrVoMVBKaVUDVoclFJK1aDFQSmlVA1uMfFeY4hIIXC4kat3BI41Y5zmorkujea6NJrr0rTGXN2NMZEXs6DHFoemEJGki52Z0JU016XRXJdGc10ab8+lh5WUUkrVoMVBKaVUDd5aHBbYHaAOmuvSaK5Lo7kujVfn8so+B6WUUvXz1j0HpZRS9WjVxUFEbhORfSLiEJGEC157SkRSRSRZRKY4tU+12lJF5EkXZHxPRHZat0wR2Wm1x4nIWafX5rd0lgtyPSsiR5ze/zqn12rddi7K9TsROSgiu0XkExEJt9pt3V5WBpd+d+rJESMi60TkgPX9/4XVXudn6uJ8mSKyx8qQZLVFiMhqEUmx7tu7OFO803bZKSIlIvJLO7aZiCwSkQIR2evUVuv2kWqvW9+53SIyvNmCGGNa7Q3oD8QD64EEp/YBwC4gEOgBpFE9Vbiv9bgnEGAtM8CFeV8B/sd6HAfstXHbPQv8Zy3ttW47F+a6FvCzHr8MvOwm28vW784FWaKA4dbjUOCQ9bnV+pnakC8T6HhB22+BJ63HT57/XG38LI8C3e3YZsAVwHDn73Nd2we4DviS6qtpjgG2NleOVr3nYIw5YIxJruWlGcAyY8w5Y0wGkAqMsm6pxph0Y0w5sMxatsWJiAC3A0td8X5NUNe2cwljzCpjTKX19FuqrxroDmz77lzIGJNnjNlhPS4FDlB9nXZ3NgNYbD1eDNxkY5ZJQJoxprEn2TaJMWYjUHRBc13bZwawxFT7FggXkajmyNGqi0M9ooFsp+c5Vltd7a5wOZBvjElxaushIt+JyAYRudxFOZz91NpVXeS0m2/nNrrQ/VT/1XSendvLnbbL90QkDhgGbLWaavtMXc0Aq0Rku1RfFx6gszEmD6qLG9DJpmxQfSVK5z/S3GGb1bV9Wux75/HFQUT+KSJ7a7nV91eb1NJm6ml3RcbZ/PALmQfEGmOGAY8A/xCRZr14cQO55gG9gMusLK+cX62WH9WsQ94uZnuJyNNAJfCu1dTi26uh2LW02ToUUETaAh8BvzTGlFD3Z+pq440xw4FpwMMicoVNOWqQ6ssUTwc+sJrcZZvVpcW+d25zJbjGMsZc04jVcoAYp+fdgFzrcV3tjdZQRhHxA/4NGOG0zjngnPV4u4ikAX2BpKbmudhcTvn+CnxuPa1v27kkl4jMAW4AJhnrwKsrtlcDWny7XAoR8ae6MLxrjPkYwBiT7/S682fqUsaYXOu+QEQ+ofqQXL6IRBlj8qzDIgV2ZKO6YO04v63cZZtR9/Zpse+dx+85NNJyYJaIBIpID6APkAhsA/qISA/rL4hZ1rIt7RrgoDEm53yDiESKiK/1uKeVMd0FWc6/v/Nxy5uB8yMn6tp2rso1FXgCmG6MOePUbuv2wr7vTg1W/9VC4IAx5g9O7XV9pq7M1kZEQs8/pnqAwV6qt9Uca7E5wKeuzmb5wR68O2wzS13bZzlwjzVqaQxQfP7wU5O5shfe1TeqP8wcqv+izAdWOr32NNWjS5KBaU7t11E9uiMNeNpFOf8GPHhB2y3APqpHvewAbnTxtnsH2APstr6AUQ1tOxflSqX6GOtO6zbfHbaXXd+dOnJMoPrQwm6n7XRdfZ+pC7P1tD6jXdbn9bTV3gFYA6RY9xE2ZAsBjgNhTm0u32ZUF6c8oML6/fVAXduH6sNKb1jfuT04jcps6k3PkFZKKVWDtx5WUkopVQ8tDkoppWrQ4qCUUqoGLQ5KKaVq0OKglFKqBi0OSimlatDioJRSqgYtDkoppWr4f40GFXJlwWMMAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Create basic plot\n", - "plt.plot(x, y)\n", - "\n", - "# Show plot\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Given a list of data for `x` and `y`, a line graph can be produced in a single command `plt.plot(x,y)`, while actually showing the plot has its own command. \n", - "\n", - "It might seem wierd that the `plt.show()` is needed, but it is not always desired to have the plot shown. Sometimes it is desired to produce the graph and have it saved to a png-file or do something else with it instead of showing it. \n", - "For more complex plots there might be many different plotting commands to build the plot, but only a single showing command is needed at the end. " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Customization of graphs\n", - "The plot of $f(x)=x^2$ from above can be made much nicer by a little customization. The command names should make the code self-explanatory." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.title('Graph for $f(x) = x^2$', fontsize=16)\n", - "plt.xlabel('$x$', fontsize=14)\n", - "plt.ylabel('$f(x)$', fontsize=14)\n", - "plt.plot(x, y, '.-', color='limegreen', markersize=6)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Plotting multiple graphs in the same plot\n", - "It is possible to plot many graphs in the same plot. It can also be styled with a grid and a legend:" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Create x-coordinates for graphs \n", - "x = [i for i in range(-10, 10, 1)]\n", - "\n", - "# Produce y-values for different graphs\n", - "y1 = [i**2 for i in x] # f(x) = x^2\n", - "y2 = [10*i**2 for i in x] # f(x) = 10x^2\n", - "y3 = [i**3 for i in x] # f(x) = x^3\n", - "y4 = [2*i**3 for i in x] # f(x) = 2x^3\n", - "\n", - "# Create plots with legend labels for each graph\n", - "plt.plot(x, y1, label='$f(x)=x^2$')\n", - "plt.plot(x, y2, label='$f(x)=10x^2$')\n", - "plt.plot(x, y3, label='$f(x)=x^3$')\n", - "plt.plot(x, y4, label='$f(x)=2x^3$')\n", - "\n", - "# Set titles, grid and legend\n", - "plt.title('Different graphs', fontsize=16)\n", - "plt.xlabel('$x$', fontsize=14)\n", - "plt.ylabel('$y$', fontsize=14)\n", - "plt.grid(linestyle=':')\n", - "plt.legend(fontsize=14)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "> * Graphs are automatically colorized, but this can of course be customized.\n", - "> * Legend will by default try to position itself so it does not overlap with the graphs, but it can be forced into a certain position if need be. " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Fill between\n", - "Plot areas can be filled based on conditions. \n", - "\n", - "The code in the next cell serves only to create dummy data for an example graph. " - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "# The code in this cell is just for creating a dummy graph\n", - "import numpy as np\n", - "x1 = np.linspace(1, 10, 100)\n", - "x2 = np.linspace(10, 15, 100)\n", - "x3 = np.linspace(15, 20, 100)\n", - "y1 = 2 * np.sin(1.98*x1)\n", - "y2 = 3 * np.sin(-x2)\n", - "y3 = 1 * np.sin(2.2 * x3)\n", - "y = np.append(np.append(y1, y2), y3)\n", - "x = np.append(np.append(x1, x2), x3)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Plotting this dummy graph and filling areas between the graph and $y=0$ with green color:" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Plot line graph in black\n", - "plt.plot(x, y, color='black', linewidth=1)\n", - "\n", - "# Put green/purple fill between the graph y=0\n", - "plt.fill_between(x, y, color='limegreen', alpha=.25)\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We can make differentiated colors by given a conditional statement in the keyword argument `where`:" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Plot line graph in black\n", - "plt.plot(x, y, color='black', linewidth=1)\n", - "\n", - "# Put green/purple fill between the graph y=0\n", - "plt.fill_between(x, y, where= y <= 0, color='limegreen', alpha=.25)\n", - "plt.fill_between(x, y, where= y > 0, color='darkorchid', alpha=.25)\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - " > **Note:** The sequences to be plotted has to be `numpy` arrays in order to make element wise comparison like `where= y > 0`. Trying this with standard Python lists will throw a `TypeError: '<' not supported between instances of 'list' and 'int'`. This is one of the many benefits of `numpy`. See a little more info about `numpy` later in this text." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Subplots\n", - "Creating subplots is also straight forward:" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Create a figure for holding subplots and set size\n", - "plt.figure(figsize=(14,3))\n", - "\n", - "# Create first plot as line plot\n", - "plt.subplot(131)\n", - "plt.plot([1, 2, 3, 4], [1, 2, 3, 4])\n", - "\n", - "# Create second plot as scatter plot\n", - "plt.subplot(132)\n", - "plt.plot([1, 2, 3, 4], [1, 2, 3, 4], '.', markersize=12)\n", - "\n", - "# Create third plot as bar plot\n", - "plt.subplot(133)\n", - "plt.bar([1, 2, 3, 4], [1, 2, 3, 4])\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "> * The `subplot` argument conatins three digits, where the first one is the number of rows, the second the number of columns and the third the current plot to manipulate. \n", - "> * For making more complicated grid formations, shared axis tick marks etc. The **Object Oriented API** should be used instead." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Object Oriented API\n", - "Almost every aspect of a visualization can be controlled. However, in order to access more complex controls, the way of interaction with the graph elements also becomes a little more complex. \n", - "\n", - "In order to use the more powerful `matplotlib` API, we get into so-called *Object Oriented Programming*. We access each element of a figure as an *object* and manipulate that object.\n", - "\n", - "The figure below gives an overview of the objects that can be controlled in a figure to enable very high customizability of plots.\n", - "\n", - "![title](matplotlib_objects_anatomy_of_a_figure.png)\n", - "\n", - "Source: [Anatomy of a figure](https://matplotlib.org/3.1.1/gallery/showcase/anatomy.html)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Subplots" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "* Note especially that the `Axes` object is the actual content of the plot, and therefore does not refer to `x`- or `y`-axis themselves.\n", - "\n", - "The Object Oriented API is recommended for more complex plotting like creation of larger grids of subplots where each plot needs independent adjustments. \n", - "\n", - "In the example below we still run the `plt.` command, but we save it to two variables `fig` and `ax`: " - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Create a 2 by 3 subplot grid with shared x- and y-axis\n", - "fig, ax = plt.subplots(2, 3, sharex='col', sharey='row')\n", - "\n", - "# Put content on the plot at grid spot 1,1 (0 indexed)\n", - "ax[1, 1].plot([1, 2, 3], [1 ,2, 3], 'g-.')\n", - "ax[1, 1].plot([3, 2, 1], [1, 2, 3], 'm:')\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "> * The figure that is created is saved in the variable `fig` \n", - "> * The axes for all the subplots are saved in an array variable `ax`\n", - "> * Individual subplots can be manipulated by indexing into the `ax` variable. Indexing starts from `0`, so `ax[1,1]` is the middle plot in the bottom row as seen above.\n", - "> * There are many other plot types where the *Object Orientated API* is preferred compared to the simple Matlab style one." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Online help and plotting galleries\n", - "Instead of creating a figure from scrath, it can be quicker to serch the web for the graph style of choice, fetch a piece of code and modify it. \n", - "\n", - "Here are some useful links:\n", - "\n", - "* Plotting gallery for `matplotlib` with code examples: https://matplotlib.org/gallery/index.html\n", - "\n", - "\n", - "* Some more examples with `matplotlib`: https://www.machinelearningplus.com/plots/top-50-matplotlib-visualizations-the-master-plots-python/\n", - "\n", - "\n", - "* Predefined styles `matplotlib`: https://matplotlib.org/gallery/style_sheets/style_sheets_reference.html\n", - "\n", - "\n", - "* Predefined color names for `matplotlib`: https://matplotlib.org/gallery/color/named_colors.html. Colors can also be defined as hexidecimal or RGB.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Numerical computation library: `numpy`\n", - "Another very well known and broadly used third party library is `numpy` (short for Numerical Python), which contains many useful features for fast and efficient numerical calculations. This library has a lot of the same functionality as `Matlab` and utilizes vectorization to perform calculations.\n", - "\n", - "It can be installed in the same way as every other third party library, namely by entering `pip install numpy` or `conda install numpy` from the relevant Prompt.\n", - "\n", - "Once installed `numpy` can be used as shown below. Like with the `matplotlib` import, `numpy`also has a community accepted standard of importing as `np`:" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The basic data structure in `numpy` is called an array, which can be compared to a normal Python list.\n", - "\n", - "A numpy array can be created, for example from a list, like this:" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [], - "source": [ - "# A normal Python list\n", - "L = [1, 2, 3, 4, 5] \n", - "\n", - "# List converted to numpy array\n", - "arr = np.array(L) " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Printing the array looks like a normal list:" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[1 2 3 4 5]\n" - ] - } - ], - "source": [ - "print(arr) " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "But it is in fact a `numpy` array, which can be seen by inspecting the type:" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "print(type(arr))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The fact that `numpy` uses verctorization can be seen for example by performing mulitplication:" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[ 2 4 6 8 10]\n" - ] - } - ], - "source": [ - "# Multiply all array elements by 2 and print result\n", - "arr_double = 2 * arr\n", - "\n", - "print(arr_double)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Recall that doing the same operation with a normal Python list is a little more complicated. Here shown with a list comprehension, but a normal `for` loop could also be used. " - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[2, 4, 6, 8, 10]\n" - ] - } - ], - "source": [ - "# Multiply all list elements by 2 and print result\n", - "L_double = [2*i for i in L]\n", - "\n", - "print(L_double)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Function: `np.linspace()`\n", - "\n", - "As mentioned, `numpy` has many useful functions and methods. One of the most used functions is \n", - "\n", - "~~~python\n", - "numpy.linspace(start, stop, num=50) \n", - "~~~\n", - "\n", - "which will generate an array of `num` numbers evenly spaced between `start` and `end`. As we day from Session 3 about functions, the `num=50` means that `num` is an optional argument, the default value of which is 50. So, if `num` is not specified, the generated array will have 50 evenly spaced numbers between `start`and `end`.\n", - "\n", - "**Note** that the `numpy.linspace()` function has more arguments, which are not shown here. See the documention for more info: https://docs.scipy.org/doc/numpy/reference/generated/numpy.linspace.html\n", - "\n", - "An example:" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0. , 0.11111111, 0.22222222, 0.33333333, 0.44444444,\n", - " 0.55555556, 0.66666667, 0.77777778, 0.88888889, 1. ])" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.linspace(0, 1, 10)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The `numpy.linspace()` function can especially be useful when generating $x$-values for plotting purposes." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Benefits of `numpy`\n", - "* In general `numpy` operations are **much** faster than equivalent operations in standard Python. When handling large amounts of data or computationally intensive tasks, `numpy` should be therefore preferred. \n", - "\n", - "\n", - "* Many useful functions and methods for working with data are predefined and optimized in the library. Before starting to reinvent the wheel for array manipulations, check if a `numpy` solution exists. `np.linspace()` is just one example of this.\n", - "\n", - "\n", - "* A lot of other libraries are built on top of or uses `numpy`. In fact `matplotlib` uses it for its plotting operations.\n", - "\n", - "\n", - "* Using `numpy`'s predefined functions and methods often lead to more readable than using other ways. Consider e.g. the example from above with element-wise multiplication. The Matlab-style syntax is just more reable for numeric computation." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "# Exercise 1.1\n", - "All exercises use the simple API described above.\n", - "\n", - "Plot a black line graph with dots at the points with these coordinates:\n", - "\n", - "~~~python\n", - "x = [1, 3, 6, 9, 16]\n", - "y = [7, 3, 7, 1, 5]\n", - "~~~\n", - "\n", - "Remember to `import matplotlib.pyplot as plt` and to call `plt.show()`. \n", - "\n", - "The color can be set by `plt.plot(..., color='black')` or by a shortcut `plt.plot(..., 'k')`, where `'k'` is black becuase `'b'` is blue. \n", - "\n", - "# Exercise 1.2\n", - "Set the plot title on the graph from Exercise 1.1. You choose what the title should be.\n", - "\n", - "# Exercise 1.3\n", - "Set the title of the $x$- and $y$-axis on the graph from Exercise 1.1. You choose what the title should be.\n", - "\n", - "# Exercise 1.4\n", - "Add the graphs with the following $y$-values to the plot from Exercise 1.1. Use the same $x$-values for all curves.\n", - "\n", - "~~~python\n", - "y2 = [9, 5, 5, 2, 6]\n", - "y3 = [4, 6, 2, 6, 8]\n", - "y4 = [1, 8, 1, 3, 2]\n", - "~~~\n", - "\n", - "# Exercise 1.5\n", - "Go back through the code from the previous exercises and add a `label` to the plots that were produced. Choose a label text freely.\n", - "Afterwards, add a legend to the plot. \n", - "\n", - "# Exercise 1.6 \n", - "Save the figure to a png-file. This can be done by the command `plt.savefig(desired_filename.png)`. This will save it in the same folder as you have your script.\n", - "\n", - "\n", - "*If you are dissatisfied with the size of the saved figure, this can be adjusted by explicitly creating the figure object before any of the graphs are created. Creating the figure object and setting a size is done by `plt.figure(figsize=(width, height))`. Both `width` and `height` are in inches. Try with different values.*\n", - "\n", - "\n", - "*Note: When using the simple API it is not necessary to explicitly create the figure object before starting the plotting with `plt.plot()`, as the figure is automatically created in the background with default settings. When saving to a file where it is not possible to drag the plot after creation, it is often useful to set the figure size beforehand*\n", - "\n", - "# Exercise 2.1\n", - "Create a new figure by the command `plt.figure()`. This will create a new figure object that subsequent commands will tie to. This is to avoid having the commands in this exercise be plotted in the plot from the previous exercises. \n", - "\n", - "\n", - "Redo the graphs from the previous exercises, this time split into four subplots instead. You choose how to structure the grid and how to style the graphs with colors, titles, line types etc.\n", - "\n", - "\n", - "# Exercise 2.2\n", - "Create a new figure and replicate the same subplots as in Exercise 2.1. But this time, turn the plots into bar plots. The only difference is that the plotting call should now be `plt.bar(...)`.\n", - "\n", - "\n", - "# Exercise 3.1\n", - "Create plot that is filled with some color of your choice between $y=0$ and the curve defined by $xx$ and $yy$ below:\n", - "\n", - "~~~python \n", - "import numpy as np\n", - "xx = np.linspace(-100, 100, 100)\n", - "yy = xx**2-3027 # <- Element-wise multiplication and subtraction (numpy)\n", - "~~~\n", - "\n", - "\n", - "# Exercise 4.1\n", - "Use `numpy.linspace()` to create an array with 10 values from 1-10. Save the array in a a variable called `x_arr`.\n", - "\n", - "Use the code below to create the $y$-values for five graphs. \n", - "\n", - "~~~python \n", - "y_arr1 = np.random.rand(10)\n", - "y_arr2 = np.random.rand(10)\n", - "y_arr3 = np.random.rand(10)\n", - "y_arr4 = np.random.rand(10)\n", - "y_arr5 = np.random.rand(10)\n", - "~~~\n", - "\n", - "\n", - "*The `numpy.random.rand()` function creates random values between 0 and 1 (see documentation for more: https://docs.scipy.org/doc/numpy/reference/generated/numpy.random.rand.html)*\n", - "\n", - "\n", - "Create a loop that goes through the five graphs. Each loop should create a figure with your chosen size and settings for the current graph and save it to a png-file.\n", - "You should end up with five png-files each containing only a single graph/curve." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# If you are up for more \n", - "Take the polygon plotting function `plot_polygon()` from the exercise solutions from Session 3. Create different polygons, run them through a for loop and save them to png-files. Remember that `plot_polygon()` calls the other functions `polygon_area()` and `polygon_centroid`, which also have to be copied." - ] } ], "metadata": { @@ -1097,7 +1106,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.1" + "version": "3.7.4" }, "latex_envs": { "LaTeX_envs_menu_present": true, diff --git a/Session 5 - Dataframes/Session 5 - Dataframes.ipynb b/Session 5 - Dataframes/Session 5 - Dataframes.ipynb index 01b20e7..f645fb0 100644 --- a/Session 5 - Dataframes/Session 5 - Dataframes.ipynb +++ b/Session 5 - Dataframes/Session 5 - Dataframes.ipynb @@ -1,9 +1,1662 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 5. Pandas DataFrames\n", + "Python is very good for data analysis. Much of this is thanks to the `pandas` library, which contains a wealth of powerful functions and methods to load and manipulate data.\n", + "\n", + "In the `pandas` environment what we normally refer to as a table is called a **DataFrame**. If the data has only a single column, it is called a **Series**. These are the core objects in the library.\n", + "\n", + "As with many libraries, there is a convection for renaming when importing. In `pandas` the convention is to import as `pd`: " + ] + }, { "cell_type": "code", "execution_count": 1, "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Creating a simple DataFrame\n", + "A simple DataFrame can be created with `pandas.DataFrame()`:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Column1Column2Column3
0112131
1122232
2132333
\n", + "
" + ], + "text/plain": [ + " Column1 Column2 Column3\n", + "0 11 21 31\n", + "1 12 22 32\n", + "2 13 23 33" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create a simple DataFrame\n", + "df = pd.DataFrame({'Column1': [11, 12, 13], \n", + " 'Column2': [21, 22, 23], \n", + " 'Column3': [31, 32, 33]})\n", + "df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + ">**Note:**\n", + "> 1. The input argument for creating the DataFrame is a *dictionary*. I.e. a data structure with keys-value pairs which are enclosed in curly brackets `{}`.\n", + "> 2. It automatically creates an *index* column as the leftmost column. The index column defaults to be a counter starting from 0.\n", + "> 3. The displayed DataFrame looks nicer than the it would have in an editor. This is because it is styled with HTML in this notebook environment. In an editor, the printed DataFrame would look like this:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Column1 Column2 Column3\n", + "0 11 21 31\n", + "1 12 22 32\n", + "2 13 23 33\n" + ] + } + ], + "source": [ + "# DataFrame as it would look without HTML-styling\n", + "print(df)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Presenting results with DataFrames\n", + "If we have a dictionary from a previous calculation of some kind, we can quickly turn it into a DataFrame with the same pricinple as above: " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
N [kN]A [mm2]sigma_n [GPa]
0853140.270701
1563140.178344
21203140.382166
\n", + "
" + ], + "text/plain": [ + " N [kN] A [mm2] sigma_n [GPa]\n", + "0 85 314 0.270701\n", + "1 56 314 0.178344\n", + "2 120 314 0.382166" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Define normal forces and cross sectional areas\n", + "normal_forces = [85, 56, 120]\n", + "areas = [314, 314, 314]\n", + "\n", + "# Compute stress in cross section for all normal forces\n", + "stresses = [force/area for force, area in zip(normal_forces, areas)]\n", + "\n", + "# Gather calculation results in a dictionary \n", + "results = {'N [kN]': normal_forces, 'A [mm2]': areas, 'sigma_n [GPa]': stresses}\n", + "\n", + "# Create a DataFrame of the results form the dictionary\n", + "df2 = pd.DataFrame(results)\n", + "df2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Adjusting the index column\n", + "The default index (leftmost column) is not really suited for this particular scenario. It just sets the default counter starting from 0.\n", + "\n", + "We could change it to be `'Load Case'` and have it start at 1 instead of 0:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
N [kN]A [mm2]sigma_n [GPa]
Load Case
1853140.270701
2563140.178344
31203140.382166
\n", + "
" + ], + "text/plain": [ + " N [kN] A [mm2] sigma_n [GPa]\n", + "Load Case \n", + "1 85 314 0.270701\n", + "2 56 314 0.178344\n", + "3 120 314 0.382166" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Set the name of the index to 'Load Case'\n", + "df2.index.name = 'Load Case'\n", + "\n", + "# Add 1 to all indices\n", + "df2.index += 1\n", + "\n", + "df2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Extracting a subset of data\n", + "We can extract specific columns from the DataFrame:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
sigma_n [GPa]
Load Case
10.270701
20.178344
30.382166
\n", + "
" + ], + "text/plain": [ + " sigma_n [GPa]\n", + "Load Case \n", + "1 0.270701\n", + "2 0.178344\n", + "3 0.382166" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Extract only the stress column to new DataFrame\n", + "df2[['sigma_n [GPa]']]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "> **Note:** The use of two square bracket pairs `[[]]` turns the result into a new DataFrame, with just one column. If there had been only a single square bracket, the result would be a *Series* object. See below." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Load Case\n", + "1 0.270701\n", + "2 0.178344\n", + "3 0.382166\n", + "Name: sigma_n [GPa], dtype: float64" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Extract stress column to Series object\n", + "df2['sigma_n [GPa]']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Most of the time, we want to keep working with DataFrames, so remember to put double square brackets.\n", + "\n", + "Double square brackets **must** be used if we want to extract more than one column. Otherwise, a `KeyError` will be raised." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
N [kN]sigma_n [GPa]
Load Case
1850.270701
2560.178344
31200.382166
\n", + "
" + ], + "text/plain": [ + " N [kN] sigma_n [GPa]\n", + "Load Case \n", + "1 85 0.270701\n", + "2 56 0.178344\n", + "3 120 0.382166" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Extract multiple columns to DataFrame\n", + "df2[['N [kN]', 'sigma_n [GPa]']]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Importing data from file to DataFrame\n", + "Data can be imported from various file types. The most common ones are probably standard text files (`.txt`), comma separated value files (`.csv`) or Excel files (`.xlsx`).\n", + "\n", + "Some common scenarios:\n", + "\n", + "-------\n", + "~~~python\n", + "# Import from .csv (comma separated values)\n", + "pd.read_csv('.csv')\n", + "\n", + "# Import from .txt with values separated by white space\n", + "pd.read_csv('.txt', delim_whitespace=True)\n", + "\n", + "# Import from Excel\n", + "pd.read_excel('.xlsx', sheet_name='')\n", + "~~~\n", + "---\n", + "\n", + "The above assumes that the files to import are located in the same directory as the script. Placing it there makes it easier to do the imports. If they are not in the same script the absolute or relative file path can be given as input.\n", + "\n", + "The functions above have many optional arguments. When importing from an Excel workbook it will often be necessary to specify more parameters than when importing a plain text file, because the Excel file inherently has a more complex structure. \n", + "For example, by default the data starts at cell A1 and the default sheet is the first sheet occurring in the workbook, but this is not always what is wanted.\n", + "\n", + "See docs for both functions here:\n", + "\n", + "* `panda.read_csv()`: https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.read_csv.html\n", + "* `panda.read_excel()`: https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.read_excel.html" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Import example" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A file called `HEA.txt` with properties for HEA steel profiles is located in the same directory as this notebook. Here's how to import it:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Profileh[mm]b[mm]Iy[mm4]Wel,y[mm3]g[kg/m]
0HE100A96100349000072.816.7
1HE120A1141206060000106.019.9
2HE140A13314010300000155.024.7
3HE160A15216016700000220.030.4
4HE180A17118025100000294.035.5
5HE200A19020036900000389.042.3
6HE220A21022054100000515.050.5
7HE240A23024077600000675.060.3
8HE260A250260104500000836.068.2
9HE280A2702801367000001010.076.4
10HE300A2903001826000001260.088.3
\n", + "
" + ], + "text/plain": [ + " Profile h[mm] b[mm] Iy[mm4] Wel,y[mm3] g[kg/m]\n", + "0 HE100A 96 100 3490000 72.8 16.7\n", + "1 HE120A 114 120 6060000 106.0 19.9\n", + "2 HE140A 133 140 10300000 155.0 24.7\n", + "3 HE160A 152 160 16700000 220.0 30.4\n", + "4 HE180A 171 180 25100000 294.0 35.5\n", + "5 HE200A 190 200 36900000 389.0 42.3\n", + "6 HE220A 210 220 54100000 515.0 50.5\n", + "7 HE240A 230 240 77600000 675.0 60.3\n", + "8 HE260A 250 260 104500000 836.0 68.2\n", + "9 HE280A 270 280 136700000 1010.0 76.4\n", + "10 HE300A 290 300 182600000 1260.0 88.3" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Import data from 'HEA.txt', which has data separated by white spaces\n", + "df = pd.read_csv('HEA.txt', delim_whitespace=True)\n", + "df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Filtering data\n", + "Data filtering is easy and intuitive. It is done by conditional expressions.\n", + "\n", + "For example, if we want to filter the HEA-DataFrame for profiles with moment of inertia $I_y$ larger than some value: " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Profileh[mm]b[mm]Iy[mm4]Wel,y[mm3]g[kg/m]
5HE200A19020036900000389.042.3
6HE220A21022054100000515.050.5
7HE240A23024077600000675.060.3
8HE260A250260104500000836.068.2
9HE280A2702801367000001010.076.4
10HE300A2903001826000001260.088.3
\n", + "
" + ], + "text/plain": [ + " Profile h[mm] b[mm] Iy[mm4] Wel,y[mm3] g[kg/m]\n", + "5 HE200A 190 200 36900000 389.0 42.3\n", + "6 HE220A 210 220 54100000 515.0 50.5\n", + "7 HE240A 230 240 77600000 675.0 60.3\n", + "8 HE260A 250 260 104500000 836.0 68.2\n", + "9 HE280A 270 280 136700000 1010.0 76.4\n", + "10 HE300A 290 300 182600000 1260.0 88.3" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df[df['Iy[mm4]'] > 30000000]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Understanding the filtering process\n", + "\n", + "The inner expression of the filtering\n", + "\n", + "~~~python\n", + "df['Iy[mm4]'] > 30000000\n", + "~~~\n", + "\n", + "returns the column `Iy[mm4]` from the DataFrame converted into a ***boolean Series***. I.e. a Series with `True`/`False` in each row depending on whether or not the condition is fulfilled:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 False\n", + "1 False\n", + "2 False\n", + "3 False\n", + "4 False\n", + "5 True\n", + "6 True\n", + "7 True\n", + "8 True\n", + "9 True\n", + "10 True\n", + "Name: Iy[mm4], dtype: bool" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Inner expression returns a boolean Series of the column Iy[mm4]\n", + "df['Iy[mm4]'] > 30000000" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This boolean Series is used to filter the original DataFrame, which is done in the outer expression by `df[boolean_series]`.\n", + "\n", + "The outer expression picks only the rows from the orignal DataFrame where the boolean series is `True`.\n", + "\n", + "## Filtering by multiple conditions\n", + "Filtering based on multiple conditions can be quite powerful. The syntax is only slightly more complicated:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Profileh[mm]b[mm]Iy[mm4]Wel,y[mm3]g[kg/m]
5HE200A19020036900000389.042.3
6HE220A21022054100000515.050.5
7HE240A23024077600000675.060.3
8HE260A250260104500000836.068.2
\n", + "
" + ], + "text/plain": [ + " Profile h[mm] b[mm] Iy[mm4] Wel,y[mm3] g[kg/m]\n", + "5 HE200A 190 200 36900000 389.0 42.3\n", + "6 HE220A 210 220 54100000 515.0 50.5\n", + "7 HE240A 230 240 77600000 675.0 60.3\n", + "8 HE260A 250 260 104500000 836.0 68.2" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df[(df['Iy[mm4]'] > 30000000) & (df['h[mm]'] < 260 )]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Each condition must be inside parentheses `()` and conditions are separated by `&`.\n", + "\n", + "---\n", + "\n", + "Filtering can also be based on lists of values. Consider the code below which extracts rows where \n", + "\n", + "* Moment of inertia $I_y$ is larger than some value \n", + "* The profile name is present in the list called `valid_profiles`" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Profileh[mm]b[mm]Iy[mm4]Wel,y[mm3]g[kg/m]
6HE220A21022054100000515.050.5
8HE260A250260104500000836.068.2
9HE280A2702801367000001010.076.4
\n", + "
" + ], + "text/plain": [ + " Profile h[mm] b[mm] Iy[mm4] Wel,y[mm3] g[kg/m]\n", + "6 HE220A 210 220 54100000 515.0 50.5\n", + "8 HE260A 250 260 104500000 836.0 68.2\n", + "9 HE280A 270 280 136700000 1010.0 76.4" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Valid profiles to choose from\n", + "valid_profiles = ['HE180A', 'HE220A', 'HE260A', 'HE280A']\n", + "\n", + "# Filter DataFrame based on Iy value and valid profiles\n", + "df[(df['Iy[mm4]'] > 30000000) & (df['Profile'].isin(valid_profiles) )]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "If we instead want to rule the profiles in the list, we could put a `~` in front of the condition to specify that values must ***not*** be present in the list:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Profileh[mm]b[mm]Iy[mm4]Wel,y[mm3]g[kg/m]
5HE200A19020036900000389.042.3
7HE240A23024077600000675.060.3
10HE300A2903001826000001260.088.3
\n", + "
" + ], + "text/plain": [ + " Profile h[mm] b[mm] Iy[mm4] Wel,y[mm3] g[kg/m]\n", + "5 HE200A 190 200 36900000 389.0 42.3\n", + "7 HE240A 230 240 77600000 675.0 60.3\n", + "10 HE300A 290 300 182600000 1260.0 88.3" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Invalid profiles\n", + "invalid_profiles = ['HE180A', 'HE220A', 'HE260A', 'HE280A']\n", + "\n", + "# Filter DataFrame based in Iy and valid profiles\n", + "df[(df['Iy[mm4]'] > 30000000) & (~df['Profile'].isin(invalid_profiles) )]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exporting a DataFrame to a file\n", + "Exporting a DataFrame to a new text file could not be easier. Saving to a `.txt`:\n", + "\n", + "---\n", + "~~~python\n", + "# Save df to a .txt file in the same folder as the script\n", + "df.to_csv('filename.txt')\n", + "~~~\n", + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## GroupBy\n", + "The method `groupby` provides a way to **split** a DataFrame into groups based on some condition, **apply** a function to those groups and **combine** the results into a new DataFrame that is then returned.\n", + "\n", + "\n", + "### An example" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FruitAmount_sold
0Pear3
1Apple6
2Apple7
3Banana2
4Lemon4
5Banana7
6Banana1
7Pear6
\n", + "
" + ], + "text/plain": [ + " Fruit Amount_sold\n", + "0 Pear 3\n", + "1 Apple 6\n", + "2 Apple 7\n", + "3 Banana 2\n", + "4 Lemon 4\n", + "5 Banana 7\n", + "6 Banana 1\n", + "7 Pear 6" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create a dataframe to work with\n", + "dff = pd.DataFrame({'Fruit': ['Pear', 'Apple', 'Apple', 'Banana', \n", + " 'Lemon', 'Banana', 'Banana', 'Pear'], \n", + " 'Amount_sold': [3, 6, 7, 2, 4, 7, 1, 6]})\n", + "dff" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `DataFrame.groupby` method itself returns a *groupby object*, **not** a DataFrame. So printing that on its own will just show you the object, which is not very helpful: " + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# The gropuby will return a groupby object\n", + "dff.groupby('Fruit')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The object contains metadata about how the data is grouped. It's kind of an intermediate state where the object is ready to receive a function.\n", + "\n", + "The powerful operations are visible only after we apply a certain function to the groupby object, like `sum()`: " + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Amount_sold
Fruit
Apple13
Banana10
Lemon4
Pear9
\n", + "
" + ], + "text/plain": [ + " Amount_sold\n", + "Fruit \n", + "Apple 13\n", + "Banana 10\n", + "Lemon 4\n", + "Pear 9" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dff.groupby('Fruit').sum()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We could say that we first **split** the DataFrame in fruit groups, **applied** a function to those individual groups and **combined** and returned the results as a new DataFrame. \n", + "\n", + "Note that by default the column that the data was grouped by becomes the new index, since these are now unique values." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### Documentation\n", + "Documentation for `groupby`: http://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.groupby.html\n", + "Documentation for `apply`: https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.apply.html" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Printing with `df.head()` and `df.tail()` \n", + "When DataFrames become very large, printing all the data to the screen becomes unwieldy. Printing is mostly done only to make sure that some operation worked as we expected it would. In that case, printing just a few rows will be sufficient, which the following methods will allow for:\n", + "\n", + "---\n", + "~~~python\n", + "# Print the first 5 rows of df\n", + "df.head()\n", + "\n", + "# Print the last 5 rows of df\n", + "df.tail()\n", + "\n", + "# Print the first x rows of df\n", + "df.head(x)\n", + "\n", + "# Print the last y rows of df\n", + "df.tail(y)\n", + "~~~\n", + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Something to be aware of\n", + "A potentially confusing thing about `pandas` methods is that it can be hard to know which ones mutates the DataFrame *inplace* and which ones need to be saved to a new variable. \n", + "\n", + "Consider the lines below:\n", + "\n", + "---\n", + "~~~python\n", + "# This line does not rename the column in df but returns a copy of df with the column renamed\n", + "df.rename(columns={'Current_name': 'New_name}) \n", + " \n", + "# Thus, it has to be saved to a new variable\n", + "df = df.rename(columns={'Current_name': 'New_name}) \n", + " \n", + "# Or, use the argument inplace=True to modify df directly\n", + "df.rename(columns={'Current_name': 'New_name'}, inplace=True) \n", + "~~~\n", + "---\n", + "\n", + "You will most likely stumble upon this when working with `pandas`. \n", + "\n", + "***Note that there is no error when when executing the first line shown above, but when `df` is eventually printed it will just not show up as intended.***" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "## Much more functionality\n", + "There are numerous functions and methods available in `pandas` and the above mentioned barely scrathes the surface. \n", + "\n", + "Practically anything that you would want to do to a dataset can be done. And quite possibly somebody has had the same problem as you before and found a solution or maybe even even contributed to the `pandas` library and put in that functionality for everyone to use.\n", + "However, some functionality can be much harder to understand and use than the above mentioned.\n", + "\n", + "The `pandas` library integrates well with other big libraries like `numpy` and `matplotlib` and other functionality in the Python language in general. For example, many DataFrame methods can take a customized function as input `def ...()` and run it through certain content of the DataFrame.\n", + "\n", + "Plotting with `matplotlib` is directly supported in `pandas` via shortcuts so you can do `df.plot()` and it will create a plot of the DataFrame of a specified kind even without having to import `matplotlib`.\n", + "\n", + "## When and why to use `pandas`\n", + "* The manipulations that can be done with `pandas` are quite powerful when datasets become much larger than ones shown above. It is especially helpful when the dataset reaches a size where all data can not be viewed and understood well by simply scrolling down and looking at the data. If the number of rows go beyond just a couple of thousands, it is hard to get the overall feel for the data and its trends just by inspection. This is were typing logic commands to do manipulations becomes a great help. \n", + "\n", + "\n", + "* Use it when a very specific solution for data manipulation is desired. Especially when the solution is not trivially done in for example Excel.\n", + "\n", + "\n", + "* It is a good tool for combining multiple datasets, e.g. from different files.\n", + "\n", + "\n", + "* Last but not least, it is good for reproducibility and handling changes in data size. \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 1.1\n", + "***All exercises 1.x are working with the same DataFrame.***\n", + "\n", + "---\n", + "\n", + "Create a DataFrame from the dictionary `d` below. Save it is a variable called `df`.\n", + "\n", + "---\n", + "~~~python \n", + "# Import built-in libraries string and random \n", + "import random\n", + "import string\n", + "\n", + "# Get upper- and lowercase letters from the string library\n", + "lower = string.ascii_lowercase\n", + "upper = string.ascii_uppercase\n", + "\n", + "# Create a dictionary with dummy data of integers and letters\n", + "d = {'Integers': [random.randint(1, 100) for i in range(1, 100)],\n", + " 'Lowercase': [random.choice(lower) for i in range(1, 100)],\n", + " 'Uppercase': [random.choice(upper) for i in range(1, 100)]}\n", + "~~~\n", + "---\n", + "\n", + "Print/display the entire DataFrame to see if it comes out as you expect.\n", + "\n", + "Remember to `import pandas as pd`.\n", + "\n", + "# Exercise 1.2\n", + "Print/display the only the first or last rows by using `DataFrame.head()` or `DataFrame.tail()`. You choose how many rows to print (default is 5).\n", + "\n", + "*Use these methods to test print the DataFrames from now on to avoid printing all rows.*\n", + "\n", + "# Exercise 1.3\n", + "Filter `df` to only contain the rows where the uppercase letter is `'K'`. Save it to a new variable called `dfk`.\n", + "\n", + "Print/display it to make sure it is correct.\n", + "\n", + "*If you were unlucky and did not have a `'K'` generated in the uppercase column, try re-running the code (it chooses letters at random)*.\n", + "\n", + "\n", + "# Exercise 1.4\n", + "When printing the filtered `dfk`, notice that the index from the original DataFrame is kept. This is often useful for back reference, but sometimes we want the index to be reset. \n", + "\n", + "Reset the index of `dfk` to start from 0 by using `DataFrame.reset_index()`. \n", + "This method does not modify the DataFrame inplace by default, so remember to either save to a new variable or give the input argument `inplace=True`.\n", + "\n", + "By default, the orignal index will be added as a new column to the DataFrame. If you don't want this, use the input argument `drop=True`." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 2.1\n", + "***All exercises 2.x are to be seen as the same problem. It has just been divided into smaller tasks.***\n", + "\n", + "---\n", + "Import the file `shear_key_forces.csv` to a DataFrame using `pandas.read_csv()`. The values in the file are comma separated, which the function also assumes as default. \n", + "The file is located in the Session 5 folder and has 104329 rows. Print the head or the tail to see the imported data.\n", + "\n", + "*The data has all spring element forces in a bunch of load cases from a Sofistik finite element calculation. It's not strictly necessary to know what the data represents. It could just be looked at as dummy data to work with.*\n", + "\n", + "\n", + "# Exercise 2.2\n", + "*The model has many spring elements. Some of them represent shear keys between the structural parts of a tunnel at movement joint locations. These are the one we are going to extract.*\n", + "\n", + "The data has a column `'shear_key'` which has the name of the shear key if the element in that row is part of a shear key. E.g. `'Shear_key1'`. If the element is not part of a shear key, the name is `'Not_a_shear_key'`.\n", + "\n", + "Filter out all rows which are not part of a shear key. The resulting DataFrame should have 2874 rows. \n", + "\n", + "\n", + "# Exercise 2.3\n", + "Since we are not really using the column called `'Element_no'`, go ahead and remove it from the DataFrame. This can be done by\n", + "\n", + "---\n", + "~~~python \n", + "# Remove column 'column_name' form 'df'\n", + "df = df.drop('column_name', axis=1)\n", + "~~~\n", + "---\n", + "The argument `axis=1` specifies that it is a column and not a row that should be removed.\n", + "\n", + "*Remember to save to a new variable or use argument `inplace=True`. If you save to a variable, you can use the same name to 'overwrite' the old one if it's not needed anymore.*\n", + "\n", + "\n", + "# Exercise 2.4\n", + "*Each shear key consists of three spring elements. The total force that the shear key should be designed for is the sum of those three spring forces.*\n", + "\n", + "Create a DataFrame with the sum of the three values within each shear key for every load case. The resulting DataFrame should have 958 rows.\n", + "\n", + "\n", + "**Hint:** Use the methods `DataFrame.groupby()` and `DataFrame.sum()` like this:\n", + "\n", + "~~~python\n", + "df.groupby(['Shear_key', 'LC', 'LC-title'], as_index=False).sum()\n", + "~~~\n", + "Replace `df` with the name of your variable containing the DataFrame.\n", + "\n", + "Here, a list of column labels is passed in the `groupby()` method instead of just a single column label. The first column `'Shear_key'` is what is used to create the groups, while consecutive labels just follow. Any columns that are not passed in will not appear in the resulting DataFrame. \n", + "\n", + "# Exercise 2.5\n", + "Filter the DataFrame for a shear key, for example `'Shear_key1'` and create a bar plot of it with the `DataFrame.plot()` method. The bar plot should have the load cases as $x$-values and the force $P$ [kN] as $y$-values.\n", + "\n", + "---\n", + "~~~python\n", + "# Plot dataframe contents\n", + "df.plot(kind='bar', x='column_for_x_values', y='column_for_y_values')\n", + "~~~\n", + "---\n", + "\n", + "The method has many optional arguments, see https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.plot.html.\n", + "\n", + "Try for example to change the figure size by `figsize=(width, height)`, rotate the x-ticks by `rot=angle_in_degrees` and change the color of the bars by `color='some_color'`.\n", + "\n", + "# If you are up for more\n", + "Create a loop that goes through all shear keys, creates a plot like the one from the previous exercise and saves each plot to a png-file.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# End of exercises\n", + "\n", + "*The cell below is for setting the style of this document. It's not part of the exercises.*" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, "outputs": [ { "data": { @@ -275,7 +1928,7 @@ "" ] }, - "execution_count": 1, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -284,1650 +1937,6 @@ "from IPython.display import HTML\n", "HTML(''.format(open('../css/cowi.css').read()))" ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# 5. Pandas DataFrames\n", - "Python is very good for data analysis. Much of this is thanks to the `pandas` library, which contains a wealth of powerful functions and methods to load and manipulate data.\n", - "\n", - "In the `pandas` environment what we normally refer to as a table is called a **DataFrame**. If the data has only a single column, it is called a **Series**. These are the core objects in the library.\n", - "\n", - "As with many libraries, there is a convection for renaming when importing. In `pandas` the convention is to import as `pd`: " - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "import pandas as pd" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Creating a simple DataFrame\n", - "A simple DataFrame can be created with `pandas.DataFrame()`:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Column1Column2Column3
0112131
1122232
2132333
\n", - "
" - ], - "text/plain": [ - " Column1 Column2 Column3\n", - "0 11 21 31\n", - "1 12 22 32\n", - "2 13 23 33" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Create a simple DataFrame\n", - "df = pd.DataFrame({'Column1': [11, 12, 13], \n", - " 'Column2': [21, 22, 23], \n", - " 'Column3': [31, 32, 33]})\n", - "df" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - ">**Note:**\n", - "> 1. The input argument for creating the DataFrame is a *dictionary*. I.e. a data structure with keys-value pairs which are enclosed in curly brackets `{}`.\n", - "> 2. It automatically creates an *index* column as the leftmost column. The index column defaults to be a counter starting from 0.\n", - "> 3. The displayed DataFrame looks nicer than the it would have in an editor. This is because it is styled with HTML in this notebook environment. In an editor, the printed DataFrame would look like this:" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Column1 Column2 Column3\n", - "0 11 21 31\n", - "1 12 22 32\n", - "2 13 23 33\n" - ] - } - ], - "source": [ - "# DataFrame as it would look without HTML-styling\n", - "print(df)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Presenting results with DataFrames\n", - "If we have a dictionary from a previous calculation of some kind, we can quickly turn it into a DataFrame with the same pricinple as above: " - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
N [kN]A [mm2]sigma_n [GPa]
0853140.270701
1563140.178344
21203140.382166
\n", - "
" - ], - "text/plain": [ - " N [kN] A [mm2] sigma_n [GPa]\n", - "0 85 314 0.270701\n", - "1 56 314 0.178344\n", - "2 120 314 0.382166" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Define normal forces and cross sectional areas\n", - "normal_forces = [85, 56, 120]\n", - "areas = [314, 314, 314]\n", - "\n", - "# Compute stress in cross section for all normal forces\n", - "stresses = [force/area for force, area in zip(normal_forces, areas)]\n", - "\n", - "# Gather calculation results in a dictionary \n", - "results = {'N [kN]': normal_forces, 'A [mm2]': areas, 'sigma_n [GPa]': stresses}\n", - "\n", - "# Create a DataFrame of the results form the dictionary\n", - "df2 = pd.DataFrame(results)\n", - "df2" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Adjusting the index column\n", - "The default index (leftmost column) is not really suited for this particular scenario. It just sets the default counter starting from 0.\n", - "\n", - "We could change it to be `'Load Case'` and have it start at 1 instead of 0:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
N [kN]A [mm2]sigma_n [GPa]
Load Case
1853140.270701
2563140.178344
31203140.382166
\n", - "
" - ], - "text/plain": [ - " N [kN] A [mm2] sigma_n [GPa]\n", - "Load Case \n", - "1 85 314 0.270701\n", - "2 56 314 0.178344\n", - "3 120 314 0.382166" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Set the name of the index to 'Load Case'\n", - "df2.index.name = 'Load Case'\n", - "\n", - "# Add 1 to all indices\n", - "df2.index += 1\n", - "\n", - "df2" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Extracting a subset of data\n", - "We can extract specific columns from the DataFrame:" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
sigma_n [GPa]
Load Case
10.270701
20.178344
30.382166
\n", - "
" - ], - "text/plain": [ - " sigma_n [GPa]\n", - "Load Case \n", - "1 0.270701\n", - "2 0.178344\n", - "3 0.382166" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Extract only the stress column to new DataFrame\n", - "df2[['sigma_n [GPa]']]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "> **Note:** The use of two square bracket pairs `[[]]` turns the result into a new DataFrame, with just one column. If there had been only a single square bracket, the result would be a *Series* object. See below." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Load Case\n", - "1 0.270701\n", - "2 0.178344\n", - "3 0.382166\n", - "Name: sigma_n [GPa], dtype: float64" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Extract stress column to Series object\n", - "df2['sigma_n [GPa]']" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Most of the time, we want to keep working with DataFrames, so remember to put double square brackets.\n", - "\n", - "Double square brackets **must** be used if we want to extract more than one column. Otherwise, a `KeyError` will be raised." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
N [kN]sigma_n [GPa]
Load Case
1850.270701
2560.178344
31200.382166
\n", - "
" - ], - "text/plain": [ - " N [kN] sigma_n [GPa]\n", - "Load Case \n", - "1 85 0.270701\n", - "2 56 0.178344\n", - "3 120 0.382166" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Extract multiple columns to DataFrame\n", - "df2[['N [kN]', 'sigma_n [GPa]']]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Importing data from file to DataFrame\n", - "Data can be imported from various file types. The most common ones are probably standard text files (`.txt`), comma separated value files (`.csv`) or Excel files (`.xlsx`).\n", - "\n", - "Some common scenarios:\n", - "\n", - "-------\n", - "~~~python\n", - "# Import from .csv (comma separated values)\n", - "pd.read_csv('.csv')\n", - "\n", - "# Import from .txt with values separated by white space\n", - "pd.read_csv('.txt', delim_whitespace=True)\n", - "\n", - "# Import from Excel\n", - "pd.read_excel('.xlsx', sheet_name='')\n", - "~~~\n", - "---\n", - "\n", - "The above assumes that the files to import are located in the same directory as the script. Placing it there makes it easier to do the imports. If they are not in the same script the absolute or relative file path can be given as input.\n", - "\n", - "The functions above have many optional arguments. When importing from an Excel workbook it will often be necessary to specify more parameters than when importing a plain text file, because the Excel file inherently has a more complex structure. \n", - "For example, by default the data starts at cell A1 and the default sheet is the first sheet occurring in the workbook, but this is not always what is wanted.\n", - "\n", - "See docs for both functions here:\n", - "\n", - "* `panda.read_csv()`: https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.read_csv.html\n", - "* `panda.read_excel()`: https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.read_excel.html" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Import example" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "A file called `HEA.txt` with properties for HEA steel profiles is located in the same directory as this notebook. Here's how to import it:" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Profileh[mm]b[mm]Iy[mm4]Wel,y[mm3]g[kg/m]
0HE100A96100349000072.816.7
1HE120A1141206060000106.019.9
2HE140A13314010300000155.024.7
3HE160A15216016700000220.030.4
4HE180A17118025100000294.035.5
5HE200A19020036900000389.042.3
6HE220A21022054100000515.050.5
7HE240A23024077600000675.060.3
8HE260A250260104500000836.068.2
9HE280A2702801367000001010.076.4
10HE300A2903001826000001260.088.3
\n", - "
" - ], - "text/plain": [ - " Profile h[mm] b[mm] Iy[mm4] Wel,y[mm3] g[kg/m]\n", - "0 HE100A 96 100 3490000 72.8 16.7\n", - "1 HE120A 114 120 6060000 106.0 19.9\n", - "2 HE140A 133 140 10300000 155.0 24.7\n", - "3 HE160A 152 160 16700000 220.0 30.4\n", - "4 HE180A 171 180 25100000 294.0 35.5\n", - "5 HE200A 190 200 36900000 389.0 42.3\n", - "6 HE220A 210 220 54100000 515.0 50.5\n", - "7 HE240A 230 240 77600000 675.0 60.3\n", - "8 HE260A 250 260 104500000 836.0 68.2\n", - "9 HE280A 270 280 136700000 1010.0 76.4\n", - "10 HE300A 290 300 182600000 1260.0 88.3" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Import data from 'HEA.txt', which has data separated by white spaces\n", - "df = pd.read_csv('HEA.txt', delim_whitespace=True)\n", - "df" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Filtering data\n", - "Data filtering is easy and intuitive. It is done by conditional expressions.\n", - "\n", - "For example, if we want to filter the HEA-DataFrame for profiles with moment of inertia $I_y$ larger than some value: " - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Profileh[mm]b[mm]Iy[mm4]Wel,y[mm3]g[kg/m]
5HE200A19020036900000389.042.3
6HE220A21022054100000515.050.5
7HE240A23024077600000675.060.3
8HE260A250260104500000836.068.2
9HE280A2702801367000001010.076.4
10HE300A2903001826000001260.088.3
\n", - "
" - ], - "text/plain": [ - " Profile h[mm] b[mm] Iy[mm4] Wel,y[mm3] g[kg/m]\n", - "5 HE200A 190 200 36900000 389.0 42.3\n", - "6 HE220A 210 220 54100000 515.0 50.5\n", - "7 HE240A 230 240 77600000 675.0 60.3\n", - "8 HE260A 250 260 104500000 836.0 68.2\n", - "9 HE280A 270 280 136700000 1010.0 76.4\n", - "10 HE300A 290 300 182600000 1260.0 88.3" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df[df['Iy[mm4]'] > 30000000]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Understanding the filtering process\n", - "\n", - "The inner expression of the filtering\n", - "\n", - "~~~python\n", - "df['Iy[mm4]'] > 30000000\n", - "~~~\n", - "\n", - "returns the column `Iy[mm4]` from the DataFrame converted into a ***boolean Series***. I.e. a Series with `True`/`False` in each row depending on whether or not the condition is fulfilled:" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0 False\n", - "1 False\n", - "2 False\n", - "3 False\n", - "4 False\n", - "5 True\n", - "6 True\n", - "7 True\n", - "8 True\n", - "9 True\n", - "10 True\n", - "Name: Iy[mm4], dtype: bool" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Inner expression returns a boolean Series of the column Iy[mm4]\n", - "df['Iy[mm4]'] > 30000000" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This boolean Series is used to filter the original DataFrame, which is done in the outer expression by `df[boolean_series]`.\n", - "\n", - "The outer expression picks only the rows from the orignal DataFrame where the boolean series is `True`.\n", - "\n", - "## Filtering by multiple conditions\n", - "Filtering based on multiple conditions can be quite powerful. The syntax is only slightly more complicated:" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Profileh[mm]b[mm]Iy[mm4]Wel,y[mm3]g[kg/m]
5HE200A19020036900000389.042.3
6HE220A21022054100000515.050.5
7HE240A23024077600000675.060.3
8HE260A250260104500000836.068.2
\n", - "
" - ], - "text/plain": [ - " Profile h[mm] b[mm] Iy[mm4] Wel,y[mm3] g[kg/m]\n", - "5 HE200A 190 200 36900000 389.0 42.3\n", - "6 HE220A 210 220 54100000 515.0 50.5\n", - "7 HE240A 230 240 77600000 675.0 60.3\n", - "8 HE260A 250 260 104500000 836.0 68.2" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df[(df['Iy[mm4]'] > 30000000) & (df['h[mm]'] < 260 )]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Each condition must be inside parentheses `()` and conditions are separated by `&`.\n", - "\n", - "---\n", - "\n", - "Filtering can also be based on lists of values. Consider the code below which extracts rows where \n", - "\n", - "* Moment of inertia $I_y$ is larger than some value \n", - "* The profile name is present in the list called `valid_profiles`" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Profileh[mm]b[mm]Iy[mm4]Wel,y[mm3]g[kg/m]
6HE220A21022054100000515.050.5
8HE260A250260104500000836.068.2
9HE280A2702801367000001010.076.4
\n", - "
" - ], - "text/plain": [ - " Profile h[mm] b[mm] Iy[mm4] Wel,y[mm3] g[kg/m]\n", - "6 HE220A 210 220 54100000 515.0 50.5\n", - "8 HE260A 250 260 104500000 836.0 68.2\n", - "9 HE280A 270 280 136700000 1010.0 76.4" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Valid profiles to choose from\n", - "valid_profiles = ['HE180A', 'HE220A', 'HE260A', 'HE280A']\n", - "\n", - "# Filter DataFrame based on Iy value and valid profiles\n", - "df[(df['Iy[mm4]'] > 30000000) & (df['Profile'].isin(valid_profiles) )]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "---\n", - "\n", - "If we instead want to rule the profiles in the list, we could put a `~` in front of the condition to specify that values must ***not*** be present in the list:" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Profileh[mm]b[mm]Iy[mm4]Wel,y[mm3]g[kg/m]
5HE200A19020036900000389.042.3
7HE240A23024077600000675.060.3
10HE300A2903001826000001260.088.3
\n", - "
" - ], - "text/plain": [ - " Profile h[mm] b[mm] Iy[mm4] Wel,y[mm3] g[kg/m]\n", - "5 HE200A 190 200 36900000 389.0 42.3\n", - "7 HE240A 230 240 77600000 675.0 60.3\n", - "10 HE300A 290 300 182600000 1260.0 88.3" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Invalid profiles\n", - "invalid_profiles = ['HE180A', 'HE220A', 'HE260A', 'HE280A']\n", - "\n", - "# Filter DataFrame based in Iy and valid profiles\n", - "df[(df['Iy[mm4]'] > 30000000) & (~df['Profile'].isin(invalid_profiles) )]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exporting a DataFrame to a file\n", - "Exporting a DataFrame to a new text file could not be easier. Saving to a `.txt`:\n", - "\n", - "---\n", - "~~~python\n", - "# Save df to a .txt file in the same folder as the script\n", - "df.to_csv('filename.txt')\n", - "~~~\n", - "---" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## GroupBy\n", - "The method `groupby` provides a way to **split** a DataFrame into groups based on some condition, **apply** a function to those groups and **combine** the results into a new DataFrame that is then returned.\n", - "\n", - "\n", - "### An example" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
FruitAmount_sold
0Pear3
1Apple6
2Apple7
3Banana2
4Lemon4
5Banana7
6Banana1
7Pear6
\n", - "
" - ], - "text/plain": [ - " Fruit Amount_sold\n", - "0 Pear 3\n", - "1 Apple 6\n", - "2 Apple 7\n", - "3 Banana 2\n", - "4 Lemon 4\n", - "5 Banana 7\n", - "6 Banana 1\n", - "7 Pear 6" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Create a dataframe to work with\n", - "dff = pd.DataFrame({'Fruit': ['Pear', 'Apple', 'Apple', 'Banana', \n", - " 'Lemon', 'Banana', 'Banana', 'Pear'], \n", - " 'Amount_sold': [3, 6, 7, 2, 4, 7, 1, 6]})\n", - "dff" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The `DataFrame.groupby` method itself returns a *groupby object*, **not** a DataFrame. So printing that on its own will just show you the object, which is not very helpful: " - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# The gropuby will return a groupby object\n", - "dff.groupby('Fruit')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The object contains metadata about how the data is grouped. It's kind of an intermediate state where the object is ready to receive a function.\n", - "\n", - "The powerful operations are visible only after we apply a certain function to the groupby object, like `sum()`: " - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Amount_sold
Fruit
Apple13
Banana10
Lemon4
Pear9
\n", - "
" - ], - "text/plain": [ - " Amount_sold\n", - "Fruit \n", - "Apple 13\n", - "Banana 10\n", - "Lemon 4\n", - "Pear 9" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dff.groupby('Fruit').sum()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We could say that we first **split** the DataFrame in fruit groups, **applied** a function to those individual groups and **combined** and returned the results as a new DataFrame. \n", - "\n", - "Note that by default the column that the data was grouped by becomes the new index, since these are now unique values." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "heading_collapsed": true - }, - "source": [ - "### Documentation\n", - "Documentation for `groupby`: http://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.groupby.html\n", - "Documentation for `apply`: https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.apply.html" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Printing with `df.head()` and `df.tail()` \n", - "When DataFrames become very large, printing all the data to the screen becomes unwieldy. Printing is mostly done only to make sure that some operation worked as we expected it would. In that case, printing just a few rows will be sufficient, which the following methods will allow for:\n", - "\n", - "---\n", - "~~~python\n", - "# Print the first 5 rows of df\n", - "df.head()\n", - "\n", - "# Print the last 5 rows of df\n", - "df.tail()\n", - "\n", - "# Print the first x rows of df\n", - "df.head(x)\n", - "\n", - "# Print the last y rows of df\n", - "df.tail(y)\n", - "~~~\n", - "---" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Something to be aware of\n", - "A potentially confusing thing about `pandas` methods is that it can be hard to know which ones mutates the DataFrame *inplace* and which ones need to be saved to a new variable. \n", - "\n", - "Consider the lines below:\n", - "\n", - "---\n", - "~~~python\n", - "# This line does not rename the column in df but returns a copy of df with the column renamed\n", - "df.rename(columns={'Current_name': 'New_name}) \n", - " \n", - "# Thus, it has to be saved to a new variable\n", - "df = df.rename(columns={'Current_name': 'New_name}) \n", - " \n", - "# Or, use the argument inplace=True to modify df directly\n", - "df.rename(columns={'Current_name': 'New_name'}, inplace=True) \n", - "~~~\n", - "---\n", - "\n", - "You will most likely stumble upon this when working with `pandas`. \n", - "\n", - "***Note that there is no error when when executing the first line shown above, but when `df` is eventually printed it will just not show up as intended.***" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "\n", - "## Much more functionality\n", - "There are numerous functions and methods available in `pandas` and the above mentioned barely scrathes the surface. \n", - "\n", - "Practically anything that you would want to do to a dataset can be done. And quite possibly somebody has had the same problem as you before and found a solution or maybe even even contributed to the `pandas` library and put in that functionality for everyone to use.\n", - "However, some functionality can be much harder to understand and use than the above mentioned.\n", - "\n", - "The `pandas` library integrates well with other big libraries like `numpy` and `matplotlib` and other functionality in the Python language in general. For example, many DataFrame methods can take a customized function as input `def ...()` and run it through certain content of the DataFrame.\n", - "\n", - "Plotting with `matplotlib` is directly supported in `pandas` via shortcuts so you can do `df.plot()` and it will create a plot of the DataFrame of a specified kind even without having to import `matplotlib`.\n", - "\n", - "## When and why to use `pandas`\n", - "* The manipulations that can be done with `pandas` are quite powerful when datasets become much larger than ones shown above. It is especially helpful when the dataset reaches a size where all data can not be viewed and understood well by simply scrolling down and looking at the data. If the number of rows go beyond just a couple of thousands, it is hard to get the overall feel for the data and its trends just by inspection. This is were typing logic commands to do manipulations becomes a great help. \n", - "\n", - "\n", - "* Use it when a very specific solution for data manipulation is desired. Especially when the solution is not trivially done in for example Excel.\n", - "\n", - "\n", - "* It is a good tool for combining multiple datasets, e.g. from different files.\n", - "\n", - "\n", - "* Last but not least, it is good for reproducibility and handling changes in data size. \n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 1.1\n", - "***All exercises 1.x are working with the same DataFrame.***\n", - "\n", - "---\n", - "\n", - "Create a DataFrame from the dictionary `d` below. Save it is a variable called `df`.\n", - "\n", - "---\n", - "~~~python \n", - "# Import built-in libraries string and random \n", - "import random\n", - "import string\n", - "\n", - "# Get upper- and lowercase letters from the string library\n", - "lower = string.ascii_lowercase\n", - "upper = string.ascii_uppercase\n", - "\n", - "# Create a dictionary with dummy data of integers and letters\n", - "d = {'Integers': [random.randint(1, 100) for i in range(1, 100)],\n", - " 'Lowercase': [random.choice(lower) for i in range(1, 100)],\n", - " 'Uppercase': [random.choice(upper) for i in range(1, 100)]}\n", - "~~~\n", - "---\n", - "\n", - "Print/display the entire DataFrame to see if it comes out as you expect.\n", - "\n", - "Remember to `import pandas as pd`.\n", - "\n", - "# Exercise 1.2\n", - "Print/display the only the first or last rows by using `DataFrame.head()` or `DataFrame.tail()`. You choose how many rows to print (default is 5).\n", - "\n", - "*Use these methods to test print the DataFrames from now on to avoid printing all rows.*\n", - "\n", - "# Exercise 1.3\n", - "Filter `df` to only contain the rows where the uppercase letter is `'K'`. Save it to a new variable called `dfk`.\n", - "\n", - "Print/display it to make sure it is correct.\n", - "\n", - "*If you were unlucky and did not have a `'K'` generated in the uppercase column, try re-running the code (it chooses letters at random)*.\n", - "\n", - "\n", - "# Exercise 1.4\n", - "When printing the filtered `dfk`, notice that the index from the original DataFrame is kept. This is often useful for back reference, but sometimes we want the index to be reset. \n", - "\n", - "Reset the index of `dfk` to start from 0 by using `DataFrame.reset_index()`. \n", - "This method does not modify the DataFrame inplace by default, so remember to either save to a new variable or give the input argument `inplace=True`.\n", - "\n", - "By default, the orignal index will be added as a new column to the DataFrame. If you don't want this, use the input argument `drop=True`." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 2.1\n", - "***All exercises 2.x are to be seen as the same problem. It has just been divided into smaller tasks.***\n", - "\n", - "---\n", - "Import the file `shear_key_forces.csv` to a DataFrame using `pandas.read_csv()`. The values in the file are comma separated, which the function also assumes as default. \n", - "The file is located in the Session 5 folder and has 104329 rows. Print the head or the tail to see the imported data.\n", - "\n", - "*The data has all spring element forces in a bunch of load cases from a Sofistik finite element calculation. It's not strictly necessary to know what the data represents. It could just be looked at as dummy data to work with.*\n", - "\n", - "\n", - "# Exercise 2.2\n", - "*The model has many spring elements. Some of them represent shear keys between the structural parts of a tunnel at movement joint locations. These are the one we are going to extract.*\n", - "\n", - "The data has a column `'shear_key'` which has the name of the shear key if the element in that row is part of a shear key. E.g. `'Shear_key1'`. If the element is not part of a shear key, the name is `'Not_a_shear_key'`.\n", - "\n", - "Filter out all rows which are not part of a shear key. The resulting DataFrame should have 2874 rows. \n", - "\n", - "\n", - "# Exercise 2.3\n", - "Since we are not really using the column called `'Element_no'`, go ahead and remove it from the DataFrame. This can be done by\n", - "\n", - "---\n", - "~~~python \n", - "# Remove column 'column_name' form 'df'\n", - "df = df.drop('column_name', axis=1)\n", - "~~~\n", - "---\n", - "The argument `axis=1` specifies that it is a column and not a row that should be removed.\n", - "\n", - "*Remember to save to a new variable or use argument `inplace=True`. If you save to a variable, you can use the same name to 'overwrite' the old one if it's not needed anymore.*\n", - "\n", - "\n", - "# Exercise 2.4\n", - "*Each shear key consists of three spring elements. The total force that the shear key should be designed for is the sum of those three spring forces.*\n", - "\n", - "Create a DataFrame with the sum of the three values within each shear key for every load case. The resulting DataFrame should have 958 rows.\n", - "\n", - "\n", - "**Hint:** Use the methods `DataFrame.groupby()` and `DataFrame.sum()` like this:\n", - "\n", - "~~~python\n", - "df.groupby(['Shear_key', 'LC', 'LC-title'], as_index=False).sum()\n", - "~~~\n", - "Replace `df` with the name of your variable containing the DataFrame.\n", - "\n", - "Here, a list of column labels is passed in the `groupby()` method instead of just a single column label. The first column `'Shear_key'` is what is used to create the groups, while consecutive labels just follow. Any columns that are not passed in will not appear in the resulting DataFrame. \n", - "\n", - "# Exercise 2.5\n", - "Filter the DataFrame for a shear key, for example `'Shear_key1'` and create a bar plot of it with the `DataFrame.plot()` method. The bar plot should have the load cases as $x$-values and the force $P$ [kN] as $y$-values.\n", - "\n", - "---\n", - "~~~python\n", - "# Plot dataframe contents\n", - "df.plot(kind='bar', x='column_for_x_values', y='column_for_y_values')\n", - "~~~\n", - "---\n", - "\n", - "The method has many optional arguments, see https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.plot.html.\n", - "\n", - "Try for example to change the figure size by `figsize=(width, height)`, rotate the x-ticks by `rot=angle_in_degrees` and change the color of the bars by `color='some_color'`.\n", - "\n", - "# If you are up for more\n", - "Create a loop that goes through all shear keys, creates a plot like the one from the previous exercise and saves each plot to a png-file.\n" - ] } ], "metadata": { @@ -1947,7 +1956,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.1" + "version": "3.7.4" }, "latex_envs": { "LaTeX_envs_menu_present": true, diff --git a/Session 5 - Dataframes/Session 5 - Exercise Solutions.ipynb b/Session 5 - Dataframes/Session 5 - Exercise Solutions.ipynb index d91b503..93ab33f 100644 --- a/Session 5 - Dataframes/Session 5 - Exercise Solutions.ipynb +++ b/Session 5 - Dataframes/Session 5 - Exercise Solutions.ipynb @@ -1,9 +1,803 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 1.1" + ] + }, { "cell_type": "code", "execution_count": 1, "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "\n", + "# Import built-in libraries 'string' and 'random' \n", + "import random\n", + "import string\n", + "\n", + "# Get upper- and lowercase letters from 'string' library\n", + "lower = string.ascii_lowercase\n", + "upper = string.ascii_uppercase\n", + "\n", + "# Create a dictionary with dummy data of integers and letters\n", + "d = {'Integers': [random.randint(1, 100) for i in range(1, 100)],\n", + " 'Lowercase': [random.choice(lower) for i in range(1, 100)],\n", + " 'Uppercase': [random.choice(upper) for i in range(1, 100)]}\n", + "\n", + "# Create dataframe from dictionary\n", + "df = pd.DataFrame(d)\n", + "\n", + "# df # <- This would print all 100 rows" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 1.2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
IntegersLowercaseUppercase
096mS
147cI
213vM
\n", + "
" + ], + "text/plain": [ + " Integers Lowercase Uppercase\n", + "0 96 m S\n", + "1 47 c I\n", + "2 13 v M" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.head(3)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
IntegersLowercaseUppercase
9563dJ
9617jD
9711vV
9876pB
\n", + "
" + ], + "text/plain": [ + " Integers Lowercase Uppercase\n", + "95 63 d J\n", + "96 17 j D\n", + "97 11 v V\n", + "98 76 p B" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.tail(4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 1.3" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
IntegersLowercaseUppercase
1552xK
7741iK
\n", + "
" + ], + "text/plain": [ + " Integers Lowercase Uppercase\n", + "15 52 x K\n", + "77 41 i K" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dfk = df[df['Uppercase'] == 'K']\n", + "dfk.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 1.4" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
IntegersLowercaseUppercase
052xK
141iK
\n", + "
" + ], + "text/plain": [ + " Integers Lowercase Uppercase\n", + "0 52 x K\n", + "1 41 i K" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dfk = dfk.reset_index(drop=True)\n", + "dfk" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 2.1" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
LCLC-titleElement_noP[kN]Shear_key
04033Shear keys - W - 2553/2554101000010.1Shear_key20
14033Shear keys - W - 2553/2554101000020.1Shear_key20
24033Shear keys - W - 2553/2554101000030.0Shear_key20
34033Shear keys - W - 2553/255410100004-0.1Shear_key19
44033Shear keys - W - 2553/2554101000050.0Shear_key19
\n", + "
" + ], + "text/plain": [ + " LC LC-title Element_no P[kN] Shear_key\n", + "0 4033 Shear keys - W - 2553/2554 10100001 0.1 Shear_key20\n", + "1 4033 Shear keys - W - 2553/2554 10100002 0.1 Shear_key20\n", + "2 4033 Shear keys - W - 2553/2554 10100003 0.0 Shear_key20\n", + "3 4033 Shear keys - W - 2553/2554 10100004 -0.1 Shear_key19\n", + "4 4033 Shear keys - W - 2553/2554 10100005 0.0 Shear_key19" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Import csv file to dataframe\n", + "dfr = pd.read_csv('shear_key_forces.csv')\n", + "dfr.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 2.2" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
LCLC-titleElement_noP[kN]Shear_key
04033Shear keys - W - 2553/2554101000010.1Shear_key20
14033Shear keys - W - 2553/2554101000020.1Shear_key20
24033Shear keys - W - 2553/2554101000030.0Shear_key20
34033Shear keys - W - 2553/255410100004-0.1Shear_key19
44033Shear keys - W - 2553/2554101000050.0Shear_key19
\n", + "
" + ], + "text/plain": [ + " LC LC-title Element_no P[kN] Shear_key\n", + "0 4033 Shear keys - W - 2553/2554 10100001 0.1 Shear_key20\n", + "1 4033 Shear keys - W - 2553/2554 10100002 0.1 Shear_key20\n", + "2 4033 Shear keys - W - 2553/2554 10100003 0.0 Shear_key20\n", + "3 4033 Shear keys - W - 2553/2554 10100004 -0.1 Shear_key19\n", + "4 4033 Shear keys - W - 2553/2554 10100005 0.0 Shear_key19" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Filer dataframe to contain only shear keys \n", + "dfr = dfr[dfr['Shear_key'] != 'Not_a_shear_key']\n", + "dfr.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 2.3" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
LCLC-titleP[kN]Shear_key
04033Shear keys - W - 2553/25540.1Shear_key20
14033Shear keys - W - 2553/25540.1Shear_key20
24033Shear keys - W - 2553/25540.0Shear_key20
34033Shear keys - W - 2553/2554-0.1Shear_key19
44033Shear keys - W - 2553/25540.0Shear_key19
\n", + "
" + ], + "text/plain": [ + " LC LC-title P[kN] Shear_key\n", + "0 4033 Shear keys - W - 2553/2554 0.1 Shear_key20\n", + "1 4033 Shear keys - W - 2553/2554 0.1 Shear_key20\n", + "2 4033 Shear keys - W - 2553/2554 0.0 Shear_key20\n", + "3 4033 Shear keys - W - 2553/2554 -0.1 Shear_key19\n", + "4 4033 Shear keys - W - 2553/2554 0.0 Shear_key19" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dfr = dfr.drop('Element_no', axis=1)\n", + "dfr.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 2.4" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Shear_keyLCLC-titleP[kN]
0Shear_key14043Shear keys - W - remaining0.0
1Shear_key14044Top slab- beam shear keys activa-284.1
2Shear_key14045Protection concrete-300.6
3Shear_key14046Backfill-855.8
4Shear_key14047Ballast concrete of 16.8-900.3
\n", + "
" + ], + "text/plain": [ + " Shear_key LC LC-title P[kN]\n", + "0 Shear_key1 4043 Shear keys - W - remaining 0.0\n", + "1 Shear_key1 4044 Top slab- beam shear keys activa -284.1\n", + "2 Shear_key1 4045 Protection concrete -300.6\n", + "3 Shear_key1 4046 Backfill -855.8\n", + "4 Shear_key1 4047 Ballast concrete of 16.8 -900.3" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create groupby object and perform sum operation on it\n", + "dfr_sum = dfr.groupby(['Shear_key', 'LC', 'LC-title'], as_index=False).sum()\n", + "dfr_sum.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The list of column labels `['Shear_key', 'LC', 'LC-title']` are the columns that are to be present in the resulting dataframe. The parameter `as_index` is by default `True`, which would create a multiindex out of all the column labels listed. By setting `as_index=False`, we reset to 0-indexing. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 2.5" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Filter for shear key 1\n", + "df_key1 = dfr_sum[dfr_sum['Shear_key'] == 'Shear_key1']\n", + "\n", + "# Use built-in pandas plot\n", + "df_key1.plot(kind='bar', x='LC', y='P[kN]', rot=45, figsize=(15, 5), color='orange', alpha=0.50)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "> **Note:** The same plot could be constructed by extracting arrays in columns `'LC'` and `'P[kN]'` to variables and using `matplotlib` itself as `plt.bar(...)`. To do that, you would have to import `matplotlib.pyplot as plt`.\n", + "`pandas` just provides a shortcut to get a fast graph out." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# End of exercises\n", + "\n", + "*The cell below is for setting the style of this document. It's not part of the exercises.*" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, "outputs": [ { "data": { @@ -275,7 +1069,7 @@ "" ] }, - "execution_count": 1, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -284,819 +1078,6 @@ "from IPython.display import HTML\n", "HTML(''.format(open('../css/cowi.css').read()))" ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 1.1" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "import pandas as pd\n", - "\n", - "# Import built-in libraries 'string' and 'random' \n", - "import random\n", - "import string\n", - "\n", - "# Get upper- and lowercase letters from 'string' library\n", - "lower = string.ascii_lowercase\n", - "upper = string.ascii_uppercase\n", - "\n", - "# Create a dictionary with dummy data of integers and letters\n", - "d = {'Integers': [random.randint(1, 100) for i in range(1, 100)],\n", - " 'Lowercase': [random.choice(lower) for i in range(1, 100)],\n", - " 'Uppercase': [random.choice(upper) for i in range(1, 100)]}\n", - "\n", - "# Create dataframe from dictionary\n", - "df = pd.DataFrame(d)\n", - "\n", - "# df # <- This would print all 100 rows" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 1.2" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
IntegersLowercaseUppercase
052iV
124jX
29hG
\n", - "
" - ], - "text/plain": [ - " Integers Lowercase Uppercase\n", - "0 52 i V\n", - "1 24 j X\n", - "2 9 h G" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df.head(3)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
IntegersLowercaseUppercase
9561zZ
9636lT
9737lW
9883yK
\n", - "
" - ], - "text/plain": [ - " Integers Lowercase Uppercase\n", - "95 61 z Z\n", - "96 36 l T\n", - "97 37 l W\n", - "98 83 y K" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df.tail(4)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 1.3" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
IntegersLowercaseUppercase
968pK
3345oK
921cK
9883yK
\n", - "
" - ], - "text/plain": [ - " Integers Lowercase Uppercase\n", - "9 68 p K\n", - "33 45 o K\n", - "92 1 c K\n", - "98 83 y K" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dfk = df[df['Uppercase'] == 'K']\n", - "dfk.head()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 1.4" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
IntegersLowercaseUppercase
068pK
145oK
21cK
383yK
\n", - "
" - ], - "text/plain": [ - " Integers Lowercase Uppercase\n", - "0 68 p K\n", - "1 45 o K\n", - "2 1 c K\n", - "3 83 y K" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dfk = dfk.reset_index(drop=True)\n", - "dfk" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 2.1" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
LCLC-titleElement_noP[kN]Shear_key
04033Shear keys - W - 2553/2554101000010.1Shear_key20
14033Shear keys - W - 2553/2554101000020.1Shear_key20
24033Shear keys - W - 2553/2554101000030.0Shear_key20
34033Shear keys - W - 2553/255410100004-0.1Shear_key19
44033Shear keys - W - 2553/2554101000050.0Shear_key19
\n", - "
" - ], - "text/plain": [ - " LC LC-title Element_no P[kN] Shear_key\n", - "0 4033 Shear keys - W - 2553/2554 10100001 0.1 Shear_key20\n", - "1 4033 Shear keys - W - 2553/2554 10100002 0.1 Shear_key20\n", - "2 4033 Shear keys - W - 2553/2554 10100003 0.0 Shear_key20\n", - "3 4033 Shear keys - W - 2553/2554 10100004 -0.1 Shear_key19\n", - "4 4033 Shear keys - W - 2553/2554 10100005 0.0 Shear_key19" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Import csv file to dataframe\n", - "dfr = pd.read_csv('shear_key_forces.csv')\n", - "dfr.head()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 2.2" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
LCLC-titleElement_noP[kN]Shear_key
04033Shear keys - W - 2553/2554101000010.1Shear_key20
14033Shear keys - W - 2553/2554101000020.1Shear_key20
24033Shear keys - W - 2553/2554101000030.0Shear_key20
34033Shear keys - W - 2553/255410100004-0.1Shear_key19
44033Shear keys - W - 2553/2554101000050.0Shear_key19
\n", - "
" - ], - "text/plain": [ - " LC LC-title Element_no P[kN] Shear_key\n", - "0 4033 Shear keys - W - 2553/2554 10100001 0.1 Shear_key20\n", - "1 4033 Shear keys - W - 2553/2554 10100002 0.1 Shear_key20\n", - "2 4033 Shear keys - W - 2553/2554 10100003 0.0 Shear_key20\n", - "3 4033 Shear keys - W - 2553/2554 10100004 -0.1 Shear_key19\n", - "4 4033 Shear keys - W - 2553/2554 10100005 0.0 Shear_key19" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Filer dataframe to contain only shear keys \n", - "dfr = dfr[dfr['Shear_key'] != 'Not_a_shear_key']\n", - "dfr.head()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 2.3" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
LCLC-titleP[kN]Shear_key
04033Shear keys - W - 2553/25540.1Shear_key20
14033Shear keys - W - 2553/25540.1Shear_key20
24033Shear keys - W - 2553/25540.0Shear_key20
34033Shear keys - W - 2553/2554-0.1Shear_key19
44033Shear keys - W - 2553/25540.0Shear_key19
\n", - "
" - ], - "text/plain": [ - " LC LC-title P[kN] Shear_key\n", - "0 4033 Shear keys - W - 2553/2554 0.1 Shear_key20\n", - "1 4033 Shear keys - W - 2553/2554 0.1 Shear_key20\n", - "2 4033 Shear keys - W - 2553/2554 0.0 Shear_key20\n", - "3 4033 Shear keys - W - 2553/2554 -0.1 Shear_key19\n", - "4 4033 Shear keys - W - 2553/2554 0.0 Shear_key19" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dfr = dfr.drop('Element_no', axis=1)\n", - "dfr.head()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 2.4" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Shear_keyLCLC-titleP[kN]
0Shear_key14043Shear keys - W - remaining0.0
1Shear_key14044Top slab- beam shear keys activa-284.1
2Shear_key14045Protection concrete-300.6
3Shear_key14046Backfill-855.8
4Shear_key14047Ballast concrete of 16.8-900.3
\n", - "
" - ], - "text/plain": [ - " Shear_key LC LC-title P[kN]\n", - "0 Shear_key1 4043 Shear keys - W - remaining 0.0\n", - "1 Shear_key1 4044 Top slab- beam shear keys activa -284.1\n", - "2 Shear_key1 4045 Protection concrete -300.6\n", - "3 Shear_key1 4046 Backfill -855.8\n", - "4 Shear_key1 4047 Ballast concrete of 16.8 -900.3" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Create groupby object and perform sum operation on it\n", - "dfr_sum = dfr.groupby(['Shear_key', 'LC', 'LC-title'], as_index=False).sum()\n", - "dfr_sum.head()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The list of column labels `['Shear_key', 'LC', 'LC-title']` are the columns that are to be present in the resulting dataframe. The parameter `as_index` is by default `True`, which would create a multiindex out of all the column labels listed. By setting `as_index=False`, we reset to 0-indexing. " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 2.5" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Filter for shear key 1\n", - "df_key1 = dfr_sum[dfr_sum['Shear_key'] == 'Shear_key1']\n", - "\n", - "# Use built-in pandas plot\n", - "df_key1.plot(kind='bar', x='LC', y='P[kN]', rot=45, figsize=(15, 5), color='orange', alpha=0.50)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "> **Note:** The same plot could be constructed by extracting arrays in columns `'LC'` and `'P[kN]'` to variables and using `matplotlib` itself as `plt.bar(...)`. To do that, you would have to import `matplotlib.pyplot as plt`.\n", - "`pandas` just provides a shortcut to get a fast graph out." - ] } ], "metadata": { @@ -1116,7 +1097,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.1" + "version": "3.7.4" }, "latex_envs": { "LaTeX_envs_menu_present": true, diff --git a/Session 6 - Exercise (shear key plots)/Session 6 - Exercise (shear key plots).ipynb b/Session 6 - Exercise (shear key plots)/Session 6 - Exercise (shear key plots).ipynb index 7f1ce65..2fba652 100644 --- a/Session 6 - Exercise (shear key plots)/Session 6 - Exercise (shear key plots).ipynb +++ b/Session 6 - Exercise (shear key plots)/Session 6 - Exercise (shear key plots).ipynb @@ -1,5 +1,200 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 6. Exercise \n", + "\n", + "## Intro\n", + "This exercise is taken from a project example where shear forces in a shell element from a Sofistik Finite Element calculation are extracted and plotted into one figure per Construction Stage. \n", + "\n", + "The purpose of this procedure to give a quick overview of the results after a calculation has finished, and to be able to flip through the Construction Stages to easily compare them. \n", + "\n", + "There are in total 56 Construction Stages in the dataset used and three different shear keys, resulting in 168 plots.\n", + "\n", + "Each plot will look something like this: \n", + "\n", + "![title](BS301_LC4069.png)\n", + "\n", + "Some plots will be almost empty as loads are close to zero in some Stages. \n", + "\n", + "The dataset is called `shear_keys_base_slab_v20.txt` and can be found in the Session 6 folder for the course. \n", + "\n", + "> **Note:** Understanding the structural context of the dataset is not important for solving the exercise. The same concepts could be used for all other types of datasets. \n", + "\n", + "## The exercise\n", + "As stated, this little program was originally used on a project. The general structure of the script is given and provides the basis for the exercise. Many code lines have been removed and the exercise consists of filling them in again.\n", + "\n", + "All code comments from the original script have been retained as guidance through the exercise. \n", + "\n", + "The problem is partly about reading and understanding already written code and partly about writing code yourself. \n", + "\n", + "Reading other people's code plays a big role when collaboration on programming projects, and it's sometimes harder than writing the code yourself. Thus, it's a good exercise to get some exposure to this.\n", + "\n", + "Before starting, open the dataset file `shear_keys_base_slab_v20.txt` and take a brief look to get a feel for what you are working with. \n", + "\n", + "Copy this directly into your editor to use as a guide through the exercise. \n", + "\n", + "---\n", + "~~~python\n", + "# Import libraries \n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "# Set style for matplotlib plots\n", + "plt.style.use('seaborn-whitegrid') \n", + "\n", + "# Dictionary for mapping node numbers to user chosen shear key names\n", + "shear_keys = { \n", + " # Shear key in Base Slab 101\n", + " 'BS101': range(10101, 10199), \n", + " \n", + " # Shear key in Base Slab 201\n", + " 'BS201': range(20101, 20199), \n", + " \n", + " # Shear key in Base Slab 301 \n", + " 'BS301': range(30101, 30214), \n", + "} \n", + " \n", + "# Set name of file that contains the dataset\n", + "file_name = 'shear_keys_base_slab_v20.txt'\n", + "\n", + "# Read dataset from text file into dataframe, save it as 'df'\n", + " # \n", + "\n", + "# Extract version number from file name as 'vXX'\n", + "# (assume the last 6 characters will always be '...vXX.txt')\n", + " # \n", + "\n", + "# Print the head of the dataframe to check it\n", + " # \n", + "\n", + "# Construct a dictionary that maps load case numbers to titles (dict auto removes duplicates)\n", + "lc_no_to_title_map = dict(zip(df['LC'], df['LC-title'])) \n", + " \n", + "# Loop over all shear key names and their corresponding node numbers \n", + "for shear_key, nodes in shear_keys.items():\n", + " \n", + " # Loop over all load cases, create plots and save them to a png-file\n", + " for lc in df['LC'].unique():\n", + "\n", + " # Get title of current load case from mapping dictionary\n", + " # (see hint 1 below)\n", + " \n", + " # Filter dataframe based on load case and nodes in shear key\n", + " # (see hint 2 below)\n", + " \n", + " # Create figure\n", + " # \n", + " \n", + " # Create x-values for plot as numbers running from 1 to length of y-values\n", + " # \n", + " \n", + " # Create y-values for plot as shear forces vx\n", + " # \n", + " \n", + " # Extract indices where y-values are negative and positive, respectively\n", + " idx_neg = np.where(y<0)\n", + " idx_pos = np.where(y>=0)\n", + " \n", + " # Extract x-values where y-values are negative and positive, respectively\n", + " x_neg, x_pos = np.take(x, idx_neg)[0], np.take(x, idx_pos)[0]\n", + " \n", + " # Extract y-values where y-values are negative and positive, respectively\n", + " y_neg, y_pos = np.take(y, idx_neg)[0], np.take(y, idx_pos)[0]\n", + " \n", + " # Plot points for negative and positve values as two separate lines\n", + " # \n", + " \n", + " # Fill between y=0 and the lines where y-values are negative and positive, respectively \n", + " # \n", + " \n", + " # Set titles and x- and y-labels\n", + " # \n", + " \n", + " # Save figure to png-file with meaningful name that varies in every loop\n", + " # \n", + "~~~\n", + "---\n", + "### The hints below refer to the comments in the code above.\n", + "\n", + "* **Hint 1:** The dictionary `lc_no_to_title_map` has load case numbers as keys and the corresponding titles as values. Use this to get the load case title from inside the loop.\n", + "\n", + "* **Hint 2:** Be sure to save the filtered DataFrame to a new variable. If it is saved to a variable of the same name it will be mutated in every loop and quickly end up empty. \n", + "\n", + "### Looping over dictionary items\n", + "The outer loop the iterates over the key/value pairs of the dictionary called `shear_keys`. The key/value pairs in a dictionary are referred to as its **items**.\n", + "\n", + "`shear_keys.items()` returns the key and value in each loop:\n", + "\n", + "---\n", + "```python\n", + "for key, value in shear_keys.items():\n", + " print(key, value)\n", + "```\n", + "would print:\n", + "\n", + "```\n", + "BS101 range(10101, 10199)\n", + "BS201 range(20101, 20199)\n", + "BS301 range(30101, 30214)\n", + "```\n", + "----\n", + "\n", + "This functionality is equivalent to using `zip()` with lists of keys and values as arguments:\n", + "\n", + "```python\n", + "for key, value in zip(shear_keys.keys(), shear_keys.values()):\n", + " print(key, value)\n", + "```\n", + "which would print exactly the same. \n", + "The built-in dictionary class in Python just has a method for creating this common type of iteration so it is more readable using `dict.items()`.\n", + "\n", + "### Some improvements\n", + "\n", + "* Comparison between the plots when flipping through them could be improved by having the same limits for the y-axis on all plots. This can be set by `ax.set_ylim(bottom_limit, top_limit)`. If any of them are left undefined they will be auto adjusted by default.\n", + "\n", + "Source: https://matplotlib.org/3.1.1/api/_as_gen/matplotlib.axes.Axes.set_ylim.html\n", + "\n", + "\n", + "* The function below can find the indices of the peak values, which can be used to annotate the key points to make the plot easier to read. \n", + "\n", + "---\n", + "~~~python\n", + "def find_local_extrema(y_curve):\n", + " '''\n", + " Return indices of all local extrema for the given sequence of values. Indices are sorted in\n", + " ascending format with no distinction between local maximum and minimum.\n", + " '''\n", + " local_max, _ = find_peaks(y_curve, height=0)\n", + " local_min, _ = find_peaks(-y_curve, height=0)\n", + " return sorted( np.append(local_min, local_max) ) \n", + "~~~\n", + "---\n", + "\n", + "Prior to running the function, `find_peaks` from the `scipy` library must be imported: `from scipy.signal import find_peaks`\n", + "\n", + "After having found the extrema values, they can be annotated like so:\n", + "\n", + "---\n", + "~~~python\n", + "for extr_val in extrema_values:\n", + " ax.annotate(f'{y[extr_val]:.0f}', xy=(x[extr_val], y[extr_val]), xytext=(x[extr_val], y[extr_val]))\n", + "~~~\n", + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# End of exercises\n", + "\n", + "*The cell below is for setting the style of this document. It's not part of the exercises.*" + ] + }, { "cell_type": "code", "execution_count": 1, @@ -284,192 +479,6 @@ "from IPython.display import HTML\n", "HTML(''.format(open('../css/cowi.css').read()))" ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# 6. Exercise \n", - "\n", - "## Intro\n", - "This exercise is taken from a project example where shear forces in a shell element from a Sofistik Finite Element calculation are extracted and plotted into one figure per Construction Stage. \n", - "\n", - "The purpose of this procedure to give a quick overview of the results after a calculation has finished, and to be able to flip through the Construction Stages to easily compare them. \n", - "\n", - "There are in total 56 Construction Stages in the dataset used and three different shear keys, resulting in 168 plots.\n", - "\n", - "Each plot will look something like this: \n", - "\n", - "![title](BS301_LC4069.png)\n", - "\n", - "Some plots will be almost empty as loads are close to zero in some Stages. \n", - "\n", - "The dataset is called `shear_keys_base_slab_v20.txt` and can be found in the Session 6 folder for the course. \n", - "\n", - "> **Note:** Understanding the structural context of the dataset is not important for solving the exercise. The same concepts could be used for all other types of datasets. \n", - "\n", - "## The exercise\n", - "As stated, this little program was originally used on a project. The general structure of the script is given and provides the basis for the exercise. Many code lines have been removed and the exercise consists of filling them in again.\n", - "\n", - "All code comments from the original script have been retained as guidance through the exercise. \n", - "\n", - "The problem is partly about reading and understanding already written code and partly about writing code yourself. \n", - "\n", - "Reading other people's code plays a big role when collaboration on programming projects, and it's sometimes harder than writing the code yourself. Thus, it's a good exercise to get some exposure to this.\n", - "\n", - "Before starting, open the dataset file `shear_keys_base_slab_v20.txt` and take a brief look to get a feel for what you are working with. \n", - "\n", - "Copy this directly into your editor to use as a guide through the exercise. \n", - "\n", - "---\n", - "~~~python\n", - "# Import libraries \n", - "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "\n", - "# Set style for matplotlib plots\n", - "plt.style.use('seaborn-whitegrid') \n", - "\n", - "# Dictionary for mapping node numbers to user chosen shear key names\n", - "shear_keys = { \n", - " # Shear key in Base Slab 101\n", - " 'BS101': range(10101, 10199), \n", - " \n", - " # Shear key in Base Slab 201\n", - " 'BS201': range(20101, 20199), \n", - " \n", - " # Shear key in Base Slab 301 \n", - " 'BS301': range(30101, 30214), \n", - "} \n", - " \n", - "# Set name of file that contains the dataset\n", - "file_name = 'shear_keys_base_slab_v20.txt'\n", - "\n", - "# Read dataset from text file into dataframe, save it as 'df'\n", - " # \n", - "\n", - "# Extract version number from file name as 'vXX'\n", - "# (assume the last 6 characters will always be '...vXX.txt')\n", - " # \n", - "\n", - "# Print the head of the dataframe to check it\n", - " # \n", - "\n", - "# Construct a dictionary that maps load case numbers to titles (dict auto removes duplicates)\n", - "lc_no_to_title_map = dict(zip(df['LC'], df['LC-title'])) \n", - " \n", - "# Loop over all shear key names and their corresponding node numbers \n", - "for shear_key, nodes in shear_keys.items():\n", - " \n", - " # Loop over all load cases, create plots and save them to a png-file\n", - " for lc in df['LC'].unique():\n", - "\n", - " # Get title of current load case from mapping dictionary\n", - " # (see hint 1 below)\n", - " \n", - " # Filter dataframe based on load case and nodes in shear key\n", - " # (see hint 2 below)\n", - " \n", - " # Create figure\n", - " # \n", - " \n", - " # Create x-values for plot as numbers running from 1 to length of y-values\n", - " # \n", - " \n", - " # Create y-values for plot as shear forces vx\n", - " # \n", - " \n", - " # Extract indices where y-values are negative and positive, respectively\n", - " idx_neg = np.where(y<0)\n", - " idx_pos = np.where(y>=0)\n", - " \n", - " # Extract x-values where y-values are negative and positive, respectively\n", - " x_neg, x_pos = np.take(x, idx_neg)[0], np.take(x, idx_pos)[0]\n", - " \n", - " # Extract y-values where y-values are negative and positive, respectively\n", - " y_neg, y_pos = np.take(y, idx_neg)[0], np.take(y, idx_pos)[0]\n", - " \n", - " # Plot points for negative and positve values as two separate lines\n", - " # \n", - " \n", - " # Fill between y=0 and the lines where y-values are negative and positive, respectively \n", - " # \n", - " \n", - " # Set titles and x- and y-labels\n", - " # \n", - " \n", - " # Save figure to png-file with meaningful name that varies in every loop\n", - " # \n", - "~~~\n", - "---\n", - "### The hints below refer to the comments in the code above.\n", - "\n", - "* **Hint 1:** The dictionary `lc_no_to_title_map` has load case numbers as keys and the corresponding titles as values. Use this to get the load case title from inside the loop.\n", - "\n", - "* **Hint 2:** Be sure to save the filtered DataFrame to a new variable. If it is saved to a variable of the same name it will be mutated in every loop and quickly end up empty. \n", - "\n", - "### Looping over dictionary items\n", - "The outer loop the iterates over the key/value pairs of the dictionary called `shear_keys`. The key/value pairs in a dictionary are referred to as its **items**.\n", - "\n", - "`shear_keys.items()` returns the key and value in each loop:\n", - "\n", - "---\n", - "```python\n", - "for key, value in shear_keys.items():\n", - " print(key, value)\n", - "```\n", - "would print:\n", - "\n", - "```\n", - "BS101 range(10101, 10199)\n", - "BS201 range(20101, 20199)\n", - "BS301 range(30101, 30214)\n", - "```\n", - "----\n", - "\n", - "This functionality is equivalent to using `zip()` with lists of keys and values as arguments:\n", - "\n", - "```python\n", - "for key, value in zip(shear_keys.keys(), shear_keys.values()):\n", - " print(key, value)\n", - "```\n", - "which would print exactly the same. \n", - "The built-in dictionary class in Python just has a method for creating this common type of iteration so it is more readable using `dict.items()`.\n", - "\n", - "### Some improvements\n", - "\n", - "* Comparison between the plots when flipping through them could be improved by having the same limits for the y-axis on all plots. This can be set by `ax.set_ylim(bottom_limit, top_limit)`. If any of them are left undefined they will be auto adjusted by default.\n", - "\n", - "Source: https://matplotlib.org/3.1.1/api/_as_gen/matplotlib.axes.Axes.set_ylim.html\n", - "\n", - "\n", - "* The function below can find the indices of the peak values, which can be used to annotate the key points to make the plot easier to read. \n", - "\n", - "---\n", - "~~~python\n", - "def find_local_extrema(y_curve):\n", - " '''\n", - " Return indices of all local extrema for the given sequence of values. Indices are sorted in\n", - " ascending format with no distinction between local maximum and minimum.\n", - " '''\n", - " local_max, _ = find_peaks(y_curve, height=0)\n", - " local_min, _ = find_peaks(-y_curve, height=0)\n", - " return sorted( np.append(local_min, local_max) ) \n", - "~~~\n", - "---\n", - "\n", - "Prior to running the function, `find_peaks` from the `scipy` library must be imported: `from scipy.signal import find_peaks`\n", - "\n", - "After having found the extrema values, they can be annotated like so:\n", - "\n", - "---\n", - "~~~python\n", - "for extr_val in extrema_values:\n", - " ax.annotate(f'{y[extr_val]:.0f}', xy=(x[extr_val], y[extr_val]), xytext=(x[extr_val], y[extr_val]))\n", - "~~~\n", - "---" - ] } ], "metadata": { @@ -489,7 +498,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.1" + "version": "3.7.4" }, "latex_envs": { "LaTeX_envs_menu_present": true, diff --git a/Session 6 - Exercise (shear key plots)/Session 6 - Exercise Solutions.ipynb b/Session 6 - Exercise (shear key plots)/Session 6 - Exercise Solutions.ipynb index 3d77381..3c962ea 100644 --- a/Session 6 - Exercise (shear key plots)/Session 6 - Exercise Solutions.ipynb +++ b/Session 6 - Exercise (shear key plots)/Session 6 - Exercise Solutions.ipynb @@ -1,8 +1,317 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 6. Exercise solution" + ] + }, { "cell_type": "code", "execution_count": 1, + "metadata": { + "code_folding": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
LCLC-titleNRNGvx[kN/m]
04031Shear keys - BS - 2553/2554201012012.33
14031Shear keys - BS - 2553/2554201022011.29
24031Shear keys - BS - 2553/2554201032010.87
34031Shear keys - BS - 2553/2554201042010.74
44031Shear keys - BS - 2553/2554201052010.64
\n", + "
" + ], + "text/plain": [ + " LC LC-title NR NG vx[kN/m]\n", + "0 4031 Shear keys - BS - 2553/2554 20101 201 2.33\n", + "1 4031 Shear keys - BS - 2553/2554 20102 201 1.29\n", + "2 4031 Shear keys - BS - 2553/2554 20103 201 0.87\n", + "3 4031 Shear keys - BS - 2553/2554 20104 201 0.74\n", + "4 4031 Shear keys - BS - 2553/2554 20105 201 0.64" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Import libraries \n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "# Set style for matplotlib plots\n", + "plt.style.use('seaborn-whitegrid') \n", + "\n", + "# Dictionary for mapping node numbers to user chosen shear key names\n", + "shear_keys = { \n", + " # Shear key in Base Slab 101\n", + " 'BS101': range(10101, 10199), \n", + "\n", + " # Shear key in Base Slab 201\n", + " 'BS201': range(20101, 20199), \n", + "\n", + " # Shear key in Base Slab 301 \n", + " 'BS301': range(30101, 30214), \n", + "} \n", + "\n", + "# Set file name of dataset\n", + "file_name = 'shear_keys_base_slab_v20.txt'\n", + "\n", + "# Read dataset from text file into dataframe, save it as 'df'\n", + "df = pd.read_csv(file_name)\n", + "\n", + "# Extract version number from file name as 'vXX'\n", + "# (assume the last 6 characters will always be '...vXX.txt')\n", + "version_number = file_name[-7:-4]\n", + "\n", + "# Print the head of the dataframe to check it\n", + "df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "ename": "FileNotFoundError", + "evalue": "[Errno 2] No such file or directory: 'Plots/v20/BS101_4031.png'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 51\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 52\u001b[0m \u001b[1;31m# Save figure to png-file with meaningful name that varies in every loop\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 53\u001b[1;33m \u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msavefig\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf'Plots/{version_number}/{shear_key}_{lc}.png'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;32m~\\AppData\\Local\\Continuum\\miniconda3\\lib\\site-packages\\matplotlib\\pyplot.py\u001b[0m in \u001b[0;36msavefig\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m 720\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0msavefig\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 721\u001b[0m \u001b[0mfig\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mgcf\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 722\u001b[1;33m \u001b[0mres\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mfig\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msavefig\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 723\u001b[0m \u001b[0mfig\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcanvas\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdraw_idle\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# need this if 'transparent=True' to reset colors\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 724\u001b[0m \u001b[1;32mreturn\u001b[0m \u001b[0mres\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m~\\AppData\\Local\\Continuum\\miniconda3\\lib\\site-packages\\matplotlib\\figure.py\u001b[0m in \u001b[0;36msavefig\u001b[1;34m(self, fname, transparent, **kwargs)\u001b[0m\n\u001b[0;32m 2178\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpatch\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mset_visible\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mframeon\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2179\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 2180\u001b[1;33m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcanvas\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mprint_figure\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfname\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 2181\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2182\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mframeon\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m~\\AppData\\Local\\Continuum\\miniconda3\\lib\\site-packages\\matplotlib\\backend_bases.py\u001b[0m in \u001b[0;36mprint_figure\u001b[1;34m(self, filename, dpi, facecolor, edgecolor, orientation, format, bbox_inches, **kwargs)\u001b[0m\n\u001b[0;32m 2080\u001b[0m \u001b[0morientation\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0morientation\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2081\u001b[0m \u001b[0mbbox_inches_restore\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0m_bbox_inches_restore\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 2082\u001b[1;33m **kwargs)\n\u001b[0m\u001b[0;32m 2083\u001b[0m \u001b[1;32mfinally\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2084\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mbbox_inches\u001b[0m \u001b[1;32mand\u001b[0m \u001b[0mrestore_bbox\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m~\\AppData\\Local\\Continuum\\miniconda3\\lib\\site-packages\\matplotlib\\backends\\backend_agg.py\u001b[0m in \u001b[0;36mprint_png\u001b[1;34m(self, filename_or_obj, metadata, pil_kwargs, *args, **kwargs)\u001b[0m\n\u001b[0;32m 528\u001b[0m \u001b[0mrenderer\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget_renderer\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 529\u001b[0m \u001b[1;32mwith\u001b[0m \u001b[0mcbook\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_setattr_cm\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdpi\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdpi\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0;31m \u001b[0m\u001b[0;31m\\\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 530\u001b[1;33m \u001b[0mcbook\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mopen_file_cm\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfilename_or_obj\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"wb\"\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0mfh\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 531\u001b[0m _png.write_png(renderer._renderer, fh,\n\u001b[0;32m 532\u001b[0m self.figure.dpi, metadata=metadata)\n", + "\u001b[1;32m~\\AppData\\Local\\Continuum\\miniconda3\\lib\\contextlib.py\u001b[0m in \u001b[0;36m__enter__\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 110\u001b[0m \u001b[1;32mdel\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mkwds\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfunc\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 111\u001b[0m \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 112\u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mnext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mgen\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 113\u001b[0m \u001b[1;32mexcept\u001b[0m \u001b[0mStopIteration\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 114\u001b[0m \u001b[1;32mraise\u001b[0m \u001b[0mRuntimeError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"generator didn't yield\"\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mfrom\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m~\\AppData\\Local\\Continuum\\miniconda3\\lib\\site-packages\\matplotlib\\cbook\\__init__.py\u001b[0m in \u001b[0;36mopen_file_cm\u001b[1;34m(path_or_file, mode, encoding)\u001b[0m\n\u001b[0;32m 445\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mopen_file_cm\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mpath_or_file\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmode\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m\"r\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mencoding\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 446\u001b[0m \u001b[1;34mr\"\"\"Pass through file objects and context-manage `.PathLike`\\s.\"\"\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 447\u001b[1;33m \u001b[0mfh\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mopened\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mto_filehandle\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mpath_or_file\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmode\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;32mTrue\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mencoding\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 448\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mopened\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 449\u001b[0m \u001b[1;32mwith\u001b[0m \u001b[0mfh\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m~\\AppData\\Local\\Continuum\\miniconda3\\lib\\site-packages\\matplotlib\\cbook\\__init__.py\u001b[0m in \u001b[0;36mto_filehandle\u001b[1;34m(fname, flag, return_opened, encoding)\u001b[0m\n\u001b[0;32m 430\u001b[0m \u001b[0mfh\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mbz2\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mBZ2File\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfname\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mflag\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 431\u001b[0m \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 432\u001b[1;33m \u001b[0mfh\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mopen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfname\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mflag\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mencoding\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mencoding\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 433\u001b[0m \u001b[0mopened\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mTrue\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 434\u001b[0m \u001b[1;32melif\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfname\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'seek'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'Plots/v20/BS101_4031.png'" + ] + } + ], + "source": [ + "%%capture\n", + "# %%capture prevent plots from showing as cell output\n", + "# ------------------------------------------------------\n", + "\n", + "# Contruct a dictionary that maps load case numbers to titles (auto removes duplicates)\n", + "lc_no_to_title_map = dict(zip(df['LC'], df['LC-title'])) \n", + "\n", + "# Loop over all shear key names and their corresponding node numbers \n", + "for shear_key, nodes in shear_keys.items():\n", + "\n", + " # Loop over all load cases, create plots and save them to a png-file\n", + " for lc in df['LC'].unique():\n", + "\n", + " # Get title of current load case from mapping dictionary\n", + " lc_title = lc_no_to_title_map[lc]\n", + " \n", + " # Filter dataframe based on load case and nodes in shear key\n", + " df_filtered = df[(df['LC'] == lc) & (df['NR'].isin(nodes))]\n", + " \n", + " # Create figure\n", + " plt.figure(figsize=(12, 5))\n", + " \n", + " # Create x-values for plot as numbers running from 1 to length of y-values\n", + " x = np.array(range(1, len(df_filtered['vx[kN/m]'])+1))\n", + " \n", + " # Create y-values for plot as shear forces vx\n", + " y = df_filtered['vx[kN/m]'].values\n", + " \n", + " # Extract indices where y-values are negative and positive, respectively\n", + " idx_neg = np.where(y<0)\n", + " idx_pos = np.where(y>=0)\n", + "\n", + " # Extract x-values where y-values are negative and positive, respectively\n", + " x_neg, x_pos = np.take(x, idx_neg)[0], np.take(x, idx_pos)[0]\n", + "\n", + " # Extract y-values where y-values are negative and positive, respectively\n", + " y_neg, y_pos = np.take(y, idx_neg)[0], np.take(y, idx_pos)[0]\n", + "\n", + " # Plot lines for negative and positve values as two separate lines\n", + " plt.plot(x_neg, y_neg, '.', color='salmon')\n", + " plt.plot(x_pos, y_pos, '.', color='cornflowerblue') \n", + " \n", + " # Fill between y=0 and the lines where y-values are negative and positive, respectively \n", + " plt.fill_between(x, y, where=y<0, color='salmon', alpha=0.25, interpolate=True)\n", + " plt.fill_between(x, y, where=y>=0, color='cornflowerblue', alpha=0.25, interpolate=True)\n", + " \n", + " # Set titles and x- and y-labels\n", + " plt.title(f'Shear force $vx$ [kN/m] for base slab shear key ${shear_key}$' + '\\n' +\n", + " f'{lc_title} $(LC: {lc}) ({version_number})$', fontsize=18)\n", + " plt.xlabel('Points along shear key', fontsize=14)\n", + " plt.ylabel('Slab shear force $vx$ [kN/m]', fontsize=14)\n", + " \n", + " # Save figure to png-file with meaningful name that varies in every loop\n", + " plt.savefig(f'Plots/{version_number}/{shear_key}_{lc}.png')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Explanations to some of the code lines are given below\n", + "\n", + "* **Line with `df_filtered = ...`:** The dataframe `df_filtered` is uniqie in every loop, since it is filtered based on the current load case and the nodes in the current shear key. The filtering is done based on the original large dataframe. Every operation from here on out inside the loop must use `df_filtered` and not the original dataframe. For filtering based on the nodes in the shear key `.isin` is used. This is a good way to filter based on values in a list. And the nodes for each shear key is is stored in the loop variable `nodes` as a list.\n", + "\n", + "\n", + "* **Line with `x = ...`:** This generates the x-values, which will just be increasing numbers from 1 and up. Note that `range(start, stop)` goes from `start` to `stop-1`. \n", + "\n", + "\n", + "* **Line with `y = ...`:** Collects the y-values for the plot in the current loop. `df['vx[kN/m']]` extracts a Series, which is a single column, but with index numbers to its left. To get only the column values as an array, we do `df['vx[kN/m']].values`. Btw, this will also work for dataframes, but will return a 'matrix' array instead of a 'vector' array as for Series.\n", + "\n", + "\n", + "* **Lines with `plt.plot()`:** The negative and positive points are plotting as two separate data series so they can have different colors. Connecting the points by lines makes the plot look strange after it has been separated, so only points are plotted. \n", + "\n", + "\n", + "* **Lines with `plt.fillbetween()`:** Parameter `alpha` set the opacity. Parameter `interpolate=True` will make sure the fill is not \"cut off\" near a crossing of the y-axis.\n", + "\n", + "\n", + "* **Lines with for `plt.title()`**: When creating plots by loops the title for each plot should probably have a unique title that varies with the loop variable(s). Then saving to a file this is important in order to not overwrite the plot with the same name in each loop. A convenient way to put variables inside text is by using f-strings. \n", + "\n", + "\n", + "* **Line with `plt.savefig()`** A subfolder called `Plots` and a subsubfolder with the version number `v20` have to be created before running this. It the folders are not present `FileNoteFoundError` will be raised. Alternatively, the png-files could be saved directly in the same folder as the script. In that case only `'.png'` would be necessary as the argument for `plt.savefig()`. By saving in a subfolder whose name depends on the version number given in the name original txt file, it is easier to keep track of versions and avoid overwriting files from previous versions. \n", + "\n", + "## Improvements mentioned in exercise text\n", + "\n", + "### y-limits of plot\n", + "Set the y-limits of the plot by `plt.ylim([ymin, ymax])`. \n", + "\n", + "`ymin` and `ymax` could be determined as the largest occuring magnitude values among all plots. \n", + "\n", + "~~~python \n", + "# Put this line before the loop\n", + "all_loads = df['vx[kN/m]']\n", + "extr_magnitude = max(abs(min(all_loads)), abs(max(all_loads)))\n", + "~~~\n", + "\n", + "~~~python\n", + "# Put this line in each loop before saving the figure\n", + "plt.ylim([-1.1*extr_magnitude, 1.1*extr_magnitude])\n", + "~~~\n", + "\n", + "\n", + "### Annotations of local extrema\n", + "For annotating the local extrema points, define the function `find_local_extrema(y_curve)` from the exercise text somewhere in the script before the loop. \n", + "\n", + "Afterwards, include the lines below within the for loop. They should be placed somewhere between when the figure is creates and when it's saved.\n", + "\n", + "~~~python\n", + "# Find local extrema points of graph\n", + "extrema_indices = find_local_extrema(y)\n", + "\n", + "# Annotate each points on the plot\n", + "for extr_idx in extreme_indices:\n", + " ax.annotate(f'{y[extr_idx]:.0f}', xy=(x[extr_idx], y[extr_idx]), xytext=(x[extr_idx], y[extr_idx]))\n", + "~~~\n", + "\n", + "This annotates the local peaks which helps for readability of the graph. The annotations could be even better than this by ensuring that text does not overlap. and by always annotating the two end points of the graph.\n", + "\n", + "Documentation for annotating method: https://matplotlib.org/3.1.1/api/_as_gen/matplotlib.axes.Axes.annotate.html \n", + "\n", + "### Another improvement\n", + "Instead of having to manually create the subdirectories `Plots` and `/v20`, we could check if they exist and create them if they don't. For this, we could use the built-in `os` module to manipulate the file system.\n", + "\n", + "One way of doing it is this:\n", + "\n", + "---\n", + "```python\n", + "# Check if directory exists\n", + "if not os.path.exists(directory):\n", + " # Create it if it doesn't\n", + " os.makedirs(directory)\n", + "```\n", + "---\n", + "\n", + "Where the variable `directory` is a string with the path to the desired directory.\n", + "\n", + "Make sure that `import os` is stated in the beginning of the script. This is a built-in module, so no installation is needed.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# End of exercises\n", + "\n", + "*The cell below is for setting the style of this document. It's not part of the exercises.*" + ] + }, + { + "cell_type": "code", + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -275,7 +584,7 @@ "" ] }, - "execution_count": 1, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -284,306 +593,6 @@ "from IPython.display import HTML\n", "HTML(''.format(open('../css/cowi.css').read()))" ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# 6. Exercise solution" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "code_folding": [] - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
LCLC-titleNRNGvx[kN/m]
04031Shear keys - BS - 2553/2554201012012.33
14031Shear keys - BS - 2553/2554201022011.29
24031Shear keys - BS - 2553/2554201032010.87
34031Shear keys - BS - 2553/2554201042010.74
44031Shear keys - BS - 2553/2554201052010.64
\n", - "
" - ], - "text/plain": [ - " LC LC-title NR NG vx[kN/m]\n", - "0 4031 Shear keys - BS - 2553/2554 20101 201 2.33\n", - "1 4031 Shear keys - BS - 2553/2554 20102 201 1.29\n", - "2 4031 Shear keys - BS - 2553/2554 20103 201 0.87\n", - "3 4031 Shear keys - BS - 2553/2554 20104 201 0.74\n", - "4 4031 Shear keys - BS - 2553/2554 20105 201 0.64" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Import libraries \n", - "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "\n", - "# Set style for matplotlib plots\n", - "plt.style.use('seaborn-whitegrid') \n", - "\n", - "# Dictionary for mapping node numbers to user chosen shear key names\n", - "shear_keys = { \n", - " # Shear key in Base Slab 101\n", - " 'BS101': range(10101, 10199), \n", - "\n", - " # Shear key in Base Slab 201\n", - " 'BS201': range(20101, 20199), \n", - "\n", - " # Shear key in Base Slab 301 \n", - " 'BS301': range(30101, 30214), \n", - "} \n", - "\n", - "# Set file name of dataset\n", - "file_name = 'shear_keys_base_slab_v20.txt'\n", - "\n", - "# Read dataset from text file into dataframe, save it as 'df'\n", - "df = pd.read_csv(file_name)\n", - "\n", - "# Extract version number from file name as 'vXX'\n", - "# (assume the last 6 characters will always be '...vXX.txt')\n", - "version_number = file_name[-7:-4]\n", - "\n", - "# Print the head of the dataframe to check it\n", - "df.head()" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "ename": "FileNotFoundError", - "evalue": "[Errno 2] No such file or directory: 'Plots/v20/BS101_4031.png'", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 51\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 52\u001b[0m \u001b[1;31m# Save figure to png-file with meaningful name that varies in every loop\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 53\u001b[1;33m \u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msavefig\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf'Plots/{version_number}/{shear_key}_{lc}.png'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[1;32m~\\Miniconda3\\lib\\site-packages\\matplotlib\\pyplot.py\u001b[0m in \u001b[0;36msavefig\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m 687\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0msavefig\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 688\u001b[0m \u001b[0mfig\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mgcf\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 689\u001b[1;33m \u001b[0mres\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mfig\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msavefig\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 690\u001b[0m \u001b[0mfig\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcanvas\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdraw_idle\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# need this if 'transparent=True' to reset colors\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 691\u001b[0m \u001b[1;32mreturn\u001b[0m \u001b[0mres\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32m~\\Miniconda3\\lib\\site-packages\\matplotlib\\figure.py\u001b[0m in \u001b[0;36msavefig\u001b[1;34m(self, fname, frameon, transparent, **kwargs)\u001b[0m\n\u001b[0;32m 2092\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mset_frameon\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mframeon\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2093\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 2094\u001b[1;33m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcanvas\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mprint_figure\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfname\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 2095\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2096\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mframeon\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32m~\\Miniconda3\\lib\\site-packages\\matplotlib\\backend_bases.py\u001b[0m in \u001b[0;36mprint_figure\u001b[1;34m(self, filename, dpi, facecolor, edgecolor, orientation, format, bbox_inches, **kwargs)\u001b[0m\n\u001b[0;32m 2073\u001b[0m \u001b[0morientation\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0morientation\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2074\u001b[0m \u001b[0mbbox_inches_restore\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0m_bbox_inches_restore\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 2075\u001b[1;33m **kwargs)\n\u001b[0m\u001b[0;32m 2076\u001b[0m \u001b[1;32mfinally\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2077\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mbbox_inches\u001b[0m \u001b[1;32mand\u001b[0m \u001b[0mrestore_bbox\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32m~\\Miniconda3\\lib\\site-packages\\matplotlib\\backends\\backend_agg.py\u001b[0m in \u001b[0;36mprint_png\u001b[1;34m(self, filename_or_obj, *args, **kwargs)\u001b[0m\n\u001b[0;32m 519\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 520\u001b[0m \u001b[1;32mwith\u001b[0m \u001b[0mcbook\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_setattr_cm\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdpi\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdpi\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0;31m \u001b[0m\u001b[0;31m\\\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 521\u001b[1;33m \u001b[0mcbook\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mopen_file_cm\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfilename_or_obj\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"wb\"\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0mfh\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 522\u001b[0m _png.write_png(renderer._renderer, fh,\n\u001b[0;32m 523\u001b[0m self.figure.dpi, metadata=metadata)\n", - "\u001b[1;32m~\\Miniconda3\\lib\\contextlib.py\u001b[0m in \u001b[0;36m__enter__\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 110\u001b[0m \u001b[1;32mdel\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mkwds\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfunc\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 111\u001b[0m \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 112\u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mnext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mgen\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 113\u001b[0m \u001b[1;32mexcept\u001b[0m \u001b[0mStopIteration\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 114\u001b[0m \u001b[1;32mraise\u001b[0m \u001b[0mRuntimeError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"generator didn't yield\"\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mfrom\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32m~\\Miniconda3\\lib\\site-packages\\matplotlib\\cbook\\__init__.py\u001b[0m in \u001b[0;36mopen_file_cm\u001b[1;34m(path_or_file, mode, encoding)\u001b[0m\n\u001b[0;32m 405\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mopen_file_cm\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mpath_or_file\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmode\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m\"r\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mencoding\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 406\u001b[0m \u001b[1;34mr\"\"\"Pass through file objects and context-manage `.PathLike`\\s.\"\"\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 407\u001b[1;33m \u001b[0mfh\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mopened\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mto_filehandle\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mpath_or_file\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmode\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;32mTrue\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mencoding\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 408\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mopened\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 409\u001b[0m \u001b[1;32mwith\u001b[0m \u001b[0mfh\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32m~\\Miniconda3\\lib\\site-packages\\matplotlib\\cbook\\__init__.py\u001b[0m in \u001b[0;36mto_filehandle\u001b[1;34m(fname, flag, return_opened, encoding)\u001b[0m\n\u001b[0;32m 390\u001b[0m \u001b[0mfh\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mbz2\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mBZ2File\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfname\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mflag\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 391\u001b[0m \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 392\u001b[1;33m \u001b[0mfh\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mopen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfname\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mflag\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mencoding\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mencoding\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 393\u001b[0m \u001b[0mopened\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mTrue\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 394\u001b[0m \u001b[1;32melif\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfname\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'seek'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'Plots/v20/BS101_4031.png'" - ] - } - ], - "source": [ - "%%capture\n", - "# %%capture prevent plots from showing as cell output\n", - "# ------------------------------------------------------\n", - "\n", - "# Contruct a dictionary that maps load case numbers to titles (auto removes duplicates)\n", - "lc_no_to_title_map = dict(zip(df['LC'], df['LC-title'])) \n", - "\n", - "# Loop over all shear key names and their corresponding node numbers \n", - "for shear_key, nodes in shear_keys.items():\n", - "\n", - " # Loop over all load cases, create plots and save them to a png-file\n", - " for lc in df['LC'].unique():\n", - "\n", - " # Get title of current load case from mapping dictionary\n", - " lc_title = lc_no_to_title_map[lc]\n", - " \n", - " # Filter dataframe based on load case and nodes in shear key\n", - " df_filtered = df[(df['LC'] == lc) & (df['NR'].isin(nodes))]\n", - " \n", - " # Create figure\n", - " plt.figure(figsize=(12, 5))\n", - " \n", - " # Create x-values for plot as numbers running from 1 to length of y-values\n", - " x = np.array(range(1, len(df_filtered['vx[kN/m]'])+1))\n", - " \n", - " # Create y-values for plot as shear forces vx\n", - " y = df_filtered['vx[kN/m]'].values\n", - " \n", - " # Extract indices where y-values are negative and positive, respectively\n", - " idx_neg = np.where(y<0)\n", - " idx_pos = np.where(y>=0)\n", - "\n", - " # Extract x-values where y-values are negative and positive, respectively\n", - " x_neg, x_pos = np.take(x, idx_neg)[0], np.take(x, idx_pos)[0]\n", - "\n", - " # Extract y-values where y-values are negative and positive, respectively\n", - " y_neg, y_pos = np.take(y, idx_neg)[0], np.take(y, idx_pos)[0]\n", - "\n", - " # Plot lines for negative and positve values as two separate lines\n", - " plt.plot(x_neg, y_neg, '.', color='salmon')\n", - " plt.plot(x_pos, y_pos, '.', color='cornflowerblue') \n", - " \n", - " # Fill between y=0 and the lines where y-values are negative and positive, respectively \n", - " plt.fill_between(x, y, where=y<0, color='salmon', alpha=0.25, interpolate=True)\n", - " plt.fill_between(x, y, where=y>=0, color='cornflowerblue', alpha=0.25, interpolate=True)\n", - " \n", - " # Set titles and x- and y-labels\n", - " plt.title(f'Shear force $vx$ [kN/m] for base slab shear key ${shear_key}$' + '\\n' +\n", - " f'{lc_title} $(LC: {lc}) ({version_number})$', fontsize=18)\n", - " plt.xlabel('Points along shear key', fontsize=14)\n", - " plt.ylabel('Slab shear force $vx$ [kN/m]', fontsize=14)\n", - " \n", - " # Save figure to png-file with meaningful name that varies in every loop\n", - " plt.savefig(f'Plots/{version_number}/{shear_key}_{lc}.png')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Explanations to some of the code lines are given below\n", - "\n", - "* **Line with `df_filtered = ...`:** The dataframe `df_filtered` is uniqie in every loop, since it is filtered based on the current load case and the nodes in the current shear key. The filtering is done based on the original large dataframe. Every operation from here on out inside the loop must use `df_filtered` and not the original dataframe. For filtering based on the nodes in the shear key `.isin` is used. This is a good way to filter based on values in a list. And the nodes for each shear key is is stored in the loop variable `nodes` as a list.\n", - "\n", - "\n", - "* **Line with `x = ...`:** This generates the x-values, which will just be increasing numbers from 1 and up. Note that `range(start, stop)` goes from `start` to `stop-1`. \n", - "\n", - "\n", - "* **Line with `y = ...`:** Collects the y-values for the plot in the current loop. `df['vx[kN/m']]` extracts a Series, which is a single column, but with index numbers to its left. To get only the column values as an array, we do `df['vx[kN/m']].values`. Btw, this will also work for dataframes, but will return a 'matrix' array instead of a 'vector' array as for Series.\n", - "\n", - "\n", - "* **Lines with `plt.plot()`:** The negative and positive points are plotting as two separate data series so they can have different colors. Connecting the points by lines makes the plot look strange after it has been separated, so only points are plotted. \n", - "\n", - "\n", - "* **Lines with `plt.fillbetween()`:** Parameter `alpha` set the opacity. Parameter `interpolate=True` will make sure the fill is not \"cut off\" near a crossing of the y-axis.\n", - "\n", - "\n", - "* **Lines with for `plt.title()`**: When creating plots by loops the title for each plot should probably have a unique title that varies with the loop variable(s). Then saving to a file this is important in order to not overwrite the plot with the same name in each loop. A convenient way to put variables inside text is by using f-strings. \n", - "\n", - "\n", - "* **Line with `plt.savefig()`** A subfolder called `Plots` and a subsubfolder with the version number `v20` have to be created before running this. It the folders are not present `FileNoteFoundError` will be raised. Alternatively, the png-files could be saved directly in the same folder as the script. In that case only `'.png'` would be necessary as the argument for `plt.savefig()`. By saving in a subfolder whose name depends on the version number given in the name original txt file, it is easier to keep track of versions and avoid overwriting files from previous versions. \n", - "\n", - "## Improvements mentioned in exercise text\n", - "\n", - "### y-limits of plot\n", - "Set the y-limits of the plot by `plt.ylim([ymin, ymax])`. \n", - "\n", - "`ymin` and `ymax` could be determined as the largest occuring magnitude values among all plots. \n", - "\n", - "~~~python \n", - "# Put this line before the loop\n", - "all_loads = df['vx[kN/m]']\n", - "extr_magnitude = max(abs(min(all_loads)), abs(max(all_loads)))\n", - "~~~\n", - "\n", - "~~~python\n", - "# Put this line in each loop before saving the figure\n", - "plt.ylim([-1.1*extr_magnitude, 1.1*extr_magnitude])\n", - "~~~\n", - "\n", - "\n", - "### Annotations of local extrema\n", - "For annotating the local extrema points, define the function `find_local_extrema(y_curve)` from the exercise text somewhere in the script before the loop. \n", - "\n", - "Afterwards, include the lines below within the for loop. They should be placed somewhere between when the figure is creates and when it's saved.\n", - "\n", - "~~~python\n", - "# Find local extrema points of graph\n", - "extrema_indices = find_local_extrema(y)\n", - "\n", - "# Annotate each points on the plot\n", - "for extr_idx in extreme_indices:\n", - " ax.annotate(f'{y[extr_idx]:.0f}', xy=(x[extr_idx], y[extr_idx]), xytext=(x[extr_idx], y[extr_idx]))\n", - "~~~\n", - "\n", - "This annotates the local peaks which helps for readability of the graph. The annotations could be even better than this by ensuring that text does not overlap. and by always annotating the two end points of the graph.\n", - "\n", - "Documentation for annotating method: https://matplotlib.org/3.1.1/api/_as_gen/matplotlib.axes.Axes.annotate.html \n", - "\n", - "### Another improvement\n", - "Instead of having to manually create the subdirectories `Plots` and `/v20`, we could check if they exist and create them if they don't. For this, we could use the built-in `os` module to manipulate the file system.\n", - "\n", - "One way of doing it is this:\n", - "\n", - "---\n", - "```python\n", - "# Check if directory exists\n", - "if not os.path.exists(directory):\n", - " # Create it if it doesn't\n", - " os.makedirs(directory)\n", - "```\n", - "---\n", - "\n", - "Where the variable `directory` is a string with the path to the desired directory.\n", - "\n", - "Make sure that `import os` is stated in the beginning of the script. This is a built-in module, so no installation is needed.\n", - "\n" - ] } ], "metadata": { @@ -603,7 +612,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.1" + "version": "3.7.4" }, "latex_envs": { "LaTeX_envs_menu_present": true, diff --git a/Session 7 - Coordinate Transformation/Session 7 - Coordinate Transformation.ipynb b/Session 7 - Coordinate Transformation/Session 7 - Coordinate Transformation.ipynb index c9e470a..24686f4 100644 --- a/Session 7 - Coordinate Transformation/Session 7 - Coordinate Transformation.ipynb +++ b/Session 7 - Coordinate Transformation/Session 7 - Coordinate Transformation.ipynb @@ -1,9 +1,509 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 7. Tranformation functions\n", + "\n", + "Coordinate transformations can be performed by matrix operations. Some common ones are:\n", + "\n", + "\\begin{equation}\n", + "\\tag{Rotation about Origin}\n", + "\\begin{bmatrix}\n", + "x_{\\text{rotated}}\\\\y_{\\text{rotated}}\\\\1\n", + "\\end{bmatrix} = \n", + "\\begin{bmatrix}\n", + "\\cos(\\theta) & \\sin(\\theta) & 0 \\\\\n", + "-\\sin(\\theta) & \\cos(\\theta) & 0 \\\\\n", + "0 & 0 & 1 \n", + "\\end{bmatrix}\n", + "\\begin{bmatrix} x \\\\ y \\\\ 1 \\end{bmatrix}\n", + "\\end{equation}\n", + "\n", + "\n", + "\\begin{equation}\n", + "\\tag{Translation}\n", + "\\begin{bmatrix}\n", + "x_{\\text{translated}}\\\\y_{\\text{translated}}\\\\1\n", + "\\end{bmatrix} = \n", + "\\begin{bmatrix}\n", + "1 & 0 & \\Delta x \\\\\n", + "0 & 1 & \\Delta y \\\\\n", + "0 & 0 & 1 \n", + "\\end{bmatrix}\n", + "\\begin{bmatrix} x \\\\ y \\\\ 1 \\end{bmatrix}\n", + "\\end{equation}\n", + "\n", + "\n", + "\\begin{equation}\n", + "\\tag{Scale about Origin}\n", + "\\begin{bmatrix}\n", + "x_{\\text{scaled}}\\\\y_{\\text{scaled}}\\\\1\n", + "\\end{bmatrix} = \n", + "\\begin{bmatrix}\n", + "C_x & 0 & 0 \\\\\n", + "0 & C_y & 0 \\\\\n", + "0 & 0 & 1 \n", + "\\end{bmatrix}\n", + "\\begin{bmatrix} x \\\\ y \\\\ 1 \\end{bmatrix}\n", + "\\end{equation}\n", + "\n", + "\n", + "\n", + "\\begin{equation}\n", + "\\tag{Mirror about $y$-axis}\n", + "\\begin{bmatrix}\n", + "x_{\\text{mirrored}}\\\\y_{\\text{mirrored}}\\\\1\n", + "\\end{bmatrix} = \n", + "\\begin{bmatrix}\n", + "-1 & 0 & 0 \\\\\n", + "0 & 1 & 0 \\\\\n", + "0 & 0 & 1 \n", + "\\end{bmatrix}\n", + "\\begin{bmatrix} x \\\\ y \\\\ 1 \\end{bmatrix}\n", + "\\end{equation}\n", + "\n", + "\n", + "* In the **rotation matrix** it is assumed that the angle $\\theta$ is a clockwise rotation.\n", + "\n", + "\n", + "* In the **translation matrix** $\\Delta x$ and $\\Delta y$ denote the absolute translation in the $x$- and $y$-direction, respectively.\n", + "\n", + "\n", + "* In the **scaling matrix** $C_x$ and $C_y$ denote the scaling in the $x$- and $y$-direction, respectively. \n", + "\n", + "\n", + "* The **mirroring matrix** has no inputs and can bee seen as a boolean operation. It can be done in exactly one way or not done at all. \n", + "\n", + "See more here: https://upload.wikimedia.org/wikipedia/commons/2/2c/2D_affine_transformation_matrix.svg" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Vectorization in `numpy`\n", + "`numpy` can perform calculation in a vectorized manner meaning that vector and matrix operations can be done on entire arrays at a time as opposed to value by value. \n", + "\n", + ">**Vectorization can eliminate the use of for loops in many scenarios**\n", + "> \n", + ">This makes the code easier to read and write. And as an added bonus, vectorized calculations are also much faster than their looping counterparts.\n", + "\n", + "For the equations above, we can utilize vectorization by using a arrays (or lists) of values for $x$ and $y$ instead of single values. That implies that $1$ also must be an array of ones with the same size.\n", + "\n", + "Thus, each vector $[x, y, 1]^T$ on the right hand side of the equations is actually an **array of arrays.**\n", + "\n", + "The resulting vector $[x_{\\text{transformed}}, y_{\\text{transformed}}, 1]^T$ is of course also an **array or arrays.**\n", + "\n", + "## Unpacking values\n", + "A small example that demontrates unpacking of returned values from a function:\n" + ] + }, { "cell_type": "code", "execution_count": 1, "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1, 2, 3)" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def f():\n", + " '''\n", + " Define function that takes no input and returns three values\n", + " '''\n", + " return 1, 2, 3\n", + "\n", + "# Call function and save result in variable\n", + "result = f()\n", + "result" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + ">**Note:** When returning multiple values from a function, they will by default be a `tuple`. This is basically the same as if the last line of the function would have been `return (1, 2, 3)`.\n", + "\n", + "Unpacking the result to three variables:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Unpack function output to three variables\n", + "a, b, c = f()\n", + "\n", + "# Print a, b and c\n", + "a" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "b" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "c" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As we see, if we do not unpack, all values are saved in a tuple. If we unpack all returned values, they each get assgined to a variable.\n", + "\n", + "**But**, if we try to unpack only 2 values when the function returns 3 we get this error:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "too many values to unpack (expected 2)", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[1;31m# ValueError, function returns 3 values, but only 2 unpacked\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mh\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mi\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mf\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;31mValueError\u001b[0m: too many values to unpack (expected 2)" + ] + } + ], + "source": [ + "# ValueError, function returns 3 values, but only 2 unpacked\n", + "h, i = f()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If we try to unpack too many values:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "not enough values to unpack (expected 4, got 3)", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[1;31m# ValueError, function returns 3 values, but 4 were unpacked\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mh\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mi\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mj\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mk\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mf\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;31mValueError\u001b[0m: not enough values to unpack (expected 4, got 3)" + ] + } + ], + "source": [ + "# ValueError, function returns 3 values, but 4 were unpacked\n", + "h, i, j, k = f()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "> **When unpacking, the variables of the left side of the equal sign must exactly match the number of outputs, so all unpacked elements are accounted for.**\n", + "\n", + "There are fancier ways to unpack which can handle cases where it is not known how many elements are to be unpacked. See for example https://www.python.org/dev/peps/pep-3132/. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Unpacking values for the tranformation examples\n", + "The resulting array of arrays will have the following code structure\n", + "\n", + "~~~python \n", + "# Define an array of arrays\n", + "array_of_arrays = [ [x_values], [y_values], [ones] ]\n", + "~~~\n", + "\n", + "**Unpacking** `x-values` and `y_values` to their own arrays can be done like this:\n", + "\n", + "~~~python\n", + "# Unpack an array of arrays\n", + "x_values, y_values, ones = array_of_arrays\n", + "~~~\n", + "\n", + "In this case, we don't care about the array of ones. It is a quite common scenario that a function returns some values that are not needed. \n", + "\n", + ">**It is common convention in Python to unpack unused variables to `_`**\n", + "\n", + "Like this:\n", + "\n", + "~~~python\n", + "# Convention for unpacking unused variables\n", + "x_transformed, y_transformed, _ = array_of_arrays\n", + "~~~\n", + "\n", + "By following this convention, it is clear to readers of the code that this value is not going to be used throughout the program.\n", + "\n", + "\n", + "## Some `numpy` functions\n", + "\n", + "### Function: `numpy.matmul`\n", + "This function will find the matrix product of two arrays:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([18, 8, 8])" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "\n", + "# Define a vector\n", + "a = np.array([1, 2, 3])\n", + "\n", + "# Define a matrix\n", + "T = np.array([ [1, 1, 5], [3, 1, 1], [5, 0, 1] ])\n", + "\n", + "# Compute the matrix product {T}x{a}\n", + "b = np.matmul(T, a) \n", + "b" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Function: `np.ones`\n", + "Creates an array of ones of a specified shape" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1., 1., 1., 1., 1.])" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create 1x5 vector of ones (1D array)\n", + "np.ones(5)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1., 1., 1., 1., 1.],\n", + " [1., 1., 1., 1., 1.],\n", + " [1., 1., 1., 1., 1.],\n", + " [1., 1., 1., 1., 1.],\n", + " [1., 1., 1., 1., 1.]])" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create 5x5 matrix of ones (2D array)\n", + "np.ones([5, 5])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 1\n", + "Write a function that implements rotation of a array of coordinates `x` and `y`. The angle of rotation in clockwise direction should be an input parameter with default value of 90 degrees. The function should return the rotated coordinates `xr` and `yr`.\n", + "\n", + "Test the function with these arrays.\n", + "\n", + "```python\n", + "# Test arrays to transform\n", + "x = np.array([-5, 5, 5, 0.5, 0.5, 5, 5, -5, -5, -0.5, -0.5, -5, -5])\n", + "y = np.array([-8, -8, -6, -6, 6, 6, 8, 8, 6, 6, -6, -6, -8])\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 2\n", + "Write a function that takes a pair of arrays of transformed coordinates `xt` and `yt` as input and plots them as a line plot. The function should be able to plot the original coordinates as well, but this should be optional and not plotted as default.\n", + "\n", + "Plot the original shape from Exercise 1 together with the rotated shape.\n", + "\n", + "*A good way of setting default values for parameters that should not be present as default is by setting them equal to None in the function definition. The code inside the function can then check if values were input or not.*" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 3\n", + "Write a function that implements translation of an array of coordinates `x` and `y`. The translation shall be defined by values (not arrays) `x_translate` and `y_translate`, which are the distance the points will move in the $x$- and $y$-direction, respectively.\n", + "\n", + "Test the function with the arrays given in Exercise 1. Plot the translation with the function written in Exercise 2." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 4\n", + "Implement the scaling transformation as a function. Test it by plotting it." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 5\n", + "Implement mirroring transformation about the $y$-axis as a function.\n", + "\n", + "Since the given coordinates in Exercise 1 are symmetric about the $y$-axis, the mirrored coordinates will lie on top of the original ones. Try to test it by plotting.\n", + "\n", + "You can quickly make a more visible test by moving all the $x$-coordinates, say 20 units to the right. Since we are using `numpy` this can be done by simply adding 20 to the array itself `x + 20`. This is a simple example of vectorization." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 6\n", + "Write a function that combines all of the above transformations in one. \n", + "\n", + "It could have a structure like this:\n", + "\n", + "```python\n", + "def transform(x, y, rotation=0, scaling=(1, 1), translation=(0, 0), mirroring=False):\n", + " '''\n", + " Perform a combined coordinate transformation according to given inputs. If no inputs are given, returns the unchanged coordinates.\n", + "\n", + " Args:\n", + " x (array) : x-values to transform.\n", + " y (array) : y-values to transform.\n", + " rotate (float, optional) : Clockwise rotation angle in [deg]. Defaults to no rotation.\n", + " scale (float, optional) : Scaling factor in axes directions (cx, cy). Defaults to no scaling.\n", + " translate (tuple, optional) : Translation in axes directions (dx, dy). Defaults to no translation.\n", + " mirror (bool, optional) : Whether or not to mirror the coordinates, Defaults to no mirroring.\n", + " '''\n", + "\n", + " # Code here\n", + "```\n", + "* Remember that rotation and scaling are performed about the origin. So the order of operations will matter.\n", + "* If you wish, you can call the previously defined functions to perform the individual transformations. \n", + "* Return the transformed coordinates xt, yt.\n", + "\n", + "*When performing multiple transformations at once, the transformation matrices can be multiplied by each other prior to multiplication with the original coordinates. But since we have all the individual transformation functions already defined the solution will successively call those. The loss in calculation speed by performing the redundant multiplication is not noticeable for smaller datasets.*" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Additional Exercise\n", + "Write a alternative function for translation where the translation input can be given as a distance that the points should move and the corresponding angle from the $x$-axis. This can often be useful instead of the one defined earlier where the distances are given parallel to the $x$- and $y$-axes." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# End of exercises\n", + "\n", + "*The cell below is for setting the style of this document. It's not part of the exercises.*" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, "outputs": [ { "data": { @@ -275,7 +775,7 @@ "" ] }, - "execution_count": 1, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -284,497 +784,6 @@ "from IPython.display import HTML\n", "HTML(''.format(open('../css/cowi.css').read()))" ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# 7. Tranformation functions\n", - "\n", - "Coordinate transformations can be performed by matrix operations. Some common ones are:\n", - "\n", - "\\begin{equation}\n", - "\\tag{Rotation about Origin}\n", - "\\begin{bmatrix}\n", - "x_{\\text{rotated}}\\\\y_{\\text{rotated}}\\\\1\n", - "\\end{bmatrix} = \n", - "\\begin{bmatrix}\n", - "\\cos(\\theta) & \\sin(\\theta) & 0 \\\\\n", - "-\\sin(\\theta) & \\cos(\\theta) & 0 \\\\\n", - "0 & 0 & 1 \n", - "\\end{bmatrix}\n", - "\\begin{bmatrix} x \\\\ y \\\\ 1 \\end{bmatrix}\n", - "\\end{equation}\n", - "\n", - "\n", - "\\begin{equation}\n", - "\\tag{Translation}\n", - "\\begin{bmatrix}\n", - "x_{\\text{translated}}\\\\y_{\\text{translated}}\\\\1\n", - "\\end{bmatrix} = \n", - "\\begin{bmatrix}\n", - "1 & 0 & \\Delta x \\\\\n", - "0 & 1 & \\Delta y \\\\\n", - "0 & 0 & 1 \n", - "\\end{bmatrix}\n", - "\\begin{bmatrix} x \\\\ y \\\\ 1 \\end{bmatrix}\n", - "\\end{equation}\n", - "\n", - "\n", - "\\begin{equation}\n", - "\\tag{Scale about Origin}\n", - "\\begin{bmatrix}\n", - "x_{\\text{scaled}}\\\\y_{\\text{scaled}}\\\\1\n", - "\\end{bmatrix} = \n", - "\\begin{bmatrix}\n", - "C_x & 0 & 0 \\\\\n", - "0 & C_y & 0 \\\\\n", - "0 & 0 & 1 \n", - "\\end{bmatrix}\n", - "\\begin{bmatrix} x \\\\ y \\\\ 1 \\end{bmatrix}\n", - "\\end{equation}\n", - "\n", - "\n", - "\n", - "\\begin{equation}\n", - "\\tag{Mirror about $y$-axis}\n", - "\\begin{bmatrix}\n", - "x_{\\text{mirrored}}\\\\y_{\\text{mirrored}}\\\\1\n", - "\\end{bmatrix} = \n", - "\\begin{bmatrix}\n", - "-1 & 0 & 0 \\\\\n", - "0 & 1 & 0 \\\\\n", - "0 & 0 & 1 \n", - "\\end{bmatrix}\n", - "\\begin{bmatrix} x \\\\ y \\\\ 1 \\end{bmatrix}\n", - "\\end{equation}\n", - "\n", - "\n", - "* In the **rotation matrix** it is assumed that the angle $\\theta$ is a clockwise rotation.\n", - "\n", - "\n", - "* In the **translation matrix** $\\Delta x$ and $\\Delta y$ denote the absolute translation in the $x$- and $y$-direction, respectively.\n", - "\n", - "\n", - "* In the **scaling matrix** $C_x$ and $C_y$ denote the scaling in the $x$- and $y$-direction, respectively. \n", - "\n", - "\n", - "* The **mirroring matrix** has no inputs and can bee seen as a boolean operation. It can be done in exactly one way or not done at all. \n", - "\n", - "See more here: https://upload.wikimedia.org/wikipedia/commons/2/2c/2D_affine_transformation_matrix.svg" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Vectorization in `numpy`\n", - "`numpy` can perform calculation in a vectorized manner meaning that vector and matrix operations can be done on entire arrays at a time as opposed to value by value. \n", - "\n", - ">**Vectorization can eliminate the use of for loops in many scenarios**\n", - "> \n", - ">This makes the code easier to read and write. And as an added bonus, vectorized calculations are also much faster than their looping counterparts.\n", - "\n", - "For the equations above, we can utilize vectorization by using a arrays (or lists) of values for $x$ and $y$ instead of single values. That implies that $1$ also must be an array of ones with the same size.\n", - "\n", - "Thus, each vector $[x, y, 1]^T$ on the right hand side of the equations is actually an **array of arrays.**\n", - "\n", - "The resulting vector $[x_{\\text{transformed}}, y_{\\text{transformed}}, 1]^T$ is of course also an **array or arrays.**\n", - "\n", - "## Unpacking values\n", - "A small example that demontrates unpacking of returned values from a function:\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(1, 2, 3)" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "def f():\n", - " '''\n", - " Define function that takes no input and returns three values\n", - " '''\n", - " return 1, 2, 3\n", - "\n", - "# Call function and save result in variable\n", - "result = f()\n", - "result" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - ">**Note:** When returning multiple values from a function, they will by default be a `tuple`. This is basically the same as if the last line of the function would have been `return (1, 2, 3)`.\n", - "\n", - "Unpacking the result to three variables:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "1" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Unpack function output to three variables\n", - "a, b, c = f()\n", - "\n", - "# Print a, b and c\n", - "a" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "2" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "b" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "3" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "c" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "As we see, if we do not unpack, all values are saved in a tuple. If we unpack all returned values, they each get assgined to a variable.\n", - "\n", - "**But**, if we try to unpack only 2 values when the function returns 3 we get this error:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "ename": "ValueError", - "evalue": "too many values to unpack (expected 2)", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[1;31m# ValueError, function returns 3 values, but only 2 unpacked\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mh\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mi\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mf\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[1;31mValueError\u001b[0m: too many values to unpack (expected 2)" - ] - } - ], - "source": [ - "# ValueError, function returns 3 values, but only 2 unpacked\n", - "h, i = f()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "If we try to unpack too many values:" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "ename": "ValueError", - "evalue": "not enough values to unpack (expected 4, got 3)", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[1;31m# ValueError, function returns 3 values, but 4 were unpacked\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mh\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mi\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mj\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mk\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mf\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[1;31mValueError\u001b[0m: not enough values to unpack (expected 4, got 3)" - ] - } - ], - "source": [ - "# ValueError, function returns 3 values, but 4 were unpacked\n", - "h, i, j, k = f()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "> **When unpacking, the variables of the left side of the equal sign must exactly match the number of outputs, so all unpacked elements are accounted for.**\n", - "\n", - "There are fancier ways to unpack which can handle cases where it is not known how many elements are to be unpacked. See for example https://www.python.org/dev/peps/pep-3132/. " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Unpacking values for the tranformation examples\n", - "The resulting array of arrays will have the following code structure\n", - "\n", - "~~~python \n", - "# Define an array of arrays\n", - "array_of_arrays = [ [x_values], [y_values], [ones] ]\n", - "~~~\n", - "\n", - "**Unpacking** `x-values` and `y_values` to their own arrays can be done like this:\n", - "\n", - "~~~python\n", - "# Unpack an array of arrays\n", - "x_values, y_values, ones = array_of_arrays\n", - "~~~\n", - "\n", - "In this case, we don't care about the array of ones. It is a quite common scenario that a function returns some values that are not needed. \n", - "\n", - ">**It is common convention in Python to unpack unused variables to `_`**\n", - "\n", - "Like this:\n", - "\n", - "~~~python\n", - "# Convention for unpacking unused variables\n", - "x_transformed, y_transformed, _ = array_of_arrays\n", - "~~~\n", - "\n", - "By following this convention, it is clear to readers of the code that this value is not going to be used throughout the program.\n", - "\n", - "\n", - "## Some `numpy` functions\n", - "\n", - "### Function: `numpy.matmul`\n", - "This function will find the matrix product of two arrays:" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([18, 8, 8])" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import numpy as np\n", - "\n", - "# Define a vector\n", - "a = np.array([1, 2, 3])\n", - "\n", - "# Define a matrix\n", - "T = np.array([ [1, 1, 5], [3, 1, 1], [5, 0, 1] ])\n", - "\n", - "# Compute the matrix product {T}x{a}\n", - "b = np.matmul(T, a) \n", - "b" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Function: `np.ones`\n", - "Creates an array of ones of a specified shape" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([1., 1., 1., 1., 1.])" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Create 1x5 vector of ones (1D array)\n", - "np.ones(5)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[1., 1., 1., 1., 1.],\n", - " [1., 1., 1., 1., 1.],\n", - " [1., 1., 1., 1., 1.],\n", - " [1., 1., 1., 1., 1.],\n", - " [1., 1., 1., 1., 1.]])" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Create 5x5 matrix of ones (2D array)\n", - "np.ones([5, 5])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 1\n", - "Write a function that implements rotation of a array of coordinates `x` and `y`. The angle of rotation in clockwise direction should be an input parameter with default value of 90 degrees. The function should return the rotated coordinates `xr` and `yr`.\n", - "\n", - "Test the function with these arrays.\n", - "\n", - "```python\n", - "# Test arrays to transform\n", - "x = np.array([-5, 5, 5, 0.5, 0.5, 5, 5, -5, -5, -0.5, -0.5, -5, -5])\n", - "y = np.array([-8, -8, -6, -6, 6, 6, 8, 8, 6, 6, -6, -6, -8])\n", - "```" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 2\n", - "Write a function that takes a pair of arrays of transformed coordinates `xt` and `yt` as input and plots them as a line plot. The function should be able to plot the original coordinates as well, but this should be optional and not plotted as default.\n", - "\n", - "Plot the original shape from Exercise 1 together with the rotated shape.\n", - "\n", - "*A good way of setting default values for parameters that should not be present as default is by setting them equal to None in the function definition. The code inside the function can then check if values were input or not.*" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 3\n", - "Write a function that implements translation of an array of coordinates `x` and `y`. The translation shall be defined by values (not arrays) `x_translate` and `y_translate`, which are the distance the points will move in the $x$- and $y$-direction, respectively.\n", - "\n", - "Test the function with the arrays given in Exercise 1. Plot the translation with the function written in Exercise 2." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 4\n", - "Implement the scaling transformation as a function. Test it by plotting it." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 5\n", - "Implement mirroring transformation about the $y$-axis as a function.\n", - "\n", - "Since the given coordinates in Exercise 1 are symmetric about the $y$-axis, the mirrored coordinates will lie on top of the original ones. Try to test it by plotting.\n", - "\n", - "You can quickly make a more visible test by moving all the $x$-coordinates, say 20 units to the right. Since we are using `numpy` this can be done by simply adding 20 to the array itself `x + 20`. This is a simple example of vectorization." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 6\n", - "Write a function that combines all of the above transformations in one. \n", - "\n", - "It could have a structure like this:\n", - "\n", - "```python\n", - "def transform(x, y, rotation=0, scaling=(1, 1), translation=(0, 0), mirroring=False):\n", - " '''\n", - " Perform a combined coordinate transformation according to given inputs. If no inputs are given, returns the unchanged coordinates.\n", - "\n", - " Args:\n", - " x (array) : x-values to transform.\n", - " y (array) : y-values to transform.\n", - " rotate (float, optional) : Clockwise rotation angle in [deg]. Defaults to no rotation.\n", - " scale (float, optional) : Scaling factor in axes directions (cx, cy). Defaults to no scaling.\n", - " translate (tuple, optional) : Translation in axes directions (dx, dy). Defaults to no translation.\n", - " mirror (bool, optional) : Whether or not to mirror the coordinates, Defaults to no mirroring.\n", - " '''\n", - "\n", - " # Code here\n", - "```\n", - "* Remember that rotation and scaling are performed about the origin. So the order of operations will matter.\n", - "* If you wish, you can call the previously defined functions to perform the individual transformations. \n", - "* Return the transformed coordinates xt, yt.\n", - "\n", - "*When performing multiple transformations at once, the transformation matrices can be multiplied by each other prior to multiplication with the original coordinates. But since we have all the individual transformation functions already defined the solution will successively call those. The loss in calculation speed by performing the redundant multiplication is not noticeable for smaller datasets.*" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Additional Exercise\n", - "Write a alternative function for translation where the translation input can be given as a distance that the points should move and the corresponding angle from the $x$-axis. This can often be useful instead of the one defined earlier where the distances are given parallel to the $x$- and $y$-axes." - ] } ], "metadata": { @@ -794,7 +803,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.1" + "version": "3.7.4" }, "latex_envs": { "LaTeX_envs_menu_present": true, diff --git a/Session 7 - Coordinate Transformation/Session 7 - Exercise solutions.ipynb b/Session 7 - Coordinate Transformation/Session 7 - Exercise solutions.ipynb index 6c2d8b7..1bc649a 100644 --- a/Session 7 - Coordinate Transformation/Session 7 - Exercise solutions.ipynb +++ b/Session 7 - Coordinate Transformation/Session 7 - Exercise solutions.ipynb @@ -1,9 +1,361 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 7. Exercise solutions" + ] + }, { "cell_type": "code", "execution_count": 1, "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([-9.19238816, -2.12132034, -0.70710678, -3.8890873 , 4.59619408,\n", + " 7.77817459, 9.19238816, 2.12132034, 0.70710678, 3.8890873 ,\n", + " -4.59619408, -7.77817459, -9.19238816])" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "from math import cos, sin, atan, pi\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "def rotate(x, y, theta=90):\n", + " '''\n", + " Rotate coordinate lists/arrays x and y rotated angle theta [deg] clockwise. \n", + " Returns the rotated coordinates as arrays.\n", + " '''\n", + " \n", + " # Convert angle to radians\n", + " theta = pi * theta / 180\n", + " \n", + " # Define rotation matrix \n", + " R = np.array([[cos(theta), sin(theta), 0],\n", + " [-sin(theta), cos(theta), 0],\n", + " [0, 0, 1]])\n", + "\n", + " # Define array of original coordinates \n", + " xy1 = np.array([x, y, np.ones(len(x))])\n", + " \n", + " # Compute rotated coordinates\n", + " xr, yr, _ = np.matmul(R, xy1)\n", + "\n", + " return xr, yr\n", + "\n", + "\n", + "\n", + "# Test arrays to transform\n", + "x = np.array([-5, 5, 5, 0.5, 0.5, 5, 5, -5, -5, -0.5, -0.5, -5, -5])\n", + "y = np.array([-8, -8, -6, -6, 6, 6, 8, 8, 6, 6, -6, -6, -8])\n", + "\n", + "# Call the function with test arrays\n", + "xr, yr = rotate(x, y, theta=45)\n", + "\n", + "# Display the rotated x-coordinates\n", + "xr" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([-2.12132034, -9.19238816, -7.77817459, -4.59619408, 3.8890873 ,\n", + " 0.70710678, 2.12132034, 9.19238816, 7.77817459, 4.59619408,\n", + " -3.8890873 , -0.70710678, -2.12132034])" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Display the rotated y-coordinates\n", + "yr" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def plot_transform(xt, yt, x=None, y=None, title=None):\n", + " ''' \n", + " Plot the transformed coordinates (xr, yr). Optionally plot the original coordinates (x, y).\n", + " All four inputs are of type list or array and should all have same length. \n", + " Optionally give a title tp the plot as a string.\n", + " '''\n", + " \n", + " # Plot transformed coordintes\n", + " plt.plot(xt, yt, '.-', color='limegreen')\n", + " \n", + " # Plot original coordinates if they were input\n", + " if x is not None and y is not None:\n", + " plt.plot(x, y, '.-', color='black')\n", + " \n", + " # Set title if that was input\n", + " if title is not None:\n", + " plt.title(title, fontsize=15)\n", + " \n", + " # Set same scaling on x- and y-axis and show the plot\n", + " plt.axis('equal') \n", + " plt.show()\n", + " \n", + " \n", + "# Plot rotated coordinates from previosly\n", + "rotate_title = 'Rotated coordinates with $\\\\theta = 45 ^{\\circ} $'\n", + "plot_transform(xr, yr, x, y, title=rotate_title)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "> **Note**: An optional `title` parameter is also implemented here, even though it was not required by the exercise text." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def translate(x, y, x_translate, y_translate):\n", + " ''' \n", + " Translate coordinate lists/arrays x and y the distance x_translate in the x-direction \n", + " and the distance y_translate in the y-direction. Returns the translated coordinates as arrays. \n", + " '''\n", + " \n", + " # Define translation matrix\n", + " T = np.array([[1, 0, x_translate],\n", + " [0, 1, y_translate],\n", + " [0, 0, 1]])\n", + " \n", + " # Define array of original coordinates\n", + " xy1 = np.array([x, y, np.ones(len(x))])\n", + " \n", + " # Compute translated coordinates\n", + " xt, yt, _ = np.matmul(T, xy1)\n", + " \n", + " return xt, yt\n", + "\n", + "\n", + "# Call the function with test arrays\n", + "xt, yt = translate(x, y, 10, 8)\n", + "\n", + "# Plot the translated coordinates\n", + "translate_title = 'Translated coordinates with $(\\Delta x, \\Delta y) = (10, 8)$'\n", + "plot_transform(xt, yt, x, y, title=translate_title)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def scale(x, y, x_scale, y_scale):\n", + " ''' \n", + " Scale coordinate lists/arrays x and y the by factors x_scale and y_scale in the x-direction \n", + " and y_translate, respectively. Returns the scaled coordinates as arrays. \n", + " '''\n", + " \n", + " # Define scaling matrix\n", + " S = np.array([[x_scale, 0, 0],\n", + " [0, y_scale, 0],\n", + " [0, 0, 1]])\n", + " \n", + " # Define array of original coordinates\n", + " xy1 = np.array([x, y, np.ones(len(x))])\n", + " \n", + " # Compute scaled coordinates\n", + " xs, ys, _ = np.matmul(S, xy1)\n", + " \n", + " return xs, ys\n", + "\n", + "\n", + "# Call the function with test arrays\n", + "xs, ys = scale(x, y, 2, 1.5)\n", + "\n", + "# Plot the scaled coordinates\n", + "scale_title = 'Scaled coordinates with $(x_{scaled}, y_{scaled}) = (2, 1.5)$'\n", + "plot_transform(xs, ys, x, y, title=scale_title)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def mirror(x, y):\n", + " ''' \n", + " Mirror coordinate lists/arrays x and y about the y-axis. Returns the mirrored \n", + " coordinates as arrays. \n", + " '''\n", + " \n", + " # Define translation matrix\n", + " M = np.array([[-1, 0, 0],\n", + " [0, 1, 0],\n", + " [0, 0, 1]])\n", + " \n", + " # Define array of original coordinates\n", + " xy1 = np.array([x, y, np.ones(len(x))])\n", + " \n", + " # Compute new coordinates\n", + " xm, ym, _ = np.matmul(M, xy1)\n", + " \n", + " return xm, ym\n", + "\n", + "\n", + "# Call the function with test arrays with 20 added to all x-values\n", + "xm, ym = mirror(x+20, y)\n", + "\n", + "# Plot the mirrored coordinates\n", + "mirror_title = 'Mirrored coordinates'\n", + "plot_transform(xm, ym, x, y, title=mirror_title)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def transform(x, y, rotation=0, scaling=(1, 1), translation=(0, 0), mirroring=False):\n", + " '''\n", + " Perform a combined coordinate tranformation according to given inputs. \n", + " Returns the transformed coordinates as arrays.\n", + " If no inputs are given, returns the unchanged coordinates.\n", + "\n", + " Args:\n", + " x (array) : x-values to transform.\n", + " y (array) : y-values to transform.\n", + " rotate (float, optional) : Clockwise rotation angle in [deg]. Defaults to no rotation.\n", + " scale (float, optional) : Scaling factor in axes directions (cx, cy). Defaults to no scaling.\n", + " translate (tuple, optional) : Translation in axes directions (dx, dy). Defaults to no translation.\n", + " mirror (bool, optional) : Whether or not to mirror the coordinates, Defaults to no mirroring.\n", + " '''\n", + " \n", + " # Rotate coordinates \n", + " xt, yt = rotate(x, y, theta=rotation)\n", + " \n", + " # Scale coordinates\n", + " xt, yt = scale(xt, yt, scaling[0], scaling[1])\n", + " \n", + " # Translate coordinates\n", + " xt, yt = translate(xt, yt, translation[0], translation[1])\n", + " \n", + " # Mirror coordinates if input parameter mirroring is set to True\n", + " if mirroring:\n", + " xt, yt = mirror(xt, yt)\n", + "\n", + " # Return transformed coordinates as numpy arrays\n", + " return xt, yt\n", + "\n", + "\n", + "# Call the function with test arrays\n", + "xt, yt = transform(x, y, rotation=45, scaling=(1.5, 2), translation=(10, 8), mirroring=True)\n", + "\n", + "# Plot the transformed coordinates\n", + "transform_title = 'Transformed coordinates'\n", + "plot_transform(xt, yt, x, y, title=transform_title)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# End of exercises\n", + "\n", + "*The cell below is for setting the style of this document. It's not part of the exercises.*" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, "outputs": [ { "data": { @@ -275,7 +627,7 @@ "" ] }, - "execution_count": 1, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -284,349 +636,6 @@ "from IPython.display import HTML\n", "HTML(''.format(open('../css/cowi.css').read()))" ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# 7. Exercise solutions" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([-9.19238816, -2.12132034, -0.70710678, -3.8890873 , 4.59619408,\n", - " 7.77817459, 9.19238816, 2.12132034, 0.70710678, 3.8890873 ,\n", - " -4.59619408, -7.77817459, -9.19238816])" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import numpy as np\n", - "from math import cos, sin, atan, pi\n", - "import matplotlib.pyplot as plt\n", - "\n", - "\n", - "def rotate(x, y, theta=90):\n", - " '''\n", - " Rotate coordinate lists/arrays x and y rotated angle theta [deg] clockwise. \n", - " Returns the rotated coordinates as arrays.\n", - " '''\n", - " \n", - " # Convert angle to radians\n", - " theta = pi * theta / 180\n", - " \n", - " # Define rotation matrix \n", - " R = np.array([[cos(theta), sin(theta), 0],\n", - " [-sin(theta), cos(theta), 0],\n", - " [0, 0, 1]])\n", - "\n", - " # Define array of original coordinates \n", - " xy1 = np.array([x, y, np.ones(len(x))])\n", - " \n", - " # Compute rotated coordinates\n", - " xr, yr, _ = np.matmul(R, xy1)\n", - "\n", - " return xr, yr\n", - "\n", - "\n", - "\n", - "# Test arrays to transform\n", - "x = np.array([-5, 5, 5, 0.5, 0.5, 5, 5, -5, -5, -0.5, -0.5, -5, -5])\n", - "y = np.array([-8, -8, -6, -6, 6, 6, 8, 8, 6, 6, -6, -6, -8])\n", - "\n", - "# Call the function with test arrays\n", - "xr, yr = rotate(x, y, theta=45)\n", - "\n", - "# Display the rotated x-coordinates\n", - "xr" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([-2.12132034, -9.19238816, -7.77817459, -4.59619408, 3.8890873 ,\n", - " 0.70710678, 2.12132034, 9.19238816, 7.77817459, 4.59619408,\n", - " -3.8890873 , -0.70710678, -2.12132034])" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Display the rotated y-coordinates\n", - "yr" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "def plot_transform(xt, yt, x=None, y=None, title=None):\n", - " ''' \n", - " Plot the transformed coordinates (xr, yr). Optionally plot the original coordinates (x, y).\n", - " All four inputs are of type list or array and should all have same length. \n", - " Optionally give a title tp the plot as a string.\n", - " '''\n", - " \n", - " # Plot transformed coordintes\n", - " plt.plot(xt, yt, '.-', color='limegreen')\n", - " \n", - " # Plot original coordinates if they were input\n", - " if x is not None and y is not None:\n", - " plt.plot(x, y, '.-', color='black')\n", - " \n", - " # Set title if that was input\n", - " if title is not None:\n", - " plt.title(title, fontsize=15)\n", - " \n", - " # Set same scaling on x- and y-axis and show the plot\n", - " plt.axis('equal') \n", - " plt.show()\n", - " \n", - " \n", - "# Plot rotated coordinates from previosly\n", - "rotate_title = 'Rotated coordinates with $\\\\theta = 45 ^{\\circ} $'\n", - "plot_transform(xr, yr, x, y, title=rotate_title)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "> **Note**: An optional `title` parameter is also implemented here, even though it was not required by the exercise text." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "def translate(x, y, x_translate, y_translate):\n", - " ''' \n", - " Translate coordinate lists/arrays x and y the distance x_translate in the x-direction \n", - " and the distance y_translate in the y-direction. Returns the translated coordinates as arrays. \n", - " '''\n", - " \n", - " # Define translation matrix\n", - " T = np.array([[1, 0, x_translate],\n", - " [0, 1, y_translate],\n", - " [0, 0, 1]])\n", - " \n", - " # Define array of original coordinates\n", - " xy1 = np.array([x, y, np.ones(len(x))])\n", - " \n", - " # Compute translated coordinates\n", - " xt, yt, _ = np.matmul(T, xy1)\n", - " \n", - " return xt, yt\n", - "\n", - "\n", - "# Call the function with test arrays\n", - "xt, yt = translate(x, y, 10, 8)\n", - "\n", - "# Plot the translated coordinates\n", - "translate_title = 'Translated coordinates with $(\\Delta x, \\Delta y) = (10, 8)$'\n", - "plot_transform(xt, yt, x, y, title=translate_title)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "def scale(x, y, x_scale, y_scale):\n", - " ''' \n", - " Scale coordinate lists/arrays x and y the by factors x_scale and y_scale in the x-direction \n", - " and y_translate, respectively. Returns the scaled coordinates as arrays. \n", - " '''\n", - " \n", - " # Define scaling matrix\n", - " S = np.array([[x_scale, 0, 0],\n", - " [0, y_scale, 0],\n", - " [0, 0, 1]])\n", - " \n", - " # Define array of original coordinates\n", - " xy1 = np.array([x, y, np.ones(len(x))])\n", - " \n", - " # Compute scaled coordinates\n", - " xs, ys, _ = np.matmul(S, xy1)\n", - " \n", - " return xs, ys\n", - "\n", - "\n", - "# Call the function with test arrays\n", - "xs, ys = scale(x, y, 2, 1.5)\n", - "\n", - "# Plot the scaled coordinates\n", - "scale_title = 'Scaled coordinates with $(x_{scaled}, y_{scaled}) = (2, 1.5)$'\n", - "plot_transform(xs, ys, x, y, title=scale_title)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "def mirror(x, y):\n", - " ''' \n", - " Mirror coordinate lists/arrays x and y about the y-axis. Returns the mirrored \n", - " coordinates as arrays. \n", - " '''\n", - " \n", - " # Define translation matrix\n", - " M = np.array([[-1, 0, 0],\n", - " [0, 1, 0],\n", - " [0, 0, 1]])\n", - " \n", - " # Define array of original coordinates\n", - " xy1 = np.array([x, y, np.ones(len(x))])\n", - " \n", - " # Compute new coordinates\n", - " xm, ym, _ = np.matmul(M, xy1)\n", - " \n", - " return xm, ym\n", - "\n", - "\n", - "# Call the function with test arrays with 20 added to all x-values\n", - "xm, ym = mirror(x+20, y)\n", - "\n", - "# Plot the mirrored coordinates\n", - "mirror_title = 'Mirrored coordinates'\n", - "plot_transform(xm, ym, x, y, title=mirror_title)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAEKCAYAAAARnO4WAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3Xt8XHWd//HXJ2nSBlIqhZSG0pIi5SYGgfyQLgjVKgr6E1FxdVlhwbWUSwV0V8pF5VZa7CroCtYuVPgtuOAqLPzEC1Ktyo9QSbHEQqktvdNbKBCaXpK0+fz+OGfoJJ1JJplz5pJ5Px+PeWTm3L7f73T6yZn3fHPG3B0RERn8yvLdARERyQ0VfBGREqGCLyJSIlTwRURKhAq+iEiJUMEXESkRKvhFxsw8g9ukfPczwcw+a2bLzKzTzF7Jd38Gwswawuf11Hz3ZSDMbImZzUl6/LCZPRNTW+eY2ZVxHFuyNyTfHZB+m5h0vwr4HXAb8GTS8pdz2qM0zGwo8ADwc+BLwLb89khCNwKVMR37HODDwA9iOr5kQQW/yLj7c4n7ZlYd3n01eXk6ZjbM3XfF1rl9jQX2Ax5096zOKM2sEtjt7l2R9GwQMTMDKt29PZPt3X1FzF2SAqVIZ5Ays6lhDHGSmf3JzHYC0yzwnfBt/nYzW2dmD5hZTY/9N5nZbWb2dTPbYGZvmNl/mtnwpG2Gmdld4THazew1M/u5mZWZ2VRgebjpb8K+TA/3qzaze8xsi5ntNLOFZvbBHu0/Z2YPmtmVZrYK2AkcZGazzGy9mZ1uZn8xsx1mtsDMxppZrZn9wszazOwlMzs9xfNymZktDfu7ysyuTrHNVWEb283sMWBUhs/5KDO7L3zudoXtXJ60vs9xh9tdY2Yrwj7+zcyu6LE+8Rx80MxeANqBT4br3hc+d7vC5+DsFMfvFukkvVaONbPfhc/py2b2iR77fSpc32JmrWb2bHL/zWwWcAVwtO2NF5OjpA+a2TPh2F83sx+a2X5J6w8ys/vNbGPY/zVmdncmz71kRmf4g98jwN3AN4E3CH7JjySIgTYChwD/CjxlZid592ttXAgsIohj6oDvAC3AV8P13wQ+A1wPrAFqgU8ABjwKvAk8DHwFeB5YG+73AMHb/uuA1cBlBL8UTnf3Pye1Pxk4Cvga0AHsCJcfEI5pVrj8+8D9QAXwGPDvYZ9+ZmaHJ858zewbBHHGLOBPwKnAt82szd3vDbf5e+Cu8BhPhn2Y29eTbGb7A38M+/Ytgl92RxG8y0noc9xmNi18nmcTxHUfBn5gZhXuflfSsUYA9wIzgZXA2vCX8VPAOuDzwHDgnrBPmXgY+FH4/HwN+G8zq3P3zeH68QT/rrPCx/8b+K2ZneruTQT/Ju8G/lfYPsDmcFwfAn5D8HqcQfC6mxX28R/Dbf8dqCd4vWwBxtE9wpRsubtuRXoDqgEH/inFuqnhukv7OEY5wX9SB05JWr4JWAqUJS2bA6xOevw0MKOXYx8THvfDScveFy77+x59WA48nrTsOaANOKjHMWeF+78/adlXw2VfT1p2Urjsg+HjkQTvEq7tcbxvA2uTHjcDj/XY5j/DY53ay1ivAnYDx6ZZ3+e4CX5hbQF+2GPfecBWYEiP5+CjPbb7KrALOCRp2eRw2zlJyx4GnknxWvmHpGW16V5b4foyghPGPwD3JC3/AfBKiu2fB37VY9k5wB5gQvh4BfDlfP+/Gsw3RTqD35M9F5jZJ8O3/a0ERSqR6R7VY9P53j0zfxkYY2YWPl4MfNnMvmZmx2fYn1MI/pM/mljg7nuAnwE9I5jn3H1rimO0ufvCpMeJ/v8uxbIx4c8PAMMIzlqHJG7AfGCsmR1iZsOA44HHe7T3KH37ELDQ3ZemWZ/JuMcDNcB/99j3EYJfWMcmLesEfpuijed87xk57j4feDuD/kPw7iCx30aCd2iHJZaZ2eFm9pCZbSB43XQCZ7Dv66YbM3sXcDLw0x7P/R/CTU4Kfy4GrgsjpiMz7LP0gwr+4Lc5+YGZnUYQe7xK8FZ6IsF/WggKYrK3ejzuIDirKw8ff5MgVrgK+KuZrTWzy/roTy3wprt3pujngb31PUlrin717G9iWWJMB4c/XyUoVInbr8PlY4HRBHHUlh7H7/k4lYMIIrJ0Mhl3bdKynttAUPQTWnzfD7BHp+lrJv2H1P/ewwDCAv0kQeG+HphEEN38jn1fNz0dRPC8zqP7c99GUIMSsdcUgn+PW4DlZvaKmX06w75LBpThD349r3/9GYII44LEAjM7ekAHdt9B8J//+vAYVwL3mNlSd1+QZreNwIFhJp1c/A4hOKPsre/ZeCP8eVaKdiCIr/aEbfb8kDaTD223srdgp5LJuBO/MEYBL/XYBvaOAVI/N5sIin5PGX3o3IfjgPcQRGQLEgvDD1339LFvYnzXEcSAPa0HcPc3gMvDD6lPCLf/qZkd45pZFAmd4ZeeKvae/SZckGrD/nD3ZcA1QBdBcUjnzwTvEM5LLDCzcoJfRLH8MVDoGYJxj3b3phS37R5MWX0JOLfHvpmcZc4H3m9mx6RZn8m4VxF8KH5+j30/R/ALJV1clPA8cKqZJX5BYGaTyfxD295UhT/fmfppZhMIzvKTvfOuICEs5H8hyOpTPfebemzv7r4YmE7wnPUaGUnmdIZfen4LTDWz2QRvn89g74yKfjGzJ4H/R5C9tofH2UMwAyYld19sZo8Cc81sJMHsnssIZgFl/Yunl3ZbzGwG8MMwH36G4PV/NPB37v65cNPbgZ+Y2feBXxDMktln6mQK9xF8+Pm0md1C8GHsu4E6d78xk3G7e6eZ3Qp8L/x85fdh+xcDX3X33X30YS5BkfxleJzhBPHIG73ulZm/EkRL3zOzbxHEULcQnp0neYXgM5ELgGXAFndfSzAT7FdmVkbwOcZ2grF/ArjG3deY2UKCD5RfIoiALiP4/GFRBP0X0CydYr6R2SydISnW3QhsIPhP92uCM3IH/jlpm03Abb0dkyDOeYHgP+XbQCNwTtL2+8zSSer3DwnOZncBC4EP9djmOYI/2OrZ91nA+h7LPha2c2TSsmE9xxQuv5jgbHMXQSFsBKb12Oar4fOzA3gC+Dh9zNIJ9xsF/Dgc106CM/Kp/Rl3UvsrCc6WVwBX9vUcJK07KTxue9j+x4ElZDZLZ0iPY3V7DRB83rMoHNsy4B9SHGt/gllNLew7O+g0ghOOtwny+5eAfwOqw/V3hX1tI4iB5vf1nOvWv5uFT7SIiAxyyvBFREqECr6ISIlQwRcRKREq+CIiJaKgpmUefPDBXldXl+9uiIgUlUWLFr3u7jV9bVdQBb+uro6mpqZ8d0NEpKiY2ZpMtlOkIyJSIlTwRURKhAq+iEiJUMEXESkRKvgiIiVCBV9EpESo4Mug09zWzLxN82hua853V0QKSkHNwxfJVnNbM5cuv5RO76TSKpkzYQ711fX57pZIQdAZvgwqjW830uEdOE6Hd9DUpj/kE0lQwZdBw915cfuLex/jHFpxaB57JFJYVPBl0Hhs62Ms3LaQTx/0af7pkH9iePlw5m2ex86unfnumkhBUMGXQeFvO/7G7HWzef/w93PduOuYNmYas8bPYuWulcxeNzvf3RMpCCr4UvS279nO9FXTOWDIAdxWdxtlFrysTz3gVL40+ks8vvVxfrH1F3nupUj+ZV3wzWysmf3ezJaa2UtmdlW4/CYze83MFoe3c7Lvrkh37s6MtTNY176O2+tuZ2TFyG7rp9RO4eTqk5m5biardq7KUy9FCkMUZ/i7ga+5+7HAqcAVZnZcuO5Od39fePtlBG2JdPPY1sf4zZu/YWrtVE4efvI+68utnBnjZ7Bf2X5cu+pa5flS0rIu+O6+0d1fCO9vA5YCY7I9rkhfknP7i0dfnHa7mooabq27VXm+lLxIM3wzqwNOBBaGi640s2Yzm2dmB6bZZ4qZNZlZU0tLS5TdkUEsXW6fjvJ8kQgLvplVAz8Hrnb3t4EfAu8G3gdsBL6Taj93n+vuDe7eUFPT5zd0ifSZ26ejPF9KXSQF38wqCIr9Q+7+KIC7b3b3Pe7eBfwHcEoUbYn0ldunU27lzKibQVVZlfJ8KUlRzNIx4D5gqbt/N2l5bdJm5wFLsm1LJNPcPp2aSuX5UrqiOMM/Dfgi8KEeUzC/bWZ/NbNm4IPANRG0JSWsv7l9OhMPmMgloy9Rni8lJ+urZbr7M4ClWKVpmBKZ5Nx+zoQ5Gef26UypncLitsXMXDeTIQxhQ+cGGqobdGVNGdR0eWQpConc/vLay/uV26czxIYwo24G5y89nxvX3IhhVFiFLqcsg5ourSAFL9vcPp2ayhqO3e9YHKeLLnb7bl1OWQY1neFLQYsqt09l7a61NLc1YxhllDHEhtBQ3RDZ8UUKjQq+FKyoc/tk7V3tTF81naFlQ7n18FtZvWu1MnwZ9FTwpWBFndsn++7677Js5zLufPednDHijEiPLVKolOFLQYortwd46o2n+NnrP+PCUReq2EtJUcGXghN3bn/b2tuo37+ey8dcHtlxRYqBIh0pKLnI7YfYEG4ffzsVVhHZsUWKgQq+FJRc5fa1lbV97yAyyCjSkYKh3F4kXir4UhCU24vET5GO5J1ye5HcUMGXvFNuL5IbinQkr5Tbi+SOCr7kjXJ7kdxSpCN5odxeJPdU8CUvlNuL5F4U32k71sx+b2ZLzewlM7sqXD7SzH5rZsvDnwdm310ZDJTbi+RHFKHpbuBr7n4scCpwhZkdB0wH5rv7BGB++FhKnHJ7kfzJ+n+bu2909xfC+9uApcAY4FzggXCzB4BPZduWFLfk3P72utuV24vkWKQZvpnVAScCC4FD3H0jBL8UzGxUlG1J8VFuL5Jfkb2fNrNq4OfA1e7+dj/2m2JmTWbW1NLSElV3pMAotxfJv0gKvplVEBT7h9z90XDxZjOrDdfXAltS7evuc929wd0bampqouiOFBjl9iKFIYpZOgbcByx19+8mrXoCuCi8fxHweLZtSfFRbi9SOKLI8E8Dvgj81cwWh8uuB2YBPzWzLwFrgfMjaEuKTC5y+7vefZdye5EMZF3w3f0ZwNKsnpzt8aV45SK3v+iQi/jAiA9EemyRwUrX0pFY5CK3P2H/E7js0MsiO67IYKdLK0jkdJ0ckcKkgi+Ry1VuP7pydKTHFhnsFOlIpJTbixQuFXyJjHJ7kcKmSEciodxepPCp4EsklNuLFD5FOpI15fYixUEFX7ISZ27/1BtP8c013+TIYUcqtxeJgAq+DFic18lpbmvmhtU30OmdrG1fy9LtSyM7tkipUsGXAUvk9lNrp0ae2ze1NeE4AJ3eSVNbU6THFylFKvgyIHHm9gAN1Q1UWiWG4TjllEfehkipUcGXfoszt0+or65nzoQ5XFp7KYdXHs79m+9nY/vGyNsRKSUq+NIvceb2PdVX1/Pl2i/zvQnfY4/vYfqq6XR2dcbWnshgp4Iv/RJnbp/O2KFj+cbh32DJjiX8YMMPctKmyGCkgi8Ziyu3b25rZt6meTS3Nafd5iMHfoTP1XyOB7c8yB/e+kNkbYuUEv2lrWQkrty+ua2Zqcun0uEdVFolcybMob66PuW2V4+5mua2Zm5acxM/qfoJtUP1LVci/aEzfOlTnLn9wm0Lafd2HKfDO3qdfjm0bCizjpilPF9kgCIp+GY2z8y2mNmSpGU3mdlrZrY4vJ0TRVuSe3Hm9st2LHvnvuMcUnFIr9srzxcZuKjO8O8HPpZi+Z3u/r7w9suI2pIcivs6Ob9v/T1nH3g2lxxyCSPKR3DfpvvYvmd7r/spzxcZmEgKvrv/EXgjimNJ4cjF9e3r96/nW3Xf4ooxVzD7iNlBbLT2dty91/2vHnM1x1Qdw01rbtL8fJEMxZ3hX2lmzWHkc2CqDcxsipk1mVlTS0tLzN2RTMWZ26e7vv3Jw09mau1Ufv3mr/mfrf/T6zGU54v0X5wF/4fAu4H3ARuB76TayN3nunuDuzfU1NTE2B3pjzhz+8T17W+qu4nayu4zbS4efTHvH/5+Zq+bzfIdy3s9jvJ8kf6JreC7+2Z33+PuXcB/AKfE1ZZEKxfXt79w1IWcMeKMfdaXWRm31d3G8CHDuXbVtcrzRSIUW8E3s+RTt/OAJem2lcKRq9z+8jGXp91uZMVIbq+7XXm+SMSimpb5X0AjcLSZrTezLwHfNrO/mlkz8EHgmijakvjkI7dPR3m+SPSimqXzBXevdfcKdz/M3e9z9y+6+3vdvd7dP+nuOvUqcPnK7dNRni8SLf2lrQD5ze3TUZ4vEi0VfCmI3D4d5fki0VHBL3GFlNunozxfJBoq+CWu0HL7dJTni2RPBb+EFWJun47yfJHsqeCXqELO7dNRni+SHRX8ElQMuX06yvNFBk4Fv8Q0tzXzLyv/pShy+3SU54sMjAp+CWlua+bS5ZeyoHUBZZRFXuyjzu3TUZ4vMjAq+CWkqa2JTg9iDcd5oe2FyI4dV26fjvJ8kf5TwS8hDdUNVFolEBT8cUPHRXLcuHP7dJTni/SPCn4Jqa+uZ86EOVw46kL2K9uP+zffT0dXR9bHzUVun47yfJHMqeCXmPrqeq467Cpuq7uNpTuWctdrd2V1vFzl9ukozxfJnAp+iTrzXWdywagLeKTlEea/OX9Ax8h1bp+O8nyRzKjgl7Bph07j+P2O5+Y1N7O+fX2/9s1Xbp+O8nyRvqngl7CKsgpmjZ9FmZUxfdX0fuX5+czt01GeL9I7FfwSVzu0lpsPv7lfeX6+c/t0lOeL9E4FX7rl+U+/+XSv2xZKbp+O8nyR9KL6Ttt5ZrbFzJYkLRtpZr81s+XhzwOjaEvikcjzb1lzC+va16XcJjm3nzl+Zt5z+3SU54ukFtUZ/v3Ax3osmw7Md/cJwPzwsRSobnn+ytR5fiK3v7nuZkZXjs5DLzOnPF9kX1F9ifkfgTd6LD4XeCC8/wDwqSjakvgk8vxXdr6yT56fyO0vOuQiPjDiA3nqYeaU54vsK84M/xB33wgQ/hyVaiMzm2JmTWbW1NLSEmN3JBOp8vxEbn/C/idw2aGX5bmHmVOeL9Jd3j+0dfe57t7g7g01NTX57o7QPc//1dZf8eW/fRmgIObb95fyfJG94iz4m82sFiD8uSXGtiRCiTzfcW5ccyOv736dDu9gS0dx/hMqzxcJxFnwnwAuCu9fBDweY1sSsdqhtUwaMemdx13eRVNbU/46lAXl+SKBqKZl/hfQCBxtZuvN7EvALOAjZrYc+Ej4WIrI+TXnM9SGUk45Q2wIDdUN+e7SgCnPFwHr64WfSw0NDd7UVJxnkYNVc1szTW1NNFQ3UF9dn+/uZO2+jfdxz8Z7uHHcjZx38Hm9bruufR0XLL2A8cPGc+9R91JRVlyfX0jpMLNF7t7nGVneP7SVwlZfXc8loy8ZFMUelOdLaVPBl5KiPF9KmQq+lBzl+VKqVPClJBXS/PzGxkZmzpxJY2NjpMfNt8E6rmI2JN8dEMmXi0dfzKK2RcxeN5vj9zueCftNSLttIs+fvmo6P9jwA6457JpI+tDY2MiZZ55JZ2cnZWVl1NfXM2LEiEiOnU+tra00Nzfj7gwbNoz58+czceLEfHer5OkMX0pWIeT5CxYsoLMzeMfQ1dVFa2trJMfNt9bWVrq6unB3Ojo6WLBgQb67JOgMX0pcIs+funwqt6+9ndvqbsPM0m5/9ZiraW5r5qY1N/GTqp9QOzS7b/uaNGkSZWVldHV1UVVVxUMPPTQozoQbGxs5/fTT6erqorKykkmTJuW7S4LO8EXymudPnDiR+vp6xo8fP6hij8E6rmKngi9CfufnjxgxgnHjxg26ojhYx1XMVPBFKIw8XyRuKvgiIc3Pl8FOBV8kSSHNz8+XF9te5L6N99Hc1pzvrkjEVPBFeijl6+38pe0v/PPf/pl7Nt7D1OVTVfQHGRV8kR5KOc+fu3EuXXQB0O7tRfsdCJKaCr5ICrnM81tbW1m7dm1slyBId4mDnsuf3/Y8z297njLKMIK/RWjvah9wu3GPS/pP18MX6UXc189P/gOlOC6tkO4SBz0v6fCe+vewfsh6yiln3LBxtO1p463db7GraxfH7ncsw8qG9bvdxYsXA1BVVaW5+DHT9fBFIhB3nr9gwYJ33j3EcWmFdJc46HlJh9Wvr2aP7+GIqiMYXj6c2spajqw6kjIrY+Wule/EPP1pN0GXVigg7l4wt5NPPtlFCs3Wjq1+VvNZft6S87xtd1uf289aO8tPWnSSL3hzQZ/bPvvss15VVeXl5eVeVVXlzz77bBRd7nb8srIyB7odP3l5xbAKP+rHR/mjLY/uu3/rs37yopP95tU397vdOMcl3QFNnkGNjT3SMbPVwDZgD7Dbe3nboUhHCtWibYuYunwqZx14Vp/X22nvaueSZZewoWMDPzmm7+vtNDY2smDBAiZNmhRL7HHiiSfS2tq6z3V6TjzxRLa8uYUDbjqAz5z5GW6tuzXluO7ZcA/3bbqPmw+/mU8c9ImM2417XLJXppFOrgp+g7u/3te2KvhSyIr1+3ATFy7rGaucduZpLN2xlEn3T+LBYx5kv/L9Uu6/23dz+fLLeWnHSzx49IOMrxofc4+lv5Thi0RsMM3P3+N7WL0ryO3vGH9H2mIPMMSGMKNuBlVlVVy76lp2du3MYU8lSrko+A48ZWaLzGxKz5VmNsXMmsysqaWlJQfdERmYwTQ/f96meby9523GDh3b6xe/JNRU1nBr3a2s3LWS2etm56CHEodcFPzT3P0k4GzgCjM7I3mlu8919wZ3b6ipqclBd0QGbjBcb+f5bc8zd+NcRg4ZycEVB2e838QDJnLJ6Et4fOvj/GLrL2LsocQl9oLv7hvCn1uAx4BT4m5TJE7FfL2drZ1buWHVDYwdOpbDhx7e7/2n1E7h5OqTmbluJqt2roqhhxKnWAu+me1vZsMT94GzgCVxtimSC8WY5+/xPXxj9Tdo29PGHePvoMz6/99feX5xi/sM/xDgGTN7Efgz8KS7/zrmNkViV4x5/rxN81i4bSH/OvZfM8rt01GeX7xiLfjuvtLdTwhv73H3GXG2J5JLxZTnb9uzjbkb53L2gWfzqYM+lfXxkvP88186n0dbHo2glxI3TcsUyUIx5Pmd3smqXasYO3Qs14+7vtc/GuuPURWjAFjZvpIZ62ao6BcBFXyRLBVynt+f+fb99fSbT3d7PP+t+ZEdW+Khgi+SpULO8/s73z5T7s7be97utmzyuyZHdnyJhwq+SAQKMc8f6Hz7TDzS8gjLdi5j8ojJnDr8VG4YewOfrvl0pG1I9FTwRSJSSHl+tvPte/Py9pe587U7OWPEGdxxxB3cPeFuFfsioYIvEqFCyPOjmG+fzrbd25i+ajoHVxzMTYffFNkHwJIbKvgiESqEPD+q+fY9uTu3rL2FTR2bmDV+FiOGRPfNXJIbKvgiEctnnp/I7aOab5/skZZH+N1bv+MrY77Ce/d/b6THltxQwReJQT7y/OTcPsr59tA9t79g1AWRHVdySwVfJCa5zPN75vZRzrdXbj94qOCLxCSXeb5ye8mECr5IjHKR5yu3l0yp4IvELM48X7m99IcKvkgOxJHnK7eX/lLBF8mBOPJ85fbSXyr4IjkSZZ6v3F4GQgVfJIeiyPOV28tAqeCL5Fg2eb5ye8lG7AXfzD5mZsvMbIWZTY+7PZFCl02e/7mXP6fcXgYs1oJvZuXA3cDZwHHAF8zsuDjbFCkG/c3zJ79rMoaxun01ZZRxxLAjIu2PcvvSEPcZ/inAivDLzDuAh4FzY25TpCj0J89v3t6MsTdiWdS2KLJ+KLcvHXEX/DHAuqTH68Nl7zCzKWbWZGZNLS0tMXdHpLBkmuc3VDdQYRWUU06FVdBQ3RBJ+4kPhJXbl4a4C36qV0+3967uPtfdG9y9oaamJubuiBSWTPP8+up65kyYw9RDpzJnwhzqq+sjaX91+2rl9iUk7oK/Hhib9PgwYEPMbYoUlUzz/Prqei4ZfUlkxX5L5xbe2v2WcvsSEnfBfx6YYGbjzawS+DzwRMxtihSd/uT5UXh5+8usb1/PiPIRyu1LyJA4D+7uu83sSuA3QDkwz91firNNkWJ18eiLWdS2iNnrZlNplWzu3ExDdUNkZ/QJifn2FVZB3bA65fYlJNaCD+DuvwR+GXc7IsUuked/9uXP8q0138IwKqwi0sw+eb79EcOOYIjFXgKkgOgvbUUKyMiKkZyw/wk4Thdd7PbdNLU1RXb8xHz7aWOmsX/5/pEdV4qDCr5IAdnauZXF2xdjGGWUMcSGRDYFM3m+/T+O+sdIjinFRe/nRApE4jo57V3t3Hz4zZFm+JpvL6CCL1IwfrzpxyzctpAbx93Ixw/6eKTHXt2+mvaOdu496l7Nty9hinRECkDTtiZ+tPFHsVzfPjHfftqYaZHP+JHiooIvkmdbO7dy/arrY7u+fWK+vXJ7UaQjkkfJ17e/+8i7Y7m+vebbS4LO8EXyKJHbx3l9e823lwQVfJE8iTO313x7SUUFXyQP4s7tNd9eUtH7PJEcy0Vur/n2kooKvkiOJc+3jyu313x7SUWRjkgO5Sq313x7SUUFXyRHlNtLvinSEckB5fZSCFTwRXJAub0UAkU6IjFTbi+FQgVfJEbK7aWQxFbwzewmM3vNzBaHt3PiakukECXn9neMv0O5veRd3Bn+ne7+bzG3IVKQlNtLoVGkIxID5fZSiOIu+FeaWbOZzTOzA1NtYGZTzKzJzJpaWlpi7o5I/JTbS6HKquCb2dNmtiTF7Vzgh8C7gfcBG4HvpDqGu8919wZ3b6ipqcmmOyJ5p9xeCllWGb67fziT7czsP4BfZNOWSDFQbi+FLM5ZOrVJD88DlsTVlkghGGhu39jYyMyZM2lsbEy7TTa5fWtrK2vXrt3n+OmWRyWTcUlumbvHc2Cz/ySIcxxYDVzq7ht726ehocGbmppi6Y9InLZ2buULS79AdXk1Dx7zYMZRTmNjI2eeeSadnZ2UlZVRX1/PiBHdz9537NnBKztf4YDyAziy6sh+9au1tZXFixcDUFVVxfz585k4cSKNjY2cfvrpdHV1pW03G62trTQ3N+PuDBs27J12JR5mtshvMdQvAAAIx0lEQVTdG/raLrYzfHf/oru/193r3f2TfRV7kWKVTW6/YMECOjs7Aejq6qK1tXWfY6/ctfKd76Xtr+TjdXR0sGDBgnfaTZzspWo3W62trXR1deHu3dqV/NK1dESylE1uP2nSJMrKyujq6qKqqoqHHnronTNhd+frq75O+1vt3HvUvQOagtnY2MjkyZPp6OigsrKSSZMmvdPusGHD3lme3G4Ukt9BJLcr+aWCL5KFbOfbT5w4kfr6elpbW/cpuonc/uoxVw94vv3EiROZP38+CxYsYNKkSe8cP93yqPQ2Lsmf2DL8gVCGL8VkoLl9T4mz3+TY4+XtL3Px3y7m7w74O757xHeLcgpmqnFJPDLN8HWGLzIAur69FCMVfJEB0Hx7KUa6lo5IP+k6OVKsVPBF+uFPb/2Ja169hlEVo3SdHCk6KvgiGWpua+ZrK7/Gjq4dvLH7DVbsXBHZsff4HuX2EjsVfJEMNbU10UUXAJ3eSVNbNDPKNmzYwPOLn6f54WZm1s0cNLl93JdukP7Th7YiGWqobqDSKunwDhwniinNc+fOZfny5QCsmbGGz/70sxx66KFZHzffki/pMHnyZF1aoUDoDF8kQ/XV9cyZMIeptVM5YugRPLD5Ada1r8vqmA/89IFuj19//fWsjlco0l3SQfJLZ/gi/VBfXU99dT0fH/lxvvDKF5i+cjo/PvrHVJZV9vtY23ZvY9tp22D+3mWzZs1iypQpEfY4P9Jd0kHyS2f4IgNQO7SWmw+/mVd2vsJdr93V7/0T8+2HnTuMb3z/G5x11ln86Ec/GhTFHvZeuuHWW29VnFNAdIYvMkBnvutMLhh1AQ9teYiTqk/iwwdm9H1AQPfr5Hxx2hdhWowdzZOJEyeq0BcYneGLZGHaodM4fr/juWXNLRnn+ZpvL/migi+ShYqyCmaNn0WZlTF95XQ6ujp63V7XyZF8UsEXyVKmeX7ydXIG03x7KR4q+CIRSOT5j7Q8wtNvPp1yG10nR/Itq4JvZueb2Utm1mVmDT3WXWdmK8xsmZl9NLtuihS+5Dx/ffv6buuU20shyPYMfwnwaeCPyQvN7Djg88B7gI8B95hZeZZtiRS0bnn+qr15vnJ7KRRZFXx3X+ruy1KsOhd42N3b3X0VsAI4JZu2RIpBIs9fumMpd712l3J7KShxzcMfAzyX9Hh9uGwfZjYFmAIwbty4mLojkjvJ8/ObtjXx6q5Xs/peWpGo9HmGb2ZPm9mSFLdze9stxbKUV5py97nu3uDuDTU1NZn2W6SgTRoxCcN4dderlFFG/f4q9pJ/fZ7hu3vmfz6413pgbNLjw4ANAziOSFFavH0xhuHhec6itkWcUH1CnnslpS6uaZlPAJ83s6FmNh6YAPw5prZECk5DdQMVVkE55VRYBQ3VDX3vJBKzrDJ8MzsP+HegBnjSzBa7+0fd/SUz+ynwMrAbuMLd92TfXZHikLiUclNbEw3VDcrvpSBYFF/iEJWGhgZvaormW4REREqFmS1y9z7fRuovbUVESoQKvohIiVDBFxEpESr4IiIlQgVfRKREqOCLiJSIgpqWaWYtwJrw4cHA63nsTlw0ruIxGMcEGlexyWRch7t7n9emKaiCn8zMmjKZV1psNK7iMRjHBBpXsYlyXIp0RERKhAq+iEiJKOSCPzffHYiJxlU8BuOYQOMqNpGNq2AzfBERiVYhn+GLiEiEVPBFREpEwRZ8M/sXM3MzOzh8bGb2fTNbYWbNZnZSvvuYKTO7NezzYjN7yswODZcX7ZgAzGy2mb0S9v0xM3tX0rrrwnEtM7OP5rOf/WVm55vZS2bWZWYNPdYV7bgAzOxjYd9XmNn0fPdnoMxsnpltMbMlSctGmtlvzWx5+PPAfPaxv8xsrJn93syWhq+/q8Ll0Y3L3QvuRvD1iL8h+COsg8Nl5wC/Ivi+3FOBhfnuZz/Gc0DS/a8Ac4p9TGH/zwKGhPfvAO4I7x8HvAgMBcYDrwLl+e5vP8Z1LHA0sABoSFpe7OMqD/t8BFAZjuW4fPdrgGM5AzgJWJK07NvA9PD+9MTrsVhuQC1wUnh/OPC38DUX2bgK9Qz/TuDrdP/i83OB/+OB54B3mVltXnrXT+7+dtLD/dk7rqIdE4C7P+Xuu8OHzxF8dzEE43rY3dvdfRWwAjglH30cCHdf6u7LUqwq6nER9HWFu6909w7gYYIxFR13/yPwRo/F5wIPhPcfAD6V005lyd03uvsL4f1twFJgDBGOq+AKvpl9EnjN3V/ssWoMsC7p8fpwWVEwsxlmtg64APhmuLiox9TDJQTvVmBwjStZsY+r2Pvfl0PcfSMExRMYlef+DJiZ1QEnAguJcFxZfaftQJnZ08DoFKtuAK4niAr22S3FsoKZU9rbmNz9cXe/AbjBzK4DrgS+RYGPCfoeV7jNDQTfXfxQYrcU2xfduFLtlmJZQY2rD8Xe/5JgZtXAz4Gr3f1ts1T/bAOTl4Lv7h9OtdzM3kuQjb4YDvIw4AUzO4XgbGRs0uaHARti7mrG0o0phZ8ATxIU/IIeE/Q9LjO7CPgEMNnDkJFBMK40Cn5cfSj2/vdls5nVuvvGMBrdku8O9ZeZVRAU+4fc/dFwcWTjKqhIx93/6u6j3L3O3esIXqAnufsm4AngwnBmy6lAa+JtTqEzswlJDz8JvBLeL9oxQTDjA7gW+KS770ha9QTweTMbambjgQnAn/PRx4gV+7ieByaY2XgzqwQ+TzCmweIJ4KLw/kVAundqBcmCs9z7gKXu/t2kVdGNK9+fTPfxqfVq9s7SMeBuglkGfyVp9kSh3wh+Yy8BmoH/C4wp9jGF/V9BkAkvDm9zktbdEI5rGXB2vvvaz3GdR3Cy0Q5sBn4zGMYV9v8cgtkfrxLEV3nv0wDH8V/ARqAz/Lf6EnAQMB9YHv4cme9+9nNMpxNEbM1J/6fOiXJcurSCiEiJKKhIR0RE4qOCLyJSIlTwRURKhAq+iEiJUMEXESkRKvgiIiVCBV9EpET8f9Lf8bz4qQsyAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "def transform(x, y, rotation=0, scaling=(1, 1), translation=(0, 0), mirroring=False):\n", - " '''\n", - " Perform a combined coordinate tranformation according to given inputs. \n", - " Returns the transformed coordinates as arrays.\n", - " If no inputs are given, returns the unchanged coordinates.\n", - "\n", - " Args:\n", - " x (array) : x-values to transform.\n", - " y (array) : y-values to transform.\n", - " rotate (float, optional) : Clockwise rotation angle in [deg]. Defaults to no rotation.\n", - " scale (float, optional) : Scaling factor in axes directions (cx, cy). Defaults to no scaling.\n", - " translate (tuple, optional) : Translation in axes directions (dx, dy). Defaults to no translation.\n", - " mirror (bool, optional) : Whether or not to mirror the coordinates, Defaults to no mirroring.\n", - " '''\n", - " \n", - " # Rotate coordinates \n", - " xt, yt = rotate(x, y, theta=rotation)\n", - " \n", - " # Scale coordinates\n", - " xt, yt = scale(xt, yt, scaling[0], scaling[1])\n", - " \n", - " # Translate coordinates\n", - " xt, yt = translate(xt, yt, translation[0], translation[1])\n", - " \n", - " # Mirror coordinates if input parameter mirroring is set to True\n", - " if mirroring:\n", - " xt, yt = mirror(xt, yt)\n", - "\n", - " # Return transformed coordinates as numpy arrays\n", - " return xt, yt\n", - "\n", - "\n", - "# Call the function with test arrays\n", - "xt, yt = transform(x, y, rotation=45, scaling=(1.5, 2), translation=(10, 8), mirroring=True)\n", - "\n", - "# Plot the transformed coordinates\n", - "transform_title = 'Transformed coordinates'\n", - "plot_transform(xt, yt, x, y, title=transform_title)" - ] } ], "metadata": { @@ -646,7 +655,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.1" + "version": "3.7.4" }, "latex_envs": { "LaTeX_envs_menu_present": true, diff --git a/Session 8 - Exercise (Interpolation)/Session 8 - Exercise (Interpolation).ipynb b/Session 8 - Exercise (Interpolation)/Session 8 - Exercise (Interpolation).ipynb index 18f6373..e967865 100644 --- a/Session 8 - Exercise (Interpolation)/Session 8 - Exercise (Interpolation).ipynb +++ b/Session 8 - Exercise (Interpolation)/Session 8 - Exercise (Interpolation).ipynb @@ -1,5 +1,204 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 8. Interpolation\n", + "\n", + "*If you haven't already installed the packages `numpy`, `pandas`, `xlrd` and `scipy`, please do so.*\n", + "\n", + "This session has no new material per se. It's supposed to combine elements from the previous sessions into a larger exercise. \n", + "\n", + "The exercise is about 3D interpolation. A set of known points $(x_{known}, x_{known}, z_{known})$ have prescribed values and are used as basis for interpolating $z$-values for a large set of points where only $(x, y)$ are known.\n", + "\n", + "For performing the actual interpolation, we call a function from a third party library called `scipy`. It's built on top of of `numpy` and holds many operations used in scientific analysis. \n", + "\n", + "The code originates from a COWI project where the points $(x, y)$ represent node coordinates from a base slab in a Finite Element model, while $z$-coordinates denote settlement values. The known points $(x_{known}, y_{known}, z_{known})$ stem from a detailed geotechnical analysis which could only be performed in a certain amount of points. The settlement values in the remaining points $(x, y)$ were therefore put into the FE-model as imposed displacements by a procedure similar to this. \n", + "\n", + "\n", + "# Exercise 1.1\n", + "Read through the code given in the script below and try to understand what it does and how it does it.\n", + "\n", + "Copy the script to your editor and run it. \n", + "\n", + "Add print statements if you are unsure about how a certain variable looks at any point throughout the code. Remember you can print the first five rows of a DataFrame with `df.head()`. \n", + "\n", + "The script reads two Excel files, i.e. one containing known points and one containing points to be interpolated. \n", + "One limitation of Excel files is that they cannot be read while they are open. If you want to inspect these files while running the script, create a copy. \n", + "\n", + "# Exercise 1.2\n", + "The bulk of the computational work in the script is done by the line:\n", + "\n", + "---\n", + "```python\n", + "settlements_interpolated = griddata(xy_known, settlements_known, (x_nodes, y_nodes), method='cubic')\n", + "```\n", + "---\n", + "This is the `scipy` function that performs the interpolation. Try to read the documentation for it [here](https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.griddata.html)\n", + "\n", + "The returned value that we save in the variable `settlements_interpolated` is a numpy array. You can see this by `print(type(settlements_interpolated))` which returns: ``. \n", + "\n", + "The last part of the given code creates a figure object and an axis object which enables 3D plots.\n", + "\n", + "**Continue the plotting code to add:**\n", + "\n", + "* 3D scatter plot of the known points $(x_{known}, y_{known}, z_{known})$\n", + "\n", + "* 3D scatter plot of the interpolated points $(x, y, z)$\n", + "\n", + "The plots should all be in the same figure and axis. Adding a scatter plot to an axis `ax` can be done as `ax.scatter(...)`.\n", + "\n", + "# Exercise 1.3\n", + "\n", + "As mentioned, this was used in a project for interpolating settlement values to be applied in an FE-model. The FE-software (Sofistik) has a certain input language which the interpolated values needed to be blended into. \n", + "\n", + "In this exercise we will construct the input `.dat`.file that Sofistik can read. \n", + "\n", + ">**Note:** This procedure could be used to produce many file types. It's a good way to programmatically create input files to software. This is just one specific example of a use case.\n", + "\n", + "The Sofistik input file we want to create has this syntax:\n", + "\n", + "---\n", + "\n", + "
\n",
+    "+PROG SOFILOAD \n",
+    "\n",
+    "LC 25 type 'SL' fact 1.0 facd 0.0 titl 'LT settlement all nodes'\n",
+    "\n",
+    "  POIN NODE insert first node number WIDE 0 TYPE WZZ insert first interpolated z-value\n",
+    "  ...\n",
+    "  one line per pair of node number/z-value \n",
+    "  ...\n",
+    "  POIN NODE insert last node number WIDE 0 TYPE WZZ insert last interpolated z-value\n",
+    "  \n",
+    "END\n",
+    "
\n", + "\n", + "---\n", + "\n", + "The indented block should print all the node/settlement pairs. The three non-indented lines should only appear once. The output file should look like the file `interpolation_output_example.dat` in the folder. Newlines are made by `\\n`.\n", + "\n", + "\n", + "## How to write to files\n", + "To write data to a file we can use something called a **context manager**. Basically, it allows us to open a file and write to it. See code snippet below:\n", + "\n", + "---\n", + "~~~python\n", + "# Use a context manager to open and write ('w') to file\n", + "with open('file_name.dat', 'w') as file:\n", + " \n", + " # The file can from here on out be referred to as file\n", + " file.write(\"This text will be written inside 'file_name.dat'\")\n", + "~~~\n", + "---\n", + "\n", + "By using the concept the file is automatically closed after our indented block is terminated. It also creates the file in case it doesn't already exist. \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# The script\n", + "\n", + "~~~python\n", + "\n", + "import pandas as pd\n", + "import numpy as np\n", + "from scipy.interpolate import griddata\n", + "import matplotlib.pyplot as plt\n", + "from mpl_toolkits.mplot3d import Axes3D\n", + "\n", + "\n", + "# Set name of Excel file to read containing known points\n", + "file_known = 'known_points.xlsx'\n", + "\n", + "# Set name of sheet to read from Excel file\n", + "sheet_known = 'Sheet1'\n", + "\n", + "# Read data from Excel sheet into a dataframe\n", + "df = pd.read_excel(file_known, sheet_name=sheet_known, skiprows=7)\n", + "\n", + "# Extract column names starting with 'Y' into new dataframe of known Y-coords\n", + "df_y = df[df.columns[df.columns.str.startswith('Y')]]\n", + "\n", + "# Extract column names starting with 'Z' into new dataframe of known Z-coords\n", + "df_z_known = df[df.columns[df.columns.str.startswith('Z')]]\n", + "\n", + "# Flatten dataframe values into 1D array (matri format -> vector format)\n", + "y_known = df_y.values.flatten()\n", + "z_known = df_z_known.values.flatten()\n", + "\n", + "# Extract known x-values\n", + "x_known = df['X']\n", + "\n", + "# Create X-array by repeating itself as many times as there are Y-columns\n", + "# This will create matching(x, y)-points between arrays x and y\n", + "x_known = np.repeat(x_known, len(df_y.columns))\n", + "\n", + "# Mirror known y-values and add corresponding x- and y-values\n", + "x_known = np.append(x_known, x_known)\n", + "y_known = np.append(y_known, -y_known)\n", + "z_known = np.append(z_known, z_known)\n", + "\n", + "# Arrange known (x, y) points to fit input for interpolation\n", + "xy_known = np.array(list(zip(x_known, y_known)))\n", + "\n", + "# Set names and read Excel file with nodes to be interpolated\n", + "file_nodes = 'points_to_be_interpolated.xlsx'\n", + "sheet_nodes = 'XLSX-Export'\n", + "df_nodes = pd.read_excel(file_nodes, sheet_name=sheet_nodes)\n", + "\n", + "# Extract x- and y-coordinates of nodes to be interpolated\n", + "x_nodes = df_nodes['X [m]']\n", + "y_nodes = df_nodes['Y [m]']\n", + "\n", + "# Extract node numbers for points to be interpolated\n", + "node_no = df_nodes['NR']\n", + "\n", + "# Perform interpolation calculation\n", + "points_interpolated = griddata(xy_known, z_known, (x_nodes, y_nodes), method='cubic')\n", + "\n", + "\n", + "####################\n", + "### Exercise 1.2 ###\n", + "####################\n", + "# Create figure object\n", + "fig = plt.figure()\n", + "\n", + "# Create axis object for 3D plot\n", + "ax = fig.add_subplot(111, projection='3d')\n", + "\n", + "# Plot known points as 3D scatter plot (ax.scatter(...))\n", + " # \n", + "\n", + "# Plot interpolated points as 3D scatter plot\n", + " # \n", + "\n", + "# Show figure\n", + " # \n", + "\n", + "\n", + "####################\n", + "### Exercise 1.3 ###\n", + "####################\n", + "# Write Sofistik input code to .dat-file for applying the interpolated z-values as \n", + "# imposed displacement load in all points (x, y)\n", + " # \n", + "\n", + "~~~" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# End of exercises\n", + "\n", + "*The cell below is for setting the style of this document. It's not part of the exercises.*" + ] + }, { "cell_type": "code", "execution_count": 1, @@ -284,196 +483,6 @@ "from IPython.display import HTML\n", "HTML(''.format(open('../css/cowi.css').read()))" ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# 8. Interpolation\n", - "\n", - "*If you haven't already installed the packages `numpy`, `pandas`, `xlrd` and `scipy`, please do so.*\n", - "\n", - "This session has no new material per se. It's supposed to combine elements from the previous sessions into a larger exercise. \n", - "\n", - "The exercise is about 3D interpolation. A set of known points $(x_{known}, x_{known}, z_{known})$ have prescribed values and are used as basis for interpolating $z$-values for a large set of points where only $(x, y)$ are known.\n", - "\n", - "For performing the actual interpolation, we call a function from a third party library called `scipy`. It's built on top of of `numpy` and holds many operations used in scientific analysis. \n", - "\n", - "The code originates from a COWI project where the points $(x, y)$ represent node coordinates from a base slab in a Finite Element model, while $z$-coordinates denote settlement values. The known points $(x_{known}, y_{known}, z_{known})$ stem from a detailed geotechnical analysis which could only be performed in a certain amount of points. The settlement values in the remaining points $(x, y)$ were therefore put into the FE-model as imposed displacements by a procedure similar to this. \n", - "\n", - "\n", - "# Exercise 1.1\n", - "Read through the code given in the script below and try to understand what it does and how it does it.\n", - "\n", - "Copy the script to your editor and run it. \n", - "\n", - "Add print statements if you are unsure about how a certain variable looks at any point throughout the code. Remember you can print the first five rows of a DataFrame with `df.head()`. \n", - "\n", - "The script reads two Excel files, i.e. one containing known points and one containing points to be interpolated. \n", - "One limitation of Excel files is that they cannot be read while they are open. If you want to inspect these files while running the script, create a copy. \n", - "\n", - "# Exercise 1.2\n", - "The bulk of the computational work in the script is done by the line:\n", - "\n", - "---\n", - "```python\n", - "settlements_interpolated = griddata(xy_known, settlements_known, (x_nodes, y_nodes), method='cubic')\n", - "```\n", - "---\n", - "This is the `scipy` function that performs the interpolation. Try to read the documentation for it [here](https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.griddata.html)\n", - "\n", - "The returned value that we save in the variable `settlements_interpolated` is a numpy array. You can see this by `print(type(settlements_interpolated))` which returns: ``. \n", - "\n", - "The last part of the given code creates a figure object and an axis object which enables 3D plots.\n", - "\n", - "**Continue the plotting code to add:**\n", - "\n", - "* 3D scatter plot of the known points $(x_{known}, y_{known}, z_{known})$\n", - "\n", - "* 3D scatter plot of the interpolated points $(x, y, z)$\n", - "\n", - "The plots should all be in the same figure and axis. Adding a scatter plot to an axis `ax` can be done as `ax.scatter(...)`.\n", - "\n", - "# Exercise 1.3\n", - "\n", - "As mentioned, this was used in a project for interpolating settlement values to be applied in an FE-model. The FE-software (Sofistik) has a certain input language which the interpolated values needed to be blended into. \n", - "\n", - "In this exercise we will construct the input `.dat`.file that Sofistik can read. \n", - "\n", - ">**Note:** This procedure could be used to produce many file types. It's a good way to programmatically create input files to software. This is just one specific example of a use case.\n", - "\n", - "The Sofistik input file we want to create has this syntax:\n", - "\n", - "---\n", - "\n", - "
\n",
-    "+PROG SOFILOAD \n",
-    "\n",
-    "LC 25 type 'SL' fact 1.0 facd 0.0 titl 'LT settlement all nodes'\n",
-    "\n",
-    "  POIN NODE insert first node number WIDE 0 TYPE WZZ insert first interpolated z-value\n",
-    "  ...\n",
-    "  one line per pair of node number/z-value \n",
-    "  ...\n",
-    "  POIN NODE insert last node number WIDE 0 TYPE WZZ insert last interpolated z-value\n",
-    "  \n",
-    "END\n",
-    "
\n", - "\n", - "---\n", - "\n", - "The indented block should print all the node/settlement pairs. The three non-indented lines should only appear once. The output file should look like the file `interpolation_output_example.dat` in the folder. Newlines are made by `\\n`.\n", - "\n", - "\n", - "## How to write to files\n", - "To write data to a file we can use something called a **context manager**. Basically, it allows us to open a file and write to it. See code snippet below:\n", - "\n", - "---\n", - "~~~python\n", - "# Use a context manager to open and write ('w') to file\n", - "with open('file_name.dat', 'w') as file:\n", - " \n", - " # The file can from here on out be referred to as file\n", - " file.write(\"This text will be written inside 'file_name.dat'\")\n", - "~~~\n", - "---\n", - "\n", - "By using the concept the file is automatically closed after our indented block is terminated. It also creates the file in case it doesn't already exist. \n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The script\n", - "\n", - "~~~python\n", - "\n", - "import pandas as pd\n", - "import numpy as np\n", - "from scipy.interpolate import griddata\n", - "import matplotlib.pyplot as plt\n", - "from mpl_toolkits.mplot3d import Axes3D\n", - "\n", - "\n", - "# Set name of Excel file to read containing known points\n", - "file_known = 'known_points.xlsx'\n", - "\n", - "# Set name of sheet to read from Excel file\n", - "sheet_known = 'Sheet1'\n", - "\n", - "# Read data from Excel sheet into a dataframe\n", - "df = pd.read_excel(file_known, sheet_name=sheet_known, skiprows=7)\n", - "\n", - "# Extract column names starting with 'Y' into new dataframe of known Y-coords\n", - "df_y = df[df.columns[df.columns.str.startswith('Y')]]\n", - "\n", - "# Extract column names starting with 'Z' into new dataframe of known Z-coords\n", - "df_z_known = df[df.columns[df.columns.str.startswith('Z')]]\n", - "\n", - "# Flatten dataframe values into 1D array (matri format -> vector format)\n", - "y_known = df_y.values.flatten()\n", - "z_known = df_z_known.values.flatten()\n", - "\n", - "# Extract known x-values\n", - "x_known = df['X']\n", - "\n", - "# Create X-array by repeating itself as many times as there are Y-columns\n", - "# This will create matching(x, y)-points between arrays x and y\n", - "x_known = np.repeat(x_known, len(df_y.columns))\n", - "\n", - "# Mirror known y-values and add corresponding x- and y-values\n", - "x_known = np.append(x_known, x_known)\n", - "y_known = np.append(y_known, -y_known)\n", - "z_known = np.append(z_known, z_known)\n", - "\n", - "# Arrange known (x, y) points to fit input for interpolation\n", - "xy_known = np.array(list(zip(x_known, y_known)))\n", - "\n", - "# Set names and read Excel file with nodes to be interpolated\n", - "file_nodes = 'points_to_be_interpolated.xlsx'\n", - "sheet_nodes = 'XLSX-Export'\n", - "df_nodes = pd.read_excel(file_nodes, sheet_name=sheet_nodes)\n", - "\n", - "# Extract x- and y-coordinates of nodes to be interpolated\n", - "x_nodes = df_nodes['X [m]']\n", - "y_nodes = df_nodes['Y [m]']\n", - "\n", - "# Extract node numbers for points to be interpolated\n", - "node_no = df_nodes['NR']\n", - "\n", - "# Perform interpolation calculation\n", - "points_interpolated = griddata(xy_known, z_known, (x_nodes, y_nodes), method='cubic')\n", - "\n", - "\n", - "####################\n", - "### Exercise 1.2 ###\n", - "####################\n", - "# Create figure object\n", - "fig = plt.figure()\n", - "\n", - "# Create axis object for 3D plot\n", - "ax = fig.add_subplot(111, projection='3d')\n", - "\n", - "# Plot known points as 3D scatter plot (ax.scatter(...))\n", - " # \n", - "\n", - "# Plot interpolated points as 3D scatter plot\n", - " # \n", - "\n", - "# Show figure\n", - " # \n", - "\n", - "\n", - "####################\n", - "### Exercise 1.3 ###\n", - "####################\n", - "# Write Sofistik input code to .dat-file for applying the interpolated z-values as \n", - "# imposed displacement load in all points (x, y)\n", - " # \n", - "\n", - "~~~" - ] } ], "metadata": { @@ -493,7 +502,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.1" + "version": "3.7.4" }, "latex_envs": { "LaTeX_envs_menu_present": true, diff --git a/Session 8 - Exercise (Interpolation)/Session 8 - Exercise Solutions.ipynb b/Session 8 - Exercise (Interpolation)/Session 8 - Exercise Solutions.ipynb index daf8d70..e5e788d 100644 --- a/Session 8 - Exercise (Interpolation)/Session 8 - Exercise Solutions.ipynb +++ b/Session 8 - Exercise (Interpolation)/Session 8 - Exercise Solutions.ipynb @@ -1,5 +1,127 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 8. Exercise solution\n", + "\n", + "The full script is provided below." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "~~~python \n", + "import pandas as pd\n", + "import numpy as np\n", + "from scipy.interpolate import griddata\n", + "import matplotlib.pyplot as plt\n", + "from mpl_toolkits.mplot3d import Axes3D\n", + "\n", + "\n", + "# Set name of Excel file to read containing known points\n", + "file_known = 'known_points.xlsx'\n", + "\n", + "# Set name of sheet to read from Excel file\n", + "sheet_known = 'Sheet1'\n", + "\n", + "# Read data from Excel sheet into a dataframe\n", + "df = pd.read_excel(file_known, sheet_name=sheet_known, skiprows=7)\n", + "\n", + "# Extract column names starting with 'Y' into new dataframe of known Y-coords\n", + "df_y = df[df.columns[df.columns.str.startswith('Y')]]\n", + "\n", + "# Extract column names starting with 'Z' into new dataframe of known Z-coords\n", + "df_z_known = df[df.columns[df.columns.str.startswith('Z')]]\n", + "\n", + "# Flatten dataframe values into 1D array (matri format -> vector format)\n", + "y_known = df_y.values.flatten()\n", + "z_known = df_z_known.values.flatten()\n", + "\n", + "# Extract known x-values\n", + "x_known = df['X']\n", + "\n", + "# Create X-array by repeating itself as many times as there are Y-columns\n", + "# This will create matching(x, y)-points between arrays x and y\n", + "x_known = np.repeat(x_known, len(df_y.columns))\n", + "\n", + "# Mirror known y-values and add corresponding x- and y-values\n", + "x_known = np.append(x_known, x_known)\n", + "y_known = np.append(y_known, -y_known)\n", + "z_known = np.append(z_known, z_known)\n", + "\n", + "# Arrange known (x, y) points to fit input for interpolation\n", + "xy_known = np.array(list(zip(x_known, y_known)))\n", + "\n", + "# Set names and read Excel file with nodes to be interpolated\n", + "file_nodes = 'points_to_be_interpolated.xlsx'\n", + "sheet_nodes = 'XLSX-Export'\n", + "df_nodes = pd.read_excel(file_nodes, sheet_name=sheet_nodes)\n", + "\n", + "# Extract x- and y-coordinates of nodes to be interpolated\n", + "x_nodes = df_nodes['X [m]']\n", + "y_nodes = df_nodes['Y [m]']\n", + "\n", + "# Extract node numbers for points to be interpolated\n", + "node_no = df_nodes['NR']\n", + "\n", + "# Perform interpolation calculation\n", + "z_interpolated = griddata(xy_known, z_known, (x_nodes, y_nodes), method='cubic')\n", + "\n", + "\n", + "####################\n", + "### Exercise 1.2 ###\n", + "####################\n", + "# Create figure object\n", + "fig = plt.figure()\n", + "\n", + "# Create axis object for 3D plot\n", + "ax = fig.add_subplot(111, projection='3d')\n", + "\n", + "# Plot known points as 3D scatter plot (ax.scatter(...))\n", + "ax.scatter(x_known, y_known, z_known, '-.', color='limegreen')\n", + "\n", + "# Plot interpolated points as 3D scatter plot\n", + "ax.scatter(x_nodes, y_nodes, z_interpolated,\n", + " '.', color='cornflowerblue', s=0.1)\n", + "\n", + "# Show figure\n", + "plt.show()\n", + "\n", + "\n", + "####################\n", + "### Exercise 1.3 ###\n", + "####################\n", + "# Write Sofistik input code to .dat-file for applying the interpolated z-values as\n", + "# imposed displacement load (settlement) in all points (x, y)\n", + "with open(f'generated_file.dat', 'w') as file:\n", + "\n", + " # Write the 'static' text to file\n", + " file.write('''+PROG SOFILOAD \n", + "\n", + "LC 25 type 'P' fact 1.0 facd 0.0 titl 'LT settlement all nodes' \\n''')\n", + "\n", + " # Write the 'variable' text to file with node number/settlement pairs\n", + " for node, settlement in zip(node_no, z_interpolated):\n", + " file.write(f' POIN NODE {node} WIDE 0 TYPE WZZ {settlement} \\n')\n", + "\n", + " # Write 'static' END statement to file\n", + " file.write('END')\n", + "\n", + "~~~" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# End of exercises\n", + "\n", + "*The cell below is for setting the style of this document. It's not part of the exercises.*" + ] + }, { "cell_type": "code", "execution_count": 1, @@ -284,119 +406,6 @@ "from IPython.display import HTML\n", "HTML(''.format(open('../css/cowi.css').read()))" ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# 8. Exercise solution\n", - "\n", - "The full script is provided below." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "~~~python \n", - "import pandas as pd\n", - "import numpy as np\n", - "from scipy.interpolate import griddata\n", - "import matplotlib.pyplot as plt\n", - "from mpl_toolkits.mplot3d import Axes3D\n", - "\n", - "\n", - "# Set name of Excel file to read containing known points\n", - "file_known = 'known_points.xlsx'\n", - "\n", - "# Set name of sheet to read from Excel file\n", - "sheet_known = 'Sheet1'\n", - "\n", - "# Read data from Excel sheet into a dataframe\n", - "df = pd.read_excel(file_known, sheet_name=sheet_known, skiprows=7)\n", - "\n", - "# Extract column names starting with 'Y' into new dataframe of known Y-coords\n", - "df_y = df[df.columns[df.columns.str.startswith('Y')]]\n", - "\n", - "# Extract column names starting with 'Z' into new dataframe of known Z-coords\n", - "df_z_known = df[df.columns[df.columns.str.startswith('Z')]]\n", - "\n", - "# Flatten dataframe values into 1D array (matri format -> vector format)\n", - "y_known = df_y.values.flatten()\n", - "z_known = df_z_known.values.flatten()\n", - "\n", - "# Extract known x-values\n", - "x_known = df['X']\n", - "\n", - "# Create X-array by repeating itself as many times as there are Y-columns\n", - "# This will create matching(x, y)-points between arrays x and y\n", - "x_known = np.repeat(x_known, len(df_y.columns))\n", - "\n", - "# Mirror known y-values and add corresponding x- and y-values\n", - "x_known = np.append(x_known, x_known)\n", - "y_known = np.append(y_known, -y_known)\n", - "z_known = np.append(z_known, z_known)\n", - "\n", - "# Arrange known (x, y) points to fit input for interpolation\n", - "xy_known = np.array(list(zip(x_known, y_known)))\n", - "\n", - "# Set names and read Excel file with nodes to be interpolated\n", - "file_nodes = 'points_to_be_interpolated.xlsx'\n", - "sheet_nodes = 'XLSX-Export'\n", - "df_nodes = pd.read_excel(file_nodes, sheet_name=sheet_nodes)\n", - "\n", - "# Extract x- and y-coordinates of nodes to be interpolated\n", - "x_nodes = df_nodes['X [m]']\n", - "y_nodes = df_nodes['Y [m]']\n", - "\n", - "# Extract node numbers for points to be interpolated\n", - "node_no = df_nodes['NR']\n", - "\n", - "# Perform interpolation calculation\n", - "z_interpolated = griddata(xy_known, z_known, (x_nodes, y_nodes), method='cubic')\n", - "\n", - "\n", - "####################\n", - "### Exercise 1.2 ###\n", - "####################\n", - "# Create figure object\n", - "fig = plt.figure()\n", - "\n", - "# Create axis object for 3D plot\n", - "ax = fig.add_subplot(111, projection='3d')\n", - "\n", - "# Plot known points as 3D scatter plot (ax.scatter(...))\n", - "ax.scatter(x_known, y_known, z_known, '-.', color='limegreen')\n", - "\n", - "# Plot interpolated points as 3D scatter plot\n", - "ax.scatter(x_nodes, y_nodes, z_interpolated,\n", - " '.', color='cornflowerblue', s=0.1)\n", - "\n", - "# Show figure\n", - "plt.show()\n", - "\n", - "\n", - "####################\n", - "### Exercise 1.3 ###\n", - "####################\n", - "# Write Sofistik input code to .dat-file for applying the interpolated z-values as\n", - "# imposed displacement load (settlement) in all points (x, y)\n", - "with open(f'generated_file.dat', 'w') as file:\n", - "\n", - " # Write the 'static' text to file\n", - " file.write('''+PROG SOFILOAD \n", - "\n", - "LC 25 type 'P' fact 1.0 facd 0.0 titl 'LT settlement all nodes' \\n''')\n", - "\n", - " # Write the 'variable' text to file with node number/settlement pairs\n", - " for node, settlement in zip(node_no, z_interpolated):\n", - " file.write(f' POIN NODE {node} WIDE 0 TYPE WZZ {settlement} \\n')\n", - "\n", - " # Write 'static' END statement to file\n", - " file.write('END')\n", - "\n", - "~~~" - ] } ], "metadata": { @@ -416,7 +425,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.1" + "version": "3.7.4" }, "latex_envs": { "LaTeX_envs_menu_present": true, diff --git a/Session 9 - Heatmaps and merging operation/Session 9 - Exercise Solutions.ipynb b/Session 9 - Heatmaps and merging operation/Session 9 - Exercise Solutions.ipynb index b87c0bd..2f7cf57 100644 --- a/Session 9 - Heatmaps and merging operation/Session 9 - Exercise Solutions.ipynb +++ b/Session 9 - Heatmaps and merging operation/Session 9 - Exercise Solutions.ipynb @@ -1,9 +1,587 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 9. Exercise Solutions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 1" + ] + }, { "cell_type": "code", "execution_count": 1, "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Read pile data from csv-file\n", + "df_piles = pd.read_csv('piles.csv')\n", + "\n", + "# Read steel profile data from csv-file\n", + "df_profiles = pd.read_csv('steel_profiles.csv')\n", + "\n", + "# Merge dataframes on \"Profile\" column (similar to Excel VLOOKUP)\n", + "df_merged = df_piles.merge(df_profiles, on='Profile', how='left')" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Profileh[mm]b[mm]Iy[mm4]Wel_y[mm3]g[kg/m]
0HE100A96100349000072.816.7
1HE120A1141206060000106.019.9
2HE140A13314010300000155.024.7
3HE160A15216016700000220.030.4
4HE180A17118025100000294.035.5
\n", + "
" + ], + "text/plain": [ + " Profile h[mm] b[mm] Iy[mm4] Wel_y[mm3] g[kg/m]\n", + "0 HE100A 96 100 3490000 72.8 16.7\n", + "1 HE120A 114 120 6060000 106.0 19.9\n", + "2 HE140A 133 140 10300000 155.0 24.7\n", + "3 HE160A 152 160 16700000 220.0 30.4\n", + "4 HE180A 171 180 25100000 294.0 35.5" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Display first five rows of dataframe of steel profiles\n", + "df_profiles.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Pile_typeProfile
0P01HE200A
1P20HE220A
2P05HE240B
3P23NaN
4P04HE200A
5P01HE300B
\n", + "
" + ], + "text/plain": [ + " Pile_type Profile\n", + "0 P01 HE200A\n", + "1 P20 HE220A\n", + "2 P05 HE240B\n", + "3 P23 NaN\n", + "4 P04 HE200A\n", + "5 P01 HE300B" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Display dataframe of piles\n", + "df_piles" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Pile_typeProfileh[mm]b[mm]Iy[mm4]Wel_y[mm3]g[kg/m]
0P01HE200A190.0200.036900000.0389.042.3
1P20HE220A210.0220.054100000.0515.050.5
2P05HE240B240.0240.0112600000.0938.083.2
3P23NaNNaNNaNNaNNaNNaN
4P04HE200A190.0200.036900000.0389.042.3
5P01HE300B300.0300.0251700000.01680.0117.0
\n", + "
" + ], + "text/plain": [ + " Pile_type Profile h[mm] b[mm] Iy[mm4] Wel_y[mm3] g[kg/m]\n", + "0 P01 HE200A 190.0 200.0 36900000.0 389.0 42.3\n", + "1 P20 HE220A 210.0 220.0 54100000.0 515.0 50.5\n", + "2 P05 HE240B 240.0 240.0 112600000.0 938.0 83.2\n", + "3 P23 NaN NaN NaN NaN NaN NaN\n", + "4 P04 HE200A 190.0 200.0 36900000.0 389.0 42.3\n", + "5 P01 HE300B 300.0 300.0 251700000.0 1680.0 117.0" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Display merged dataframe \n", + "df_merged" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 2" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Criterionx[m]y[m]N[kN/m]M[kNm/m]w_k[mm]
2max My22.1157.603-459.666.10.002553
5max My22.2507.603-432.187.80.013417
8max My22.2507.747-443.180.90.009092
11max My22.1157.747-497.069.00.002068
14max My22.1158.159-522.556.70.000000
\n", + "
" + ], + "text/plain": [ + " Criterion x[m] y[m] N[kN/m] M[kNm/m] w_k[mm]\n", + "2 max My 22.115 7.603 -459.6 66.1 0.002553\n", + "5 max My 22.250 7.603 -432.1 87.8 0.013417\n", + "8 max My 22.250 7.747 -443.1 80.9 0.009092\n", + "11 max My 22.115 7.747 -497.0 69.0 0.002068\n", + "14 max My 22.115 8.159 -522.5 56.7 0.000000" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "\n", + "# Set filename for dataset of forces from an IBDAS shell element\n", + "filename = 'crack_width_Seg7_y_direction.csv'\n", + "\n", + "# Read CSV-file\n", + "df = pd.read_csv(filename, skip_blank_lines=True)\n", + "\n", + "# Filter dataframe for load case and criterion for critical combination\n", + "criterion = 'max My'\n", + "df = df[df['Criterion'] == criterion]\n", + "\n", + "df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(141.0, 0.5, 'Global y-coordinate [m]')" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Round dataframe coordinate columns\n", + "df['x[m]'] = round(df['x[m]'], 1)\n", + "df['y[m]'] = round(df['y[m]'], 1)\n", + "\n", + "# Pivot data frame data into matrix form for heatmap plotting\n", + "pivot_final = df.pivot(index='y[m]', columns='x[m]', values='w_k[mm]').sort_index(ascending=False)\n", + "\n", + "# Set max allowable crack with for concrete slab for use as max value of colorbar\n", + "vmax = 0.3\n", + "\n", + "# Create figure\n", + "plt.figure(figsize=(18, 8))\n", + "\n", + "# Plot heatmap with annotation\n", + "sns.heatmap(pivot_final, annot=True, annot_kws={'size': 10}, vmax=vmax,\n", + " fmt=\".2f\", square=True, cbar_kws={\"orientation\": \"horizontal\"}, cmap='Reds')\n", + "\n", + "# Set titles and axes labels\n", + "plt.title(f'Crack width for Segment 7, Criterion: {criterion}', fontsize=20)\n", + "plt.xlabel('Global x-coordinate [m]', fontsize=16)\n", + "plt.ylabel('Global y-coordinate [m]', fontsize=16)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Some extra stuff - Conditional coloring of values" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# Create figure\n", + "plt.figure(figsize=(18, 8))\n", + "\n", + "# Plot heatmap wiht annotation, save axes object so it can be accessed later\n", + "ax = sns.heatmap(pivot_final, annot=True, annot_kws={'size': 10}, vmax=vmax,\n", + " fmt=\".2f\", square=True, cbar_kws={\"orientation\": \"horizontal\"}, cmap='Reds')\n", + "\n", + "# --- Color values that exceed the max value ---\n", + "\n", + "# Loop over all annotations of the axis object\n", + "for annot in ax.texts:\n", + " \n", + " # Annot will now be an object which prints 'Text(x, y, w_k)'\n", + " \n", + " # Extract the crack width part of the Text object and convert from string to float \n", + " wk = float(annot.get_text())\n", + " \n", + " # Set all values that exceed vmax to bold and a special color\n", + " if wk > vmax: \n", + " annot.set_weight('bold')\n", + " annot.set_color('cyan')\n", + " annot.set_size(12)\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# End of exercises\n", + "\n", + "*The cell below is for setting the style of this document. It's not part of the exercises.*" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, "outputs": [ { "data": { @@ -275,7 +853,7 @@ "" ] }, - "execution_count": 1, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -284,575 +862,6 @@ "from IPython.display import HTML\n", "HTML(''.format(open('../css/cowi.css').read()))" ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# 9. Exercise Solutions" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 1" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", - "\n", - "# Read pile data from csv-file\n", - "df_piles = pd.read_csv('piles.csv')\n", - "\n", - "# Read steel profile data from csv-file\n", - "df_profiles = pd.read_csv('steel_profiles.csv')\n", - "\n", - "# Merge dataframes on \"Profile\" column (similar to Excel VLOOKUP)\n", - "df_merged = df_piles.merge(df_profiles, on='Profile', how='left')" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Profileh[mm]b[mm]Iy[mm4]Wel_y[mm3]g[kg/m]
0HE100A96100349000072.816.7
1HE120A1141206060000106.019.9
2HE140A13314010300000155.024.7
3HE160A15216016700000220.030.4
4HE180A17118025100000294.035.5
\n", - "
" - ], - "text/plain": [ - " Profile h[mm] b[mm] Iy[mm4] Wel_y[mm3] g[kg/m]\n", - "0 HE100A 96 100 3490000 72.8 16.7\n", - "1 HE120A 114 120 6060000 106.0 19.9\n", - "2 HE140A 133 140 10300000 155.0 24.7\n", - "3 HE160A 152 160 16700000 220.0 30.4\n", - "4 HE180A 171 180 25100000 294.0 35.5" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Display first five rows of dataframe of steel profiles\n", - "df_profiles.head()" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Pile_typeProfile
0P01HE200A
1P20HE220A
2P05HE240B
3P23NaN
4P04HE200A
5P01HE300B
\n", - "
" - ], - "text/plain": [ - " Pile_type Profile\n", - "0 P01 HE200A\n", - "1 P20 HE220A\n", - "2 P05 HE240B\n", - "3 P23 NaN\n", - "4 P04 HE200A\n", - "5 P01 HE300B" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Display dataframe of piles\n", - "df_piles" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Pile_typeProfileh[mm]b[mm]Iy[mm4]Wel_y[mm3]g[kg/m]
0P01HE200A190.0200.036900000.0389.042.3
1P20HE220A210.0220.054100000.0515.050.5
2P05HE240B240.0240.0112600000.0938.083.2
3P23NaNNaNNaNNaNNaNNaN
4P04HE200A190.0200.036900000.0389.042.3
5P01HE300B300.0300.0251700000.01680.0117.0
\n", - "
" - ], - "text/plain": [ - " Pile_type Profile h[mm] b[mm] Iy[mm4] Wel_y[mm3] g[kg/m]\n", - "0 P01 HE200A 190.0 200.0 36900000.0 389.0 42.3\n", - "1 P20 HE220A 210.0 220.0 54100000.0 515.0 50.5\n", - "2 P05 HE240B 240.0 240.0 112600000.0 938.0 83.2\n", - "3 P23 NaN NaN NaN NaN NaN NaN\n", - "4 P04 HE200A 190.0 200.0 36900000.0 389.0 42.3\n", - "5 P01 HE300B 300.0 300.0 251700000.0 1680.0 117.0" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Display merged dataframe \n", - "df_merged" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 2" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Criterionx[m]y[m]N[kN/m]M[kNm/m]w_k[mm]
2max My22.1157.603-459.666.10.002553
5max My22.2507.603-432.187.80.013417
8max My22.2507.747-443.180.90.009092
11max My22.1157.747-497.069.00.002068
14max My22.1158.159-522.556.70.000000
\n", - "
" - ], - "text/plain": [ - " Criterion x[m] y[m] N[kN/m] M[kNm/m] w_k[mm]\n", - "2 max My 22.115 7.603 -459.6 66.1 0.002553\n", - "5 max My 22.250 7.603 -432.1 87.8 0.013417\n", - "8 max My 22.250 7.747 -443.1 80.9 0.009092\n", - "11 max My 22.115 7.747 -497.0 69.0 0.002068\n", - "14 max My 22.115 8.159 -522.5 56.7 0.000000" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", - "import seaborn as sns\n", - "\n", - "# Set filename for dataset of forces from an IBDAS shell element\n", - "filename = 'crack_width_Seg7_y_direction.csv'\n", - "\n", - "# Read CSV-file\n", - "df = pd.read_csv(filename, skip_blank_lines=True)\n", - "\n", - "# Filter dataframe for load case and criterion for critical combination\n", - "criterion = 'max My'\n", - "df = df[df['Criterion'] == criterion]\n", - "\n", - "df.head()" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(141.0, 0.5, 'Global y-coordinate [m]')" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Round dataframe coordinate columns\n", - "df['x[m]'] = round(df['x[m]'], 1)\n", - "df['y[m]'] = round(df['y[m]'], 1)\n", - "\n", - "# Pivot data frame data into matrix form for heatmap plotting\n", - "pivot_final = df.pivot(index='y[m]', columns='x[m]', values='w_k[mm]').sort_index(ascending=False)\n", - "\n", - "# Set max allowable crack with for concrete slab for use as max value of colorbar\n", - "vmax = 0.3\n", - "\n", - "# Create figure\n", - "plt.figure(figsize=(18, 8))\n", - "\n", - "# Plot heatmap with annotation\n", - "sns.heatmap(pivot_final, annot=True, annot_kws={'size': 10}, vmax=vmax,\n", - " fmt=\".2f\", square=True, cbar_kws={\"orientation\": \"horizontal\"}, cmap='Reds')\n", - "\n", - "# Set titles and axes labels\n", - "plt.title(f'Crack width for Segment 7, Criterion: {criterion}', fontsize=20)\n", - "plt.xlabel('Global x-coordinate [m]', fontsize=16)\n", - "plt.ylabel('Global y-coordinate [m]', fontsize=16)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Some extra stuff - Conditional coloring of values" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "\n", - "# Create figure\n", - "plt.figure(figsize=(18, 8))\n", - "\n", - "# Plot heatmap wiht annotation, save axes object so it can be accessed later\n", - "ax = sns.heatmap(pivot_final, annot=True, annot_kws={'size': 10}, vmax=vmax,\n", - " fmt=\".2f\", square=True, cbar_kws={\"orientation\": \"horizontal\"}, cmap='Reds')\n", - "\n", - "# --- Color values that exceed the max value ---\n", - "\n", - "# Loop over all annotations of the axis object\n", - "for annot in ax.texts:\n", - " \n", - " # Annot will now be an object which prints 'Text(x, y, w_k)'\n", - " \n", - " # Extract the crack width part of the Text object and convert from string to float \n", - " wk = float(annot.get_text())\n", - " \n", - " # Set all values that exceed vmax to bold and a special color\n", - " if wk > vmax: \n", - " annot.set_weight('bold')\n", - " annot.set_color('cyan')\n", - " annot.set_size(12)\n", - "\n", - "plt.show()\n" - ] } ], "metadata": { @@ -872,7 +881,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.1" + "version": "3.7.4" }, "latex_envs": { "LaTeX_envs_menu_present": true, diff --git a/Session 9 - Heatmaps and merging operation/Session 9 - Heatmaps and merging operations.ipynb b/Session 9 - Heatmaps and merging operation/Session 9 - Heatmaps and merging operations.ipynb index 2c94e81..c2ef859 100644 --- a/Session 9 - Heatmaps and merging operation/Session 9 - Heatmaps and merging operations.ipynb +++ b/Session 9 - Heatmaps and merging operation/Session 9 - Heatmaps and merging operations.ipynb @@ -1,9 +1,352 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 9. Heatmaps and Merging Operations\n", + "\n", + "\n", + "## Heatmaps\n", + "A `pandas` dataframe can be visualized by means of a so-called heatmap. A heatmap consists of tiles at each data point that adheres to a chosen color palette.\n", + "\n", + "Many plotting libraries offer the possibility of creating heatmaps. A common one is called `seaborn`, which is built on top of `matplotlib` to enhance certain plot types.\n", + "\n", + "Before the dataframe can be plotted to a heatmap, it needs to be in the right format. \n", + "If we for example have a dataframe with $x$-values in one column, $y$-values in another and the values to be plotted in a third column we can pivot the data to a new dataframe:" + ] + }, { "cell_type": "code", "execution_count": 1, "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
xyvalues
01a34
11b74
21c1
32a9
42b-36
52c-24
63a47
73b-27
83c47
\n", + "
" + ], + "text/plain": [ + " x y values\n", + "0 1 a 34\n", + "1 1 b 74\n", + "2 1 c 1\n", + "3 2 a 9\n", + "4 2 b -36\n", + "5 2 c -24\n", + "6 3 a 47\n", + "7 3 b -27\n", + "8 3 c 47" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd\n", + "\n", + "# Creata a dummy dataframe\n", + "df = pd.DataFrame({\n", + " 'x': [1, 1, 1, 2, 2, 2, 3, 3, 3],\n", + " 'y': ['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c'],\n", + " 'values': [34, 74, 1, 9, -36, -24, 47, -27, 47]})\n", + "\n", + "df" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
x123
y
a34947
b74-36-27
c1-2447
\n", + "
" + ], + "text/plain": [ + "x 1 2 3\n", + "y \n", + "a 34 9 47\n", + "b 74 -36 -27\n", + "c 1 -24 47" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Pivot the dataframe\n", + "df_pivot = df.pivot(index='y', columns='x', values='values')\n", + "df_pivot" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "A heatmap can be created from a dataframe like this:\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "\n", + "# Plot the pivotted dataframe as a heatmap\n", + "sns.heatmap(df_pivot, annot=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "> **Note:** Make sure you have installed the `seaborn` library before using this. Otherwise a `ModuleNotFoundError` will be raised.\n", + "\n", + "## Heatmap parameters\n", + "`seaborn.heatmap` has many parameters for tweaking the appearance of the colormap. Often a bunch of them are needed to create a good looking plot. \n", + "\n", + "Special attention should be paid to choosing a colormap that fits the dataset well. \n", + "\n", + ">**A poor chosen colormap can be very misleading to the reader of the plot, while a well-chosen one can convey the overall message to the reader in very few seconds.**\n", + "\n", + "See https://seaborn.pydata.org/generated/seaborn.heatmap.html\n", + "\n", + "Some of the parameters for `seaborn.heatmap`:\n", + "\n", + "* `annot=True` for annotating the value in each tile.\n", + "* `fmt` to set the number of decimals for the annotated tiles. Set equal to `\".0f\"` for 0 decimals.\n", + "* `annot_kws={'size': 10}` for setting font size of annotated tiles to 10.\n", + "* `square=True` for ensuring that tiles are square.\n", + "* `cmap=name_of_colormap` for controlling the colormap (see available colormaps here: https://matplotlib.org/users/colormaps.html, be sure to choose one that fits the content of the data).\n", + "* `vmin` and `vmax` to define the min and max values of the colormap (and colorbar).\n", + "* `cbar_kws={\"orientation\": \"horizontal\"}` for orientation of the colorbar. Here set to horizontal but is vertical as default.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Merge operations on dataframes\n", + "\n", + "Merge operations provide very powerful manipulation techniques in `pandas`. We are only going to look at a simple example here, which will perform an operation similar to Excel's `VLOOKUP`.\n", + "\n", + "---\n", + "~~~python\n", + "# Merge df1 and df2 on , retain only rows from df1 (similar to Excel VLOOKUP)\n", + "df_merged = df1.merge(df2, on='', how='left')\n", + "~~~\n", + "---\n", + "\n", + "See this page of the `pandas` documentation for more on merging, joining and concatenating DataFrames: https://pandas.pydata.org/pandas-docs/stable/user_guide/merging.html" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 1\n", + "\n", + "The file `piles.csv` in the session folder contains some steel piles and their profile type. Use `steel_profiles.csv` to insert the cross sectional parameters in each pile row. Use the merging operation described above. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 2\n", + "\n", + "The file `crack_width_Seg7_y_direction.csv` has results of a crack width calculation for a concrete slab. \n", + "\n", + "While doing the exercises below, recall that `df.head()` will print the first five rows of `df`.\n", + "\n", + "## Exercise 2.1\n", + "Load the file `crack_width_Seg7_y_direction.csv` into a dataframe. Filter the dataframe so it only contains rows where the `criterion` column is `max My`.\n", + "\n", + "## Exercise 2.2 \n", + "Pivot the dataframe and save it to a new dataframe. Use column `'y[m]'` as index, column `'x[m]'` as columns and column `'w_k[mm]'` as values.\n", + "\n", + "## Exercise 2.3\n", + "Create a heatmap of the pivotted dataframe. Use parameters of your choice from the ones described above or in the `pandas` documentation.\n", + "\n", + "Be sure to choose a colormap, the default one is awful. The maximum allowable crack width for this concrete slab is $w_{k.max} = 0.30$mm.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# End of exercises\n", + "\n", + "*The cell below is for setting the style of this document. It's not part of the exercises.*" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, "outputs": [ { "data": { @@ -275,7 +618,7 @@ "" ] }, - "execution_count": 1, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -284,328 +627,6 @@ "from IPython.display import HTML\n", "HTML(''.format(open('../css/cowi.css').read()))" ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# 9. Heatmaps and Merging Operations\n", - "\n", - "\n", - "## Heatmaps\n", - "A `pandas` dataframe can be visualized by means of a so-called heatmap. A heatmap consists of tiles at each data point that adheres to a chosen color palette.\n", - "\n", - "Many plotting libraries offer the possibility of creating heatmaps. A common one is called `seaborn`, which is built on top of `matplotlib` to enhance certain plot types.\n", - "\n", - "Before the dataframe can be plotted to a heatmap, it needs to be in the right format. \n", - "If we for example have a dataframe with $x$-values in one column, $y$-values in another and the values to be plotted in a third column we can pivot the data to a new dataframe:" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
xyvalues
01a34
11b74
21c1
32a9
42b-36
52c-24
63a47
73b-27
83c47
\n", - "
" - ], - "text/plain": [ - " x y values\n", - "0 1 a 34\n", - "1 1 b 74\n", - "2 1 c 1\n", - "3 2 a 9\n", - "4 2 b -36\n", - "5 2 c -24\n", - "6 3 a 47\n", - "7 3 b -27\n", - "8 3 c 47" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import pandas as pd\n", - "\n", - "# Creata a dummy dataframe\n", - "df = pd.DataFrame({\n", - " 'x': [1, 1, 1, 2, 2, 2, 3, 3, 3],\n", - " 'y': ['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c'],\n", - " 'values': [34, 74, 1, 9, -36, -24, 47, -27, 47]})\n", - "\n", - "df" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
x123
y
a34947
b74-36-27
c1-2447
\n", - "
" - ], - "text/plain": [ - "x 1 2 3\n", - "y \n", - "a 34 9 47\n", - "b 74 -36 -27\n", - "c 1 -24 47" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Pivot the dataframe\n", - "df_pivot = df.pivot(index='y', columns='x', values='values')\n", - "df_pivot" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "A heatmap can be created from a dataframe like this:\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import seaborn as sns\n", - "\n", - "# Plot the pivotted dataframe as a heatmap\n", - "sns.heatmap(df_pivot, annot=True)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "> **Note:** Make sure you have installed the `seaborn` library before using this. Otherwise a `ModuleNotFoundError` will be raised.\n", - "\n", - "## Heatmap parameters\n", - "`seaborn.heatmap` has many parameters for tweaking the appearance of the colormap. Often a bunch of them are needed to create a good looking plot. \n", - "\n", - "Special attention should be paid to choosing a colormap that fits the dataset well. \n", - "\n", - ">**A poor chosen colormap can be very misleading to the reader of the plot, while a well-chosen one can convey the overall message to the reader in very few seconds.**\n", - "\n", - "See https://seaborn.pydata.org/generated/seaborn.heatmap.html\n", - "\n", - "Some of the parameters for `seaborn.heatmap`:\n", - "\n", - "* `annot=True` for annotating the value in each tile.\n", - "* `fmt` to set the number of decimals for the annotated tiles. Set equal to `\".0f\"` for 0 decimals.\n", - "* `annot_kws={'size': 10}` for setting font size of annotated tiles to 10.\n", - "* `square=True` for ensuring that tiles are square.\n", - "* `cmap=name_of_colormap` for controlling the colormap (see available colormaps here: https://matplotlib.org/users/colormaps.html, be sure to choose one that fits the content of the data).\n", - "* `vmin` and `vmax` to define the min and max values of the colormap (and colorbar).\n", - "* `cbar_kws={\"orientation\": \"horizontal\"}` for orientation of the colorbar. Here set to horizontal but is vertical as default.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Merge operations on dataframes\n", - "\n", - "Merge operations provide very powerful manipulation techniques in `pandas`. We are only going to look at a simple example here, which will perform an operation similar to Excel's `VLOOKUP`.\n", - "\n", - "---\n", - "~~~python\n", - "# Merge df1 and df2 on , retain only rows from df1 (similar to Excel VLOOKUP)\n", - "df_merged = df1.merge(df2, on='', how='left')\n", - "~~~\n", - "---\n", - "\n", - "See this page of the `pandas` documentation for more on merging, joining and concatenating DataFrames: https://pandas.pydata.org/pandas-docs/stable/user_guide/merging.html" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 1\n", - "\n", - "The file `piles.csv` in the session folder contains some steel piles and their profile type. Use `steel_profiles.csv` to insert the cross sectional parameters in each pile row. Use the merging operation described above. " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 2\n", - "\n", - "The file `crack_width_Seg7_y_direction.csv` has results of a crack width calculation for a concrete slab. \n", - "\n", - "While doing the exercises below, recall that `df.head()` will print the first five rows of `df`.\n", - "\n", - "## Exercise 2.1\n", - "Load the file `crack_width_Seg7_y_direction.csv` into a dataframe. Filter the dataframe so it only contains rows where the `criterion` column is `max My`.\n", - "\n", - "## Exercise 2.2 \n", - "Pivot the dataframe and save it to a new dataframe. Use column `'y[m]'` as index, column `'x[m]'` as columns and column `'w_k[mm]'` as values.\n", - "\n", - "## Exercise 2.3\n", - "Create a heatmap of the pivotted dataframe. Use parameters of your choice from the ones described above or in the `pandas` documentation.\n", - "\n", - "Be sure to choose a colormap, the default one is awful. The maximum allowable crack width for this concrete slab is $w_{k.max} = 0.30$mm.\n" - ] } ], "metadata": { @@ -625,7 +646,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.1" + "version": "3.7.4" }, "latex_envs": { "LaTeX_envs_menu_present": true,