diff --git a/scripts/data-generation.py b/scripts/data-generation.py new file mode 100644 index 0000000..37edd7e --- /dev/null +++ b/scripts/data-generation.py @@ -0,0 +1,22 @@ +# iport PAndas +import pandas as pd + +# data generation +x=np.linspace(0,5) +y1 = np.power(x,0.5) +y2 = np.power(x,0.25) + +# Pandas series +sx = pd.Series(x) +sy1 = pd.Series(y1) +sy2 = pd.Series(y2) + +# Concat data in columns +nd = pd.concat([sx,sy1,sy2],axis=1) + +# Write data +nd.to_csv("test.csv") + +# Read data +d = pd.read_csv("test.csv",delimiter=",") +print(d) diff --git a/scripts/exp-imp.py b/scripts/exp-imp.py index 2f8d3ad..5011173 100644 --- a/scripts/exp-imp.py +++ b/scripts/exp-imp.py @@ -6,9 +6,9 @@ y= np.sin(x) # implicity plt.plot(x,y,label="sin") -plt.xlabel('x label') -plt.ylabel('y label') -plt.title("Simple Plot") +plt.xlabel('x') +plt.ylabel('y') +plt.title("Plot") plt.legend() plt.show() @@ -18,5 +18,5 @@ ax = plt.subplot(aspect=1) ax.plot(x,y,label="sin") ax.set_xlabel('x') # Add an x-label to the axes. ax.set_ylabel('y') # Add a y-label to the axes. -ax.set_title("Simple Plot") # Add a title to the axes. +ax.set_title("Plot") # Add a title to the axes. ax.legend() # Add a legend. diff --git a/source/02_io_readwrite.svg b/source/02_io_readwrite.svg new file mode 100644 index 0000000..a99a6d7 --- /dev/null +++ b/source/02_io_readwrite.svg @@ -0,0 +1,1401 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + image/svg+xml + + + + + + + + read_* + to_* + + + + + + + + + + + + + + + + + + + + + + + CSV + + + + + + + + + + + + + XLS + + + + + + + + + + + + + + + + + + PARQUET + + + + + + + + HTML + + <> + + + + + HDF5 + + + + + + + + JSON + + {} + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + GBQ + + + + + + + SQL + + + + + + ... + + + + + + + + + + CSV + + + + + + + + + + + + + XLS + + + + + + + + + + + + + + + + + + PARQUET + + + + + + + + HTML + + <> + + + + + HDF5 + + + + + + + + JSON + + {} + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + GBQ + + + + + + + SQL + + + + + + ... + + + + + + + diff --git a/source/Plotting II .ipynb b/source/Plotting II .ipynb new file mode 100644 index 0000000..2fd4964 --- /dev/null +++ b/source/Plotting II .ipynb @@ -0,0 +1,1784 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Reading files" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "# pandas is a Python package providing fast, flexible, and expressive data \n", + "# structures designed to make working with “relational” or “labeled” data \n", + "# both easy and intuitive. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### CSV files" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "x;y;er\r", + "\r\n", + "1;1;0.2\r", + "\r\n", + "2;4;0.2\r", + "\r\n", + "3;8;0.3\r", + "\r\n", + "4;17;0.4\r", + "\r\n", + "5;24;0.2" + ] + } + ], + "source": [ + "!cat data.csv" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " x y er\n", + "0 1 1 0.2\n", + "1 2 4 0.2\n", + "2 3 8 0.3\n", + "3 4 17 0.4\n", + "4 5 24 0.2\n" + ] + } + ], + "source": [ + "# read file\n", + "d = pd.read_csv(\"data.csv\",delimiter=\";\")\n", + "print(d)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 1\n", + "1 2\n", + "2 3\n", + "3 4\n", + "4 5\n", + "Name: x, dtype: int64 0 1\n", + "1 4\n", + "2 8\n", + "3 17\n", + "4 24\n", + "Name: y, dtype: int64\n" + ] + } + ], + "source": [ + "# taking values from headers\n", + "x=d[\"x\"]\n", + "y=d[\"y\"]\n", + "e=d[\"er\"]\n", + "print(x,y)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 1\n", + "1 2\n", + "2 3\n", + "3 4\n", + "4 5\n", + "Name: x, dtype: int64 0 1\n", + "1 4\n", + "2 8\n", + "3 17\n", + "4 24\n", + "Name: y, dtype: int64\n" + ] + } + ], + "source": [ + "# taking values from colon .iloc[row,col] or .loc[row,col]\n", + "x=d.iloc[:,0]\n", + "y=d.iloc[:,1]\n", + "e=d.iloc[:,2]\n", + "print(x,y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Raw files with headers" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "x y er\r", + "\r\n", + "1 1 0.2\r", + "\r\n", + "2 4 0.2\r", + "\r\n", + "3 8 0.3\r", + "\r\n" + ] + } + ], + "source": [ + "# text files\n", + "!cat data.txt" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " x y er\n", + "0 1 1 0.2\n", + "1 2 4 0.2\n", + "2 3 8 0.3\n" + ] + } + ], + "source": [ + "# read file\n", + "dtext = pd.read_csv(\"data.txt\")\n", + "print(dtext)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Raw files without headers" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 1 0.2\r", + "\r\n", + "2 4 0.2\r", + "\r\n", + "3 8 0.3\r", + "\r\n" + ] + } + ], + "source": [ + "# raw values\n", + "!cat data.raw" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 0 1 2\n", + "0 1 1 0.2\n", + "1 2 4 0.2\n", + "2 3 8 0.3\n" + ] + } + ], + "source": [ + "# read raw file\n", + "draw = pd.read_csv(\"data.raw\",delimiter=\" \", header = None)\n", + "print(draw)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 0.2\n", + "1 0.2\n", + "2 0.3\n", + "Name: 2, dtype: float64" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "draw.iloc[:,2]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Formatted file" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 0 1\n", + "0 0.0 0.894520\n", + "1 100.0 0.849616\n", + "2 200.0 0.806313\n", + "3 300.0 0.763861\n", + "4 400.0 0.722299\n", + "5 500.0 0.681680\n", + "6 600.0 0.642211\n", + "7 700.0 0.603411\n", + "8 800.0 0.565199\n", + "9 900.0 0.528873\n", + "10 1000.0 0.492817\n" + ] + } + ], + "source": [ + "# read raw file\n", + "fwidths = [11,10]\n", + "dexpe = pd.read_fwf(\"expe.dat\",delimiter=\" \",header = None, widths = fwidths)\n", + "print(dexpe)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### More formats\n", + "see references " + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# import image module\n", + "from IPython.display import Image\n", + " \n", + "# get the image\n", + "Image(url=\"02_io_readwrite.svg\", width=500, height=500)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plotting data" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 0 1\n", + "0 0.0 0.894520\n", + "1 100.0 0.849616\n", + "2 200.0 0.806313\n", + "3 300.0 0.763861\n", + "4 400.0 0.722299\n", + "5 500.0 0.681680\n", + "6 600.0 0.642211\n", + "7 700.0 0.603411\n", + "8 800.0 0.565199\n", + "9 900.0 0.528873\n", + "10 1000.0 0.492817\n" + ] + } + ], + "source": [ + "# read raw file\n", + "fwidths = [11,10]\n", + "dexpe = pd.read_fwf(\"expe.dat\",delimiter=\" \",header = None, widths = fwidths)\n", + "print(dexpe)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# get x and y\n", + "x=dexpe.iloc[:,0]\n", + "y=dexpe.iloc[:,1]" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# plot\n", + "fig = plt.figure(figsize=(6,6)) # s\n", + "ax = plt.subplot() \n", + "ax.plot(x,y,\"o\",label=\"Experimental data\")\n", + "ax.set_ylim([0,2])\n", + "ax.set_xlabel(\"t[s]\")\n", + "ax.set_ylabel(\"V[t]\")\n", + "ax.set_title(\"Temporal Evolution of Volume\")\n", + "ax.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Fitting : linear" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "from scipy.optimize import curve_fit\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "def func(x, a, b):\n", + " return a * x + b" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(array([-4.01437909e-04, 8.87155318e-01]), array([[ 1.96723961e-11, -9.83619802e-09],\n", + " [-9.83619802e-09, 6.88533863e-06]]))\n" + ] + } + ], + "source": [ + "popt= curve_fit(func, x, y)\n", + "print(popt)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "[a,b]=popt[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAGDCAYAAAAxhIflAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAymUlEQVR4nO3deXxV9Z3/8dcnIUCAQJBNSNgEQUC2EBFcUNxALW5TR6mdStWhtmqntXVE+2vVmY7a2k6ntlqKSl2qaGsBqdVKrVJcoBIgbLIFRElACCAIsib5/P44J8lNOAkJ5HJD8n4+HueRe9b7PTdw3znn+z3fr7k7IiIilSUlugAiIlI/KSBERCSSAkJERCIpIEREJJICQkREIikgREQkkgJCGhwzczPrfZzfc4OZXXSU+3Yzsz1mllzX5TrC+3Yys7lmttvMfl7Hxz7uvwOpewqIRi78YiqdSsxsX8z8DYkuX10zszlmtr/Sef/5OJehQpi4+yfu3srdi49nOYCJwDagtbt/r1IZ7zGzuZV3MLP2ZnbQzE4/XoWUxFFANHLhF1Mrd28FfAKMi1n2fKLLV5mZNamDw9wee97uPq4Ojnki6g586NFPyz4HnGVmPSstvx5Y5u7L4146STgFhEQysyQzm2Rm68xsu5n9wcxOCtf1CG8hfN3MNprZZ2Z2q5mdYWZLzWynmf065lgTzOw9M/uVme0ys1VmdmHM+i5mNsvMdphZnpn9e8y6+83sZTP7vZl9Dkwws+FmNi98n81m9msza1oH57zSzL4UM9/EzLaZWVY4f4WZrQjfd46Z9aviOE+b2Y9j5s83s/zw9XNAN+DP4dXLf8Z8nk1q+Hn8wcyeDW8NrTCz7GrO6SwzWxB+7gvM7KzSMgI3Av8ZlqPC7TF3zwfeAv6t0iG/BjwTHuPfw/LtCMvbpYoyzDGzW2LmJ5jZuzHzbmbfMrO14Tn9t5n1Cn/Hn4fn2zRm+y+ZWW74e3jfzAZVdf5yjNxdkybcHWADcFH4+jvAfCATaAb8FpgWrusBODAZaA5cAuwHZgIdgQxgK3BeuP0EoAj4LpACXAfsAk4K1/8DeDw81hCgELgwXHc/cAi4iuAPmlRgGDACaBKWZSXwnZjzcKB3Fec4B7ilinU/Ap6Pmb8cWBW+7gN8AVwcnsN/AnlA04jP7mngxzHHOR/Ij/qcK32eTWr4eewHLgOSgYeA+VWcz0nAZwRf8k2A8eF8u6hyRux/A7A2Zr4vcBDoAFxAcHsqi+Dfx6+AuVG/g8qfefjv4d1K284CWgMDgAPA34FTgDbAh8CN4bZZBP+2zgzP/8bw82yW6P8/DXHSFYRU5RvAD9w9390PEHwxfbnSLZ7/dvf97j6b4MtzmrtvdfcC4B1gaMy2W4H/c/dD7v4SsBq43My6AucAd4fHygWepOJfrvPcfaa7l7j7Pndf6O7z3b3I3TcQhNd5tTi3R8O/Pkun/w6XvwBcYWYtwvmvhMsgCLW/uPvf3P0Q8DOCsDqrFu97RDX8PN5199c8qLN4DhhcxeEuJ/iCfy78rKYBq4Ca3lKbAXQqveoguHp43d0LCcJjqrsvCv993AOMNLMeNT7Zin7i7p+7+wpgOTDb3de7+y7gdcr/Lf078Ft3/6e7F7v7MwSBMuIo31eqoYCQqnQHZpR+iRL8lV4MdIrZZkvM630R861i5gs8/BMw9DHQJZx2uPvuSusyYuY3xhbMzPqY2atm9ml42+lBoH0tzu3b7p4eM/0QwN3zwvMcF4bEFZQHRJewXITbloTlyqBu1eTz+DTm9V6geRV1MxXKXMWxquTue4E/Al8zMyMIhWeiju3ue4DtNT12hJr+W+oOfC824IGuYXmkjikgpCobgUsrfZE2D68OjkZG+CVTqhuwKZxOMrO0Suti36dyJepvCP4SPtXdWwP3AkbdmEZwK+ZKggrcvHD5JoIvJwDCc+laqZylvgBaxMyfXGl9dV0o1+TzqKkKZT7KYz0D/CvBrbU04NWoY5tZS6BdFcc+0udRGxuB/6n077JFeHUkdUwBIVWZDPyPmXUHMLMOZnblMRyvI/BtM0sxs2uBfsBr7r4ReB94yMyahxWONwPVtaBKAz4H9pjZacA3j6Fclb1IUKfyTcqvHgD+QHBL7EIzSwG+R3Br4/2IY+QCl5nZSWZ2MkF9TqwtBPfXD3OUn0dVXgP6mNlXwgr364D+lH/J18Q7wE5gCvCiux8Ml78AfN3MhphZM4KruH+Gt/wqywWuMbMWFjwbcfNRnEupJ4BbzexMC7Q0s8srBarUEQWEVOWXBBWHs81sN0GF9ZnHcLx/AqcSVGz+D/Bld98erhtPUFG7ieC+933u/rdqjvV9gvqB3QRfGC/Vsiy/torPQSwsXeHum4F5BHULL8UsXw18laAydhvBffxxMV+YsZ4DlhBUns6OKN9DwP8Lb5F8P2L/2n4ekcLP90sEYbadoGL9S+6+rRbHcOBZgquFZ2OW/x34IfAnYDPQi6AJbJRfEFRubyG4Ijnq5tPunkNQD/Frggr3PIJKb4kDq3hbWKTumdkEglYs5yS6LCJSc7qCEBGRSHELCDPramZvW/Dw0Qoz+4+IbczMHg0ftllq4QNJ4bqxZrY6XDcpXuUUEZFocbvFZGadgc7uviisQFoIXOXuH8ZscxlwB8FDP2cCv3T3My3otGwNQcuJfGABMD52XxERia+4XUG4+2Z3XxS+3k3QvrxyG+krgWc9MB9ID4NlOJAXPihzkKBlybG0oBERkVo6LnUQ4dOVQwlassTKoOJDUPnhsqqWi4jIcVIXPWNWy8xaETSF+467f155dcQuXs3yqONPJOi2mJYtWw477bTTjqG0IiKNy8KFC7e5e4eodXENiPCBoj8RdIA2PWKTfIKnUUtlErT9blrF8sO4+xSCh3jIzs72nJycOii5iEjjYGaVu2MpE89WTAY8Bax09/+tYrNZhP28mNkIYFf4oNIC4FQz6xl283t9uK2IiBwn8byCOJugB8plZpYbLruXoC8Y3H0yQVcAlxE8DbkX+Hq4rsjMbgfeIOjSd2rYy6OIiBwncQsId3+XI3SgFj7Gf1sV614jCBAREUmAuFdSi0j9cejQIfLz89m/f3+iiyLHWfPmzcnMzCQlJaXG+yggRBqR/Px80tLS6NGjBxV7X5eGzN3Zvn07+fn59OxZeZjxqqkvJpFGZP/+/bRr107h0MiYGe3atav1laMCQqSRUTg0Tkfze1dAiMhxlZyczJAhQ8qmhx9+OK7vN2vWrLi/x5w5c3j//aixoyp6+umnuf3224+4XY8ePdi2rfphOx588MEal+9oqQ5CRKo0c3EBj7yxmk0799ElPZW7xvTlqqHH1utNamoqubm5dVPAIygqKuKKK67giiuuiOv7zJkzh1atWnHWWWfF9X1iPfjgg9x7771xfQ9dQYhIpJmLC7hn+jIKdu7DgYKd+7hn+jJmLj7aYcmrtmvXLvr27cvq1asBGD9+PE888QQArVq14nvf+x5ZWVlceOGFFBYWArBu3TrGjh3LsGHDOPfcc1m1ahUAEyZM4M4772T06NHcfffdFf5qnzBhAt/85jcZPXo0p5xyCv/4xz+46aab6NevHxMmTCgrz+zZsxk5ciRZWVlce+217NmzBwj+sr/vvvvIyspi4MCBrFq1ig0bNjB58mR+8YtfMGTIEN555x3+/Oc/c+aZZzJ06FAuuugitmzZUu35b9++nUsuuYShQ4fyjW98g9hetq+66iqGDRvGgAEDmDJlCgCTJk1i3759DBkyhBtuuKHK7Y6ZuzeYadiwYS4iVfvwww9rvO1ZD/3du9/96mHTWQ/9/ZjKkJSU5IMHDy6bXnzxRXd3nz17to8YMcKnTZvmY8aMKdse8N///vfu7v7AAw/4bbfd5u7uF1xwga9Zs8bd3efPn++jR492d/cbb7zRL7/8ci8qKnJ399/97ndl+9x4441+3XXXeUlJic+cOdPT0tJ86dKlXlxc7FlZWb548WIvLCz0c8891/fs2ePu7g8//LA/8MAD7u7evXt3f/TRR93d/bHHHvObb77Z3d3vu+8+f+SRR8rKvGPHDi8pKXF39yeeeMLvvPPOw8oS64477ih7j1dffdUBLywsdHf37du3u7v73r17fcCAAb5t2zZ3d2/ZsmWFY1S1Xayo3z+Q41V8p+oWk4hE2rRzX62W11RVt5guvvhi/vjHP3LbbbexZMmSsuVJSUlcd911AHz1q1/lmmuuYc+ePbz//vtce+21ZdsdOHCg7PW1115LcnJy5PuPGzcOM2PgwIF06tSJgQMHAjBgwAA2bNhAfn4+H374IWeffTYABw8eZOTIkWX7X3PNNQAMGzaM6dOjupgLmhNfd911bN68mYMHDx6xaencuXPLjnX55ZfTtm3bsnWPPvooM2bMAGDjxo2sXbuWdu3aHXaMmm5XGwoIEYnUJT2Vgogw6JKeGpf3KykpYeXKlaSmprJjxw4yMzMjtzMzSkpKSE9Pr7Iuo2XLllW+T7NmzYAgeEpfl84XFRWRnJzMxRdfzLRp06rdPzk5maKiosht7rjjDu68806uuOIK5syZw/33319leWLPq7I5c+bw5ptvMm/ePFq0aMH5558f2VS1ptvVluogRCTSXWP6kppS8a/w1JRk7hrTNy7v94tf/IJ+/foxbdo0brrpJg4dOgQEwfHyyy8D8MILL3DOOefQunVrevbsyR//+EcguFUee9VxLEaMGMF7771HXl4eAHv37mXNmjXV7pOWlsbu3bvL5nft2kVGRlCZ/8wzzxzxPUeNGsXzzz8PwOuvv85nn31Wdpy2bdvSokULVq1axfz588v2SUlJKfuMqtvuWCggRCTSVUMzeOiagWSkp2JARnoqD10z8JhbMZVWrpZOkyZNYs2aNTz55JP8/Oc/59xzz2XUqFH8+Mc/BoKrgRUrVjBs2DDeeustfvSjHwHw/PPP89RTTzF48GAGDBjAK6+8cqynDECHDh14+umnGT9+PIMGDWLEiBFlFeBVGTduHDNmzCirpL7//vu59tprOffcc2nfvv0R3/O+++5j7ty5ZGVlMXv2bLp16wbA2LFjKSoqYtCgQfzwhz9kxIgRZftMnDiRQYMGccMNN1S73bGI25jUiaDxIESqt3LlSvr165foYtRKq1atyloRybGJ+v2b2UJ3z47aXlcQIiISSQEhIvWarh4SRwEhIiKRFBAiIhJJASEiIpEUECIiEkkBISLHVatWrQ5bNnnyZJ599tkElKZuTJgwoexhvmPZpr5RVxsiknC33nprXI9f2vlcUpL+Jq4NfVoiknD3338/P/vZzwA4//zzufvuuxk+fDh9+vThnXfeAaC4uJi77rqLM844g0GDBvHb3/4WCJrBXnjhhWVdcJc+Ub1hwwb69evHt771LbKysti4cWOF9+zRowf33nsvI0eOJDs7m0WLFjFmzBh69erF5MmTgSBY7rrrLk4//XQGDhzISy+9VLb89ttvp3///lx++eVs3bq17LgLFy7kvPPOY9iwYYwZM4bNmzfH98OLI11BiDRWr0+CT5fV7TFPHgiXHvvobUVFRXzwwQe89tprPPDAA7z55ps89dRTtGnThgULFnDgwAHOPvtsLrnkErp27cqMGTNo3bo127ZtY8SIEWUDBK1evZrf/e53PP7445Hv07VrV+bNm8d3v/tdJkyYwHvvvcf+/fsZMGAAt956K9OnTyc3N5clS5awbds2zjjjDEaNGsW8efNYvXo1y5YtY8uWLfTv37+s/6g77riDV155hQ4dOvDSSy/xgx/8gKlTpx7zZ5IICggRqXdiu9TesGEDEAzis3Tp0rL7+Lt27WLt2rVkZmZy7733MnfuXJKSkigoKCgboKd79+7V9ktUGiQDBw5kz549pKWlkZaWRvPmzdm5cyfvvvsu48ePJzk5mU6dOnHeeeexYMEC5s6dW7a8S5cuXHDBBUAQSMuXL+fiiy8Ggquezp07x+UzOh4UECKNVR38pR8vUV1quzu/+tWvGDNmTIVtn376aQoLC1m4cCEpKSn06NGjrKvr6rr9jn2fqrr+rq6vuqjuud2dAQMGMG/evBqcZf2nOggROSGMGTOG3/zmN2VdXK9Zs4YvvviCXbt20bFjR1JSUnj77bf5+OOP6+w9R40axUsvvURxcTGFhYXMnTuX4cOHM2rUKF588UWKi4vZvHkzb7/9NgB9+/alsLCwLCAOHTrEihUr6qw8x5uuIETkuNq7d2+FwYDuvPPOGu13yy23sGHDBrKysnB3OnTowMyZM7nhhhsYN24c2dnZDBkyhNNOO63Oynr11Vczb948Bg8ejJnx05/+lJNPPpmrr76at956i4EDB9KnTx/OO+88AJo2bcrLL7/Mt7/9bXbt2kVRURHf+c53GDBgQJ2V6XhSd98ijciJ2N231B119y0iInVCASEiIpEUECIiEkkBIdLINKR6R6m5o/m9xy0gzGyqmW01s+VVrL/LzHLDabmZFZvZSeG6DWa2LFynWmeROtK8eXO2b9+ukGhk3J3t27fTvHnzWu0Xz2auTwO/BiK7aHT3R4BHAMxsHPBdd98Rs8lod98Wx/KJNDqZmZnk5+dTWFiY6KLIcda8efMKzYtrIm4B4e5zzaxHDTcfD0yLV1lEJJCSkkLPnj0TXQw5QSS8DsLMWgBjgT/FLHZgtpktNLOJR9h/opnlmFmO/ioSEak7CQ8IYBzwXqXbS2e7exZwKXCbmY2qamd3n+Lu2e6e3aFDh3iXVUSk0agPAXE9lW4vufum8OdWYAYwPAHlEhFp1BIaEGbWBjgPeCVmWUszSyt9DVwCRLaEEhGR+IlbJbWZTQPOB9qbWT5wH5AC4O6Tw82uBma7+xcxu3YCZoRd6TYBXnD3v8arnCIiEi2erZjG12Cbpwmaw8YuWw8Mjk+pRESkpupDHYSIiNRDCggREYmkgBARkUgKCBERiaSAEBGRSAoIERGJpIAQEZFICggREYmkgBARkUgKCBERiaSAEBGRSAoIERGJpIAQEZFICggREYmkgBARkUgKCBERiaSAEBGRSAoIERGJpIAQEZFICggREYmkgBARkUgKCBERiaSAEBGRSAoIERGJpIAQEZFICggREYmkgBARkUgKCBERiaSAEBGRSAoIERGJpIAQEZFICggREYkUt4Aws6lmttXMllex/nwz22VmueH0o5h1Y81stZnlmdmkeJVRRESqFs8riKeBsUfY5h13HxJO/wVgZsnAY8ClQH9gvJn1j2M5RUQkQtwCwt3nAjuOYtfhQJ67r3f3g8CLwJV1WjgRETmiRNdBjDSzJWb2upkNCJdlABtjtskPl0Uys4lmlmNmOYWFhfEsq4hIo5LIgFgEdHf3wcCvgJnhcovY1qs6iLtPcfdsd8/u0KFD3ZdSRKSRSlhAuPvn7r4nfP0akGJm7QmuGLrGbJoJbEpAEUVEGrWEBYSZnWxmFr4eHpZlO7AAONXMeppZU+B6YFaiyiki0lg1ideBzWwacD7Q3szygfuAFAB3nwx8GfimmRUB+4Dr3d2BIjO7HXgDSAamuvuKeJVTRESiWfCd3DBkZ2d7Tk5OooshInLCMLOF7p4dtS7RrZhERKSeUkCIiEgkBYSIiERSQIiISCQFhIiIRFJAiIhIJAWEiIhEUkCIiEgkBYSIiERSQIiISCQFhIiIRFJAiIhIJAWEiIhEUkCIiEgkBYSIiERSQIiISCQFhIiIRFJAiIhIJAWEiIhEUkCIiEgkBYSIiERSQIiISCQFhIiIRFJAiIhIJAWEiIhEUkCIiEgkBYSIiERSQIiISCQFhIiIRFJAiIhIJAWEiIhEUkCIiEikuAWEmU01s61mtryK9TeY2dJwet/MBses22Bmy8ws18xy4lVGERGpWjyvIJ4Gxlaz/iPgPHcfBPw3MKXS+tHuPsTds+NUPhERqUaTeB3Y3eeaWY9q1r8fMzsfyIxXWUREpPbqSx3EzcDrMfMOzDazhWY2sbodzWyimeWYWU5hYWFcCyki0pjE7QqipsxsNEFAnBOz+Gx332RmHYG/mdkqd58btb+7TyG8PZWdne1xL7CISCOR0CsIMxsEPAlc6e7bS5e7+6bw51ZgBjA8MSUUEWm8EhYQZtYNmA78m7uviVne0szSSl8DlwCRLaFERCR+4naLycymAecD7c0sH7gPSAFw98nAj4B2wONmBlAUtljqBMwIlzUBXnD3v8arnCIiEi2erZjGH2H9LcAtEcvXA4MP30NERI6n+tKKSURE6hkFhIiIRFJAiIhIJAWEiIhEUkCIiEgkBYSIiERSQIiISCQFhIiIRFJAiIhIJAWEiIhEUkCIiEgkBYSIiERSQIiISCQFhIiIRFJAiIhIJAWEiIhEUkCIiEgkBYSIiERSQIiISCQFhIiIRFJAiIhIJAWEiIhEUkCIiEgkBYSIiERSQIiISCQFhIiIRFJAiIhIJAWEiIhEUkCIiEikJtWtNLOlNThGobtfWEflERGReqLagACSgcuqWW/ArLorjoiI1BdHusX0DXf/uJppA/CtqB3NbKqZbTWz5VWsNzN71MzyzGypmWXFrBtrZqvDdZOO+uxEROSoVRsQ7v4ugJn9R+V1pctKt4nwNDC2msNfCpwaThOB34THTQYeC9f3B8abWf/qyikiInWvppXUN0Ysm1DdDu4+F9hRzSZXAs96YD6QbmadgeFAnruvd/eDwIvhtiIichwdqZJ6PPAVoKeZxdY1pAHbj/G9M4CNMfP54bKo5Wce43uJiEgtHamS+n1gM9Ae+HnM8t1ATVo4Vccilnk1y6MPYjaR4BYV3bp1O8YiiYhIqWoDwt0/Bj4GRsbhvfOBrjHzmcAmoGkVy6sq4xRgCkB2dnaVQSIiIrVTbR2Emb16pAPUZJsqzAK+FrZmGgHscvfNwALgVDPraWZNgetRU1oRkePuSLeYzqlU91CZEbQ0OnyF2TTgfKC9meUD9wEpAO4+GXiN4BmLPGAv8PVwXZGZ3Q68QfAcxlR3X1HTExIRkbpxpIAoAP4JVNWUFeBg1EJ3H1/dgd3dgduqWPcaQYCIiEiCHCkgphDc4vl34CVgmrvnxrtQIiKSeEd6UO6X7j4SOI/gmYbfmdlKM/uRmfU5LiUUEZGEqNGDcmG3Gj9x96EEz0VcDayMa8lERCShahQQZpZiZuPM7HngdWAN8C9xLZmIiCTUkZ6kvhgYD1wOfEDQ7cVEd//iOJRNREQS6EiV1PcCLwDfd/fq+lUSEZEG5khPUo8+XgUREZH6RUOOiohIJAWEiIhEOlIdRIM3c3EBj7yxmk0799ElPZW7xvTlqqEZiS6WiEjCNeqAmLm4gHumL2PfoWIACnbu457pywAUEiLS6DXqW0yPvLG6LBxK7TtUzCNvrE5QiURE6o9GfQWxaec+AB5s8gRb/CRyvTe5Jb3YtDOx5RIRqQ8adUB0SU+lcOfnDE3Ko6/lk2TBeEOfWGeY/gpkZEPmMOg0EJo0TXBpRUSOr0YdEHeN6cs905dx6cGf0Iq9DEz6iDOarGN8l62wfg4sfSnYMLkZdB4EmWdAxjDIzIb07mBRo6OKiDQMjTogSiuig1ZM8EnrbK4bcwOdh2aAO+zKh4IcyA+nnKkw//Fg5xbtg6AovcrokgWp6Qk7FxGRumbBuD0NQ3Z2tufk5MTvDYoPwZYVYWgsDH5uW1O+vn2f8sDIyIZOAyA5JfJQal4rIvWBmS109+zIdQqIY7RvJ2xaVB4Y+Tmwd1uwrkkqdBlSflsqIxvaZDIzd1OF5rUAqSnJPHTNQIWEiBxXCojjyR12fhwERcHC4OfmJVB8IFjfqhNz93Zn/oGeLPbeLC05hS9IBSAjPZX3Jl2QwMKLSGNTXUA06jqIuDCDtj2CaeCXg2VFB2HL8rLA6Jo7h1EpHwBQ4sZaz2BxSW+W7O4Nn3aEjv0gKTlhpyAiArqCSIizH36LPTsLGZK0jiGWx5CkPIYkraOt7Qk2SGkJXYaW12VkZkPrLokttIg0SLqCqGeC5rUH+cehwfyDwVAMqSlJPHpJGy5ukx/ensqBeY9DyaFgp7QuFQOjy1Bo2jKxJyIiDZoCIgEqNq8tb8V0cWkF9aB/DX4WHYBPl5UHRn4OrPxzsM6SoGP/ihXgHfrq1pSI1BndYjrRfLGtvPK7IKwI378rWNc0DTKGll9lZGRDWqfDDqEmtiJSSreYGpKW7aHPmGACKCmBHesqXmW8/yiUFAXr23StcJXx560duGdWnnqwFZEj0hVEQ3RoH2xeWh4YBTmw8xMAikhiVUk3ckt6keu9WVzSm/XemS7pLdXEVqQR0hVEY5OSCt3ODKZSe7ZCwUImP/cigy2PK5Lf56v2dwA+9xYs+aIXvPV++e2plu0TVHgRqS8UEI1Fq47Q91KmtWrGz3buwyihl21iaFIeQ2wdZ6Ssh3f+Fzx8uju9e0xfU9lw8iBIaZ7YcxCR40oB0ciU9mC77xDkeSZ5xZm8mnIhD10xkD4D0oOnvktvS33yT1j+p2DHpBQ4+fSKFeDteqlHW5EGTAHRyFTVxLasgrr7WcFUavenFSvAl0yDBU8E65qnl1eAl3aF3uKk43tCIhI3qqSW2ikphsJVMaGxEApXgpcE6086peJVxsmnQ5NmgJrXitRHqqSWupOUHHRj3mkADLsxWHZgD2xaXH6VseEdWPaHYF1yUzh5EOuanca7eW1JPnQKTkc1rxU5AcQ1IMxsLPBLIBl40t0frrT+LuCGmLL0Azq4+w4z2wDsBoqBoqoSTuqBZq2g57nBVGpXQUwz24V0Wf9HfpZ0AJrBdk9jSUkvckt684/XVnDVaTdBatvElV9EIsXtFpOZJQNrgIuBfGABMN7dP6xi+3HAd939gnB+A5Dt7ttq+p66xVR/9Z40i1MtP2w1FXRQ2Ns2lY0DTrve5bemMrOh0+lVDrYkInUnUbeYhgN57r4+LMSLwJVAZEAA44FpcSyPJFCn9Fas3NmdlcXdeYELAWjFXi5IK+DRc4uCLkPWvQVLXwx2aNIcOg+uOEJfeje1mhI5juIZEBnAxpj5fODMqA3NrAUwFrg9ZrEDs83Mgd+6+5Qq9p0ITATo1q1bHRRb4qG8eW35KHrFKWlccNm1UFoH4Q67NlYcbCnnKZj/WLC+ZYeKgZGRBc3bJOBsRBqHeAZE1J96Vd3PGge85+47Ypad7e6bzKwj8DczW+Xucw87YBAcUyC4xXSshZb4OGLzWgiuDtK7BdPp1wTLKo8Dnr8A1rxeukMwDnhmdnlz244DIFltL0TqQjz/J+UDXWPmM4FNVWx7PZVuL7n7pvDnVjObQXDL6rCAkBPHVUMzat9iKTklGNe7yxA445Zg2b7PoGBR+VXGmr9C7vPBumrGAVcTW5HaiWcldROCSuoLgQKCSuqvuPuKStu1AT4Curr7F+GylkCSu+8OX/8N+C93/2t176lK6kbKHT7bULEb9M1LoPggAPubtefd/T1YVNSrbBzwkpRWPHTNQIWENHoJqaR29yIzux14g6CZ61R3X2Fmt4brJ4ebXg3MLg2HUCdghgUVkk2AF44UDtKImcFJPYOpwjjgyyB/IXPeeJW+voqLUoI/HkrcWOOZrH21L5SMC64yNA64yGH0JLU0eD0n/QUH0tkdjAMedlA4WOOAi+hJamncuqSnUrBzHztJY07JEOaUDAEgo01z3pvYo2JfUxoHXKSMAkIavKgmtqkpydw19jRolxH0Sjv4umDFof3BOOClgZG/4PBxwGO7QW/fR7empMFSQEiDV6MmtqVSmkPXM4Kp1BfbKl5lLJ8BC58O1tVwHHCRE5HqIERqq6QEtudVHNJ1y4rIccDn7u3O/QtS+GhXiZrXSr1UXR2EAkKkLhzaV3GwpfyFsCscB9yTWOXBOOArkvpw4UWXcdE550BSUoILLaKAEEmIcQ/9iU67VzA0aS1DbB2DktaTZvuClc3aBF2FxNZnaBxwSQC1YhJJgOW7mrOMYbxZMgyApJhxwH867GBwlfHOz8sHW9I44FLPKCBE4qS0eW2pEpJY65nsTTsVxl0QLDz4BWzKLa/P+GS+xgGXekMBIRInVTavHdO3fKOmLaHH2cFU6vPNYWAsCK4ycl8oHwc8tW1QAV4WGhoHXOJHASESJ7VqXhurdWdoPQ76jQvmS4ph68oKI/SR9xPKOkc+bBzwgcxcVqjOCeWYqZJa5ER0YHcwDnjs2Bl7PgWgOCmF5cXdWVTci8Ulvcn13hQ26cxD1wxSSMhhVEkt0tA0S4Oeo4IJgh5tPy+A/Bxemj6dXr6a65Pf5utN3gCCccBX/7kP7BpTfmsqNT1x5ZcTggJCpCEwgzaZ0CaTHzyXggNNKKKv5YedE+YxxNfBnAfL92l3asXBljQOuFSigBBpYEpbTxXRhBXegxXFPXiei8hIT+W97wwLB1sKH+bLexOWhGN1aRxwqUQBIdLAVNt6qnkb6DU6mCC4NbXzk/LAKMiBBU/GjAPeMbzCGAaZZ0CXLGjeOgFnJYmggBBpYGrVesoM2nYPptP/JVhWdBC2LK84Ql/sOOAd+la8yujYv8I44DMXF6gFVQOhVkwicmT7PgsDY2F5c9t9O4J1KS2g8xDIHMYHh07h7vlN+ehQOhDcmkpNSdbwrvWY+mISkbrlDp99VDEwPl1aNg74Fk8nt6Q3uSW9Wey92ZbWnzfvuTzBhZYoauYqInXLLHhA76RTYNC1wbKiA1z1w8kMTlpX1kHhmHAc8OL9Bo/3rzhCX4fTNNhSPaeAEJG60aQZhW0G8szO3jxTPAaAtnzO4KR1jEr9mJvStsOHs2DRs8H2TVsFw7iWNrPNyA6eIpd6QwEhInWmcguqz2jNP5OzuepLX4ehGcGtqe3rKg62NO/X5YMttc6oGBhdhmgc8ARSQIhInTliCyozaN87mAZfHyw7tD+ovygdA7wgB1bOCrdPhk79K/Y11b6PBls6TlRJLSL1z57CilcZBYvgwOfBumatg1tTsWNntOqo5rVHSZXUInJiadUB+l4aTBCOA742ZkjXHHj3/8CDW1l7U7vQ7IvujC0+hVzrzfKdPbln+jIAhcQxUECISP2XlBQ8oNehLwy9IVh2cG8wDnhBDvPf/AuDbA2XpswD4JAns9K7sfbVvmBXBVcZJ/XSralaUkCIyImpaQvoPhK6j+TmWafgQAc+Y2hSHkOS1jHE8hhTNAdm/jXYvnmbSoMtZUPLdok8g3pPASEiJ7zSDgoLacvskjOYXXIGAF3bNOWdmzIqDrb0zs/KxwFv26NiYHQeBE2aJe5E6hkFhIic8KrqoPB7Y/tDp4ygJVTW14IVB/bA5tzy+oyP34flLwfrklLg5IEVK8BPOqXR9mirgBCRE16tOihs1gp6nBNMpXYVVLzKWPx7+GBKsC71pIrPZmRkHTYOeENtQaVmriIilRUXQeHKmFZTC6FwFeXjgPcqC4w5X3Tj228X8fmh8quME6mDQnXWJyJyrPZ/HowDHjt2xp4tABzwFFZ497IOChd5b7x1N96758IEF/rIFBAiInXNHXZt5PafPsHgpDyGJOUx0D6iuR0CYJu3pn3fs8rHzuiSVS/HAU/Yg3JmNhb4JZAMPOnuD1dafz7wCvBRuGi6u/9XTfYVEUkoM0jvxuLWo3l15wigdBzwjQxNyuOsZhu4bMd6WPPX8n3a96k42FKnAfV6HPC4BYSZJQOPARcD+cACM5vl7h9W2vQdd//SUe4rIpJQsS2ognHAe7I+qTfZ4wYGHRTu2wmbFpXfllo7G5a8EOzcJDXokDC2ErxNZo1bTcW7cjyeVxDDgTx3Xw9gZi8CVwI1+ZI/ln1FRI6bI7agSk2HXhcEE4TjgH9c3mIqPwc+eCLo1RagVaeKVxkZWdAs7bD3nbm4oELT3oKd++q8e5F4BkQGsDFmPh84M2K7kWa2BNgEfN/dV9RiX8xsIjARoFu3bnVQbBGR2rlqaEbNv5TNggf02vaAgV8OlpWOAx7b19Tqv5TuEAyulDkMMs8IxwHvxyNvrK7w3AfAvkPFPPLG6hMiIKKukSrXiC8Curv7HjO7DJgJnFrDfYOF7lOAKRBUUh91aUVEEqVJ0+BKISOL8O9d2Lsj6MW2NDBW/SV4PgMgpSU/P9CN3Ca9WVzSi9yS3mwheDZj0859dVesOjvS4fKBrjHzmQRXCWXc/fOY16+Z2eNm1r4m+4qINGgtToJTLwomCG5N7VhfdlsqbcFb3GSv0bRJMZ97CwYfmIKTRJf01DorQjwDYgFwqpn1BAqA64GvxG5gZicDW9zdzWw4kARsB3YeaV8RkUbFDNr1CqZB/8razgWMn76IU4rW08l24CSRmpLMXWP61tlbxi0g3L3IzG4H3iBoqjrV3VeY2a3h+snAl4FvmlkRsA+43oMHMyL3jVdZRURONOWV4y1ZsnMfGXFoxaQH5UREGrHqHpTT6BkiIhJJASEiIpEUECIiEkkBISIikRQQIiISSQEhIiKRFBAiIhJJASEiIpEUECIiEkkBISIikRQQIiISSQEhIiKRFBAiIhJJASEiIpEUECIiEkkBISIikRQQIiISSQEhIiKRFBAiIhJJASEiIpEUECIiEkkBISIikRQQIiISSQEhIiKRFBAiIhJJASEiIpEUECIiEkkBISIikRQQIiISSQEhIiKRFBAiIhJJASEiIpHiGhBmNtbMVptZnplNilh/g5ktDaf3zWxwzLoNZrbMzHLNLCee5RQRkcM1ideBzSwZeAy4GMgHFpjZLHf/MGazj4Dz3P0zM7sUmAKcGbN+tLtvi1cZRUSkavG8ghgO5Ln7enc/CLwIXBm7gbu/7+6fhbPzgcw4lkdERGohngGRAWyMmc8Pl1XlZuD1mHkHZpvZQjObWNVOZjbRzHLMLKewsPCYCiwiIuXidosJsIhlHrmh2WiCgDgnZvHZ7r7JzDoCfzOzVe4+97ADuk8huDVFdnZ25PFFRKT24nkFkQ90jZnPBDZV3sjMBgFPAle6+/bS5e6+Kfy5FZhBcMtKRESOk3gGxALgVDPraWZNgeuBWbEbmFk3YDrwb+6+JmZ5SzNLK30NXAIsj2NZRUSkkrjdYnL3IjO7HXgDSAamuvsKM7s1XD8Z+BHQDnjczACK3D0b6ATMCJc1AV5w97/Gq6wiInI4c284t+2zs7M9J0ePTIiI1JSZLQz/MD+MnqQWEZFICggREYmkgBARkUgKCBERiaSAEBGRSAoIERGJpIAQEZFICggREYmkgBARkUgKCBERiaSAEBGRSAoIERGJpIAQEZFICggREYmkgBARkUgKCBERiaSAEBGRSAoIERGJpIAQEZFICggREYmkgBARkUgKCBERiaSAEBGRSAoIERGJpIAQEZFICggREYmkgBARkUgKCBERiaSAEBGRSAoIERGJpIAQEZFIcQ0IMxtrZqvNLM/MJkWsNzN7NFy/1MyyarqviIjEV9wCwsySgceAS4H+wHgz619ps0uBU8NpIvCbWuwrIiJxFM8riOFAnruvd/eDwIvAlZW2uRJ41gPzgXQz61zDfUVEJI7iGRAZwMaY+fxwWU22qcm+IiISR03ieGyLWOY13KYm+wYHMJtIcHsKYI+Zra5xCStqD2w7yn1PVDrnhq+xnS/onGure1Ur4hkQ+UDXmPlMYFMNt2lag30BcPcpwJRjLayZ5bh79rEe50Sic274Gtv5gs65LsXzFtMC4FQz62lmTYHrgVmVtpkFfC1szTQC2OXum2u4r4iIxFHcriDcvcjMbgfeAJKBqe6+wsxuDddPBl4DLgPygL3A16vbN15lFRGRw8XzFhPu/hpBCMQumxzz2oHbarpvnB3zbaoTkM654Wts5ws65zpjwXe0iIhIRepqQ0REIjX6gGioXXqYWVcze9vMVprZCjP7j3D5SWb2NzNbG/5sG7PPPeHnsNrMxiSu9EfPzJLNbLGZvRrON+jzBTCzdDN72cxWhb/vkQ35vM3su+G/6eVmNs3MmjfE8zWzqWa21cyWxyyr9Xma2TAzWxaue9TMoh4jiObujXYiqABfB5xC0LR2CdA/0eWqo3PrDGSFr9OANQTdlvwUmBQunwT8JHzdPzz/ZkDP8HNJTvR5HMV53wm8ALwazjfo8w3P5RnglvB1UyC9oZ43wQOzHwGp4fwfgAkN8XyBUUAWsDxmWa3PE/gAGEnwfNnrwKU1LUNjv4JosF16uPtmd18Uvt4NrCT4z3UlwRcK4c+rwtdXAi+6+wF3/4igZdnw41roY2RmmcDlwJMxixvs+QKYWWuCL5KnANz9oLvvpGGfdxMg1cyaAC0InpFqcOfr7nOBHZUW1+o8w66LWrv7PA/S4tmYfY6osQdEo+jSw8x6AEOBfwKdPHjWhPBnx3CzhvBZ/B/wn0BJzLKGfL4QXP0WAr8Lb609aWYtaaDn7e4FwM+AT4DNBM9OzaaBnm+E2p5nRvi68vIaaewBUeMuPU5UZtYK+BPwHXf/vLpNI5adMJ+FmX0J2OruC2u6S8SyE+Z8YzQhuA3xG3cfCnxBcOuhKif0eYf33K8kuI3SBWhpZl+tbpeIZSfM+dbCMXdbFKWxB0RNugM5YZlZCkE4PO/u08PFW8LLTsKfW8PlJ/pncTZwhZltILhVeIGZ/Z6Ge76l8oF8d/9nOP8yQWA01PO+CPjI3Qvd/RAwHTiLhnu+ldX2PPPD15WX10hjD4gG26VH2FLhKWClu/9vzKpZwI3h6xuBV2KWX29mzcysJ8EYHR8cr/IeK3e/x90z3b0Hwe/xLXf/Kg30fEu5+6fARjPrGy66EPiQhnvenwAjzKxF+G/8QoL6tYZ6vpXV6jzD21C7zWxE+Hl9LWafI0t0TX2iJ4KuPtYQ1Pr/INHlqcPzOofgUnIpkBtOlwHtgL8Da8OfJ8Xs84Pwc1hNLVo61LcJOJ/yVkyN4XyHADnh73om0LYhnzfwALAKWA48R9Byp8GdLzCNoJ7lEMGVwM1Hc55AdvhZrQN+TfiAdE0mPUktIiKRGvstJhERqYICQkREIikgREQkkgJCREQiKSBERCSSAkJERCIpIETqQNjl9rfC1+eb2S4zq3ZExLA79j1mVueDzYvUBQWESN1IB74VM/+Ou19W3Q7uPprgATeReimuY1KLNCIPA73MLJfgydctpSvCPnNeAloT/J/7pru/k4hCitSGriBE6sYkYJ27DwHuqrTuK8Ab4brBBN2eiNR7uoIQib8FwNSwd92Z7p6b4PKI1IiuIETizIORwUYBBcBzZva1BBdJpEYUECJ1YzfB2N+HMbPuBIMZPUHQBXvW8SyYyNHSLSaROuDu283sPTNbDuwjppKaoPvxu8zsELCHoE9+kXpPASFSR9z9KxA8BwF8P2b5M5QPNC9ywtAtJpG6dxA4vSYPygGnEDSLFal3NGCQiIhE0hWEiIhEUkCIiEgkBYSIiERSQIiISCQFhIiIRPr/w8ueSb7nm5gAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(6,6)) # \n", + "ax = plt.subplot() \n", + "ax.plot(x,y,\"o\",label=\"Experimental data\")\n", + "ax.plot(x,func(x,*popt[0]),label=\"Linear model\")\n", + "ax.set_ylim([0,2])\n", + "ax.set_xlabel(\"t[s]\")\n", + "ax.set_ylabel(\"V[t]\")\n", + "ax.set_title(\"Temporal Evolution of Volume\")\n", + "ax.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Fitting : non linear" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 0 1 2\n", + "0 0.102 0.319 0.565\n", + "1 0.204 0.452 0.672\n", + "2 0.306 0.553 0.744\n", + "3 0.408 0.639 0.799\n", + "4 0.510 0.714 0.845\n", + "5 0.612 0.782 0.885\n", + "6 0.714 0.845 0.919\n", + "7 0.816 0.904 0.951\n", + "8 0.918 0.958 0.979\n", + "9 1.020 1.010 1.005\n", + "10 1.122 1.059 1.029\n", + "11 1.224 1.107 1.052\n", + "12 1.327 1.152 1.073\n", + "13 1.429 1.195 1.093\n", + "14 1.531 1.237 1.112\n", + "15 1.633 1.278 1.130\n", + "16 1.735 1.317 1.148\n", + "17 1.837 1.355 1.164\n", + "18 1.939 1.392 1.180\n", + "19 2.041 1.429 1.195\n", + "20 2.143 1.464 1.210\n", + "21 2.245 1.498 1.224\n", + "22 2.347 1.532 1.238\n", + "23 2.449 1.565 1.251\n", + "24 2.551 1.597 1.264\n", + "25 2.653 1.629 1.276\n", + "26 2.755 1.660 1.288\n", + "27 2.857 1.690 1.300\n", + "28 2.959 1.720 1.312\n", + "29 3.061 1.750 1.323\n", + "30 3.163 1.779 1.334\n", + "31 3.265 1.807 1.344\n", + "32 3.367 1.835 1.355\n", + "33 3.469 1.863 1.365\n", + "34 3.571 1.890 1.375\n", + "35 3.673 1.917 1.384\n", + "36 3.776 1.943 1.394\n", + "37 3.878 1.969 1.403\n", + "38 3.980 1.995 1.412\n", + "39 4.082 2.020 1.421\n", + "40 4.184 2.045 1.430\n", + "41 4.286 2.070 1.439\n", + "42 4.388 2.095 1.447\n", + "43 4.490 2.119 1.456\n", + "44 4.592 2.143 1.464\n", + "45 4.694 2.167 1.472\n", + "46 4.796 2.190 1.480\n", + "47 4.898 2.213 1.488\n", + "48 5.000 2.236 1.495\n" + ] + } + ], + "source": [ + "# read raw file\n", + "fwidths = [6,6,6]\n", + "dexpe = pd.read_fwf(\"power.dat\",delimiter=\" \",header = None, widths = fwidths)\n", + "print(dexpe)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "# get x and y\n", + "x =dexpe.iloc[:,0]\n", + "y1=dexpe.iloc[:,1]\n", + "y2=dexpe.iloc[:,2]" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# plot\n", + "fig = plt.figure(figsize=(6,6)) # s\n", + "ax = plt.subplot() \n", + "ax.plot(x,y1,\"o\",label=\"Experimental data 1\")\n", + "ax.plot(x,y2,\"o\",label=\"Experimental data 2\")\n", + "ax.set_ylim([0,2])\n", + "ax.set_xlabel(\"t[s]\")\n", + "ax.set_ylabel(\"V[t]\")\n", + "ax.set_title(\"Temporal Evolution of Volume\")\n", + "ax.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### log-log" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# plot\n", + "fig = plt.figure(figsize=(6,6)) # s\n", + "ax = plt.subplot() \n", + "ax.plot(x,y1,\"o\",label=\"Experimental data 1\")\n", + "ax.plot(x,y2,\"o\",label=\"Experimental data 2\")\n", + "ax.set_xlabel(\"t[s]\")\n", + "ax.set_ylabel(\"V[t]\")\n", + "ax.set_title(\"Temporal Evolution of Volume\")\n", + "ax.legend()\n", + "ax.loglog()" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "def func(x, a, b):\n", + " return a * x + b" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "popt= curve_fit(func, np.log(x), np.log(y1))" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.500\n", + "-0.000\n" + ] + } + ], + "source": [ + "popt[0]\n", + "a=popt[0][0]\n", + "b=popt[0][1]\n", + "print(\"%.3f\" % a)\n", + "print(\"%.3f\" % b)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# plot\n", + "fig = plt.figure(figsize=(6,6)) # s\n", + "ax = plt.subplot() \n", + "ax.plot(x,y1,\"o\",label=\"Experimental data 1\")\n", + "ax.plot(x,x**a+b,\"-\",label=\"Model 1\")\n", + "ax.set_xlabel(\"t[s]\")\n", + "ax.set_ylabel(\"V[t]\")\n", + "ax.set_title(\"Temporal Evolution of Volume\")\n", + "ax.legend()\n", + "ax.loglog()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Errors bar" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 1\n", + "1 2\n", + "2 3\n", + "3 4\n", + "4 5\n", + "Name: x, dtype: int64 0 1\n", + "1 4\n", + "2 8\n", + "3 17\n", + "4 24\n", + "Name: y, dtype: int64 0 0.2\n", + "1 0.2\n", + "2 0.3\n", + "3 0.4\n", + "4 0.2\n", + "Name: er, dtype: float64\n" + ] + } + ], + "source": [ + "# read file\n", + "d = pd.read_csv(\"data.csv\",delimiter=\";\")\n", + "# taking values from headers\n", + "x=d[\"x\"]\n", + "y=d[\"y\"]\n", + "e=d[\"er\"]\n", + "print(x,y,e)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(6,6)) # s\n", + "ax = plt.subplot() \n", + "ax.errorbar(x,0.1*y,e*2, marker='.', linestyle=\"none\", label=\"data\")\n", + "ax.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "metadata": {}, + "outputs": [], + "source": [ + "# data generation\n", + "x=np.linspace(0,5)\n", + "y1 = np.power(x,0.5)\n", + "y2 = np.power(x,0.25)\n", + "#print(np.size(x))\n", + "#for i in range(50):\n", + "# print(\"%.3f\" % x[i],\"%.3f\" % np.power(x[i],0.5),\"%.3f\" % np.power(x[i],0.25))\n", + "#print(x,np.power(x,1./2))" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "metadata": {}, + "outputs": [], + "source": [ + "sx = pd.Series(x)\n", + "sy1 = pd.Series(y1)\n", + "sy2 = pd.Series(y2)" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "metadata": {}, + "outputs": [], + "source": [ + "nd = pd.concat([sx,sy1,sy2],axis=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": {}, + "outputs": [], + "source": [ + "nd.to_csv(\"test.csv\")" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "metadata": {}, + "outputs": [], + "source": [ + "d = pd.read_csv(\"test.csv\",delimiter=\",\")" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Unnamed: 0012
000.0000000.0000000.000000
110.1020410.3194380.565189
220.2040820.4517540.672126
330.3061220.5532830.743830
440.4081630.6388770.799298
550.5102040.7142860.845154
660.6122450.7824610.884568
770.7142860.8451540.919323
880.8163270.9035080.950530
990.9183670.9583150.978936
10101.0204081.0101531.005063
11111.1224491.0594571.029299
12121.2244901.1065671.051935
13131.3265311.1517511.073197
14141.4285711.1952291.093265
15151.5306121.2371791.112286
16161.6326531.2777531.130377
17171.7346941.3170781.147640
18181.8367351.3552621.164157
19191.9387761.3923991.180000
20202.0408161.4285711.195229
21212.1428571.4638501.209897
22222.2448981.4982981.224050
23232.3469391.5319721.237729
24242.4489801.5649221.250968
25252.5510201.5971911.263800
26262.6530611.6288221.276253
27272.7551021.6598501.288352
28282.8571431.6903091.300119
29292.9591841.7202281.311575
30303.0612241.7496361.322738
31313.1632651.7785571.333626
32323.2653061.8070161.344253
33333.3673471.8350331.354634
34343.4693881.8626291.364782
35353.5714291.8898221.374708
36363.6734691.9166301.384424
37373.7755101.9430671.393939
38383.8775511.9691501.403264
39393.9795921.9948911.412406
40404.0816332.0203051.421374
41414.1836732.0454031.430176
42424.2857142.0701971.438818
43434.3877552.0946971.447307
44444.4897962.1189141.455649
45454.5918372.1428571.463850
46464.6938782.1665361.471916
47474.7959182.1899591.479851
48484.8979592.2131331.487660
49495.0000002.2360681.495349
\n", + "
" + ], + "text/plain": [ + " Unnamed: 0 0 1 2\n", + "0 0 0.000000 0.000000 0.000000\n", + "1 1 0.102041 0.319438 0.565189\n", + "2 2 0.204082 0.451754 0.672126\n", + "3 3 0.306122 0.553283 0.743830\n", + "4 4 0.408163 0.638877 0.799298\n", + "5 5 0.510204 0.714286 0.845154\n", + "6 6 0.612245 0.782461 0.884568\n", + "7 7 0.714286 0.845154 0.919323\n", + "8 8 0.816327 0.903508 0.950530\n", + "9 9 0.918367 0.958315 0.978936\n", + "10 10 1.020408 1.010153 1.005063\n", + "11 11 1.122449 1.059457 1.029299\n", + "12 12 1.224490 1.106567 1.051935\n", + "13 13 1.326531 1.151751 1.073197\n", + "14 14 1.428571 1.195229 1.093265\n", + "15 15 1.530612 1.237179 1.112286\n", + "16 16 1.632653 1.277753 1.130377\n", + "17 17 1.734694 1.317078 1.147640\n", + "18 18 1.836735 1.355262 1.164157\n", + "19 19 1.938776 1.392399 1.180000\n", + "20 20 2.040816 1.428571 1.195229\n", + "21 21 2.142857 1.463850 1.209897\n", + "22 22 2.244898 1.498298 1.224050\n", + "23 23 2.346939 1.531972 1.237729\n", + "24 24 2.448980 1.564922 1.250968\n", + "25 25 2.551020 1.597191 1.263800\n", + "26 26 2.653061 1.628822 1.276253\n", + "27 27 2.755102 1.659850 1.288352\n", + "28 28 2.857143 1.690309 1.300119\n", + "29 29 2.959184 1.720228 1.311575\n", + "30 30 3.061224 1.749636 1.322738\n", + "31 31 3.163265 1.778557 1.333626\n", + "32 32 3.265306 1.807016 1.344253\n", + "33 33 3.367347 1.835033 1.354634\n", + "34 34 3.469388 1.862629 1.364782\n", + "35 35 3.571429 1.889822 1.374708\n", + "36 36 3.673469 1.916630 1.384424\n", + "37 37 3.775510 1.943067 1.393939\n", + "38 38 3.877551 1.969150 1.403264\n", + "39 39 3.979592 1.994891 1.412406\n", + "40 40 4.081633 2.020305 1.421374\n", + "41 41 4.183673 2.045403 1.430176\n", + "42 42 4.285714 2.070197 1.438818\n", + "43 43 4.387755 2.094697 1.447307\n", + "44 44 4.489796 2.118914 1.455649\n", + "45 45 4.591837 2.142857 1.463850\n", + "46 46 4.693878 2.166536 1.471916\n", + "47 47 4.795918 2.189959 1.479851\n", + "48 48 4.897959 2.213133 1.487660\n", + "49 49 5.000000 2.236068 1.495349" + ] + }, + "execution_count": 102, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "d" + ] + }, + { + "cell_type": "code", + "execution_count": 110, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 111, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Unnamed: 0012
10101.0204081.0101531.005063
11111.1224491.0594571.029299
12121.2244901.1065671.051935
13131.3265311.1517511.073197
14141.4285711.1952291.093265
15151.5306121.2371791.112286
16161.6326531.2777531.130377
17171.7346941.3170781.147640
18181.8367351.3552621.164157
19191.9387761.3923991.180000
20202.0408161.4285711.195229
21212.1428571.4638501.209897
22222.2448981.4982981.224050
23232.3469391.5319721.237729
24242.4489801.5649221.250968
25252.5510201.5971911.263800
26262.6530611.6288221.276253
27272.7551021.6598501.288352
28282.8571431.6903091.300119
29292.9591841.7202281.311575
30303.0612241.7496361.322738
31313.1632651.7785571.333626
32323.2653061.8070161.344253
33333.3673471.8350331.354634
34343.4693881.8626291.364782
35353.5714291.8898221.374708
36363.6734691.9166301.384424
37373.7755101.9430671.393939
38383.8775511.9691501.403264
39393.9795921.9948911.412406
40404.0816332.0203051.421374
41414.1836732.0454031.430176
42424.2857142.0701971.438818
43434.3877552.0946971.447307
44444.4897962.1189141.455649
45454.5918372.1428571.463850
46464.6938782.1665361.471916
47474.7959182.1899591.479851
48484.8979592.2131331.487660
49495.0000002.2360681.495349
\n", + "
" + ], + "text/plain": [ + " Unnamed: 0 0 1 2\n", + "10 10 1.020408 1.010153 1.005063\n", + "11 11 1.122449 1.059457 1.029299\n", + "12 12 1.224490 1.106567 1.051935\n", + "13 13 1.326531 1.151751 1.073197\n", + "14 14 1.428571 1.195229 1.093265\n", + "15 15 1.530612 1.237179 1.112286\n", + "16 16 1.632653 1.277753 1.130377\n", + "17 17 1.734694 1.317078 1.147640\n", + "18 18 1.836735 1.355262 1.164157\n", + "19 19 1.938776 1.392399 1.180000\n", + "20 20 2.040816 1.428571 1.195229\n", + "21 21 2.142857 1.463850 1.209897\n", + "22 22 2.244898 1.498298 1.224050\n", + "23 23 2.346939 1.531972 1.237729\n", + "24 24 2.448980 1.564922 1.250968\n", + "25 25 2.551020 1.597191 1.263800\n", + "26 26 2.653061 1.628822 1.276253\n", + "27 27 2.755102 1.659850 1.288352\n", + "28 28 2.857143 1.690309 1.300119\n", + "29 29 2.959184 1.720228 1.311575\n", + "30 30 3.061224 1.749636 1.322738\n", + "31 31 3.163265 1.778557 1.333626\n", + "32 32 3.265306 1.807016 1.344253\n", + "33 33 3.367347 1.835033 1.354634\n", + "34 34 3.469388 1.862629 1.364782\n", + "35 35 3.571429 1.889822 1.374708\n", + "36 36 3.673469 1.916630 1.384424\n", + "37 37 3.775510 1.943067 1.393939\n", + "38 38 3.877551 1.969150 1.403264\n", + "39 39 3.979592 1.994891 1.412406\n", + "40 40 4.081633 2.020305 1.421374\n", + "41 41 4.183673 2.045403 1.430176\n", + "42 42 4.285714 2.070197 1.438818\n", + "43 43 4.387755 2.094697 1.447307\n", + "44 44 4.489796 2.118914 1.455649\n", + "45 45 4.591837 2.142857 1.463850\n", + "46 46 4.693878 2.166536 1.471916\n", + "47 47 4.795918 2.189959 1.479851\n", + "48 48 4.897959 2.213133 1.487660\n", + "49 49 5.000000 2.236068 1.495349" + ] + }, + "execution_count": 111, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.9.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/source/Plotting1.ipynb b/source/Plotting1.ipynb new file mode 100644 index 0000000..1c2b8df --- /dev/null +++ b/source/Plotting1.ipynb @@ -0,0 +1,483 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "f8579363", + "metadata": {}, + "source": [ + "# **Libraries**" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "e4d24b04", + "metadata": {}, + "outputs": [], + "source": [ + "# libraries\n", + "import scipy \n", + "# \"SciPy\" provides algorithms for optimization, integration, interpolation, eigenvalue problems, \n", + "# algebraic equations, differential equations, statistics and many other classes of problems.\n", + "import numpy as np\n", + "# Fast and versatile, the \"NumPy\" vectorization, indexing, and broadcasting concepts are the \n", + "# de-facto standards of array computing today.\n", + "import matplotlib.pyplot as plt\n", + "# \"Matplotlib\" is a comprehensive library for creating static, animated, and interactive \n", + "# visualizations in Python." + ] + }, + { + "cell_type": "markdown", + "id": "4c41a20d", + "metadata": {}, + "source": [ + "## Data" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "9e9a38b3", + "metadata": {}, + "outputs": [], + "source": [ + "x= np.linspace(0,2*np.pi)\n", + "y= np.sin(x)" + ] + }, + { + "cell_type": "markdown", + "id": "6a8dcbb5", + "metadata": {}, + "source": [ + "## Anatomy of a figure" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "b5768c9e", + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "from PIL import Image\n", + "img = Image.open('anatomy.webp')\n", + "img.save(\"anatomy.png\")" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "8f75cee3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# import image module\n", + "from IPython.display import Image\n", + " \n", + "# get the image\n", + "Image(url=\"anatomy.png\", width=500, height=500)" + ] + }, + { + "cell_type": "markdown", + "id": "82c13c31", + "metadata": {}, + "source": [ + "## Implicit or explicit?\n", + "**Using figures**\n", + "- Explicitly create Figures and Axes, and call methods on them (the \"object-oriented (OO) style\").\n", + "- Rely on pyplot to implicitly create and manage the Figures and Axes, and use pyplot functions for plotting." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "0f84f0db", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# implicit \n", + "plt.plot(x,y,label=\"sin\")\n", + "plt.xlabel('x label')\n", + "plt.ylabel('y label')\n", + "plt.title(\"Simple Plot\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "3f2d03de", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# explicity\n", + "fig = plt.figure(figsize=(6,6)) # size\n", + "ax = plt.subplot(aspect=1) # aspect ratio\n", + "ax.plot(x,y,label=\"sin\") # label\n", + "ax.set_xlabel('x') # Add an x-label to the axes.\n", + "ax.set_ylabel('y') # Add a y-label to the axes.\n", + "ax.set_title(\"Simple Plot\") # Add a title to the axes.\n", + "ax.legend() # Add a legend." + ] + }, + { + "cell_type": "markdown", + "id": "9d5ac225", + "metadata": {}, + "source": [ + "### Figure : lines" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "568d7656", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(6,6))\n", + "ax = plt.subplot(aspect=1)\n", + "ax.plot(x,y,label=\"sin\",color='blue', linewidth=3, linestyle='--') \n", + "ax.plot(x,y*y,label=\"$\\sin^2$\",color='red', linewidth=1, linestyle='dotted') \n", + "ax.set_xlabel('x') # Add an x-label to the axes.\n", + "ax.set_ylabel('y') # Add a y-label to the axes.\n", + "ax.set_title(\"Simple Plot\") # Add a title to the axes.\n", + "ax.legend() # Add a legend." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "b316fd3f", + "metadata": {}, + "outputs": [], + "source": [ + "ax.plot?" + ] + }, + { + "cell_type": "markdown", + "id": "287d0813", + "metadata": {}, + "source": [ + "## Figure and Axes" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "7cbcc514", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0,0.5,'y')" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#\n", + "fig = plt.figure(figsize=(6,6))\n", + "ax = plt.subplot(aspect=1)\n", + "ax.plot(x,y,\".r\",label=\"$\\sin(x)$\") \n", + "ax.plot(x,y*y,\".g\",label=\"$\\sin(x)^2$\") \n", + "ax.legend()\n", + "ax.set_xlabel(\"x\")\n", + "ax.set_ylabel(\"y\")" + ] + }, + { + "cell_type": "markdown", + "id": "cf3594a3", + "metadata": {}, + "source": [ + "### Figures : axes and text" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "8cd16580", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0,0.5,'y')" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# adding text\n", + "fig = plt.figure(figsize=(6,6))\n", + "ax = plt.subplot(aspect=1)\n", + "ax.plot(x,y,\".\",label=\"sin\") \n", + "ax.legend()\n", + "\n", + "\n", + "ax.text(0.3, 0.1, \"-> Mot\",family=\"cursive\",size=14)\n", + "ax.text(0.3, -0.5, \"-> Mot\",family=\"serif\",size = 14)\n", + "\n", + "ax.annotate('point (3,0)', xy=(3, 0), xytext=(4, 0.5),\n", + " arrowprops=dict(facecolor='black', shrink=0.05))\n", + "\n", + "ax.set_title('Title')\n", + "ax.set_xlabel(\"x\")\n", + "ax.set_ylabel(\"y\")\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "977fb62b", + "metadata": {}, + "source": [ + "### figure : scales" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "5f4d1736", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 51, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(6,6)) # size\n", + "ax = plt.subplot(aspect=1) # aspect ratio\n", + "\n", + "ax.plot(x,y,label=\"sin\") # label\n", + "ax.set_xscale('log')\n", + "ax.set_yscale('log')\n", + "ax.set_xlabel('x') # Add an x-label to the axes.\n", + "ax.set_ylabel('y') # Add a y-label to the axes.\n", + "ax.set_title(\"Title\") # Add a title to the axes.\n", + "ax.legend() # Add a legend." + ] + }, + { + "cell_type": "markdown", + "id": "b2266d48", + "metadata": {}, + "source": [ + "### figures multiples" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "id": "45b0275c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 72, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, (ax0, ax1, ax2) = plt.subplots(nrows=1, ncols=3,\n", + " figsize=(6, 6))\n", + "fig.tight_layout()\n", + "ax0.set_title('a')\n", + "ax0.plot(x,y,label=\"sin\") # label\n", + "\n", + "ax1.plot(x,y,label=\"sin\") # label\n", + "\n", + "ax2.set_title('title')\n", + "ax2.plot(x,y,label=\"sin\") # label\n" + ] + }, + { + "cell_type": "markdown", + "id": "fecf66d0", + "metadata": {}, + "source": [ + "### figure : save" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "id": "2f6abdd2", + "metadata": {}, + "outputs": [], + "source": [ + "#save\n", + "fig.savefig(\"output.png\")\n", + "fig.savefig(\"output.pdf\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.9.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/source/anatomy.png b/source/anatomy.png new file mode 100644 index 0000000..2532b6d Binary files /dev/null and b/source/anatomy.png differ diff --git a/source/anatomy.webp b/source/anatomy.webp new file mode 100644 index 0000000..cb6521e Binary files /dev/null and b/source/anatomy.webp differ diff --git a/source/data.csv b/source/data.csv new file mode 100644 index 0000000..8161d5d --- /dev/null +++ b/source/data.csv @@ -0,0 +1,6 @@ +x;y;er +1;1;0.2 +2;4;0.2 +3;8;0.3 +4;17;0.4 +5;24;0.2 \ No newline at end of file diff --git a/source/data.raw b/source/data.raw new file mode 100644 index 0000000..3ea963a --- /dev/null +++ b/source/data.raw @@ -0,0 +1,3 @@ +1 1 0.2 +2 4 0.2 +3 8 0.3 diff --git a/source/data.txt b/source/data.txt new file mode 100644 index 0000000..eb919ad --- /dev/null +++ b/source/data.txt @@ -0,0 +1,4 @@ +x y er +1 1 0.2 +2 4 0.2 +3 8 0.3 diff --git a/source/data.xlsx b/source/data.xlsx new file mode 100644 index 0000000..2161ab2 Binary files /dev/null and b/source/data.xlsx differ diff --git a/source/expe.dat b/source/expe.dat new file mode 100644 index 0000000..a7826a6 --- /dev/null +++ b/source/expe.dat @@ -0,0 +1,11 @@ + 0.000000 0.894520 + 100.000000 0.849616 + 200.000000 0.806313 + 300.000000 0.763861 + 400.000000 0.722299 + 500.000000 0.681680 + 600.000000 0.642211 + 700.000000 0.603411 + 800.000000 0.565199 + 900.000000 0.528873 +1000.000000 0.492817 \ No newline at end of file diff --git a/source/output.pdf b/source/output.pdf new file mode 100644 index 0000000..6c9d80a Binary files /dev/null and b/source/output.pdf differ diff --git a/source/output.png b/source/output.png index 57579ae..77dbbd8 100644 Binary files a/source/output.png and b/source/output.png differ diff --git a/source/power.dat b/source/power.dat new file mode 100644 index 0000000..c867b77 --- /dev/null +++ b/source/power.dat @@ -0,0 +1,49 @@ +0.102 0.319 0.565 +0.204 0.452 0.672 +0.306 0.553 0.744 +0.408 0.639 0.799 +0.510 0.714 0.845 +0.612 0.782 0.885 +0.714 0.845 0.919 +0.816 0.904 0.951 +0.918 0.958 0.979 +1.020 1.010 1.005 +1.122 1.059 1.029 +1.224 1.107 1.052 +1.327 1.152 1.073 +1.429 1.195 1.093 +1.531 1.237 1.112 +1.633 1.278 1.130 +1.735 1.317 1.148 +1.837 1.355 1.164 +1.939 1.392 1.180 +2.041 1.429 1.195 +2.143 1.464 1.210 +2.245 1.498 1.224 +2.347 1.532 1.238 +2.449 1.565 1.251 +2.551 1.597 1.264 +2.653 1.629 1.276 +2.755 1.660 1.288 +2.857 1.690 1.300 +2.959 1.720 1.312 +3.061 1.750 1.323 +3.163 1.779 1.334 +3.265 1.807 1.344 +3.367 1.835 1.355 +3.469 1.863 1.365 +3.571 1.890 1.375 +3.673 1.917 1.384 +3.776 1.943 1.394 +3.878 1.969 1.403 +3.980 1.995 1.412 +4.082 2.020 1.421 +4.184 2.045 1.430 +4.286 2.070 1.439 +4.388 2.095 1.447 +4.490 2.119 1.456 +4.592 2.143 1.464 +4.694 2.167 1.472 +4.796 2.190 1.480 +4.898 2.213 1.488 +5.000 2.236 1.495 \ No newline at end of file diff --git a/source/test.csv b/source/test.csv new file mode 100644 index 0000000..1347fbd --- /dev/null +++ b/source/test.csv @@ -0,0 +1,51 @@ +,0,1,2 +0,0.0,0.0,0.0 +1,0.10204081632653061,0.31943828249996997,0.5651887140592688 +2,0.20408163265306123,0.45175395145262565,0.672126440078521 +3,0.30612244897959184,0.5532833351724882,0.7438301789874407 +4,0.40816326530612246,0.6388765649999399,0.7992975447228272 +5,0.5102040816326531,0.7142857142857143,0.8451542547285166 +6,0.6122448979591837,0.7824607964359516,0.884568141205612 +7,0.7142857142857143,0.8451542547285166,0.9193227152249185 +8,0.8163265306122449,0.9035079029052513,0.9505303271885918 +9,0.9183673469387755,0.9583148474999099,0.9789355686151718 +10,1.0204081632653061,1.0101525445522108,1.005063452997974 +11,1.1224489795918369,1.0594569267279519,1.029299240613706 +12,1.2244897959183674,1.1065666703449764,1.0519347272264454 +13,1.3265306122448979,1.1517511068997928,1.0731966767092567 +14,1.4285714285714286,1.1952286093343936,1.0932651139290934 +15,1.5306122448979593,1.2371791482634837,1.1122855515844319 +16,1.6326530612244898,1.2777531299998799,1.1303774281185377 +17,1.7346938775510203,1.3170777796132696,1.147640091497883 +18,1.836734693877551,1.355261854357877,1.1641571433263969 +19,1.9387755102040818,1.3923991921155663,1.1799996576760379 +20,2.0408163265306123,1.4285714285714286,1.1952286093343936 +21,2.142857142857143,1.4638501094227998,1.2098967350244398 +22,2.2448979591836737,1.498298354528788,1.224049980404717 +23,2.3469387755102042,1.5319721849662298,1.237728639470797 +24,2.4489795918367347,1.5649215928719031,1.2509682621361355 +25,2.5510204081632653,1.5971914124998499,1.2638003847522161 +26,2.6530612244897958,1.6288220358559113,1.276253123739923 +27,2.7551020408163267,1.6598500055174645,1.2883516622092992 +28,2.857142857142857,1.6903085094570331,1.3001186520687384 +29,2.9591836734693877,1.720227796970328,1.3115745487658443 +30,3.0612244897959187,1.749635530559413,1.3227378918589325 +31,3.163265306122449,1.778557085426962,1.3336255416821328 +32,3.2653061224489797,1.8070158058105026,1.344252880157042 +33,3.36734693877551,1.83503322552359,1.3546339821234332 +34,3.4693877551020407,1.8626292586293283,1.3647817622716565 +35,3.5714285714285716,1.889822365046136,1.3747081017605651 +36,3.673469387755102,1.9166296949998198,1.3844239578249937 +37,3.7755102040816326,1.9430672155336348,1.3939394590632819 +38,3.8775510204081636,1.9691498217271746,1.4032639886091194 +39,3.979591836734694,1.9948914348241344,1.41240625700403 +40,4.081632653061225,2.0203050891044216,1.4213743662752687 +41,4.183673469387755,2.045403009039479,1.4301758664721897 +42,4.285714285714286,2.0701966780270626,1.438817805709626 +43,4.387755102040816,2.0946968998021687,1.4473067745996937 +44,4.4897959183673475,2.1189138534559038,1.4556489458162307 +45,4.591836734693878,2.142857142857143,1.4638501094227998 +46,4.6938775510204085,2.166535841157586,1.4719157045013094 +47,4.795918367346939,2.1899585309651273,1.4798508475400916 +48,4.8979591836734695,2.2131333406899527,1.4876603579748815 +49,5.0,2.23606797749979,1.4953487812212205