From 2b35aa6b7e780c1e6257a9ccd4c7e3a898004394 Mon Sep 17 00:00:00 2001 From: Mikhal Zelenyy Date: Mon, 4 Sep 2023 18:48:32 +0300 Subject: [PATCH] Add notebooks draft for laboratory python --- requirements.txt | 4 +- source/_static/style.css | 3 + source/_templates/layout.html | 4 + source/conf.py | 8 +- source/laboratory_python.md | 1 + source/pages/StudentEdition/01.ipynb | 1006 +++++++++++++++++ source/pages/StudentEdition/02.ipynb | 638 +++++++++++ source/pages/StudentEdition/03.ipynb | 590 ++++++++++ source/pages/StudentEdition/04.ipynb | 381 +++++++ source/pages/StudentEdition/05.ipynb | 279 +++++ source/pages/StudentEdition/06.ipynb | 236 ++++ source/pages/StudentEdition/07.ipynb | 198 ++++ source/pages/StudentEdition/08.ipynb | 475 ++++++++ source/pages/StudentEdition/README.md | 46 + source/pages/StudentEdition/data/data.txt | 10 + source/pages/StudentEdition/data/temp.txt | 1 + source/pages/StudentEdition/example.png | Bin 0 -> 33131 bytes source/pages/StudentEdition/example_fit.jpg | Bin 0 -> 44483 bytes source/pages/StudentEdition/example_fit.txt | 16 + source/pages/StudentEdition/filename.csv | 10 + .../pages/StudentEdition/filename_result.csv | 10 + source/pages/StudentEdition/jupyterlite.md | 8 + source/pages/StudentEdition/notebooks.md | 34 + 23 files changed, 3956 insertions(+), 2 deletions(-) create mode 100644 source/_static/style.css create mode 100644 source/_templates/layout.html create mode 100644 source/pages/StudentEdition/01.ipynb create mode 100644 source/pages/StudentEdition/02.ipynb create mode 100644 source/pages/StudentEdition/03.ipynb create mode 100644 source/pages/StudentEdition/04.ipynb create mode 100644 source/pages/StudentEdition/05.ipynb create mode 100644 source/pages/StudentEdition/06.ipynb create mode 100644 source/pages/StudentEdition/07.ipynb create mode 100644 source/pages/StudentEdition/08.ipynb create mode 100644 source/pages/StudentEdition/README.md create mode 100644 source/pages/StudentEdition/data/data.txt create mode 100644 source/pages/StudentEdition/data/temp.txt create mode 100644 source/pages/StudentEdition/example.png create mode 100644 source/pages/StudentEdition/example_fit.jpg create mode 100644 source/pages/StudentEdition/example_fit.txt create mode 100644 source/pages/StudentEdition/filename.csv create mode 100644 source/pages/StudentEdition/filename_result.csv create mode 100644 source/pages/StudentEdition/jupyterlite.md diff --git a/requirements.txt b/requirements.txt index 0d0e602..3299258 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,3 +1,5 @@ sphinx sphinx_rtd_theme -myst-parser \ No newline at end of file +myst-parser +jupyterlite-sphinx +jupyterlite-pyodide-kernel \ No newline at end of file diff --git a/source/_static/style.css b/source/_static/style.css new file mode 100644 index 0000000..579fe07 --- /dev/null +++ b/source/_static/style.css @@ -0,0 +1,3 @@ +.wy-nav-content { + max-width: none; +} \ No newline at end of file diff --git a/source/_templates/layout.html b/source/_templates/layout.html new file mode 100644 index 0000000..b0a4480 --- /dev/null +++ b/source/_templates/layout.html @@ -0,0 +1,4 @@ +{% extends "!layout.html" %} +{% block extrahead %} + +{% endblock %} \ No newline at end of file diff --git a/source/conf.py b/source/conf.py index b8f9472..34256dc 100644 --- a/source/conf.py +++ b/source/conf.py @@ -17,7 +17,8 @@ extensions = [ 'sphinx_rtd_theme', 'myst_parser', - 'sphinx.ext.todo' + 'sphinx.ext.todo', + 'jupyterlite_sphinx' ] templates_path = ['_templates'] @@ -33,6 +34,11 @@ todo_include_todos = True +myst_enable_extensions = [ + "amsmath", + "dollarmath" +] + # -- Options for HTML output ------------------------------------------------- # https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output diff --git a/source/laboratory_python.md b/source/laboratory_python.md index aeac535..d0ea5d0 100644 --- a/source/laboratory_python.md +++ b/source/laboratory_python.md @@ -10,5 +10,6 @@ cards/installation/installation.md cards/run/run.md pages/general_python/scikit_py.md + pages/StudentEdition/notebooks.md pages/TeacherEdition/introduction.md ``` \ No newline at end of file diff --git a/source/pages/StudentEdition/01.ipynb b/source/pages/StudentEdition/01.ipynb new file mode 100644 index 0000000..dc5e97f --- /dev/null +++ b/source/pages/StudentEdition/01.ipynb @@ -0,0 +1,1006 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "![](https://mipt.ru/upload/medialibrary/829/rus_text_prozrachnaya_podlozhka.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "# Введение в Python и работа с Jupyter Notebook\n", + "\n", + "\n", + "Рабочая тетрадь Jupyter Notebook состоит из последовательного набора ячеек, которые могут содержать код, текст, картинки (для того чтобы увидеть как вставить картинку, дважды щелкните по логотипу Физтеха выше), таблицы, формулы или даже интерактивные элементы. " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## Hello World!\n", + "Для того что бы выполнить код, написанный в ячейке, нужно выбрать ячейчу и нажать `Shift+Enter`, при этом после ячейки (эта зона называется `Out`) появится результат работы ячейки." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello World!\n" + ] + } + ], + "source": [ + "print(\"Hello World!\") # Функция print выводит текст в `Out` ячейки" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "# Эта строка -- комментарий. То, что здесь написано, не будет выполняться как код. \n", + "# print(\"Я не печатаюсь\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## Калькулятор\n", + "\n", + "Код на Python состоит из так называемых *выражений*, в `Out` ячейки будет показано значение последнего *выражения*." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "6" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2+2*2 # Шесть или восемь? Что надо сделать чтобы получить восемь?" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(1-2j)" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2+2*2 # Значение этого выражение не будет выведено в `Out`\n", + "(2+1j)*(-1j) # Встроена поддержка комплексных чисел" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "2.8284271247461903" + ] + }, + "execution_count": 61, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2**1.5 # Возведение в степень" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Деление нацело: 4\n", + "Остаток от деления: 3\n" + ] + } + ], + "source": [ + "print(\"Деление нацело: \", 23 // 5)\n", + "print(\"Остаток от деления: \", 23 % 5)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "180443894485522835714954192172999280028845717532682776236340940102536698145222569108484463188835141501257568786614496374890490631237110580592001682129147574651845715171456148359301092015447205623057495772659564027213301182232076238590331900681806078027178740976490955033321310868454820309128358774485790967770683032944024352558539124788679067434454263656340662912379366253271751953736731074819372491000795297394853010105837025484346139393089929535058486260828830048634323191537485125711757553017086494262086507174576160642886415424336562785001644174485982226421972489721110767356064962137106505728778418700556641023076586539800506459911177905554903899443902042199874341653922049139720885160820424705059531702449496414152206583904252440335125073512355264351679192059781951740756716496372272101373104569806788535169770019927578333904122000732663242308371786294445444694565563343590247938552086658203292972070407426713686306344322058332865613102498986620473134625473086906778038872631750464721441869000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Python поодерживает длинную арифметику для целых чисел\n", + "# Иначе говоря длина целых чисел ограничена только \n", + "# размером оперативной памяти вашего компьютера\n", + "1234567890**123" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(1, 5.0)" + ] + }, + "execution_count": 70, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "abs(-1), abs(3+4j) # Модуль числа\n" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'Двойный кавычки не отличаются от одинарных'" + ] + }, + "execution_count": 62, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"Двойный кавычки не отличаются от одинарных\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## Объявление переменных и функций" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "some_variable = 1 # Объявляем переменную, переменым лучше давать значащие имена" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n" + ] + } + ], + "source": [ + "print(some_variable) # Объявленная переменная доступна из любой ячейки" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "some_variable # Для втодополнения имени переменной можно использовать клавишу `Tab`" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "a = \"Строка\"" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Строка\n" + ] + } + ], + "source": [ + "print(a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Чтобы вывести данные в определенном формате, используется так называемое форматирование строк, есть несколько разных методво форматирования." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a = 3.14\n", + "b = 3.145\n", + "Привет! 5\n" + ] + } + ], + "source": [ + "a = 3.14\n", + "print(f\"a = {a}\") # `f`- форматирование\n", + "b = 3.14525436356546\n", + "print(f\"b = {b:.4}\") # `f`- форматирование, с ограничением числа значащих цифр\n", + "my_string = \"Привет\"\n", + "my_number = 5\n", + "print(\"%s! %d\" % (my_string, my_number)) # `%`-форматирование, счиатется устаревшим\n", + "# Далее будут даны ещё методы форматирования" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Для ввода данных в программу можно использовать функцию input(). Она считывает одну строку. Применение этой функции в интереснов основном при написании отдельных программ, а не работе в рабочих тетрадях." + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "1\n" + ] + } + ], + "source": [ + "a = input()\n", + "print(a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Функции — это такие участки кода, которые изолированы от остальный программы и выполняются только тогда, когда вызываются. Код с объявлением функции должен быть вызван раньше кода в котором вызвается функция, поэтому ячейку с функций крайне желательно располагать раньше ячейки с вызовом функции (иначе нельзя будет исполнять ячейки последовательно). В круглых скобках после названия функции пичется список параметров, `return` возвращает некоторое значение. " + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "def to_fahrenheit_degree(celsius_degree):\n", + " \"\"\"\n", + " Эта функцию принимает температуру в градусах Цельсия и переводит её в градусы Фаренгейта\n", + " Пригодится при работе с имперским оборудованием\n", + " \"\"\"\n", + " return (9/5)*celsius_degree + 32" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10 градусов Цельсия это 50.0 градусов Фаренгейта\n", + "20 градусов Цельсия это 68.0 градусов Фаренгейта\n", + "30 градусов Цельсия это 86.0 градусов Фаренгейта\n" + ] + } + ], + "source": [ + "data = [10,20,30] # Результаты измерений в градусах Цельсия сохранены в списке - одном из типов коллекций (наборов элементов) предоставляемых Python\n", + "for element in data: # Так называемы цикл for-each - в переменную element по очередно записываются элементы набора data\n", + " print(element, \"градусов Цельсия это\" , to_fahrenheit_degree(element), \"градусов Фаренгейта\")\n", + " \n", + "# Больше о циклах и коллекциях будет написано в следующих разделах пмс " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Обратите внимание что входным типом данных были целые числа, а выходным чилса с плавающей точкой.\n", + "\n", + "Также обращу ваше внимание на текст:\n", + "```\n", + " \"\"\"\n", + " Эта функцию принимает температуру в градусах Цельсия и переводит её в градусы Фаренгейта\n", + " Пригодится при работе с имперским оборудованием\n", + " \"\"\"\n", + "```\n", + "приведенный в начале функции `to_fahrenheit_degree` - это так называемый `docstring` - строка содержащая документацию по функции, для обращения в данной документации используется встроенная функция `help`." + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Help on function to_fahrenheit_degree in module __main__:\n", + "\n", + "to_fahrenheit_degree(celsius_degree)\n", + " Эта функцию принимает температуру в градусах Цельсия и переводит её в градусы Фаренгейта\n", + " Пригодится при работе с имперским оборудованием\n", + "\n" + ] + } + ], + "source": [ + "help(to_fahrenheit_degree)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "В хорошо оформленных библиотеках функция `help` позволяет получить исчерпывающую справку об работе функции (на английском языке конечно). " + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Help on built-in function print in module builtins:\n", + "\n", + "print(...)\n", + " print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)\n", + " \n", + " Prints the values to a stream, or to sys.stdout by default.\n", + " Optional keyword arguments:\n", + " file: a file-like object (stream); defaults to the current sys.stdout.\n", + " sep: string inserted between values, default a space.\n", + " end: string appended after the last value, default a newline.\n", + " flush: whether to forcibly flush the stream.\n", + "\n" + ] + } + ], + "source": [ + "help(print)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Функция может и не заканчиваться инструкцией `return`, при этом функция вернет значение `None`" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "qwe!\n", + "None\n" + ] + } + ], + "source": [ + "def my_print(x):\n", + " print(x + '!')\n", + " \n", + "print(my_print('qwe'))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Функция может содержать необязательные аргументы, которые будут принимать значение по умолчанию, если пользователь не передал их значение." + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n", + "6\n" + ] + } + ], + "source": [ + "def add(a, b, c=2): # c - необязательный аргумент\n", + " return a + b + c\n", + "print(add(1, 2))\n", + "print(add(1, 2, 3))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## Подключение дополнительных библиотек\n", + "\n", + "При написаннии программ не обойти без использования сторонних или даже ваших собсвенных библиотек с кодом. Python ищет библиотеки по определенным путям, включая директорию в которой мы сейчас расположены. Стандратная билиотека Python содрежит много полезных при написании программ функций и классов, а дистрибутив Anaconda предоставлет большое множество библиотке для научного программирования.\n", + "\n", + "В качесве примера рассмотрим использование стандартной математической билиотеки." + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "import math # Подключение билотеки по её полному имени" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "1.0" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "math.log(math.e) # Обращение к элементам библиотеки" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "2.9999999999999996" + ] + }, + "execution_count": 51, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "math.log(1000, 10) # Кто не прогуливал лекции по информатике, тот сможет объяснить почему результат оказался не равным 3.0" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['__doc__',\n", + " '__file__',\n", + " '__loader__',\n", + " '__name__',\n", + " '__package__',\n", + " '__spec__',\n", + " 'acos',\n", + " 'acosh',\n", + " 'asin',\n", + " 'asinh',\n", + " 'atan',\n", + " 'atan2',\n", + " 'atanh',\n", + " 'ceil',\n", + " 'copysign',\n", + " 'cos',\n", + " 'cosh',\n", + " 'degrees',\n", + " 'e',\n", + " 'erf',\n", + " 'erfc',\n", + " 'exp',\n", + " 'expm1',\n", + " 'fabs',\n", + " 'factorial',\n", + " 'floor',\n", + " 'fmod',\n", + " 'frexp',\n", + " 'fsum',\n", + " 'gamma',\n", + " 'gcd',\n", + " 'hypot',\n", + " 'inf',\n", + " 'isclose',\n", + " 'isfinite',\n", + " 'isinf',\n", + " 'isnan',\n", + " 'ldexp',\n", + " 'lgamma',\n", + " 'log',\n", + " 'log10',\n", + " 'log1p',\n", + " 'log2',\n", + " 'modf',\n", + " 'nan',\n", + " 'pi',\n", + " 'pow',\n", + " 'radians',\n", + " 'sin',\n", + " 'sinh',\n", + " 'sqrt',\n", + " 'tan',\n", + " 'tanh',\n", + " 'tau',\n", + " 'trunc']" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dir(math) # Функция dir позволяет узнать какие имена используются в библиотеке" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "import math as m # Можно вместо полного имени использовать псевдоним,\n", + " # наиболее популярные билиотеки имеют общепринятые псевдонимы" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "1.2246467991473532e-16" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "m.sin(m.pi) # Очень близко, но из=за конечной точности все же не ноль\n" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "from math import cos, tan # Можно импортировать одно или несколько имен" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "-0.9999987317275395" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cos(3.14)" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "# Самый плохой вариант - импортирует все имена из билиотеки, \n", + "# при этом возмозможно перекрытие имен (смотри код далее)\n", + "from math import *" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "-1.0" + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cos(pi)" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "pi = 4 # Согласно приказу Минобрнауки значение числа пи принять равным 4" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "-0.6536436208636119" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cos(pi)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Поскольку поиск подобных ошибок затруднен использование синтаксиса `from module import *` крайне не желательно." + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": false, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": false, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} \ No newline at end of file diff --git a/source/pages/StudentEdition/02.ipynb b/source/pages/StudentEdition/02.ipynb new file mode 100644 index 0000000..bc5971b --- /dev/null +++ b/source/pages/StudentEdition/02.ipynb @@ -0,0 +1,638 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "# Управляющие выражения\n", + "\n", + "\n", + "## Cтруктуры данных: списки" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Любые данные в компьютере хранятся ввиде набора байт, однако человеку гораздо проще рабоать с какой-либо абстрактной моделью представляющей данные. Такие модели называются *структурами данных*, это могут быть *примитивы*, такие как число или символ, или более сложные структуры данных, состоящие из отдельных примитивов. Структуры данных очень полезны, поскольку позволяют организивать удобную и эффективную работу с данными в зависимости от их вида. Как пример сложно структуры мы уже встречали *строки* и *списки*. О последних мы поговорим в этом разделе.\n", + "\n", + "Списки (list) - упорядоченные изменяемые коллекции объектов произвольных типов. К элементу или диапазону элементов списка можно обращаться по номеру (нумерация с нуля). Отрицательный индекс означает, что отсчет ведется с конца списка к началу." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['a', 4, 2.5, 1, 2, 3]\n", + "4\n", + "[4, 2.5, 1, 2, 3]\n", + "[4, 2.5]\n", + "[4, 1]\n", + "['a', 2.5, 2]\n", + "6\n" + ] + } + ], + "source": [ + "my_list = [] # создание пустого списка\n", + "my_list.append('a') # добавление элемента\n", + "my_list.append(4)\n", + "my_list.append(2.5)\n", + "my_list.extend([1, 2, 3]) # добавление списка в конец списка my_list\n", + "print(my_list) \n", + "print(my_list[1]) # Выбор элемента с индексом 1, ВНИМАНИЕ нумерация идет с нуля!\n", + "print(my_list[1:]) # Срез списка: все элементы от номер 1 включительно до конца\n", + "print(my_list[1:3]) # Срез списка\n", + "print(my_list[1:5:2]) # Срез списка c шагом 2\n", + "print(my_list[::2]) # Элементы списка с четных позиций\n", + "print(len(my_list)) # длина списка" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Если список состоит из сравнимых элементов, то его можно отсортировать." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-9, -3, 1, 2, 5, 8]\n" + ] + } + ], + "source": [ + "my_new_list = [-9, 5, 1, 8, -3, 2]\n", + "my_new_list.sort()\n", + "print(my_new_list)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "hideCode": true, + "hideOutput": true, + "hidePrompt": true, + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## Условия и циклы" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "### Условие if" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Для проверки условий используется логический тип (bool), который представлен двумя постоянными значениями `False` и `True`. Возможно приведение других типов в логическому с помощью операции `bool(x)`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "c = True\n", + "d = False\n", + "print(c, d)\n", + "print(type(c), type(d))\n", + "print(bool(123))\n", + "print(bool('hello'))\n", + "print(bool(0))\n", + "print(bool(''))\n", + "print(bool())" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Условный оператор в Pytnon провяряет значение выражения (или переменной), которой является или приводиться к логическому типу. Если выражение после `if` верно, то блок команд с отступом выполняется, если нет - пропускается." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "y is positive\n" + ] + } + ], + "source": [ + "x = -4\n", + "if x > 0:\n", + " print('x is positive')\n", + " \n", + "y = 5\n", + "if y > 0:\n", + " print('y is positive')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Значение переменной a автоматически сконвертировалось к логическом типу\n" + ] + } + ], + "source": [ + "a = 5\n", + "if a:\n", + " print(\"Значение переменной a автоматически сконвертировалось к логическом типу\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Если выражение после `if` верно, то выполняется первый блок команд, если нет - второй блок." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "negative\n" + ] + } + ], + "source": [ + "x = -4\n", + "if x > 0:\n", + " print('positive')\n", + "else:\n", + " print('negative')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Внутри условных инструкций можно использовать любые инструкции языка Питон, в том числе и условную инструкцию. Получаем вложенное ветвление – после одной развилки в ходе исполнения программы появляется другая развилка. При этом вложенные блоки имеют больший размер отступа (например, 8 пробелов). Писать много вложенных проверок условий является плохой практикой и Python препятсвует ей. " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Четвертая четверть\n" + ] + } + ], + "source": [ + "x = 5\n", + "y = -2\n", + "if x > 0:\n", + " if y > 0: # x > 0, y > 0\n", + " print(\"Первая четверть\")\n", + " else: # x > 0, y < 0\n", + " print(\"Четвертая четверть\")\n", + "else:\n", + " if y > 0: # x < 0, y > 0\n", + " print(\"Вторая четверть\")\n", + " else: # x < 0, y < 0\n", + " print(\"Третья четверть\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Пример программы, определяющий четверть координатной плоскости, можно переписать используя “каскадную“ последовательность операцией `if...` `elif...` `else`. `elif` - сокращение для `else if`" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Вторая четверть\n" + ] + } + ], + "source": [ + "x = -3\n", + "y = 3\n", + "if x > 0 and y > 0:\n", + " print(\"Первая четверть\")\n", + "elif x > 0 and y < 0:\n", + " print(\"Четвертая четверть\")\n", + "elif y > 0:\n", + " print(\"Вторая четверть\")\n", + "else:\n", + " print(\"Третья четверть\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "### Цикл for" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "В цикле `for` указывается переменная и множество значений, по которому будет пробегать переменная. Множество значений может быть задано списком, кортежем, строкой или диапазоном." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "2\n", + "3\n", + "one\n", + "two\n", + "three\n" + ] + } + ], + "source": [ + "for i in 1, 2, 3, 'one', 'two', 'three':\n", + " print(i)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Функция `range()` позволяет вам генерировать ряд чисел в рамках заданного диапазона. Различные способы вызова функции:\n", + "* range(stop)\n", + "* range(start, stop)\n", + "* range(start, stop, step)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "2\n", + "3\n", + "4\n", + "\n", + "\n", + "2\n", + "3\n", + "4\n", + "\n", + "\n", + "1\n", + "3\n" + ] + } + ], + "source": [ + "for number in range(5):\n", + " print(number)\n", + "print('\\n')\n", + "for number in range(2, 5):\n", + " print(number)\n", + "print('\\n') \n", + "for number in range(1, 5, 2):\n", + " print(number)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "### Цикл while" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Цикл `while` (“пока”) позволяет выполнить одну и ту же последовательность действий, пока проверяемое условие истинно. Условие записывается до тела цикла и проверяется до выполнения тела цикла. Как правило, цикл `while` используется, когда невозможно определить точное значение количества проходов исполнения цикла." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "4\n", + "9\n", + "16\n", + "25\n" + ] + } + ], + "source": [ + "i = 1\n", + "while i <= 5:\n", + " print(i ** 2)\n", + " i += 1" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Если во время выполнения Питон встречает инструкцию `break` внутри цикла, то он сразу же прекращает выполнение этого цикла и выходит из него. Другая инструкция управления циклом — `continue` (продолжение цикла). Если эта инструкция встречается где-то посередине цикла, то пропускаются все оставшиеся инструкции до конца цикла, и исполнение цикла продолжается со следующей итерации." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "Цикл окончен, i = 6\n" + ] + } + ], + "source": [ + "i = 1\n", + "while i <= 5:\n", + " print(i)\n", + " i += 1\n", + "else:\n", + " print('Цикл окончен, i =', i)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "2\n" + ] + } + ], + "source": [ + "i = 1\n", + "while i <= 5:\n", + " print(i)\n", + " i += 1\n", + " if i == 3:\n", + " break\n", + "else:\n", + " print('Цикл окончен, i =', i)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "2\n", + "4\n", + "5\n", + "6\n", + "Цикл окончен, i = 6\n" + ] + } + ], + "source": [ + "i = 0\n", + "while i <= 5:\n", + " i += 1\n", + " if i == 3:\n", + " continue\n", + " print(i)\n", + "else:\n", + " print('Цикл окончен, i =', i)" + ] + } + ], + "metadata": { + "@webio": { + "lastCommId": null, + "lastKernelId": null + }, + "hide_input": false, + "kernelspec": { + "display_name": "Python [default]", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.7" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": false, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": false, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} \ No newline at end of file diff --git a/source/pages/StudentEdition/03.ipynb b/source/pages/StudentEdition/03.ipynb new file mode 100644 index 0000000..a20385e --- /dev/null +++ b/source/pages/StudentEdition/03.ipynb @@ -0,0 +1,590 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Парадигмы программирования\n", + "\n", + "В отличии от Fortran или С которые поддерживают только парадигму процедурного программирования Python позволяет писать код также в объектно-ориентированном и функциональном стилях.\n", + "\n", + "## Объектно-ориентированное программировние (ООП)\n", + "ООП основанное на использовании специальных типов - классов, которые объеденяют данные и способы работы с ними. \n", + "\n", + "В языке Pascal вы можете создать переменную типа string и например передать её в функцию ToUpperCase:\n", + " ```pascal\n", + " variable := 'AaBb'\n", + " toUpperCase(variable)\n", + " // Теперь variable содержит строку 'AABB'\n", + " ```\n", + " Но приведение к верхнему регистру это операция характерная для строк, бессмысленно пытаться приводить целое число к нему. Поэтому ООП предлагает превратить функцию ToUpperCase в _метод_ класса, иначе говоря в функцию-член класса.\n", + "Рассмотрим пример:" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a = \"AaBb\"\n", + "type(a)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "В переменную `a` мы сохранили строку \"AaBb\", которая явлется экземпляром (объектом) класса `str`. Теперь мы можем вызвать у переменной `a` один из методов класса `str`." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'AABB'" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a.upper()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Метод может принимать аргументы (на самом деле любой метод принимает как минимум один аргумент подробнее [здесь]())\n", + "# Например посчитаем сколько раз буква A входит в строку\n", + "a.count('A')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'My name is Mikahil, my age is 24 and my temperature is 36.6 degree.'" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Возвращаясь к форматированию строк, \n", + "# то наилучшим способом будет использования метода format\n", + "\"My name is {}, my age is {:d} and my temperature is {:.1f} degree.\".format(\"Mikahil\", 24, 36.6)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1, 2)" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a = 0.5 # Числа тоже имеют методы\n", + "a.as_integer_ratio() # Представляет вещественное число как отношение целых" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['__abs__',\n", + " '__add__',\n", + " '__bool__',\n", + " '__class__',\n", + " '__delattr__',\n", + " '__dir__',\n", + " '__divmod__',\n", + " '__doc__',\n", + " '__eq__',\n", + " '__float__',\n", + " '__floordiv__',\n", + " '__format__',\n", + " '__ge__',\n", + " '__getattribute__',\n", + " '__getformat__',\n", + " '__getnewargs__',\n", + " '__gt__',\n", + " '__hash__',\n", + " '__init__',\n", + " '__init_subclass__',\n", + " '__int__',\n", + " '__le__',\n", + " '__lt__',\n", + " '__mod__',\n", + " '__mul__',\n", + " '__ne__',\n", + " '__neg__',\n", + " '__new__',\n", + " '__pos__',\n", + " '__pow__',\n", + " '__radd__',\n", + " '__rdivmod__',\n", + " '__reduce__',\n", + " '__reduce_ex__',\n", + " '__repr__',\n", + " '__rfloordiv__',\n", + " '__rmod__',\n", + " '__rmul__',\n", + " '__round__',\n", + " '__rpow__',\n", + " '__rsub__',\n", + " '__rtruediv__',\n", + " '__setattr__',\n", + " '__setformat__',\n", + " '__sizeof__',\n", + " '__str__',\n", + " '__sub__',\n", + " '__subclasshook__',\n", + " '__truediv__',\n", + " '__trunc__',\n", + " 'as_integer_ratio',\n", + " 'conjugate',\n", + " 'fromhex',\n", + " 'hex',\n", + " 'imag',\n", + " 'is_integer',\n", + " 'real']" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dir(a) # Позволяет узнать методы, определенные у объекта,\n", + " # методы начинающиеся с двойного подчеркивая --- служебные и обычно явно не вызываются" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### In-place и Out-of-place операции\n", + "Операции проводимые _in place_ производятся непосредвенно с объектом вызвашим эту операцию, а _out of place_ создают новый объект. Сравним два примера." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Список data изменился: [1, 2, 3]\n" + ] + } + ], + "source": [ + "data = [1, 3, 2]\n", + "data.sort()\n", + "print(\"Список data изменился: {}\".format(data))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Список data не изменился: [1, 3, 2]\n", + "Список res содержит результат сортировки: [1, 2, 3]\n" + ] + } + ], + "source": [ + "data = [ 1,3,2]\n", + "res = sorted(data)\n", + "print(\"Список data не изменился: {}\".format(data))\n", + "print(\"Список res содержит результат сортировки: {}\".format(res))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "В первом примере вызов метода sort отсортировал список data, во втором примере функция sorted создала новый отсртированный список оставив порядок элементов в data неизменным " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Пользовательские типы (Дополнительный материал)\n", + "Однако мы можем использовать не только классы изначально сушествующие в языке, но и создавать свои!" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [], + "source": [ + "class VelocityVector2D:\n", + " \"\"\"\n", + " Класс описывающий двумерный вектор скорости\n", + " \"\"\"\n", + " units = \"м/c\"\n", + " \n", + " def __init__(self, x, y):\n", + " \"\"\"\n", + " Значение переменных x,y считается данным в м\\с\n", + " \"\"\"\n", + " self.x = x\n", + " self.y = y\n", + " \n", + " def module(self, system_of_units = \"SI\"):\n", + " \"\"\"\n", + " Модуль вектора скорости\n", + " Аргумент system_of_units может принимать значения \"SI\" и \"SGS\"\n", + " \"\"\"\n", + " module = (self.x**2 + self.y**2)**0.5\n", + " if system_of_units==\"SI\":\n", + " return module\n", + " elif system_of_units==\"SGS\":\n", + " return module*10 # Перевели из СИ в СГС\n", + " else:\n", + " raise Exception('Незнакомая система единиц')\n", + " \n", + " def __add__(self, another_vector):\n", + " \"\"\"\n", + " Позволяет складывать два вектора с помощью оператора +\n", + " \"\"\"\n", + " return VelocityVector2D(self.x + another_vector.x, self.y + another_vector.y)\n", + " \n", + " def __repr__(self):\n", + " \"\"\"\n", + " Генериует строковой представление для нашего класса\n", + " Например, мы теперь можем сделать:\n", + " print(VelocityVector2D(3,4))\n", + " \"\"\"\n", + " return \"Vx = {0} {2}, Vy = {1} {2}\".format(self.x, self.y , self.units)\n", + " \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [], + "source": [ + "v1 = VelocityVector2D(3,4)" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3" + ] + }, + "execution_count": 51, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "v1.x" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "5.0" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "v1.module()" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Модуль скорости равен 5.0\n" + ] + } + ], + "source": [ + "print(\"Модуль скорости равен {}\".format(v1.module()))" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Vx = 0 м/c, Vy = 0 м/c" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "v_rel = v1 + VelocityVector2D(-3,-4)\n", + "print(v_rel)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Функциональное программирование (ФП)\n", + "Одной из основ ФП является передача функции _в качестве аргумента для другой функции_. Для пример реализуем функцию которая будет вычислять интеграл от произвольной функции." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "def riman_integral(function, left_boundary = 0, rigth_boundary = 1, number_points = 200):\n", + " \"\"\"\n", + " Вычисляем интеграл методом прямоугольников.\n", + " Это определенно не самый лучший способ численного интегрирования,\n", + " но самый простой и для функций без особенностей дает приемлимую точность.\n", + " Отметим что реализация данной функции основанно на чистом Python\n", + " и поэтому не является оптимальной по производительности.\n", + " О высокопроизводительных вычислениях смотри раздел Numpy и Scipy\n", + " \"\"\"\n", + " a, b = left_boundary, rigth_boundary \n", + " dx = (b - a) / (number_points - 1) # Интервалов на один меньше чем точек\n", + " res = function(a)\n", + " for i in range(1, number_points - 1):\n", + " res += function(a + i*dx)\n", + " res += function(b)\n", + " return res*dx\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "from math import cos, pi" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1.003941532222525" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# В качестве аргумента мы передаем функцию cos от которой вычисляем интеграл\n", + "riman_integral(cos, 0, pi/2) # Вопрос на засыпку, верен ли результат?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Анонимные функции (дополнительный материал)\n", + "\n", + "Другим пример функционального стиля, является использование _аномнимных функций_. _Анонимные функции_ могут содержать лишь одно выражение. Создаются с помощью инструкции `lambda`. Рассмотрим на примере такой задачи: дан набор скоростей, нужно получить набор отсортированный по модулю скорости." + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Текущий порядок\n", + "Vx = 0 м/c, Vy = 0 м/c\n", + "Vx = 1 м/c, Vy = 1 м/c\n", + "Vx = 0.1 м/c, Vy = 0.5 м/c\n" + ] + } + ], + "source": [ + "data = [VelocityVector2D(0,0),\n", + " VelocityVector2D(1,1),\n", + " VelocityVector2D(0.1,0.5)]\n", + "print(\"Текущий порядок\")\n", + "for element in data:\n", + " print(element)" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Порядок после сортировки\n", + "Vx = 0 м/c, Vy = 0 м/c\n", + "Vx = 0.1 м/c, Vy = 0.5 м/c\n", + "Vx = 1 м/c, Vy = 1 м/c\n" + ] + } + ], + "source": [ + "result = sorted(data, # Входные данные\n", + " key = lambda velocity : velocity.module() # Функция принимающая в качестве аргумента элемент из data\n", + " # и определяющая порядок сортировки\n", + " )\n", + "print(\"Порядок после сортировки\")\n", + "for element in result:\n", + " print(element)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n" + ] + } + ], + "source": [ + "# Анонимная функция так же может иметь несколько аргументов\n", + "print((lambda x, y: x * y)(1, 2))" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python [default]", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.7" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": false, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": false, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/source/pages/StudentEdition/04.ipynb b/source/pages/StudentEdition/04.ipynb new file mode 100644 index 0000000..7a668e8 --- /dev/null +++ b/source/pages/StudentEdition/04.ipynb @@ -0,0 +1,381 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Двигаемся дальше\n", + "\n", + "## Работа с произвольными файлами\n", + "\n", + "Для того что бы обрабатывать данные с лабораторных работ, нужно что бы они как-то попали к вам в программу. Конечно можно просто ввести их непосредтсвенно в код программы (например так, `data = [1,2,3,4,5,6,7]`), но по многим практическим соброжениям это не удобно и неправильно. Корректным будет хранить данные в отдельных файлах и уметь считывать информацию из них. Способов считывать данные много, о более удобных для использования (но работающих только с определенными форматами файлов) мы поговорим в следующих разделах, а сейчас разберем универсальный способ работы с произвольным файлом. \n", + "Файлы можно окрывать в двух режимах: \n", + "\n", + "* Текстовом: информация в файле интерпретируется как текст, и в данном мы оперируем данными как набором символов, например если в файл написано `123`, это не значит что там записанно число 123, а значит что там записаны символы `1`, `2`, `3`.\n", + "* Бинарном: информация в файле интерпретируется как набор байтов и в данном случае мы оперируем отдельными байтами, которые мы потом можем интерперитовать как числа, символы или ещё что-то.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "' x y y_error\\n0 1.05923 0.0861431\\n0.0714286 0.913173 0.0859666\\n0.142857 0.954408 0.06095\\n0.214286 0.819393 0.0378351\\n0.285714 0.91041 0.07267\\n0.357143 0.73905 0.0580905\\n0.428571 0.80262 0.0656587\\n0.5 0.764531 0.0278336\\n0.571429 0.782643 0.0450629\\n0.642857 0.790794 0.0482949\\n0.714286 0.762573 0.0409075\\n0.785714 0.8131 0.0640749\\n0.857143 0.779934 0.0820886\\n0.928571 0.915171 0.082733\\n1 1.00332 0.0567224'" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fin = open(\"example_fit.txt\") # Окрываем файл\n", + "text = fin.read() # Считываем его целиком\n", + "fin.close() # Закрываем файл\n", + "text " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Как мы видим считанная из файла информация представлена как строка и для того чтобы получить из неё цифоры её надо будет обработать. Нам необязательно считывать файл целиком, мы можем делать это построчно или посимвольно, считывать данные можно не только с начала файла но и с произвольного места. Обращаю ваше внимание на операцию `fin.close()`, закрытие файла очень важно, не смотря на то что Python часто относиться к этому либерально, если вы не закроете файл то вы можете потерять данные при записи в файл или может возникнуть проблема с записью в этот файл. Для того что бы не иметь проблем с закрытием файлов нужно использовать *контекстный менеджер*." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "with open(\"temp.txt\", \"w\") as fout: # Переменная fout действует внутри контекста open\n", + " fout.write(\"Текст\") # Пишим данные\n", + " # Обрабите внимание что в текстовые файлы мы пишем текст, \n", + " # поэтому нужно привести числовые данные к строкам" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Как видно в этом примере для того что бы открыть файл на запись мы передали второй аргумент в функцию `open`. `\"w\"` означает что файл открыт на запись, **при этом сущетсвующующий файл перезаписывается**. Сущетсвуют различные режимы записи/чтения файла, если нужно совместить несколько режимов, они указываются вместе, например `\"rb\"` - октрывает файл на чтение в *бинарном* режиме. По умолчанию файл открывается на чтение в текстовом режиме." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Еще не много важных вещей о переменных и об объектах (дополнительный материал)\n", + "\n", + "В этом разделе мы поговорим о том что такое переменная. Все наши данные в программе представлены как некоторые *объекты*, которые находятся где-то в памяти компьютера. Так вот переменная ссылается на некий объект в памяти, на один и тот же объект могут ссылаться не сколько переменных. Расмотрим пример. " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a : [1, 2, 3]\n", + "b : [1, 2, 3]\n", + "a : [1, 10, 3]\n" + ] + } + ], + "source": [ + "a = [1,2,3]\n", + "b = a\n", + "print(\"a : {}\".format(a))\n", + "print(\"b : {}\".format(b))\n", + "b[1] = 10\n", + "print(\"a : {}\".format(a))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Мы поменяли что-то в перменной `b`, а изменилась переменная `a`? Нет это не правильная точка зрения, и `a`, и `b` ссылаются на один и тот же список лежащий в памяти и поэтому неважно через какую переменную мы к нему обращащемся. Если же мы хотит записать в gпеременную `b` новый объект являющийся *копией* сущетсвующего объекта, то мы должны использовать методы `copy` (создает поверхностную копию) и `deepcopy` (создает полную копию) (о разнице в этих методах можно прочесть [здесь](https://docs.python.org/3.7/library/copy.html)).\n", + "\n", + "Так же следует знать что объекты в Python бывают изменяемые и не изменяемые.\n", + "Они отличаются тем, что содержимое изменяемых объектов может быть изменено (перезаписанно в памяти), а неизменяемых нет. Расмотрим пример:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "String\n", + "STRING\n" + ] + } + ], + "source": [ + "a = \"String\" # строка не изменяемый объект\n", + "b = a.upper() # Метод upper нужен для перевода данных в верхний регистр\n", + "print(a) # Строка a не изменилась\n", + "print(b) # Строка b это новый объект строки, никак не связанный с предыдущим" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1, 2, 3, 4, 5]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a = [5,4,3,2,1] # список изменемый объект\n", + "a.sort() # При сортировке не создался новый список, с отсортированными значениями,\n", + " # а изменился сущетсвующий объект\n", + "a" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Другим существенным отличием в неизменяемых от изменяемых объектов, является их поведение при передачи в функцию. " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2, 3]\n", + "[1, 2, 3, 0]\n" + ] + } + ], + "source": [ + "a = [1,2,3]\n", + "\n", + "print(a)\n", + "\n", + "def change_list(a):\n", + " a.append(0) # Добавляем новый элементв в a\n", + " \n", + "change_list(a)\n", + "print(a)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "В нашу функцию передался иммено наш объект, а не его копия и функция может изменить содержимое объекта. Все пользовательские типы являются изменяемыми объектами. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Структуры данных: словари и кортежи\n", + "\n", + "Пришло время познакомится с ещё двумя структурами данных.\n", + "\n", + "### Кортежи\n", + "\n", + "Кортежи (tuple) - неизменяемые списки. Для них доступны все операции над списками, не изменяющие список (сложение, умножение на число, методы `index()` и `count()` и некоторые другие операции). Можно также по-разному менять элементы местами и так далее." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1, 2, 3, 4, 5)\n", + "(1, 2, 3, 4, 5, 1, 2, 3)\n", + "(1, 2, 3, 4, 5, 1, 2, 3, 1, 2, 3, 4, 5, 1, 2, 3)\n", + "16\n" + ] + } + ], + "source": [ + "a = tuple() # создание пустого кортежа\n", + "a = () # создание пустого кортежа\n", + "c = tuple([1, 2, 3, 4, 5])\n", + "с = 1, 2, 3, 4, 5 # Это тоже кортеж\n", + "print(c)\n", + "c += (1, 2, 3)\n", + "print(c)\n", + "c = c * 2\n", + "print(c)\n", + "print(len(c)) # длина кортежа" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Другим важным свойсвтом кортежа, явлется возможность использовать его для упаковки/распаковки данных." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "a, b = 1, 2 # 1,2 это на самом деле кортеж, который можно распаковать по отдельным переменным\n", + "a, b = b, a # меняем значения переменных местами" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def fun(a,b):\n", + " \"\"\"\n", + " Так же кортеж можно использовать\n", + " что бы вернуть из функции несколько аргументов\n", + " \"\"\"\n", + " a = 1\n", + " b = 2\n", + " return a, b\n", + "\n", + "c = (1,2)\n", + "a, b = fun(*c) # `*c` позволяет распаковать значения из кортежа `с` как аргументы функции" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Словари\n", + "\n", + "Словари (они же карты (map), ассоциативные массивы и хэш-таблицы) --- структра, позволяющая организовтаь доступ к данным по ключу. Данные в словаре хранятся в формате ключ – значение. " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'a': 1, 'b': 2}\n", + "{'a': 3, 'b': 2}\n", + "dict_keys(['a', 'b'])\n" + ] + } + ], + "source": [ + "d = {'a': 1, 'b': 2}\n", + "print(d)\n", + "d['a'] = 3\n", + "print(d)\n", + "print(d.keys())" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(3, 2)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def fun(a=1,b=2):\n", + " \"\"\"\n", + " Так же кортеж можно использовать\n", + " что бы вернуть из функции несколько аргументов\n", + " \"\"\"\n", + " return a, b\n", + "\n", + "fun(**d) # `**d` позволяет распаковать значения из словаря `d` как именнованые аргументы функции" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "** Больше полезных модулей, типов, структур данных, методов, свойств можно найти в интернете. Гуглите!**\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [default]", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.7" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": false, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": false, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/source/pages/StudentEdition/05.ipynb b/source/pages/StudentEdition/05.ipynb new file mode 100644 index 0000000..f317dc5 --- /dev/null +++ b/source/pages/StudentEdition/05.ipynb @@ -0,0 +1,279 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# NumPy\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Создание Numpy массивов" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 1. 2. 3.]\n", + "\n", + "[-1. -1. -1. -1. -1. -1. -1. -1. -1. -1.]\n", + "\n", + "[[ 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0.]]\n", + "\n", + "[[[ 1. 1.]\n", + " [ 1. 1.]]\n", + "\n", + " [[ 1. 1.]\n", + " [ 1. 1.]]]\n", + "\n", + "[[ 1. 0. 0. 0. 0.]\n", + " [ 0. 1. 0. 0. 0.]\n", + " [ 0. 0. 1. 0. 0.]\n", + " [ 0. 0. 0. 1. 0.]\n", + " [ 0. 0. 0. 0. 1.]]\n", + "(3, 5)\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "a = np.array([1,2,3], float) # Однмемерный массив из списка \n", + "b = np.repeat(-1. ,10) # Массив полученные повоторением исходного объекта\n", + "c = np.zeros((3, 5)) # Матрица из нулей размера 3х5\n", + "d = np.ones((2, 2, 2)) # Трехмерный массив из единиц\n", + "e = np.eye(5) # Единичная матрица\n", + "print(a, b, c, d, e, sep='\\n\\n')\n", + "print(c.shape) # Возвращает размерность массива, для двумерного это количество строк и столбцов" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Арифметические операции с массивами и векторизация\n", + "\n", + "Полезной особенностью numpy-массивов является так называемая _векторизация_ --- возможность делать быстрые поэлементные операции с массивами без использования цикла `for`." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 6. 4. 9.]\n", + "[-4. 0. -3.]\n", + "[ 5. 4. 18.]\n", + "[ 5. 1. 2.]\n", + "[ 1. 0. 3.]\n", + "[ 5. 4. 216.]\n", + "[ 1. 1.41421356 1.73205081]\n", + "6.0\n", + "60.0\n", + "27.0\n", + "[False False False]\n", + "[ 1. 2. 0.33333333]\n" + ] + } + ], + "source": [ + "a = np.array([1,2,3], float)\n", + "b = np.array([5,2,6], float)\n", + "print(a + b)\n", + "print(a - b)\n", + "print(a * b)\n", + "print(b / a)\n", + "print(a % b)\n", + "print(b ** a)\n", + "print(np.sqrt(a))\n", + "print(np.sum(a))\n", + "print(np.prod(b))\n", + "print(a.dot(b)) # Скалярное произведение\n", + "print(a > b)\n", + "print(np.where(a != 2, 1 / a, a))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Линейная алгебра\n", + "\n", + "NumPy также предоставляет набор встроенных функций и методов для работы с линейной алгеброй. Это всё можно найти в под-модуле `linalg`." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-48.0\n", + "[ 8.85591316 1.9391628 -2.79507597]\n", + "[[-0.3663565 -0.54736745 0.25928158]\n", + " [-0.88949768 0.5640176 -0.88091903]\n", + " [-0.27308752 0.61828231 0.39592263]]\n" + ] + } + ], + "source": [ + "a = np.array([[4, 2, 0], [9, 3, 7], [1, 2, 1]], float)\n", + "b = a.T # Транспонированый массив\n", + "print(np.linalg.det(a)) # Ищем детерминант \n", + "vals, vecs = np.linalg.eig(a)\n", + "print(vals)\n", + "print(vecs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Операции с индексами \n", + "Оперативная память компьютера линейна, и поэтому даже многомерные массивы, на самом деле являются некоторыми линейными структурами, над которыми существуют система индексов, говорящих как именно читать этот линейный блок. Проведение операций над индексами в большистве случаев эффективно и поэтому операции смены размерности массива или транспонирования выполняются быстро" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1 3]\n", + " [2 4]]\n" + ] + } + ], + "source": [ + "a = np.asarray([[1,2], [3,4]])\n", + "b = a.T # Транспонированый массив\n", + "print(b)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[10 3]\n", + " [ 2 4]]\n" + ] + } + ], + "source": [ + "b[0,0] = 10\n", + "print(b)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[10 2]\n", + " [ 3 4]]\n" + ] + } + ], + "source": [ + "print(a)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Как мы видим при изменени переменной `b` изменилась переменная `a`. Это произошло потому, что обе эти переменные использубют один и тот же кусок памяти, но по разному " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Чтение даных\n", + "\n", + "Numpy также предоставляет функционал для чтения данных, который бывает весьма полезен" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0., 0.],\n", + " [ 1., 1.],\n", + " [ 2., 4.],\n", + " [ 3., 9.],\n", + " [ 4., 16.],\n", + " [ 5., 25.],\n", + " [ 6., 36.],\n", + " [ 7., 49.],\n", + " [ 8., 64.],\n", + " [ 9., 81.]])" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data = np.loadtxt('./data/data.txt')\n", + "data" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [default]", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/source/pages/StudentEdition/06.ipynb b/source/pages/StudentEdition/06.ipynb new file mode 100644 index 0000000..8393ae6 --- /dev/null +++ b/source/pages/StudentEdition/06.ipynb @@ -0,0 +1,236 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Работа с файлами, Pandas\n", + "\n", + "Часто бывает необходимо прочитать данные их файла, для этого удобно использовать модуль [pandas](https://pandas.pydata.org). Про параметры функции `read_csv` можно почитать [здесь](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.read_csv.html)." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "87c65c20275c471dad602afc2bd29fb6", + "version_major": 2, + "version_minor": 0 + } + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import pandas as pd\n", + "data_frame = pd.read_csv('filename.csv', sep=';')\n", + "data_frame" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "Когда вы обрабатываете CSV с помощью pandas, вы получаете объект под названием `DataFrame`, который состоит из строк и столбцов. Обратиет внимание, что в `out` выводится интерактивная таблица, в которой можно например сортировать данные и при этом исходный `DataFrame` не измениться. Вы можете получать столбцы таким же образом, каким получаете элементы словаря." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index(['x', 'y', 'z'], dtype='object')\n", + "0 1\n", + "1 4\n", + "2 7\n", + "3 10\n", + "4 13\n", + "5 16\n", + "6 19\n", + "7 22\n", + "8 25\n", + "Name: x, dtype: int64\n" + ] + } + ], + "source": [ + "print(data_frame.keys())\n", + "print(data_frame['x'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Добавить колонку можно как для обычного словаря:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3235e57f371940bbb8fe985882569fbf", + "version_major": 2, + "version_minor": 0 + } + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np \n", + "\n", + "data_frame['t'] = np.random.randint(0, 3, size = len(data_frame['x']))\n", + "data_frame" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Можно сортировать строки:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " x y z t\n", + "2 7 8 9 0\n", + "0 1 2 3 1\n", + "7 22 23 24 1\n", + "1 4 5 6 2\n", + "3 10 11 12 2\n", + "4 13 14 15 2\n", + "5 16 17 18 2\n", + "6 19 20 21 2\n", + "8 25 26 27 2\n" + ] + } + ], + "source": [ + "print(data_frame.sort_values(by=['t']))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Или группировать с нахождением среднего:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " x y z\n", + "t \n", + "0 7.0 8.0 9.0\n", + "1 11.5 12.5 13.5\n", + "2 14.5 15.5 16.5\n" + ] + } + ], + "source": [ + "print(data_frame.groupby(['t']).mean())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Применять функции к столбцам:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " x y z t u\n", + "0 1 2 3 1 6\n", + "1 4 5 6 2 7\n", + "2 7 8 9 0 5\n", + "3 10 11 12 2 7\n", + "4 13 14 15 2 7\n", + "5 16 17 18 2 7\n", + "6 19 20 21 2 7\n", + "7 22 23 24 1 6\n", + "8 25 26 27 2 7\n" + ] + } + ], + "source": [ + "data_frame['u'] = data_frame['t'].apply(lambda x: x+5)\n", + "print(data_frame)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Записывать в файл (подробнее можно почитать [здесь](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.to_csv.html)):" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "data_frame.to_csv('filename_result.csv', index=False, sep=';')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [default]", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/source/pages/StudentEdition/07.ipynb b/source/pages/StudentEdition/07.ipynb new file mode 100644 index 0000000..7fd4a87 --- /dev/null +++ b/source/pages/StudentEdition/07.ipynb @@ -0,0 +1,198 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Построение графиков\n", + "\n", + "Для построения графиков чаще всего используется `matplotlib.pyplot`. Больше информации можно найти по этим ссылкам:\n", + "* [Научная графика в python](https://nbviewer.jupyter.org/github/whitehorn/Scientific_graphics_in_python/tree/master/) --- уроки по `matplotlib` на русском языке.\n", + "* [Галерея `matplotlib`](https://matplotlib.org/3.1.1/gallery/index.html) --- галерея примеров на официальном сайте `matplotlib`, выбираете нужный вам пример и смотрите как он сделан.\n", + "\n", + "Построить график достаточно просто:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "x = np.linspace(-1,1,100) # Создаем массив из ста точек на промежутке (-1;1)\n", + "y = x**3\n", + "plt.plot(x,y);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Как вы можете заметить построеный график хорош всем, кромо того обстоятельства что он нарушает все правила оформления графиков для лабораторных работ. Постораемся оформить его. \n", + "Следующая иллюстрация поможет нам узнать как называются элементы изображения:\n", + "\n", + "\n", + "![](https://matplotlib.org/_images/anatomy.png)\n", + "\n", + "\n", + "Используя поиск по сайту [matplotlib.org](https://matplotlib.org/3.1.1/index.html) можно подробно узнать как настроить тот или иной элемент изображения. А мы приведем краткое описание полезных функции:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib as mpl\n", + "mpl.rcParams['font.size'] = 16 # Управление стилем, в данном случаем - размером шрифта \n", + " # Создаем фигуру\n", + "plt.figure(figsize=(7,7))\n", + "\n", + "# Подписываем оси и график\n", + "plt.title(r\"Это название графика $y = x^3$ - да, можно использовать LaTeX:\")\n", + "plt.ylabel(\"Это ось Y\")\n", + "plt.xlabel(r\"Это ось X, $F(x) = \\int f(x) dx + C$\")\n", + "\n", + "\n", + "\n", + "# Добавляем данные\n", + "x = np.linspace(-1,1,100)\n", + "y = x**3\n", + "plt.plot(x,y, label=\"Синия линия\")\n", + "\n", + "# Еще данные\n", + "x2 = x[::10]\n", + "y2 = np.sin(x2)\n", + "plt.plot(x2,y2, 'r^', label='Красные треугольники')\n", + "# 'r^' - задает стиль линии - красные (red) треугольники (^), подробнее в документации\n", + "\n", + "# Данные с ошибками\n", + "mu = np.sin(x2)\n", + "sigma = np.abs(mu)**0.5\n", + "y2 = np.random.normal(mu, sigma)\n", + "# Можно рисовать ошибки\n", + "plt.errorbar(x2,y2, yerr=sigma, xerr=0.1, fmt='.', label='Кресты') \n", + "\n", + "# Активируем сетку\n", + "plt.grid(b=True, which='major', axis='both', alpha=1)\n", + "plt.grid(b=True, which='minor', axis='both', alpha=0.5)\n", + "\n", + "# Активируем легенду графика\n", + "plt.legend()\n", + "# Внимание, запускаете вашу программу как сценарий, то что бы показать график\n", + "# Используйте эту команду\n", + "# plt.show()\n", + "# Сохраняем изображение в текущую директорию\n", + "plt.savefig('example.png')" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Логарифмический масштаб по оси x (аналогично для y)\n", + "plt.xscale('log')\n", + "plt.yscale('log')\n", + "# Сетка\n", + "plt.grid(True)\n", + "# Добавляем данные\n", + "x = np.linspace(0,100,100)\n", + "y = x**3\n", + "plt.plot(x,y,\"k--\", label=\"Синия линия\") # \"k--\" --- черная прерывистая линия" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": false, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": false, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/source/pages/StudentEdition/08.ipynb b/source/pages/StudentEdition/08.ipynb new file mode 100644 index 0000000..9f5146f --- /dev/null +++ b/source/pages/StudentEdition/08.ipynb @@ -0,0 +1,475 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "# Вычислительные методы в физике\n", + "\n", + "## Фитирование\n", + "Пусть есть набор экспериментальных точек $(x_i, y_i)$ (полученных, естественно, с некоторой погрешностью) и есть некоторая функция $F(x,\\theta)$, которая предположительно описывает нашу экспериментальную зависимость при некотором $\\hat{\\theta}$. Процедура поиска значения параметра или набора параметров $\\theta^*$, при которых функция $(x,\\theta)$ наилучшим образом описывает экспериментальные точки, называется фитированием.\n", + "\n", + "Фитирование важная процедура и многие математический библиотеки имеют функции для проведения этой операции.\n", + "\n", + "\n", + "### Определение положения пика\n", + "\n", + "Фитирование может применяться для определения положения пика. В качестве примера можно рассмотреть график, иллюстрирующий открытие бозона Хиггса: \n", + "![](./example_fit.jpg)\n", + "Красной линией на верхнем графике показан результат фитирования экпериментальных данных с помощью суммы двух функций: описывающей фоновую подложку и форму пика.\n", + "Проведя процедуру фитирования можно получить точное положения максимума пика и его ширину. \n", + "\n", + "\n", + "### Пример 1\n", + "\n", + "Пусть есть истиная функция $y = x^2 - x + 1$, и результат измерения этой зависимости (файл `example_fit.dat`). Предположим, что нам из каких-то теоретических предположений известно, что зависимость должна быть параболической, и мы пытаемся восстановить параметры этой параболы. Для этого мы воспользуемся функцией `curve_fit` из модуля `scipy.optimize`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n", + "is_executing": true + } + }, + "outputs": [], + "source": [ + "# Импротируем необходимые функции\n", + "import numpy as np # работа с массивами и линейной алгеброй\n", + "import matplotlib.pyplot as plt # для отрисовки графиков\n", + "import pandas as pd # для чтения и работы с данными\n", + "from scipy.optimize import curve_fit # фитирующая процедура" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "# #Так были сгенерированны данные\n", + "# from tabulate import tabulate\n", + "# n = 15\n", + "# x = np.linspace(0, 1, n)\n", + "# y_true = x**2 - x + 1\n", + "# error = y_true*0.1*np.random.sample(n)\n", + "# y = np.random.normal(y_true, error)\n", + "# with open('example_fit.txt', 'w') as fout:\n", + "# text = tabulate(zip(x,y, error), headers = ('x', 'y', 'y_error'), tablefmt='plain')\n", + "# fout.write(text)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "data = pd.read_table('example_fit.txt', # имя или путь к файлу \n", + " sep = '\\s+' # Здесь указывается разделитель между значениями, используемыми в файле\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "# Создадим переменные с короткими именами\n", + "x = data['x']\n", + "y = data['y']\n", + "yerr = data['y_error']" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "0.0" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x[0] # получить одно значение" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0.35714286, 0.42857143, 0.5 , 0.57142857, 0.64285714])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x[5:10] # выбрать диапазон значений" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "def parabolla(x, a, b, c):\n", + " \"\"\"\n", + " Параметрическая парабола\n", + " \"\"\"\n", + " return a*x**2 + b*x + c" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "result = curve_fit(f = parabolla, # функция, для которой ищутся параметры\n", + " xdata= x, ydata=y, # вводим экспериментальные точки\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Функция `curve_fit` имеет большой список параметров. Например, кроме экспериментальных точек можно указать их ошибки, и тогда будет применен алгоритм фитирования, учитывающий величины ошибок, или начальную точку для поиска значения параметров. " + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "popt, pcov = result # декомпозиция кортежа по отдельным переменным" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "import matplotlib as mpl\n", + "mpl.rcParams['font.size'] = 16 # Управление стилем, в данном случаем - размером шрифта " + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcMAAAGkCAYAAABNd048AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzs3XlcVFX/wPHPAYZNFkVAEFTcENQy10wlTNwzl9wjFc0Wl/R51NKfWq6lZmb2aC5pLpW45J5lmppaaWqkZQZiboioKKCC7JzfH8DEMAPMIDCo5/163RfOueec+70zOF/O3Y6QUqIoiqIojzMLcwegKIqiKOamkqGiKIry2FPJUFEURXnsqWSoKIqiPPZUMlQURVEeeyoZKoqiKI89lQwVRVGUx55KhoqiKMpjTyVDRVEU5bFnZe4ASoqrq6v08fExdxiKoihKOfHbb7/dklK6GVP3kUmGPj4+nDx50txhKIqiKOWEEOKysXXVYVJFURTlsaeSoaIoivLYU8lQURRFeeypZKgoiqI89lQyVBRFUR57KhkqiqIoj71H5taKR9Hdu3e5efMm6enp5g5FUZRHnEajwd3dHScnJ3OHYhYqGZZTd+/e5caNG3h5eWFnZ4cQwtwhKYryiJJSkpycTHR0NMBjmRDVYdJy6ubNm3h5eWFvb68SoaIopUoIgb29PV5eXty8edPc4ZiFSoblVHp6OnZ2duYOQ1GUx4idnd1je1pGJcNyTI0IFUUpS4/zd45KhoqiKMpjTyVDRVEU5bGnkqFSJtasWYMQQrs4OjrSqFEjFi9eTEZGhrnDe+S1adOGtm3bmjsMRSm31K0VSpnavHkz3t7e3L17l82bN/Pmm29y8+ZNZs6cae7QFEV5jKlkqJSpp556ijp16gDQsWNHzp8/z8cff6ySoaIoZqUOkypm1bx5c+7du6dzb9Nnn31Go0aNsLW1xdXVlVdeeYW4uDjt+vPnz9OqVSsqV66MjY0NPj4+vP3226SlpQHw9ddfI4Tg9OnTettr27YtzzzzjE7Z9OnTdQ7h5i7Tp0/X1gkJCcHb27vA/bh06ZLBPvIuP/74IwB79+6la9eueHp6Ym9vT8OGDVmwYAGZmZna/nx8fArtK29shqxdu5Zq1arh7OzMrFmztOXvvvsuTk5O1KpVi127dum9NyEhITplX3zxBUII7SHWH3/8scj9vHTpknYf8sc5a9YshBA628k9hH748GF69uyJg4MDlStXZtSoUSQnJ+u0j4mJYfDgwbi6umJjY8OTTz7Jl19+qVMn/yF5JycnnnnmGX744Qedehs2bKBdu3a4ubnh4OBA48aNWbt2rd57KYRg6tSpeuU+Pj68/PLLetvNKz4+Hjc3N533BbIfqjFq1CiqV6+ORqPRibfYpw1uRWYvSrGokaFiVhcvXsTS0hIHBwcAJk2axIIFCxgzZgzz588nOjqaqVOncubMGX755RcsLS2xtbVl0KBB1K5dGzs7OyIiIpgyZQqWlpbMmTOHnj17UrVqVZYvX86nn36q3VZERASHDh1i9erVBmM5evSo9t/5E2ZRPD09ddrPmjWLmJgYne3Xr18fgAsXLhAUFMSbb76Jra0tJ0+eZPr06cTGxjJ37lwAtm3bRmpqKgC7d+9m9uzZOv0XlpiPHj3K0KFDCQ4OZtCgQaxcuZLff/9d227Tpk0sWbKEPn36EB4eTs2aNQ32c/fuXd5++20sLS21ZU2aNNGJY+TIkXh6evLOO+/ovBeGXL58mTlz5uj0l9fLL79Mv379GDlyJMePH2fmzJkkJSWxZs0aAJKSkggMDCQ+Pp7333+fatWq8eWXXzJo0CDu37/Pa6+9ptPf1q1b8fT05ObNm8yYMYMePXpw5coVKleuDGR/Dn369GHSpElYWFhw+PBhhg8fTnJyMm+88UaB768ppkyZQnx8vF75+PHj+eKLL5g3bx5NmzbFysqKlStXsmrVqhLZrmI6lQwfIjN2/cXZa3fNGkP9qk5Me6FBsdtnZmaSkZHBvXv32LRpE1u3buWFF17A3t6eS5cuMX/+fKZNm8a7776rbePr60ubNm3YtWsXPXv2xNvbmxEjRpCZmUlmZiaurq64urpy9uxZAKysrHj11VdZuHAh8+fPp0KFCgAsX76cihUr0r9/f52Y0tLSsLS0pGXLlsXeLxsbG532bm5uJCUlGewz7xetlJKAgADS0tL48MMPef/997GwsKBx48baOuHh4QBGxzd//nwaNGjAunXrEEIQFBREgwYNsLKyYt26dVhYWPDcc8/h7e3NJ598wsKFCw32M23aNCwtLenZsye3bt0Csh/TlTcOJycn3NzcjIrtP//5D35+fto/fPLr2rUrH374IZB9CF0IwbvvvsvkyZPx9fVl9erVREZGcvDgQe1ItUuXLty4cYOpU6fyyiuv6CTaxo0b4+Pjo33do0cPzp07p/1DZ/Lkydp1WVlZtG3blpiYGJYuXVoiyfD3339n+fLljB49mk8++URn3dGjR+nYsSNjx47Vlu3Zs+eBt6kUnzpMqpQpPz8/NBoNLi4ujBw5kuDgYD7//HMA9u3bR1ZWFsHBwWRkZGiXp59+GicnJw4fPqzTV9OmTbGxsaF+/frcuHGDCRMmaNe99tpr3L9/n9DQUABSUlJYu3YtgwcP1nuyT3JyMra2tkbFn5GRoXM4szhiYmJ4/fXXqVGjBtbW1mg0GqZOnUpCQkKJPAorLCyMZ599VnvIztLSUvsHg4VF9n95GxsbWrRooR0x5nfmzBkWL17MggULCkxeptizZw87duxgyZIl2hjy69evn87rAQMGkJWVxfHjxwE4fPgwXl5eelfFvvzyy8TGxmr/GMqV+4dXTEwM69atw83NjQYN/v1DLjIykoEDB+Ll5YVGo0Gj0bBy5UoiIiL0YpNS6vxOFnUoU0rJyJEj6dChA7169dJbX6tWLY4ePcrPP/9MSkoKGRkZZGVlFdqnUrrUyPAh8iAjsvJi27ZteHt74+joSI0aNXSSUG4iyL3AJr/bt2/rvF6/fj0JCQmcOHGCsLAwatSooV1XtWpVevTowbJlyxg+fDibN28mLi6O119/3WC/uYfOChMdHY1GowGgQoUK+Pv7M2XKFHr27Fn0jufIysqie/fuXLt2jenTp+Pn54ednR3bt2/nvffeIyUlxei+CnL9+nUcHR2LrOfo6MiFCxcMrhs1ahQBAQH079+f77777oHiSU1NZcyYMYSEhBR6+LlKlSoGX+c+PDouLs7gIVgPDw/t+rzy/h5VqlSJL774QvsA6sTERDp06IC9vT1z586ldu3aWFtbs3TpUu0fZ3m9//77vP/++3rlbdq0Mbgvq1evJiwsjDNnzmjjz2vRokWEhIQU2F4peyoZKmWqYcOGBSa73IS0d+9eKlWqVOD6XLnn4Fq1asXs2bPp06ePdhQB2eezgoKC+O2331i+fDkBAQHaNnlFRkZSu3btImN3d3dn9+7dQPaFEYsWLaJv3778+eef+Pn5Fdke4J9//uHkyZN88cUXOhdf5L+Y5UG4u7vr/eFgyO3bt3Fzc9Mr/+qrrzh69CinTp0qkXg+/PBDYmNjmTdvXqH1bty4oTNyu3HjBgBeXl4AuLi4GBy1Xb9+HdD//di5cyeenp4kJyfzzTff0LNnT77//nvatWvH0aNHuXz5MkeOHNFJSAWN+IYNG8aIESN0yrp3726wbkJCApMmTeKtt96ibt26BpNhzZo1Wb9+PQ0aNGDYsGG89NJLrFixgs8++8xgn0rpMyoZCiG8gYlAM6ARYAfUlFJeMqKtRU7b1wEPIAKYKaXckq/ej0CggS7+K6X82Jg4lYdbhw4dsLCw4MqVK3To0MGktklJSZw5c0anrF27dvj7+zNu3Dh+/vlnvvrqK712165dIywsjP/7v/8rchsajYZmzZppX1epUoXdu3fzxx9/GJ0M79+/r+0rV3p6usHYiqtRo0YcOnQIKSVCCDIzM7l16xZWVlZkZWVhYWFBcnIyJ0+eJDg4WKftvXv3eOuttxg7dqzBPxxMdeXKFTZu3MgHH3xgMPHmtWnTJtq1a6d9vWHDBiwsLGjRogUAgYGBbN68mZ9//pnWrVtr661fvx53d3f8/f11+nviiSe05wwDAgJYsWIFX3/9Ne3atTP4OcTHx7Njxw6DsXl6eup89gDW1tYG606dOhU7Ozudc5KGDBs2jJo1azJv3jw0Gg3ffPNNofWV0mXsyLAO0A/4DTgCdDRhG7OACcCUnPYDgM1CiG5Sym/z1f2D7KSZ1yUTtqU8xGrXrs3EiRMZPXo0ERERBAYGYmtrS1RUFPv27WP48OE899xzLF++nNjYWJo0aYK1tTWHDx9mwYIF9OjRQ6/PN954g7Fjx+Lq6krv3r111m3evJmZM2diZ2fHq6++WmR8GRkZ2otZEhISWLhwIVZWVjz11FNG76O/vz81atTQXv2q0WgKvICluCZMmKC9TSI4OJhVq1Zx9epVAIYMGcLLL7/Mp59+SmJios4FHAA7duygSpUqTJs2rURiWbduHU8++aRRF6R8++23vPXWW3Ts2JHjx48zY8YMBg8ejK+vL5B9e8uiRYt48cUXee+99/D29uarr75i3759LF++XO8q1d9//53r169rR4YJCQk0atQIyD6a4OTkxKhRo5gxYwZJSUnMnj0bV1dX7ty580D7vGzZMjZv3oy9vX2BdZYuXcqPP/7IyZMndRKyYj7GJsPDUsoqAEKI4RiZDIUQ7mQnwrlSyg9zig8KIeoAc4H8yfCelPKYkTEpj6D3338ff39/lixZwpIlSxBCUK1aNYKCgqhbty6QPSJbsWIF8+bNIysri2rVqjFp0iQmTpyo11/fvn0ZO3YsISEh2NjY6KybPXs2vr6+bNy4UXsorjA3btzQjj6cnJyoX78+W7Zs0X5ZG8Pa2prt27czevRoBg8ejIuLC8OGDaN69epGJWRjBAYGsmLFCqZPn86OHTuYOHEi0dHRWFlZUbduXfr27UulSpXYuHGj9j3NlZmZWWIXzUD2OdIlS5YUeDtFXl9++SULFixg6dKlWFtb8+qrr2qvLoXs87SHDh3i7bffZtKkSdy7d4969erpHXLO9eKLLwJga2tLjRo1mDt3rvb2Czc3N7Zt28b48ePp06cPVatWZezYscTFxTFjxowH2uf27dsbvGgm1z///MNbb73FzJkzeeKJJx5oW0oJklKatADDAQn4GFF3UE7duvnKh+aU18xT9iPwk6nx5C5NmzaVj5KzZ8+aO4RHwooVK6QQQkZGRpo7FLNq3bq1DAwMNHcYBq1evVoCj/1n9MBiz2UvD+hR+u4BTkojc0hp31rRAEgFzucr/yvnZ/6TEo2FEHeEEOlCiD+EEK+UcnzKI+rs2bPs2rWLadOm0bNnzwIv2lEURYHSv5rUBUjIydB5xeVZn+sw8BVwDqgIDAZWCiE8pZSzDXUuhHgNeA2gevXqJRm38pAbOXIkv/zyC61atWLx4sXmDkdRlHKutJOhIPtwqKFyHVLKd/MV7RBCbAOmCCE+llImGmizAlgB0KxZM0PbUR5Tuc8BVbL99NNP5g6hQCEhIXrPRFWUslbah0njgEoi/9NroVKe9YUJBWwBdZZZURRFKTWlnQz/AmyA/Hc0554rPEvhcpOoGvUpiqIopaa0k+EeIA0Izlf+MnBGSnmxiPYvAcnAn6UQm6IoiqIAJpwzFEL0yfln05yfXYQQsUCslPJQTp0MYK2U8hUAKeVNIcRC4P+EEPeAMKA/0A7okafvAGASsJXsm+ydgSFAd2CSlDKp2HuoKIqiKEUw5QKazfle507Udghom/Nvy5wlrylAIjCWfx/H1k9KmfdhjDFkj1JnAq5AOtlPo3lJShlqQoyKoiiKYjKjk6GUUu8KUGPqSCkzgdk5S0HtzgNdjI1FURRFUUqSms9QURRFeeypZKiUiTVr1iCE4Px53YcRZWRk4OvrixCC6dOnmyc4RVEeeyoZKma1evVqIiMjzR2GoiiPOZUMFbNJTU1l1qxZdOrUydyhKIrymFPJUDGbTz/9lKtXrzJ7tuFrqy5evMigQYPw8PDAxsaGWrVqaeffCwkJQQhR4NK2bVsg+7FsQgguXbqk7Tc9PR1/f3+EEDqPbWvbtq3OrOe5QkJC8Pb21imbNm0aTZo0wdnZGVdXV9q1a8exY/qzjx09epSgoCAqV66sE5+hKYfyWrp0KX5+fjg4OODo6EiLFi30Jp7dsGED7dq1w83NDQcHBxo3bszatWv1+sq7XY1GQ61atZg2bRpZWVnaOtOnT9dOhJvr/Pnz2Nrakv8BUhkZGcybN4/69etja2uLm5sbnTt31s71aOp7LoQw+Dg2Pz8/hBBMnTpVp3zPnj0888wz2NnZ4ezsTM+ePYmIiNBrv23bNlq3bo2DgwNOTk60aNGCnTt36r0nhpY1a9YAhj975dFU2s8mVRSDEhMTmTNnDn379jU4Oe7Fixdp0aIF9vb2zJgxg7p16xIVFcXevXsBeOedd7QTxsbExPDiiy+yZMkSmjRpAmTPN1iQhQsXPvCh2ejoaP773//i7e1NUlISX375Jc8++ywnT57kySef1O5j165d8fHxYeXKlXh6egIUOtddLh8fH6ZNm4anpyeZmZns3LmT3r1788cff2hnoL9w4QJ9+vRh0qRJWFhYcPjwYYYPH05ycrLeZLqvvPIKw4cPJzU1lW3btjFz5kw8PDwYMWJEgTGMGTOGjIwMvfIBAwawfft2/vOf/9C+fXtSUlI4fPgwMTEx+Pn5GeyrsPfcxcWFjRs38tFHH+Hikv3s/gMHDhAbG6tXd8+ePTz//PO0a9eOjRs3kpiYyLvvvkubNm04deqUdl7K//3vf4wZM4aePXuydu1aHBwcCAsL0yboo0ePavtcuXIlu3fvZtu2bdqy2rXzPzRLedSpZPgQmXd8HuFx4WaNwc/Fj4kt9CfRNdXChQuJi4tj5syZBtdPmzaN5ORkTp8+TdWqVbXlQ4YMAbK/rHK/sHK/4OrXr0/Lli0L3W50dDSzZs1i1KhRfPLJJ8WOf+XKldp/Z2Zm0rlzZxo0aMCqVatYtGgRAOHh4SQkJPDOO+/oJMD8kwwb0qVL9p1GGRkZJCcnc+vWLT755BMiIiK0yXDy5Mna+llZWbRt25aYmBiWLl2qlwy9vb21701gYCDr1q3j1KlTBW5/x44dfP/994wcOVJn1o8DBw6wZcsWFi1axJgxY7TlPXv2LLCvot5zf39/0tPTWbNmDePGjQOyR8YhISF89NFHOnWnTp1KrVq1+O6777Cyyv76euaZZ/D19WXBggV89NFH3L17l8mTJ9OrVy+2bt2qbZv3cHze35M9e/ZgY2NT5O+O8mhTh0mVMhcXF8eCBQsYPHgw9erVM1hn7969dOvWTScRloRx48bh4+PDm2++WWCdjIwMnUV/BjL44YcfeO6556hcuTJWVlZoNBrOnTunc7iuWrVqaDQavvjiC6KiorT9GevUqVNoNBqcnJwYMGAAgYGBdO7cWbs+MjKSgQMH4uXlhUajQaPRsHLlSoOHDLOyssjIyOD+/ft88cUXxMfHaw8l55ecnMx//vMfXnvtNZo2baqzbu/evQghePXVV43eD2Pe8xEjRrBs2TKklMTExLBz505ef/11nTpJSUmEhYXRv39/bSIEqFmzJq1bt+bQoUMA/PLLLyQmJmpntS8JGRkZZGZmllh/SvmjRoYPkZIYkZUH8+bNIzk5mWnTphVY5/bt2yV+rubAgQNs3ryZgwcP6nyZ5vXzzz+j0Wj0ynMPvwGEhYXRtWtXOnXqxKpVq/D09MTS0pLhw4eTkpKirVelShVWr17NhAkT9ObbNHRuMr969epx4sQJ4uPj2b59O97e3lhbWwPZh2A7dOiAvb09c+fOpXbt2lhbW7N06VI+//xzvb5mzZrFrFmztK9ff/11+vfvb3C7c+bMITExkffee097ji3X7du3cXFxwc7Orsj4wbj3HKB///6MGzeO/fv3c/ToUQICAvD19dWpEx8fj5RSe7g5Lw8PDy5fvqyNESix35/o6Gjt70SFChXw9/dnypQphY6GlYePSoZKmbp+/TqLFy/mtddeo0aNGgXWc3V1JTo6usS2m56ezujRo3nppZcIDAzUubgjr0aNGukcAgWYMWMGv//+u/b1li1bsLKyYuvWrTqJMz4+nooVK+q0DQ4OJj4+ngkTJrB161bc3d3p3r27UTHb2dnRrFkzANq3b4+vry/Ozs6MHDmSo0ePcvnyZY4cOaKTWAsaeb766qu89tprZGVlERkZyYQJE0hPT2fVqlU69f755x8++OADFi9erD1/l5erqytxcXEkJycXmRCNfc9z9zUkJITFixcTFhamd3gUoFKlSgghuH79ut6669evU7lyZW2MkJ3EGjZsWGiMxnB3d2f37t1A9me8aNEi+vbty59//lngOVLl4aMOkyplKnd0MmXKlELrdezYkW+++YaYmJgS2e6iRYu4evUq8+fPL7Seg4MDzZo101lyv2Rz3b9/H0tLS52rLA8cOMCVK1f0+jt//jwTJ05k9uzZdO3alWbNmmlHd6bIzMwkNTWVM2fOaGMA9JJx/itOc1WtWpVmzZrRokULgoODGTBgAKGh+o/9HTt2LI0aNeKVV14x2E/Hjh2RUur9wWCIse95rjfeeIOdO3eSkZFhcNRVoUIFmjZtyubNm3UOWV6+fJlffvmFwMBAAFq1aoWDgwMrVqwwartF0Wg02t+FDh068P7775ORkcEff/xRIv0r5YMaGSplau/evUycOBEPD49C682YMYPdu3fTqlUrJk+eTJ06dYiOjmbPnj18+eWXJm932bJlzJ8/3+AhNlN17tyZjz/+mJCQEIYOHcq5c+eYNWuWzqFUyE5ggwcPpkmTJtoLQ4w1ZMgQAgMDqVmzJgkJCSxbtoyoqCi6du0KZH/hOzk5MWrUKGbMmEFSUhKzZ8/G1dWVO3fu6PV39epVjh07ph0ZhoaG0qhRI706UVFR/Prrr3q3U+R67rnn6N27N+PGjSMqKop27dqRnp7O4cOHef7553XOQ5r6nvv6+nL48GGcnZ0LPKQ6a9Ysnn/+ebp168bIkSNJTExk2rRpODs7M378eAAcHR2ZM2cOb775Jr179yY4OBhHR0dOnTqFra1toecuDcnIyNDeNpKQkMDChQuxsrIyeBW08vBSybCsrX4+++fQ3eaNw0ycnZ15++23i6zn4+PDr7/+ytSpU/m///s/7t27h5eXFz169CiyrSF+fn4mfwkWpFOnTnzyySd89NFHbNmyhYYNG7Ju3Tq9+yXnz5/PH3/8wenTp7GwMO0gTIUKFZg5cyYxMTE4OjrSsGFDtm/fTrdu3QBwc3Nj27ZtjB8/nj59+lC1alXGjh1LXFwcM2bM0Otv1apVrFq1CgsLC9zd3QkKCmLu3Lk6dTIzM3n99de1h2YLsmHDBubNm8fatWv5+OOPcXZ2pnnz5gwfPlynXnHe86LOpXbu3Jndu3czY8YM+vXrh7W1NW3btuWDDz7Qudhq9OjReHh4MH/+fIKDg9FoNPj7+/POO++YFA/AjRs38Pf3B7Jv2alfvz5btmzRO6epPNyEoSvlHkbNmjWTJ0+eNHcYRTMyGf7999/a/4CKoihFupVzH6dr3Qfq5lH67hFC/CalLPyvuxzqnKGiKIry2FPJUFEURXnsqWSoKIqiPPZUMlQURVEeeyoZKoqiKI89lQwVRVGUx55KhoqiKMpjTyVDRVEU5bGnkmFeq5//96b4R9Gjvn+KoijFpJKhoiiK8thTyVApE3v27OHFF1/E09MTa2trXF1d6dKlC7t27TJ3aIqiKCoZKqXv8uXL9OjRAycnJz755BP279/PqlWr8PHxoVevXowZM8bcISqK8phTs1Yopc7JyYmwsDAaNGigU96jRw+efvpphg4dSvPmzRk0aJCZIlQU5XGnRoZKqatUqZJeIswVEhJC8+bNmTNnjrZszZo1evPpLVmyBEtLS7766iud8m3bttG6dWscHBxwcnKiRYsW7Ny5U7teCFHg8vLLL+v0dfHiRYKDg3Fzc8PGxoannnqKbdu26dSZPn06Qgj+/PNPnnvuOezt7fH09OTdd98lKytLW+/HH39ECKEzu3t6ejr+/v4IIfjxxx+15W3btkUIQUhIiN774+fnhxCCqVOn6pSfPn2a7t27U6lSJezs7GjdujVHjhzRe2+9vb31+szdh4yMjCLfIyEEa9asAeDEiRP06dMHb29v7OzsqFevHpMnTyY5OVlvG7n7n3/JO99h7ud8/vx5vfZ5+fj46H1Wue9b3imfcrf5ww8/FNiXEILp06frlB06dIigoCAcHR2pUKECnTp10k6iXJCQkJBC37O8+xkREUGvXr2oWLEidnZ2tGzZkj179ujtY/7PP/dzyh9/7ucB2ZNHV61alRdeeIH09HTA8P+f+Ph43Nzc9H4nlX+pZPg4Sb0Ld6Ig6rhZNp+VlUVGRobeEhQUxN9//13grParV69mzJgxLF++nODgYG35//73P1588UXc3d1Zu3YtmzdvplevXnr/2UNCQjh69KjOkn9y4aioKJ5++mlOnz7NwoUL2blzJ02aNKF37946yTVXz549ad++Pdu3b+ell15i1qxZzJw5s9D9X7hwIZGRkQbXubi4sHHjRuLi4rRlBw4cIDY2Vq9uWFgYrVq1Ii4ujs8++4wtW7ZQuXJl2rdvz2+//VZoDIbkfV9eeeUVPDw8dMqefz77CuQrV67w1FNPsWzZMvbs2cPYsWP5/PPPGTp0aIF9L1myRNtP48aNTY6ttO3evZugoCAcHBz48ssvWb9+Pffu3SMgIICoqKgC273zzjva/dq6dSugu6+ffvopANeuXaNNmzacPn2axYsXs2nTJipWrMjzzz/Pd99990CxX758maCgIBo0aMDXX3+NRqMpsO6UKVOIj49/oO098qSUj8TStGlT+cCWtpFy4RNSXvn1wfsqyOdds5cinD17tmS3e+VXKadXlHKak5SzqpTuPhZgyJAhEihw+fXX7JhWr14ts381pQwNDZWWlpZy0aJFOn0jb4qlAAAgAElEQVTduXNHOjg4yF69ehW6TUBOmTJFr7xGjRoyODhY+3rYsGHS1dVV3rp1S6de+/btZaNGjbSvp02bJgE5Z84cnXrDhw+XDg4OMj4+Xkop5cGDByUgL168KKWU8urVq9LBwUGOGTNGAvLgwYPatoGBgbJ169ayRYsWcsGCBdryPn36yHHjxuntQ7t27aSfn59MTU3VlmVkZEg/Pz/Zo0cPbdmQIUOkl5eX3r7n7kN6errBdTVq1NArzy8rK0ump6fLL774Qgoh9N6377//XgLyyJEjOvsZGBiofZ37OUdGRha6rfyfVd7+WrdurX2d+57v27evwL4AOW3aNO3r2rVry3bt2unUuXPnjqxcubIcO3ZsoXHlunjxot5nmmv8+PHS0tJSZx8zMjKkr6+vbNy4sbbMz89P9u7dW6dt7ueUP/7Vq1fLa9euydq1a8uAgACZlJSUvTL2nJSx53T+/0gpZVhYmLSwsND+7uX+ThakxL97zAg4KY3MIWpkmCvqONw4AwmXYW13s42eSs2lIyBzDuNlpmW/LmPTp0/nxIkTesuIESMM1t++fTuDBg3ihRde0LvI5pdffiExMZHXXnutRGLbs2cPXbt2xdnZWWfU2qlTJ06fPs3du3d16vfr10/n9YABA0hMTCzw8Nq4cePw8fEpdOb3ESNGsGzZMqSUxMTEsHPnTl5//XWdOsnJyRw6dIi+fftiYWGhjVNKSfv27Tl8+LBev/lH4nkP55ri7t27TJw4kdq1a2NjY4NGo2HQoEFIKfVGvLmHTm1tbYvsNzMzU7sPBZFS6u1HQfVzj0AU1h9AZGQk//zzD8HBwTr92tvb88wzzxh8L011+PBhWrZsSZ06dbRllpaWDBw4kFOnTml/rxo1asS+ffs4fvx4kZ9TbGwsQUFBREVF8fXXX2Nvb1/g9qWUjBw5kg4dOtCrV68H3p9HmUqGucpBsihVPgEgcj5uS+vs12Udgo8PzZo101tyDw1Wq1ZNp37//v1p1aoVu3fvJiwsTGfd7du3AQyeEyuOmzdvsm7dOjQajc7y1ltv6WwvV5UqVQy+jo6O1uv7wIEDbN68mcWLF2NlVfA1a/379+fWrVvs37+flStXEhAQgK+vr06duLg4MjMzmTVrll6sixcvJj4+XudLNDo6Wq/erFmzTHtzcgwdOpRly5YxZswY9u3bx4kTJ1iyZAkAKSkpOnVz36/KlSsX2a+fnx8ajQYbGxvq1q3LnDlz9BLZ+vXr9fajoGTVqVMnbZ3q1aszYcIE0tLS9OrdvHkTgFdeeUWv72+++UbvMy+OuLg4PD099co9PDyQUmoPXb7//vt4e3vz9NNPF/k5TZ06FY1Gg729PfPmzSt0+6tXryYsLIz//e9/D7wvjzqjriYVQngDE4FmQCPADqgppbxkRFuLnLavAx5ABDBTSrnFQN1XgfFATeASsFBKucyYGB9YbrKQWWZLFqWqWguo0hBS7kDvldmvy4G7d++yb98+/P399b40xo4dy7x58+jQoQODBw/mt99+w8bGBgBXV1cg+8u+YcOGDxxH5cqVCQgIYOLEiQbXV61aVef1jRs3qFWrls5rAC8vL5166enpjB49mpdeeonAwMBCL16ws7MjJCSExYsXExYWxkcffaRXp2LFilhYWDBq1CgGDx5ssB8Li3//xnV3d2f37t0661esWMFnn31WYByGpKSksGPHDqZPn87YsWO15X/++afB+pGRkdjY2Bj1x8q2bdvw9vYmOTmZXbt2MXnyZNzc3Bg+fLi2TpcuXfTOyeYfNedasmQJLVq0IC0tjSNHjjBlyhRsbW2ZPXu2Tr3cRD1nzhzat2+v14+1tXWRsRfFxcWF69ev65Vfv34dIQQuLi4A1KpViz///JMLFy6QkJAAFPw51alTh/379/Ptt98ydOhQevTowbPPPqtXLyEhgUmTJvHWW29Rt25dg3+oKf8y9taKOkA/4DfgCNDRhG3MAiYAU3LaDwA2CyG6SSm/za2UkwiXA3OAH4Ag4FMhhJBSLjVhe8VTTpNFibJxyl7KeN+uXbvG4cOHGTBggN662bNnExcXx8cff6y37oMPPgDg888/54knnuCdd97RlrVq1QoHBwdWrFhBp06dHjjGzp07c/ToURo0aICdnV2R9Tdt2sSkSZO0rzds2ICDg4NeYl60aBFXr15l//79RsXxxhtv4Ofnh4eHBz179tRbX6FCBQICAjh9+jRNmjTRSXyGaDQamjVrplP2zTffGBVLXqmpqWRmZupdpJH3ysZcGRkZ7Nmzh5YtWxZ6UUeuhg0bag8jBgQEsHLlSr0jAS4uLnr74ejoqL0iNi9fX19t3VatWrFx40a9/gDq1auHj48Pf/31l85nWZICAwP5+OOPuXTpEj4+PkD2YeGNGzfSuHFjHB0dtXUtLCx0DqcW9Dm99dZbuLq6MnjwYLZt20ZISAh//PEHDvnqTZ06FTs7OyZPnlzSu/VIMjYZHpZSVgEQQgzHyGQohHAnOxHOlVJ+mFN8UAhRB5gLfJtTzwp4D/hCSjklT72qwCwhxEopZbqRsRafmZLFoy49PZ2BAweybt06goODqV69Ojdv3mTTpk1s2rSJN998s9B7DKtXr87ChQt59dVX6d69O23atMHR0ZE5c+bw5ptv0rt3b4KDg3F0dOTUqVPY2toWem7OkJkzZ9KiRQueffZZRo8ejY+PD/Hx8Zw5c4YLFy7w+eef69T/7LPPyMrKonnz5nz//fesXLmS6dOnU7FiRZ16y5YtY/78+QYPlRni6+vL4cOHcXZ2LvCQ6kcffcSzzz5Lp06deOWVV/D09OTWrVuEhYWRmZnJ3LlzTdp3Yzg7O9OyZUsWLFiAp6cnrq6ufP7553qjjePHjzNr1ixOnz5t8CpcQy5cuEBGRgYpKSl88803xMfH07x582LHGhUVRXh4OGlpafzyyy+cOXOGF154Qa+eEIIlS5bQo0cP0tLS6NevH66urty4cYNffvmF6tWrM27cuGLHAfDf//6XNWvW0KFDB2bMmIGTkxOffvop586d0xuxF8fy5ctp0KAB48ePZ/l7E3TWLVu2jM2bNxd6TlH5l1HJUEpZvDPu0AmwBr7MV/4l8LkQoqaU8iLwDOBmoN4XwFCgDXCwmDEoZlajRg327t3L8uXLmTBhArdu3cLJyYnmzZuzY8cOunfvXmQfw4YNY/v27YSEhHD69GkqVKjA6NGj8fDwYP78+QQHB6PRaPD39+edd94xOcbq1atz8uRJpk+fzuTJk4mNjaVy5co0bNiQIUOG6NXfsWMHb775JrNmzcLZ2ZmpU6ca3K6fn5/JiTnvvXOGNGnShBMnTjBjxgzGjBnDnTt3cHNzo0mTJrzxxhsmbcsUoaGhjBgxglGjRmFnZ0e/fv1YtGgR3bp109ZZuXIld+7cYdeuXdpbMoqSO7K3tbWlRo0azJ07t9DbNYoybNgwIPswp5eXF//973/17tPM1bVrVw4fPsx7773H8OHDSU5OxsPDg5YtW9K/f/9ix5CratWq/PTTT0ycOJERI0aQmprKU089xe7du+ncufMD9+/u7s6yZcvo06cPPZ9rTpf2gdp17du3VxfNmMLYy05zF2A42ZfC+xhRdy6QAoh85S1y+ng+5/UbOa8989VzzykfVdS2HvTWiqysLPn750Ey5fMuD9RPkcx1a4UJ21YKVthtCYpiVjm3Vjyo8nBrxYmYEzItM+2B+6Ec3VrhAiTkBJVXXJ71eX/mvys0f71Sczr2NIMsbrCHpNLelKIoilKAqLtRDPt+GGv/Wlum2y3tZ5MKskd2hsoNvS78xqD8jYR4DXgNsg9zPYhGbo2oJa1YLxLpLqXe44weCUMf/ByFoihKadoYsRFLYUn32kWfPilJpT0yjAMqCf3MUinP+rw/848AXfKt1yGlXCGlbCalbObm5vZAgQohGCgdOSvS+POW4cvFFWX69OlIKQu9X1BRlOJJzkhm6/mtBNUIwt3evUy3XdrJ8C/ABqidr7x+zs+zeeoB5H+ac/56peoFKlBBCtaHry+LzSmKoih57L6wm3tp9xjoN7DMt13ayXAPkAYE5yt/GTgjs68kBTgK3CqgXhzwc2kGmavC0O/o4T+Q7y99z63kW2WxSUVRFIXsizlDw0PxreRLE/cmZb59o5OhEKKPEKIP0DSnqEtOWWCeOhlCiFW5r6WUN4GFwP8JIcYJIdoKIZYC7YDJeeqlA+8AQ4QQs3PqzQSGAe9KKfWfpVRK+vv1JyMrgy3n9B6QU+b0rztSFEUpPeb8zgm7Gca5+HMM9Btolms2TDnxsTnf609zfh4C2ub82zJnyWsKkAiM5d/HsfWTUu7KW0lKuUwIIcl+HNtbwBVgtJTyU8pQLedaPOP5DJvObWLYE8PQWBT9BI3SoNFoSE5OVjfMKopSZpKTk416alBpCA0PxdHaka41u5pl+0aPDKWUooClbb46IfnaZUopZ0spa0gpbaSUT0opvy5gG8ullL459eqWdSLM9ZL/S9y8f5ODV8x3n7+7uzvR0dHcv39fjRAVRSlVUkru379PdHQ07u5le+EKwI2kG+y/vJ8X67yIvcY8AwB1SZwBAV4BeDl4ERoeSkcfUx7DWnKcnJyA7Od65s5grSiKUqDE7Fk4iNV/XqsxNBoNVapU0X73lKWvI78mU2bSv96DP/WnuFQyNMDSwpL+9frz0W8fcS7+HL6VfItuVAqcnJzM8oupKMpDaHXOs0kfsvuJ0zPT2RyxmQDvAKo5VSu6QSlR8xkWoFedXthY2hAaHmruUBRFUR5Zey/v5XbKbbPcTpGXSoYFqGhbka41u7L7wm7upN4xdziKoiiPpNDwUKo7VqdV1VZmjUMlw0IM9BtIckYyO87vMHcoiqIoj5y/bv/F6djTDPAbgIUwbzpSybAQ/pX9aezemA0RG8gq9ixWiqIoiiEbwjdgZ2VHjzo9zB2KSoZFGeg3kKh7UfwcXSYPwVEURXksJKQk8O2Fb3mh1gs4WZv/QkGVDIvQvnp7XO1c1YU0iqIoJWjr+a2kZaUxwG+AuUMBVDIsksZSQ1/fvvwU/RNX7l4xdziKoijms/r57OUBZWZlsjF8I809mlO3Ut0SCOzBqWRohD6+fbAUlmyI2GDuUBRFUQxLvQt3oiDquLkjKdKhq4e4lnTN7LdT5KWSoRHc7d1pX6M92yO3cz/9vrnDURRF0RV1HG6cgYTLsLZ7uU+IoeGhVLGvwnPVnjN3KFoqGRppoN9A7qXfY/fFh+vpDoqiPAYuHYHcK94z07Jfl1MXEi5wLOYY/er1w8qi/DwETSVDIzV2b4yfix+h4aHqwdmKopQvPgGQe5+epXX263JqQ8QGNBYaetftbe5QdKhkaCQhBAP9BhIZH8lvN34zdziKoij/qtYCqjSEijVgyM7s1+VQYloiO87voLNPZyrbVTZ3ODpUMjRBl5pdcLJ2UrdZKIpS/tg4gXO1cpsIAXZd2MX9jPvl6sKZXCoZmsDOyo4X677I/iv7uZF0w9zhKIqiPDSklISGh9KwckOecHvC3OHoUcnQRP3q9SNLZrHp3CZzh6IoivLQOBZzjIt3LjLQv/yNCkElQ5NVc6zGs97P8vW5r0nLTDN3OIqiKA+F0PBQKtlUopNPJ3OHYpBKhsUw0G8gcSlx7L2819yhKIqilHvRidEcunqI3r69sbG0MXc4BqlkWAzPVH0GHycfdSGNoiiKETZFZJ9W6l+vv5kjKZhKhsVgISwY4DeAP2L/4K9bf5k7HEVRlHIrJSOFrZFbaVetHR4VPMwdToFUMiym7rW7Y2dlp0aHiqIohdhzaQ8JqQnl8naKvFQyLCZHa0e61+7Odxe/Iz4l3tzhKIqilDtSStb/vZ7azrVp7tHc3OEUSiXDBzCg3gDSstLYErnF3KEoiqKUO6djT/N33N8M9BuIEMLc4RRKJcMHUKdSHVp4tGBTxCYysjLMHY6iKEq5EhoeioPGgRdqv2DuUIqkkuEDGug3kJikGA5dPWTuUBRFUcqNW8m32Ht5Lz3q9MBeY2/ucIqkkuEDalutLR4VPNSFNIqiKHl8fe5rMrIyGFBvgLlDMYpKhg/IysKK/vX682vMr1xIuGDucBRFUcwuPSudzRGbaV21NT7OPuYOxygqGZaAF+u+iMZCo0aHiqIowIErB7iZfLPc306Rl0qGOVLSM1n980XupaSb3NbF1oUuNbuw85+dJKYllkJ0iqIoD4/Q8FC8HLxo49XG3KEYTSXDHJE3Epmx6ywrj1wsVvuBfgO5n3GfHf/sKOHIFEVRHh4RcRH8duM3BtQbgKWFZbH6KM6g5EGpZJjjCW9nuj7hwcojF7iVmGpy+4auDXnC9Qk2hG8gS2aVQoSKoijlX2h4KLaWtvSq26tY7eOS0gj44CBf/Xq5hCMrnFHJUAhRTQjxtRDijhDirhBiqxCiupFta+a0TRBCJAkhDgohmhmod0kIIQ0sPU3dqeIa37EeKRlZLDl4vljtB/oN5NLdSxyLOVbCkSmKopR/d1LvsPvCbp6v9TzONs7F6uPTg+e5m5xOCx+XEo6ucEUmQyGEPXAA8AOGAIOAusBBIUSFItpWBn4CGgKvA7nX2B4UQvgbaPI98Ey+pcxu4Kvt5kDfpt58dewKUXH3TW7fyacTLrYu6kIaRVEeS9vPbyclM4UBfsW7nSI6IZl1Ry/Tu4k3das4lnB0hTNmZPgqUAvoKaXcLqXcAXQHapCd4AozAqgCdJNSbpRS7gK6AfeBGQbq35JSHsu3lOmDP8e2rwsCPv4h0uS21pbW9K7bm0NRh4hOjC6F6BRFUcqnLJnFhvANNHFvgp+LX7H6WLjvHAj4bwffEo6uaMYkw+7AMSml9tihlPIi8DPQo4i2LYHIfG2TgCNANyGElekhly5PZztCWvmw9ferRFy/Z3L7fvX6YSEs2BixsRSiUxRFKZ9+iv6Jq4lXi307xbkb99gadpUhz9SgakW7Eo6uaMYkwwbAGQPlfwH1i2ibCaQZKE8F7IDa+cpfEELcF0KkCiGOleX5wrxGtq2Ng40VH+6NMLmtRwUP2lVvx9bIraRkpJRCdIqiKOVPaHgobnZuBFUPKlb7+d9HUMHaipFt65RwZMYxJhm6AIYOVcYBlYpoGwHUzTl3CIAQwgJokafvXLuAN4FOQDCQAmwTQrxsRIwlqqK9NW8E1mbf2Rv8dtn0o7QD/QZyJ/UO3138Tn9l6l24EwVRx0sgUkVRFPO7fPcyP0X/RF/fvmgsNSa3/+1yHPvO3uD1wFpUqmBdChEWzdhbK6SBMmPm41iWs411QojaQghP4BOgZs567T0IUso3pZTrpJRHpJRfA0HASWBOQZ0LIV4TQpwUQpyMjY01cleMM7S1D64ONszbE46Uhna/YM2qNKNOxTqsD1+v2zbqONw4AwmXYW13lRAVRXkkbAjfgJWwoo9vH5PbSimZ910Erg42DGtTs+gGpcSYZBiP7gguVyUMjxi1pJQXyB7lNQXOA9fIvkJ0YU6VmELaZgKbAe+cJGqozgopZTMpZTM3N7ei9sMk9tZWjA2qw/GLcfx4zrREK4RgoN9AwuPCOR17+t8Vl45A7j2ImWnZrxVFUR5i99Pvs+P8Djr4dMDN3vTv4R8jYjl+KY6xQXWwtzbfZSTGJMO/yD5vmF994GxRjaWUWwCvnPp1pJRNAQcgSkp5pYjmuaNP04ZmJaR/8+pUd7Hngz0RZGWZFkK3Wt1w1DiyPnz9v4U+ASBy3nJL6+zXiqIoD7FvLnzDvfR7vOT3kslts7Ik8/aEU6OyPQNaGHXreqkxJhnuBFoKIWrlFgghfIDWOeuKJKXMlFL+LaX8RwhRFegPLC2sTc6Vpn2BK1LK68Zsp6RZW1kwvqMvf8fcZdcf10xqa6+xp0edHuy7tI/Y+zkjy2otoEpDqFgDhuzMfq0oivKQklISGh6Kv4s/jdwamdx+5+lrhF+/x/iO9dBYmveBaMZs/TPgErBDCNFDCNEd2AFEActzKwkhagghMoQQ7+Yp0wghFgohegoh2gkh3iT7POBfwII89QYKITYIIQYLIZ4TQgwADpJ9eHViCexnsb3wZFX8PBxZsPccaRmmPWZtgN8AMmQGX0d+/W+hjRM4V1OJUFGUh97JGyc5n3CegX4DEcKYy0j+lZaRxYJ9ETSo6kS3JwyeCStTRSbDnPsC2wHngC+Ar4CLQDspZd4pGgRgma9PSfbTapYD3wH/AT4HOkkp895ycRFwB+YDe3PqpwKdpZQbirVnJcTCQjCxsx9X4u6z8WSUSW1rONWgtVdrNkdsJj2r7B88qyiKUppCw0NxtnGmS80uJrdd/+tlouKSebuzHxYWpiXS0mDU2cqcc3u9i6hziXxXmEopM8h+4kxR/R8jO+GWS23rudHCx4VP9kfSu4mXSSd5X/J7iVH7R7H/8n461+xcilEqiqKUnetJ1zlw5QCD6w/G1srWpLaJqRn878B5nqlVmWfrupZShKZRs1YYQQjB253rEXsvldU/XzKpbeuqrfF28FbPK1UU5ZGyKWITWTKLfvX6mdx21ZGL3E5K4+3O9Uw+vFpaVDI0UjMfF9r7u7Ps0D8k3Df0UB3DLC0sGeA3gLCbYYTHhZdihIqiKGUjLTONLZFbCKwWiLejt0ltbyemsuLwP3Ru4EHj6kU9t6XsqGRoggmd6pGYmsHSQ/+Y1K5nnZ7YWtqyIdyspz8VRVFKxPeXvicuJa5YzyFdfPA8yemZTOhUrxQiKz6VDE3g5+FEr6e8WPPzJa7fMf65o842zjxf63l2X9jNHTJLMUJFUZTStyF8Az5OPrT0bGlSu6i4+3x17Ap9m1ajjrtDKUVXPCoZmui/HXzJkpJF+02b4mmg30BSMlPYTlIpRaYoilLKUu9y/c5FxNUTDPAbgIUwLYUs/OEcQsB/OtQtpQCLTyVDE1VzsSf46RpsOhnFP7GJRTfIUc+lHk3cm7BBJJJpngfqKIqiFF/Os5XdEqJZef0mvWy8TGoefv0u236PJqSVD57OZT9FU1FUMiyG0e3qYGNlwUd7z5nUbqD/QK6KDH5CTe2kKMpD5tIRpMzCEtBIsI/+zaTmH34fgYONFSPa5p+5r3xQybAYXB1sGB5Qi91/xvDH1QSj2wVVD8JdWrJO3C3F6BRFUUqBTwAZQpABCCvTnq184lIcP/x9kzcCa1PR3jxTNBVFJcNiejWgJpXsNcz/3vgJgDUWGgZLR46LVH67YdpfVYqiKOZ0r4o/o6pU4duKrlgM+cboR0pmT9EUjrujDcNam2+KpqKoZFhMjrYaRj1XhyORt/j5/C2j2/XDARdpwdLThT6nXFEUpVz56u+vOGpnTR3nWiY9W/lA+E1OXo5nTFBd7KwtSzHCB6OS4QN4uWUNqjrb8oEJEwDbYcEw6cSvMb8SdiOslCNUFEV5cPfS7rHu7DraSjvqY/xhzswsyQd7IqjpWoH+zauVYoQPTiXDB2CrseQ/HXw5ffUO3/9l/CxT/XDAxdZFjQ4VRXkorP97PffS7jFCOpvUbvvv0UTcuMf4jr5mn6KpKOU7uofAi429qOPuwPzvI8jING6KJzssGNZwGMdijqnRoaIo5Zp2VOjd1qRRYWpGJh/tO0dDLye6NjRxiqbVz2cvZUglwwdkZWnBhI71+Cc2ia1h0Ua36+vbV40OFUUp99b/vZ67aXd546k3TGr31bErRCckM7GcTNFUFJUMS0CnBlVoVK0iC384R0q6cY9bs9fYq9GhoijlWt5RYYPKDYxvl5LO4oPnaV2nMgF13UoxwpKjkmEJEEIwsXM9Yu6k8OWxy0a3U6NDRVHKs+KOCj87cpG4pDTe7uRXSpGVPJUMS0ir2q486+vG4oPnuZti3Kz2eUeHv9/8vZQjVBRFMV5iWmKxRoW3ElNZeeQCXZ/woFG1iqUYYclSybAEvd2pHgn30/ns8AWj22hHh6fU6FBRlPJjfXjxRoWLD5wnNSOL8R3L1xRNRVHJsAQ19HKm25OerDxykdh7qUa1sdfYM7TBUI7GHFWjQ0VRyoXEtETW/rWWQO9Ak0aFV27f56tfL9OvmTe13crXFE1FUcmwhI3vWI+0zCwWHzB+iqd+9fqp0aGiKOVG7qhwRKMRJrVb+MM5LIRgbJBvKUVWelQyLGG5T1pYf/wKV27fN6qNGh0qilJe6IwKXY0fFf4dc5ftp6IZ2romHs62pRhh6VDJsBSMDaqLhRAs/MH4KZ7U6FBRlPKguKPCD/aE42hjxYjA8jlFU1FUMiwFVZxsGdq6JttPRfN3jHHTNeUdHZ66eaqUI1QURdGXewWpqaPCXy/c5mBELCPa1sHZXlOKEZYelQxLyYjA2jjaWPGhCVM8aUeH6r5DRVHMIDQ8lDupd0waFUopmbcnnCpONoS08im94EqZSoalxNlewxtta7M//CYnLsUZ1cZeY09IgxB+ufaLGh0qilKmEtMSWXt2Lc96P2vSqHDf2RuEXUlgbJBvuZ6iqSgqGZaioa1q4u5ow7zvjJ/iqX+9/lSyqaRGh4qilKnijAozsyTzv4+glmsF+jXzLsXoSp9KhqXIztqSMUF1OXk5noMRN41qY6+xZ2jDoWp0qChKmck7Kmzo2tDodlvDrhJ5M5EJnephVc6naCrKwx39Q6B/82rUqGzPB3siyMpSo0NFUcqf4owKU9IzWbjvHE96O9OloUcpRlc2VDIsZRpLC8Z3rEf49XvsOG3cFE/2GntCGqpzh0oxmGEeOOXhlpSexNqzawnwCjBpVPjlsctcu5PCxM5+CFH+p2gqikqGZaDbE540qOrEgr3nSJPGveUD6g2gkk0llp1eVsrRKYryOCvOqPBuSjpLDp4noK4rreu4lmJ0ZUclwzJgYSF4u7MfV+OTCU2ob1Sb3NHhz9d+VqNDRVFKRVJ6Emv+WkOAVwBPuD1hdHRgPN0AACAASURBVLvPDl8g/n76QzVFU1FUMiwjz9Z1pWUtF/53uxlJWVZGtVGjQ0VRSlNxRoU3M+xYeeQizz/pyRPezqUYXdkyKhkKIaoJIb4WQtwRQtwVQmwVQlQ3sm3NnLYJQogkIcRBIUQzA/UshBD/J4S4JIRIEUKcFkL0NnWHyishskeHtzLtWRn3lFFt8o4OT8eeLuUIFUV5nBR3VLj4djPSMrOY8JBN0VSUIpOhEMIeOAD4AUOAQUBd4KAQokIRbSsDPwENgdeBATmrDgoh/PNVnwVMBxYDXYBjwGYhRFdjd6a8a1K9El0c/mFpXGOjH+KdOzpUV5YqilKSijMqvJzmxPqE+vRvXo2aroV+/T90jBkZvgrUAnpKKbdLKXcA3YEaZCe4wowAqgDdpJQbpZS7gG7AfWBGbiUhhDswAZgrpfxQSnlQSvk6cBCYa+pOlWfvuv+ElZBM2f6nUTfi22vsGdJgCD9Hq9GhoiglIyk9ibV/raWNVxujR4VSSmbcbINGZDE2qG4pR1j2jEmG3YFjUsrzuQVSyovAz0CPItq2BCLztU0CjgDdhBC5J886AdbAl/nafwk8IYSoaUScDwVPTRITXH/lSOQtdp6+ZlSbgX4DqWhTUY0OFUUpEaHhoSSkJpg0Kvz2z+scSPJhvOtxqjg9fFM0FcWYZNgAOGOg/C+gqEsjM4E0A+WpgB2QO9dHg5yy8/nq/ZXz07hLMB8SgyqeoVG1isz65iwJ9w29Pbpyn1mqRoeKojyovKPCJ92eNKrNneR0pu/6i4Y2Nwmp9EcpR2gexiRDFyDeQHkcUKmIthFA3Zxzh0D2hTJAizx95/5MkPrHDePy1XskWArJ+70aEn8/nbnfhRvVRo0OFUUpCcUZFc7bE87txFTmevyIlTDuSVoPG2NvrTC098Y8cmBZzjbWCSFqCyE8gU+A3MOeWXn6MnkbQojXhBAnhRAnY2NjjQin/GhQ1ZlX2tRkw4kojl8selaLvOcO/4h9NP8yUxSldN1Pv8/av9bS2qu10aPCE5fiWP/rFYa1rklD21ulHKH5GJMM4zE8MquE4RGjlpTyAhAMNCX7EOg14BlgYU6VmJyfcUAlof9Mn0p51hvqf4WU8v/bu++4Ksv/j+OvD1twIYKT4cCNe5u5KkdlmZUNzWzbVPtWrsYvNXOkZcMcmZlNy9L21DRz5BZUXKC4QXCB7Ov3xzkY4kEOMg5wPs/H4zyQ+1z3uT/nFs6b676v677bGmPa+vv75/U+SpwR14VSq3I5xizdTkp6Rp7ttXeolCqI/PYKU9IzGLN0B7Uql2Pk9Q2KuDrHsicMI7Cc08upCbAzr5WNMV8Dtazt6xtj2gDlgRhjzKFs2/Dkv3OI2beBPdspjbw93Jg4oBn7YxOZ89eBPNv7uPswtOlQ/j7yt/YOlVL5kpSWxMKIhXSp1YUW/i3sWmfOXwfYd/I8E29tho+nfRcLKa3sCcPlQEcRqZu1QERCgC7W5/JkjMkwxuwyxuwXkZrAICB79+ZnLANt7s2x6mAg3Dp6tUzq0TCAm5rX4J0V+zgQez7P9to7VErZNOwHyyMX+e0V7o89zzt/7uPG5jXo0SigsKossewJw3lANLBMRG4Rkf7AMiAGmJPVSESCRSRdRF7KtsxdRGaKyK0i0lNEngI2YukJvpHVzhhzEsuh0zEiMkpEuovIbKAnMLbgb7Nke+nmJni6uTDum/A85x5q71AplV/57RUaYxi7dAee7i68fHOZGsyfqzzD0DovsCewB/gY+ASIAnoaY7J3ZQRwzfGaBsvVauYAPwEjgAVAb2NMzjkF44CJwDPAL1h6nndaJ+qXaQEVvBjdtxFrD5zi68153+bp7kZ3U8mzkvYOlVJ2yW+vcMnGw6yPimdsv8YEVCh7cwptsesgsPXc3hWvE2qMiSbH6E9jTDqWK87Ys40MLGE40Z72Zc3d7YL4ZvMRJv2wk56NAqji45FrWx93H+5vej9vbX6LHbE78nVdQaWUc7k4grSmfb3CuPMpTPpxF+1CfBnUNrAYKiwZ9K4VJYSLi/DabWGcT0ln4g95jxfS3qFSyh6fR35OQkoCj7V4zK72E77fSVJqOpNvC8PFpfTftNdeGoYlSINqFXj02nos3XyENfuuPJ8nq3e4+shqdsTuKKYKlVKlSVJaEgvDF9KlZhdaBuR9t5yVkSdZtvUow7vXp35AhWKosOTQMCxhnuxZnxA/b8Z9s4PktCvPPdTeoVLqSvLTK0xKTWf8t+HU9ffh8e45Z7mVfRqGJYyXuyuTBoQRfSqJd1fkvFTrpXzcfRjaZKj2DpVSl8nqFXau2dmuXuFbv+/lcMIFXhsQhpe7azFUWLJoGJZAXepX5bZWtXj/r/3sPXHuim21d6iUsiWrV2jPCNKIo2eY/3cUg9oG0rGuX+4N85jLWJppGJZQ425sjI+nG2OW7iAzM/e5h+U9yl/sHYbH2bq5iFLK2eSnV5iRaRizdAe+3u6M6deomCoseTQMSyi/8p6M7deYjQcT+GJjzBXbau9QKZXdF5Ff2N0rXLQ2mu2Hz/DiTU2o7J37lK6yTsOwBLujTW061q3C5B93cfJccq7tsnqHqw6v0t6hUk4uKS2JD8M/tKtXeOT0Bab9Ekm3Bv70b1GzmCosmTQMSzARYdKAMJLTMpnw/a4rtr270d1U9KiovUOlnJy9vUJjDC8vC8cYmHhrMy6/aZBz0TAs4er5l+eJHvX5bttRVkaezLVdeY/yDG2qvUOlnFlWr7BTjU559gp/Dj/O77tOMvL6UAKreBdThSWXhmEp8Fj3utTz92H8t+FcSM197uE9je7R3qFSTuxir7DllXuFZ5PTeHl5BE1qVOSBLnWu2NZZaBiWAp5urrw2IIzDCRd48489ubbL3juMiIsoxgqVUo6WdWeKTjU60Sqg1RXbTv15N3HnU3h9YBhurhoDoGFYanSo68egtoHMXx3FzqNnc22nvUOlnNOXkV8SnxyfZ69wY3Q8i9cd4v7OdWheu3IxVVfyaRiWImP6NaJyOXfGfLODjFzmHmb1Dv86/Bfrj60v5gqVUo4QnxzP/PD5efYKU9MzGbN0BzUrefHsDQ2KscKST8OwFKns7cGLNzVhW8xpPll/MNd29zW5j1rlazFp/STSMtKKsUKllCPM3DSTxNREnm/3/BXbzV21n70nz/PqLc3w8bTrDn5OQ8OwlLmlZU26hlZl6s+RHD9je+6hl5sXYzuMJepMFB/t/KiYK1RKFafNJzbz7b5vGdJ0CPV96+fa7kDseWb9uY8bw2pwXZNqxVhh6aBhWMqICBNvbUZaRiavLM99kMy1ta+lV1Av5mybw5HzR4qxQqVUcUnLTGPCuglU96nOY81zvzOFMYZx34Tj6ebCyzc3KcYKSw8Nw1Io2M+HZ64L5eeI4/y280Su7V5o9wIiwusbXi/G6pRSxeXTXZ+y7/Q+Rrcbjbd77nMFv9p0mLUHTjG6byMCKnoVY4Wlh4ZhKfVw17o0rFaBl5aFcz4l3WabGuVr8FiLx1gZs5IVh1YUc4VKqaJ0PPE47219j661utIzqGeu7U6dT2HSj7toG+zL3e2CirHC0kXDsJRyd3XhtdvCOH42mRm/5j73cEiTIdSrVI/XN7xOUlpSMVaolCpKU/+dSobJYEyHMVe8lNrEH3aRmJLOa7eF4eLi3JdcuxINw1KsTbAv93YIYuE/Uew4fMZmG3cXd8Z3HM/RxKPM2zGvmCtUShWFv4/8zW8Hf+PhsIcJrBCYa7vVe2P5ZssRhnerR4NqFYqxwtJHw7C4FfLNMZ/v04iq5T0ZvXQ76RmZNtu0rd6W/vX6szBiIQdOHyi0bSulil9KRgqvrX+N4IrBDGs2LNd2F1IzGPdNOHWr+vB4j9xHmSoLDcNSrqKXO6/0b0rE0bMs/Cc613aj2oyinFs5Jq2fhDG53yxYKVWyLdixgJhzMYztMBYP19zvP/jWH3s5FJ/EpAFheLm7FmOFpZOGYRnQt1l1ejYKYMZvezhy+oLNNn7l/BjRegQbjm/gh6jC65kqpYrPobOHmL9jPn1C+tC5Zudc2+06dpZ5qw9wR5vadKrnV4wVll4ahmWAiPDqLU0xBl76NjzXnt/A0IE082vG9H+nczY19+ubKqVKHmMMr61/DXdXd55r91yu7TIyDaOX7qByOXfG9mtcjBWWbhqGZURtX2+evaEBf+w+yU/hx222cXVxZXyn8cQnx/POlneKuUKlVEH8dvA31hxdw5MtnyTAOyDXdovXHWRbzGleurkJvj65H0Yt0VLOwpkYiNlQbJvUMCxD7u8cQtOaFXlleQRnk21fk7SpX1MGNRzEF5FfEHFKb/OkVGmQmJbIlH+n0NC3IXc1uivXdkdPX2Dqz7vpGlqV/i1qFmOFhShmA5wIh9MH4aP+xRaIGoZliJurC5NvCyPufArTfo7Mtd1TrZ/C19OXiWsnkpGZ+82ClVIlw+ytszmZdJLxHcfj5pL7BbZfXh5BhjFMujXsinMPS7To1WCsI+MzUi3fFwMNwzKmee3KDO0cwsfrDrIi8qTNNhU9KvK/dv8j/FQ4X+/9upgrVErlR2R8JIt3LWZg6EBaBrTMtd3P4ZbLM464rgFBfrlfmq3EC+kKYo0mVw/L98VAw7AMeqFPIxpVr8DIL7ZyOMH2VWdurHMj7aq3483Nb3LqwqlirlApZY9Mk8nEdROp4FGBEa1H5NruxNlkxn+7g8Y1KvLgNXWKscIiENgeqjWDysEwdLnl+2KgYVgGebm78v7gNmRkGJ74dAsp6ZcfChURxncYz4W0C8zYNMMBVSql8rJs3zK2xm5lVJtRVPayfVf6tIxMnvhkM0mpGcy6qyXurmXgY92zIlQKLLYgBA3DMiukqg/T7mjBtpjTvPbDLptt6lauy9CmQ1m+fzkbj28s5gqVUldyOvk0MzbNoKV/S26pf0uu7V7/aTcbDybw+sDmhOol166ahmEZ1qdZdR7uWoeP1h5k+bajNts82uJRavrUZNL6SaRl2h6BqpQqfm9ufpNzqecY33E8LmL7o/rHHcf44O8o7u8cUnpHj5YQdoWhiASKyFcickZEzorIUhGx614gIhIkIh+JyCERSRKRPSIyUUR8crRbKSLGxiP3A+UqT8/3aUS7EF9Gf72dfSfPXfZ8ObdyjG4/mn2n97F452IHVKiUymlb7Da+3vs19za+l4ZVGtpssz/2PM8t2UaroMo6ub4Q5BmGIuIN/Ak0AoYCQ4BQYEXOQLOxrg/wO3At8CJwIzAfeBZYYGOV7UCnHI/P7XwvygZ3Vxfeuac13h6uPLZ4M4k27n3YI6gH3Wt3Z/a22RxPtD1hXylVPNIz05m4biIB5QJ4vOXjNtskpaYzfPEmPN1defee1ni46UG+grJnDz4M1AVuNcZ8a4xZBvQHgoFH81i3C5bgfNQY85ExZoUxZirwFjDQGrTZnTPGrMvx0E/nAqpW0Yu37mrFgdjzjFm6w+bl2kZ3GI0xhikbpjigQqVUli8iv2B3/G6eb/88Pu6X9zeMMYxZuoO9J88z665W1KxczgFVlj32hGF/YJ0xZl/WAmNMFLAGyP2srkXWtYByXgjztHXbpXRWaOnTpX5VRl3fgOXbjrJ4/aHLnq9VvhaPtniU3w/9zqrDqxxQoVIqNimWt7e8TZeaXbgh+AabbRavO8iyrUcZdV0DrgmtWswVll32hGFTINzG8gigSR7r/g7sBaaISBMRKS8iPYFngPeNMYk52reynpdME5HtIvKgHfUpOz3evT49Gvoz4budbIs5fdnzQ5sMpU6lOkxeP5nk9GQHVKiUc5v27zTSMtIY22GszSvIbI05zavf76RHQ3+e0HsUFip7wrAKkGBjeTzge6UVjTHJwDXW7UQA54A/gO+BJ3M0XwWMwNITvR1LiM4XkfG5vb6IPCIiG0VkY2xsrB1vxbm5uAgzB7XEv4Inj3+ymYTE1Eued3d1Z1yHcRw+f5j5O+Y7qEqlnNPao2v5KfonHgx7kKCKl49PjE9M5fHFm6hW0YuZg1ri4qIH1gqTvWddbd0TKM//CRHxAr4AArAMvOkGPAcMAt69ZAPGvGSMmWeM+csYs8wYMxD4FhgnIuVtFmXMXGNMW2NMW39/fzvfinOr7O3Be/e2JvZcCiO/3Epm5qX/tR1qdKBfnX4sCF9A9JloxxSplJNJzUjltfWvEVghkAfDLj8glpFpeObzLcSdT2X2vW2o7F1K70ZRgtkThglYeoc5+WK7x5jdg0B3oJ8xZrExZpUxZjqW0aSPiUiLPNb/DPACwuyoU9mpRWBlXry5CSsjY3lv5b7Lnn+u3XN4unoyaf2kXO+NqJQqPAsjFhJ9NpqxHcbi6ep52fOz/tjL6r1x/N8tTQmrXckBFZZ99oRhBJbzhjk1AXbmsW4YkGCM2Z9jedY9OfKaHJPV+9RP5EI2uEMQt7SsyYzf9rBmX9wlz1UtV5WnWj3FumPr+CX6FwdVqJRziDkXw9ztc7k++HquqXXNZc+vjDzJrD/3MrB1be5qF+iACp2DPWG4HOgoInWzFohICJZpE8vzWPc44CsiOc/0drB+PZLH+vcAF4AddtSp8kFEeG1AGPX8y/P0Z1s4fubSATODGg6icZXGTP13KudTzzuoSqXKNmMMk9dPxkVceL7d85c9fzghiRFfbKVhtQpMvLVZ6b0tUylgTxjOA6KBZSJyi4j0B5YBMcCcrEYiEiwi6SLyUrZ1F2IZNPOjiAwVkR4i8hwwHdiEZXoGItJVRH4QkQdFpJeI3CYiWfMZ/8/GqFNVCHw83Zg9uDUX0jJ48tPNpGVkXnzO1cWVFzu+SNyFON7d+u4VXkUpdbX+jPmT1UdW80TLJ6juU/2S51LSM3j8k81kZBjeH9yGch6uDqrSOeQZhtYg6gnsAT4GPgGigJ7GmOxdBgFcs7+mMSYa6AhsBSYCP2KZxD8XuN6YrDs4csy63qvWNosAf+AeY4zOAi9C9QMq8PrA5mw8mMCUn3Zf8lyYfxh3NLiDT3d/yu743bm8gipRUs7CmZhiuzt4kfrwRsujjEpKS+L1Da8T6hvKPY3vuez5Cd/vZPvhM0y/swUhVa94sS9VCHK/ZXI2xphDwMA82kRjY4SpMWYncGce6+4D+tpTiyp8/VvUZFN0PPP/jqJtiC99mtW4+NzTrZ/m90O/M3HdRBb1XZTrBYNVCRCzAU6EW+4S/lH/Yr0XnMq/OdvncDzxOFO6TsHdxf2S55ZuPszidYd4tFtdejetnssrqMKkn2wKgLE3NqZFYGWeW7KdqLj/jkpX8qzEqDaj2Ba7jW/2fuPAClWeoldbghAgI9XyvSqR9iXsY1HEIm6tfyutq7W+5Lndx88y9psddKhThedusH2RblX4NAwVAJ5urrx7TytcXYXhizdxIfW/GwL3r9ef1gGtmbl5JgnJec2mUQ4T0hWyeu6uHpbvVYljjGHi+ol4u3szss3IS547l5zG8MWbqejlztv3tMKtLNyot5TQPa0uqu3rzZuDWhJ54hwvLfvvCnwiwviO40lMTeTNzW8Wb1Fl/LxRoQpsD9WaQeVgPURagn1/4Hs2ndjEyDYjqeL13xRuYwzPLdnOofgk3rmnNQEVvBxYpfPRMFSX6N4wgKd61GfJpsN8+W/MxeWhvqEMaTKEpXuXsvXkVgdWqK7IsyJUCtQgLKHOpJxh+sbpNK/anNtCb7vkuQ/+juLniOOM7tOI9nVsXedEFSUNQ3WZZ65rwDX1q/LisnAijp65uPyxFo9RzbsaE9ZNID3z8vsiKqWu7O0tb3M65fRld6/fEBXP5J9206dpdR7qWseBFTovDUN1GVcX4a27WuLr7cHjn2zmzIU0ALzdvRndfjR7Evbw6a5PHVylUqVLeFw4X0Z+yd2N7qax338X3zp5LpknPt1MUBVvpt3RXCfWO4iGobLJr7wn797biiMJF3huybaL1yjtFdSLa2pdw7tb3+VE4gkHV6lU6ZCRmcGEdRPwK+fHEy2fuLg8PSOTpz7dwrnkNGYPbk0FL/crvIoqShqGKldtgqswpl9jft15gnmrDwCWwTRjO4wlw2QwbeM0B1eoVOmwZM8Sdp7ayfPtnqeCR4WLy6f9Gsn6qHgm3xZGo+oVHVih0jBUV/RAlxD6NqvOlJ8j2RAVD0BghUAeCnuIX6J/YdXhVQ6uUKmS7XjicWZtnkWHGh3oE9Ln4vJfIo4z568DDO4YxIBWtR1YoQINQ5UHEWHq7c0JquLNk59u5uQ5ywW9H2j2AKG+oYz9eyxHzud1vXWlSqginrqTmpHKsyufJcNkML7D+IvnA6PjEvnfl9toUbsSL97UpMi2r+ynYVgWFfIveAUvd2YPbs3Z5DSe+Wwr6RmZeLh68Gb3N8nMzGTkipEkpyfn/UJKOZkpG6awPW47E6+ZSEilEAAupGbw2OJNuLoK797bGk83vQB3SaBhqOzSqHpFJt4axtoDp5jx2x4AgioGMbnrZHbF72Liuol6I2Clsvl237d8uedLhjUdxvXB1wOWifXjvw0n8sQ53hzUktq+3g6uUmXRMFR2u72N5eai763czx+7LCNJuwV249Hmj7Js/zKW7Fni4Aqvkl7lRhWynad2MmHtBNpXb8/TrZ++uPzzf2P4evNhnu4ZSveGAQ6sUOWkYajy5ZX+TWlasyIjv9hKTHwSAMNbDKdLrS5M3jCZbbHbHFyhUo51Ovk0I1eMxNfLl6nXTsXNxXJzoB2Hz/Dy8giubeDP071CHVylyknDUOWLl7sr793bGgM8/tYXJH/QH1cXV6Z0nUI172qMWjmKUxdOObpMpRwiIzOD0atHE3shlpndZ+JXzg+A00mpDP9kE1V9PHhzUEtcXXRifUmjYajyLdjPhzfuaMGOlABGHLuOtIxMKnlWYmb3mZxJOcNzq57Ty7Upp/TetvdYc3QNYzqMIcw/DIDMTMOoL7dx4mwy7w1uQxUfDwdXqWzRMFRX5Yam1Xkp4G9+Pl+PEZ9bRpg29mvMS51e4t/j//LW5rccXaJSxWrFoRXM3T6XAfUHcHvo7YAlCF/4ejt/7j7JSzc3pWVgZQdXqXJj153ulbLlAd/tZBph4o4uuLgIM+9sQf96/dkeu52FEQtpVrUZvUN6O7pMpYrcwbMHGfv3WJr4NWFcx3GICJmZhtFLt7Nk02Ge6RXKkI7Bji5TXYH2DFWBPFRlG6P7NuK7bUf535JtZGQaXmj3As39m/PimhfZf3q/o0tUqkglpSUxYsUIXF1cmdF9Bp6unmRmGsZ+s4MvNx7m6V6hjLy+gaPLVHnQMFQF9li3ejzXuyHfbj3Kc19tw0XcmNFtBuXcyjFixQjOp553dIlKFQljDK/88wr7T+9natep1Cpfi8xMw7hvd/D5vzE81bM+I6/TkaOlgYahunopZ+FMDMRs4Ike9Rl1fQOWbj7CmKXb8S8XwPRu04k5F8P4NeN1Qr4qkz7Z9Qk/Rf/EU62eonOtztYgDOezDTE80aMeo65voLdkKiU0DNXVidkAJ8Lh9EH4qD/EbODpXqE83SuULzceZty3O2gT0JaRbUbyx6E/WBC+wNEVK1WoNp3YxBsb36BHYA8eDHsQYwwvLgvnsw2HGN69Hv+7oaEGYSmiA2jU1YleDSbT8u+MVMv3ge0ZeV0oGZmZvLtiP64uwqv9hxAeF86sLbNoWrUpHWt0dGzdShWCk0kneXbls9SuUJtJ10xCEF5aFsEn6w/xWLd6PN9bg7C00TBUVyekK4iLJRBdPSzfY7nLxf9uaEhGJrz/135cRXil7yvsTdjL8389zxc3fUGN8jUcXLxSVy8tI41nVz5LUnoS82+YT3n38ry8PIKP1x3k0Wvr8kIfDcLSSA+TqqsT2B6qNYPKwTB0ueV7KxHhhT4NebhrHT5ae5Dpv0Qzo/sMUjNTGblyJCkZKQ4sXKmCmbZxGltjt/Jq51epV7ke//fdThatPcjDXeswum8jDcJSSsNQXT3PilAp8JIgzCIijO3XmGFdQvhwTTSfrUlmUpdJRJyKYPL6yQ4oVqmC+27/d3y2+zOGNBlC75DevPr9Thb+E81D19RhbL/GGoSlmB4mVUVGRHjppiZkZhrmrY7C1aUeDzZ7kA/CPyCsahgDGwx0dIlK2S0yPpJX175Km2ptGNF6BBO+38WHa6J5oEsdxt2oQVjaac9QFSkR4ZX+TRncMYj3/9pPSuz1dKrRidfWv0ZEXISjy1PKLmdSzjBixQgqelRk+rXTmfLTPhasieL+ziG8eJMGYVmgYaiKnIjwav9m3N0+kNkro6mT+Qh+5fwYuXIkCckJji5PqSvKNJmMWT2G40nHeaP7G8xZcZIP/rYE4cs3N9EgLCM0DFWxcHERJt0axp1tazNn5Qk6+Fhu9fT8qufJyMxwdHlK5WrOtjmsPrKa59s+z08bPZm3Oor7OgVrEJYxGoaq2Li4CK/f1pyBrWvz8V8ZdK78MOuOrePtLW87ujSlbFp1eBWzt83m5ro3ExXVgjmrDjC4YxD/179p/oLwwxstD1Vi6QAadfWG/ZDvVVxchKm3NycjM5Nv10CHdtdfHFDTK7hXERSp1NWJORvD6NWjaeDbAJ/zg5i7Kop7OwTxav9m2iMsg+zqGYpIoIh8JSJnROSsiCwVkSA71w0SkY9E5JCIJInIHhGZKCI+Nto+LCK7RSRFRCJF5LH8viFV8rm6CNPvaMHNLWqyfmM3qnmGMm7NOKLORDm6NKUAuJB+gZErRyIITVyfYt5fh7m7fRATbmmGi96lvkzKMwxFxBv4E2gEDAWGAKHACluBlmNdH+B34FrgReBGYD7wLLAgR9uHgTnA10AfYAnwnogMz99bUqWBm6sLM+9swY3NAtkfPpDMDFdGrhhJUlqSo0tTTs4Yw4S1E9iTsId2Pk+yaPV57m4fyKRbNQjLMnsOkz4MdQytTAAAIABJREFU1AUaGmP2AYjIdmAv8Cgw4wrrdsESnL2NMb9al60QkSrA/0TE2xiTJCJuwCTgY2PMuGztagITRGS+MSYt3+9OlWhuri68eVdLMj41/BZ1J8nBC3hxzYtM7zZdD0Mph/k88nO+O/AdrSoM4tt/KjKobSCTbg3TICzj7DlM2h9YlxWEAMaYKGANcEse63pYv57Nsfy0ddtZP12dAH9gcY52HwN+wDV21KlKIXdXF2bd3YqeIV1IPtGbXw/+yqKdixxdlnJSW09uZeqGqQR6tWHVhhbc2bY2k2/TIHQG9oRhUyDcxvIIoEke6/6OpQc5RUSaiEh5EekJPAO8b4xJzLYNbGwna1Z2XttRpZiHmwvv3tOaawJuJ+1sU97YOIN/j//r6LKUk4m7EMeolaPwdqnKzm03cXubIF6/rbkGoZOwJwyrALZmRscDvlda0RiTjKVX54Il2M4BfwDfA0/m2AY2thOf43lVRnm4uTB7cBvalR9ORoofT/4+kuOJxx1dlnISaZmWO1HEJ5/h2N5BDGwZypSBGoTOxN55hrZuU57nT4mIeAFfAAFYBt50A54DBgHv2nitfN0OXUQeEZGNIrIxNjY2P6uqEsjTzZV5g6+hietTJKZe4P4fniQ1fz8SSl2VmZtmsvnkZs4fHsCtTdoy9fbmuGoQOhV7wjAB2z0zX2z3GLN7EOgO9DPGLDbGrDLGTMcymvQxEWlhbZdbD7BKjucvYYyZa4xpa4xp6+/vn0cpqjTwcnfl4/v6E2we4MiFSIanZTq6JFXG/UQiH+/8mNT4ztxc7yam3dFCg9AJ2ROGEfx3Ti+7JsDOPNYNAxKMMftzLN9g/do42zawsZ2sc4V5bUeVIV7urnw15DH80m9gg+cRXrxwxRk8qriVoaupRJLKWDlNelIwN1R/iOkahE7LnjBcDnQUkbpZC0QkBMu0ieV5rHsc8BWR+jmWd7B+PWL9uhaIA+7N0W4wll7hGjvqVGVIOQ9Xlt87CZ8LtfnGezf3fvEWF1L1Gqaq8Gw+sZV7iCc13ZtrKz3LzDvbaBA6MXvCcB4QDSwTkVtEpD+wDIjBMkkeABEJFpF0EXkp27oLsQya+VFEhopIDxF5DpgObMIactY5hC8CQ61Xp+kuIq8CDwAvGWNSC/pGVelT0cuLXzxcqJlaje3J8+n5wXh2HTvj6LJUGfD1zt+5/6cHaZjowusnKvJul3K4ueqlmkuMYT9c1eUeCyLP/33r9IeewB4s8/4+AaKAnsaY89maCuCa/TWNMdFAR2ArMBH4Ecsk/rnA9caYzGxt3weGA3cCvwB3A08aY7IPtFFOppLAD+7utK96Pee9v2fgl8+z6J8DGKMDa1T+GWN46Y9FvLzhWZqf92RR3H5uTluL28e3QsyGvF9AlVl2XajbGHMIuOJtya3Bd9kxBmPMTiwBZ8925pCtt6kUgDvCvH7TmbR2Gl/uXcxrG1/kr71PMv32Nvj6eOT9AkoBZy6kMfTr6ezP+BSfzAa8Wb8Fblk3mM5IhejVENjesUUqh9HjAqpUcBEXXuz8AiNbj8S90nbWJk6lz6zfWLv/lKNLU6XAhqhT9FzwHPszPqVuuU6sGPIJVZv2AbF+BLp6QEhXxxapHErDUJUqD4Q9wMQuE3EvH0Wq/3vc8+HvvPFrJOkZOgVDXS49I5M3ft3Ffcv/R2r5P+hZ8xaW3j4bb3cvSy+wWjOoHAxDlxdtrzDlLJyJ0UOxJZiGoSp1bql/C7N6vIWr10kCGsznndUbGDR3HTHxescL9Z+Y+CTumLuK+Xtexr3yRh5o+ghvXjcBVxfX/xp5VoRKgUUbhDEb4EQ4nD4IH/XXQCyhNAxVqdQtsBvzb5iHq3siNRrNJzI+kn6zVvPD9mOOLk2VAMu3HaXf27+wz+UN3CvsZlyHcYxs+5Rj7oYSvRqyxgpmnZtUJY6GoSq1Wga0ZFGfRZTzcKN8yFxqVjvGE59uZvTX20lKTXd0ecoBzqekM+rLrTyzZCUeQe/j5n2Ead2mcVejuxxXVEhXPTdZCmgYqlKtvm99FvddjL93VU5VeIebO8bzxcYYbn77b3YezXnnMFWWbY05zY2zVrMsYivVG83HzeM07183m94hvR1bWHGem1RXTcNQlXo1ytdgUd9FNPBtwKqz0xl+0ynOJadz67tr+HBNlM5JLOMyMg3vrtjH7bP/IcUlmoCG8/Fwz2BBnwV0qNEh7xcoDsVxblIViIahKhN8vXyZf8N8OtXoxMf7pjG4z366hPrxf9/t5KGPNnLqfIqjS1RF4OjpC9wzbx3TfomkfZM4MqvPppJneRb1XURTP1uXVFbKNg1DVWZ4u3vzds+36VenH/PC36FRkxW8fFMjVu+No+9bq/lnX5yjS1SF6OfwY/R9azU7jpzh/usT2GVmElghkI/7fkxwxWBHl6dKGQ1DVaa4u7ozuetkBjcezOJdi9mdOZevhrengpcb936wnqk/7yZN5ySWDrnMzUtKTWfM0u08tngzwX7ePHbzUb4+PIUW/i1Y2Gch/t56OzeVf3Zdjk0ph0k5C8lnLB+Idp5vcREXnm/3PH7l/Hhr81ucSTnDF49NZfrP0by3cj//7D/FrLtaEeTnXcTFq6uWNTfPZFrm5lkHnoQfOcPTn28hKi6Rx7rVxcv/N+ZFzKNnYE+mdpuKp6unoytXpZT2DFXJVYDJyiLCQ2EP8X+d/4+1x9by9MrHeOHGQN65pxX7Y8/Tb9Zqlm09kvcLKcfIMTcvM2o181YdYMB7a0hKyWDRg21JrvQFH0TMY2DoQN7o/oYGoSoQDUNVchXCZOXbQm/jze5vsidhD/f9dB9t6go/Pt2VBtXK88znW/nfkm0kZuoBkhIn29w84+rOhPAqTPpxFz0aBvDtk+356tBrfL33ax5p/ggvd3oZNxf9P1QFo2GoSq5CmqzcI6gHc66fw6kLpxj802BS5ChfPtqJp3vW5+vNh7kp+k7Ck6sWYuGqwKxz8/Z5t2BY5ot8dqw6rw0IY9qgUEb/8xQrYlYwuv1onmrloKvKqDJHw1CVXIU4WblNtTYs7LsQYwxDfx5K+KntjLqhIZ8+1JELxo1bDt7OU59tYcuhhEJ8A+pqHYg9zwsJ/bku/gVOVGrB909dw/Vh5XjglwfYFruNKddO4d7G9zq6TFWGaBiqkq0QJys38G3Ax/0+xtfLl4d/fZhVh1fRqZ4fP4V8wQO+21kZeZIB7/3DgPfW8N22ozrqtJhlZhpWRp7k/g830PONv1h6piEP+27l2yc64+4Vz5CfhhBzLoZ3e71L3zp9HV2uKmM0DJVTqVW+Fov6LqJe5Xo8/efTLNu3DF/XFMYF/MPaMb34v/5NSUhM5anPtnDt1BXMXrmf00mpji67TDuXnMbCNVFcN+Mv7v/wXyKOnmXU9Q34p94ixgX8w/4zkdz3030kpSWxoPcCOtfs7OiSVRmkZ52V06niVYUPen/AiBUjGL9mPPFUZhgVKe/pxtDOIQzpGMyKyJN8uCaaKT/v5q0/9jCwdW2GdQmhfkAFR5dfZkTFJfLRP9F8tekw51PSaRVUmbfuaknfZjXwcHOBQxdYTzLP/PIAlTwqMef6OYRUCnF02aqM0jBUTsnH3Yf3er3H2L/HMiP6Z+JMBiMy0nB3dcfFRejVuBq9Gldj9/GzLFwTzZJNh/lk/SGubeDPA11CuDbUHxeXEjhwY9gPjq7gijIzDav3xbFwTRQrImNxdxVual6ToZ1DaBlY+WI7Yww/ksiLcopgn/rMuX4OAd4BDqxclXUahsppubu6M+XaKYTt+pX4lMOM/rQnN3Qdzw3BN1wcodioekVeH9ic53o35LMNh1i09iD3f/gv9fx9GNalDre1roW3h/4a5eV8SjpLNx9m4T/RHIhNpGp5T0ZcF8o9HYIIqOB1SduIuAhmbJrBBpdTtDaezOqzkEqelRxUuXIW+lusnJrL4Y0MOXEITCapp8N5MOkpFtVux8g2I2lbve3Fdn7lPXmyZyiPXFuPH3cc44O/oxj/bTjTfonk7vZB3NcpmJqVyznwnZRM0XGJfLQ2mq82HuZcSjotAyvz5qCW9AuzHgrNJuZcDG9vfpufon/C19OXMZm+3EF53DUIVTHQMFTOLXo1Yp3Y74EwJqArTydFM+yXYXQP7M7I1iOpW7nuxeYebi7c2qoWt7SsyaaDCSxYE8XcVfuZt/oAfZtV54Fr6tA6yNdR76ZEMMawem8cC/+JZkXkSdxchBvDajC0cwitbOyb08mnmbN9Dp9Hfo6buPFI80cY1nQY5T8Z5IDqi0gJP3ytNAyVs8ua2G8yEVcPmrZ9lO9rhPHJrk/4YMcHDFg+gNtCb+PxFo9fcgFoEaFtSBXahlThcEISi9Ye5LMNh/h++zFaBlbmgWvq0LdZddxdnWfAdtah0I/+iWa/9VDo0z1DubdDEAEVvS5rn5yefHE/J6YnMqD+AIa3GE41n2oOqF45Ow1D5dyyJvYnn4GB8yGwPeWAh8IeYmDoQOZun8vnkZ/zw4EfuK/JfQxrNgwfd59LXqK2rzdj+zXmmV6hfL35MAvXRPP0Z1uoXtGLIZ2Cuad9EL4+Ho55f8UgOi6RRWsPsmRjDOdS0mlRuxJvDmpJ37DqeLq5XtY+IzOD7w58xztb3uFE0gm61e7GiNYjqO9b3wHVK2WhYaiUZ0XLI8fEfl8vX15o/wL3NLqHWVtmMWf7HJbsWcLwFsMZ2GAg7i7ul7T38XTjvk4hDO4QzF97YlmwJoppv0Ty9p97GdCqNg90CSG0WtmYmmEM/L03loVrovkz8iSuItzYvAb353Io1LKOYc3RNczYNIO9CXtp5teMyV0n0656u2KuXqnLaRiWRVdx2yOVu8CKgUzrNo37mtzHjE0zmLR+Eot3LeaZ1s9wXdB1l10b08VF6NEogB6NAog8fo6F/0SxdPNhPttwiFqVy1HX34c6Vf971K1anlq+5XAtgVM1jDEkJKURfSqRg6cSiY5L4tCxXmy7EMCBPRuoWt6Dp6yHQqvZOBSaZeepnczYNIP1x9ZTu3xtpnWbRu/g3npdUVViaBiWNbncB04VXJh/GAt6L2DV4VXM3DSTUStH0cK/BaPajKJ1tdY212lYvQKTb2vOc70b8fWmw0QcPUNUXCLfbD7CuZT0i+08XF0I8vO2hmO2sPT3wb+8Z5GGhjGG2HMpHIxPIjoukYOnkqzhZ/l6Lvm/OkWgpmsN6nqc5skB3bmxeQ2bh0KzHDl/hLe3vM0PB36gsmdlRrcfzZ0N7sTd1T3XdZRyBA3DssbWbY80DAuNiNAtsBtdanVh2b5lvLv1XYb+PJSegT15ps0z1K1U1+Z6VXw8ePja/54zxnAqMZWouESiYhM5EJdIVNx5ouIS+WtPLKnp/10Xtbyn26U9SWvPMqSqDxW97AuVzEzD8bPJl4TcwTjL10PxSSSlZlxs6+oiBPqWI9jPh1ZBlQn28yHEz5tgPx8Cq5TD8+P+loath+e6vTMpZ5i7fS6f7f4MF3HhobCHeKDZA1TwKBuHiVXZo2FY1mQbHVmQ2x6pK3NzcWNgg4H0rdOXxbsWsyB8Abctu42BoQMZ3nI4Vctd+ZZQIkLV8p5ULe9Ju5AqlzyXkWk4evqCJSitjwNxiWyJSeC77Ucx5r+2Vct7/teTtIakl7srh04lEn0qiYPW8DsYn3RJwHq4uhBYpRwhfj50rleVkKreF0OvZuVyVz0KNiUjhU93fcq8HfM4n3qeW+vfyuMtH6e6T/Wrej2liouGYVljY3SkKjre7t480vwRBoYOtAywiVzCdwe+4/6m93N/0/vxdvfO92u6ugiBVbwJrOLNtQ38L3kuOS2DmPgka0/S0quMikvkj90niduYcklbL3cXgqtYArJHowCC/bwJ8fMh2M+bGpUK9xxlpsnkhwM/8PaWtzmWeIyutboyos0IGvg2KLRtKFWUNAzLolxGR6qi41fOj7EdxnJv43uZtXkWs7fN5svIL3m85eMMCB1gGXn64Y2WxgWYgO3l7kpotQo2R6WeTU4jOi6RpNQMQvx8CKjgWSzXT/3n6D/M2DiDyIRImvg1YUKXCXSo0aHIt6tUYdIwVKoQBVcM5o3ub7AtdhszNs5gwroJfLzzY0a0GUFPDELRhVNFL3ea166cd8NCsjt+NzM2zmDtsbXUKl+LKV2n0KdOH1zEeS40oMoOu35qRSRQRL4SkTMiclZElopIkB3rvSIiJpdHco620bm0u/Vq35xSjtLCvwUL+yxkVo9ZiAgjVozgPjnBEs6zLXYbSWlJji4x39Iy09ibsJfvSeQFiePO7+5kZ/xOnm/3PMtvXU6/uv00CFWplWfPUES8gT+BFGAoYICJwAoRaW6MSbzC6vOBn3Ms87EuW26j/S/AKzmWReZVo1IlkYjQI6gHXWt35Zt93/D+P5N41SUefhyMIARVDKKBb4OLj4ZVGlLTp2aJmHuXkJxAZEIkkfGR7EnYw56EPew/vZ+0zDRwAS8jDGs2jAfDHqSiR0VHl6tUgdlzmPRhoC7Q0BizD0BEtgN7gUeBGbmtaIw5DBzOvkxEhli3+5GNVeKMMevsK12p0sHNxY07GtzB7Ws+5IjJYE+vF4hMiGRvwl4i4yP5/eDvGCxDRMu7l/8vIKs0oKFvQ+pXrn9VA3HskZaZRvSZaPYk7CEywRp88XuIvRB7sY1/OX8a+DagU5NOltD+6y1CcMe9zcgiqalY6QW0lZU9YdgfWJcVhADGmCgRWQPcwhXCMBdDgRNYeoFKOQ1BqI0btYN60jOo58XlSWlJ7D2995Je2HcHviMxMvHietl7kQ19G9KwSkNq+NTIVy8yq7e3J37PxTDed3qfpbeHJbTrVapHp5qdLumx+pXzu/SF/ppd8J2hVAljTxg2BZbZWB4B3JGfjYlIbaAH8KYxJt1Gk5tFJAlwBbYArxtjvs3PNpQqbbzdvWnh34IW/i0uLss0mRw9f/SS3tru+N38dvC3i20quFcg1Df04iHWhr4NqVe5Hh6uHkSfib64bmRCJHvj93LywsmL61YtV5WGvg0Z3HgwDapYQq9OpTqXXW9VKWdhTxhWARJsLI8H8nvjtiFYBu3YOkT6HfAvEAVUA54EvhGRIcaYxfncjlKlmou4ULtCbWpXqE2voF4XlyelJV3sPe5J2ENkfCTL9y8nKdIyIEcQ3FzcLuvtdazZ8cq9PaWcnL1TK4yNZVdzlv8+YIsxZvtlGzDmqUteXOQbYB0wGbAZhiLyCPAIQFBQnoNblSr1vN29aRnQkpYBLS8uyzSZHDl/5GIP8kL6BUJ9Q2lYpSF1KtbR64AqZQd7wjABS+8wJ19s9xhtEpH2QCNghD3tjTEZIrIEmCIiNYwxx2y0mQvMBWjbtq2twFaqzHMRFwIrBBJYIfCSXqRSyn72TAqKwHLeMKcmwM58bGsokA58mo91snqfGnRKKaWKjD1huBzoKCIXL7kvIiFAF2zPFbyMiHgAdwE/GmNi82pvXccNywCdQ8aY4/aso5RSSl0Ne8JwHhANLBORW0SkP5bRpTHAnKxGIhIsIuki8pKN17gJy6FWWwNnEJG7ReRzEblPRHqIyF3ACqAN8EK+3pFSSimVT3meMzTGJIpIT2Am8DGWQ5d/ACOMMeezNRUsUyJsBexQLKNPv89lM1FAADANS2gmYRlZ2scYo/MRlVJKFSm7RpMaYw4BA/NoE00uI0yNMbfkse46oOeV2iillFJFRa+qq5TKn5SzcCYGYjY4uhKlCo2GoVLKfjEb4EQ4nD4IH/XXQFRlhoahUsp+0avBZFr+nZFq+V6pMkDDUCllv5CukHXPQlcPy/dKlQF6p3ullP0C20O1ZpB8BgbOt3yvVBmgYaiUyh/PipaHBqEqQ/QwqVJKKaenYaiUUsrpaRgqpZRyehqGSimlnJ6GoVJKKaenYaiUUsrpaRgqpZRyehqGSimlnJ6GoVJKKaenYaiUUsrpaRgqpZRyehqGSimlnJ6GoVLFRe8Qr1SJpWGoVHHQO8QrVaJpGCpVHPQO8UqVaBqGShUHvUO8UiWa3txXlWzDfnB0BYVD7xCvVImmYahUcdE7xCtVYmkYKqVKprJyVECVCnrOUCmllNPTMFRKKeX0NAyVUko5PQ1DpZRSTk/DUCmllNPT0aRK6ahFpZye9gyVUko5PQ1DpZRSTs+uMBSRQBH5SkTOiMhZEVkqIkF2rPeKiJhcHsk52rqIyBgRiRaRZBHZJiIDr/aNKaWUUvbK85yhiHgDfwIpwFDAABOBFSLS3BiTeIXV5wM/51jmY122PMfyCcD/gHHAJuAuYImI3GSM+dGO96KUUkpdFXsG0DwM1AUaGmP2AYjIdmAv8CgwI7cVjTGHgcPZl4nIEOt2P8q2LABLEL5ujJluXbxCROoDrwMahkoppYqMPYdJ+wPrsoIQwBgTBawBbrmKbQ4FTgC/ZFvWG/AAFudouxgIE5E6V7EdpZRSyi72hGFTINzG8gigSX42JiK1gR7AJ8aY9BzbSAH25Vglwvo1X9tRSiml8sOeMKwCJNhYHg/45nN7Q6zb/CjH8irAaWOMsbGNrOcvIyKPiMhGEdkYGxubz1KUUkopC3unVuQMKQC5iu3dB2wxxmy38Vr53oYxZq4xpq0xpq2/v/9VlKOUUkrZF4YJ2O6Z+WK7x2iTiLQHGnF5rxCsvUwRyRl+vtmeV0oppYqEPWEYgeWcXk5NgJ352NZQIB34NJdteAL1bGyDfG5HKaWUyhd7wnA50FFE6mYtEJEQoAuXzxW0SUQ8sMwb/NEYY+vk3s9AKnBvjuWDgXDr6FWllFKqSNgzz3Ae8CSwTETGYzm3NwGIAeZkNRKRYGA/8Kox5tUcr3ETlkOttg6RYow5KSIzgTEicg7YDAwCenJ10zecm154Wiml8iXPMDTGJIpIT2Am8DGWQS1/ACOMMeezNRXAFdu9zaFYzvt9f4VNjQPOA88A1YFI4E5jzHd2vA+llFLqqtl1CydjzCHgitcJNcZEk8voT2NMnr07Y0wGlsu8TbSnJqWUUqqw6F0rlFJKOT0NQ6WUUk5Pw1AppZTT0zBUSinl9DQMlVJKOT0NQ6WUUk5Pw1AppZTTs2ueoVJKXaRXOFJlkPYMlVJKOT0NQ6WUUk5PD5MqVVz08KJSJZb2DJVSSjk9DUOllFJOT8NQKaWU09MwVEop5fQ0DJVSSjk9DUOllFJOT8NQKaWU09MwVEop5fQ0DJVSSjk9DUOllFJOT8NQKaWU09MwVEop5fQ0DJVSSjk9DUOllFJOT8NQKaWU09MwVEop5fTEGOPoGgqFiMQCBwvhpaoCcYXwOmWR7pvc6b7Jne6b3Om+yV1h7JtgY4y/PQ3LTBgWFhHZaIxp6+g6SiLdN7nTfZM73Te5032Tu+LeN3qYVCmllNPTMFRKKeX0NAwvN9fRBZRgum9yp/smd7pvcqf7JnfFum/0nKFSSimnpz1DpZRSTs8pwlBEAkXkKxE5IyJnRWSpiATZua6XiEwTkWMickFE1orItUVdc3G52n0jIm1FZK6I7BaRJBE5JCKfiEid4qi7OBTk5ybH64wRESMifxdFnY5Q0H0jIo1FZImIxFl/ryJF5JmirLm4FPDzJkhEPrL+PiWJyB4RmSgiPkVdd3EQkdoi8rb1czTJ+nsRYue6LtbfpWgRSRaRbSIysLBqK/NhKCLewJ9AI2AoMAQIBVbY+QP2AfAw8BJwE3AM+EVEWhZNxcWngPvmLqApMAvoC4wGWgMbRSSwyIouJoXwc5P1OnWBccDJoqjTEQq6b0SkLbAe8AQeAvoBbwCuRVVzcSnIvrE+/ztwLfAicCMwH3gWWFCEZRen+sCdQAKwOp/rTgBeAd7B8pmzDlgiIv0KpTJjTJl+AM8AGUD9bMvqAOnAqDzWbQEYYFi2ZW5AJLDc0e/NwfvG38ayYCATeNXR782R+ybH6/wCzAFWAn87+n05et9g+QM8AvjG0e+jBO6bG6yfNzfkWP66dX1vR7+/Qtg/Ltn+/ZD1/YbYsV4AkAL8X47lfwDbC6O2Mt8zBPoD64wx+7IWGGOigDXALXasmwZ8kW3ddOBzoLeIeBZ+ucXqqveNMSbWxrKDQCxQq5DrdISC/NwAICL3YOktjymSCh2nIPumO9AEmFFk1TlWQfaNh/Xr2RzLT2P5I0IKq0hHMcZkXuWqvbHsn8U5li8Gwgrj9IwzhGFTINzG8ggsv5R5rRtljEmysa4Hli5/aVaQfXMZEWmM5S+4XQWsqyQo0L4REV9gJvC8MSa+kGtztILsm2usX71EZJ2IpInISRGZJSLlCrVKxyjIvvkd2AtMEZEmIlJeRHpi6W2+b4xJLNxSS5WmWHqG+3Isj7B+zffnVU7OEIZVsByfzike8C3AulnPl2YF2TeXEBE34H0sPcMPCl6awxV030wD9gALC7GmkqIg+6am9esXwK/A9cBULIfMPi2sAh3oqveNMSYZyx8LWYeSz2E5DPg98GThllnqVAFOG+ux0WwK7bPYraAvUErYmkxpzyEHKcC6pUVhvb93gM7AjcYYWx8GpdFV7RsR6QrcB7S28ctbVlztz03WH+CLjTEvWf+9UkRcgddFpIkxZmehVOg4V/tz44Xlj4QALANvDgHtsQzeSweGF2KNpU2RfxY7QxgmYPuvBl9s/wWXXTxga0i0b7bnS7OC7JuLRGQy8Agw1BjzayHV5mgF2TdzsPSOD4tIZesyN8DV+v0FY0xKoVVa/Aqyb05Zv/6WY/mvWAaKtARKcxgWZN88iOWcan1jzH7rslUicgaYKyLvG2O2FVqlpUs84CsikuMPzEL7LHaGw6QRWI4359SEvH/pIoA61uHSOddN5fLj16VNQfYNACIyDsu0imeMMR8XYm2OVpB90xh4DMuHX9ajC9DR+u/S/hd+QX+n4PK/8rP+wr/aARYlRUEJ2i4wAAACBUlEQVT2TRiQkC0Is2ywfm1cwNpKswgsU3Hq5Vieda6wwH9AOUMYLgc6Wud7AWCd5NnF+lxe67oDd2Rb1w0YBPxayv+6h4LtG0TkaWAiMM4Y83YR1egoBdk3PWw8tmEZWNED+Krwyy1WBdk3P2EZCNEnx/Le1q8bC6dEhynIvjmOpfeTc2BeB+vXI4VUY2n0M5YOyL05lg8Gwq0jdgvG0fNOimFeiw+WHtwOLEOb+2P5YDoAlM/WLhjLcfmXcqz/OZa/5h8CemH5IEvGcj7I4e/PUfsGy6T7TCwfbh1zPJo4+r05+ufGxuutpOzMMyzo79TL1uWvAddhObJwAVjo6PfmyH0DhGCZVrEHy4T9HsBz1mUbyTZHrzQ/gNutj9lYjhAMt37fLVubdOCDHOu9bv3sHYXlcPJs62fQzYVSl6N3TDHt/CDga+sP1TngW3JM9LT+IBrglRzLy2GZE3Xc+h+xHuju6Pfk6H2DZZSkyeWx0tHvy9E/NzZeq8yEYUH3DZZDoqOsoZEKHAReBdwd/b5KwL5pAnwJxGD5A2EPMB3wdfT7KsT9k+fnhvX7hTnWcwXGW39eUoDtwO2FVZfetUIppZTTc4ZzhkoppdQVaRgqpZRyehqGSimlnJ6GoVJKKaenYaiUUsrpaRgqpZRyehqGSimlnJ6GoVJKKaenYaiUUsrp/T8N9GegsjYQjAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize= (7,7)) # Настраиваем размер холста\n", + "plt.plot(x, parabolla(x, *popt), label='Результат фитирования') # Строим график\n", + "plt.errorbar(x,y, yerr=yerr, fmt='.', label='Экспериментальные точки') # Строим график с \"крестами\"\n", + "plt.plot(x, parabolla(x, 1,-1,1), label=\"Истиная зависимость\")\n", + "plt.legend(); # Активируем легенду" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "### Пример 2: \n", + "\n", + "Для приближения функции многочленом можно использовать `numpy.polyfit()`" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 3.00601091 4.85432505 6.48622882]\n", + "[[ 2.11152260e-02 -4.35855647e-18 -2.15062487e-01]\n", + " [ -4.35855647e-18 1.66836354e-01 5.77114466e-20]\n", + " [ -2.15062487e-01 5.77114466e-20 3.88971042e+00]]\n", + "a = 3.01 ± 0.15\n", + "b = 4.85 ± 0.41\n", + "c = 6.49 ± 1.97\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "z = np.linspace(-5, 5, 1000)\n", + "\n", + "# Данные\n", + "x = np.linspace(-5, 5, 10)\n", + "y = 3*x**2 + 5*x + 1 + 10*np.random.sample(len(x))\n", + "\n", + "# Фитируем многочленом второй степени с рассчетом матрицы ошибок\n", + "params, cov = np.polyfit(x, y, 2, cov=True)\n", + "plt.plot(x, y, 'o', markersize=2)\n", + "plt.plot(z, params[0] * z**2 + params[1] * z + params[2])\n", + "print(params)\n", + "print(cov)\n", + "print(f\"a = {params[0]:.3} \\u00B1 {np.sqrt(cov[0][0]):.2}\")\n", + "print(f\"b = {params[1]:.3} \\u00B1 {np.sqrt(cov[1][1]):.2}\")\n", + "print(f\"c = {params[2]:.3} \\u00B1 {np.sqrt(cov[2][2]):.3}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "### Пример 3" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 45.40114559 341.39906678 88.62304246]\n", + "[[ 17.35905932 -6.77377934 0.75023018]\n", + " [ -6.77377934 4.29974581 -2.95671194]\n", + " [ 0.75023018 -2.95671194 10.18644967]]\n", + "a = 45.4 ± 4.2\n", + "b = 3.41e+02 ± 2.1\n", + "c = 88.6 ± 3.19\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from scipy.optimize import curve_fit\n", + "\n", + "# Функция, которой нужно приблизить зависимость\n", + "def fit_func(x, a, b, c):\n", + " return c*np.exp(-x*1.9*11.34/a)+b\n", + "\n", + "# Данные\n", + "z = np.linspace(0, 9, 1000)\n", + "x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", + "y = [428., 401., 376., 360., 356., 345., 345., 346.5, 344., 345.]\n", + "\n", + "# Получение параметров и ошибок по функции и точкам, с указанием начальных параметров\n", + "params, cov = curve_fit(fit_func, x, y, p0 = [30, 345, 100])\n", + "print(params)\n", + "print(cov)\n", + "\n", + "plt.plot(x, y, 'o', markersize=2)\n", + "plt.plot(z, fit_func(z, params[0], params[1], params[2]))\n", + "\n", + "print(f\"a = {params[0]:.3} \\u00B1 {np.sqrt(cov[0][0]):.2}\")\n", + "print(f\"b = {params[1]:.3} \\u00B1 {np.sqrt(cov[1][1]):.2}\")\n", + "print(f\"c = {params[2]:.3} \\u00B1 {np.sqrt(cov[2][2]):.3}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## Гистограммы и распределения\n", + "\n", + "### Закон больших чисел\n", + "\n", + "ЗБЧ говорит нам о сходимости среднеего по выборке из распределения к математическому ожиданию от этого распределения. Привеженный ниже код эмулирует бросок игрального кубика. \n", + "Изучите как меняется среднее от размера выборки. Выполняется ли ЗБЧ?" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "n = 50 # Размер выборки\n", + "np.random.seed(10) # Фиксирует состояниее ГПСЧ, для повторяемости случайных последовательностей\n", + "sample = np.random.randint(1,7,size=n) # Правая граница не включается\n", + "means = np.cumsum(sample)/np.arange(1, n+1)\n", + "\n", + "plt.ylabel(\"Среднее значение\")\n", + "plt.xlabel('Размер выборки')\n", + "plt.plot(means);" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [default]", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.7" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": false, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": false, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} \ No newline at end of file diff --git a/source/pages/StudentEdition/README.md b/source/pages/StudentEdition/README.md new file mode 100644 index 0000000..9fe5ccc --- /dev/null +++ b/source/pages/StudentEdition/README.md @@ -0,0 +1,46 @@ +# Анализ и представление данных на Python + +* [Введение](./introduction.md) + * Зачем вообще читать это руководство? + * Как читать это руководство + * Почему Python? + * Итак Python: +* [Установка Python и ПО](../../cards/installation/installation.md) + * Дистрибутив Anaconda + * Установка дистрибутива Anaconda + * Windows + * MacOs + * Linux + * Google Colab +* [Запуск Python](../../cards/run/run.md) + * Написание и запуск отдельных программ на Python + * Python Notebook + * Google Colab + * Установка пакетов c `conda` +* [Введение в Python и работа с Jupyter Notebook](./01.ipynb) + * Hello World! + * Калькулятор + * Объявление переменных и функций + * Подключение дополнительных библиотек +* [Управляющие выражения](./02.ipynb) + * Структуры данных: списки + * Условия и циклы +* [Парадигмы программирования](./03.ipynb) + * Объектно-ориентированное программирование (ООП) + * Функциональное программирование (ФП) +* [Двигаемся дальше](./04.ipynb) + * Работа с произвольными файлами + * Еще не много важных вещей о переменных и об объектах (дополнительный материал) + * Структуры данных: словари и кортежи +* [Вычислительный Python](../general_python/scikit_py.md) +* [NumPy](./05.ipynb) + * Создание Numpy массивов + * Арифметические операции с массивами и векторизация + * Линейная алгебра + * Операции с индексами + * Чтение данных +* [Работа с файлами, Pandas](./06.ipynb) +* [Построение графиков](./07.ipynb) +* [Вычислительные методы в физике](./08.ipynb) + * Фитирование + * Гистограммы и распределения diff --git a/source/pages/StudentEdition/data/data.txt b/source/pages/StudentEdition/data/data.txt new file mode 100644 index 0000000..18367e0 --- /dev/null +++ b/source/pages/StudentEdition/data/data.txt @@ -0,0 +1,10 @@ +0 0 +1 1 +2 4 +3 9 +4 16 +5 25 +6 36 +7 49 +8 64 +9 81 diff --git a/source/pages/StudentEdition/data/temp.txt b/source/pages/StudentEdition/data/temp.txt new file mode 100644 index 0000000..8df0d9e --- /dev/null +++ b/source/pages/StudentEdition/data/temp.txt @@ -0,0 +1 @@ +28 23 22 28 28 36 31 28 22 26 29 24 28 24 21 24 24 24 28 23 23 31 28 23 25 18 28 31 28 19 25 26 28 25 23 22 24 19 26 33 35 33 22 36 25 21 25 20 25 18 22 28 31 32 35 31 27 29 19 23 27 33 29 29 20 25 25 25 34 21 21 22 22 26 35 41 23 27 22 24 34 31 62 26 23 26 22 24 26 25 25 24 22 27 24 25 25 26 30 24 18 24 21 31 21 24 24 24 14 20 30 30 24 35 25 28 26 21 15 33 26 30 30 23 22 25 29 16 29 20 26 30 13 28 36 32 18 13 24 20 24 31 21 30 29 13 25 30 31 22 19 17 34 26 34 24 26 33 38 28 32 22 28 27 27 23 24 23 22 31 27 25 28 32 29 32 25 23 28 28 21 32 18 33 28 18 25 22 18 21 27 27 17 22 13 28 34 20 38 33 \ No newline at end of file diff --git a/source/pages/StudentEdition/example.png b/source/pages/StudentEdition/example.png new file mode 100644 index 0000000000000000000000000000000000000000..b3c6b3d9c2e7b6fe3f87e3f1270a2fa470cfe05e GIT binary patch literal 33131 zcmdSBWmuJK6fL>{r5iySK?&&)MG#O*1q5lNTSBEnKtj3&q)R}$1q7rUMCq394(UE~ zxzD-hx%cn6_s88^1Q%<4@xC+09COSs;HBJCJZwsA1OkEg{F#Iz0)cXj{K7(Vs% zL_^%{jcRC(jg6l=jTHT!2zGRKK5=pqaQ*N>q1xeXPBT3N9|;{DL7c3wezR{>6)wr6 zaFor->YMoZ_{9|!?R6i{cGipPoBI0|*NXkK(P5=|zt9Rh&&;(32{>$!$KNyi7=HUH z0~eS4zu$k0<$H~9#QUnM=%MWr0>N2Q>6BtEpYTIe9M+Z-o7JUral z*=eY>p8u4Xm|y-jLouMJ{*toRAHfW z%N163c3j>#T$jU*yY`n)={{V8OTIWeQai2vdE5JO!u_{;W@Z7gvE&8s9k(VLZF__< z2nYxYF1}Y(_!Sj#Ajue_>oP}*bdlTD zm;Tg(QY5JgvS#v^whV1zMGDh-TnUd zkFO^h#@uL$;R<|Jov99=-2DyC)tef`9vRPm!PWF}!8$3{s7b4|%=EFo$5sFGmef93{U$e62 zcV?S+_V(Cpsl+fl7H!hou|LU-Gou8Qy$**i*29Vu#If>2k9^emU*WM-P*Djj`)4Pc59Boef(2iNMyywX~?e zTTX|fprL(X31SI^y>j_A;$yV^s%Ga(|MG#ty6n=1y zCKU6({WKI4VQ{!H7HrnA>8Cpd~$R&)0?+% zC954arSnT|7Nt=hd;9rWyx`)Be!Z#mz6+IbeYjvC{sS17sW;cM$$zqL=D?n}az@VyQ1N5p!K!^@FmaA5P0YbuFgB`4+dj zO1paox~6Mg)b5$~KCY~+^vAi$`PpAH=A!SZjmxZG$P;O&=}Jo8Z#Mg`zHp zZ<2IK`wBE4=d-aezU$Z2qZeT^-13mEo$r zvo@5+3>IQ9i2g&+Zsil=7F>Qhe=V438hkNEKUjLm{v+8Jmx2M|58=k*_x4~;B)OoS zX->-TogFKb$NQ@TPZyS#Ei&6%S}-A7%x-M3^YZda*DN3J&R<8AK)fg*5A5Fd!MW+3 zo}O+x`J?=qygV2G)VD&P{?ODq>*%Ap#mT3)85pi1`XIm)pM@tSaX?U4UOZFob1C9H z8tpeSGQxCmapBQxK-3y?viU;NL3xZzbzj!vM_mfZ2b*k>xw*M(2p+qYUfvj<4!&cq zx?@zw?WxunUAI@OZ+*PI8^*^qlr*@$z27rgSXlV1;oQ^HgMnbV5hz{nF3E2(jBD5y z+!uczRuKZ80R)VAGi)E!9^oUcfCI0OA7{3=i&TEsS&VRk-^iwjX!8{qwui0^=8zyv zg@3H{rlL9TuXuu?&qMy`2`*1tUWOl>c3W?TCng3X*X`mcr{{8|d2*8GMf|h^xR2?Cbb+BDnDCB!M?R>^RC7i4e6{!5{EZzPw1dZ#rEk9L=R$80T>E z*BBYYNSNi=?UU@+hfxqBSLe0`8evPn6AYWYv0zKuw`s(Ty9*s~+Y< zxjqm(_1i;fDs7iTGk=;LtPK^Hm$zmsq)X@T9q$?`*<@_Db z-wd|31HTmz6huXIr-+7029eDkO}n>yVG!J-!+w00>AE@2KUkzo2RMQ>Fcp4%yjd}A z1ur@|Ieq>iE7>FO>@0YCxETZ~#&EP)KR)+wzp|bC{!o?e>wL`$e2C%@IK8AZn!s&m zmzGqwY}xd^-_gKj1j4=`uNZ-yQYCybaT5VCtZ?LTpub;QIpIfT<>xW7jIsk1Nc)9N z+h!ZKmrU6$ zv}&A6T11BdV#Pjs&wIG}#}6=$d13hApz{9u2thzVfYa5*kxcEYn*qVW><8o0GBRwt z1o3s&A~KR9S+9GNeZcRQ=-kBn9aHRTkH|#3<>cfbsi6EjrLZO3FTh*G%j3#?%jr6e zXS&^dLd3y)e*3Xk<9YZ zEToo`KUCH&A;f~as=$&Pcb$gG$Lyu6<`L1-h63970-GHxV9fwH(uWvJ1u~JE0@mWj zSSb?Rm~dcAv zgRMd!0Iw^iF6O}&`0!&x1a5?Nn3-vXo%VxxKLP_2m4~=4y|M_1@C&X2|&g zG(rwvRPt0;`ZI7MA|vU&8!}%c^nQP;pkJ5hx6g+`G||x55s@FC8r`7?qh1 zVMA_(@T;C-z)33(TL);t3yXy5784UXvwZR(`|FLK0M2$X%P6y3gg0*7f%wJP-`{_4 zPoY!FK@wJk8Q~A87R%AmadvrGZRs0q)J<3s#>|+TGDIIJ$M`L$v>?zIyzlJnY#JU` zz4vDHC0~KrKxWhAWNnK>L_~ylR8$m;8}@jGCD(#YmDBlg$?!KoC~2RS7y$%uApBce zS`?2m7?!h4Pry~pGB>B|brFQ=QX#Cn$v-y2>aek~y}i7=Rwk-SV|k4O5w`%Os;AoT zenl~o)Lnd4Y7&CDrQ^KHNJK@&mY<(50fmHgqDu~3)$HabhnAL>w{%8-yqfB5At)5G zL}j3+BSLsbMn*a;#pB=vaeeZ)PbCj8pTAv}kcR1D9=2R^e zY<(+pimRe|`FrD9upaNC&0DJ*yQ6bk|FF9nOdb9uIXn}7* zD2w#KRN~i6w0lxD3eXX?N99hhU-bM1_ykyz1_%MJ@iH?na0QFHk;KSIF92|6Dpi*| z%>@2|flWxV1r|rx_K)Or7vyPSCi!Ho9QR(kkiA!SCyC(JG z;_FbPdn=q#JOr#}9tWIoza*_C6x*1nQrb%z&!PcGy!UQGT{ezaGA~dgMm=yvNfKGP z>`q@@s@bjfOOB3>A*1DP8q4lpdb=} zrG!vW19VW^n5tHJ*9^i0GNpoP-NcTp8~Y-q26I_ zFb91sne*L5CH*5|VV{_o7)Vm80Vk16FNhH>K)vKW`aT!fZ7ZqsG?cneqatnjWq~RV zGK|m9rypp~e^cHsRUUq=l%pKjBXTBte0GN8BSxQ?lq8uV@<9UJbJzx|57N-k&@|v8 z7-?TTV)F&hhrmokL_```k>5^D8dAz0RTcJb?3<+B`tS>YuI5`L0J@RnNKV9u{^co6 zSN9+t-$}>m)p8M{=TCo}w%Pz9&|mx+m917pi;hptVlSZVQ+NJXMyt-10&@60 zXJ(%LHvr{4Vq!-4H0w#i&3LP>xzDv=Nk~ZO2N-=-L>L_|*keTOb9WNduGsNXP}()Fq9FsYs%{Aau^j$*IC?PD&I<8%HR$@+T7D z?H%J!jVAEDqbyd7^n(fjjp(T!COi%{HkkoWG!@#gtl8aIN;3FHu@>9b-X1ePD`&5i zPEr#VCLf^xJcF2mB4B1lFQ=KC>QS<9yP>%{e0!a3I9{k-{S(6wRbBG`lnDN`fF(jt zkAie!LB}mzD5ZgCYiVy+Gu1BF2)T|!*3jOLasU2(sG#{BwkFIbJb-h~Md>6t2f7Fe zz@fN8@&|$iLbgk?$l~#T#Z3L-_Z)2@N*@vNWIcI^=YA?&>007u`M^`kQYQb{T(4pwmRxz5Lm;$ALqUAL3# z(iy~nafjnYocB$&s%)-XTU+~LhWYzvYeYP1TxSy$q=Y)UuC7jF01XutfdD|I=q)KB zLHz8uq8KKa_-vBCs`go=Qnk-hPy1Y+@2G%f95%KCt5?ix<>BV0AdHIHzhO za(aqGJ7AFe_9Glv+}zweKq4hRJ~vJ`9+DB{T~q`Tx5LJ!w`&jq*~LT>^l)bP-XmJ2 z=DFQ_!C&{aWCf`MZYH>-8D6meI}quI$Bz+E$5`zxy(n0f?3uc_xX8c^g01L1zZiM> zg)Ekz?t_{{uiw)4sIpzyz`=7)eMdlgdpxdke>0wrM^I zQJ9{TTeFf4eXiWM4J<9f>hkJhzq^!?prV6z_q@F-&OH1rH^2AGJ3#5i{t8B+m+A{k9|0$MFbYZ9XHd&82GZ3kyz zC2#CBM>RC1X+od#23*q(-{y?|9-NWE*woZSNJeH7TnzScjWKgsud`^RFFgn26y51L zO=xHC_a5kwWShj7GE=hB?{xN(Ww>d_VsT!PBrpiwP6N~)*_n4#Qj)~sb z%6F^pr4fRO=3b1@)!}{hfX>8VHC27zQi1A1V=x+i;e%}B$VO;zaL;G46^Coi%%@Vz zN~uAQ$M}^{@s6ZKggPB*7@zfBOsWL}`KMGl%{dOprclR13-jyQQZILg${Y--vI1s% zfg$35S9K#wW2Sa9M(?eeXOC}%fn%Ao0h=?N{H}#u%k0FaGCRc>WqHyo{vxhu34;8hHO9GMC+SD)ZKKrxQ zj-Be_k>+nIgbcK!hLUnzGx&IjFtJf1BJ6YyWVNvC!fFDD-ma(W1_?@G7B1-{dsoe| zLN^7h({{4(d2RN1-mXhJRgdc*5;~X~vLKsU%I^aL8pg{#G_;SE{1nd<{Y~#=F3)tS zq0N4oi8K^P9wO~$f=~r_6`F^%%BFte_?XB;s|Gg|#Mipygky<$$g>Tbv#`I8!2S`dzwABWtBY#UCkUb9`@ zv`9iXURq1LgT|ms9VzTUb!IUM2^A)hhdA4BtG!hZ5_k2lOu$!$|9wb$fknm1V*b6l z#?PHe(PTfdcX#cdnS`k9L(k7n4AXnFE^z&b&hYo>;f_OTq~M*>c49C%ipgj`$CACU zYc+oc2!!LEVXHzKkXt2Xf9b%wv=Jcnpk5=kze|42${ZKjM&yk@qo{InnSVd%@V#-Q zsN6H-x}Qe@D{`%kZd9GH%1&6(#=XC;e&Q@tIj$)~qZoqp5ar2?Mbs3@RessL5=?q- z+andNngn0Q+nVWSZ=dFf=UO9gA-6ik5>b*PNHAb7n1{L#|}TZU7Y7AwYCg zTST~Lv0l1hXRO4>dY2LYLsRP-hDn5sqNr!-}!I@%SX%;aQqXdNP1{`A#)Ir zI{KEDx?A_#LTQ2mNSMuESoD7lC=p{~;Kl2q%si;x&b{}!z3Rk?@0^`>dCBlhQ+sCB zNGW4mp7D9|4AiUvkQis7F5NjexQ;+p_CTPj*SS8-luyywy1zDD5Cln*LP(i`VIZxY zyP)k0WS`9t_nFg+c6HKz{L7w)DywHot9OdhrlAW0{Lk0tTZrCbeQ{(X5I`NVl$3!TlbEzhehm4Z!|IRJbG14@7fRAFHu zV`g<#6+J(H`NRPfz9HN7SG3STYzic0+ga(mjqE)^K9ll~_V*8D7j-7-3Y}_MkvrhI zTUjzV+pBcP9i8CDcW?K2!ZfkX=K6&q((DPLdiRH5C;VrDf$`yx=G|(xrt(K+?>4YDJv(Zl zxAk%VXD;UM*bTNtK_tg8JB3h2KM8wHs+%XOdwN5bbNqj40jSp9syt|42p7A`3aNK7 z7U7~dSnQicq(pgmAS9kXjftftAwh$}vG)62Z4?hOD>wR^T*kL-L4T5{dKjdpgpDGqfS9t9JTLWtwSDOyeW zEWxqpviA`EMn~Hq*cr2IEP{@X4wpvo2ABl0UFM5VgKcSPStx$Q96A8Yz zyK}8bV&cB#RB%VfGbF*RUF{&Ls7Newv9EO3!Oy>go#tYlp6Q)H7*jb-@$BzVtFn>^ z!8@#e3q3QNo150hJNmK-_wj%-^CU#Abv|h7&ybm&nfdZc4ihCx`nr9IPD1?sw}Eg} zeV{sk-1m!&BteqZLwRcHP#P+3;1h+9JtRs9?mbwZS)cU?nHOvt3+=2G{Pd_1?J?k% z5~zD$bIt=4cKY;bwUsh*^G;=m& zX5kH>*9e)N8M@Cvk|v3)9jr)ttG~lu?=GrAg!&AGs#_?XLIC+K5q_;Qwu}yh$ldLrj5* zywgHXtxtleUjDULS^D8}z{8<2gp zzTyYq2E#RHqZ5hgjrD1&?{}q`>iofC6CY143@RAZ4<~{pA{rumC`~#w{hk6`fyzr` zsByWd%tYor9{_^PtZb#22Zzt8Fv2OS4!B7o?_YRAj+(!4d$H^A(hy3DoMwjGNQnxs z?HMQYoL5qezVY4W@sdrVi9w~cPubYW6U61zppuepT#?K&&-Z24;nbbA?>U9`{IU3# zulR1bT=6hnIT4Kz^X*8f(fwMPrXIF&&{2x~_gNzPYp`WrRW62lMV}1qp9$@oZ!y}d z-$7w=QYv=1g*wphF*BVJ>g{i*Z-6JZ{d!@pIVr|^;Z)piFVBZds?0YlG6e2a;$QxG zNbfO8@q*i>Q-MXr{1@dySc$f)o_?e1Uw#U@4nl>4$XLv4*Hza0{@^n52xE|3ZiSgW z=W6QdB06JsY);_1XJo_7Dw-eLbc_0+fDaKpoi%Q=}cO=%ib7yk}KPJvK7}9QT-Cl zMssFS#lsP!xmD`)E^F=0kk&%wVSmM%Z;wMlvfdf4rq+MTP@er=h{v-iDJn3g{+xy~ zjvH>f-^r0BKf33|Ynum*tuot^fzrFvADCarO5O2pxMX{dw64kv7Amge;iiqo%bh)& z&w}@I(P7C^+W@leTO$D(;HFQSyw;0|L!#sDJCn5tFdUHE7H7Dlwa9tlQ zxSYUaTorP#dKJ2xoX==H`;zJoFm=xlZ+5q2d74(i7?GPo8>H?bd*2vMNJ6)BKbIdjn@ z$W1?KX?5vP&Fw8or82=gY!CWfdmNmE8w$?W;ooojw`ALf!R?U?Mhr>6zM-+_lY(S% z8A)C-U%P0*N6ow?eFx@($csYjQp?#r3o+U_pQm*TkrUJLq znjGyV?3U->H;M7D-qYobofMaTZ-I;C&Q_th#($uf{xAa6P(&)C#KP;OVz&;TFoo*4 z`=`4Lx5OpPf4LEDC084k{QFT~`!r7D3t@eW-(ThW4Z+JaA3v z_$e_C1F^Gb*FYY_wqoo~wK=VW&L)H3{XDbv4)OV9wIk2l@q6coe=G^bW`OZ*fz+Z< z?{;A`^85GiR-hG1tmmb^W@ONVUKMcpy%mQ*^u%)%$kD-t-LxDDqsoDbWx)@Xg`L9aRkvtRP77Gg|3JOXrzXchz zgOnK09xIb{@P2Oi#`48ov7FpRJA=$=N8qNTk`3V%3yveL@$D@IvUegK5?VH7f3dOs zlA=02(BC;=I(1_e+3!f@{opixHA2ztKy8tf`vAxs0D!$YO3W{8Fg&0`kp>JmuvShc zACb5dNkXsX6`5ytF51)_j$0gWl=ggziNWv@(;qwzFvm{N-9|0Ri3qDrPAC#{_N1XD z9i3Cy5dUg)cX!8{b_*h{n-pyXug$Kb27W}pt-=?w_ycwhqwHn#pf+0kl_fQtx@3IQ zxkY~_ozP;nXKrkFcm+C()>AKnpd+4Qr)}xwuoi$1tv{Y!YAm|}6 z*@7=~u7AF6zK}P>@)8T&m*pi+_8_Xc!afNC+Z`JP_uhYLrMy~n@AA0yWIEeM75 zS+O4pqdYDRCG^n1#Jq7|j?I2Mq?d5G|T_5TU z>{suvgEN1MQ}Y1S-|>s>v6LK2zs={4-)d;&n#Y-WJ*Ea_CEq+^BJpad-}V-IvVpxx zYO85NC7bG5O#}bppZ2wSPx1Jjpw$uX%;b|b(+-Je$umldil9}~F!%x7ImluTbSg|m z6zrkNIA4SM=%@0Wf(fl+>0WqrfrPWP#n(Jiry6ET3gi`V$hy7yi3;^%N2eP716`j9 zSN^})$}h>XQ#o%dtXphxO{dlsd!U*xEZ>~jPf+5?>$%fhhlOC1q1eb@1Yh?qC}*T5 zwGkLsZye}D54~>#m0t7MFn0G%wT4Mvj4dxw-)b*@^M@=mMz@RVdOCvY4zt2)aBr>J z%x+tpqUvxUd?MZc@Xn)u<_}-MqJ5l0C#|5WFqdO&r|k$-nR9j9y zF+z_%(rju#QFU~5LQIuBW+;-pAo={=+gFt}-#;>Qz4bh%d5LnwEqy_yWUyeX@4j>2E34_jzP)ehrb#PvndiySRU{Jpjfn`{1D2&$&R z{`c1J-n|2%iCoS)*>87^|3?u*t3aimhy(3h+1q4Fgv+RiC_!2%N}@!Qom;|-6mN4r z#Cbq#G}q=OJK?H6`h^WB1d6KhfS=vt#P*4AUsgxsX*?WnXnyXgafn?hq~83yZfDW_ zHC_dWmtLN%Z!25g*BrN`dpQ!r6{tIhi|PHsK@S@E8SJSwMof3MPus1IWc53>v*{!M zG&$@`jjp{YADs{1dl%%ib8H7+iKYEPC5%T?o;*Gl{f?V8p%51sIzPZtwekglCY629KKW7SBlLgFmzs(T;vi z>kJQQoL;55qjuhb3dj$a;^Wbj3jvgpV$g#|Aa-|mk1vjx^zY)@1ykSm}5u zWGx9p0>36snGv_tE2`zpn>b?H#}##0w7uJ}wilK?9%1-@?UK*k!U+ zBtTjhJCQ>Up%sKG$mXX3=(Udb2jr1DUtr2XWnwtj5)i)#C0Yowrw1YyWOPT|f(!?W z4%SS$q`>oYS7^=?ik|PFfz+(nY=9}pA>da_tt-ZPvNl21cO8krf~U`9d#)n{SQktO z8c08&ny0I1zb?yP#^qv8`1U|K&RaGAl+;FZRoc||@~M}9u-xBkP#T5-U1A7*KXN`3 zTyMgap}d>XoZ8qJ7#P28#4xj!S+j@6L!Kffj#uZ)qR`9~*U>*0p82^}If7YTNi7WtNyv*+?UW6!`Utv68b{joEN^ zrY#6|_A=^;PDaF8a0as%^+HfM*1uHL-~4ep?EH7*JhF*2cik}$PnNL)Em1pmA|Mxw z$tjm;(A-n0f>yts4okp^A8SmS^brl|@l(H3^3h!Uw-Qe`zQ>bAC^* z4SKu0HK(J24}lcd?1I|2JSXT-gAP?Gw3EGx(=m%9(H2L=OjKn;3k|GGA|;*UA^9^?Q-^ z?zT*hSdmF`Y;P@*;C;JhP)x^71Y}DY!n>9stwhsR`y43jLdM|99$Qu(gH13I?Q$)+_DYe;qa>U!EWf4T_pEaFb~4$8Fj#;$*HCw^J| zeXx&Efxq#ZJQEji!%G8>J45b<;Sm`v4XXCso06i(&Vtf38bik?=!6N_zmnJ{ck(5a zq4tjKBo>>gAEDI)7SLa&TWncs>)7ZtRmo8gWKP2dC>j}&P}DR+AY@=H zee2DQ989WFYI>;UjLqob;9NW<#e;>;5i?QJ(Q^UWP3AM&k+MU(qkb!Ui#)C={bb^a z2D{ToAGzx^)8peNJee~bH)q57Gn^RGY>KbRN67qEoQtgG8MU9Kr5yU!PPRR{^5*El z%(1(oA5%egc9WuuHIg9ydT*Cdp&YI|;uNgeyUc8%} zH!ih+(_f}K`x@lqpG(8!6d?hHhR762NDAkK_@1Dg`jrXBv1og!IZTB>XCQY1K)&q7 zF6x$Ock_adn^Tq_SNxNlF++ zgC$8%$aFPUCtNkqIrej>y%qjNL5y&@&LzsgU^q(?9lX_XfD!xsfI*qn(^9Iuab~#Z zISnz;H?XGZ3OU#7&NsPST^7*eha6f6(*ML?HE=^$;3HOYFaw8X0C46FyQ4-mtqnZ;+0puQb-uxDc841)|hTyiUH`5K8`tTlaWL!$;_D*)_kvmunmrGB1=C?bYODX@ZRx!>N@$ zesr6G7xe_>P~M=^MNSut!dyuXPL48b`t>iWc_mh}V(hwg)X$$kM@~e*z=jV9HmWA< zfou(eHb7LY2u$O!YyTJ|pB)xxzjXHR#ao^Q&hj^jU{h=1f~W^$Y{TAAPp5pW4&S z&1j%Q=!;j)lA|&7(M(VDf6?ZBu-rS^jFQl%#$BaGM#Txe9dB2-fmlI%)}`(w9IAxe zO`-EfFAVh>CmxaW9q}3fKL`(G-3mYgsa0V6JX26m&<6#bp`XS)vH}OXFioGs1s0yD z@KEJAj4q{!m`El5e4#TE2*8*sgr_=>7vW$R84-aBvU1=H3swOp z$Di~Nlau?yxC+CqTL_qL7%jKBY4R)9b97WaU!(k|sdYl$pRjM-CI@CL3uL4B3Q1}b z1t!>t6zq+AuepOZYai6*6N}JuM#{M8B?1=kZ-jE_5P>{q=+p(I1y)v84Zt+)g3<_- zyhSa7Y^wPU(93{PLM$x*;NbjT7YZdPSD;z_wdCt!4$rnSrw#Ts6T7n30=CyyGHL3- zDsoi~aDeD}pLcjS{ z9#D=EA(>*`d!S+TV5|%&40|zMX?sa~vyLQO-nd%o9W2s$gI%nkbJWzm~} zLXlvY>cKk%0{H`vVcSgkh>jNwl7aG}7{(xwVs8M=rW2JVH>#Bj*iSaOHhx$UT#Zy? zNqyggj``II5?%bH*9h=uO&z>;1#<9N;Bqi=aoKlC?~5lqu%xA?rrsG+(>42%JNci~ zAiq3OIz#Nq6VD|}Xb-_Cn*MB)4^pFI#7hzXz%mp$T?f|7YyN9#CQFof=l3iX`B)+C z)T-HpZGPl`@w?%_GfI2}4N5~t`0enN6atV=p99_}7bqr9_lj!n?4AC{#lLQ{EF zA}>&K4Y=`puR2J2}Q&_Rkn4B}t>lgOpgI zQp*VN^UtOnkls1RuR76iUg4ttafq-*KTDUH*HH9R`hjy3+r98Z|B{ziJ|WTSi>=K~ zZH80=a&CmGs;Wl8aL%cq6F-qIU7aV$1n9p8g$>RU0;~GzXl*En(SeT)S^=4s)!vUS zZ@Qi;;v`!DND!l?rRB88{TzcLxg|ccMbS|0)p$PvoTlP_vR_g;V|17qj?YBD-XA7t zw=$W@JD3>0Wjw{|=t4wrHlrhk|7C7$=8Nwt8*%mu56Y}NUya^N7Oy8J8oEaY660o= zNRUo?X!4638E;jn74aey@DZO-JYHH{7Uu6n?v6S>B-%c*@a+zn#QXLF1WzIh5ZfDJ zc2hcO3`j$yI4bBSSK)YeZo<#9!#Wpq^?{pW$YL9nt0>ow|Kj9NPHe?CrSqAKzQK`H z)HvvHRpiNl>h!8`Tty2R%u^#k@}6^_%*nU$J=Aa(SZh2!2}j9o0i3L8JhPZ{lQ;-}a13abm8-VJ9$ob&o7v~?FxsRaJ4 zjVfsyFc98oDbx?}|K-sd#8v12es5_ORG}JtThsMnFy5CA+CpL1XJH=*|jx4`tb4g1LBScein@^feDCuc={52^6BOFmtlgFT*tpH9RsC z4e}^H{Pq`nXDb@VsDQ5kyxN0Z1Y#u@W{=Ks;>dYvA);uRVTJ((puYG0=510x-3I+)1L>AL7XIVaUUj^a#b&B7f;FJ?Chf{s0PYk8eRTj$439ipo*|Co21ga=iRSvc)3hXwWr4 zEArs0Ji$UHUsVF;2?#cKdfYEbfF$jW2gT|~2%mZo$z*q!Oy_g{2%L_H|DvHp=*nXt z2cGZ7{p7RoQJM|voV=s1RqsXveREFxB@m=rLmQSAKj5eBnF86;_7%xwf|H(I7P_LJ zINDXnhl63T z6<}Mc`_&~FPsXb~7wYboEWN`S#Gv)}C_!qFp(v0Ak#T%1E#>>@?Kpsz5ur(2k=#wTBM?mEee9SZs7b`U7)=3#pH z7?|o_P^t<%e3%Mp{&*?D(rUKpy3_mj&uP+6&Q8$T=XsM)YHfkEpZ>$u*!Ghc$G6lR zbV124@DY$H|B1Z2g|?s3$p3~eU*adQmf&Cpu`?OUo+2~ur}MO-?M(Atm%m?*_!RtK zzmlWd>5O}SY-EW$&TrMa61vd~10}3-oc0KQ4F$R#3k(Jh4m{2Qw~_dZ)hTi#phCvF zIP~=uuB+@xic9_-11Ujy*7KdackhD4TTEIS8)jRPU=ecPa|+FnLu99^?)U-I(Y{X+ zvkS=`28PKFlv`lqx~{v|KTBtrP&iVrl4=u=hRu#=(Y3u$O%Frj* z)&7iFQFq||sIvIAHsBkN`=u)kzUlp4=u~Wfm3~h6o&-WHvZx(Ze}x>=CsGmr3&~0U z=jXe}f4jK&Nnk1@@XME50s;avpow_>u}G|f)@07FBY}M4^r4;Q9KF2&=)zvS0=cRo zNXaw0sbMS#6cizp4KSh14cY;io5O(db=#$1eP$P+bN&J`1xEWM0f_N@IJJYJOmb%R z+azLosuK5ZsFKA#%m$$zBpQB`*{!WmkcmVK@`0EXsaVF-13j|S&I}6lM>6+*#Bk|K zZBNzCuC4~a=si*?-3k_noT6yP(72AT^P(w$sxx+~8tW0w7!3zxQu#}WWBM@XYUSwI z4x?Yl(W)CaZs>u)1Ihb=#xj`lv7OyLc6RocFJF4VLade{sY`_-9bssH&_G^9AYilw zXv`Te0+EKj9#PBSPazCXJ9r!|agk+stlW9G5UgTo>&NRjgn*kreIf*Ddt+A@4(Qd7 zmqo7vpyyo}WmQQT)?Z?da zzLx8wI|v(@Ls59DMAU6ZJG&MbdM>t{7NHh(qXq*)PEf<3z(CV6eLi3PiLgoo>)81P-^Et(! z$VI@&r$xZ~f8c+paRP&@K{~VPDcWc;csZ{4I~W#+hyrshsr^(!b}NL)ndB`Sm`y^0 z^+6X>`wk@yJn_Doe&iGifO!Ps&Ye5Tf}ua9e<{zKMnAYTb|fFUv})$ZGQ^UVK|^SL zK8_`42nB&rXHP-ZEDuKx??~=LTKSx9`Xwh>Hu1}RqwG9R?H@Da<$skvCnafTOy^}& zP4-K#<>cf*XNkqW_Wv&Fosn)=e6>k(iM6~Tw1cU``u3JJC*sxx56@$2;PLyn{o>#x zl2)_FM2*h*=F#m+b1wd`Xa}UZSM>P)1L|?~4_;-0zd${8OHfe5!uj1h&UcePe28vK zDL<$7oymJ9t`Yj<{5t5cS)bt};87P%Pz!cxAu+xR*-Ob+nwsgl^=?QZEm#{`Rn3lj z6ilz(;^HEJ#|wlDhymJO?Lg53>xGep3{Gf!2FK6zBnkN)A3J3a`7n+Gk&k?81A-eS zpI_Kt!Vr1!yGcPXR@31mc(euR#DgI(&*@&Bj$BnZE?X<8T+lU$HsgQmU zuC!p;GLznl#-hw2FlSx*m^l|A9j*BeE8uHH;8Ju>l}F`EeNJIk#=A2S>u3QTbKHs3 zbmy_uul3N$$;m~wN7n1~x`me~wuN!`lB#cm@{G^qSHmZI@tM`tSMPX0jjQ4yg(!Bv zaw|wQQlo?_LL9~)&h5c{($dpW5HQ$gWo?aufI1TX_C=_eQNgLTZ7- z4=KPO8is~cMyz4DBAkrkFDf(CCoIzlS!%N~e9}HlM1g>i=zqltzK% z8wnl-u|c`*|Fh`}OijiiYTl-4S?dGd z4Bd-jhIx8e2M!kAMxlofRg9>ShnIAXr-pT-MJj?A`u}@qjq|^U);uHl_oSQE|DJRs z{O?IOU;U7}2LJv4o^U-wzuM9Vz4aCOFuxjujb6eY+j|sK{3yU4xaWO}{x-4kp8W@18fHAS4q7Pw~+9L#~sO zigW#UXbK~R0T8>z8Nz1(UN*rTi4`bZAqH!W%)+Lu2CI^sgFv+x=99}0YHDj?u2OSp z5oj{$S$h~3L&7TABtcT-@H5N@e;$7`RYL*AFgjua9{0dz{aGc?{nAsGY2ZD3!Q}}C z!m5fm`1vbi6O%R9M+bQA%GLYUkL)if(!vZi$TVK;Ks1psFi0DBCL<#o*UCpe{Kf!= zo1Q&;_A+j!J%q{+;4ccIrlzJB2H$LgBn>I^S>AbVC z<}o^`{V6fT@c1aR4Cb55 zmXu=T2%zrk*RQukMd=V$7pL}+DM4QX`jIZjWp_}vf^kde=p@&?h2X#gQzA8&r|X}d z-2qT4fSfh}2f~2IzT_Q8fpO;Eu}hvADbVx-S>(w&=nkL=KtsTo@9f+hDguVX;Scs( zq=d!sy;fB}NA78OH_18dQ3;TTibH<@f}UJc>1(5ITO3ul z8?pzp|N3BmiyVq-qW>(MF=;yutY4UCskrd=ml!J?0HOb<)_n`~3%QWsVBAN}`0KZYK97BczE~+zRxqZ*csqw!#({7=+dCR;(qYJPlDlYg)vBeZ~;y&4%bU1pI`lH zY}Br>Hhq#oF8@DT`|@xs+i&e#QD`!&C?PV0XndoTP)UPKMaEKwQj{_eg$z+bD3Xw| zq)5pS8H!3|D0+n`LrGG`*yrl~eS06@{^NIi-?8@}9UbZMJoj_o*R`&-&huR7+K^at zP{wx?^x%MIW-{7?NrDf9i{@j?s6p-u&j6h}&*K74?GOulf`y9i#-}KoPA!@nX3)K= z1kl)Y-CNq5QO&^9h6AMw{Banlz-u2~gck?(h^|<<@*K7}XwGRd+P5M{lJ-i!c=ukeoY$C;l9 zNN$~DCp(z~fHpOUM~_i(m~p>)!_27<+vB^3=1-vga0MjQeqJ(=2&3D{9L5zR*d@Wo zr~~p;|NDQ!0Ga{kpwVyNy+a(--~*+3gx#M-9l0y7ZIQ5WM3G|4+qXBcuLr|Tf*e1; zT11_As89DwO(7dy5~<|?d#c-&JFrOf_432NK*4b0XRki;eLmxFNQ@b8G^Wc&thKFY zN6>)o$@NkBzJ_un?(l&~HO`aQ*48!$FAW`%nB(VRBV{k2fPhmObrK`!sNKTu1K>)) zSOH}XV{T`cv8o1b>l@?wZkrY^j9c%d26h@sZU^-L9esC?4G3a|*J1y*^YNCa7Kw3l z+xQqVgBt7Ck*aYF$O)!{2hAYnpd&xFzT3H1ca1RUAhP zbozzFOCce1a8(9Jg`35~pI3S8#}P~^FEX_A(5Oqj_yN?SGI3^yi@|BX+b3Pp1HNb4 zr&mXR>g?nje{@3*x0U~1Y_IRZG0p^yns`+~IA_?Vz(phZ0gz5UrVORZDx*ep8cH$b z<0Sj?{@uG=@$Q3x%^T4s8XV_^=oVsG>yOjg(Mn=4KBpCDR&EEx>N)y;26=6A z%a^}S+8)l6*Mih^+VtsEfxU=RHcVWDMLB)XiRDGmhz|}TZ9w-Y^@2%+Zi#=6Zp4ZT z^64P4Q13ys7DHIxWP1R4uiDJ+snz;=Z3 zKJ&rD@Yru^=X7y#kudUKuMyHhNfbGV`1_Z>dBdxzsR<8|O3)sO4PCrCKa+kKH}tpU z&4b!~GZ>Ack&am*EieV(k~4l#7P?58i;HWC0-lEQg^-ZiyyG7R*#&3KGkN;6cx6s& z7S4x+gal2eYmK=TXU|-XOr3&r!xE?s(HNi1F%MioDWK^Pbi`Sp6ix2^s1IQ8Dc}o5 zY}VwB5Wv?KxST}7_N*FSVe>-9J->IbF=VcjYF50Fc~W1W^LEY5xx!D7)l#L0*kV(V z*}=Eg9%(DdIS>-W6qH?uQVp)`P)~Xj{ssDx6^@a+0i>y52x!$k%%sP3Jui zC%}R@j1AeqVQn#X$G%)!eiCCy>)skz=q$&hMyeESpXH9S``CR73RL{I^PQAuWmwtR zO3*)xetv_i!_9VC?bsF6R&psa(hsj9hbG~Z2&as7L7o`CJ`fr5q(T~>b}uyDX?bYA zgWK2KCN2??i%|ZHqHVpbZ=1TFaGZTfJdA@-OQNlwhZ|W??wG!oJOwnv@ZG}t)U`4}3pmzJd*N^^y!!I0*2BXFK5jF~?+sOmI2wBK zEnctdM~+we?%n>x;Zm?Q-|^6ikiC2VzU;kLygsrqdthWTW7UE@a&M85;Y48sYG5Hg zXrOkhh|Pnu>gu-L6Z2K{V*$%1LKF%J+`sB$_w%$f1IvH>W#l|{?GiPQL|?m>QCM6Y z7qB~!%3qAOHhr4UHBvw~z z-Ndt#*_|mH0Vf!I8Lod>)oIlaBe5qxJo1b{JCK2~nPj-d#K?Co<4;z}_U}R51)}-f zy!NJs^T&|2Ir&G$#F$I$PATjA6k$^U`;LTXqjbD{3(S)1^0*vF>CMmXxf&vNSu!%^ z&b=|cO1JobdWqoj(LjD>+%cW^SV&s_`#m_b-D*+T>b(0ORbL~vhmdX~%^rbO17DSu z(gL*d&VJgw^X^HJ_`{m&N%KbT#@Oy+_aST=v6J2G=K{@w7PBT%Dx&c?Px|=y5ODFw zT~BqzH|F_A9b-3pmJP%e5_#b z_U+qu190=U?b~%yA46w3GBR?*;I`4-oE&vr9QT3+X*pP>DrA3xGX^Qy7Qh2!d`M0b z4Ci%LiLh-akV-^mgKn&@hW8)|(Z!mMK^cIr#+m)8tIGo0$ht0xLwn~=ojiLJc(X0~ z>#x7cL&K3@o^D26p{5Prm96BDdHC=QFxu|$3(@kBT(;~ZbctK>f#$ZhLAWXl+=anW z&_whdpbC#@hF>8+G!J`(%-}0g@Ct&h+Jr4LvBRELRLnq2`v`!)$T9f|p@Q{=6TWwD z&iz?Xg%C`+*a9!)CXrW02R~@ZM3z2%y2WNg{^_rr=t3LqLrDqAAsKAoq?tbOZM>`N z^rjMVce6=1?jB|P62qMGV4wR(W_jK*%eucpK>k1gx!HmDR0BsI_LHpOaJeX!rXd?H zMW}t9VWFDT4uK?6RK3`o$uW;?930uw+JVW3=R&X?kS~Tw6#qJYpL6%tUg?98xgf{-m*%=ub z6T_$n$d~H=;g@Go9>bU*kj{2&xWTeh$WC+Yn&!g9f;J=ByHQ8lKwAl{2vldxp3j(> znUMt=3cA&Bgjn)z3dLy|boa=l61WnJi&ZNwie&9+%(2mB*q#>xOCw?m8|D(?6)|Br zs>p8)K`bTb6};OjuN^PqxM8laTf-P12>K@IcKEexv+yyn4-%J`-__;H*Iek9x3_dz zo!iZYKZb^upPmFgmHYTf@svR63vKpI>?co(_J4?~se1P8b^kp*RJmM?y1DrcW(k%U zSwQ-ttu=LEM6+b6F909`25Ymj_=g`CjMn%Wb!X>?RaStyL?g8{Hf{1I0Jea%9n-w` z-9NlD?0Y#}5*h07Da@z(kbXvzi(~HFg5N(F(Zax{Aw9y)1y&oYnUp zJP<(gJ9rPfED%9IC^K`p%L2+E--{jmH8jKrj8{!2vZ@;3rUa7PGGJbOy^EDkYcpJM zJq?R;adVpmt?H;-&VWZmM1)?ak{=hHW(8A|<62#gfFm=KegtXHU8Pzir9qwr&*|+qoCNGc(J}BDn9-q!q4c^@aI99 z8TOtDC?S!5vqD;H(ES+s3FH0n;ksN8>(bY+x#)*dLW-8G&_l?5@N*yP)+zY?tL1KX zwoX7YHpfH9E>1Y(Fbp2z76Su;qVaxZX49@+bH&8P3H3nOu;Z&iRp9`*h&GI-=2ZV( zyZTgat{*Mfn$n)foj-z5>thH`{XOhL+ER zRsm>P_ur4#(k%q5%28uLEJ}Vh(q%btgZ~M((i!YY7QbRm%k2 zjLxBw(F{z(cO6vVM63bfpt~Q?wHq=4|FAG_xY5+!+9~t}24q%$L$}lpq!giEue+tT zR%dbi8d&&L%`@SX5q?^#=mt-~qTj!a{njC8#}PE!Zy)tw!|=iq{5}I=yEUpP>90Ww zyO2Qmasdb2d({wYhkhEtFW=JIYI^Jg@F^cWTI@^Wh_KY9CBA`^NdCFJzZ$7z3fH1V zA;`z2-9=sA0Y-56@>Y?uZZJ=Bzh>At52nPGWV-RA!jzn6|nq=sn~& zE2->I9sja&{=$XR7|Ls~I!ODZSbI%0Y#U$iM)#3DX}sGHjJ85D+R>xDSzzBW>VYyhY>jIW z(T4al1h_Gd376?RYfDJ6n&AovSOd!g$&zYlvC$mG*6$eWuwNy~b4W^cQ^eBHD zO}5%pqSy}cUsQRASql zhw?=nB`;xOkgFX%dUOTA3g!vfKOw+;gjv@*=YboVzgzR2X1OF`@3-gpf%_azLTP}3o-4(EtDv>rqj0ruh>y9SF(ls@}=qXW{F7N1+j zz~{uy!q)bz!{&II2wd6ImoMj_YKM%i45>ySjN6{)4NzhOsSW%pDD`5WJ697Ye^p;R z?s6cQ-_c}qysjLDvDT2!HR^~aUp)k^kMxx9T0C80QOXKvunnI&_>={Un060^g~{KmA77)*gP-}}2gHt( zVFr#4-Hs8?)i!nNUt8l0w=d-Z;!c+6SZ#*UM~)w_;q6Oxebe*T#Cn7FsOS8NV)Eg- zJIbvb70j+0M0Q)MG??TY8lf5%;0aX!YGu=PdvC#3SwT#vh<`oX2qd+ zg=NWEHu!bO4cbl<6VnIrB$Eb^D^}HOF?MMgRx|KkZhb}Vfuzeg8JmSJUlKd^;bUx` zfyB*wZQD=dy8bk>Z%lz8Jk!yLL@KX=ewtR_G(XB=M<>m0rLd1 z;!9GX#My;J!iRPyj3LwF@7`UJbMze#U_nyxo)_^9z=!y)N35jKfLma3_^>}LjS~Pb zAYQ0)2?=Ekx(7w2ly<=&In`bGm?$bESYRKJ{kR3NwLVJV-PctXsIiCaim+=)=Lh;) zo4J1_L?VA`RctVLWndG@E@|HT>?PxPecBmMHc%rrQosVr1kK!iP|k?1TQ}eNa+2N= zsu1xeAo$1_g|vUqdzI*IJ;+);8;k0fs2c_`KSko{4_x3IQmztMK-1-`1H zQ?DLE#dK7c0WjW26-9~@5cQ*ufTh|yJAIK+J+Iape~+G&-fbBilVyRt-S6(FG`r#i zl@UqG25N_SB%j`+ioI^sE88g_F-N^KmByUi)&fnm=3Qe!s zmgSrTc>xf*qL6a8759XcWaO6#4WS15Bqx8wPd)2%0$w@khQhD2xG7a#d5>Hjt}W1zb^W@lbe7%=4L?HVZ2C!VGxbQO$=% zN2flx?&s&X_Z^nqiX*Rt$&C|HQ_g8NjQYvQ*a0+SB!?%ujpwhm7iOM7OM_xk?p_uU za~!sjD(p|i{PnMne)}dSqFJZ?q*Q>pw5P}fvLKJd=-v9yJedQAh4h?E~R@v~trJ|$$xz$2O*GDC^LkgKSF@nSY$CHdhl zppgROqgx~@74?%ESdU{{A@7QK2t{-Y!N~~X1hiWPB@A$0UUPIlY}m}LtpfmceuiseGZ}s1k)Wgd!)wCcngC4B2 z@{cM9G}KKHBMj&1cS7^$w*fXTzwT8F^o812Xf>(0IK~`&aR2_fs3<{(ID&^~zWp%_ z2b}z$SMJqYFHNX3aDJkLN>z>=IpSBH4UIeMhR&?pnVIAR1uc_``v?~n7b5jOEOgK` zvbOv~6_gNm{OuW?Yt1%xab#FH0MVfYqzn$9O8h}QpADnZ3yV!oY>xvoP9g>ZsBwdQ zF-+#gix($=%8+IZJ^S5_w}t*qR#?m>A+g9X# zl;4a>I5Kq1kRB08z`kP74NG}A7Ot}PM%a;!?WX>03TH}6JP-l;g90RzTyJl0o=R7= zmC(_PdxR5^nr9}WL3^|C=r|h~t?umVLc5VX-(RZmHU22nZ=E@?-7zaR!0_FxJ-fDV z-wdb=9uo%XteJL^$5ei9c3SYpakSXb=ZL#q{DTTT6Z=#dnZM({0RKt-a>`S{BUiUx z;uLZUBM4z+9zA?`W1&c)s95^o!{Gm0EwK9GwX3OPZBxoUypki9hzH`z%EnC=Tsmye z!4y8MoUWr^!D==e@aX%;XXfqSzklNJ?xadzu4h$MrAP#w*Q(bEsetMRbIy1dPfZH_ zVcH|Z!^OQKWFr?<>W&Y2Xro@Gfk~rN8+7z5S+o3ebDjJqo>o>=7(820Gq z!*Jd8=1Ro|`9JSGRelgQcgWNpcmE?SDwvyj;1Lg5m&V4%BEsycOI(U2u7Oj+!rnd< zXbCxRpseoVJ<5;nj*F=KiTOhIVg2rpJ5b&QctY+K5cYy+ILOE|ZmW>`RR=Y!RQ zJX#SNM}!sQ#0NObaURUT2btrok>xItm%kG$erKXe=~jB{c`Pi5OXWYO%4U%XH{`N3 z=>xJ*T-K$_mv8E{+;f-jo-XOUh+L+D548358FxIuLsKRfJ3QhEw15$nkK6-vRMziJ z8JCbHh%Q~q3Ou(I@#}Swha35YVe&_!=2zr8e#j{NY_P_0-S$>iRwXcf^_uuT6EG4{ zq~y&Bh}U^?;!*Q25zi4(MEtwfwPN%^07=x4uxB_a$@E1}V>4T4=Ap0#9>=lbS){p9 z_yUV`$WLLMzay~u%FmMtRlIubhm>Nt)Y#FB#{|Gk)cSoR8plAw2ZEk{R*es3V+dQY zQLdLERUOgOFXC0r65dxBp~3>lJ{%`NH&3q zHyW6j6DpSR9tPO~h}bCLcA7S(>WGt$?yFl5tj&nY0*KIM1>zY{0V^nFe~dD541TO6 zTOEDbHu-l!=jUl>Y7M2=9&c3#q=#OlJA3SrQJ@J2ihYx}E6*&78Pmb-# z$Tr}&TJS~Y^aydF2BoiLnZD#DCi}237)%uT3EScMXT!DV zPD|Z?UlPTN+9RNK?w$_Fy4kSnR$;;o7CT0Ni69Jz0UZVA;TUY(gcCQ&T>$`7RQ|E{ ziQd%Z2RZqUnqbh22(Tv&kguqgSs+-U1B247^8r5%_p1sHvGBSti2H9s4lAQ8BU8o# z1!MjmF4s3o^+a=uR;`lEx-K^bnG1DYA%IuFN2jg7|IYq4{XI67w=)mksi{(u2c8f< z)tbCRkSqbgk5*FW2GUPkxr$!zZ#t4AN_}s$#d&yn8yel53=iAz4ZmEuVS`CgUs}3s zPqcvjqQbFxCJ)Q?*4axaA}h;;7zJ_ZbqnipJ3He}x9trE-PK>de92CFuw?@eO4%O|EFxg(|2$u$^((&sa6_EuG&9XIE1t{C z%bWc1dV|LPiX178V}X0WSA9I0klw!iv_6V@4l2(9po?RIooUgLn#Gi}054pBVb>Y_ z*L3_c^uSvZ+)<5Nw-)>bph~Y}W8#0NV#oaU_mI{}b!uWIf%ytMwr{6lL-j>bM7Myf z2D0k1AFYR2cz#Ix2^4(aapwgEJoJ;bVIM%;6u0JSrT|@6Rc(2$OM{7;+F9`O0ziRy zm@>c#8mCU>&<}8qM>Pp4pU#A0QqS5A4RNUSBwIa(O-KQR(IN6!o#j9>WL#IvMBjjZ(2ts_p1pu528cQBvis4Q8&fNa~{+8g5IllsJk+*Hklt!FHHovS4 z``s@s%_g@{QH60zi;KyfGJ4g*Z%i0J<0(fp>4pJ$kNuUF$RUjBXBwFn= zgvMl6uhyTvaMdPahUff8IvWm0tXCU&2sq@`d2 z4Vx0U^RVEy#v?Yd5kgyor4d4fvh#`yI)|Ajw zM#l+qZ%iJLil{!MgjS^z*vlihO7yQq(+v=-uAxEsuMon0#B300hbfXifpxhQA8*$2 zz$z>zhJyj+vHSs8kzs13KoT_zx?^Cb>93uzuN9EnVqfZabVULt8DRm6`!C7e9;9=4 zurYQrh9OIu3m0(QW87%Jf_DigE~kKU~L(oh;r-%U#vjX8~5&P$vlCIiVqzN z9q{efmoh7Ie*}t4Y|WYndcX16L5L9nNGg)0VRg?gS_ZCFf|fVRn!xdzswy6wTmqO^ zBCYS9+||<~%>cZ~vF!T^g~Tc-s!7-mBr6!v*q}Qf>S|-~I9HtaH%mrp(OfQHbun&? zQsJf807%{vTE3g8*Ghpuq2}&gubsXWQq_8#Gi87|^j|@4&&8Bsn1ykPPLCt+Mh%m<&80`Y%W8)A@frSY6DS7_liFRt*VxBH379GO7MSgS6T-~(P7Ndo||h#Jchy$qaup)Omnf-<CaRlY zP_r^+Fhbi=*pGo2++e#qaP-q%pb>fPrF1CA9yG%QpGGB0;% zX~8^L(-NXN&Msa_Z7$6D8ob>`Q~<*T&O%l{Hkp(SK%tE~CrCZlQ>X-)f}^n^vNp&A zq%e2F5AZm|W>F74#vh=B=Ldc#RjX7lZF5%Dp~IK?Gt|#PD7_Vr;sr9kOIpcVZvgos zxx-kBV9eQ+`eHC+2?>Zs`_LH6Day%{gG3G*f%6#T;f=iNJcV48Ssf_L$}19VT44UK z0fZwMQ!TgP-Uk5#3Bvsh#Df?0J@kH2YQPpCw}Z^*#x@)EerP_ zsCAt%7nRLhEWDc5GX@vCn3OuKKL3tn7$}qi)FsjjM5|kx}cR-->`W57omLO-3sM>(>AlI&4Q*$hI>btT6 zMJNHfYv%53IgM#0fQighye1D=sWxvLP-7nzjK%YgOp8aNlqQVR%+MvS^xy=fb28)T zVlTS;FEuG(C_!vYOE~jt{X`4Tauf?`_bwt1T28(43x|xXqVF&i2Y1nVjQ)`TSksD!DesJ>Y!Rsh|hRb!42GD$-BQ3l1SS*KEfX?b;L z>I-c36*hHClLtW&n1iWVIQ(N`^dyP!(2nO5R$F}hB~oT;(p(2_C8p&tf-Sf`Dvgj1 z1%+&t3}^9H^STO2#1r6BRQ+JiC*clNRq18FnJ3r*=uz>eDQqYZOzn>ylfyw)JcYV6 zw{#+^0lj~uH^fmB2*MqMI0X8Nz~;`>wg$b}R&@nbUcwyi#W4(nrQ#Bw zlMzx0w2nb`&j}ETnm2%)EWBNfNlTZmUk@cR1%X!s!}@Sgr|7g8nm~{ZMFkGqgJDjP z*x)yfj;ewWL&B(m9Zky8NGHh6g9|RyV3cuUU%doRVDoxr;LE#}F2&^yk6eC8VhEg^ zg6u`7o#-(_rjv~tFBvU%e?J9$oR(vHb$Q~YbcL;$fU^lhRut{uuXEY2V|M!bMh{K~ z=l|*KYEjn(S?5w5Np%lc=qWTvR(1O2jg7>+^el8_sDbj!*RR#@0W=6;IRdJ>-t6o- zIeG-udK-2=3Fa{A&lk;_smG9g+CZ&h@%*wxHw2IrDbP?vBdrWu3?e}W%Pw7~kGBiE ze%-Wl0uP(Sa#Sr7sR~g+Y9{G7L7+wc*cHEV4vM#2U3{C>Mp>nHZNV*Pi=pE2<>Kr! zTij!5V;J@LT&#^`BTZ2>Y2rMV)&?JfBlC{hJJ8*C?s-^PDir(>36rEl zW^!`;_!rC?>MDTdn8}!Vs7JT`{Me|64#7U7 zu>AstYW&kGV@OMsL1Rz3Wec=Z;-LMHHRqH>Nb52T@NP9=<=n8}LygR*%AVysG9bEG z#rekR>PJA@5L;z0A5PwFo`;}$`hR|!P-iG#tFT*KwugrI=wkGYZCQ1 zN>EL_ag~$FEZ*NZkokI{I9{@B*-QX#htsYk$l-5Ez!We~34H(lK=LT+iG_o;L^&5R%OkiijGbWyQRIYL78xYS)zGyvB{xD0Cec${O%3zYeERA zg(8eZPKeQE=*K8WG9`sj#mbB(Uy<1Fzg}WPuqU8i2zSWNUJbnn8h8#t2q6Jz6XM*u zwbIt5hC^mCuS(=|&^=2bj$96`NF3rPUlh(DX7gx(Rrc2)tpPPDv+9lJPrUb<%{0?% z!RZ);6l@lHYN^&SMJo~w6BG3vTs;o+7}BKcxqZHm8wKuYU#Hb!92mSB(@kW! zP}DEKR|C)r@-4iPZBrrA9H?c@Cdcs4o3OT}S;R;Yo>k+FR0mF^4nUr-86&?;ApH+Q zf|zP@WepMU)4V4J)%C$wOG85zQB{4=1jlAM8vY~@Tr|**QHK4y6eAAgX;KtqYu}L) zybQ6&8A7H6t>|eY{N+oQK8yX|G2|CZdzHKY^dI*?z8;M8LpUf0- zr|E9k3v(pw-7t_AokQlJc#Q&+rKs%T2LEuQZRy%g-yKzV>iaoK)U7s^+?phgdCsqG zy-?7>HY&K8mqp(Nk&6JePoHizM4RTi4cil0L`DTz3M`x2#~lCsI%jN4F~cy?+toMg z)vX31d6P37LrsA}LF+b6>fuBmlDFh$xYKnw2yWokpATUpL1aWOqYQTFfB%={nVXKK qaUY%4&;AGY=~5{G literal 0 HcmV?d00001 diff --git a/source/pages/StudentEdition/example_fit.jpg b/source/pages/StudentEdition/example_fit.jpg new file mode 100644 index 0000000000000000000000000000000000000000..db6481a1288983b16729ee6e0a10b093a506ca0b GIT binary patch literal 44483 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 literal 0 HcmV?d00001 diff --git a/source/pages/StudentEdition/example_fit.txt b/source/pages/StudentEdition/example_fit.txt new file mode 100644 index 0000000..6a2c137 --- /dev/null +++ b/source/pages/StudentEdition/example_fit.txt @@ -0,0 +1,16 @@ + x y y_error +0 1.0068 0.0102257 +0.0714286 0.948294 0.0795922 +0.142857 0.762078 0.0679092 +0.214286 0.817114 0.00938375 +0.285714 0.778159 0.0608459 +0.357143 0.768747 0.0597124 +0.428571 0.719843 0.0390595 +0.5 0.841425 0.069739 +0.571429 0.740294 0.0570824 +0.642857 0.779505 0.0642933 +0.714286 0.792859 0.0385559 +0.785714 0.788247 0.0197552 +0.857143 0.979925 0.0830202 +0.928571 0.93524 0.0473833 +1 0.86203 0.0666696 \ No newline at end of file diff --git a/source/pages/StudentEdition/filename.csv b/source/pages/StudentEdition/filename.csv new file mode 100644 index 0000000..f0280c5 --- /dev/null +++ b/source/pages/StudentEdition/filename.csv @@ -0,0 +1,10 @@ +x;y;z +1;2;3 +4;5;6 +7;8;9 +10;11;12 +13;14;15 +16;17;18 +19;20;21 +22;23;24 +25;26;27 \ No newline at end of file diff --git a/source/pages/StudentEdition/filename_result.csv b/source/pages/StudentEdition/filename_result.csv new file mode 100644 index 0000000..a45b5fb --- /dev/null +++ b/source/pages/StudentEdition/filename_result.csv @@ -0,0 +1,10 @@ +x;y;z;t;u +1;2;3;1;6 +4;5;6;2;7 +7;8;9;0;5 +10;11;12;2;7 +13;14;15;2;7 +16;17;18;2;7 +19;20;21;2;7 +22;23;24;1;6 +25;26;27;2;7 diff --git a/source/pages/StudentEdition/jupyterlite.md b/source/pages/StudentEdition/jupyterlite.md new file mode 100644 index 0000000..da3ed8d --- /dev/null +++ b/source/pages/StudentEdition/jupyterlite.md @@ -0,0 +1,8 @@ +# Запуск ноутбуков в JupyterLab + +```{eval-rst} +.. jupyterlite:: + :width: 100% + :prompt: Try JupyterLab! + :prompt_color: #00aa42 +``` \ No newline at end of file diff --git a/source/pages/StudentEdition/notebooks.md b/source/pages/StudentEdition/notebooks.md index 7f503cb..936dc68 100644 --- a/source/pages/StudentEdition/notebooks.md +++ b/source/pages/StudentEdition/notebooks.md @@ -1,2 +1,36 @@ # Введение в Python и использование Jupyter Notebook +Что же пора приступить к практике. +Демонстрационные блокноты можно скачать локально или запускать на этом сайте. +Для запуска всех блокнотов в JupyterLab перейдите [по этой ссылке](./jupyterlite.md) + +Для открытия отдельного блокнота перейдите по ссылке из списка: + +* [Введение в Python и работа с Jupyter Notebook](01) + * Hello World! + * Калькулятор + * Объявление переменных и функций + * Подключение дополнительных библиотек +* [Управляющие выражения](02) + * Структуры данных: списки + * Условия и циклы +* [Парадигмы программирования](03) + * Объектно-ориентированное программирование (ООП) + * Функциональное программирование (ФП) +* [Двигаемся дальше](04) + * Работа с произвольными файлами + * Еще не много важных вещей о переменных и об объектах (дополнительный материал) + * Структуры данных: словари и кортежи +* [NumPy](05) + * Создание Numpy массивов + * Арифметические операции с массивами и векторизация + * Линейная алгебра + * Операции с индексами + * Чтение данных +* [Работа с файлами, Pandas](06) +* [Построение графиков](07) +* [Вычислительные методы в физике](08) + * Фитирование + * Гистограммы и распределения + +