├── assets └── figure1-1.png ├── Pipfile ├── README.md ├── .gitignore ├── notebooks ├── Errors.ipynb └── Fundamentals.ipynb └── Pipfile.lock /assets/figure1-1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Michael-Liao/numerical-methods-with-python/HEAD/assets/figure1-1.png -------------------------------------------------------------------------------- /Pipfile: -------------------------------------------------------------------------------- 1 | [[source]] 2 | url = "https://pypi.org/simple" 3 | verify_ssl = true 4 | name = "pypi" 5 | 6 | [packages] 7 | jupyterlab = "*" 8 | numpy = "*" 9 | scipy = "*" 10 | matplotlib = "*" 11 | 12 | [dev-packages] 13 | 14 | [requires] 15 | python_version = "3.7" 16 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Applied Numerical Methods with python 2 | This repository holds jupyter notebooks that explains the fundementals of numerical methods. 3 | All examples and chapter layouts are similar to that of Steven C. Chapra's book *Applied Numerical Methods with MATLAB for Engineers and Scientists*. 4 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Byte-compiled / optimized / DLL files 2 | __pycache__/ 3 | *.py[cod] 4 | *$py.class 5 | 6 | # C extensions 7 | *.so 8 | 9 | # Distribution / packaging 10 | .Python 11 | build/ 12 | develop-eggs/ 13 | dist/ 14 | downloads/ 15 | eggs/ 16 | .eggs/ 17 | lib/ 18 | lib64/ 19 | parts/ 20 | sdist/ 21 | var/ 22 | wheels/ 23 | share/python-wheels/ 24 | *.egg-info/ 25 | .installed.cfg 26 | *.egg 27 | MANIFEST 28 | 29 | # PyInstaller 30 | # Usually these files are written by a python script from a template 31 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 32 | *.manifest 33 | *.spec 34 | 35 | # Installer logs 36 | pip-log.txt 37 | pip-delete-this-directory.txt 38 | 39 | # Unit test / coverage reports 40 | htmlcov/ 41 | .tox/ 42 | .nox/ 43 | .coverage 44 | .coverage.* 45 | .cache 46 | nosetests.xml 47 | coverage.xml 48 | *.cover 49 | *.py,cover 50 | .hypothesis/ 51 | .pytest_cache/ 52 | cover/ 53 | 54 | # Translations 55 | *.mo 56 | *.pot 57 | 58 | # Django stuff: 59 | *.log 60 | local_settings.py 61 | db.sqlite3 62 | db.sqlite3-journal 63 | 64 | # Flask stuff: 65 | instance/ 66 | .webassets-cache 67 | 68 | # Scrapy stuff: 69 | .scrapy 70 | 71 | # Sphinx documentation 72 | docs/_build/ 73 | 74 | # PyBuilder 75 | .pybuilder/ 76 | target/ 77 | 78 | # Jupyter Notebook 79 | .ipynb_checkpoints 80 | 81 | # IPython 82 | profile_default/ 83 | ipython_config.py 84 | 85 | # pyenv 86 | # For a library or package, you might want to ignore these files since the code is 87 | # intended to run in multiple environments; otherwise, check them in: 88 | # .python-version 89 | 90 | # pipenv 91 | # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. 92 | # However, in case of collaboration, if having platform-specific dependencies or dependencies 93 | # having no cross-platform support, pipenv may install dependencies that don't work, or not 94 | # install all needed dependencies. 95 | #Pipfile.lock 96 | 97 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow 98 | __pypackages__/ 99 | 100 | # Celery stuff 101 | celerybeat-schedule 102 | celerybeat.pid 103 | 104 | # SageMath parsed files 105 | *.sage.py 106 | 107 | # Environments 108 | .env 109 | .venv 110 | env/ 111 | venv/ 112 | ENV/ 113 | env.bak/ 114 | venv.bak/ 115 | 116 | # Spyder project settings 117 | .spyderproject 118 | .spyproject 119 | 120 | # Rope project settings 121 | .ropeproject 122 | 123 | # mkdocs documentation 124 | /site 125 | 126 | # mypy 127 | .mypy_cache/ 128 | .dmypy.json 129 | dmypy.json 130 | 131 | # Pyre type checker 132 | .pyre/ 133 | 134 | # pytype static type analyzer 135 | .pytype/ 136 | 137 | # Cython debug symbols 138 | cython_debug/ 139 | -------------------------------------------------------------------------------- /notebooks/Errors.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "antique-literature", 6 | "metadata": {}, 7 | "source": [ 8 | "# 捨入與截斷誤差 Round-off and Truncation Errors\n", 9 | "本章介紹各種數值誤差與他們的意義。數值方法往往必須用有限的位數表示自然界中無限的實數，因此絕對會有誤差。比如說一個64位元的浮點數，最高可以精確到小數點後12位；但是32位元的浮點數就只能精準到小數點後7位。當然之後我們會探討「精準到幾位數」又是如何定義的。\n", 10 | "## 誤差 Errors\n", 11 | "### Accuracy vs Precision\n", 12 | "這兩個字翻成中文都是**精準度**，但是他們在意義上有些許不同。Accuracy 偏向準度，Precision 偏向精度。以打靶為例，當你說一個人打靶的Accuracy很高，表示他可能六發都打在靶上沒有脫靶，但是不見得每發都在靶心附近。如果你說這個人Precision很高，那就是他的彈孔非常集中，但這也不代表這些集中的彈孔會在靶心。以數學來說，high accuracy 暗示平均數接近中心，但標準差不見得小；相對的，high precision表示標準差小，但平均不一定接近中心。\n", 13 | "![accuracy_vs_precision](http://cdn.antarcticglaciers.org/wp-content/uploads/2013/11/precision_accuracy.png)" 14 | ] 15 | }, 16 | { 17 | "cell_type": "markdown", 18 | "id": "biological-intervention", 19 | "metadata": {}, 20 | "source": [ 21 | "### 絕對誤差 Absolute Error\n", 22 | "絕對誤差描述的是量測跟真實數值的差異。還記得高中物理做量測的時候嗎。通常量測的數據會有準確項跟估測項。跟那時候一樣，真正的數值就是你能量測到的準確項再加一個誤差\n", 23 | "$$\n", 24 | "true\\ value = measured\\ value + error\n", 25 | "$$\n", 26 | "經過移項就能得到絕對誤差的公式\n", 27 | "$$\n", 28 | "absolute\\ error = {true\\ value - measured\\ value}\n", 29 | "$$" 30 | ] 31 | }, 32 | { 33 | "cell_type": "markdown", 34 | "id": "sustained-density", 35 | "metadata": {}, 36 | "source": [ 37 | "### 相對誤差 Relative Error\n", 38 | "當你的真實數值跟你的量測數值都很大的時候，些微的偏移會有看似很大的誤差，但是可能在實際情況下並不是這一回事。比如說莫耳數，$6.02\\times10^{23}$，每次加一兩滴液體到容器內就是增加十的30幾次方，絕對誤差看起來就高到爆，但是藥劑實際上偏差並不大。這就是用相對誤差的時機。簡單來說就是絕對誤差除上真實數值已達到歸一化(normalize)的作用。常見的相對誤差通常會乘上100%讓他變成 percent relative error\n", 39 | "$$\n", 40 | "percent\\ relative\\ error\\ (\\epsilon_t) = {{{true\\ value - measured\\ value} \\over {true\\ value}} \\times 100\\%}\n", 41 | "$$\n", 42 | "\n", 43 | "當然世間萬物並非完美。有時候你稱為true value的數值根本不能算是真的數值（例如：$\\pi$或是$e$這種無限非循環實數）那我們就只能盡可能的用近似值去推估\n", 44 | "$$\n", 45 | "percent\\ relative\\ error\\ (\\epsilon_a) = {{{true\\ value - measured\\ value} \\over {approximation}} \\times 100\\%}\n", 46 | "$$\n", 47 | "\n", 48 | "有些更糟的情況下，有些演算法只能經過迭代(iteration)得到近似值。這種情況下就只能根據現在的數值去推測誤差\n", 49 | "$$\n", 50 | "percent\\ relative\\ error\\ (\\epsilon_a) = {{{current\\ approximation - previous\\ approximation} \\over {current\\ approximation}} \\times 100\\%}\n", 51 | "$$\n", 52 | "\n", 53 | "這些迭代式估測當然不能一直迭代下去，通常我們會設定一個終止條件(stopping criteria)讓他在我們認為容許的誤差範圍內就停止。" 54 | ] 55 | }, 56 | { 57 | "cell_type": "markdown", 58 | "id": "binding-intervention", 59 | "metadata": {}, 60 | "source": [ 61 | "> Example 4.1 Error Estimates for Iterative Methods \n", 62 | "exponential 常數可以用下列的無窮迴圈表示\n", 63 | "$$\n", 64 | "e^x = 1 + x + {{x^2}\\over 2} + {{x^3}\\over 3!} + \\dotsb + {{x^n}\\over n!}\n", 65 | "$$\n", 66 | "因為 `numpy.exp` 也只是一個近似，所以我們可以試著用迭代想辦法近似到 `numpy.exp` 的數值" 67 | ] 68 | }, 69 | { 70 | "cell_type": "code", 71 | "execution_count": 1, 72 | "id": "plastic-serial", 73 | "metadata": {}, 74 | "outputs": [ 75 | { 76 | "name": "stdout", 77 | "output_type": "stream", 78 | "text": [ 79 | "1 2.0 2.718281828459045\n", 80 | "2 2.5 2.718281828459045\n", 81 | "3 2.6666666666666665 2.718281828459045\n", 82 | "4 2.708333333333333 2.718281828459045\n", 83 | "5 2.7166666666666663 2.718281828459045\n", 84 | "6 2.7180555555555554 2.718281828459045\n", 85 | "7 2.7182539682539684 2.718281828459045\n", 86 | "8 2.71827876984127 2.718281828459045\n", 87 | "percent relative error of estimate: 0.00011%\n" 88 | ] 89 | } 90 | ], 91 | "source": [ 92 | "import numpy as np\n", 93 | "\n", 94 | "x = 1\n", 95 | "ref_value = np.exp(x)\n", 96 | "approx_exp = 1\n", 97 | "\n", 98 | "n = 1\n", 99 | "while not np.allclose(approx_exp, ref_value, rtol=1e-5):\n", 100 | " # approx_exp += x**n/np.prod(np.arange(1, n+1))\n", 101 | " approx_exp += x**n/np.math.factorial(n)\n", 102 | " print(n, approx_exp, ref_value)\n", 103 | " n += 1\n", 104 | " \n", 105 | "percent_rel_err = (ref_value - approx_exp) / (ref_value) * 100\n", 106 | "print(f'percent relative error of estimate: {percent_rel_err:.5f}%')" 107 | ] 108 | }, 109 | { 110 | "cell_type": "markdown", 111 | "id": "backed-orbit", 112 | "metadata": {}, 113 | "source": [ 114 | "> np.allclose 的close指的是接近。我們利用 while 迴圈檢查第幾項之後才達到我們設定的近似值。allclose 的 `rtol` 參數就是在設定我們的終止條件。你可以試著調整 `rtol` 觀察我們必須花多少項(n)才能達到我們設定的精度" 115 | ] 116 | }, 117 | { 118 | "cell_type": "markdown", 119 | "id": "unlikely-plastic", 120 | "metadata": {}, 121 | "source": [ 122 | "## 捨入誤差 Round-off Errors\n", 123 | "前面有提到，當我們把現實世界數位化之後，我們能表示的數字就被電腦所能表達的數字長度所限制。 \n", 124 | "以尺為例，如果你的尺最小刻度是1mm=0.001m，那你能量到的最小值就是0.001。這支尺沒有辦法表示0.0015，只能將這個數值表示成0.001或是0.002。這個情況就叫做*underflow*也就是我們的精度已經超出我能表示的範圍了。 \n", 125 | "另一個情況是，如果你的尺只有30cm，你永遠無法量超過30公分的蔬菜水果。這種情況就被稱為*overflow*。\n", 126 | "\n", 127 | "### 機器誤差 Machine Epsilon\n", 128 | "除了上述兩種情況之外，還有另一個比較特殊的情況。為了讓我們每個數字都能用相同的位數表示，所以會用科學符號來代表。比如說在 IEEE 754 的規範中，就規定雙精度浮點數(double precision float)在記憶體中的排列必須是: `1位元 正負號(sign) + 11位元 次方數(exponent) + 52位元 尾數(mantissa)`。為了讓大家了解，我們來假設一個基本的10進位系統\n", 129 | "$$\n", 130 | "s_1 d_1.d_2 \\times 10^{s_0 d_0}\n", 131 | "$$\n", 132 | "$s_1$ 表示尾數的正負號，$d_1$ 表示整數部份，$d_2$ 表示小數部份；$s_0$ 表示次方的正負號，$d_0$ 表示次方的值。用最基本的尾數兩位、次方介於-2到+2之間來描述的話，我們能量測到的極值為 $\\pm9.99\\times 10^{+2}$ 也就是 -999 跟 999，超出這個範圍的就是overflow。能量到最趨近於0的數值為 $\\pm0.01 \\times 10^{-2}$ 也就是 -0.0001 跟 0.0001，在這個數值中間的都會underflow - 無法表示。接下來我們來看正的數列。在 $0.01 \\times 10^{-2}$ 到 $1.00 \\times 10^{-2}$ 之間我們的每次步進(step)都是0.0001, 但是如果你一到 $0.01 \\times 10^{-1}$ 跟 $1.00 \\times 10^{-1}$ 的區間你每個間隔都變成0.01，這就表示你的次方離最小值越來越遠就會有更多無法表示得空洞(hole)。而且在$\\lt1.00 \\times 10^{-2}$的區間內我們能遇到的最大相對誤差會落在step大小一半的位置\n", 133 | "$$\n", 134 | "\\frac{1.00 - 0.99}{2} \\times 10^{-2} = 0.00005\n", 135 | "$$\n", 136 | "\n", 137 | "0.00005 就是我們的機器誤差($\\epsilon$)。\n", 138 | "在 numpy 你可以用finfo (讀作f-info) 還獲得當下型別的機器誤差。" 139 | ] 140 | }, 141 | { 142 | "cell_type": "code", 143 | "execution_count": 6, 144 | "id": "subjective-aberdeen", 145 | "metadata": {}, 146 | "outputs": [ 147 | { 148 | "name": "stdout", 149 | "output_type": "stream", 150 | "text": [ 151 | "machine epsilon for a 64-bit float (compliant to IEEE 754) 2.220446049250313e-16\n", 152 | "1024\n" 153 | ] 154 | } 155 | ], 156 | "source": [ 157 | "print(f'machine epsilon for a {np.finfo(np.float64).bits}-bit float (compliant to IEEE 754) {np.finfo(np.float64).eps}')\n", 158 | "print(f'{np.finfo(np.float64).maxexp}')" 159 | ] 160 | }, 161 | { 162 | "cell_type": "markdown", 163 | "id": "double-number", 164 | "metadata": {}, 165 | "source": [ 166 | "大多數的語言對機器誤差的定義跟要求都是相同的，也就是四則運算後的結果通常是 $0.5\\epsilon$。但是在比較舊的函式庫 (i.e. BLAS) 經過四則運算後只能保證 $1\\epsilon$ 所以使用上要特別注意。\n", 167 | "\n", 168 | "你可能會問，不會阿我永遠不會用到 BLAS (Basic Linear Algebra Subroutines) 不知道沒關係。但是實際上在使用C/C++做複雜科學運算的時候，有時候會用BLAS做結合。因為 BLAS 是經過數十年最佳化的矩陣運算函式，所以有時候非用不可。" 169 | ] 170 | }, 171 | { 172 | "cell_type": "markdown", 173 | "id": "ancient-franklin", 174 | "metadata": {}, 175 | "source": [ 176 | "## 截斷誤差 Trucation Error\n", 177 | "截斷誤差就是數學運算過程中經過近似所產生的誤差。最明顯的例子就是微分\n", 178 | "$$\n", 179 | "\\frac{dv}{dt} \\approx \\frac{\\Delta v}{\\Delta t}\n", 180 | "$$\n", 181 | "當你的$\\Delta t$不夠小的時候，割線跟切線會有一定的誤差。另一個例子是泰勒序列 (Taylor Series)。雖然他能近似任何連續函數，但是必須要有無限項，因此必定會有截斷誤差。" 182 | ] 183 | }, 184 | { 185 | "cell_type": "markdown", 186 | "id": "anticipated-vessel", 187 | "metadata": {}, 188 | "source": [ 189 | "## 總數值誤差 Total Numerical Error\n", 190 | "一樣用微分為例。上面提到$\\Delta t$必須趨近於零才能讓割線等於切線。但是太小又會讓$\\Delta t$本身underflow或是運算數值小於機器誤差。此外還有電腦資源的限制，因此這一切都是工程師需要考慮的trade-off。" 191 | ] 192 | }, 193 | { 194 | "cell_type": "code", 195 | "execution_count": null, 196 | "id": "understood-friendship", 197 | "metadata": {}, 198 | "outputs": [], 199 | "source": [] 200 | } 201 | ], 202 | "metadata": { 203 | "kernelspec": { 204 | "display_name": "Python 3", 205 | "language": "python", 206 | "name": "python3" 207 | }, 208 | "language_info": { 209 | "codemirror_mode": { 210 | "name": "ipython", 211 | "version": 3 212 | }, 213 | "file_extension": ".py", 214 | "mimetype": "text/x-python", 215 | "name": "python", 216 | "nbconvert_exporter": "python", 217 | "pygments_lexer": "ipython3", 218 | "version": "3.7.7" 219 | } 220 | }, 221 | "nbformat": 4, 222 | "nbformat_minor": 5 223 | } 224 | -------------------------------------------------------------------------------- /notebooks/Fundamentals.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "extra-career", 6 | "metadata": {}, 7 | "source": [ 8 | "# 基本操作\n", 9 | "上個章節我們並沒有深入講解`numpy`跟`matplotlib`的操作。這個章節我們就稍微提一些常用功能。首先，numpy是個用C語言寫成的函式庫，支援多維度陣列(N-Dimensional Array)。首先我們就來看看要如何令一個陣列。\n", 10 | "## 變數指定 Assignments" 11 | ] 12 | }, 13 | { 14 | "cell_type": "code", 15 | "execution_count": 1, 16 | "id": "analyzed-making", 17 | "metadata": {}, 18 | "outputs": [ 19 | { 20 | "data": { 21 | "text/plain": [ 22 | "array([[1, 2],\n", 23 | " [3, 4],\n", 24 | " [5, 6]])" 25 | ] 26 | }, 27 | "execution_count": 1, 28 | "metadata": {}, 29 | "output_type": "execute_result" 30 | } 31 | ], 32 | "source": [ 33 | "import numpy as np\n", 34 | "arr = np.array([[1, 2], [3, 4], [5, 6]])\n", 35 | "arr" 36 | ] 37 | }, 38 | { 39 | "cell_type": "markdown", 40 | "id": "united-validity", 41 | "metadata": {}, 42 | "source": [ 43 | "這就是一個一維陣列，要注意的是，numpy的陣列是不能修改長度的，而且每個數值都必須是相同的型別(type)。這一點跟python內建的`list`很不一樣。這格特性是源自於C/C++的陣列的用法。 \n", 44 | "numpy的陣列有幾個重要的attribute(屬性)\n", 45 | "* ndim: number of dimensions；維度\n", 46 | "* shape: shape of ndarray；每個維度的長度\n", 47 | "* dtype: underlying data type of each element；每個資料的型別\n", 48 | "* size: number of elements；有幾筆資料，shape所有長度的乘積" 49 | ] 50 | }, 51 | { 52 | "cell_type": "code", 53 | "execution_count": 2, 54 | "id": "incomplete-product", 55 | "metadata": {}, 56 | "outputs": [ 57 | { 58 | "name": "stdout", 59 | "output_type": "stream", 60 | "text": [ 61 | "\n", 62 | "arr dimension: 2\n", 63 | "arr shape: (3, 2)\n", 64 | "arr element data type: int64\n", 65 | "arr number of elements: 6\n" 66 | ] 67 | } 68 | ], 69 | "source": [ 70 | "print(type(arr))\n", 71 | "print('arr dimension:', arr.ndim)\n", 72 | "print('arr shape:', arr.shape)\n", 73 | "print('arr element data type:', arr.dtype)\n", 74 | "print('arr number of elements:', arr.size)" 75 | ] 76 | }, 77 | { 78 | "cell_type": "markdown", 79 | "id": "metallic-invalid", 80 | "metadata": {}, 81 | "source": [ 82 | "### 科學常數\n", 83 | "numpy內建許多科學常數，比如最常見的($\\pi$)、數值無限($\\infty$)、非數值(Not a Number, NaN)都有明確定義。他跟python內建的`math`模組所定義的常數是可以互換的。那位什麼不用math就好？因為這樣能少一個import很方便。" 84 | ] 85 | }, 86 | { 87 | "cell_type": "code", 88 | "execution_count": 3, 89 | "id": "injured-mechanics", 90 | "metadata": {}, 91 | "outputs": [ 92 | { 93 | "name": "stdout", 94 | "output_type": "stream", 95 | "text": [ 96 | "True\n" 97 | ] 98 | } 99 | ], 100 | "source": [ 101 | "import math\n", 102 | "print(np.inf == math.inf)" 103 | ] 104 | }, 105 | { 106 | "cell_type": "markdown", 107 | "id": "gorgeous-hundred", 108 | "metadata": {}, 109 | "source": [ 110 | "### 陣列、矩陣、高維度陣列 Arrays, Matrices, and ndarrays\n", 111 | "除了前面提到可以利用`numpy.array`來建立自己想要的陣列。numpy也提供其他函式方便我們建立一些常用的矩陣。以下列舉一些常用的：\n", 112 | "\n", 113 | "`zeros`: 零矩陣，通常表示為$O$" 114 | ] 115 | }, 116 | { 117 | "cell_type": "code", 118 | "execution_count": 26, 119 | "id": "compressed-battery", 120 | "metadata": {}, 121 | "outputs": [ 122 | { 123 | "data": { 124 | "text/plain": [ 125 | "array([[0., 0.],\n", 126 | " [0., 0.],\n", 127 | " [0., 0.]])" 128 | ] 129 | }, 130 | "execution_count": 26, 131 | "metadata": {}, 132 | "output_type": "execute_result" 133 | } 134 | ], 135 | "source": [ 136 | "np.zeros((3, 2))" 137 | ] 138 | }, 139 | { 140 | "cell_type": "markdown", 141 | "id": "devoted-honduras", 142 | "metadata": {}, 143 | "source": [ 144 | "`ones`: 一矩陣，全部都是一的矩陣" 145 | ] 146 | }, 147 | { 148 | "cell_type": "code", 149 | "execution_count": 27, 150 | "id": "economic-hanging", 151 | "metadata": {}, 152 | "outputs": [ 153 | { 154 | "data": { 155 | "text/plain": [ 156 | "array([[1., 1.],\n", 157 | " [1., 1.],\n", 158 | " [1., 1.]])" 159 | ] 160 | }, 161 | "execution_count": 27, 162 | "metadata": {}, 163 | "output_type": "execute_result" 164 | } 165 | ], 166 | "source": [ 167 | "np.ones((3, 2))" 168 | ] 169 | }, 170 | { 171 | "cell_type": "markdown", 172 | "id": "missing-rebel", 173 | "metadata": {}, 174 | "source": [ 175 | "`empty`: 空矩陣。沒有初始值的記憶體區塊。寫C的可以把他理解為`malloc`，C++可以把他當作是`new[]`。因為沒有定義初始值，所以一開始記憶體內的數值便是亂碼。empty最大的用處是先配一塊記憶體，再用for迴圈將值寫進去。(從C/C++/Java來的應該很熟悉這種操作）" 176 | ] 177 | }, 178 | { 179 | "cell_type": "code", 180 | "execution_count": 28, 181 | "id": "graduate-catalyst", 182 | "metadata": {}, 183 | "outputs": [ 184 | { 185 | "data": { 186 | "text/plain": [ 187 | "array([[4.66017529e-310, 0.00000000e+000, 3.29673704e+180,\n", 188 | " 7.19026821e+252],\n", 189 | " [3.07941658e+175, 1.21906099e-152, 6.09249078e+247,\n", 190 | " 4.95264277e+223]])" 191 | ] 192 | }, 193 | "execution_count": 28, 194 | "metadata": {}, 195 | "output_type": "execute_result" 196 | } 197 | ], 198 | "source": [ 199 | "np.empty((2, 4))" 200 | ] 201 | }, 202 | { 203 | "cell_type": "markdown", 204 | "id": "invisible-comfort", 205 | "metadata": {}, 206 | "source": [ 207 | "`identity`: 單位矩陣。diagonal為1其餘為0的方陣，通常表示為$I$" 208 | ] 209 | }, 210 | { 211 | "cell_type": "code", 212 | "execution_count": 30, 213 | "id": "outside-nightmare", 214 | "metadata": {}, 215 | "outputs": [ 216 | { 217 | "data": { 218 | "text/plain": [ 219 | "array([[1., 0., 0.],\n", 220 | " [0., 1., 0.],\n", 221 | " [0., 0., 1.]])" 222 | ] 223 | }, 224 | "execution_count": 30, 225 | "metadata": {}, 226 | "output_type": "execute_result" 227 | } 228 | ], 229 | "source": [ 230 | "np.identity(3) # can only be square matrix" 231 | ] 232 | }, 233 | { 234 | "cell_type": "markdown", 235 | "id": "efficient-permit", 236 | "metadata": {}, 237 | "source": [ 238 | "### 序列生成 Sequence Generation\n", 239 | "除了上述矩陣之外，我們有時候也會需要產生一組序列，方便我們迭代或取值。`numpy.arrange`就是這個功能。他跟python內建`range`的差異就是`numpy.arrange`產生的是`numpy.ndarray`所以比較方便操作。此外python range 產生的是generator而不是list，所以如果要得到list還要自己unpack。" 240 | ] 241 | }, 242 | { 243 | "cell_type": "code", 244 | "execution_count": 5, 245 | "id": "wrapped-tribe", 246 | "metadata": {}, 247 | "outputs": [ 248 | { 249 | "name": "stdout", 250 | "output_type": "stream", 251 | "text": [ 252 | "[1, 2, 3, 4, 5] \n", 253 | "[1 2 3 4 5] \n" 254 | ] 255 | } 256 | ], 257 | "source": [ 258 | "py_range = [i for i in range(1, 6)]\n", 259 | "print(py_range, type(py_range))\n", 260 | "np_arange = np.arange(1, 6, step=1)\n", 261 | "print(np_arange, type(np_arange))" 262 | ] 263 | }, 264 | { 265 | "cell_type": "markdown", 266 | "id": "sensitive-greek", 267 | "metadata": {}, 268 | "source": [ 269 | "此外numpy跟matlab一樣也有`linspace`跟`logspace`。這兩個基本上就是幫你產生線性的座標點，或是對數的座標點，在繪圖的時候很方便。" 270 | ] 271 | }, 272 | { 273 | "cell_type": "code", 274 | "execution_count": 31, 275 | "id": "powered-leather", 276 | "metadata": {}, 277 | "outputs": [ 278 | { 279 | "data": { 280 | "text/plain": [ 281 | "array([1. , 2.25, 3.5 , 4.75, 6. ])" 282 | ] 283 | }, 284 | "execution_count": 31, 285 | "metadata": {}, 286 | "output_type": "execute_result" 287 | } 288 | ], 289 | "source": [ 290 | "np.linspace(1, 6, 5)" 291 | ] 292 | }, 293 | { 294 | "cell_type": "code", 295 | "execution_count": 32, 296 | "id": "stunning-cherry", 297 | "metadata": {}, 298 | "outputs": [ 299 | { 300 | "data": { 301 | "text/plain": [ 302 | "array([1.00000000e+01, 1.77827941e+02, 3.16227766e+03, 5.62341325e+04,\n", 303 | " 1.00000000e+06])" 304 | ] 305 | }, 306 | "execution_count": 32, 307 | "metadata": {}, 308 | "output_type": "execute_result" 309 | } 310 | ], 311 | "source": [ 312 | "np.logspace(1, 6, 5)" 313 | ] 314 | }, 315 | { 316 | "cell_type": "markdown", 317 | "id": "blank-wright", 318 | "metadata": {}, 319 | "source": [ 320 | "> 你可以調整`numpy.arange`跟`numpy.linspace`的第三個參數觀察他們的不同之處。arange的第三個參數是*點到點之間的間隔*，而linspace則是*從頭到尾必須分割出多少點*" 321 | ] 322 | }, 323 | { 324 | "cell_type": "markdown", 325 | "id": "bored-fabric", 326 | "metadata": {}, 327 | "source": [ 328 | "## 數學運算 Mathematical operations\n", 329 | "numpy.ndarray支援所有python的數學運算。也就是加減乘除跟次方(a**2)。當然，bitwise operatrion 如且(&)、或(|)、非(~)以及XOR(^)也都是支援的。" 330 | ] 331 | }, 332 | { 333 | "cell_type": "code", 334 | "execution_count": 36, 335 | "id": "velvet-stanford", 336 | "metadata": {}, 337 | "outputs": [ 338 | { 339 | "name": "stdout", 340 | "output_type": "stream", 341 | "text": [ 342 | "[1.2 1.4 1.6 1.8 2. ]\n" 343 | ] 344 | } 345 | ], 346 | "source": [ 347 | "a = np.arange(1, 6)\n", 348 | "b = np.ones(5)\n", 349 | "print(a * 0.2 + b)" 350 | ] 351 | }, 352 | { 353 | "cell_type": "code", 354 | "execution_count": 37, 355 | "id": "canadian-baseball", 356 | "metadata": {}, 357 | "outputs": [ 358 | { 359 | "data": { 360 | "text/plain": [ 361 | "array([ 1, 4, 9, 16, 25])" 362 | ] 363 | }, 364 | "execution_count": 37, 365 | "metadata": {}, 366 | "output_type": "execute_result" 367 | } 368 | ], 369 | "source": [ 370 | "a**2" 371 | ] 372 | }, 373 | { 374 | "cell_type": "markdown", 375 | "id": "foster-madagascar", 376 | "metadata": {}, 377 | "source": [ 378 | "跟python內建的數字做四則運算也是OK的" 379 | ] 380 | }, 381 | { 382 | "cell_type": "code", 383 | "execution_count": 38, 384 | "id": "specific-defendant", 385 | "metadata": {}, 386 | "outputs": [ 387 | { 388 | "data": { 389 | "text/plain": [ 390 | "array([3., 3., 3., 3., 3.])" 391 | ] 392 | }, 393 | "execution_count": 38, 394 | "metadata": {}, 395 | "output_type": "execute_result" 396 | } 397 | ], 398 | "source": [ 399 | "b * 3 # works with scalars too" 400 | ] 401 | }, 402 | { 403 | "cell_type": "markdown", 404 | "id": "automated-platform", 405 | "metadata": {}, 406 | "source": [ 407 | "此外我們最在乎的當然不是上面那些一對一的運算，而是矩陣運算。numpy也有提供矩陣法。以下顯示內積的作法：" 408 | ] 409 | }, 410 | { 411 | "cell_type": "code", 412 | "execution_count": 39, 413 | "id": "guilty-share", 414 | "metadata": {}, 415 | "outputs": [ 416 | { 417 | "name": "stdout", 418 | "output_type": "stream", 419 | "text": [ 420 | "[0.55 0.45]\n" 421 | ] 422 | } 423 | ], 424 | "source": [ 425 | "x = np.array([0.1, 0.9]) # vector\n", 426 | "\n", 427 | "A = np.array([[0.1, 0.6], # matrix\n", 428 | " [0.9, 0.4]])\n", 429 | "\n", 430 | "# all three statements are equivilent\n", 431 | "x1 = A @ x\n", 432 | "# x1 = A.dot(x)\n", 433 | "# x1 = np.dot(A, x)\n", 434 | "print(x1)" 435 | ] 436 | }, 437 | { 438 | "cell_type": "markdown", 439 | "id": "manufactured-orleans", 440 | "metadata": {}, 441 | "source": [ 442 | "## Numpy 通用函式 Numpy Universal Functions\n", 443 | "除了四則運算其他函式也不可少。numpy當然應有盡有。這些函式`math`模組也有，但是math的函式不能用在ndarray上，但numpy的通用函式可以用在python內建型別，所以能用numpy就用numpy。工程上常見的就是下面幾種：\n", 444 | "指數與對數：exponential指數 [`np.exp(x)`](https://numpy.org/doc/stable/reference/generated/numpy.exp.html), 自然對數 [`np.log(x)`](https://numpy.org/doc/stable/reference/generated/numpy.log.html), 以10為底的對數 $log_{10}(x)$ [`np.log10(x)`](https://numpy.org/doc/stable/reference/generated/numpy.log10.html)" 445 | ] 446 | }, 447 | { 448 | "cell_type": "code", 449 | "execution_count": 41, 450 | "id": "failing-allergy", 451 | "metadata": {}, 452 | "outputs": [ 453 | { 454 | "name": "stdout", 455 | "output_type": "stream", 456 | "text": [ 457 | "2.718281828459045\n", 458 | "[[2.71828183 2.71828183]\n", 459 | " [2.71828183 2.71828183]\n", 460 | " [2.71828183 2.71828183]]\n" 461 | ] 462 | } 463 | ], 464 | "source": [ 465 | "# numpy works with both scalar and ndarrays!\n", 466 | "arr = np.ones((3, 2))\n", 467 | "print(np.exp(1))\n", 468 | "print(np.exp(arr))\n", 469 | "# print(math.exp(arr)) # TypeError, math only works with scalars" 470 | ] 471 | }, 472 | { 473 | "cell_type": "markdown", 474 | "id": "sealed-donor", 475 | "metadata": {}, 476 | "source": [ 477 | "三角函數系列：包含一般三角函數 [`np.sin`](https://numpy.org/doc/stable/reference/generated/numpy.sin.html), [`np.cos`](https://numpy.org/doc/stable/reference/generated/numpy.cos.html); hyperbolic三角函數 [`np.sinh`](https://numpy.org/doc/stable/reference/generated/numpy.sinh.html), [`np.cosh`](https://numpy.org/doc/stable/reference/generated/numpy.cosh.html); 反函數 [`np.arcsin`](https://numpy.org/doc/stable/reference/generated/numpy.arcsin.html)。三角函數相關的參數都是以徑度(radians)為單位。所以numpy也提供了一些函數幫你簡易轉換。[`np.deg2rad`](https://numpy.org/doc/stable/reference/generated/numpy.deg2rad.html) 從角度(degrees)轉成徑度(radians)，反之 [`np.rad2deg`](https://numpy.org/doc/stable/reference/generated/numpy.rad2deg.html) 就是徑度轉成角度。\n", 478 | "> deg2rad 讀作 *degrees-to-radians*，讀成 *deg二rad* 就low 掉了。\n", 479 | "\n", 480 | "有方向性的三角函數：例如 [`np.arctan2`](https://numpy.org/doc/stable/reference/generated/numpy.arctan2.html) 也蠻重要的。" 481 | ] 482 | }, 483 | { 484 | "cell_type": "code", 485 | "execution_count": 45, 486 | "id": "promotional-charge", 487 | "metadata": {}, 488 | "outputs": [ 489 | { 490 | "name": "stdout", 491 | "output_type": "stream", 492 | "text": [ 493 | "1.0\n", 494 | "pi/4 45.0 degrees\n", 495 | "arctan(1) is 45.0 degrees\n" 496 | ] 497 | } 498 | ], 499 | "source": [ 500 | "print(np.sin(np.pi/2)) # 90 degrees\n", 501 | "print(f'pi/4 {np.rad2deg(np.pi/4)} degrees')\n", 502 | "print('arctan(1) is', np.rad2deg(np.arctan(1)), 'degrees')" 503 | ] 504 | }, 505 | { 506 | "cell_type": "markdown", 507 | "id": "talented-morocco", 508 | "metadata": {}, 509 | "source": [ 510 | "有方向性的三角函數：例如 [`np.arctan2`](https://numpy.org/doc/stable/reference/generated/numpy.arctan2.html) 也蠻重要的。因為第二跟第四象限、或是第一跟第三象限的三角函數值是正負號是相同的。所以有時候把分子(numerator)跟分母(denominator)拆開才會獲得正確的結果。" 511 | ] 512 | }, 513 | { 514 | "cell_type": "code", 515 | "execution_count": 52, 516 | "id": "mature-wings", 517 | "metadata": {}, 518 | "outputs": [ 519 | { 520 | "name": "stdout", 521 | "output_type": "stream", 522 | "text": [ 523 | "135.0\n", 524 | "-45.0\n" 525 | ] 526 | } 527 | ], 528 | "source": [ 529 | "# np.arctan2(y, x)\n", 530 | "print(np.rad2deg(np.arctan2(1, -1))) # 2nd quadrant (x-, y+)\n", 531 | "print(np.rad2deg(np.arctan2(-1, 1))) # 4th quadrant (x+, y-)" 532 | ] 533 | }, 534 | { 535 | "cell_type": "markdown", 536 | "id": "thousand-planner", 537 | "metadata": {}, 538 | "source": [ 539 | "進位、捨去：無條件捨去 [`np.floor(x)`](https://numpy.org/doc/stable/reference/generated/numpy.floor.html), 無條件進位 [`np.ceil(x)`](https://numpy.org/doc/stable/reference/generated/numpy.ceil.html), 四捨六入五雙數 [`np.around(x)`](https://numpy.org/doc/stable/reference/generated/numpy.around.html)" 540 | ] 541 | }, 542 | { 543 | "cell_type": "code", 544 | "execution_count": 46, 545 | "id": "earned-lightweight", 546 | "metadata": {}, 547 | "outputs": [ 548 | { 549 | "name": "stdout", 550 | "output_type": "stream", 551 | "text": [ 552 | "[[1.27 1.27]\n", 553 | " [1.27 1.27]\n", 554 | " [1.27 1.27]]\n" 555 | ] 556 | } 557 | ], 558 | "source": [ 559 | "# rounding\n", 560 | "arr = np.full((3, 2), 1.275)\n", 561 | "# print(np.floor(arr))\n", 562 | "# print(np.ceil(arr))\n", 563 | "print(np.around(arr, decimals=2))" 564 | ] 565 | }, 566 | { 567 | "cell_type": "markdown", 568 | "id": "wooden-highland", 569 | "metadata": {}, 570 | "source": [ 571 | "Reducing Function：可以縮減維度的函式。比如說 [`np.sum`](https://numpy.org/doc/stable/reference/generated/numpy.sum.html)可以用以下的數學式表示\n", 572 | "$$\n", 573 | "\\textbf{v} = {\\sum_{\\forall i} \\textbf{A}_{ij}}\n", 574 | "$$\n", 575 | "根據上面的式子可以觀察到我們不僅可以把向量加總成單一數值，也可以把根據不同的方向降維。在numpy裡方向被稱為axis。" 576 | ] 577 | }, 578 | { 579 | "cell_type": "code", 580 | "execution_count": 55, 581 | "id": "valid-mineral", 582 | "metadata": {}, 583 | "outputs": [ 584 | { 585 | "name": "stdout", 586 | "output_type": "stream", 587 | "text": [ 588 | "21\n", 589 | "[ 9 12]\n", 590 | "[ 3 7 11]\n" 591 | ] 592 | } 593 | ], 594 | "source": [ 595 | "A = np.array([[1, 2],\n", 596 | " [3, 4],\n", 597 | " [5, 6]])\n", 598 | "print(np.sum(A)) # axis defaults to -1, which means \"all elements\"\n", 599 | "print(np.sum(A, axis=0)) # sum in the row direction\n", 600 | "print(np.sum(A, axis=1)) # sum in the column direction" 601 | ] 602 | }, 603 | { 604 | "cell_type": "markdown", 605 | "id": "casual-browse", 606 | "metadata": {}, 607 | "source": [ 608 | "當然不只加總，我們也可以用[`np.prod`](https://numpy.org/doc/stable/reference/generated/numpy.prod.html)表示連乘\n", 609 | "$$\n", 610 | "\\textbf{v} = {\\prod_{\\forall i} \\textbf{A}_{ij}}\n", 611 | "$$" 612 | ] 613 | }, 614 | { 615 | "cell_type": "code", 616 | "execution_count": 57, 617 | "id": "advanced-pendant", 618 | "metadata": {}, 619 | "outputs": [ 620 | { 621 | "name": "stdout", 622 | "output_type": "stream", 623 | "text": [ 624 | "720\n", 625 | "[15 48]\n", 626 | "[ 2 12 30]\n" 627 | ] 628 | } 629 | ], 630 | "source": [ 631 | "print(np.prod(A)) # equivilent to `6!`\n", 632 | "print(np.prod(A, axis=0))\n", 633 | "print(np.prod(A, axis=1))" 634 | ] 635 | }, 636 | { 637 | "cell_type": "markdown", 638 | "id": "noble-contents", 639 | "metadata": {}, 640 | "source": [ 641 | "當然比大小也OK。" 642 | ] 643 | }, 644 | { 645 | "cell_type": "code", 646 | "execution_count": 58, 647 | "id": "dried-attribute", 648 | "metadata": {}, 649 | "outputs": [ 650 | { 651 | "name": "stdout", 652 | "output_type": "stream", 653 | "text": [ 654 | "[5 6]\n", 655 | "[1 3 5]\n" 656 | ] 657 | } 658 | ], 659 | "source": [ 660 | "print(np.amax(A, axis=0))\n", 661 | "print(np.amin(A, axis=1))" 662 | ] 663 | }, 664 | { 665 | "cell_type": "markdown", 666 | "id": "received-filling", 667 | "metadata": {}, 668 | "source": [ 669 | "## 繪圖 Graphics\n", 670 | "不是每個人都對數字這麼直覺，所以有時候繪圖比較容易理解某些問題。科學相關的繪圖都是用x,y座標點相連來產生圖像。雖然很便利，點越多畫的圖就越精準。\n", 671 | "繪圖的大致流程通常是：\n", 672 | "1. 產生 x 座標\n", 673 | "2. 帶入函數 $y=f(x)$ 得到所有的y座標\n", 674 | "3. 繪製\n", 675 | "4. 修改畫面設定\n", 676 | "\n", 677 | "numpy本身只是拿來運算的，所以這裡我們要用`matplotlib`來進行繪圖。\n", 678 | "\n", 679 | "舉上個章節的解析解為例：\n", 680 | "$$\n", 681 | "v(t)=\\sqrt {{gm} \\over c_d} \\tanh (\\sqrt{{gc_d}\\over m}t)\n", 682 | "$$\n", 683 | "已知的東西可以先設定常數，$g=9.81$、$m=72$、$c_d=0.25$" 684 | ] 685 | }, 686 | { 687 | "cell_type": "code", 688 | "execution_count": 66, 689 | "id": "loved-blond", 690 | "metadata": {}, 691 | "outputs": [ 692 | { 693 | "data": { 694 | "image/png": "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\n", 695 | "text/plain": [ 696 | "
" 697 | ] 698 | }, 699 | "metadata": { 700 | "needs_background": "light" 701 | }, 702 | "output_type": "display_data" 703 | } 704 | ], 705 | "source": [ 706 | "import matplotlib.pyplot as plt\n", 707 | "\n", 708 | "g = 9.81\n", 709 | "m = 72\n", 710 | "cd = 0.25\n", 711 | "\n", 712 | "# step 1\n", 713 | "t = np.arange(0, 12, 1)\n", 714 | "# step 2\n", 715 | "v = np.sqrt(g*m/cd) * np.tanh(np.sqrt(g*cd/m) * t)\n", 716 | "# step 3\n", 717 | "plt.plot(t, v)\n", 718 | "plt.show()" 719 | ] 720 | }, 721 | { 722 | "cell_type": "markdown", 723 | "id": "hairy-bridge", 724 | "metadata": {}, 725 | "source": [ 726 | "et Voila! 圖就出來了！當然這樣的圖別人也不清楚你畫的是什麼，所以通常我們可以佳一些註解。比如說標題title、x軸的單位、y軸的單位等等。\n", 727 | "> 你可以改改`t`最後面的參數step，看看圖會有什麼變化" 728 | ] 729 | }, 730 | { 731 | "cell_type": "code", 732 | "execution_count": 64, 733 | "id": "ordinary-finnish", 734 | "metadata": {}, 735 | "outputs": [ 736 | { 737 | "data": { 738 | "image/png": "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\n", 739 | "text/plain": [ 740 | "
" 741 | ] 742 | }, 743 | "metadata": { 744 | "needs_background": "light" 745 | }, 746 | "output_type": "display_data" 747 | } 748 | ], 749 | "source": [ 750 | "plt.plot(t, v)\n", 751 | "plt.title('speed over time')\n", 752 | "plt.xlabel('time (sec)')\n", 753 | "plt.ylabel('speed (m/s)')\n", 754 | "\n", 755 | "plt.show()" 756 | ] 757 | }, 758 | { 759 | "cell_type": "markdown", 760 | "id": "general-commissioner", 761 | "metadata": {}, 762 | "source": [ 763 | "## 小結\n", 764 | "這個章節我們提到`numpy`跟`maplotlib`最基礎的操作。有了運算跟繪圖我們已經可以做很多事了。" 765 | ] 766 | }, 767 | { 768 | "cell_type": "code", 769 | "execution_count": null, 770 | "id": "shared-rapid", 771 | "metadata": {}, 772 | "outputs": [], 773 | "source": [] 774 | } 775 | ], 776 | "metadata": { 777 | "kernelspec": { 778 | "display_name": "Python 3", 779 | "language": "python", 780 | "name": "python3" 781 | }, 782 | "language_info": { 783 | "codemirror_mode": { 784 | "name": "ipython", 785 | "version": 3 786 | }, 787 | "file_extension": ".py", 788 | "mimetype": "text/x-python", 789 | "name": "python", 790 | "nbconvert_exporter": "python", 791 | "pygments_lexer": "ipython3", 792 | "version": "3.7.7" 793 | } 794 | }, 795 | "nbformat": 4, 796 | "nbformat_minor": 5 797 | } 798 | -------------------------------------------------------------------------------- /Pipfile.lock: -------------------------------------------------------------------------------- 1 | { 2 | "_meta": { 3 | "hash": { 4 | "sha256": "fdf784e975f4d4953cd067cc29d3609c45a962993eb50e43c1597c8d09a078f9" 5 | }, 6 | "pipfile-spec": 6, 7 | "requires": { 8 | "python_version": "3.7" 9 | }, 10 | "sources": [ 11 | { 12 | "name": "pypi", 13 | "url": "https://pypi.org/simple", 14 | "verify_ssl": true 15 | } 16 | ] 17 | }, 18 | "default": { 19 | "anyio": { 20 | "hashes": [ 21 | "sha256:4a41c5b3a65ed92e469d51b6fba3779301850ea2e352afcf9e36c46f21ee14a9", 22 | "sha256:aa3da546ed17f097ca876c78024dea380a3b7fa80759abfdda59f12176a3dac8" 23 | ], 24 | "markers": "python_full_version >= '3.6.2'", 25 | "version": "==2.2.0" 26 | }, 27 | "argon2-cffi": { 28 | "hashes": [ 29 | "sha256:05a8ac07c7026542377e38389638a8a1e9b78f1cd8439cd7493b39f08dd75fbf", 30 | "sha256:0bf066bc049332489bb2d75f69216416329d9dc65deee127152caeb16e5ce7d5", 31 | "sha256:18dee20e25e4be86680b178b35ccfc5d495ebd5792cd00781548d50880fee5c5", 32 | "sha256:392c3c2ef91d12da510cfb6f9bae52512a4552573a9e27600bdb800e05905d2b", 33 | "sha256:57358570592c46c420300ec94f2ff3b32cbccd10d38bdc12dc6979c4a8484fbc", 34 | "sha256:6678bb047373f52bcff02db8afab0d2a77d83bde61cfecea7c5c62e2335cb203", 35 | "sha256:6ea92c980586931a816d61e4faf6c192b4abce89aa767ff6581e6ddc985ed003", 36 | "sha256:77e909cc756ef81d6abb60524d259d959bab384832f0c651ed7dcb6e5ccdbb78", 37 | "sha256:7d455c802727710e9dfa69b74ccaab04568386ca17b0ad36350b622cd34606fe", 38 | "sha256:8a84934bd818e14a17943de8099d41160da4a336bcc699bb4c394bbb9b94bd32", 39 | "sha256:9bee3212ba4f560af397b6d7146848c32a800652301843df06b9e8f68f0f7361", 40 | "sha256:9dfd5197852530294ecb5795c97a823839258dfd5eb9420233c7cfedec2058f2", 41 | "sha256:b160416adc0f012fb1f12588a5e6954889510f82f698e23ed4f4fa57f12a0647", 42 | "sha256:ba7209b608945b889457f949cc04c8e762bed4fe3fec88ae9a6b7765ae82e496", 43 | "sha256:cc0e028b209a5483b6846053d5fd7165f460a1f14774d79e632e75e7ae64b82b", 44 | "sha256:d8029b2d3e4b4cea770e9e5a0104dd8fa185c1724a0f01528ae4826a6d25f97d", 45 | "sha256:da7f0445b71db6d3a72462e04f36544b0de871289b0bc8a7cc87c0f5ec7079fa", 46 | "sha256:e2db6e85c057c16d0bd3b4d2b04f270a7467c147381e8fd73cbbe5bc719832be" 47 | ], 48 | "version": "==20.1.0" 49 | }, 50 | "async-generator": { 51 | "hashes": [ 52 | "sha256:01c7bf666359b4967d2cda0000cc2e4af16a0ae098cbffcb8472fb9e8ad6585b", 53 | "sha256:6ebb3d106c12920aaae42ccb6f787ef5eefdcdd166ea3d628fa8476abe712144" 54 | ], 55 | "markers": "python_version >= '3.5'", 56 | "version": "==1.10" 57 | }, 58 | "attrs": { 59 | "hashes": [ 60 | "sha256:31b2eced602aa8423c2aea9c76a724617ed67cf9513173fd3a4f03e3a929c7e6", 61 | "sha256:832aa3cde19744e49938b91fea06d69ecb9e649c93ba974535d08ad92164f700" 62 | ], 63 | "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3'", 64 | "version": "==20.3.0" 65 | }, 66 | "babel": { 67 | "hashes": [ 68 | "sha256:9d35c22fcc79893c3ecc85ac4a56cde1ecf3f19c540bba0922308a6c06ca6fa5", 69 | "sha256:da031ab54472314f210b0adcff1588ee5d1d1d0ba4dbd07b94dba82bde791e05" 70 | ], 71 | "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3'", 72 | "version": "==2.9.0" 73 | }, 74 | "backcall": { 75 | "hashes": [ 76 | "sha256:5cbdbf27be5e7cfadb448baf0aa95508f91f2bbc6c6437cd9cd06e2a4c215e1e", 77 | "sha256:fbbce6a29f263178a1f7915c1940bde0ec2b2a967566fe1c65c1dfb7422bd255" 78 | ], 79 | "version": "==0.2.0" 80 | }, 81 | "bleach": { 82 | "hashes": [ 83 | "sha256:6123ddc1052673e52bab52cdc955bcb57a015264a1c57d37bea2f6b817af0125", 84 | "sha256:98b3170739e5e83dd9dc19633f074727ad848cbedb6026708c8ac2d3b697a433" 85 | ], 86 | "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3, 3.4'", 87 | "version": "==3.3.0" 88 | }, 89 | "certifi": { 90 | "hashes": [ 91 | "sha256:1a4995114262bffbc2413b159f2a1a480c969de6e6eb13ee966d470af86af59c", 92 | "sha256:719a74fb9e33b9bd44cc7f3a8d94bc35e4049deebe19ba7d8e108280cfd59830" 93 | ], 94 | "version": "==2020.12.5" 95 | }, 96 | "cffi": { 97 | "hashes": [ 98 | "sha256:005a36f41773e148deac64b08f233873a4d0c18b053d37da83f6af4d9087b813", 99 | "sha256:0857f0ae312d855239a55c81ef453ee8fd24136eaba8e87a2eceba644c0d4c06", 100 | "sha256:1071534bbbf8cbb31b498d5d9db0f274f2f7a865adca4ae429e147ba40f73dea", 101 | "sha256:158d0d15119b4b7ff6b926536763dc0714313aa59e320ddf787502c70c4d4bee", 102 | "sha256:1f436816fc868b098b0d63b8920de7d208c90a67212546d02f84fe78a9c26396", 103 | "sha256:2894f2df484ff56d717bead0a5c2abb6b9d2bf26d6960c4604d5c48bbc30ee73", 104 | "sha256:29314480e958fd8aab22e4a58b355b629c59bf5f2ac2492b61e3dc06d8c7a315", 105 | "sha256:34eff4b97f3d982fb93e2831e6750127d1355a923ebaeeb565407b3d2f8d41a1", 106 | "sha256:35f27e6eb43380fa080dccf676dece30bef72e4a67617ffda586641cd4508d49", 107 | "sha256:3d3dd4c9e559eb172ecf00a2a7517e97d1e96de2a5e610bd9b68cea3925b4892", 108 | "sha256:43e0b9d9e2c9e5d152946b9c5fe062c151614b262fda2e7b201204de0b99e482", 109 | "sha256:48e1c69bbacfc3d932221851b39d49e81567a4d4aac3b21258d9c24578280058", 110 | "sha256:51182f8927c5af975fece87b1b369f722c570fe169f9880764b1ee3bca8347b5", 111 | "sha256:58e3f59d583d413809d60779492342801d6e82fefb89c86a38e040c16883be53", 112 | "sha256:5de7970188bb46b7bf9858eb6890aad302577a5f6f75091fd7cdd3ef13ef3045", 113 | "sha256:65fa59693c62cf06e45ddbb822165394a288edce9e276647f0046e1ec26920f3", 114 | "sha256:69e395c24fc60aad6bb4fa7e583698ea6cc684648e1ffb7fe85e3c1ca131a7d5", 115 | "sha256:6c97d7350133666fbb5cf4abdc1178c812cb205dc6f41d174a7b0f18fb93337e", 116 | "sha256:6e4714cc64f474e4d6e37cfff31a814b509a35cb17de4fb1999907575684479c", 117 | "sha256:72d8d3ef52c208ee1c7b2e341f7d71c6fd3157138abf1a95166e6165dd5d4369", 118 | "sha256:8ae6299f6c68de06f136f1f9e69458eae58f1dacf10af5c17353eae03aa0d827", 119 | "sha256:8b198cec6c72df5289c05b05b8b0969819783f9418e0409865dac47288d2a053", 120 | "sha256:99cd03ae7988a93dd00bcd9d0b75e1f6c426063d6f03d2f90b89e29b25b82dfa", 121 | "sha256:9cf8022fb8d07a97c178b02327b284521c7708d7c71a9c9c355c178ac4bbd3d4", 122 | "sha256:9de2e279153a443c656f2defd67769e6d1e4163952b3c622dcea5b08a6405322", 123 | "sha256:9e93e79c2551ff263400e1e4be085a1210e12073a31c2011dbbda14bda0c6132", 124 | "sha256:9ff227395193126d82e60319a673a037d5de84633f11279e336f9c0f189ecc62", 125 | "sha256:a465da611f6fa124963b91bf432d960a555563efe4ed1cc403ba5077b15370aa", 126 | "sha256:ad17025d226ee5beec591b52800c11680fca3df50b8b29fe51d882576e039ee0", 127 | "sha256:afb29c1ba2e5a3736f1c301d9d0abe3ec8b86957d04ddfa9d7a6a42b9367e396", 128 | "sha256:b85eb46a81787c50650f2392b9b4ef23e1f126313b9e0e9013b35c15e4288e2e", 129 | "sha256:bb89f306e5da99f4d922728ddcd6f7fcebb3241fc40edebcb7284d7514741991", 130 | "sha256:cbde590d4faaa07c72bf979734738f328d239913ba3e043b1e98fe9a39f8b2b6", 131 | "sha256:cd2868886d547469123fadc46eac7ea5253ea7fcb139f12e1dfc2bbd406427d1", 132 | "sha256:d42b11d692e11b6634f7613ad8df5d6d5f8875f5d48939520d351007b3c13406", 133 | "sha256:f2d45f97ab6bb54753eab54fffe75aaf3de4ff2341c9daee1987ee1837636f1d", 134 | "sha256:fd78e5fee591709f32ef6edb9a015b4aa1a5022598e36227500c8f4e02328d9c" 135 | ], 136 | "version": "==1.14.5" 137 | }, 138 | "chardet": { 139 | "hashes": [ 140 | "sha256:0d6f53a15db4120f2b08c94f11e7d93d2c911ee118b6b30a04ec3ee8310179fa", 141 | "sha256:f864054d66fd9118f2e67044ac8981a54775ec5b67aed0441892edb553d21da5" 142 | ], 143 | "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3, 3.4'", 144 | "version": "==4.0.0" 145 | }, 146 | "cycler": { 147 | "hashes": [ 148 | "sha256:1d8a5ae1ff6c5cf9b93e8811e581232ad8920aeec647c37316ceac982b08cb2d", 149 | "sha256:cd7b2d1018258d7247a71425e9f26463dfb444d411c39569972f4ce586b0c9d8" 150 | ], 151 | "version": "==0.10.0" 152 | }, 153 | "decorator": { 154 | "hashes": [ 155 | "sha256:41fa54c2a0cc4ba648be4fd43cff00aedf5b9465c9bf18d64325bc225f08f760", 156 | "sha256:e3a62f0520172440ca0dcc823749319382e377f37f140a0b99ef45fecb84bfe7" 157 | ], 158 | "version": "==4.4.2" 159 | }, 160 | "defusedxml": { 161 | "hashes": [ 162 | "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69", 163 | "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61" 164 | ], 165 | "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3, 3.4'", 166 | "version": "==0.7.1" 167 | }, 168 | "entrypoints": { 169 | "hashes": [ 170 | "sha256:589f874b313739ad35be6e0cd7efde2a4e9b6fea91edcc34e58ecbb8dbe56d19", 171 | "sha256:c70dd71abe5a8c85e55e12c19bd91ccfeec11a6e99044204511f9ed547d48451" 172 | ], 173 | "markers": "python_version >= '2.7'", 174 | "version": "==0.3" 175 | }, 176 | "idna": { 177 | "hashes": [ 178 | "sha256:b307872f855b18632ce0c21c5e45be78c0ea7ae4c15c828c20788b26921eb3f6", 179 | "sha256:b97d804b1e9b523befed77c48dacec60e6dcb0b5391d57af6a65a312a90648c0" 180 | ], 181 | "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3'", 182 | "version": "==2.10" 183 | }, 184 | "importlib-metadata": { 185 | "hashes": [ 186 | "sha256:c9db46394197244adf2f0b08ec5bc3cf16757e9590b02af1fca085c16c0d600a", 187 | "sha256:d2d46ef77ffc85cbf7dac7e81dd663fde71c45326131bea8033b9bad42268ebe" 188 | ], 189 | "markers": "python_version < '3.8'", 190 | "version": "==3.10.0" 191 | }, 192 | "ipykernel": { 193 | "hashes": [ 194 | "sha256:21abd584543759e49010975a4621603b3cf871b1039cb3879a14094717692614", 195 | "sha256:a682e4f7affd86d9ce9b699d21bcab6d5ec9fbb2bfcb194f2706973b252bc509" 196 | ], 197 | "markers": "python_version >= '3.5'", 198 | "version": "==5.5.3" 199 | }, 200 | "ipython": { 201 | "hashes": [ 202 | "sha256:9c900332d4c5a6de534b4befeeb7de44ad0cc42e8327fa41b7685abde58cec74", 203 | "sha256:c0ce02dfaa5f854809ab7413c601c4543846d9da81010258ecdab299b542d199" 204 | ], 205 | "markers": "python_version >= '3.7'", 206 | "version": "==7.22.0" 207 | }, 208 | "ipython-genutils": { 209 | "hashes": [ 210 | "sha256:72dd37233799e619666c9f639a9da83c34013a73e8bbc79a7a6348d93c61fab8", 211 | "sha256:eb2e116e75ecef9d4d228fdc66af54269afa26ab4463042e33785b887c628ba8" 212 | ], 213 | "version": "==0.2.0" 214 | }, 215 | "jedi": { 216 | "hashes": [ 217 | "sha256:18456d83f65f400ab0c2d3319e48520420ef43b23a086fdc05dff34132f0fb93", 218 | "sha256:92550a404bad8afed881a137ec9a461fed49eca661414be45059329614ed0707" 219 | ], 220 | "markers": "python_version >= '3.6'", 221 | "version": "==0.18.0" 222 | }, 223 | "jinja2": { 224 | "hashes": [ 225 | "sha256:03e47ad063331dd6a3f04a43eddca8a966a26ba0c5b7207a9a9e4e08f1b29419", 226 | "sha256:a6d58433de0ae800347cab1fa3043cebbabe8baa9d29e668f1c768cb87a333c6" 227 | ], 228 | "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3, 3.4'", 229 | "version": "==2.11.3" 230 | }, 231 | "json5": { 232 | "hashes": [ 233 | "sha256:703cfee540790576b56a92e1c6aaa6c4b0d98971dc358ead83812aa4d06bdb96", 234 | "sha256:af1a1b9a2850c7f62c23fde18be4749b3599fd302f494eebf957e2ada6b9e42c" 235 | ], 236 | "version": "==0.9.5" 237 | }, 238 | "jsonschema": { 239 | "hashes": [ 240 | "sha256:4e5b3cf8216f577bee9ce139cbe72eca3ea4f292ec60928ff24758ce626cd163", 241 | "sha256:c8a85b28d377cc7737e46e2d9f2b4f44ee3c0e1deac6bf46ddefc7187d30797a" 242 | ], 243 | "version": "==3.2.0" 244 | }, 245 | "jupyter-client": { 246 | "hashes": [ 247 | "sha256:c4bca1d0846186ca8be97f4d2fa6d2bae889cce4892a167ffa1ba6bd1f73e782", 248 | "sha256:e053a2c44b6fa597feebe2b3ecb5eea3e03d1d91cc94351a52931ee1426aecfc" 249 | ], 250 | "markers": "python_version >= '3.5'", 251 | "version": "==6.1.12" 252 | }, 253 | "jupyter-core": { 254 | "hashes": [ 255 | "sha256:79025cb3225efcd36847d0840f3fc672c0abd7afd0de83ba8a1d3837619122b4", 256 | "sha256:8c6c0cac5c1b563622ad49321d5ec47017bd18b94facb381c6973a0486395f8e" 257 | ], 258 | "markers": "python_version >= '3.6'", 259 | "version": "==4.7.1" 260 | }, 261 | "jupyter-packaging": { 262 | "hashes": [ 263 | "sha256:b140325771881a7df7b7f2d14997b619063fe75ae756b9025852e4346000bbb8", 264 | "sha256:e36efa5edd52b302f0b784ff2a4d1f2cd50f7058af331151315e98b73f947b8d" 265 | ], 266 | "markers": "python_version >= '3.6'", 267 | "version": "==0.7.12" 268 | }, 269 | "jupyter-server": { 270 | "hashes": [ 271 | "sha256:951b944f25dcf7e34106415859630273f59a472fdb24e866f63ef431b232d3a0", 272 | "sha256:db646c991c17ad3dff12e419d36e2b91025912dfd21d13f8ddd524531e6d63bf" 273 | ], 274 | "markers": "python_version >= '3.6'", 275 | "version": "==1.5.1" 276 | }, 277 | "jupyterlab": { 278 | "hashes": [ 279 | "sha256:929c60d7fb4aa704084c02d8ededc209b8b378e0b3adab46158b7fa6acc24230", 280 | "sha256:dbbbf6329c18422e7e22e95494933e7ea28b0fad09965cd60431b1b857f80ca2" 281 | ], 282 | "index": "pypi", 283 | "version": "==3.0.12" 284 | }, 285 | "jupyterlab-pygments": { 286 | "hashes": [ 287 | "sha256:abfb880fd1561987efaefcb2d2ac75145d2a5d0139b1876d5be806e32f630008", 288 | "sha256:cfcda0873626150932f438eccf0f8bf22bfa92345b814890ab360d666b254146" 289 | ], 290 | "version": "==0.1.2" 291 | }, 292 | "jupyterlab-server": { 293 | "hashes": [ 294 | "sha256:2a7f0b125a59a7cc543f62e5f9dea50b44b3459b3f679db7e3dbe0f8616f90bc", 295 | "sha256:94e606edb7b60e3fc54b8b4de14cded1483959361df9023e50092b6f8ede9cf6" 296 | ], 297 | "markers": "python_version >= '3.6'", 298 | "version": "==2.4.0" 299 | }, 300 | "kiwisolver": { 301 | "hashes": [ 302 | "sha256:0cd53f403202159b44528498de18f9285b04482bab2a6fc3f5dd8dbb9352e30d", 303 | "sha256:1e1bc12fb773a7b2ffdeb8380609f4f8064777877b2225dec3da711b421fda31", 304 | "sha256:225e2e18f271e0ed8157d7f4518ffbf99b9450fca398d561eb5c4a87d0986dd9", 305 | "sha256:232c9e11fd7ac3a470d65cd67e4359eee155ec57e822e5220322d7b2ac84fbf0", 306 | "sha256:31dfd2ac56edc0ff9ac295193eeaea1c0c923c0355bf948fbd99ed6018010b72", 307 | "sha256:33449715e0101e4d34f64990352bce4095c8bf13bed1b390773fc0a7295967b3", 308 | "sha256:401a2e9afa8588589775fe34fc22d918ae839aaaf0c0e96441c0fdbce6d8ebe6", 309 | "sha256:44a62e24d9b01ba94ae7a4a6c3fb215dc4af1dde817e7498d901e229aaf50e4e", 310 | "sha256:50af681a36b2a1dee1d3c169ade9fdc59207d3c31e522519181e12f1b3ba7000", 311 | "sha256:563c649cfdef27d081c84e72a03b48ea9408c16657500c312575ae9d9f7bc1c3", 312 | "sha256:5989db3b3b34b76c09253deeaf7fbc2707616f130e166996606c284395da3f18", 313 | "sha256:5a7a7dbff17e66fac9142ae2ecafb719393aaee6a3768c9de2fd425c63b53e21", 314 | "sha256:5c3e6455341008a054cccee8c5d24481bcfe1acdbc9add30aa95798e95c65621", 315 | "sha256:5f6ccd3dd0b9739edcf407514016108e2280769c73a85b9e59aa390046dbf08b", 316 | "sha256:72c99e39d005b793fb7d3d4e660aed6b6281b502e8c1eaf8ee8346023c8e03bc", 317 | "sha256:78751b33595f7f9511952e7e60ce858c6d64db2e062afb325985ddbd34b5c131", 318 | "sha256:834ee27348c4aefc20b479335fd422a2c69db55f7d9ab61721ac8cd83eb78882", 319 | "sha256:8be8d84b7d4f2ba4ffff3665bcd0211318aa632395a1a41553250484a871d454", 320 | "sha256:950a199911a8d94683a6b10321f9345d5a3a8433ec58b217ace979e18f16e248", 321 | "sha256:a357fd4f15ee49b4a98b44ec23a34a95f1e00292a139d6015c11f55774ef10de", 322 | "sha256:a53d27d0c2a0ebd07e395e56a1fbdf75ffedc4a05943daf472af163413ce9598", 323 | "sha256:acef3d59d47dd85ecf909c359d0fd2c81ed33bdff70216d3956b463e12c38a54", 324 | "sha256:b38694dcdac990a743aa654037ff1188c7a9801ac3ccc548d3341014bc5ca278", 325 | "sha256:b9edd0110a77fc321ab090aaa1cfcaba1d8499850a12848b81be2222eab648f6", 326 | "sha256:c08e95114951dc2090c4a630c2385bef681cacf12636fb0241accdc6b303fd81", 327 | "sha256:c5518d51a0735b1e6cee1fdce66359f8d2b59c3ca85dc2b0813a8aa86818a030", 328 | "sha256:c8fd0f1ae9d92b42854b2979024d7597685ce4ada367172ed7c09edf2cef9cb8", 329 | "sha256:ca3820eb7f7faf7f0aa88de0e54681bddcb46e485beb844fcecbcd1c8bd01689", 330 | "sha256:cf8b574c7b9aa060c62116d4181f3a1a4e821b2ec5cbfe3775809474113748d4", 331 | "sha256:d3155d828dec1d43283bd24d3d3e0d9c7c350cdfcc0bd06c0ad1209c1bbc36d0", 332 | "sha256:f8d6f8db88049a699817fd9178782867bf22283e3813064302ac59f61d95be05", 333 | "sha256:fd34fbbfbc40628200730bc1febe30631347103fc8d3d4fa012c21ab9c11eca9" 334 | ], 335 | "markers": "python_version >= '3.6'", 336 | "version": "==1.3.1" 337 | }, 338 | "markupsafe": { 339 | "hashes": [ 340 | "sha256:00bc623926325b26bb9605ae9eae8a215691f33cae5df11ca5424f06f2d1f473", 341 | "sha256:09027a7803a62ca78792ad89403b1b7a73a01c8cb65909cd876f7fcebd79b161", 342 | "sha256:09c4b7f37d6c648cb13f9230d847adf22f8171b1ccc4d5682398e77f40309235", 343 | "sha256:1027c282dad077d0bae18be6794e6b6b8c91d58ed8a8d89a89d59693b9131db5", 344 | "sha256:13d3144e1e340870b25e7b10b98d779608c02016d5184cfb9927a9f10c689f42", 345 | "sha256:195d7d2c4fbb0ee8139a6cf67194f3973a6b3042d742ebe0a9ed36d8b6f0c07f", 346 | "sha256:22c178a091fc6630d0d045bdb5992d2dfe14e3259760e713c490da5323866c39", 347 | "sha256:24982cc2533820871eba85ba648cd53d8623687ff11cbb805be4ff7b4c971aff", 348 | "sha256:29872e92839765e546828bb7754a68c418d927cd064fd4708fab9fe9c8bb116b", 349 | "sha256:2beec1e0de6924ea551859edb9e7679da6e4870d32cb766240ce17e0a0ba2014", 350 | "sha256:3b8a6499709d29c2e2399569d96719a1b21dcd94410a586a18526b143ec8470f", 351 | "sha256:43a55c2930bbc139570ac2452adf3d70cdbb3cfe5912c71cdce1c2c6bbd9c5d1", 352 | "sha256:46c99d2de99945ec5cb54f23c8cd5689f6d7177305ebff350a58ce5f8de1669e", 353 | "sha256:500d4957e52ddc3351cabf489e79c91c17f6e0899158447047588650b5e69183", 354 | "sha256:535f6fc4d397c1563d08b88e485c3496cf5784e927af890fb3c3aac7f933ec66", 355 | "sha256:596510de112c685489095da617b5bcbbac7dd6384aeebeda4df6025d0256a81b", 356 | "sha256:62fe6c95e3ec8a7fad637b7f3d372c15ec1caa01ab47926cfdf7a75b40e0eac1", 357 | "sha256:6788b695d50a51edb699cb55e35487e430fa21f1ed838122d722e0ff0ac5ba15", 358 | "sha256:6dd73240d2af64df90aa7c4e7481e23825ea70af4b4922f8ede5b9e35f78a3b1", 359 | "sha256:6f1e273a344928347c1290119b493a1f0303c52f5a5eae5f16d74f48c15d4a85", 360 | "sha256:6fffc775d90dcc9aed1b89219549b329a9250d918fd0b8fa8d93d154918422e1", 361 | "sha256:717ba8fe3ae9cc0006d7c451f0bb265ee07739daf76355d06366154ee68d221e", 362 | "sha256:79855e1c5b8da654cf486b830bd42c06e8780cea587384cf6545b7d9ac013a0b", 363 | "sha256:7c1699dfe0cf8ff607dbdcc1e9b9af1755371f92a68f706051cc8c37d447c905", 364 | "sha256:7fed13866cf14bba33e7176717346713881f56d9d2bcebab207f7a036f41b850", 365 | "sha256:84dee80c15f1b560d55bcfe6d47b27d070b4681c699c572af2e3c7cc90a3b8e0", 366 | "sha256:88e5fcfb52ee7b911e8bb6d6aa2fd21fbecc674eadd44118a9cc3863f938e735", 367 | "sha256:8defac2f2ccd6805ebf65f5eeb132adcf2ab57aa11fdf4c0dd5169a004710e7d", 368 | "sha256:98bae9582248d6cf62321dcb52aaf5d9adf0bad3b40582925ef7c7f0ed85fceb", 369 | "sha256:98c7086708b163d425c67c7a91bad6e466bb99d797aa64f965e9d25c12111a5e", 370 | "sha256:9add70b36c5666a2ed02b43b335fe19002ee5235efd4b8a89bfcf9005bebac0d", 371 | "sha256:9bf40443012702a1d2070043cb6291650a0841ece432556f784f004937f0f32c", 372 | "sha256:a6a744282b7718a2a62d2ed9d993cad6f5f585605ad352c11de459f4108df0a1", 373 | "sha256:acf08ac40292838b3cbbb06cfe9b2cb9ec78fce8baca31ddb87aaac2e2dc3bc2", 374 | "sha256:ade5e387d2ad0d7ebf59146cc00c8044acbd863725f887353a10df825fc8ae21", 375 | "sha256:b00c1de48212e4cc9603895652c5c410df699856a2853135b3967591e4beebc2", 376 | "sha256:b1282f8c00509d99fef04d8ba936b156d419be841854fe901d8ae224c59f0be5", 377 | "sha256:b1dba4527182c95a0db8b6060cc98ac49b9e2f5e64320e2b56e47cb2831978c7", 378 | "sha256:b2051432115498d3562c084a49bba65d97cf251f5a331c64a12ee7e04dacc51b", 379 | "sha256:b7d644ddb4dbd407d31ffb699f1d140bc35478da613b441c582aeb7c43838dd8", 380 | "sha256:ba59edeaa2fc6114428f1637ffff42da1e311e29382d81b339c1817d37ec93c6", 381 | "sha256:bf5aa3cbcfdf57fa2ee9cd1822c862ef23037f5c832ad09cfea57fa846dec193", 382 | "sha256:c8716a48d94b06bb3b2524c2b77e055fb313aeb4ea620c8dd03a105574ba704f", 383 | "sha256:caabedc8323f1e93231b52fc32bdcde6db817623d33e100708d9a68e1f53b26b", 384 | "sha256:cd5df75523866410809ca100dc9681e301e3c27567cf498077e8551b6d20e42f", 385 | "sha256:cdb132fc825c38e1aeec2c8aa9338310d29d337bebbd7baa06889d09a60a1fa2", 386 | "sha256:d53bc011414228441014aa71dbec320c66468c1030aae3a6e29778a3382d96e5", 387 | "sha256:d73a845f227b0bfe8a7455ee623525ee656a9e2e749e4742706d80a6065d5e2c", 388 | "sha256:d9be0ba6c527163cbed5e0857c451fcd092ce83947944d6c14bc95441203f032", 389 | "sha256:e249096428b3ae81b08327a63a485ad0878de3fb939049038579ac0ef61e17e7", 390 | "sha256:e8313f01ba26fbbe36c7be1966a7b7424942f670f38e666995b88d012765b9be", 391 | "sha256:feb7b34d6325451ef96bc0e36e1a6c0c1c64bc1fbec4b854f4529e51887b1621" 392 | ], 393 | "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3'", 394 | "version": "==1.1.1" 395 | }, 396 | "matplotlib": { 397 | "hashes": [ 398 | "sha256:1f83a32e4b6045191f9d34e4dc68c0a17c870b57ef9cca518e516da591246e79", 399 | "sha256:2eee37340ca1b353e0a43a33da79d0cd4bcb087064a0c3c3d1329cdea8fbc6f3", 400 | "sha256:53ceb12ef44f8982b45adc7a0889a7e2df1d758e8b360f460e435abe8a8cd658", 401 | "sha256:574306171b84cd6854c83dc87bc353cacc0f60184149fb00c9ea871eca8c1ecb", 402 | "sha256:7561fd541477d41f3aa09457c434dd1f7604f3bd26d7858d52018f5dfe1c06d1", 403 | "sha256:7a54efd6fcad9cb3cd5ef2064b5a3eeb0b63c99f26c346bdcf66e7c98294d7cc", 404 | "sha256:7f16660edf9a8bcc0f766f51c9e1b9d2dc6ceff6bf636d2dbd8eb925d5832dfd", 405 | "sha256:81e6fe8b18ef5be67f40a1d4f07d5a4ed21d3878530193898449ddef7793952f", 406 | "sha256:84a10e462120aa7d9eb6186b50917ed5a6286ee61157bfc17c5b47987d1a9068", 407 | "sha256:84d4c4f650f356678a5d658a43ca21a41fca13f9b8b00169c0b76e6a6a948908", 408 | "sha256:86dc94e44403fa0f2b1dd76c9794d66a34e821361962fe7c4e078746362e3b14", 409 | "sha256:90dbc007f6389bcfd9ef4fe5d4c78c8d2efe4e0ebefd48b4f221cdfed5672be2", 410 | "sha256:9f374961a3996c2d1b41ba3145462c3708a89759e604112073ed6c8bdf9f622f", 411 | "sha256:a18cc1ab4a35b845cf33b7880c979f5c609fd26c2d6e74ddfacb73dcc60dd956", 412 | "sha256:a97781453ac79409ddf455fccf344860719d95142f9c334f2a8f3fff049ffec3", 413 | "sha256:a989022f89cda417f82dbf65e0a830832afd8af743d05d1414fb49549287ff04", 414 | "sha256:ac2a30a09984c2719f112a574b6543ccb82d020fd1b23b4d55bf4759ba8dd8f5", 415 | "sha256:be4430b33b25e127fc4ea239cc386389de420be4d63e71d5359c20b562951ce1", 416 | "sha256:c45e7bf89ea33a2adaef34774df4e692c7436a18a48bcb0e47a53e698a39fa39" 417 | ], 418 | "index": "pypi", 419 | "version": "==3.4.1" 420 | }, 421 | "mistune": { 422 | "hashes": [ 423 | "sha256:59a3429db53c50b5c6bcc8a07f8848cb00d7dc8bdb431a4ab41920d201d4756e", 424 | "sha256:88a1051873018da288eee8538d476dffe1262495144b33ecb586c4ab266bb8d4" 425 | ], 426 | "version": "==0.8.4" 427 | }, 428 | "nbclassic": { 429 | "hashes": [ 430 | "sha256:0248333262d6f90c2fbe05aacb4f008f1d71b5250a9f737488e0a03cfa1c6ed5", 431 | "sha256:b649436ff85dc731ba8115deef089e5abbe827d7a6dccbad42c15b8d427104e8" 432 | ], 433 | "markers": "python_version >= '3.6'", 434 | "version": "==0.2.6" 435 | }, 436 | "nbclient": { 437 | "hashes": [ 438 | "sha256:db17271330c68c8c88d46d72349e24c147bb6f34ec82d8481a8f025c4d26589c", 439 | "sha256:e79437364a2376892b3f46bedbf9b444e5396cfb1bc366a472c37b48e9551500" 440 | ], 441 | "markers": "python_full_version >= '3.6.1'", 442 | "version": "==0.5.3" 443 | }, 444 | "nbconvert": { 445 | "hashes": [ 446 | "sha256:39e9f977920b203baea0be67eea59f7b37a761caa542abe80f5897ce3cf6311d", 447 | "sha256:cbbc13a86dfbd4d1b5dee106539de0795b4db156c894c2c5dc382062bbc29002" 448 | ], 449 | "markers": "python_version >= '3.6'", 450 | "version": "==6.0.7" 451 | }, 452 | "nbformat": { 453 | "hashes": [ 454 | "sha256:1d223e64a18bfa7cdf2db2e9ba8a818312fc2a0701d2e910b58df66809385a56", 455 | "sha256:3949fdc8f5fa0b1afca16fb307546e78494fa7a7bceff880df8168eafda0e7ac" 456 | ], 457 | "markers": "python_version >= '3.5'", 458 | "version": "==5.1.2" 459 | }, 460 | "nest-asyncio": { 461 | "hashes": [ 462 | "sha256:76d6e972265063fe92a90b9cc4fb82616e07d586b346ed9d2c89a4187acea39c", 463 | "sha256:afc5a1c515210a23c461932765691ad39e8eba6551c055ac8d5546e69250d0aa" 464 | ], 465 | "markers": "python_version >= '3.5'", 466 | "version": "==1.5.1" 467 | }, 468 | "notebook": { 469 | "hashes": [ 470 | "sha256:cb271af1e8134e3d6fc6d458bdc79c40cbfc84c1eb036a493f216d58f0880e92", 471 | "sha256:cbc9398d6c81473e9cdb891d2cae9c0d3718fca289dda6d26df5cb660fcadc7d" 472 | ], 473 | "markers": "python_version >= '3.6'", 474 | "version": "==6.3.0" 475 | }, 476 | "numpy": { 477 | "hashes": [ 478 | "sha256:2428b109306075d89d21135bdd6b785f132a1f5a3260c371cee1fae427e12727", 479 | "sha256:377751954da04d4a6950191b20539066b4e19e3b559d4695399c5e8e3e683bf6", 480 | "sha256:4703b9e937df83f5b6b7447ca5912b5f5f297aba45f91dbbbc63ff9278c7aa98", 481 | "sha256:471c0571d0895c68da309dacee4e95a0811d0a9f9f532a48dc1bea5f3b7ad2b7", 482 | "sha256:61d5b4cf73622e4d0c6b83408a16631b670fc045afd6540679aa35591a17fe6d", 483 | "sha256:6c915ee7dba1071554e70a3664a839fbc033e1d6528199d4621eeaaa5487ccd2", 484 | "sha256:6e51e417d9ae2e7848314994e6fc3832c9d426abce9328cf7571eefceb43e6c9", 485 | "sha256:719656636c48be22c23641859ff2419b27b6bdf844b36a2447cb39caceb00935", 486 | "sha256:780ae5284cb770ade51d4b4a7dce4faa554eb1d88a56d0e8b9f35fca9b0270ff", 487 | "sha256:878922bf5ad7550aa044aa9301d417e2d3ae50f0f577de92051d739ac6096cee", 488 | "sha256:924dc3f83de20437de95a73516f36e09918e9c9c18d5eac520062c49191025fb", 489 | "sha256:97ce8b8ace7d3b9288d88177e66ee75480fb79b9cf745e91ecfe65d91a856042", 490 | "sha256:9c0fab855ae790ca74b27e55240fe4f2a36a364a3f1ebcfd1fb5ac4088f1cec3", 491 | "sha256:9cab23439eb1ebfed1aaec9cd42b7dc50fc96d5cd3147da348d9161f0501ada5", 492 | "sha256:a8e6859913ec8eeef3dbe9aed3bf475347642d1cdd6217c30f28dee8903528e6", 493 | "sha256:aa046527c04688af680217fffac61eec2350ef3f3d7320c07fd33f5c6e7b4d5f", 494 | "sha256:abc81829c4039e7e4c30f7897938fa5d4916a09c2c7eb9b244b7a35ddc9656f4", 495 | "sha256:bad70051de2c50b1a6259a6df1daaafe8c480ca98132da98976d8591c412e737", 496 | "sha256:c73a7975d77f15f7f68dacfb2bca3d3f479f158313642e8ea9058eea06637931", 497 | "sha256:d15007f857d6995db15195217afdbddfcd203dfaa0ba6878a2f580eaf810ecd6", 498 | "sha256:d76061ae5cab49b83a8cf3feacefc2053fac672728802ac137dd8c4123397677", 499 | "sha256:e8e4fbbb7e7634f263c5b0150a629342cc19b47c5eba8d1cd4363ab3455ab576", 500 | "sha256:e9459f40244bb02b2f14f6af0cd0732791d72232bbb0dc4bab57ef88e75f6935", 501 | "sha256:edb1f041a9146dcf02cd7df7187db46ab524b9af2515f392f337c7cbbf5b52cd" 502 | ], 503 | "index": "pypi", 504 | "version": "==1.20.2" 505 | }, 506 | "packaging": { 507 | "hashes": [ 508 | "sha256:5b327ac1320dc863dca72f4514ecc086f31186744b84a230374cc1fd776feae5", 509 | "sha256:67714da7f7bc052e064859c05c595155bd1ee9f69f76557e21f051443c20947a" 510 | ], 511 | "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3'", 512 | "version": "==20.9" 513 | }, 514 | "pandocfilters": { 515 | "hashes": [ 516 | "sha256:bc63fbb50534b4b1f8ebe1860889289e8af94a23bff7445259592df25a3906eb" 517 | ], 518 | "version": "==1.4.3" 519 | }, 520 | "parso": { 521 | "hashes": [ 522 | "sha256:12b83492c6239ce32ff5eed6d3639d6a536170723c6f3f1506869f1ace413398", 523 | "sha256:a8c4922db71e4fdb90e0d0bc6e50f9b273d3397925e5e60a717e719201778d22" 524 | ], 525 | "markers": "python_version >= '3.6'", 526 | "version": "==0.8.2" 527 | }, 528 | "pexpect": { 529 | "hashes": [ 530 | "sha256:0b48a55dcb3c05f3329815901ea4fc1537514d6ba867a152b581d69ae3710937", 531 | "sha256:fc65a43959d153d0114afe13997d439c22823a27cefceb5ff35c2178c6784c0c" 532 | ], 533 | "markers": "sys_platform != 'win32'", 534 | "version": "==4.8.0" 535 | }, 536 | "pickleshare": { 537 | "hashes": [ 538 | "sha256:87683d47965c1da65cdacaf31c8441d12b8044cdec9aca500cd78fc2c683afca", 539 | "sha256:9649af414d74d4df115d5d718f82acb59c9d418196b7b4290ed47a12ce62df56" 540 | ], 541 | "version": "==0.7.5" 542 | }, 543 | "pillow": { 544 | "hashes": [ 545 | "sha256:15306d71a1e96d7e271fd2a0737038b5a92ca2978d2e38b6ced7966583e3d5af", 546 | "sha256:1940fc4d361f9cc7e558d6f56ff38d7351b53052fd7911f4b60cd7bc091ea3b1", 547 | "sha256:1f93f2fe211f1ef75e6f589327f4d4f8545d5c8e826231b042b483d8383e8a7c", 548 | "sha256:30d33a1a6400132e6f521640dd3f64578ac9bfb79a619416d7e8802b4ce1dd55", 549 | "sha256:328240f7dddf77783e72d5ed79899a6b48bc6681f8d1f6001f55933cb4905060", 550 | "sha256:46c2bcf8e1e75d154e78417b3e3c64e96def738c2a25435e74909e127a8cba5e", 551 | "sha256:5762ebb4436f46b566fc6351d67a9b5386b5e5de4e58fdaa18a1c83e0e20f1a8", 552 | "sha256:5a2d957eb4aba9d48170b8fe6538ec1fbc2119ffe6373782c03d8acad3323f2e", 553 | "sha256:5cf03b9534aca63b192856aa601c68d0764810857786ea5da652581f3a44c2b0", 554 | "sha256:5daba2b40782c1c5157a788ec4454067c6616f5a0c1b70e26ac326a880c2d328", 555 | "sha256:63cd413ac52ee3f67057223d363f4f82ce966e64906aea046daf46695e3c8238", 556 | "sha256:6efac40344d8f668b6c4533ae02a48d52fd852ef0654cc6f19f6ac146399c733", 557 | "sha256:71b01ee69e7df527439d7752a2ce8fb89e19a32df484a308eca3e81f673d3a03", 558 | "sha256:71f31ee4df3d5e0b366dd362007740106d3210fb6a56ec4b581a5324ba254f06", 559 | "sha256:72027ebf682abc9bafd93b43edc44279f641e8996fb2945104471419113cfc71", 560 | "sha256:74cd9aa648ed6dd25e572453eb09b08817a1e3d9f8d1bd4d8403d99e42ea790b", 561 | "sha256:81b3716cc9744ffdf76b39afb6247eae754186838cedad0b0ac63b2571253fe6", 562 | "sha256:8565355a29655b28fdc2c666fd9a3890fe5edc6639d128814fafecfae2d70910", 563 | "sha256:87f42c976f91ca2fc21a3293e25bd3cd895918597db1b95b93cbd949f7d019ce", 564 | "sha256:89e4c757a91b8c55d97c91fa09c69b3677c227b942fa749e9a66eef602f59c28", 565 | "sha256:8c4e32218c764bc27fe49b7328195579581aa419920edcc321c4cb877c65258d", 566 | "sha256:903293320efe2466c1ab3509a33d6b866dc850cfd0c5d9cc92632014cec185fb", 567 | "sha256:90882c6f084ef68b71bba190209a734bf90abb82ab5e8f64444c71d5974008c6", 568 | "sha256:98afcac3205d31ab6a10c5006b0cf040d0026a68ec051edd3517b776c1d78b09", 569 | "sha256:a01da2c266d9868c4f91a9c6faf47a251f23b9a862dce81d2ff583135206f5be", 570 | "sha256:aeab4cd016e11e7aa5cfc49dcff8e51561fa64818a0be86efa82c7038e9369d0", 571 | "sha256:b07c660e014852d98a00a91adfbe25033898a9d90a8f39beb2437d22a203fc44", 572 | "sha256:bead24c0ae3f1f6afcb915a057943ccf65fc755d11a1410a909c1fefb6c06ad1", 573 | "sha256:d1d6bca39bb6dd94fba23cdb3eeaea5e30c7717c5343004d900e2a63b132c341", 574 | "sha256:e2cd8ac157c1e5ae88b6dd790648ee5d2777e76f1e5c7d184eaddb2938594f34", 575 | "sha256:e5739ae63636a52b706a0facec77b2b58e485637e1638202556156e424a02dc2", 576 | "sha256:f36c3ff63d6fc509ce599a2f5b0d0732189eed653420e7294c039d342c6e204a", 577 | "sha256:f91b50ad88048d795c0ad004abbe1390aa1882073b1dca10bfd55d0b8cf18ec5" 578 | ], 579 | "markers": "python_version >= '3.6'", 580 | "version": "==8.1.2" 581 | }, 582 | "prometheus-client": { 583 | "hashes": [ 584 | "sha256:9da7b32f02439d8c04f7777021c304ed51d9ec180604700c1ba72a4d44dceb03", 585 | "sha256:b08c34c328e1bf5961f0b4352668e6c8f145b4a087e09b7296ef62cbe4693d35" 586 | ], 587 | "version": "==0.9.0" 588 | }, 589 | "prompt-toolkit": { 590 | "hashes": [ 591 | "sha256:bf00f22079f5fadc949f42ae8ff7f05702826a97059ffcc6281036ad40ac6f04", 592 | "sha256:e1b4f11b9336a28fa11810bc623c357420f69dfdb6d2dac41ca2c21a55c033bc" 593 | ], 594 | "markers": "python_full_version >= '3.6.1'", 595 | "version": "==3.0.18" 596 | }, 597 | "ptyprocess": { 598 | "hashes": [ 599 | "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35", 600 | "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220" 601 | ], 602 | "markers": "os_name != 'nt'", 603 | "version": "==0.7.0" 604 | }, 605 | "pycparser": { 606 | "hashes": [ 607 | "sha256:2d475327684562c3a96cc71adf7dc8c4f0565175cf86b6d7a404ff4c771f15f0", 608 | "sha256:7582ad22678f0fcd81102833f60ef8d0e57288b6b5fb00323d101be910e35705" 609 | ], 610 | "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3'", 611 | "version": "==2.20" 612 | }, 613 | "pygments": { 614 | "hashes": [ 615 | "sha256:2656e1a6edcdabf4275f9a3640db59fd5de107d88e8663c5d4e9a0fa62f77f94", 616 | "sha256:534ef71d539ae97d4c3a4cf7d6f110f214b0e687e92f9cb9d2a3b0d3101289c8" 617 | ], 618 | "markers": "python_version >= '3.5'", 619 | "version": "==2.8.1" 620 | }, 621 | "pyparsing": { 622 | "hashes": [ 623 | "sha256:c203ec8783bf771a155b207279b9bccb8dea02d8f0c9e5f8ead507bc3246ecc1", 624 | "sha256:ef9d7589ef3c200abe66653d3f1ab1033c3c419ae9b9bdb1240a85b024efc88b" 625 | ], 626 | "markers": "python_version >= '2.6' and python_version not in '3.0, 3.1, 3.2, 3.3'", 627 | "version": "==2.4.7" 628 | }, 629 | "pyrsistent": { 630 | "hashes": [ 631 | "sha256:2e636185d9eb976a18a8a8e96efce62f2905fea90041958d8cc2a189756ebf3e" 632 | ], 633 | "markers": "python_version >= '3.5'", 634 | "version": "==0.17.3" 635 | }, 636 | "python-dateutil": { 637 | "hashes": [ 638 | "sha256:73ebfe9dbf22e832286dafa60473e4cd239f8592f699aa5adaf10050e6e1823c", 639 | "sha256:75bb3f31ea686f1197762692a9ee6a7550b59fc6ca3a1f4b5d7e32fb98e2da2a" 640 | ], 641 | "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3'", 642 | "version": "==2.8.1" 643 | }, 644 | "pytz": { 645 | "hashes": [ 646 | "sha256:83a4a90894bf38e243cf052c8b58f381bfe9a7a483f6a9cab140bc7f702ac4da", 647 | "sha256:eb10ce3e7736052ed3623d49975ce333bcd712c7bb19a58b9e2089d4057d0798" 648 | ], 649 | "version": "==2021.1" 650 | }, 651 | "pyzmq": { 652 | "hashes": [ 653 | "sha256:13465c1ff969cab328bc92f7015ce3843f6e35f8871ad79d236e4fbc85dbe4cb", 654 | "sha256:23a74de4b43c05c3044aeba0d1f3970def8f916151a712a3ac1e5cd9c0bc2902", 655 | "sha256:26380487eae4034d6c2a3fb8d0f2dff6dd0d9dd711894e8d25aa2d1938950a33", 656 | "sha256:279cc9b51db48bec2db146f38e336049ac5a59e5f12fb3a8ad864e238c1c62e3", 657 | "sha256:2f971431aaebe0a8b54ac018e041c2f0b949a43745444e4dadcc80d0f0ef8457", 658 | "sha256:30df70f81fe210506aa354d7fd486a39b87d9f7f24c3d3f4f698ec5d96b8c084", 659 | "sha256:33acd2b9790818b9d00526135acf12790649d8d34b2b04d64558b469c9d86820", 660 | "sha256:38e3dca75d81bec4f2defa14b0a65b74545812bb519a8e89c8df96bbf4639356", 661 | "sha256:3e29f9cf85a40d521d048b55c63f59d6c772ac1c4bf51cdfc23b62a62e377c33", 662 | "sha256:3ef50d74469b03725d781a2a03c57537d86847ccde587130fe35caafea8f75c6", 663 | "sha256:4231943514812dfb74f44eadcf85e8dd8cf302b4d0bce450ce1357cac88dbfdc", 664 | "sha256:4f34a173f813b38b83f058e267e30465ed64b22cd0cf6bad21148d3fa718f9bb", 665 | "sha256:532af3e6dddea62d9c49062ece5add998c9823c2419da943cf95589f56737de0", 666 | "sha256:581787c62eaa0e0db6c5413cedc393ebbadac6ddfd22e1cf9a60da23c4f1a4b2", 667 | "sha256:60e63577b85055e4cc43892fecd877b86695ee3ef12d5d10a3c5d6e77a7cc1a3", 668 | "sha256:61e4bb6cd60caf1abcd796c3f48395e22c5b486eeca6f3a8797975c57d94b03e", 669 | "sha256:6d4163704201fff0f3ab0cd5d7a0ea1514ecfffd3926d62ec7e740a04d2012c7", 670 | "sha256:7026f0353977431fc884abd4ac28268894bd1a780ba84bb266d470b0ec26d2ed", 671 | "sha256:763c175294d861869f18eb42901d500eda7d3fa4565f160b3b2fd2678ea0ebab", 672 | "sha256:81e7df0da456206201e226491aa1fc449da85328bf33bbeec2c03bb3a9f18324", 673 | "sha256:9221783dacb419604d5345d0e097bddef4459a9a95322de6c306bf1d9896559f", 674 | "sha256:a558c5bc89d56d7253187dccc4e81b5bb0eac5ae9511eb4951910a1245d04622", 675 | "sha256:b25e5d339550a850f7e919fe8cb4c8eabe4c917613db48dab3df19bfb9a28969", 676 | "sha256:b62ea18c0458a65ccd5be90f276f7a5a3f26a6dea0066d948ce2fa896051420f", 677 | "sha256:c0cde362075ee8f3d2b0353b283e203c2200243b5a15d5c5c03b78112a17e7d4", 678 | "sha256:c5e29fe4678f97ce429f076a2a049a3d0b2660ada8f2c621e5dc9939426056dd", 679 | "sha256:d18ddc6741b51f3985978f2fda57ddcdae359662d7a6b395bc8ff2292fca14bd", 680 | "sha256:da7d4d4c778c86b60949d17531e60c54ed3726878de8a7f8a6d6e7f8cc8c3205", 681 | "sha256:f52070871a0fd90a99130babf21f8af192304ec1e995bec2a9533efc21ea4452", 682 | "sha256:f5831eff6b125992ec65d973f5151c48003b6754030094723ac4c6e80a97c8c4", 683 | "sha256:f7f63ce127980d40f3e6a5fdb87abf17ce1a7c2bd8bf2c7560e1bbce8ab1f92d", 684 | "sha256:ff1ea14075bbddd6f29bf6beb8a46d0db779bcec6b9820909584081ec119f8fd" 685 | ], 686 | "markers": "python_version >= '3.6'", 687 | "version": "==22.0.3" 688 | }, 689 | "requests": { 690 | "hashes": [ 691 | "sha256:27973dd4a904a4f13b263a19c866c13b92a39ed1c964655f025f3f8d3d75b804", 692 | "sha256:c210084e36a42ae6b9219e00e48287def368a26d03a048ddad7bfee44f75871e" 693 | ], 694 | "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3, 3.4'", 695 | "version": "==2.25.1" 696 | }, 697 | "scipy": { 698 | "hashes": [ 699 | "sha256:03f1fd3574d544456325dae502facdf5c9f81cbfe12808a5e67a737613b7ba8c", 700 | "sha256:0c81ea1a95b4c9e0a8424cf9484b7b8fa7ef57169d7bcc0dfcfc23e3d7c81a12", 701 | "sha256:1fba8a214c89b995e3721670e66f7053da82e7e5d0fe6b31d8e4b19922a9315e", 702 | "sha256:37f4c2fb904c0ba54163e03993ce3544c9c5cde104bcf90614f17d85bdfbb431", 703 | "sha256:50e5bcd9d45262725e652611bb104ac0919fd25ecb78c22f5282afabd0b2e189", 704 | "sha256:6ca1058cb5bd45388041a7c3c11c4b2bd58867ac9db71db912501df77be2c4a4", 705 | "sha256:77f7a057724545b7e097bfdca5c6006bed8580768cd6621bb1330aedf49afba5", 706 | "sha256:816951e73d253a41fa2fd5f956f8e8d9ac94148a9a2039e7db56994520582bf2", 707 | "sha256:96620240b393d155097618bcd6935d7578e85959e55e3105490bbbf2f594c7ad", 708 | "sha256:993c86513272bc84c451349b10ee4376652ab21f312b0554fdee831d593b6c02", 709 | "sha256:adf7cee8e5c92b05f2252af498f77c7214a2296d009fc5478fc432c2f8fb953b", 710 | "sha256:bc52d4d70863141bb7e2f8fd4d98e41d77375606cde50af65f1243ce2d7853e8", 711 | "sha256:c1d3f771c19af00e1a36f749bd0a0690cc64632783383bc68f77587358feb5a4", 712 | "sha256:d744657c27c128e357de2f0fd532c09c84cd6e4933e8232895a872e67059ac37", 713 | "sha256:e3e9742bad925c421d39e699daa8d396c57535582cba90017d17f926b61c1552", 714 | "sha256:e547f84cd52343ac2d56df0ab08d3e9cc202338e7d09fafe286d6c069ddacb31", 715 | "sha256:e89091e6a8e211269e23f049473b2fde0c0e5ae0dd5bd276c3fc91b97da83480", 716 | "sha256:e9da33e21c9bc1b92c20b5328adb13e5f193b924c9b969cd700c8908f315aa59", 717 | "sha256:ffdfb09315896c6e9ac739bb6e13a19255b698c24e6b28314426fd40a1180822" 718 | ], 719 | "index": "pypi", 720 | "version": "==1.6.2" 721 | }, 722 | "send2trash": { 723 | "hashes": [ 724 | "sha256:60001cc07d707fe247c94f74ca6ac0d3255aabcb930529690897ca2a39db28b2", 725 | "sha256:f1691922577b6fa12821234aeb57599d887c4900b9ca537948d2dac34aea888b" 726 | ], 727 | "version": "==1.5.0" 728 | }, 729 | "six": { 730 | "hashes": [ 731 | "sha256:30639c035cdb23534cd4aa2dd52c3bf48f06e5f4a941509c8bafd8ce11080259", 732 | "sha256:8b74bedcbbbaca38ff6d7491d76f2b06b3592611af620f8426e82dddb04a5ced" 733 | ], 734 | "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3'", 735 | "version": "==1.15.0" 736 | }, 737 | "sniffio": { 738 | "hashes": [ 739 | "sha256:471b71698eac1c2112a40ce2752bb2f4a4814c22a54a3eed3676bc0f5ca9f663", 740 | "sha256:c4666eecec1d3f50960c6bdf61ab7bc350648da6c126e3cf6898d8cd4ddcd3de" 741 | ], 742 | "markers": "python_version >= '3.5'", 743 | "version": "==1.2.0" 744 | }, 745 | "terminado": { 746 | "hashes": [ 747 | "sha256:9a7dbcfbc2778830eeb70261bf7aa9d98a3eac8631a3afe3febeb57c12f798be", 748 | "sha256:daed77f9fad7b32558fa84b226a76f45a02242c20813502f36c4e1ade6d8f1ad" 749 | ], 750 | "markers": "python_version >= '3.6'", 751 | "version": "==0.9.4" 752 | }, 753 | "testpath": { 754 | "hashes": [ 755 | "sha256:60e0a3261c149755f4399a1fff7d37523179a70fdc3abdf78de9fc2604aeec7e", 756 | "sha256:bfcf9411ef4bf3db7579063e0546938b1edda3d69f4e1fb8756991f5951f85d4" 757 | ], 758 | "version": "==0.4.4" 759 | }, 760 | "tornado": { 761 | "hashes": [ 762 | "sha256:0a00ff4561e2929a2c37ce706cb8233b7907e0cdc22eab98888aca5dd3775feb", 763 | "sha256:0d321a39c36e5f2c4ff12b4ed58d41390460f798422c4504e09eb5678e09998c", 764 | "sha256:1e8225a1070cd8eec59a996c43229fe8f95689cb16e552d130b9793cb570a288", 765 | "sha256:20241b3cb4f425e971cb0a8e4ffc9b0a861530ae3c52f2b0434e6c1b57e9fd95", 766 | "sha256:25ad220258349a12ae87ede08a7b04aca51237721f63b1808d39bdb4b2164558", 767 | "sha256:33892118b165401f291070100d6d09359ca74addda679b60390b09f8ef325ffe", 768 | "sha256:33c6e81d7bd55b468d2e793517c909b139960b6c790a60b7991b9b6b76fb9791", 769 | "sha256:3447475585bae2e77ecb832fc0300c3695516a47d46cefa0528181a34c5b9d3d", 770 | "sha256:34ca2dac9e4d7afb0bed4677512e36a52f09caa6fded70b4e3e1c89dbd92c326", 771 | "sha256:3e63498f680547ed24d2c71e6497f24bca791aca2fe116dbc2bd0ac7f191691b", 772 | "sha256:548430be2740e327b3fe0201abe471f314741efcb0067ec4f2d7dcfb4825f3e4", 773 | "sha256:6196a5c39286cc37c024cd78834fb9345e464525d8991c21e908cc046d1cc02c", 774 | "sha256:61b32d06ae8a036a6607805e6720ef00a3c98207038444ba7fd3d169cd998910", 775 | "sha256:6286efab1ed6e74b7028327365cf7346b1d777d63ab30e21a0f4d5b275fc17d5", 776 | "sha256:65d98939f1a2e74b58839f8c4dab3b6b3c1ce84972ae712be02845e65391ac7c", 777 | "sha256:66324e4e1beede9ac79e60f88de548da58b1f8ab4b2f1354d8375774f997e6c0", 778 | "sha256:6c77c9937962577a6a76917845d06af6ab9197702a42e1346d8ae2e76b5e3675", 779 | "sha256:70dec29e8ac485dbf57481baee40781c63e381bebea080991893cd297742b8fd", 780 | "sha256:7250a3fa399f08ec9cb3f7b1b987955d17e044f1ade821b32e5f435130250d7f", 781 | "sha256:748290bf9112b581c525e6e6d3820621ff020ed95af6f17fedef416b27ed564c", 782 | "sha256:7da13da6f985aab7f6f28debab00c67ff9cbacd588e8477034c0652ac141feea", 783 | "sha256:8f959b26f2634a091bb42241c3ed8d3cedb506e7c27b8dd5c7b9f745318ddbb6", 784 | "sha256:9de9e5188a782be6b1ce866e8a51bc76a0fbaa0e16613823fc38e4fc2556ad05", 785 | "sha256:a48900ecea1cbb71b8c71c620dee15b62f85f7c14189bdeee54966fbd9a0c5bd", 786 | "sha256:b87936fd2c317b6ee08a5741ea06b9d11a6074ef4cc42e031bc6403f82a32575", 787 | "sha256:c77da1263aa361938476f04c4b6c8916001b90b2c2fdd92d8d535e1af48fba5a", 788 | "sha256:cb5ec8eead331e3bb4ce8066cf06d2dfef1bfb1b2a73082dfe8a161301b76e37", 789 | "sha256:cc0ee35043162abbf717b7df924597ade8e5395e7b66d18270116f8745ceb795", 790 | "sha256:d14d30e7f46a0476efb0deb5b61343b1526f73ebb5ed84f23dc794bdb88f9d9f", 791 | "sha256:d371e811d6b156d82aa5f9a4e08b58debf97c302a35714f6f45e35139c332e32", 792 | "sha256:d3d20ea5782ba63ed13bc2b8c291a053c8d807a8fa927d941bd718468f7b950c", 793 | "sha256:d3f7594930c423fd9f5d1a76bee85a2c36fd8b4b16921cae7e965f22575e9c01", 794 | "sha256:dcef026f608f678c118779cd6591c8af6e9b4155c44e0d1bc0c87c036fb8c8c4", 795 | "sha256:e0791ac58d91ac58f694d8d2957884df8e4e2f6687cdf367ef7eb7497f79eaa2", 796 | "sha256:e385b637ac3acaae8022e7e47dfa7b83d3620e432e3ecb9a3f7f58f150e50921", 797 | "sha256:e519d64089b0876c7b467274468709dadf11e41d65f63bba207e04217f47c085", 798 | "sha256:e7229e60ac41a1202444497ddde70a48d33909e484f96eb0da9baf8dc68541df", 799 | "sha256:ed3ad863b1b40cd1d4bd21e7498329ccaece75db5a5bf58cd3c9f130843e7102", 800 | "sha256:f0ba29bafd8e7e22920567ce0d232c26d4d47c8b5cf4ed7b562b5db39fa199c5", 801 | "sha256:fa2ba70284fa42c2a5ecb35e322e68823288a4251f9ba9cc77be04ae15eada68", 802 | "sha256:fba85b6cd9c39be262fcd23865652920832b61583de2a2ca907dbd8e8a8c81e5" 803 | ], 804 | "markers": "python_version >= '3.5'", 805 | "version": "==6.1" 806 | }, 807 | "traitlets": { 808 | "hashes": [ 809 | "sha256:178f4ce988f69189f7e523337a3e11d91c786ded9360174a3d9ca83e79bc5396", 810 | "sha256:69ff3f9d5351f31a7ad80443c2674b7099df13cc41fc5fa6e2f6d3b0330b0426" 811 | ], 812 | "markers": "python_version >= '3.7'", 813 | "version": "==5.0.5" 814 | }, 815 | "typing-extensions": { 816 | "hashes": [ 817 | "sha256:7cb407020f00f7bfc3cb3e7881628838e69d8f3fcab2f64742a5e76b2f841918", 818 | "sha256:99d4073b617d30288f569d3f13d2bd7548c3a7e4c8de87db09a9d29bb3a4a60c", 819 | "sha256:dafc7639cde7f1b6e1acc0f457842a83e722ccca8eef5270af2d74792619a89f" 820 | ], 821 | "markers": "python_version < '3.8'", 822 | "version": "==3.7.4.3" 823 | }, 824 | "urllib3": { 825 | "hashes": [ 826 | "sha256:2f4da4594db7e1e110a944bb1b551fdf4e6c136ad42e4234131391e21eb5b0df", 827 | "sha256:e7b021f7241115872f92f43c6508082facffbd1c048e3c6e2bb9c2a157e28937" 828 | ], 829 | "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3, 3.4' and python_version < '4'", 830 | "version": "==1.26.4" 831 | }, 832 | "wcwidth": { 833 | "hashes": [ 834 | "sha256:beb4802a9cebb9144e99086eff703a642a13d6a0052920003a230f3294bbe784", 835 | "sha256:c4d647b99872929fdb7bdcaa4fbe7f01413ed3d98077df798530e5b04f116c83" 836 | ], 837 | "version": "==0.2.5" 838 | }, 839 | "webencodings": { 840 | "hashes": [ 841 | "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78", 842 | "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923" 843 | ], 844 | "version": "==0.5.1" 845 | }, 846 | "zipp": { 847 | "hashes": [ 848 | "sha256:3607921face881ba3e026887d8150cca609d517579abe052ac81fc5aeffdbd76", 849 | "sha256:51cb66cc54621609dd593d1787f286ee42a5c0adbb4b29abea5a63edc3e03098" 850 | ], 851 | "markers": "python_version >= '3.6'", 852 | "version": "==3.4.1" 853 | } 854 | }, 855 | "develop": {} 856 | } 857 | --------------------------------------------------------------------------------