From 84e88fd6e6208e8d6048c14610bfdffbea272243 Mon Sep 17 00:00:00 2001 From: Basso Ricci Jacopo Date: Sun, 5 Apr 2026 22:04:06 +0200 Subject: [PATCH] analisi ben fatta del caso dinamico --- molla/dinamica/mollaDinamica.ipynb | 1620 ++++++++++++++++ molla/dinamica/mollaDinamica1.ipynb | 2735 ++++++++++++++++++++------ molla/dinamica/mollaDinamica2.ipynb | 2763 +++++++++++++++++++++------ molla/dinamica/ripara.py | 2 - molla/statica/mollaStatica1.ipynb | 59 +- molla/statica/mollaStatica2.ipynb | 63 +- 6 files changed, 6001 insertions(+), 1241 deletions(-) create mode 100644 molla/dinamica/mollaDinamica.ipynb diff --git a/molla/dinamica/mollaDinamica.ipynb b/molla/dinamica/mollaDinamica.ipynb new file mode 100644 index 0000000..be39360 --- /dev/null +++ b/molla/dinamica/mollaDinamica.ipynb @@ -0,0 +1,1620 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 26, + "id": "f34c5b88", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import scipy as sc\n", + "from scipy.stats import chi2\n", + "from scipy.odr import ODR, Model, RealData\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib as mpl\n", + "import statsmodels.api as sm\n", + "\n", + "\n", + "g = 9.806\n", + "ug = 0.001\n", + "\n", + "m_mol = 15.43\n", + "um_mol = 0.01" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "08efb2be", + "metadata": {}, + "outputs": [], + "source": [ + "df = pd.read_csv(r'dinamica2.csv')\n", + "\n", + "def calcola_stats(df, prefix, err_arbitrario):\n", + " cols = [col for col in df.columns if col.startswith(prefix)]\n", + "\n", + " def riga_stats(row):\n", + " valori = row[cols].dropna()\n", + " n = len(valori)\n", + "\n", + " if n == 0:\n", + " return pd.Series({prefix: np.nan, f\"u{prefix}\": np.nan})\n", + " elif n == 1:\n", + " return pd.Series({prefix: valori.iloc[0], f\"u{prefix}\": err_arbitrario})\n", + " else:\n", + " media = valori.mean()\n", + " sigma = valori.std(ddof=1)\n", + " sigma = sigma * np.sqrt(24) if prefix == \"w\" else sigma # Line cursed per non duplicare il codice\n", + " return pd.Series({prefix: media, f\"u{prefix}\": sigma})\n", + "\n", + " stats = df.apply(riga_stats, axis=1)\n", + " df[prefix] = stats[prefix]\n", + " df[f\"u{prefix}\"] = stats[f\"u{prefix}\"]\n", + "\n", + " return df\n", + "\n", + "\n", + "df = calcola_stats(df, \"w\", err_arbitrario=0.0002)\n", + "df = calcola_stats(df, \"m\", err_arbitrario=0.01)\n", + "df = calcola_stats(df, \"c\", err_arbitrario=0.01)\n", + "df = calcola_stats(df, \"a\", err_arbitrario=0.01)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "5494409f", + "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", + "
m1a1ua1w1uw1c1uc1t1a2ua2w2uw2c2uc2t2a3ua3w3uw3c3uc3t3a4ua4w4uw4c4uc4t4wuwmumcucaua
049.259.71710.0167.656500.00040484.45500.01115.628.91100.0157.656900.00040484.5160.01115.5810.4460.0277.660300.00050485.0820.01915.768.3770.0167.658200.00040484.7520.01115.877.6579750.00838549.250.01484.701250.2843149.3627750.908254
169.289.86000.0166.559680.00029423.35200.01118.3110.39000.0126.558910.00022423.1540.00918.2710.4910.0136.560020.00024423.6970.01018.3410.9680.0196.560000.00030423.4650.01418.166.5596520.00254269.280.01423.417000.22664110.4272500.454472
288.9711.58400.0145.844170.00020363.22900.01020.2710.17630.0175.845850.00028363.3540.01220.4412.0440.0185.845000.00026363.1830.01320.5411.2240.0165.845130.00025363.2330.01120.495.8450380.00337488.970.01363.249750.07310911.2570750.794837
3108.6111.54200.0265.327800.00030303.55020.01922.498.42400.0175.328200.00030303.5810.01222.2710.5010.0225.329600.00030303.8420.01622.559.9590.0145.328220.00020303.4450.01022.155.3284550.003858108.610.01303.604550.16866910.1065001.299853
4128.6411.57400.0204.926630.00023242.96200.01424.3311.59200.0234.925370.00029242.8760.01724.3810.2640.0234.924300.00030242.7890.01725.099.1180.0214.926100.00030243.1150.01524.264.9256000.004943128.640.01242.935500.13895410.6370001.188344
\n", + "
" + ], + "text/plain": [ + " m1 a1 ua1 w1 uw1 c1 uc1 t1 a2 \\\n", + "0 49.25 9.7171 0.016 7.65650 0.00040 484.4550 0.011 15.62 8.9110 \n", + "1 69.28 9.8600 0.016 6.55968 0.00029 423.3520 0.011 18.31 10.3900 \n", + "2 88.97 11.5840 0.014 5.84417 0.00020 363.2290 0.010 20.27 10.1763 \n", + "3 108.61 11.5420 0.026 5.32780 0.00030 303.5502 0.019 22.49 8.4240 \n", + "4 128.64 11.5740 0.020 4.92663 0.00023 242.9620 0.014 24.33 11.5920 \n", + "\n", + " ua2 w2 uw2 c2 uc2 t2 a3 ua3 w3 \\\n", + "0 0.015 7.65690 0.00040 484.516 0.011 15.58 10.446 0.027 7.66030 \n", + "1 0.012 6.55891 0.00022 423.154 0.009 18.27 10.491 0.013 6.56002 \n", + "2 0.017 5.84585 0.00028 363.354 0.012 20.44 12.044 0.018 5.84500 \n", + "3 0.017 5.32820 0.00030 303.581 0.012 22.27 10.501 0.022 5.32960 \n", + "4 0.023 4.92537 0.00029 242.876 0.017 24.38 10.264 0.023 4.92430 \n", + "\n", + " uw3 c3 uc3 t3 a4 ua4 w4 uw4 c4 \\\n", + "0 0.00050 485.082 0.019 15.76 8.377 0.016 7.65820 0.00040 484.752 \n", + "1 0.00024 423.697 0.010 18.34 10.968 0.019 6.56000 0.00030 423.465 \n", + "2 0.00026 363.183 0.013 20.54 11.224 0.016 5.84513 0.00025 363.233 \n", + "3 0.00030 303.842 0.016 22.55 9.959 0.014 5.32822 0.00020 303.445 \n", + "4 0.00030 242.789 0.017 25.09 9.118 0.021 4.92610 0.00030 243.115 \n", + "\n", + " uc4 t4 w uw m um c uc \\\n", + "0 0.011 15.87 7.657975 0.008385 49.25 0.01 484.70125 0.284314 \n", + "1 0.014 18.16 6.559652 0.002542 69.28 0.01 423.41700 0.226641 \n", + "2 0.011 20.49 5.845038 0.003374 88.97 0.01 363.24975 0.073109 \n", + "3 0.010 22.15 5.328455 0.003858 108.61 0.01 303.60455 0.168669 \n", + "4 0.015 24.26 4.925600 0.004943 128.64 0.01 242.93550 0.138954 \n", + "\n", + " a ua \n", + "0 9.362775 0.908254 \n", + "1 10.427250 0.454472 \n", + "2 11.257075 0.794837 \n", + "3 10.106500 1.299853 \n", + "4 10.637000 1.188344 " + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.set_option('display.max_columns', None)\n", + "pd.set_option('display.width', None)\n", + "\n", + "df" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "976d5531", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[(0, 1), (0, 2), (0, 3), (0, 4), (1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]\n", + "10\n", + "############################################################\n", + "[ 61.28425 121.4515 181.0967 241.76575 60.16725 119.81245 180.4815\n", + " 59.6452 120.31425 60.66905]\n", + "[0.36359352 0.29356288 0.33058029 0.31645313 0.23814054 0.28251562\n", + " 0.26584645 0.18383143 0.15701353 0.21853469]\n", + "############################################################\n", + "[-20.03 -39.72 -59.36 -79.39 -19.69 -39.33 -59.36 -19.64 -39.67 -20.03]\n", + "[0.01414214 0.01414214 0.01414214 0.01414214 0.01414214 0.01414214\n", + " 0.01414214 0.01414214 0.01414214 0.01414214]\n" + ] + } + ], + "source": [ + "perm = [(x,i) for x in range(0,len(df)) for i in range(x+1,len(df))]\n", + "\n", + "este = np.array([df.c[x] - df.c[j] for x,j in perm])\n", + "ueste = np.array([np.sqrt(df.uc[x]**2 + df.uc[j]**2) for x,j in perm])\n", + "\n", + "masse = np.array([df.m[x] - df.m[j] for x,j in perm])\n", + "umasse = np.array([np.sqrt(df.um[x]**2 + df.um[j]**2) for x,j in perm])\n", + "\n", + "\n", + "print(perm)\n", + "print(len(perm))\n", + "\n", + "print(\"#\"* 60)\n", + "print(este)\n", + "print(ueste)\n", + "\n", + "print(\"#\"* 60)\n", + "print(masse)\n", + "print(umasse)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "2ad19283", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[3.20496996 3.20699473 3.21421738 3.22005222 3.20905709 3.21894745\n", + " 3.22517355 3.22892437 3.23323314 3.23746919]\n", + "[0.01915174 0.00784216 0.00592618 0.00426631 0.01291295 0.00768498\n", + " 0.00482359 0.01022511 0.00438647 0.01188811]\n" + ] + } + ], + "source": [ + "F = masse * g\n", + "uF = np.sqrt((g * umasse)**2 + (masse * ug)**2)\n", + "\n", + "K = - F / este\n", + "uK = np.sqrt((1/este)**2 * uF**2 + (F / este**2)**2 * ueste**2 )\n", + "\n", + "\n", + "print(K)\n", + "print(uK)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "5f59d6c9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "K-medio: 3.222622761146456\n", + "sigmaC: 0.002054455999024885\n" + ] + } + ], + "source": [ + "def mediaPesata(x, ux, dim = 0):\n", + " x_arr = x.to_numpy() if isinstance(x, (pd.Series, pd.DataFrame)) else np.asarray(x)\n", + " sigma_arr = ux.to_numpy() if isinstance(ux, (pd.Series, pd.DataFrame)) else np.asarray(ux)\n", + "\n", + " w = 1.0 / (sigma_arr ** 2)\n", + "\n", + " num = np.nansum(w * x_arr, axis=dim)\n", + " den = np.nansum(w, axis=dim)\n", + "\n", + " media = num / den\n", + " sigma = np.sqrt(1.0 / den)\n", + "\n", + " return media, sigma\n", + "\n", + "media, uA = mediaPesata(K, uK)\n", + "print(\"K-medio:\", media)\n", + "print(\"sigmaC: \", uA)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "aefe7756", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " OLS Regression Results \n", + "==============================================================================\n", + "Dep. Variable: F R-squared: 1.000\n", + "Model: OLS Adj. R-squared: 1.000\n", + "Method: Least Squares F-statistic: 3.114e+05\n", + "Date: Fri, 03 Apr 2026 Prob (F-statistic): 1.19e-19\n", + "Time: 11:31:18 Log-Likelihood: -14.035\n", + "No. Observations: 10 AIC: 32.07\n", + "Df Residuals: 8 BIC: 32.68\n", + "Df Model: 1 \n", + "Covariance Type: nonrobust \n", + "==============================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "const 0.0101 0.778 0.013 0.990 -1.785 1.805\n", + "este 3.2197 0.006 558.014 0.000 3.206 3.233\n", + "==============================================================================\n", + "Omnibus: 0.921 Durbin-Watson: 0.565\n", + "Prob(Omnibus): 0.631 Jarque-Bera (JB): 0.614\n", + "Skew: 0.062 Prob(JB): 0.736\n", + "Kurtosis: 1.792 Cond. No. 302.\n", + "==============================================================================\n", + "\n", + "Notes:\n", + "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", + "\n", + "RISULTATI REGRESSIONE:\n", + "k (pendenza) = 3.21975 ± 0.00577\n", + "intercetta = 0.01011 ± 0.77845\n", + "R² = 0.99997\n" + ] + } + ], + "source": [ + "data = pd.DataFrame({\n", + " \"este\": este,\n", + " \"ueste\": ueste,\n", + " \"F\": - F,\n", + " \"uF\": uF\n", + "})\n", + "\n", + "\n", + "X = sm.add_constant(data[\"este\"])\n", + "model = sm.OLS(data[\"F\"], X).fit()\n", + "\n", + "print(model.summary())\n", + "\n", + "# Estrazione parametri\n", + "intercetta = model.params[\"const\"]\n", + "pente = model.params[\"este\"]\n", + "u_intercetta = model.bse[\"const\"]\n", + "u_pente = model.bse[\"este\"]\n", + "R2 = model.rsquared\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE:\")\n", + "print(f\"k (pendenza) = {pente:.5f} ± {u_pente:.5f}\")\n", + "print(f\"intercetta = {intercetta:.5f} ± {u_intercetta:.5f}\")\n", + "print(f\"R² = {R2:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "8d795186", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chi^2 = 18.49884\n", + "Gradi di libertà = 8\n", + "Chi^2 ridotto = 2.31235\n", + "Probabilità P(0 → chi^2) = 0.98222\n" + ] + } + ], + "source": [ + "## X^2 sui dai fatti così\n", + "F_fit = intercetta + pente * data[\"este\"]\n", + "sigma = np.sqrt(data[\"uF\"]**2 + (pente * data[\"ueste\"])**2)\n", + "\n", + "\n", + "chi2_val = np.sum( ((data[\"F\"] - F_fit) / sigma)**2 )\n", + "\n", + "N = len(data)\n", + "nu = N - 2\n", + "\n", + "chi2_red = chi2_val / nu\n", + "P = chi2.cdf(chi2_val, df=nu)\n", + "\n", + "\n", + "print(f\"Chi^2 = {chi2_val:.5f}\")\n", + "print(f\"Gradi di libertà = {nu}\")\n", + "print(f\"Chi^2 ridotto = {chi2_red:.5f}\")\n", + "print(f\"Probabilità P(0 → chi^2) = {P:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "1d42b009", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "sns.set_theme(style=\"whitegrid\")\n", + "\n", + "plt.figure(figsize=(10,6))\n", + "\n", + "# Seaborn scatter\n", + "sns.scatterplot(\n", + " data=data,\n", + " x=\"este\",\n", + " y=\"F\",\n", + " s=7\n", + ")\n", + "\n", + "# Barre d’errore\n", + "plt.errorbar(\n", + " data[\"este\"],\n", + " data[\"F\"],\n", + " xerr=data[\"ueste\"],\n", + " yerr=data[\"uF\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", + ")\n", + "\n", + "# Linea di regressione\n", + "xfit = np.linspace(0, data[\"este\"].max(), 200)\n", + "yfit = intercetta + pente * xfit\n", + "\n", + "\n", + "plt.plot(\n", + " xfit,\n", + " yfit,\n", + " color=\"crimson\",\n", + " linewidth=1,\n", + " zorder=10,\n", + " label=\"Fit lineare\"\n", + ")\n", + "\n", + "\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "\n", + "\n", + "plt.xlabel(\"Δx (mm)\")\n", + "plt.ylabel(\"Forza F (mN)\")\n", + "plt.title(\"Legge di Hooke — punti permutati con errorbar\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "986ff4a6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chi^2 = 18.49884\n", + "Gradi di libertà = 8\n", + "Chi^2 ridotto = 2.31235\n", + "Probabilità P(0 → chi^2) = 0.98222\n" + ] + } + ], + "source": [ + "F_fit = intercetta + pente * data[\"este\"]\n", + "sigma = np.sqrt(data[\"uF\"]**2 + (pente * data[\"ueste\"])**2)\n", + "\n", + "chi2_val = np.sum( ((data[\"F\"] - F_fit) / sigma)**2 )\n", + "\n", + "N = len(data)\n", + "nu = N - 2\n", + "\n", + "chi2_red = chi2_val / nu\n", + "P = chi2.cdf(chi2_val, df=nu)\n", + "\n", + "\n", + "print(f\"Chi^2 = {chi2_val:.5f}\")\n", + "print(f\"Gradi di libertà = {nu}\")\n", + "print(f\"Chi^2 ridotto = {chi2_red:.5f}\")\n", + "print(f\"Probabilità P(0 → chi^2) = {P:.5f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "ef0817f4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 0.603364\n", + "1 2.659042\n", + "2 0.885979\n", + "3 0.003753\n", + "4 0.702764\n", + "5 0.013285\n", + "6 1.242733\n", + "7 0.779930\n", + "8 9.404606\n", + "9 2.203380\n", + "dtype: float64" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "((data[\"F\"] - F_fit) / sigma)**2" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "cebe6742", + "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", + "
esteuesteFuF
061.284250.363594196.414180.140117
1121.451500.293563389.494320.144254
2181.096700.330580582.084160.150848
3241.765750.316453778.498340.159795
460.167250.238141193.080140.140069
5119.812450.282516385.669980.144147
6180.481500.265846582.084160.150848
759.645200.183831192.589840.140062
8120.314250.157014389.004020.144240
960.669050.218535196.414180.140117
\n", + "
" + ], + "text/plain": [ + " este ueste F uF\n", + "0 61.28425 0.363594 196.41418 0.140117\n", + "1 121.45150 0.293563 389.49432 0.144254\n", + "2 181.09670 0.330580 582.08416 0.150848\n", + "3 241.76575 0.316453 778.49834 0.159795\n", + "4 60.16725 0.238141 193.08014 0.140069\n", + "5 119.81245 0.282516 385.66998 0.144147\n", + "6 180.48150 0.265846 582.08416 0.150848\n", + "7 59.64520 0.183831 192.58984 0.140062\n", + "8 120.31425 0.157014 389.00402 0.144240\n", + "9 60.66905 0.218535 196.41418 0.140117" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "2d4b7144", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ax + B : \n", + "A = 3.21951 +- 0.00470\n", + "B = 0.42600 +- 0.57172\n", + "cov_AB = -0.002417\n", + "p-value chi² = 0.9584088\n" + ] + } + ], + "source": [ + "def sigma_y_equiv(x, y, sigma_x, sigma_y):\n", + " # Stima iniziale di A con sola sigma_y\n", + " sy2 = sigma_y**2\n", + " Sw = np.sum(1 / sy2)\n", + " Sx = np.sum(x / sy2)\n", + " Sxx = np.sum(x**2 / sy2)\n", + " Sy = np.sum(y / sy2)\n", + " Sxy = np.sum(x * y / sy2)\n", + " delta = Sxx * Sw - Sx**2\n", + " A_est = (Sxy * Sw - Sx * Sy) / delta\n", + "\n", + " # Propagazione\n", + " sigma_eq = np.sqrt(sigma_y**2 + A_est**2 * sigma_x**2)\n", + " return sigma_eq\n", + "\n", + "\n", + "def reg_lin(x, y, sigma_x, sigma_y):\n", + " x = np.asarray(x, dtype=float)\n", + " y = np.asarray(y, dtype=float)\n", + " sigma_x = np.asarray(sigma_x, dtype=float)\n", + " sigma_y = np.asarray(sigma_y, dtype=float)\n", + "\n", + " # Propagazione errore x → y\n", + " sigma_y_eq = sigma_y_equiv(x, y, sigma_x, sigma_y)\n", + "\n", + " # Somme pesate\n", + " w = 1.0 / sigma_y_eq**2\n", + " Sw = np.sum(w)\n", + " Sx = np.sum(w * x)\n", + " Sxx = np.sum(w * x**2)\n", + " Sy = np.sum(w * y)\n", + " Sxy = np.sum(w * x * y)\n", + " delta = Sxx * Sw - Sx**2\n", + "\n", + " # Parametri\n", + " A = (Sxy * Sw - Sx * Sy) / delta\n", + " B = (Sxx * Sy - Sxy * Sx) / delta\n", + " sigma_A = np.sqrt(Sw / delta)\n", + " sigma_B = np.sqrt(Sxx / delta)\n", + " cov_AB = -Sx / delta\n", + "\n", + " # Chi quadro\n", + " x2 = np.sum((y - A * x - B)**2 / sigma_y_eq**2)\n", + " dof = len(x) - 2\n", + " chi = sc.stats.chi2.cdf(x2, dof) # P(X² > x2)\n", + "\n", + " return A, B, sigma_A, sigma_B, cov_AB, chi\n", + "\n", + "\n", + "A, B, sA, sB, covAB, chi = reg_lin(data[\"este\"], data[\"F\"], data[\"ueste\"], data[\"uF\"])\n", + "print(\"Ax + B : \")\n", + "print(f\"A = {A:.5f} +- {sA:.5f}\")\n", + "print(f\"B = {B:.5f} +- {sB:.5f}\")\n", + "print(f\"cov_AB = {covAB:.6f}\")\n", + "print(f\"p-value chi² = {chi:.7f}\")\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "32e9948f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chi^2 = 16.05746\n", + "Gradi di libertà = 8\n", + "Chi^2 ridotto = 2.00718\n", + "Probabilità P(0 → chi^2) = 0.95843\n" + ] + } + ], + "source": [ + "F_fit = B + A * data[\"este\"]\n", + "sigma = np.sqrt(data[\"uF\"]**2 + (A * data[\"ueste\"])**2)\n", + "\n", + "\n", + "chi2_val = np.sum( ((data[\"F\"] - F_fit) / sigma)**2 )\n", + "\n", + "N = len(data)\n", + "nu = N - 2\n", + "\n", + "chi2_red = chi2_val / nu\n", + "P = chi2.cdf(chi2_val, df=nu)\n", + "\n", + "\n", + "print(f\"Chi^2 = {chi2_val:.5f}\")\n", + "print(f\"Gradi di libertà = {nu}\")\n", + "print(f\"Chi^2 ridotto = {chi2_red:.5f}\")\n", + "print(f\"Probabilità P(0 → chi^2) = {P:.5f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "e2407a04", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "sns.set_theme(style=\"whitegrid\")\n", + "\n", + "plt.figure(figsize=(10,6))\n", + "\n", + "# Seaborn scatter\n", + "sns.scatterplot(\n", + " data=data,\n", + " x=\"este\",\n", + " y=\"F\",\n", + " s=7\n", + ")\n", + "\n", + "# Barre d’errore\n", + "plt.errorbar(\n", + " data[\"este\"],\n", + " data[\"F\"],\n", + " xerr=data[\"ueste\"],\n", + " yerr=data[\"uF\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", + ")\n", + "\n", + "# Linea di regressione\n", + "xfit = np.linspace(0, data[\"este\"].max(), 200)\n", + "yfit = B + A * xfit\n", + "\n", + "\n", + "plt.plot(\n", + " xfit,\n", + " yfit,\n", + " color=\"crimson\",\n", + " linewidth=1,\n", + " zorder=10,\n", + " label=\"Fit lineare\"\n", + ")\n", + "\n", + "\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "\n", + "\n", + "plt.xlabel(\"Δx (mm)\")\n", + "plt.ylabel(\"Forza F (mN)\")\n", + "plt.title(\"Legge di Hooke — punti permutati con errorbar\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "95dde99f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 0.673181\n", + "1 0.917483\n", + "2 1.155540\n", + "3 1.390456\n", + "4 1.627202\n", + "Name: w, dtype: float64\n", + "0 0.001474\n", + "1 0.000711\n", + "2 0.001334\n", + "3 0.002013\n", + "4 0.003266\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "## Dinamica davvero\n", + "\n", + "Meq = df.m + ( m_mol / 3 )\n", + "uMeq = np.sqrt( df.um**2 + um_mol**2 / 9 )\n", + "\n", + "T2 = ( 2 * np.pi / df.w )**2\n", + "uT2 = np.sqrt( (8*np.pi**2 / df.w**3)**2 * df.uw**2 )\n", + "print(T2)\n", + "print(uT2)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "1bb433f0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " OLS Regression Results \n", + "==============================================================================\n", + "Dep. Variable: tmp2 R-squared: 1.000\n", + "Model: OLS Adj. R-squared: 1.000\n", + "Method: Least Squares F-statistic: 7.624e+04\n", + "Date: Fri, 03 Apr 2026 Prob (F-statistic): 1.05e-07\n", + "Time: 11:31:19 Log-Likelihood: 23.705\n", + "No. Observations: 5 AIC: -43.41\n", + "Df Residuals: 3 BIC: -44.19\n", + "Df Model: 1 \n", + "Covariance Type: nonrobust \n", + "==============================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "const 0.0219 0.004 5.124 0.014 0.008 0.035\n", + "masse 0.0120 4.35e-05 276.124 0.000 0.012 0.012\n", + "==============================================================================\n", + "Omnibus: nan Durbin-Watson: 1.430\n", + "Prob(Omnibus): nan Jarque-Bera (JB): 0.670\n", + "Skew: -0.251 Prob(JB): 0.716\n", + "Kurtosis: 1.279 Cond. No. 344.\n", + "==============================================================================\n", + "\n", + "Notes:\n", + "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", + "\n", + "RISULTATI REGRESSIONE:\n", + "B) = 0.0120187 ± 0.0000435\n", + "intercetta = 0.02190 ± 0.00427\n", + "R² = 0.99996\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jack/uni/lab/.venv/lib/python3.13/site-packages/statsmodels/stats/stattools.py:74: ValueWarning: omni_normtest is not valid with less than 8 observations; 5 samples were given.\n", + " warn(\"omni_normtest is not valid with less than 8 observations; %i \"\n" + ] + } + ], + "source": [ + "dfDin = pd.DataFrame({\n", + " \"masse\": Meq,\n", + " \"umasse\": uMeq,\n", + " \"tmp2\": T2,\n", + " \"utmp2\": uT2\n", + "})\n", + "\n", + "\n", + "X = sm.add_constant(dfDin[\"masse\"])\n", + "model = sm.OLS(dfDin[\"tmp2\"], X).fit()\n", + "\n", + "print(model.summary())\n", + "\n", + "# Estrazione parametri\n", + "intercetta = model.params[\"const\"]\n", + "pente = model.params[\"masse\"]\n", + "u_intercetta = model.bse[\"const\"]\n", + "u_pente = model.bse[\"masse\"]\n", + "R2 = model.rsquared\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE:\")\n", + "print(f\"B) = {pente:.7f} ± {u_pente:.7f}\")\n", + "print(f\"intercetta = {intercetta:.5f} ± {u_intercetta:.5f}\")\n", + "print(f\"R² = {R2:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "67d16b84", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "K : 3.284762657868823\n", + "uK : 3.786606732225535e-06\n" + ] + } + ], + "source": [ + "\n", + "K = (2*np.pi)**2 / pente / 1000\n", + "uK = np.sqrt( (4*np.pi / pente**2)**2 * u_pente**2 ) / 1e6\n", + "\n", + "print(\"K : \", K)\n", + "print(\"uK :\", uK)" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "a0ba5c8d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.set_theme(style=\"whitegrid\")\n", + "\n", + "plt.figure(figsize=(10,6))\n", + "\n", + "# Seaborn scatter\n", + "sns.scatterplot(\n", + " data=dfDin,\n", + " x=\"masse\",\n", + " y=\"tmp2\",\n", + " s=7\n", + ")\n", + "\n", + "# Barre d’errore\n", + "plt.errorbar(\n", + " dfDin[\"masse\"],\n", + " dfDin[\"tmp2\"],\n", + " xerr=dfDin[\"umasse\"],\n", + " yerr=dfDin[\"utmp2\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", + ")\n", + "\n", + "# Linea di regressione\n", + "xfit = np.linspace(0, dfDin[\"masse\"].max(), 200)\n", + "yfit = intercetta + pente * xfit\n", + "\n", + "\n", + "plt.plot(\n", + " xfit,\n", + " yfit,\n", + " color=\"crimson\",\n", + " linewidth=1,\n", + " zorder=10,\n", + " label=\"Fit lineare\"\n", + ")\n", + "\n", + "\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "\n", + "\n", + "plt.xlabel(\"Meq (g)\")\n", + "plt.ylabel(\"T^2 (s^2)\")\n", + "plt.title(\"Legge di Stocazzo — punti permutati con errorbar\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "859f2337", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ax + B : \n", + "A = 0.0120540 +- 0.0000313\n", + "B = 0.0198573 +- 0.0025536\n", + "cov_AB = -0.000000\n", + "p-value chi² = 0.9131\n" + ] + } + ], + "source": [ + "def sigma_y_equiv(x, y, sigma_x, sigma_y):\n", + " # Stima iniziale di A con sola sigma_y\n", + " sy2 = sigma_y**2\n", + " Sw = np.sum(1 / sy2)\n", + " Sx = np.sum(x / sy2)\n", + " Sxx = np.sum(x**2 / sy2)\n", + " Sy = np.sum(y / sy2)\n", + " Sxy = np.sum(x * y / sy2)\n", + " delta = Sxx * Sw - Sx**2\n", + " A_est = (Sxy * Sw - Sx * Sy) / delta\n", + "\n", + " # Propagazione\n", + " sigma_eq = np.sqrt(sigma_y**2 + A_est**2 * sigma_x**2)\n", + " return sigma_eq\n", + "\n", + "\n", + "def reg_lin(x, y, sigma_x, sigma_y):\n", + " x = np.asarray(x, dtype=float)\n", + " y = np.asarray(y, dtype=float)\n", + " sigma_x = np.asarray(sigma_x, dtype=float)\n", + " sigma_y = np.asarray(sigma_y, dtype=float)\n", + "\n", + " # Propagazione errore x → y\n", + " sigma_y_eq = sigma_y_equiv(x, y, sigma_x, sigma_y)\n", + "\n", + " # Somme pesate\n", + " w = 1.0 / sigma_y_eq**2\n", + " Sw = np.sum(w)\n", + " Sx = np.sum(w * x)\n", + " Sxx = np.sum(w * x**2)\n", + " Sy = np.sum(w * y)\n", + " Sxy = np.sum(w * x * y)\n", + " delta = Sxx * Sw - Sx**2\n", + "\n", + " # Parametri\n", + " A = (Sxy * Sw - Sx * Sy) / delta\n", + " B = (Sxx * Sy - Sxy * Sx) / delta\n", + " sigma_A = np.sqrt(Sw / delta)\n", + " sigma_B = np.sqrt(Sxx / delta)\n", + " cov_AB = -Sx / delta\n", + "\n", + " # Chi quadro\n", + " x2 = np.sum((y - A * x - B)**2 / sigma_y_eq**2)\n", + " dof = len(x) - 2\n", + " chi = sc.stats.chi2.cdf(x2, dof) # P(X² > x2)\n", + "\n", + " return A, B, sigma_A, sigma_B, cov_AB, chi\n", + "\n", + "\n", + "A, B, sA, sB, covAB, chi = reg_lin(dfDin[\"masse\"], dfDin[\"tmp2\"], dfDin[\"umasse\"], dfDin[\"utmp2\"])\n", + "print(\"Ax + B : \")\n", + "print(f\"A = {A:.7f} +- {sA:.7f}\")\n", + "print(f\"B = {B:.7f} +- {sB:.7f}\")\n", + "print(f\"cov_AB = {covAB:.6f}\")\n", + "print(f\"p-value chi² = {chi:.4f}\")\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "fef04a85", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "K nostro: 3.275133343668113\n", + "uK nostro: 0.0001776827257612153\n" + ] + } + ], + "source": [ + "K = (2*np.pi)**2 / A / 1000\n", + "uK = np.sqrt( (4*np.pi / A**2)**2 * uA**2 ) / 1e6\n", + "\n", + "print(\"K nostro: \", K)\n", + "print(\"uK nostro:\", uK)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "5b191469", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chi^2 = 6.57093\n", + "Gradi di libertà = 3\n", + "Chi^2 ridotto = 2.19031\n", + "Probabilità P(0 → chi^2) = 0.91309\n" + ] + } + ], + "source": [ + "F_fit = B + A * dfDin[\"masse\"]\n", + "sigma = np.sqrt(dfDin[\"utmp2\"]**2 + (A * dfDin[\"umasse\"])**2)\n", + "\n", + "\n", + "chi2_val = np.sum( ((dfDin[\"tmp2\"] - F_fit) / sigma)**2 )\n", + "\n", + "N = len(dfDin)\n", + "nu = N - 2\n", + "\n", + "chi2_red = chi2_val / nu\n", + "P = chi2.cdf(chi2_val, df=nu)\n", + "\n", + "\n", + "print(f\"Chi^2 = {chi2_val:.5f}\")\n", + "print(f\"Gradi di libertà = {nu}\")\n", + "print(f\"Chi^2 ridotto = {chi2_red:.5f}\")\n", + "print(f\"Probabilità P(0 → chi^2) = {P:.5f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "ee9d9744", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 2.486198\n", + "1 0.533770\n", + "2 0.859257\n", + "3 0.083522\n", + "4 2.608185\n", + "dtype: float64" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "((dfDin[\"tmp2\"] - F_fit) / sigma)**2\n" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "59281ecb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== REGRESSIONE T^2 vs Meq (ODR/York) ===\n", + "A = 0.0120540 ± 0.0000463\n", + "B = 0.0198570 ± 0.0037792\n", + "cov(A,B) = -7.804236195803344e-08\n", + "chi² = 6.57093\n", + "chi² ridotto = 2.19031\n", + "\n", + "=== COSTANTE ELASTICA DINAMICA DA ODR ===\n", + "k = 3.275132 ± 0.012588 N/m\n" + ] + } + ], + "source": [ + "\n", + "# --- DATI DELLA TUA ANALISI ---\n", + "x = Meq.to_numpy() # masse equivalenti\n", + "sx = uMeq.to_numpy() # errori masse equivalenti\n", + "y = T2.to_numpy() # T^2\n", + "sy = uT2.to_numpy() # errori di T^2\n", + "\n", + "# --- MODELLO LINEARE ---\n", + "def f(B, x):\n", + " return B[0] * x + B[1] # A*x + B\n", + "\n", + "# Pacchetto \"RealData\" con errori anche su x\n", + "dati = RealData(x, y, sx=sx, sy=sy)\n", + "\n", + "# Modello lineare\n", + "modello = Model(f)\n", + "\n", + "# Esecuzione ODR (metodo di York)\n", + "odr = ODR(dati, modello, beta0=[0.01, 0]) # stima iniziale: A≈0.01, B≈0\n", + "out = odr.run()\n", + "\n", + "A, B = out.beta\n", + "sA, sB = out.sd_beta\n", + "cov_AB = out.cov_beta[0, 1]\n", + "chi2 = out.sum_square\n", + "chi2_red = out.res_var\n", + "\n", + "print(\"=== REGRESSIONE T^2 vs Meq (ODR/York) ===\")\n", + "print(f\"A = {A:.7f} ± {sA:.7f}\")\n", + "print(f\"B = {B:.7f} ± {sB:.7f}\")\n", + "print(f\"cov(A,B) = {cov_AB}\")\n", + "print(f\"chi² = {chi2:.5f}\")\n", + "print(f\"chi² ridotto = {chi2_red:.5f}\")\n", + "\n", + "# --- COSTANTE ELASTICA ---\n", + "K = (2*np.pi)**2 / A / 1000 # k in N/m → convertito a N/mm?\n", + "uK = (2*np.pi)**2 / (A**2) * sA / 1000\n", + "\n", + "print(\"\\n=== COSTANTE ELASTICA DINAMICA DA ODR ===\")\n", + "print(f\"k = {K:.6f} ± {uK:.6f} N/m\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "a53e863f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== REGRESSIONE T^2 vs Meq (Metodo di Y0RK 2004) ===\n", + "A = 0.0120540 ± 0.0000313\n", + "B = 0.0198570 ± 0.0025536\n", + "cov(A,B) = -7.804416866416002e-08\n", + "chi² = 6.57093\n", + "chi² ridotto = 2.19031\n", + "\n", + "=== COSTANTE ELASTICA DINAMICA (York 2004) ===\n", + "k = 3.275132 ± 0.008506 N/m\n" + ] + } + ], + "source": [ + "# --- DATI ---\n", + "x = Meq.to_numpy().astype(float)\n", + "sx = uMeq.to_numpy().astype(float)\n", + "y = T2.to_numpy().astype(float)\n", + "sy = uT2.to_numpy().astype(float)\n", + "\n", + "# --- METODO DI YORK 2004 ---\n", + "def york_fit(x, y, sx, sy, max_iter=50, tol=1e-15):\n", + " # Pesi iniziali\n", + " wx = 1 / sx**2\n", + " wy = 1 / sy**2\n", + "\n", + " # Stima iniziale della pendenza (OLS y|x)\n", + " A = np.cov(x, y, aweights=wy)[0,1] / np.cov(x, x, aweights=wy)[0,1]\n", + "\n", + " for _ in range(max_iter):\n", + " A_old = A\n", + "\n", + " # 1) Pesi combinati (eq. 9)\n", + " Wi = (wx * wy) / (A**2 * wy + wx)\n", + "\n", + " # 2) x̄ e ȳ pesati (eq. 10)\n", + " X_bar = np.sum(Wi * x) / np.sum(Wi)\n", + " Y_bar = np.sum(Wi * y) / np.sum(Wi)\n", + "\n", + " # 3) Variabili centrate\n", + " Ui = x - X_bar\n", + " Vi = y - Y_bar\n", + "\n", + " # 4) β (eq. 11)\n", + " beta_i = Wi * (Ui / wy + A * Vi / wx)\n", + "\n", + " # 5) Aggiornamento pendenza (eq. 12)\n", + " A = np.sum(Wi * beta_i * Vi) / np.sum(Wi * beta_i * Ui)\n", + "\n", + " # Convergenza\n", + " if abs(A - A_old) < tol:\n", + " break\n", + "\n", + " # 6) Intercetta (eq. 13)\n", + " B = Y_bar - A * X_bar\n", + "\n", + " # --- ERRORI (eq. 14–16) ---\n", + " # S = Σ Wi (xi - x̄)²\n", + " S = np.sum(Wi * Ui**2)\n", + "\n", + " sA = np.sqrt(1 / S)\n", + " sB = np.sqrt(1 / np.sum(Wi) + X_bar**2 * sA**2)\n", + "\n", + " # cov(A,B)\n", + " cov_AB = -X_bar * sA**2\n", + "\n", + " # CHI QUADRATO (eq. 17)\n", + " chi2 = np.sum(Wi * (Vi - A * Ui)**2)\n", + " dof = len(x) - 2\n", + " chi2_red = chi2 / dof\n", + "\n", + " return A, B, sA, sB, cov_AB, chi2, chi2_red\n", + "\n", + "A, B, sA, sB, cov_AB, chi2, chi2_red = york_fit(x, y, sx, sy)\n", + "\n", + "print(\"=== REGRESSIONE T^2 vs Meq (Metodo di Y0RK 2004) ===\")\n", + "print(f\"A = {A:.7f} ± {sA:.7f}\")\n", + "print(f\"B = {B:.7f} ± {sB:.7f}\")\n", + "print(f\"cov(A,B) = {cov_AB}\")\n", + "print(f\"chi² = {chi2:.5f}\")\n", + "print(f\"chi² ridotto = {chi2_red:.5f}\")\n", + "K = (2*np.pi)**2 / A / 1000\n", + "uK = (2*np.pi)**2 / (A**2) * sA / 1000\n", + "\n", + "print(\"\\n=== COSTANTE ELASTICA DINAMICA (York 2004) ===\")\n", + "print(f\"k = {K:.6f} ± {uK:.6f} N/m\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "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.13.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/molla/dinamica/mollaDinamica1.ipynb b/molla/dinamica/mollaDinamica1.ipynb index 7738b75..0028e56 100644 --- a/molla/dinamica/mollaDinamica1.ipynb +++ b/molla/dinamica/mollaDinamica1.ipynb @@ -1,42 +1,66 @@ { "cells": [ + { + "cell_type": "markdown", + "id": "a80529e4", + "metadata": {}, + "source": [ + "# Analisi dei dati con il sonar\n", + "Minimo Indice:\n", + "- Analisi dei dati statici\n", + "- Analisi dei dati dinamici\n", + " - Sonar\n", + " - Cronometro" + ] + }, + { + "cell_type": "markdown", + "id": "32702b8f", + "metadata": {}, + "source": [ + "## Import delle librerie e set di variabili gloabali" + ] + }, { "cell_type": "code", - "execution_count": 305, + "execution_count": 2, "id": "f34c5b88", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_4545/438762488.py:5: DeprecationWarning: `scipy.odr` is deprecated as of version 1.17.0 and will be removed in SciPy 1.19.0. Please use `https://pypi.org/project/odrpack/` instead.\n", - " from scipy.odr import ODR, Model, RealData\n" - ] - } - ], + "outputs": [], "source": [ "import numpy as np\n", "import pandas as pd\n", "import scipy as sc\n", "from scipy.stats import chi2\n", - "from scipy.odr import ODR, Model, RealData\n", "import seaborn as sns\n", "import matplotlib.pyplot as plt\n", "import matplotlib as mpl\n", "import statsmodels.api as sm\n", "\n", "\n", - "g = 9.806\n", + "g = 9.807\n", "ug = 0.001\n", "\n", - "m_mol = 29.89\n", + "m_mol = 15.43\n", "um_mol = 0.01" ] }, + { + "cell_type": "markdown", + "id": "fd0b8b1d", + "metadata": {}, + "source": [ + "## Lettura dei dati e calcolo delle deviazioni standard campionarie\n", + "- Lettura del CSV\n", + "- Creazione del data frame\n", + "- Deviazioni standard\n", + "\n", + "ATTENZIONE: Linea cursed ~17" + ] + }, { "cell_type": "code", - "execution_count": 306, + "execution_count": 3, "id": "08efb2be", "metadata": {}, "outputs": [], @@ -56,8 +80,7 @@ " return pd.Series({prefix: valori.iloc[0], f\"u{prefix}\": err_arbitrario})\n", " else:\n", " media = valori.mean()\n", - " sigma = ( valori.max() - valori.min() ) / 2\n", - " sigma = max(sigma, err_arbitrario) if prefix == \"w\" else sigma # Line cursed per non duplicare il codice\n", + " sigma = valori.std(ddof=1)\n", " return pd.Series({prefix: media, f\"u{prefix}\": sigma})\n", "\n", " stats = df.apply(riga_stats, axis=1)\n", @@ -68,14 +91,15 @@ "\n", "\n", "df = calcola_stats(df, \"w\", err_arbitrario=0.0002)\n", - "df = calcola_stats(df, \"m\", err_arbitrario=0.01)\n", + "df = calcola_stats(df, \"m\", err_arbitrario=0.0028867513)\n", "df = calcola_stats(df, \"c\", err_arbitrario=0.01)\n", - "df = calcola_stats(df, \"a\", err_arbitrario=0.01)" + "df = calcola_stats(df, \"a\", err_arbitrario=0.01)\n", + "df = calcola_stats(df, \"t\", err_arbitrario=0.01)" ] }, { "cell_type": "code", - "execution_count": 307, + "execution_count": 4, "id": "5494409f", "metadata": {}, "outputs": [ @@ -121,6 +145,8 @@ " uc\n", " a\n", " ua\n", + " t\n", + " ut\n", " \n", " \n", " \n", @@ -140,13 +166,15 @@ " 268.326\n", " 0.026\n", " 14.24465\n", - " 0.00125\n", + " 0.001768\n", " 108.610000\n", - " 0.01\n", + " 0.002887\n", " 268.2385\n", - " 0.0875\n", + " 0.123744\n", " 9.9500\n", - " 0.7400\n", + " 1.046518\n", + " NaN\n", + " NaN\n", " \n", " \n", " 1\n", @@ -164,13 +192,15 @@ " 259.745\n", " 0.020\n", " 13.19260\n", - " 0.00130\n", + " 0.001838\n", " 128.636667\n", - " 0.01\n", + " 0.002887\n", " 259.6750\n", - " 0.0700\n", + " 0.098995\n", " 9.8905\n", - " 0.1465\n", + " 0.207182\n", + " NaN\n", + " NaN\n", " \n", " \n", " 2\n", @@ -188,13 +218,15 @@ " 251.542\n", " 0.023\n", " 12.34650\n", - " 0.00040\n", + " 0.000566\n", " 148.380000\n", - " 0.01\n", + " 0.002887\n", " 251.5335\n", - " 0.0085\n", + " 0.012021\n", " 10.6700\n", - " 0.7400\n", + " 1.046518\n", + " NaN\n", + " NaN\n", " \n", " \n", " 3\n", @@ -212,13 +244,15 @@ " 243.130\n", " 0.021\n", " 11.63445\n", - " 0.00020\n", + " 0.000071\n", " 168.530000\n", - " 0.01\n", + " 0.002887\n", " 243.1705\n", - " 0.0405\n", + " 0.057276\n", " 11.4200\n", - " 0.0800\n", + " 0.113137\n", + " NaN\n", + " NaN\n", " \n", " \n", "\n", @@ -231,20 +265,20 @@ "2 148.380000 9.930 0.030 12.3469 0.0007 251.525 0.021 11.410 0.030 \n", "3 168.530000 11.340 0.030 11.6345 0.0005 243.211 0.021 11.500 0.030 \n", "\n", - " w2 uw2 c2 uc2 w uw m um \\\n", - "0 14.2434 0.0009 268.326 0.026 14.24465 0.00125 108.610000 0.01 \n", - "1 13.1913 0.0009 259.745 0.020 13.19260 0.00130 128.636667 0.01 \n", - "2 12.3461 0.0006 251.542 0.023 12.34650 0.00040 148.380000 0.01 \n", - "3 11.6344 0.0006 243.130 0.021 11.63445 0.00020 168.530000 0.01 \n", + " w2 uw2 c2 uc2 w uw m um \\\n", + "0 14.2434 0.0009 268.326 0.026 14.24465 0.001768 108.610000 0.002887 \n", + "1 13.1913 0.0009 259.745 0.020 13.19260 0.001838 128.636667 0.002887 \n", + "2 12.3461 0.0006 251.542 0.023 12.34650 0.000566 148.380000 0.002887 \n", + "3 11.6344 0.0006 243.130 0.021 11.63445 0.000071 168.530000 0.002887 \n", "\n", - " c uc a ua \n", - "0 268.2385 0.0875 9.9500 0.7400 \n", - "1 259.6750 0.0700 9.8905 0.1465 \n", - "2 251.5335 0.0085 10.6700 0.7400 \n", - "3 243.1705 0.0405 11.4200 0.0800 " + " c uc a ua t ut \n", + "0 268.2385 0.123744 9.9500 1.046518 NaN NaN \n", + "1 259.6750 0.098995 9.8905 0.207182 NaN NaN \n", + "2 251.5335 0.012021 10.6700 1.046518 NaN NaN \n", + "3 243.1705 0.057276 11.4200 0.113137 NaN NaN " ] }, - "execution_count": 307, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -256,9 +290,25 @@ "df" ] }, + { + "cell_type": "markdown", + "id": "9b8d8cb4", + "metadata": {}, + "source": [ + "# Analisi statica" + ] + }, + { + "cell_type": "markdown", + "id": "fd1b1164", + "metadata": {}, + "source": [ + "## Permutazioni" + ] + }, { "cell_type": "code", - "execution_count": 308, + "execution_count": 5, "id": "976d5531", "metadata": {}, "outputs": [ @@ -270,11 +320,11 @@ "6\n", "############################################################\n", "[ 8.5635 16.705 25.068 8.1415 16.5045 8.363 ]\n", - "[0.11205467 0.08791189 0.09641836 0.07051418 0.08087181 0.04138236]\n", + "[0.15846924 0.12432618 0.13635615 0.09972211 0.11437001 0.0585235 ]\n", "############################################################\n", "[-20.02666667 -39.77 -59.92 -19.74333333 -39.89333333\n", " -20.15 ]\n", - "[0.01414214 0.01414214 0.01414214 0.01414214 0.01414214 0.01414214]\n" + "[0.00408248 0.00408248 0.00408248 0.00408248 0.00408248 0.00408248]\n" ] } ], @@ -300,9 +350,19 @@ "print(umasse)" ] }, + { + "cell_type": "markdown", + "id": "d37fbd7c", + "metadata": {}, + "source": [ + "## Calcolo dei K e media pesata\n", + "- Calcolo del K\n", + "- Calcolo della media pesata (sui K)" + ] + }, { "cell_type": "code", - "execution_count": 309, + "execution_count": 6, "id": "2ad19283", "metadata": {}, "outputs": [ @@ -310,8 +370,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "[22.93238668 23.34538282 23.439266 23.77978587 23.70226463 23.6267966 ]\n", - "[0.30051945 0.12316079 0.090355 0.20667602 0.11646939 0.11810642]\n" + "[22.93472529 23.34776354 23.44165629 23.78221089 23.70468175 23.62920603]\n", + "[0.42444376 0.17379748 0.12754214 0.29135079 0.16430027 0.16544183]\n" ] } ], @@ -329,7 +389,7 @@ }, { "cell_type": "code", - "execution_count": 310, + "execution_count": 7, "id": "5f59d6c9", "metadata": {}, "outputs": [ @@ -337,8 +397,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "K-medio: 23.518009860547757\n", - "sigmaC: 0.052106970693817985\n" + "K-medio: 23.52082621035826\n", + "sigmaC: 0.07342397251895814\n" ] } ], @@ -362,9 +422,50 @@ "print(\"sigmaC: \", uA)" ] }, + { + "cell_type": "markdown", + "id": "21baebb4", + "metadata": {}, + "source": [ + "## Analisi con regressioni e grafici\n", + "Ogni blocco ha:\n", + "- Regressione\n", + "- grafico\n", + "- chi^2\n", + "\n", + "Nota: Ax + B" + ] + }, { "cell_type": "code", - "execution_count": 311, + "execution_count": 8, + "id": "5be377eb", + "metadata": {}, + "outputs": [], + "source": [ + "sns.set_theme(style=\"whitegrid\")\n", + "\n", + "data = pd.DataFrame({\n", + " \"x\": este,\n", + " \"ux\": ueste,\n", + " \"y\": - F,\n", + " \"uy\": uF\n", + "})" + ] + }, + { + "cell_type": "markdown", + "id": "6ec60a92", + "metadata": {}, + "source": [ + "### Regressione lineare \"OLS\"\n", + "\n", + "Non tiene conto dei nostri errori, un risultato puro e semplice" + ] + }, + { + "cell_type": "code", + "execution_count": 9, "id": "aefe7756", "metadata": {}, "outputs": [ @@ -374,11 +475,11 @@ "text": [ " OLS Regression Results \n", "==============================================================================\n", - "Dep. Variable: F R-squared: 1.000\n", + "Dep. Variable: y R-squared: 1.000\n", "Model: OLS Adj. R-squared: 1.000\n", "Method: Least Squares F-statistic: 1.044e+04\n", - "Date: Thu, 02 Apr 2026 Prob (F-statistic): 5.50e-08\n", - "Time: 19:05:38 Log-Likelihood: -14.806\n", + "Date: Sun, 05 Apr 2026 Prob (F-statistic): 5.50e-08\n", + "Time: 21:57:04 Log-Likelihood: -14.807\n", "No. Observations: 6 AIC: 33.61\n", "Df Residuals: 4 BIC: 33.20\n", "Df Model: 1 \n", @@ -386,8 +487,8 @@ "==============================================================================\n", " coef std err t P>|t| [0.025 0.975]\n", "------------------------------------------------------------------------------\n", - "const 0.1355 3.495 0.039 0.971 -9.568 9.839\n", - "este 23.4628 0.230 102.161 0.000 22.825 24.100\n", + "const 0.1355 3.495 0.039 0.971 -9.569 9.840\n", + "x 23.4652 0.230 102.161 0.000 22.827 24.103\n", "==============================================================================\n", "Omnibus: nan Durbin-Watson: 0.555\n", "Prob(Omnibus): nan Jarque-Bera (JB): 0.395\n", @@ -399,8 +500,8 @@ "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", "\n", "RISULTATI REGRESSIONE:\n", - "k (pendenza) = 23.46278 ± 0.22966\n", - "intercetta = 0.13546 ± 3.49489\n", + "Aols = 23.46517 ± 0.22969\n", + "Bols = 0.13548 ± 3.49525\n", "R² = 0.99962\n" ] }, @@ -414,79 +515,33 @@ } ], "source": [ - "data = pd.DataFrame({\n", - " \"este\": este,\n", - " \"ueste\": ueste,\n", - " \"F\": - F,\n", - " \"uF\": uF\n", - "})\n", - "\n", - "\n", - "X = sm.add_constant(data[\"este\"])\n", - "model = sm.OLS(data[\"F\"], X).fit()\n", + "X = sm.add_constant(data[\"x\"])\n", + "model = sm.OLS(data[\"y\"], X).fit()\n", "\n", "print(model.summary())\n", "\n", "# Estrazione parametri\n", - "intercetta = model.params[\"const\"]\n", - "pente = model.params[\"este\"]\n", - "u_intercetta = model.bse[\"const\"]\n", - "u_pente = model.bse[\"este\"]\n", + "Bols = model.params[\"const\"]\n", + "Aols = model.params[\"x\"]\n", + "uBols = model.bse[\"const\"]\n", + "uAols = model.bse[\"x\"]\n", "R2 = model.rsquared\n", "\n", "print(\"\\nRISULTATI REGRESSIONE:\")\n", - "print(f\"k (pendenza) = {pente:.5f} ± {u_pente:.5f}\")\n", - "print(f\"intercetta = {intercetta:.5f} ± {u_intercetta:.5f}\")\n", + "print(f\"Aols = {Aols:.5f} ± {uAols:.5f}\")\n", + "print(f\"Bols = {Bols:.5f} ± {uBols:.5f}\")\n", "print(f\"R² = {R2:.5f}\")" ] }, { "cell_type": "code", - "execution_count": 312, + "execution_count": 10, "id": "8d795186", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Chi^2 = 12.06747\n", - "Gradi di libertà = 4\n", - "Chi^2 ridotto = 3.01687\n", - "Probabilità P(0 → chi^2) = 0.98314\n" - ] - } - ], - "source": [ - "## X^2 sui dai fatti così\n", - "F_fit = intercetta + pente * data[\"este\"]\n", - "sigma = np.sqrt(data[\"uF\"]**2 + (pente * data[\"ueste\"])**2)\n", - "\n", - "\n", - "chi2_val = np.sum( ((data[\"F\"] - F_fit) / sigma)**2 )\n", - "\n", - "N = len(data)\n", - "nu = N - 2\n", - "\n", - "chi2_red = chi2_val / nu\n", - "P = chi2.cdf(chi2_val, df=nu)\n", - "\n", - "\n", - "print(f\"Chi^2 = {chi2_val:.5f}\")\n", - "print(f\"Gradi di libertà = {nu}\")\n", - "print(f\"Chi^2 ridotto = {chi2_red:.5f}\")\n", - "print(f\"Probabilità P(0 → chi^2) = {P:.5f}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 313, - "id": "1d42b009", - "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1wAAAIsCAYAAADmsKixAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAoohJREFUeJzs3Xd4FOX6PvB7drNppJEQQpdmApLQFOkoRZCiKCIoIhaKqKDowRNACFVBREIHCUV6laJIUyyIRg6iQigWSICAtPSebJnfH/ntfrMkhOzum8zu5P5cl9c52Zl988zsnSFP5p0ZSZZlGURERERERCScRukCiIiIiIiI1IoNFxERERERUTlhw0VERERERFRO2HARERERERGVEzZcRERERERE5YQNFxERERERUTlhw0VERERERFRO2HARERERERGVEzZcRERERERE5YQNFxHRPbz44ot48cUXLV9fvXoVYWFh2LVrl4JVlc2ECRPQqlUrpctQlbCwMCxevFjpMlSpW7dumDBhgtJlqMqLL76Ifv36KV0GUaXGhouIymzXrl0ICwtDXFyc0qW4hOPHjyMsLAwHDx4scTmbIef1ww8/sKkqQW5uLhYvXozjx4/bPcZvv/2GxYsXIyMjQ2BlRETOy03pAoiIXE3t2rVx+vRpuLnxEKpWP/zwAzZt2oSxY8cWW3b69GlotVoFqlJebm4ulixZgjFjxqBt27Z2jfH7779jyZIlePrpp+Hn52e17ODBg5AkSUSpREROg2e4iIhsJEkSPDw8Ku0v3ZWdh4eH0zTbOTk5SpcglLu7O3Q6ndJlVAhZlpGXl1fisvz8fJhMJofGr8hsGAwGFBQUVNj3I3I1bLiISLibN29i4sSJ6NChA8LDw9G3b1/s3Lmz2HrXrl3D6NGj0bJlS7Rv3x4ffvghfvzxR4SFhRWbsrRp0yZ0794dzZs3x8CBA/Hrr78Wu7YKAAoKCrBo0SI89thjCA8PxyOPPIK5c+eW+ZeBbdu2oUePHlbf507lfQ3Xpk2b0LdvX4SHh6NTp06YPn16idOvDhw4gAEDBqB58+Zo27Ytxo8fj5s3b95z/PPnz6Ndu3Z48cUXkZ2dDaDsn1lFMe/j1atX47PPPkPXrl3RvHlzDB06FH///bfVuiXlACicstmtW7cSxzR/zuHh4XjmmWdw+vRpq/dt2rQJQOH1Wub/zMpyDZd5Oun+/fsxf/58dOzYES1btsTo0aNx/fr1YuufOnUKw4cPx4MPPogWLVpg6NChOHnypNU6ixcvRlhYGC5cuID//Oc/aNOmDYYMGQKg8Nqn1157DcePH7dk4oknnrD8HB0+fBhPPPEEIiIiMGDAAJw7d87mfXj16lW0b98eALBkyRLLfjHviz///BMTJkxA9+7dERERgY4dO2LixIlITU212oa5c+cCALp3724Z4+rVq5btKMs1XCaTCevWrbNsU7t27TB8+HCr6c4GgwFLly61fM7dunXD/Pnzix0LzPvu119/xcCBAxEREYHu3btjz54996zDXMtnn32Gvn37IiIiAh06dEBUVBTS09NL/D4//vij5TPaunWrJStfffUVoqOj0blzZ7Ro0QJZWVkAyvZzbp6efOXKFYwcORKtWrXC+PHjrdY5c+YMnnvuOTRv3hzdunXDli1brJYXFBRg4cKFGDBgAB588EG0bNkSQ4YMwS+//GK13p0/mz169EBERAQuXrxYpv1FVBk5x5/oiEg1kpKSMGjQIEiShBdeeAGBgYE4evQo3n//fWRlZeHll18GUPjX15deegm3b9/GsGHDUK1aNezbt6/Ea0M2b96MGTNm4KGHHsLLL7+Ma9eu4c0334Sfnx9q1KhhWc9kMuH111/HyZMnMWjQIDRq1Ah///031q1bh0uXLmHZsmWl1r5jxw5ERUWhVatWeOmll5CYmIjXX38d/v7+qFmzpt37JDs7GykpKcVeL6kJXLx4MZYsWYIOHTrg+eefR0JCArZs2YK4uDhs2bLF8tf/Xbt2YeLEiYiIiMC7776L5ORkrF+/Hr/99hv27NlTbKqW2enTpzFixAiEh4dj2bJl8PT0LPNnpoQ9e/YgOzsbQ4YMQX5+PjZs2ICXXnoJX375JapVq2bXmPv27UN2djYGDx4MSZKwatUqjB07Ft988w10Oh0GDx6MW7du4aeffrI0B/Zavnw5JEnCyJEjkZycjHXr1uHll1/G3r174enpCQCIjY3FyJEjER4ejjFjxkCSJOzatQsvvfQSNm/ejObNm1uN+fbbb+O+++7DO++8A1mWLa9fvnwZ//nPf/Dcc8/hySefxJo1azB69GhMnz4d0dHReP755wEAK1euxLhx43Dw4EFoNGX/u2tgYCCmTZuGadOm4bHHHsNjjz0GAJZm9Oeff0ZiYiIGDBiA4OBg/PPPP9i+fTsuXLiA7du3Q5IkPPbYY7h06RL27duHiRMnomrVqpaxbfH+++9j165d6NKlCwYOHAij0Yhff/0Vp06dQkREBABg8uTJ2L17N3r16oVXXnkFp0+fxqeffoqLFy9i6dKlVuNdvnwZb7/9NgYOHIinn34an3/+OSZMmIBmzZrh/vvvL7WWqKgo7N69GwMGDMCLL76Iq1evYtOmTTh37pzVzywAJCQk4D//+Q8GDx6MQYMGoUGDBpZly5Ytg06nw/Dhw1FQUACdTmfTz7nBYLA07ZGRkZZ8AUB6ejpGjRqF3r17o2/fvjhw4ACmTZsGnU6HgQMHAgCysrKwY8cO9OvXD88++yyys7Oxc+dOjBgxAjt27EDTpk2ttnvXrl3Iz8/HoEGD4O7uDn9/f5s+Q6JKRSYiKqPPP/9cDg0NlU+fPn3XdSZNmiR37NhRTklJsXr9nXfekR988EE5NzdXlmVZXrNmjRwaGip//fXXlnXy8vLkxx9/XA4NDZV/+eUXWZZlOT8/X3744YflZ555Rtbr9ZZ1d+3aJYeGhspDhw61vLZnzx65SZMm8okTJ6y+95YtW+TQ0FD55MmTd627oKBAbt++vdy/f385Pz/f8vq2bduKfZ/ExEQ5NDRU/vzzz+86nizL8i+//CKHhoaW+l/Lli0t6ycnJ8vNmjWTX331VdloNFpe37hxoxwaGirv3LnTqtZ+/frJeXl5lvW+++47OTQ0VF64cKHltcjISMv3+PXXX+XWrVvLo0aNstrGsn5mFcm8j5s3by7fuHHD8vqpU6fk0NBQ+cMPP7S8NnToUKvPxywyMlLu2rVrsTEffvhhOS0tzfL6N998I4eGhsrffvut5bXp06fLoaGhJdYWGhoqL1q0qNT6zZ99586d5czMTMvr+/fvl0NDQ+V169bJsizLJpNJ7tmzp/zqq6/KJpPJsl5ubq7crVs3+ZVXXrG8tmjRIjk0NFR+9913i32/rl27yqGhofJvv/1mee3HH3+07MNr165ZXt+6davVz5gsl30fJicn33X7S8rJvn375NDQUKufyVWrVsmhoaFyYmJiidsRGRlZ7PWiYmNj5dDQUHnmzJnFlpn34fnz5+XQ0FD5/ffft1o+Z84cOTQ0VI6NjbX6nnfWmJycLIeHh8tz5swptZYTJ07IoaGh8hdffGH1+tGjR4u9bv4+R48etVrXnJXu3btb7UNbf85DQ0PlefPmFatx6NChcmhoqLxmzRrLa/n5+XL//v3l9u3bywUFBbIsy7LBYLA6LsiyLKenp8sdOnSQJ06caHnN/HPUunVrOTk5udT9Q0SFOKWQiISRZRmHDx9Gt27dIMsyUlJSLP916tQJmZmZOHv2LADgxx9/REhICLp37255v4eHBwYNGmQ15pkzZ5CWloZBgwZZXTfzxBNPFPuL6sGDB9GoUSM0bNjQ6nu3a9cOAEq9s9qZM2eQnJyM5557Du7u7pbXn376afj6+tq/UwC8+eabWLt2bbH/OnXqZLXezz//DL1ej2HDhlmdeXj22Wfh4+ODH374warW559/Hh4eHpb1Hn30UTRs2BDff/99sRp++eUXjBgxAu3bt8fixYst22jLZ6aEHj16ICQkxPJ18+bN0aJFC8u+sEefPn2ssvPQQw8BABITE+0v9C6eeuop+Pj4WL5+/PHHERwcbKn//PnzuHTpEp544gmkpqZa9n1OTg7at2+PEydOFLuW57nnnivxezVu3NjqrpctWrQAALRr1w61atUq9rro7S16RiU/Px8pKSmW7yUyQ4cPH4YkSRgzZkyxZeYbbpj37yuvvGK1/NVXX7Vabta4cWNLDoDCM24NGjS45z46ePAgfH190bFjR6ufnWbNmsHb27vYMadOnTro3LlziWM99dRTVvvQnp9z81nMO7m5uWHw4MGWr93d3TF48GAkJydbPhutVms5LphMJqSlpcFgMCA8PLzYFFQA6Nmzp81nJokqK04pJCJhUlJSkJGRgW3btmHbtm13XQcovH6rXr16xe5IVq9ePauv//333xJfd3NzQ+3ata1eu3z5Mi5evGi5zuROycnJd63d/H3uu+8+q9d1Oh3q1q171/eVRWhoKDp06FDs9S+++KLEGho2bGj1uru7O+rWrYtr165ZrVd0OpJZw4YNi137k5+fj9deew3NmjXDggULrBpXWz6zkqSlpUGv1991eWn8/f2tmtuS3Pl5AED9+vVx4MABu74ngGLTQ83NV3ncpvzO+iVJwn333Wf5LC9dugQAiIyMvOsYmZmZVg1inTp1Slzvzu0y/6Gg6LRbAJYGUPT2pqWlYcmSJdi/f3+xn7XMzExh3+fKlSuoXr06AgIC7rrOtWvXoNFoih03goOD4efnZ9n/ZiVNGfb39y92HdadLl++jMzMzDIfc+722ZW0zNafczc3t2KftVn16tXh7e1t9Vr9+vUBFO6rli1bAgB2796NNWvWICEhwernuqS6S9sWIrLGhouIhDH/Jf7JJ5/E008/XeI6RW8+UB7fPzQ0FBMnTixx+d1+GVE7d3d3dOnSBd9++y1+/PFHdO3a1bLM0c9s7Nix+N///mdXXevXr7f71uJlYTQaS3z9bneXlItcD1VRzN/zv//9b7FrZMzu/EW56NmOou62XY5s7932YUnGjRuH33//HcOHD0fTpk3h7e0Nk8mEESNGKLJvAZT5FvP23nHUZDIhKCgI8+bNK3H5nWeAip7BulNpy8rC3d3dpmvy7rR3715MmDABPXr0wPDhwxEUFAStVotPP/20xDN9jtZLVJmw4SIiYQIDA1GlShWYTKYSz+gUVbt2bVy4cAGyLFv9UnTlyhWr9cxToa5cuWKZGggUXiB+7do1q2agXr16+PPPP9G+fXubn+Vj/j6XL1+2+mu1Xq/H1atX0aRJE5vGs4e5hvj4eKuzagUFBbh69apln5rXS0hIKPaX9YSEBKvpY0DhL53z5s3DG2+8gbfffhsxMTGWRseWz6wkkZGRdp8pKcs+vXz5crHXLl26ZHV209/fv8RfCM1nCOwh6llQd9YvyzIuX75sya35c/bx8bFr/4tS1n14t/2Snp6O2NhYjB071mqqn/kMXlnGKKt69erh2LFjSEtLu+tZrtq1a8NkMuHy5cto1KiR5fWkpCRkZGQUOzvuSC2xsbFo3bq18AbE1p/z0ty6dQs5OTlWzbv5szHvi0OHDqFu3bpYsmSJ1We0aNEiezeBiP4/XsNFRMJotVr06tULhw4dKnbrbsB6alqnTp1w8+ZNHDlyxPJafn4+tm/fbvWe8PBwBAQEYPv27TAYDJbXv/zyy2LTfXr37o2bN28WGwMA8vLySn0uTXh4OAIDA7F161aruwfu3r27XKaalaRDhw7Q6XTYsGGD1RmBnTt3IjMzE4888oil1qCgoGK1/vDDD7h48SIeffTRYmO7u7tjyZIliIiIwOjRoy23QbflMytJeHg4OnToYNd/Zbmr2TfffGN1C+zTp0/j1KlT6NKli+W1unXrIj4+3qrWP//8E7/99ts9x78bLy8vAI5Pu9uzZ4/l9t5A4TU/t2/fttQfHh6OevXqYc2aNZZb9Bd1r/0vSln34d32y93OEK1bt67Ya+Yx7J1m2LNnT8iyjCVLlhRbZv65Mf+s3Pn9165da7XcUb1794bRaCzxDqgGg8Gh/Njzc343BoPBaspwQUEBtm3bhsDAQDRr1gzA/32GRY89p06dwh9//GH3NhBRIZ7hIiKbff755/jxxx+LvT5s2DD85z//wfHjxzFo0CA8++yzaNy4MdLT03H27FnExsZapp8NHjwYGzduxH/+8x8MGzYMwcHB+PLLLy3Tpcx/YXV3d8fYsWMxc+ZMvPTSS+jduzeuXbuGXbt2Fbs+o3///jhw4ACmTp2K48ePo3Xr1jAajYiPj8fBgwexatUqyy2j76TT6TBu3DhERUXhpZdeQp8+fXD16lXs2rXL4Wu4yiowMBCvvfYalixZghEjRqBbt25ISEjA5s2bERERgSeffNJS6/jx4zFx4kQMHToUffv2tdwuunbt2ne9jbunpyc+/fRTDBs2DCNHjsSGDRsQGhpa5s9MCfXq1cPzzz+P559/HgUFBVi/fj0CAgIwYsQIyzoDBw7EZ599huHDh2PgwIFITk7G1q1b0bhx4xKbmLIw/xI6a9YsdOrUCVqtFn379rV5HH9/fwwZMgQDBgyw3Bb+vvvus9wcRqPRYNasWRg5ciT69euHAQMGICQkBDdv3sTx48fh4+ODFStW2LUNtijrPvT09ETjxo1x4MAB1K9fHwEBAbj//vsRGhqKNm3aYNWqVdDr9QgJCcFPP/1keb5WUeZ9Gx0djT59+kCn06Fr167Fpk7eTbt27dC/f39s2LABly9fRufOnWEymXDy5Em0bdsWQ4cORZMmTfD0009j27ZtyMjIQJs2bRAXF4fdu3ejR48eVmfLHfHwww9j8ODB+PTTT3H+/Hl07NgROp0Oly5dwsGDB/H+++/j8ccft2tse3/OS1K9enXExMTg2rVrqF+/Pvbv34/z589j5syZltvWP/roozh8+DDefPNNPProo7h69aolA2p7wDZRRWPDRUQ2u/OBmWYDBgxAjRo1sGPHDixduhRff/01tmzZgoCAADRu3NjqQZxVqlTBunXrMGvWLKxfvx7e3t546qmn0KpVK4wdO9bqOpWhQ4dClmWsXbsWH330EZo0aYLly5dj1qxZVutpNBosXboUn332Gfbu3Yuvv/4aXl5eqFOnDl588cUSLz4vavDgwTAajVi9ejXmzp2L0NBQLF++HAsXLnRwj5Xd2LFjERgYiI0bN2L27Nnw9/fHoEGD8O6771o9z2fAgAHw9PRETEwM5s2bB29vb/To0QPvvffeXZ/BBRROXVu9ejWGDh2KV199FZs2bcJ9991Xps9MCU899RQ0Gg3WrVuH5ORkNG/eHFOmTEH16tUt6zRq1AgfffQRFi1ahNmzZ6Nx48aYO3cu9u3bZ3ez2LNnT7z44ov46quv8MUXX0CWZbsartGjR+Ovv/7CypUrkZ2djfbt22Pq1KmWszwA0LZtW2zbtg3Lli3Dxo0bkZOTg+DgYDRv3tzqznLlyZZ9OGvWLMycOROzZ8+GXq/HmDFjEBoaik8++QQzZ87E5s2bIcsyOnbsiJiYmGJ35WvevDnefvttbN26FT/++CNMJhOOHDlS5oYLAGbPno2wsDDs3LkTc+fOha+vL8LDw63u0jhr1izUqVMHu3fvxjfffINq1arhtddeK/Huho6YMWMGwsPDsXXrVkRHR0Or1aJ27dp48skn0bp1a4fGtvfn/E7+/v6YM2cOZs2ahe3bt6NatWqIioqyuivsgAEDkJSUhG3btuHYsWNo3LgxPv74Yxw8eFDRP7oQqYEkK3UlKxFRCT777DPMnj0bR48etbod+J1MJhPat2+Pxx57DLNmzarACqkiXL16Fd27d8d///tfDB8+XOlybHb8+HEMGzYMCxcutPsMBxERqQOv4SIixeTl5Vl9nZ+fj23btqF+/fpWzVZ+fn6xu5zt2bMHaWlpePjhhyukViIiIiJ7cEohESlmzJgxqFWrFpo0aYKsrCx88cUXiI+PL3aL5T/++AOzZ8/G448/joCAAJw7dw47d+5EaGgozx4QERGRU2PDRUSK6dSpE3bu3Ikvv/wSRqMRjRs3tlxIX1Tt2rVRo0YNbNiwAenp6fD390f//v0xfvz4ez44l4iIiEhJvIaLiIiIiIionPAaLiIiIiIionLChouIiIiIiKic8BouG/z++++QZdnqWThERERERFT56PV6SJJk9QzAkrDhsoEsy8VuTU1ERERERJVPWfsCNlw20Ol0kGUZ4eHhkCRJ6XLIRcmyDL1eD51OxxyRQ5glEoVZIhGYIxLFVbIUFxdXpvV4DRcREREREVE5YcNFRERERERUTthwERERERERlRM2XEREREREROWEDZeNnPnCPXIdfLQAicIskSjMEonAHJEoasoS71Joh3s1XUajEXq9voKqIWei0+mg1WpLXYdNO4nCLJEozBKJwByRKGrLklM2XLt378a6detw8eJFeHt7IyIiAkuWLIGnpycA4Ntvv8WCBQuQkJCAWrVqYdSoUXjmmWesxigoKEB0dDS++OILZGdno1WrVpgyZQoaNmzocH2yLJcYBFmWcePGDaSlpTn8Pch1BQQEoEaNGnc9WMiyDKPRCK1Wq7oDClUsZolEYZZIBOaIRFFblpyu4Vq+fDliYmIwevRotGzZEqmpqYiNjYXRaAQA/PrrrxgzZgwGDhyISZMm4ZdffsH777+PKlWq4PHHH7eMM2vWLOzfvx8TJkxASEgIVqxYgZdffhlfffUVfH197a6vtAecmZut6tWrw9vbWxUBobKTZRk5OTm4desWAKBmzZp3XddkMt3zTBhRWTBLJAqzRCIwRySKmrLkVA1XfHw8lixZgmXLluGRRx6xvN6rVy/L/1++fDmaN2+OGTNmAADatWuHxMRELFq0yNJw3bhxAzt37sTUqVMxcOBAAEBERAS6du2KrVu3YuTIkcJrNxqNlmYrKChI+PjkGry8vAAAt27dQvXq1VVzoCAiIiIi+zjVTTN27dqFOnXqWDVbRRUUFOD48eNWZ7IAoE+fPrh48SKuXr0KADh27BhMJpPVegEBAejYsSOOHj1aLrWbr9ny9vYul/HJdZgzwOv4iIiIiMipznCdOnUKoaGhWLZsGTZs2IDMzEyEh4dj4sSJaNGiBa5cuQK9Xl/sOqxGjRoBKDxDVqdOHcTHxyMoKAj+/v7F1tu5c6fDdZY2rbCk5eaphXd7nyRJpS5z5L0ct3zHLe29d1tmfs3VtlWJfai2bRU9btHXnKUmjuv8NblalpyxJlcbt6JqkmXZ8p/a9qGrfzauNq4tWaqomsr63pI4VcN1+/ZtnDlzBn///TemTp0KLy8vrFixAq+++ioOHz6M9PR0AICfn5/V+8xfm5dnZGSUeJ2Wn5+fZR1H6PV6q+uzNJr/O1FoDkdRRde1Z1lJYzoy7p1jV+ZxSxvb3nGLfm00GmEymayWazQaaLVayLIMg8FQbFzzbVANBkOxsd3c3CBJEkwmk+W6RjOtVmuZwnjn2TVHxtVoNHBzcytxXKDwzoySJJW4reZxS9pW87iyLN91XKDkfWjeVnv2oXlZaftQ9Gdzr33o7u5+120tbVxJku5ab9FtLa99KHpce/ehUvkubVvLMi5QsfuwtGOEebk94/IYUbZxlThGVPQ+vPP3FR4j1HOMqOh9WLThMn/tjMcIc0N4L07VcMly4U0HFi5ciCZNmgAAWrRogW7dumHjxo3o1KmTwhUWfgjmA19R5g9LkqRSd7w9y8ryQYr8nosXL8bSpUuLvX7//ffjyy+/RFhYGN577z0MHz4cQOFUUJ1OhyeeeOKe37Nbt2545JFHEBUVBQCYMGECzp49iy+//NLhbbHnvUVfE7UPi35d9OB15zqyLFs163cyH5xKotFoSn1vac+uED2ueXvvtq3mde5WU2nLHBkXsH9by2tcoPTPprRtvdu45v2vxD5U4rMBXCvfdxvXzJn2oXlbnW0f8hjxf+w5RgDK7UNnynd5jVuZjhHlNa4rHyPK8js64GQNl5+fHwICAizNFlB47dUDDzyACxcuoG/fvgCAzMxMq/dlZGQAgGUKoZ+fH7KysoqNn5GRUWyaob1Ka47saZxENxKOjCtJEjw9PbFu3Tqr1z09PSFJErZt24ZatWpZ3rtnzx54e3vjySefLHNN5uVvvvkmcnJyLF87036w9733auJkWYbJZCqX5vxey5xxXGesyVXGLe8sOfJejuu8Nblalhx5L8et2JqKTgETOa6oZc44rjPW5Azj2pKliqrJ1vcW5VQNV+PGjXHlypUSl+Xn56NevXrQ6XSIj49H586dLcvi4+MBwHJtV8OGDZGUlIT09HSrBis+Pt7h53DZMl/TlWk0GrRs2bLEZXd73R716tUTNpYoBQUFcHNzK/UvNI4yGAyqeoI6KYdZIlGYJRKBOSJR1JQlp7pLYdeuXZGWlobz589bXktNTcXZs2fRrFkzuLu7o23btjh06JDV+/bv349GjRqhTp06AIBOnTpBo9Hg8OHDlnXS09Nx7NgxdOnSpWI2RsXCwsKwevVqAMCLL76I//3vf/j+++8RFhaGsLAwLF68uMxjTZgwAf369bN8vWvXLoSFheHcuXMYMWIEWrZsiZ49e2LPnj3F3vv999/j2WefRfPmzdGuXTtMnToVOTk5luU5OTmYMWMGevXqZZmaGhUVVewMabdu3TBjxgzExMSga9euaN68ueXh1bt27cITTzyBiIgIdO7cGdHR0cXmJhMRERER3Y1TneHq0aMHIiIi8NZbb+Gdd96Bh4cHVq5cCXd3dwwZMgQA8Prrr2PYsGGYNm0aevfujePHj2Pfvn2Ijo62jFOjRg0MHDgQc+fOhUajQUhICD799FP4+vriueeeU2rzXM6dFxGW9LTvqVOn4r333oOnpyciIyMBFO5/R40fPx6DBg3CK6+8gu3bt2PChAmIiIiw3JHy4MGDeOeddzBgwACMHTsWt2/fxieffIKMjAxLFvLy8mA0GvHOO+8gMDAQ169fx4oVK/DGG29gw4YNVt/v8OHDuO+++/D+++9Do9HA29sba9euxccff4yXXnoJEyZMwMWLFy0N1/jx4x3eRiIiIiJSP6dquDQaDVauXInZs2cjKioKer0eDz30EDZt2oTg4GAAwEMPPYTFixdjwYIF2LlzJ2rVqoVZs2ahd+/eVmNNnjwZVapUwSeffILs7Gy0bt0aa9euLfHuhVRcTk4OmjVrZvXa3Llz0b9/f6vXGjduDB8fH3h7ewudavjCCy/ghRdeAAC0atUKP/zwAw4dOoQ33ngDsixj7ty56NOnDz744APLe4KDgzFq1Ci88cYbuP/++xEYGIjp06dblhsMBtSpUwdDhgxBQkICGjRoYFmm1+sRExNjeYZWVlYWFi1ahBEjRuDdd98FAHTs2BE6nQ5z5szB8OHDUbVqVWHbS0RERERAbm4u/vnnH9x3331WUwpzc3Nx4cIFNG7cGF5eXgpWaDunargAIDAwEB9//HGp63Tv3h3du3cvdR13d3dERkZazrqIYssFckXpL/0LU3rmvVcUTOPvC139Wja/z9PTExs3brR6rW7duqLKuqeid6T09vZGrVq1cOPGDQBAQkICrl27hkmTJlmdhXv44Yeh0Whw5swZ3H///QAKb+jx2Wef4fLly1bTDS9dumTVcLVt29bqodW///47cnJy8Pjjj1t9jw4dOiAvLw///PMPHn74Ybu3z94cEd2JWSJRmCUSgTkiR+Xm5uLMmTPFZkyZX69duzYbrsrA1oOJMTkNV9o+D9zxDIAKodWi/tk90AYF2PQ2jUaDiIiI8qmpDO48E6nT6VBQUACg8Lo+oPAOhyW5fv06AODrr79GZGQkBg8ejHfeeQcBAQG4ffs23nzzTeTn51u9JygoyOpr8/d4+umnS/0e9rjXLUiJyopZIlGYJRKBOSJRJEmCm5sbUo7+jiSjBjUfbqp0SQ5hw1UBtEEBqHd8i2JnuGxttpxdQEAAACAqKgrNmzcvtrx69eoACq/zatq0KWbMmGFZ9r///a/EMe9sos13t1yyZEmJ16SZb9BCREREROKkpaWh4OoNXH3pfVT55QximzfHhX5d0a1lMDIzM5GWlobAwECly7QJGy47lPWp0kXZM63PVeh0umJnjMpTw4YNUaNGDSQmJlqu8ypJXl5esb+0FX3AcmlatWoFLy8v3LhxA4899phD9d7J/FRz81PZiezFLJEozBKJwByRo+QCPa7NiUHbfbEw6LQ41qMZEkKrQ5t+DseOSZAA/PHHHw4/5qmiseGyUWV5DpctGjZsiD179uDbb79FcHAwqlevjpCQkHL7fpIkYcKECRg/fjxycnLw6KOPwsvLC//++y9++OEHvPPOO2jQoAE6dOiAGTNmYOnSpZYbb8TGxpbpe/j5+eGtt97Cxx9/jBs3buDhhx+GVqtFYmIijhw5gsWLFzs0f5g5IlGYJRKFWSIRmCOyV873J5A0cQFqJVzFlbahMA1/Bv9czELi9UzUremLR1oG48I/fwm9SVtFYcNFDhs5ciSuXLmCyMhIZGRkYMyYMRg7dmy5fs/evXvDz88PK1assJy1ql27Njp37oxq1aoBAJ577jlcvXoVGzduxOrVq9GpUyd88sknGDRoUJm+x6uvvoqQkBCsXbsWGzduhJubG+rVq4dHH32Uc9SJiIiIBNBfvYnkKYuRve8HeLZvAa/5/8H1hD/RvW0rPNTVHzdTclEjyBuGgmzcvPGv5dISVyLJ/FNEmcXFxUGWZURERBQ7VZ6Xl2e51binp6dCFZIzuFcWZFmGXq+HTqfjlAtyCLNEojBLJAJzRLaQ8wuQtnwbUqPXQ+NbBUHT34TPgB5ITU3FwYMH0b17d1SvXt2SpZSUFBw6dAi9evVymmu44uLiAOCeN5rjGS4iIiIiIqowOd8eR9LEBdBfvg7/UQMR+N4r0PhWAQB4eXkhPDy82B+tza+72i3hATZcNuNfbEgETkkkUZglEoVZIhGYIyqNPvFG4fTBr47Cs2Mr1Fj3IdybNLBax8vLq8QzRnd73RWw4bIDmy5yBPNDojBLJAqzRCIwR3Q3prx8pC/ditSFG6Dx90X1lVPh81T3u2ZGbVliw2UHe24LT2QmyzJMJhM0Gg1zRA5hlkgUZolEYI6oJNnf/ILkSQuhT7wO/9eeReD4V6Dx8S71PWrLEhsuG/EeIySC0WiERqNRugxSAWaJRGGWSATmiMz0V64jafIi5Bw4Bq/OrVFjw4dwD2tw7zf+f2rKEhsuwdiQETNARERElZUpLx9pSzYjbeFGaKr6IyRmOqr076qKM1X2YsMliPki0ZycHJe8ewqJk5OTA4AXDhMREVHlkn34JyS9vwiGa7cQMHowqr477J7TBysDNlyCaLVaBAQE4NatWwAAb2/vSt3JV0ayLCMnJwe3bt1CQEAAtFqt0iURERERlTv9pX8Lpw8e+glejzyEmpvnwv3++5Quy2mw4bJRaU1UjRo1AMDSdFHlFBAQYMnC3bAZI1GYJRKFWSIRmKPKxZSbj7TFm5C2aBO01QIQsnoGqjzxqJCTDmrKEhsuO5R2C8uaNWuievXq0Ov1FVwVOQOdTnfPA4QkSao6iJBymCUShVkiEZijyiX70E9Ien8hDP/eRsAbz6HqO8OgqSLmshq1ZYkNlx3udVt4rVarqpCQWLIsWzLEaafkCGaJRGGWSATmqHLQJ1xD0vsLkfN1LLwebYOaW+fBvXE9od9DbVliw2Uj3oGORDAYDLypBgnBLJEozBKJwByplyknD2mLNiJtyRZog6siZO0sVOnbpdwaIjVliQ0XERERERGVSJZl5Bz4EUmTF8NwMxkBbz6PquNehMbbU+nSXAYbLiIiIiIiKqbgYiKSJi1E7rfH4d29HWrumA/3RnWVLsvlsOEiIiIiIiILU3YuUhdsQNqyrXALCUKN9R/C+/FOqrieSglsuGzEoJEIzBGJwiyRKMwSicAcuTZZlpH91VEkT1kM4+1UVB07BAFvDVVk+qCassSGyw5qCgBVPEmSVHMRKCmLWSJRmCUSgTlybQUXryBpwgLkfn8C3o+1R7Vdb0PXoLYitagtS2y4iIiIiIgqKVN2LlKj1xdOH6wZjBob56BKr45Kl6UqbLjscK/ncBGVRpZlGAwGuLm5MUfkEGaJRGGWSATmyLXIsozsL79HctQSGJPSUHXciwgY+wI0Xh5Kl6a6LLHhshGfw0UiMEckCrNEojBLJAJz5BoK/rmMpIkLkPvDr/Du1RHVZr0FXf1aSpdlRU1ZYsNFRERERFQJmLJykDp/HdJWbIdb7eqosekjVOnZQemyVI8NFxERERGRismyjOy93yEpaglMqemo+u4wBIwZAo2n8tMHKwM2XEREREREKlXw9yUkTYhG7o+/wbt3J1SbORa6+5xr+qDaseGykRou3CPlubnxR4/EYJZIFGaJRGCOnIcpKwcp89Yi/dMd0NWtiRpbPkaVHu2ULqvM1JQl9WxJBWLTRY6QJIkZIiGYJRKFWSIRmCPnIMsysvYcQXLUUpjSMxH43qvwf2OwS00fVFuW2HDZgbeFJ0fIsgyTyQSNRsMckUOYJRKFWSIRmCPlFfyZgNsTFyDv2G+o0vcRBM0cA13dGkqXZTO1ZYkNl43UdItKUo7RaIRGo1G6DFIBZolEYZZIBOZIGabMbKR8vBbpMTuhq1cTNbfNg3e3tkqX5RA1ZYkNFxERERGRC5JlGVmff43kactgysxGYORwBLw+GJKHu9KlURFsuIiIiIiIXEz+uYtImhCNvNhTqNLvEQTNHAtdnRCly6ISsOEiIiIiInIRxowspM5dg/RVu6BrUBs1d8yH96NtlC6LSsGGy0ZquHCPlKeWOcmkPGaJRGGWSATmqPzIsoysHYeQPG05TNm5CJw0EgGjB0Fy1yldWrlQU5bYcNmBTRc5QpIkVT1bgpTDLJEozBKJwByVn/wzFwqnDx4/jSr9u6HajDfhVqu60mWVG7VlST1bUoF4W3hyRNE7XTJH5AhmiURhlkgE5kg8Y3omUj9ag/TVu6BrXBc1P4+Gd5eHlC6r3KktS2y4bMTbwpMIer0eOp06pwBQxWKWSBRmiURgjsSQTSZkbj+ElBnLYcrOQ+CU1xAw6lnVTh8siZqyxIaLiIiIiMhJ5Mf9g6TI+cg7cQY+T3dH0PQ34VYzWOmyyAFsuIiIiIiIFGZMz0TK7FXIWLsHuvvrodbuhfDq1FrpskgANlxERERERAqRTSZkbj2A5JkrIOfmI2jq6/AfORCSjr+mqwU/SSIiIiIiBeSf+gu3J0Qj/9ez8HnmMQRNewNuNaopXRYJxobLRpIkqeJuKaQcSZLg7u6udBmkAswSicIskQjMUdkZUzOQMjsGGZ/thXuTBqi1ZxG8OrZSuiynobYsseEiIiIiIqoAssmEzE1fIfmDTyHn6xE0Ywz8hw/g9EGV46drBz6HixwhyzKMRiO0Wi1zRA5hlkgUZolEYI5Kl/fHn0iKnI/8387D59meCIp6ndMH70JtWWLDZSM+h4tEMJlM0Gq1SpdBKsAskSjMEonAHBVnTElHyocxyFj/BdybNkCtL5bAq30LpctyemrKEhsuIiIiIiLBCqcP7kPyrJWA3oCgWW/B/9WnILnx1+/Khp84EREREZFAeb+fR1JkNPJ/Pw/fwY8jMOp1uFUPVLosUggbLiIiIiIiAYzJaUj+YCUyN+6D+wONUGvfUni1ba50WaQwNlw2UsOFe6Q8N04nIEGYJRKFWSIRKmuOZKMRGRu+RMqHMYDRhGofvg2/l/tz+qAD1JQl9WxJBWLTRY7gs9xIFGaJRGGWSITKmqO8k2cLpw+e+gu+z/dB4JTRcAuuqnRZLk1tWWLDZQfeFp4cIcsyTCYTNBoNc0QOYZZIFGaJRKhsOTImpSJ51qfI3PQV3CPuR+39y+HZJlzpslRBbVliw2Uj3haeRDAajdBoNEqXQSrALJEozBKJUBlyJBuNyFj3BVI+XAkAqPbRu/B76UlIKrmFubNQU5bYcBERERERlUHeiTO4HTkfBXH/wPeFvgia/Bq01Th9kErHhouIiIiIqBSG26lImbkCmVv2w6NFGGofXAHPB5spXRa5CDZcREREREQlkA0GZHy2FylzVgGShGrzxsNvaD9OHySbsOGykRou3CPlqWVOMimPWSJRmCUSQU05yj1+GkmR0Sg4dxG+Q/sh6P1R0AYFKF1WpaGmLLHhsgObLnKEJEmqerYEKYdZIlGYJRJBLTky3EpB8vTlyNp+EB4tmxROH2z9gNJlVSpqyZKZeraEyIXw0QIkCrNEojBLJIIr50g2GJC+Zg9S56wC3LQI/uQ9+L7Ql9MHFeLKWbqTU52r27VrF8LCwor9N2/ePKv1duzYgV69eiEiIgJPPvkkvvvuu2JjZWZmYtKkSXj44YfRqlUrvPXWW7h165bDNcqyzFvDk0NkWYZer2eOyGHMEonCLJEIrpyj3NhTuNpjBJInL4LPgB6o98tm+A3jrd6V4spZKolTnuFatWoVfH19LV+HhIRY/v9XX32FKVOmYPTo0WjXrh3279+PMWPGYNOmTWjZsqVlvXHjxuHChQuYNm0aPDw8sGDBAowcORKff/65qk5REhEREZF9DDeSkDxjObJ2HIZH66aofXglPFs2UbosUhmn7DyaNWuGwMDAEpctWrQIffv2xbhx4wAA7dq1w99//42lS5ciJiYGAPD777/j2LFjWL16NTp16gQAaNCgAfr06YPDhw+jT58+FbIdREREROR8ZL0B6as/R8pHayB56BAcHQnfIX0gqehGDeQ8XCpViYmJuHTpEnr37m31ep8+fRAbG4uCggIAwNGjR+Hn54eOHTta1mnYsCGaNm2Ko0ePVmjNREREROQ8cn/+A1e7D0dy1FL4PtsL9WI3F97qnc0WlROnPMPVr18/pKamolatWhg0aBBGjBgBrVaL+Ph4AIVnq4pq1KgR9Ho9EhMT0ahRI8THx6NBgwbFLrRr2LChZQwiIiIiqjwMN5KQPG0Zsj7/Gh4PNUOdr2Pg0SJM6bKoEnCqhis4OBhjx45FixYtIEkSvv32WyxYsAA3b95EVFQU0tPTAQB+fn5W7zN/bV6ekZFhdQ2Ymb+/P86cOeNQjZIklXgB391eNy8DUOry8novx3W+z0aWZeh0OpfbVmfahxwXlvV1Op1T1cRxnb8mV8uSM9bkauNWVE2yLMPNzc1ydzlnqVfWG5Cx6nOkzF0DycsDwQsnwGfw45A0Gsv6av9sXG1cW7JUUTWV9b0lcaqGq3PnzujcubPl606dOsHDwwPr1q3D6NGjFazMmsFgsPpao9FYbsSh1+uLre/u7g4AMBqNMJlMVsvc3NwgSRJMJhOMRmOJ45rv1HIn8z+OJY2r1Wqh1Wohy3KxeiVJsrzXYDAUC0x5jVuWbQWK78PyGte8rZIk2bytZRkXuPs+1Pz/g7zIbTXXW1JNSu1D87il7UOl8l3aPqzIfAM8RtiyrYDz5Ls8jxHlsQ/Leowo6c5gPEY4Pi6PEY6Pa88+zPv5D6S9vwj6C4nwe+Up+P3nJUj+PjAYjcD/H4PHCOtxS6pJyd8jADjtMcLcEN6LUzVcJenduzfWrFmD8+fPw9/fH0DhLd+Dg4Mt62RkZACAZbmfnx9u3LhRbKz09HTLOo4wh6ok5g+hJEWDfCeNRnPXJ2oX/eBtHfde7y3tjo3lNW5p2wqUvg9Fj2v+HB3ZVls/G/MPt0aj4T68xzJHxgXs31al8m3rMcKcJa1Wy2NEOY2rxDGirOOK3NaiWXK2fchjxP9x9t8jZFmG0Wi0/BKqZL4N128jedoyZO8+Ao824ajzzSp4RNxf6lkJHiPKVlNFHCPMWSq6jjMeI8rSbAEu0HAV1bBhQwBAfHy85f+bv9bpdKhbt65lvdjY2GJdZ0JCAkJDQx2qwTxmSTv4Xju9tOXl9V6OW77j2vtek8kErVZbLttTWfYhxy1Unlly5L0c13lrcrUsOfJejlvxNRX93UuRbdUbkLZyB1LnfQaNtyeCF0+C76BelhtiVObPxtXGLWuWKrImW95blNPfjmX//v3QarV44IEHULduXdSvXx8HDx4stk779u0tp9y7dOmC9PR0xMbGWtZJSEjAuXPn0KVLlwqtn4iIiIjKX87RX5H46CtImfkp/Ib0Rd3YTfB7rjfvPkiKc6ozXMOHD0fbtm0RFlZ4x5gjR45g+/btGDZsmGUK4dixYzF+/HjUq1cPbdu2xf79+3H69Gls3LjRMk6rVq3QqVMnTJo0CZGRkfDw8EB0dDTCwsLQs2dPRbaNiIiIiMQz/HsLSVOWIPuL7+DZtjlCVk6DR3hjpcsisnCqhqtBgwb4/PPPcePGDZhMJtSvXx+TJk3Ciy++aFmnX79+yM3NRUxMDFauXIkGDRpgyZIlaNWqldVYCxYswOzZsxEVFQWDwYBOnTph8uTJpc7FJCIiIiLXIBfokbZiO1I/WQdNFS9UX/o+fJ7tZdNUL6KKIMm23NOwkouLiwMAhIeH84eZ7CbLMkwmk00XWxKVhFkiUZglEqEic5Tz/QkkTVwAfcI1+I8YgKr/fRVaP59y/Z5UcVzlmGTuDSIiIkpdj6d77ODMHzw5P/Odm4gcxSyRKMwSiVAROTJcu1k4ffDL7+HZvgVCVs+AxwONyvV7UsVT2zGJDZcdynrPfaKSyLJc6t0uicqKWSJRmCUSoTxzJOcXIG35NqRGr4fGtwqqr4iCz4AezKtKqe2YxIbLRpyBSSIYDIZSn/tAVFbMEonCLJEI5ZGjnG+PF04fvHwd/qMGIvC9V6DxrSL0e5DzUdMxiQ0XERERETkdfeINJE9ZjOyvjsKzYyvUWPch3Js0ULosIpux4SIiIiIip2HKy0f60q1IXbgBGn9fVF85FT5PdVfF1DKqnNhwEREREZFTyP7mFyRPWgh94nX4v/YsAse/Ao2Pt9JlETmEDZeN+NcVEoE5IlGYJRKFWSIR7M2R/sp1JE1ehJwDx+DVuTVqbPgQ7mGcPliZqemYxIbLDmoKAFU8SZJUcxEoKYtZIlGYJRLBnhyZ8vKRtnQL0hZsgKaqP0JipqNK/678XauSU9sxiQ0XEREREVW47MM/I+n9RTBcu4mA0YNR9d1hnD5IqsSGyw58Dhc5QpZlGAwGuLm5MUfkEGaJRGGWSISy5kh/6d/C6YOHfoLXIw+h5uaP4H7/fRVYKTk7tR2T2HDZiM/hIhGYIxKFWSJRmCUSobQcmXLzkbZ4E9IWbYImKAAhq2egyhOPquIXahJPTcckNlxEREREVK6yD/2EpPcXwvDvbQS8PhhV330JmipeSpdFVCHYcBERERFRudAnXEPS+wuR83UsvB5tg5pb58G9cT2lyyKqUGy4iIiIiEgoU04e0hZtRNqSLdAGV0XI2lmo0rcLpw9SpcSGy0Y8UJAIarrVKSmLWSJRmCUSwc3NDdn7f0TylMUw3ExGwJvPo+q4F6Hx9lS6NHIxajomseGyA5sucgTzQ6IwSyQKs0Qi6OOvImnSQuR+exze3duh5o75cG9UV+myyAWp7ZjEhssOvC08OUKWZRiNRmi1WuaIHMIskSjMEjnClJOH1AUbkLZ0C7TVAxGy7gNU6d2ZWSK7qe2YxIbLRmq6RSUpx2QyQavVKl0GqQCzRKIwS2QrWZaR/dVRJE9ZDOPtVASMGYIqbwyCh5+vKn5JJmWp6ZjEhouIiIiIbFJw8QqSJixA7vcn4P1Ye1Tb9Tbc6teCXq9XujQip8OGi4iIiIjKxJSdi9To9UhbthVuNYNRY+McVOnVEQBnARHdDRsuIiIiIiqVLMvI/vJ7JEctgTEpDVXHvYiAsS9A4+WhdGlETo8Nl404J5lEUMucZFIes0SiMEt0NwX/XEbSxAXI/eFXePfqiGqz3oKufq0S12WOSBQ1ZYkNlx3YdJEjJElS1UGElMMskSjMEpXElJWD1PnrkLZiO9xqV0eNTR+hSs8Od12fOSJR1JYlNlx24G3hyRGyLFsyxByRI5glEoVZoqJkWUb23u+QFLUEptR0VH13GALGDIHGs/Tpg8wRiaK2LLHhshEvCCURDAaDqp6gTsphlkgUZokAoODvS0iaEI3cH3+Dd+9OqDZzLHT3lTx9sCTMEYmipiyx4SIiIiKq5ExZOUiZtxbpn+6Arm5N1NjyMar0aKd0WUSqwIaLiIiIqJKSZRlZe44gOWopTOmZCHzvVfi/Mfie0weJqOzYcBERERFVQgV/JuD2xAXIO/YbqvR9BEEzx0BXt4bSZRGpDhsuG6nhwj1SHnNEojBLJAqzVHmYMrOR8vFapMfshK5eTdTcNg/e3doKGZs5IlHUlCU2XHZQUwCo4kmSpJqLQElZzBKJwixVDrIsI+vzr5E8bRlMmdkIjByOgNcHQ/JwFzI+c0SiqC1LbLiIiIiIVC7/3EUkTYhGXuwpVOn3CIJmjoWuTojSZRFVCmy47MDncJEjZFmGwWCAm5sbc0QOYZZIFGZJvYwZWUiduwbpq3ZB16A2au6YD+9H25TL92KOSBS1ZYkNl434HC4SgTkiUZglEoVZUhdZlpG14xCSpy2HKTsXgZNGImD0IEju5TtNizkiUdSUJTZcRERERCqSf/YCkiKjkXf8NKr074ZqM96EW63qSpdFVGmx4SIiIiJSAWN6JlI/WoP0Nbuha1QHNT+PhneXh5Qui6jSY8NFRERE5MJkkwmZ2w8hZcZymLLzEDh5FAJGPVvu0weJqGzYcNlIDRfukfLc3PijR2IwSyQKs+Sa8uP+QVLkfOSdOAOfp7sjaPqbcKsZrFg9zBGJoqYsqWdLKhCbLnKEJEnMEAnBLJEozJLrMaZnImX2KmSs3QPd/fVQa/dCeHVqrWhNzBGJorYsseGyA28LT46QZRkmkwkajYY5IocwSyQKs+Q6ZJMJmVsPIHnmCsi5+Qia+jr8Rw6EpFP+VzrmiERRW5aU/+l0MWq6RSUpx2g0QqPRKF0GqQCzRKIwS84v/9RfuD0hGvm/noXPM48haNobcKtRTemyrDBHJIqassSGi4iIiMiJGVMzkDI7Bhmf7YV7kwaotWcRvDq2UrosIiojNlxERERETkg2mZC5eT+SZ62AnK9H0Iwx8B8+wCmmDxJR2fEnloiIiMjJ5J/6C7cj5yP/5Dn4PNsTQVGvO930QSIqGzZcNlLDhXukPLXMSSblMUskCrPkHIwp6Uj5MAYZ67+Ae9MGqPXFEni1b6F0WWXGHJEoasoSGy47sOkiR0iSpKpnS5BymCUShVlSnmwyIXPTPiTPWgnoDQia9Rb8X30Kkgt9LswRiaK2LKlnSyoQbwtPjih6p0vmiBzBLJEozJKy8n4/j6TIaOT/fh6+gx9HYNTrcKseqHRZNmOOSBS1ZYkNl414W3gSQa/XQ6fTKV0GqQCzRKIwSxXPmJyG5A9WInPjPrg/0Ai19i2FV9vmSpflEOaIRFFTlthwEREREVUg2WhExoYvkfJhDGA0odqHb8Pv5f4uNX2QiMqOP9lEREREFSTv5NnC6YOn/oLv830QOGU03IKrKl0WEZUjNlxERERE5cyYlIrkWZ8ic9NXcI+4H7X3L4dnm3ClyyKiCsCGy0ZquHCPlMcckSjMEonCLJUP2WhExrovkPLhSgBAtY/ehd9LT0LSahWurHwwRySKmrLEhssOagoAVTxJklRzESgpi1kiUZil8pF34gxuT4hGwem/4ftCXwRNfg3aauqdPsgckShqyxIbLiIiIiKBDLdTkTJzBTK37IdHizDUPrgCng82U7osIlIIGy478Dlc5AhZlmEwGODm5sYckUOYJRKFWRJDNhiQ8dlepMxZBUgSqs0bD7+h/VQ7ffBOzBGJorYsseGyEZ/DRSIwRyQKs0SiMEuOyT1+GkmR0Sg4dxG+Q/sh6P1R0AYFKF1WhWOOSBQ1ZYkNFxEREZGdDLdSkDx9ObK2H4RHyyaF0wdbP6B0WUTkRNhwEREREdlINhiQvmYPUuesAty0CP7kPfi+0LfSTB8korJjw0VERERkg9zYU0iaGI2Cc/HwG/YkAieNhDbQX+myiMhJseGykRou3CPlubnxR4/EYJZIFGbp3gw3k5E8fRmydhyGR+umqH14JTxbNlG6LKfCHJEoasqSerakArHpIkdIksQMkRDMEonCLJVONhiQvmoXUueuAdzdEBwdCd8hfSBpNEqX5lSYIxJFbVliw2UH3haeHCHLMkwmEzQaDXNEDmGWSBRm6e5yf/4DSROiUfBnAvxefgqBE0dAW9VP6bKcEnNEoqgtS2y4bKSmW1SScoxGIzT8yygJwCyRKMySNcONJCRPW4asz7+Gx0PNUOfrGHi0CFO6LKfHHJEoasqS025FdnY2unTpgrCwMMTFxVkt27FjB3r16oWIiAg8+eST+O6774q9PzMzE5MmTcLDDz+MVq1a4a233sKtW7cqqnwiIiJyQbLegLRlW3Gl3RDk/HACwQsnoPZXy9hsEZHdnLbhWrZsGYxGY7HXv/rqK0yZMgW9e/dGTEwMWrZsiTFjxuCPP/6wWm/cuHH46aefMG3aNMybNw8JCQkYOXIkDAZDBW0BERERuZLcn35HYtdXkDx9OXwH90a92M3wG9KX12oRkUOcckrhxYsXsXnzZkRGRmLq1KlWyxYtWoS+ffti3LhxAIB27drh77//xtKlSxETEwMA+P3333Hs2DGsXr0anTp1AgA0aNAAffr0weHDh9GnT58K3R4iIiJyXobrt5E8dSmydh+BZ5twhHyzCh4R9ytdFhGphFP+yWbWrFl47rnn0KBBA6vXExMTcenSJfTu3dvq9T59+iA2NhYFBQUAgKNHj8LPzw8dO3a0rNOwYUM0bdoUR48edag2NVy4R8pTy5xkUh6zRKJUxizJBXqkLtmMK+1fQO6x3xC8eBJq7VvKZssBlTFHVD7UlCWn25KDBw/i77//xptvvllsWXx8PAAUa8QaNWoEvV6PxMREy3oNGjQo1hw1bNjQMoYj2HSRIyRJgpubG3NEDmOWSJTKmKWco78i8dFXkDLzU/gN6Yu6sZvg91xvTh90QGXMEZUPtWXJqaYU5ubmYs6cOXjnnXfg4+NTbHl6ejoAwM/P+nas5q/NyzMyMuDr61vs/f7+/jhz5ozDdZpMpmIBkCTprncwNK9b2vLyei/Hdb7PxvxYgbs9XsBZt9WZ9iHHhWX9e/1jpJZtddVxnbEmV8uSI+8taZnh31tInroM2Xu/hWfb5qj+6VR4hDe2+j7O9NmIGLeiair6/zUajdPX6wzjOmNNzjCuLVmqqJrK+t6SOFXDtXz5cgQFBeGZZ55RupS7kmUZer3e6h8mjUZjeRq2Xq8v9h53d3cAhbe3NJlMVsvM3bvJZCp2kxDzuObveSedTnfXcbVaLbRaLWRZLnajEEmSLO81GAzFAlNe45ZlW4Hi+7C8xjVvqyRJNm9rWcYFSt6HGo0GJpMJWq1W6D4011tSTUrtQ/O4pe1DpfJd2j6syHwD9h8jzPvWzc2txBsC8Rjh2Ljmba3oY0R57cPSjhFF61LrMUIu0CMzZicyFmyEpoo3qi99Hx5PdStWt5qOERV9nDWv6+XlJXRcW7YV4DFCDb9HmLfN09PT6uuSxlXy94iy/LEKcKKG69q1a1izZg2WLl2KzMxMAEBOTo7lf7Ozs+Hv7w+g8JbvwcHBlvdmZGQAgGW5n58fbty4Uex7pKenW9ZxhDkYd1t2N0WDfCeNRnPXuapFP3hbx73Xe80/ABU5bmnbCpS+D0WPa/4cHdlWWz8bWZYtZ0m5D5XLtyM/c+X12dh6jDD/Q8FjRPmNq8QxoqzjitzWor90ONs+FJHvnO9PIHnSQugTrsFvxAAE/vdVaP18Sv0LtRqOEWYVdYy4c386S77Lc9zKcowoz3FL2odFzzab/9cZf48oS7MFOFHDdfXqVej1eowaNarYsmHDhqFFixb45JNPABReo9WwYUPL8vj4eOh0OtStWxdA4bVasbGxxbrOhIQEhIaGOlyrJEkl7uCyTMewZ5kj7+W45TuuozWVx/ZUtn3IcZ2zJo7rvDW52riOvNf47y0kTVmC7C+/h2f7FghZPQMeDzRyeNzKtA9tHbfov22uUK/S4zpjTc4yblmzVJE12fLeopym4WratCnWr19v9dr58+cxe/ZsTJ8+HREREahbty7q16+PgwcPokePHpb19u/fj/bt21tOuXfp0gXLli1DbGwsOnToAKCw2Tp37hxGjBhRcRtFREREQuTm5uLChQto3LixZcpaSa8BgJxfgLTl25AavR4aH29UXxEFnwE9bPoFiYhIFKdpuPz8/NC2bdsSlzVr1gzNmjUDAIwdOxbjx49HvXr10LZtW+zfvx+nT5/Gxo0bLeu3atUKnTp1wqRJkxAZGQkPDw9ER0cjLCwMPXv2rJDtISIiInFyc3Nx5swZ1K5d26rhOnXqFLKystCyZUt4eXkh59vjuDUhGobL1+Ez/GlUnzgSGt8qCldPRJWZ0zRcZdWvXz/k5uYiJiYGK1euRIMGDbBkyRK0atXKar0FCxZg9uzZiIqKgsFgQKdOnTB58uRS52KWxb2mgRHdi3m+MHNEjmKWSBRXy1JGVj6uJ2fDS1sAo9GIv//+G419qiL9kw3I/uoo3B4Ox5nnOqPLy8+z2apArpYjcl5qy5Ik23JPw0ouLi4OABAREaFwJURERJVLfHw8vvnmGzS+Pwzf/nEbidczUTfEAzU0t9Ao9i/c//NfkPx8kPXa89D2aIWTvx5Hly5dUKNGDavphkREopS1N3C5M1zOoKy3gCQqiSzLMBqN0Gq1zBE5hFkiUVwhS3/88Qdu3ryJGzdvQmuUUd8bqHXmNh7+8S/4ZObh7wcb4mSbpshJvgT33dfg5WbEt99+i5YtW+LBBx9UuvxKwRVyRK5BbVliw2UjnhAkEczP4SJyFLNEojh7llq2bImkpCQ0vj8M//v+IiL2HUGTK1dw675qONqvFTKD/ZFfUAA3SYZJb4BR0vLfbAU4e47IdagpS2y4iIiIyOkFBATAz9MLYcfO4b7VOyH7+0L70Ts4L6fCy2hE25atse+X67iYmI6GtTxR3Scd3bt3Q40aNZQunYgqOTZcRERE5PT03/+KiNlbkZeeg4DRg1H13WFIK8iD9ssvoXVzQ2jjhvjvAxG4kZwDT20+fvrxO/j7+/P6LSJSHBsuIiIiclr6S/8iafIi5Bz6CboHmyD44/HwiwgDAHjlSggNDcXFixcBAH4+HvDz8UBKSoqSJRMRWWHDZSM1XLhHylPLnGRSHrNEojhblky5+UhbvAlpizZBExSAkNUzUOWJR63+Hfby8kLLli3h4+NjdSbLy8sL4eHhPLulAGfLEbkuNWWJDZcd2HSRIyRJUtVBhJTDLJEozpal7EM/Ien9hTD8exsBrw9G1XdfgqZKyc2Tl5dXsVsyl/QalT9nyxG5LrVliQ2XHXhbeHKELMuWDDFH5AhmiURxlizpE64h6f2FyPk6Fl6PtkHNrfPg3rieYvWQbZwlR+T61JYlNlw24i1mSQSDwQCdTqd0GaQCzBKJomSWTDl5SFu0EWlLtkAbXBUha2ehSt8uqvhFq7LhMYlEUVOW2HARERGRImRZRs7BY0h6fxEMN5MR8ObzqDruRWi8PZUujYhIGDZcREREVOH08VeRNGkhco78Au/u7VBzx3y4N6qrdFlERMLZ3HBdvXoVR44cwW+//YaLFy8iNTUVkiShatWqaNiwIVq3bo1u3bqhbl0eNImIiMiaKScPqQs2IG3pFriFBKHG+g/h/XgnTh8kItUqc8P13XffYc2aNTh58iRkWUa9evVQp04dhIaGQpZlZGRk4M8//8Thw4cxZ84cPPjggxg+fDi6du1anvVXOP6DQCJoNBqlSyCVYJZIlPLOkizLyP7qKJKnLIbxdiqqjh2CgLeGcvqgyvCYRKKoKUtlargGDRqEP//8E927d8eCBQvQoUMH+Pj4lLhuVlYWfvrpJxw6dAjjxo1DkyZNsG3bNqFFK41NFzlCkiS4uXE2LzmOWSJRyjtLBRevIGnCAuR+fwLePdqh2q6F0DWoXW7fj5TBYxKJorYslWlL2rZti2XLlqFatWr3XNfHxwe9evVCr169cPv2baxfv97hIomIiMj1mLJzkRq9HmnLtsKtZjBqbJgN714d+YdLIqpUJJn3OS+zuLg4yLKMiIgI/mNBdpNlGXq9HjqdjjkihzBLJIroLMmyjOwvv0dy1BIYk9IQ8NYLCBj7AjReHo4XS06LxyQSxVWyFBcXBwD3fNC6es7VERERkeIK/rmMpIkLkPvDr/Du1RHVZr0FXf1aSpdFRKSYMjdcZ8+etXnwZs2a2fweIiIicj2mrBykzl+HtBXb4Va7Omps+ghVenZQuiwiIsWVueF65plnbDqlJ0kSzp07Z1dRRERE5BpkWUb23u+QFLUEptR0VH13GALGDIHGk9MHiYgAGxqu2bNn33OdvLw8bN++HefPn3eoKCIiInJ+BX9fKpw+ePQkvHt3QrWZY6G7j9MHiYiKKnPD9fTTT991WUFBAbZu3YqYmBjcvn0bbdq0wdixY4UU6Gyc+cI9ch06nU7pEkglmCUSxZYsmbJykDJvLdI/3QFd3ZqoseVjVOnRrhyrI1fBYxKJoqYsOXTTjIKCAmzZsgWrVq3C7du38fDDD2P+/Plo06aNqPqcEpsucgTzQ6IwSyRKWbMkyzKy9hxBctRSmNIzEfjeq/B/YzCnDxIAHpNIHLVlya6Gq6CgAJs3b8bq1atx+/ZttG3btlI0WmayLKsuCFRxZFmG0WiEVqtljsghzBKJUpYsFfyZgNsTFyDv2G+o0rcLgmaOha5ujQqulJwZj0kkitqyZFPDlZ+fbzmjlZSUhLZt2yI6OhoPPfRQedXndPjYMhLBZDJBq9UqXQapALNEotwtS6bMbKR8vBbpMTuhq1cTNbfNg3e3tgpUSK6AxyQSRU1ZKnPD9dlnn2HVqlVITk5Gu3btsHDhQjz44IPlWRsREREpRJZlZH3+NZKnLYMpMxuBkcMR8PpgSB7uSpdGRORSytxwzZkzB5IkoWnTpmjUqBEOHDiAAwcOlPqeyZMnO1wgERERVaz8cxeRNCEaebGnUKXfI4XTB+uEKF0WEZFLsmlKoSzLOHfuXJmeryVJEhsuIiIiF2LKyELqx2uRvmoXdA1qo+aO+fB+tHJcn01EVF7K3HD9+eef5VmHy1DDhXukPLXMSSblMUskgizLyN19BKnTV8CUnYvASSMRMHoQJHf13JaZKgaPSSSKmrLk0G3hKys2XeQISZJUdRAh5TBLJEL+2QtImrAAeb+cQpX+3VBtxptwq1Vd6bLIBfGYRKKoLUtsuOzA28KTI2RZtmSIOSJHMEvkCGN6JlI/WoP0Nbuha1QHNXbMh/cjDzFLZDcek0gUtWXJ7oZr7969+Pzzz3H16lWkp6cXu126JEk4efKkwwU6G94WnkQwGAyqeoI6KYdZIlvJJhMytx9CyozlMGXnIXDyKPiPHAiD6/9OQ06AxyQSRU1Zsqvh+vjjj7FmzRqEhIQgPDwcvr6+ousiIiIiwfLj/kFS5HzknTgDn6e7I2j6m3CrGVz4x0S9XunyiIhUya6Ga8eOHXj00UexdOlSaDQa0TURERGRQMb0TKTMXoWMtXugu78eau1eCK9OrZUui4ioUrB7SuEjjzzCZouIiMiJySYTMrceQPLMFZBz8xE09XX4jxwIScdLuImIKopdHdOjjz6qyuuzykINF+6R8pgjEoVZorvJP/UXrvV9A7ffngPvR9qg3i+bEfDGc3dttpglEoE5IlHUlCVJtuMuEJmZmRg9ejTCwsLwzDPPoGbNmiWe7QoICBBRo9OIi4sDAERERChcCRERUcmMaZlI+TAGGZ/tgXuTBqg2exy8OrZSuiwiItUpa29g15wCLy8vtGrVCqtXr8aWLVvuut758+ftGZ6IiIhsJJtMyNy8H8mzVkDO1yNoxhj4Dx/A6YNERAqz6yg8Y8YM7NixAy1atECLFi0q3V0K+RwucoQsyzAYDHBzc2OOyCHMEpnln/oLtyPnI//kOfg82xNBUa/DrUa1Mr+fWSIRmCMSRW1ZsqvhOnDgAPr37485c+aIrsfp8TlcJAJzRKIwS5WbMSW9cPrg+i/g3rQBan2xBF7tW9g1FrNEIjBHJIqasmRXw+Xm5oYWLew7oBMREZFjZJMJmZv2IXnWSkBvQNCst+D/6lOQ3Dh9kIjI2dh1l8K+ffviu+++E10LERER3UPe7+dx7fHRuP3ux6jyWHvU/WUzAkYNZLNFROSk7Do69+7dG7NmzcKoUaMsdynUarXF1mvWrJnDBRIRERFgTE5D8gcrkblxH9wfaIRa+5bCq21zpcsiIqJ7sKvheuGFFwAU3oXwxx9/LLbcfFMJNd6lUA0X7pHy3PiXaBKEWVI/2WhExoYvkfJhDGA0odqHb8Pv5f7Cz2gxSyQCc0SiqClLdm3J7NmzRdfhUth0kSMkSWKGSAhmSf3yTp5FUmQ08k/9Bd/n+yBwymi4BVcV/n2YJRKBOSJR1JYluxqup59+WnQdLoW3hSdHyLIMk8kEjUbDHJFDmCX1MialInnWp8jc9BXcI+5H7f3L4dkmvNy+H7NEIjBHJIrasqSec3UVRE23qCTlGI1GaDR23bOGyAqzpC6y0YiMdV8gZXYMIMuo9tG78HvpSUglXCctGrNEIjBHJIqaslSmrYiKikJiYqLNg1+5cgVRUVE2v4+IiKiyyTtxBld7jkJS5HxU6dsF9X7ZDP9Xn66QZouIiMpPmc5wXb9+Hb1790a7du3Qp08ftG/fHjVr1ixx3atXryI2NhYHDhzA8ePH0bFjR6EFExERqYnhdipSZq5A5pb98GgRhtoHV8DzQd7ll4hILcrUcMXExODkyZNYs2YNoqKiYDQaERAQgNq1a8Pf3x+yLCM9PR1Xr15FRkYGtFotunTpgnXr1uGhhx4q720gIiJyObLBgIzP9iJlzipAklBt3nj4De3HM1pERCpT5mu4HnzwQTz44INISUnBd999hz/++APx8fG4ceMGACAgIAA9e/ZEy5Yt8eijjyIoKKjcilaSGi7cI+WV9Nw6InswS64p9/hpJEVGo+DcRfgO7Yeg90dBGxSgaE3MEonAHJEoasqSJPMuEGUWFxcHAIiIiFC4EiIickWGWylInr4cWdsPwqNlE1T76B14tn5A6bKIiMgOZe0NeJdCO/C28OSIon/jYI7IEcyS65ANBqSv2YPUOasANy2CP3kPvi/0dZrpg8wSicAckShqyxIbLhvxhCCJoNfrodPplC6DVIBZcn65saeQNDEaBefi4TfsSQROGgltoL/SZRXDLJEIzBGJoqYsseEiIiIqB4abyUiesRxZ2w/Bo3VT1D68Ep4tmyhdFhERVTA2XERERALJBgPSV+1C6tw1gLsbgqMj4TukDySVPMCTiIhsw4aLiIhIkNyf/0DShGgU/JkAv5efQuDEEdBW9VO6LCIiUhAbLhup4cI9Uh5zRKIwS87BcCMJydOWIevzr+HxUDPU+ToGHi3ClC7LJswSicAckShqylKZ5zfMnz8ff/75Z3nW4jLUFACqeJIkQafTMUfkMGZJebLegLRlW3Gl3RDk/HACwQsnoPZXy1yy2WKWyFHMEYmitiyVueFauXIl/vnnH8vXqampaNq0KWJjY8ulMCIiImeW+9PvSOz6CpKnL4fv4N6oF7sZfkP68lotIiKy4tCUwsp6i3Q+h4scIcsyDAYD3NzcmCNyCLOkDMP120ieuhRZu4/As004Qr5ZBY+I+5UuyyHMEonAHJEoassSr+GyUWVtMkks5ohEYZYqjqw3IH3lDqR8vBYab08EL54E30G9VHNGi1kiEZgjEkVNWWLDRUREdA85P55E0oRo6C8kwn/4AFSNfBVaf1+lyyIiIhdgU8N17do1nD17FgCQmZkJALh8+TL8/Eq+5W2zZs1sKuaHH35ATEwMLly4gKysLISEhKBHjx4YM2YMfH3/7x+2b7/9FgsWLEBCQgJq1aqFUaNG4ZlnnrEaq6CgANHR0fjiiy+QnZ2NVq1aYcqUKWjYsKFNNRERUeVl+PcWkqKWInvvt/Bs2xwhR6bBI7yx0mUREZELkeQynq9r0qRJsTmUd7uWyfz6+fPnbSpm7969+Ouvv9CiRQsEBATgn3/+weLFi9GsWTOsWbMGAPDrr79i2LBhGDhwIPr06YNffvkFK1aswIIFC/D4449bxoqKisL+/fsxYcIEhISEYMWKFUhMTMRXX31l1bzZIi4uDrIsIyIiQhXzSUkZsixDr9er6u47pAxmqfzIBXqkrdiO1E/WQVPFC0HTXofPs71Uu5+ZJRKBOSJRXCVLcXFxAICIiIhS1yvzGa7Zs2c7VlEZ9O/f3+rrtm3bwt3dHVOmTMHNmzcREhKC5cuXo3nz5pgxYwYAoF27dkhMTMSiRYssDdeNGzewc+dOTJ06FQMHDgRQuCO6du2KrVu3YuTIkXbX6MwfOrkONzfO5iUxmCXxcr4/gaSJC6BPuAb/EQNQ9b+vQuvno3RZ5Y5ZIhGYIxJFTVkq85Y8/fTT5VnHXQUEBAAA9Ho9CgoKcPz4cYwfP95qnT59+mDfvn24evUq6tSpg2PHjsFkMlmd8QoICEDHjh1x9OhRhxougE0XOUaSJGaIhGCWxDJcu4mkKUuQ/eX38GzfAiGrZ8DjgUZKl1UhmCUSgTkiUdSWJae8tZLRaER+fj7Onj2LpUuXolu3bqhTpw6uXLkCvV5f7DqsRo0K/0GMj4+3/G9QUBD8/f2LrWdexxFqumsKVTxZlmE0GpkjchizJIacX4DUBRtwpcNQ5B0/jeorolBr7+JK02wBzBKJwRyRKGrLklOeq+vatStu3rwJAOjcuTM++eQTAEB6ejoAFLtJh/lr8/KMjIwSr9Py8/OzrGMvWZZL/PAlSbprKMwdemnLy+u9HNf5PhvzQeRuf7lx1m11pn3IcWFZ32g0QqPROE1NrjZuzrf/Q/KkBdBfvg7/kc+g6nuvQONbxTJWZcm3M2fJkfdy3IqtyfzsJPN1N85erzOM64w1OcO4tmSpomoq63tL4pQN18qVK5Gbm4sLFy5g+fLlGD16NNauXat0WRZ6vd7ql2WNRmOZZ6rX64ut7+7uDqDwzJ3JZLJaZn6gm8lkgtFotFpmHtd84eCddDrdXcfVarXQarWWwBYlSZLlvQaDoVhgymvcsmwrUHwflte45m2VJMnmbS3LuEDJ+1Dz/5/ZI3ofmustqSal9qF53NL2oVL5Lm0fVmS+AfuPEUX/Qbiz3qLbymNE8XENV28ibdoy5B44Bs+OrRDy2QeQGtWBEYCxyPhKHCPKax+WdowoiscI9RwjKnofFv0lWeS4tmwr4Dz/BqrpGFHR+9C8beb3Oesxougf5krjlA1XkyZNAACtWrVCREQE+vfvj6+//hqNGxfeitd8S3qzjIwMALBMIfTz80NWVlaxcTMyMopNM7RHaXdMMX8IJSka5DtpNBrLL+J3KvrB2zruvd5b2gWJ5TVuadsKlL4PRY9r/hwd2VZbPxtZlmEymbgPy7DMkXEB+7dVqc/G1mOE+R8KHiPKPq6kNyBt2VakLdgAjb8vqn86FT5Pd7/re5Q4RpR1XJH7sOgvHTxGFFLDMcKsovbhnb+YOku+y3PcynKMKM9xS9qH5iyZlznrMaIszRbgpA1XUWFhYdDpdLhy5Qq6desGnU6H+Ph4dO7c2bKO+bos87VdDRs2RFJSEtLT060arPj4eCHP4ZKkki/ku9dOL215eb2X45bvuI7WVB7bU9n2Icd1zpqccdycI8eRPGkh9InX4f/aswgc/wo0Pt6ljlfeNXFc16zJ1catyJqK/tvmCvUqPa4z1uQs45Y1SxVZky3vLcopb5pR1KlTp6DX61GnTh24u7ujbdu2OHTokNU6+/fvR6NGjVCnTh0AQKdOnaDRaHD48GHLOunp6Th27Bi6dOniUD227Fyiuyntrz9EtmCW7k1/5TquD5uIG8+/B7c61VH3+7WoNu3NMjdblQWzRCIwRySKmrLk0BkuvV6P+Ph4ZGZmlnjhWJs2bWwab8yYMQgPD0dYWBg8PT3x559/YvXq1QgLC0OPHj0AAK+//jqGDRuGadOmoXfv3jh+/Dj27duH6Ohoyzg1atTAwIEDMXfuXGg0GoSEhODTTz+Fr68vnnvuOUc2GQCbLnKMJEmqerYEKYdZKp0pLx9pS7cUTh+s6o+QmOmo0r8rj+ElYJZIBOaIRFFbliTZllts/H8mkwmffPIJNm/ejLy8vLuud/78eZvGXblyJfbv348rV65AlmXUrl0bjz32GIYPHw4fn/976OSRI0ewYMECJCQkoFatWhg1apTlAcdmBQUFiI6Oxt69e5GdnY3WrVtj8uTJllvI28P8NOnw8HD+g012K/ojxxyRI5ilu8s+/DOS3l8Ew7WbCBg9GFXfHcYzWqVglkgE5ohEcZUsmXuDiIiIUtezq+FatmwZFi1ahMGDB+PBBx/Ef//7X4wfPx5+fn7YvHkzJEnCe++9hw4dOthXvZOKi4uDLMuIiIhw6g+fnJv5bjql3XyFqCyYpeL0l/5F0uRFyDn0E7weeQjVZo+D+/33KV2W02OWSATmiERxlSyVteGya3Lk7t270bt3b0yfPt1y84pmzZph0KBB2L59OyRJwi+//GLP0ERERDYz5eYjZe4aJHZ6Eflx/yBk9QzU3DGfzRYRESnOrobrxo0baNeuHYD/ezZEQUGB5esnn3wSe/fuFVQiERHR3WUf+gmJnV9E6oIN8H/tWdT7eSN8nuS1WkRE5BzsuhotICAAOTk5AIAqVarAx8cHiYmJVuuYn41FRERUHvQJ15D0/kLkfB0Lr0fboObWeXBvXE/psoiIiKzY1XA98MADljmLANC2bVusW7cOTZs2hSzLWL9+PcLCwoQVSUREZGbKyUPaoo1IW7IF2uCqCFk7C1X6duEZLSIickp2TSkcNGgQCgoKLNMI33nnHWRkZGDo0KEYOnQosrOzMWHCBKGFOot7PayW6F4kSXL6i0DJNVS2LMmyjOwDPyKx8zCkLt4M/zeeQ92fNsKn3yOVZh+Ul8qWJSofzBGJorYs2XWXwpJkZmbi+PHj0Gq1aNWqFQICAkQM61TKeicSIiISSx9/FUmTFiLnyC/w7t4OQR+8BfdGdZUui4iIKrGy9gbCnijm6+treTix2smyrJqOmyqeLMswGo3QarXMETmkMmTJlJOH1AUbkLZ0C9xCglBj/YfwfryTardXKZUhS1T+mCMSRW1ZsmtKYffu3TF48GDEx8eXuPybb75B9+7dHSrMWQk6IUiVnMlkUroEUgm1ZkmWZWTt+wGJHYcifdlWVB07BHWPbUCV3p1V8Y+vM1JrlqhiMUckipqyZFfDde3aNZw9exbPPvssvvnmm2LLc3Jy8O+//zpcHBERVT4FF6/g+qD/4OYrk+HepAHq/rgegRNGQOPtqXRpRERENrOr4QKAiRMnok2bNhg7diwWLFggsCQiIqqMTNm5SJ71KRI7vwR9/FXU2DAbNTbPha5BbaVLIyIispvd13D5+flhxYoVWLJkCZYtW4Zz587hk08+ga+vr8j6iIhI5WRZRvaX3yM5agmMSWmoOu5FBIx9ARovD6VLIyIicpjdZ7jMxowZgxUrVuDUqVMYOHAg/vnnHxF1OS1eO0AiuLkJu18NVXKunqWCfy7j+rPv4ubwKLiH34+6xzYg8L+vstlSgKtniZwDc0SiqClLDjdcANClSxfs3LkTXl5eGDRoEI4cOSJiWKfFposcIUkSNBoNc0QOc+UsmbJykDxjBRIfeRn6y/+ixqaPUHPjHOjq11K6tErJlbNEzoM5IlHUliUhDRcA1K1bF9u2bUPPnj1x6NAhUcM6Jd6pkBwhyzJMJhNzRA5zxSzJsoysPd/iSscXkR6zA1XfHYa6P65HlZ4dlC6tUnPFLJHzYY5IFLVlya5zdevXr0fjxo2Lve7h4YGPPvoIffr0QUpKisPFOSO1fPCkLIPBAJ1Op3QZpAKulKWCvy8haeIC5B49Ce/enVBt5ljo7uMZLWfhSlki58UckShqypLNDVdubi7mzJmDZ599Fs8//3yJ6zzyyCMOF0ZEROpgyspByry1SP90B3R1a6LGlo9RpUc7pcsiIiKqEDY3XF5eXrh69apq5lQSEVH5KJw+eATJUUthSs9E4Huvwv+NwdB48oYYRERUedh1DVfnzp1x7Ngx0bUQEZFKFPyZgH8HjMOtUdPh+eADqPvTRlR9dxibLSIiqnTsarjeeOMNXLp0Ce+99x5+/fVX3Lx5E2lpacX+UyOe2SMRNBph96uhSs7ZsmTKzEZS1BIkdn0Fxn9voea2eajx2QfQ1a2hdGl0D86WJXJNzBGJoqYs2XXTjL59+wIALly4gH379t11vfPnz9tXlZNj00WOkCRJVc+WIOU4U5ZkWUbW518jedoymDKzERg5HAGvD4bk4a50aVQGzpQlcl3MEYmitizZtSVvvvkmmw4iB8iyzJ8hEsIZspR/Ph5JkfORF3sKVfo9gqCZY6GrE6JoTWQ7Z8gSuT7miERRU5bsarjGjh0rug6XIcuyqgJAFU+WZej1euh0OuaIHKJ0lowZWUiduwbpq3ZB16A2au6YD+9H21R4HeQ4pbNE6sAckShqy5KQc3V5eXkAAE9PTxHDERGRE5NlGVk7DyN56jKYsnMROGkkAkYPguSujuelEBERiWR3w/Xvv/9i8eLF+OGHH5CamgoAqFq1Kh555BGMGTMGtWvXFlYkERE5h/yzF5A0YQHyfjmFKv27odqMN+FWq7rSZRERETktuxquixcvYsiQIcjMzESHDh3QqFEjAEB8fDz27t2L7777Dps3b0bDhg2FFktERMowpmci9aM1SF+zG7pGdVDz82h4d3lI6bKIiIicnl0N1yeffAKNRoPdu3cjLCzMatnff/+Nl19+GZ988gmWLl0qpEgiIlKGbDIhc/shpMxYDlN2HgInj0LAqGc5fZCIiKiM7Gq4Tpw4gVdeeaVYswUAoaGheOGFF/DZZ585WptTUsOFe6Q8nY6/rJIY5Zml/Lh/Cu8+eOIMfJ7ujqDpb8KtZnC5fT9SFo9LJAJzRKKoKUt2NVwGg6HUG2R4eXnBYDDYXZSzY9NFjmB+SJTyypIxPRMps1chY+0e6O6vh1q7F8KrU+ty+V7kHHhcIhGYIxJFbVmy6xHOTZs2xY4dO5CZmVlsWVZWFnbu3IkHHnjA4eKclSzLSpdALkyWZRgMBuaIHCY6S7LJhIzNX+FKuyHI3HoAQVNfR93v1rLZqgR4XCIRmCMSRW1Zsvs5XCNHjkTv3r0xYMAA1K9fHwCQkJCA3bt3Iy0tDVFRUSLrdBpq+eBJWSaTCVqtVukySAVEZSn/1F+4PXEB8k+cgc8zjyFo2htwq1FNQIXkKnhcIhGYIxJFTVmyq+Fq3749Vq5ciblz52LlypVWy5o2bYqPP/4Y7dq1E1IgERGVH2NaJlI+jEHGur1wD6uPWnsWwatjK6XLIiIiUg27n8PVoUMH7NmzB7dv38a///4LAKhVqxaCg3lBNRGRs5NNJmRu3o/kWSsg5+sRNP1N+A8fAEln9z8LREREVIIy/8s6f/589OnTB02aNLF6PTg4mE0WEZELyT/1F25Hzkf+yXPwebYngqJe5/RBIiKiclLmm2asXLkS//zzj+Xr1NRUNG3aFLGxseVSmLNS211TSBlqmZNMyrMlS8aUdNwePw9XHxsJOTcPtb5YgpBlU9hsEQAel0gM5ohEUVOWHJo7UllvIMGmixwhSZKqDiKknLJmSTaZkLlpH5JnrQT0BgTNegv+rz4FyY3TB6kQj0skAnNEoqgtS/zX1g6yLLPpIrvJsmzJEHNEjihLlvJ+P4+kyGjk/34ePoMeR1DUaLiFBFVwpeTseFwiEZgjEkVtWWLDZaPKelaPxDIYDKp6gjop525ZMianIfmDlcjcuA/uDzRCrX1L4dW2uQIVkqvgcYlEYI5IFDVlyaaG69q1azh79iwAWB56fPnyZfj5+ZW4frNmzRwsj4iIbCEbjcjYuA8pH6wEjCZU+/Bt+L3cn9MHiYiIFCLJZTxl06RJk2Kn9O42tc78+vnz58VU6STi4uIgyzIiIiJUcXqTlCHLMvR6PXQ6HXNEDrkzS3knzxZOHzz1F3yf74PAKaPhFlxV6TLJBfC4RCIwRySKq2QpLi4OABAREVHqemX+k+fs2bMdq4iIiMqFMSkNKR98isxNX8E94n7U3r8cnm3ClS6LiIiIYEPD9fTTT5dnHS7Dmbtsch3MEYkgG43IWvcF0ueuAWQZ1T56F34vPQlJRXd2oorD4xKJwByRKGrKEif120FNAaCKJ0mSai4CJeXknTiD2xOiUXD6b/i+0BdBk1+DthqnD5J9eFwiEZgjEkVtWWLDRUTkQgy3U5EycwUyt+yHR4sw1D64Ap4P8gZFREREzooNlx34HC5yhCzLMBgMcHNzY46ozGSDARmf7UXKnFWAJKHavPHwfaEvjEWeVUJkLx6XSATmiERRW5bYcNmIz+EiEZgjskXu8dNIioxGwbmL8B3aD0Hvj4I2KKDwwZB6vdLlkUrwuEQiMEckipqyxIaLiMhJGW6lIGXGcmRuOwiPlk0Kpw+2fkDpsoiIiMgGbLiIiJyMbDAgfc0epH60GtBqEPzJe/B9oS/vPkhEROSC2HARETmR3NhTSJoYjYJz8fAb9iQCJ42ENtBf6bKIiIjITmy4bKSGC/dIeWq61SmJYbiZjOQZy5G1/RA8WjdF7cMr4dmyyT3fxyyRKMwSicAckShqyhIbLjuw6SJHMD9UlGwwIH3VLqTOXQO4uyE4OhK+Q/pA0mju+V5miURhlkgE5ohEUVuW2HDZgbdgJkfIsgyTyQSNRsMcVXK5P/+BpAnRKPgzAX4vP4XAiSOgrepX5vczSyQKs0QiMEckitqyxIbLRmq6RSUpx2g0QlOGMxikToYbSUietgxZn38Nj4eaoc7XMfBoEWbXWMwSicIskQjMEYmipiyx4SIiqiCy3oD0mJ1ImbsGkqc7ghdOgO9zvcs0fZCIiIhcExsuIqIKkPvT77gdOR/6f6783/TBAF+lyyIiIqJyxoaLiKgcGa7fRvLUpcjafQSebcIR8s0qeETcr3RZREREVEHYcNlIDRfukfK0fICt6sl6A9JX7kDKx2uh8fZE8OJJ8B3US/j0QWaJRGGWSATmiERRU5bYcNmBTRc5QpIkVR1EqLicH08iaUI09BcS4T98AKpGvgqtv/jpg8wSicIskQjMEYmitiyx4bIDbwtPjpBl2ZIh5khdDP/eQlLUUmTv/RaebZsj5Mg0eIQ3LrfvxyyRKMwSicAckShqyxIbLhvxtvAkgsFgUNUT1Cs7uUCPtBXbkfrJOmiqeKH60vfh82yvCvlHglkiUZglEoE5IlHUlCU2XEREDsj5/gSSJi6APuEa/EcMQNX/vgqtn4/SZREREZGTYMNFRGQHw7WbSJqyBNlffg/P9i0QsnoGPB5opHRZRERE5GTYcBER2UDOL0Da8m1IjV4PjY83qi+fAp9nHlPFHHMiIiIST+z9iR104MABvP766+jSpQtatmyJ/v37Y+fOncWum9qxYwd69eqFiIgIPPnkk/juu++KjZWZmYlJkybh4YcfRqtWrfDWW2/h1q1bDtfIX6pIBObINeV8exyJXV5CypzV8HupP+r9shm+A3sq+nkySyQKs0QiMEckipqy5FQN12effQYvLy9MmDABy5cvR5cuXTBlyhQsXbrUss5XX32FKVOmoHfv3oiJiUHLli0xZswY/PHHH1ZjjRs3Dj/99BOmTZuGefPmISEhASNHjoTBYHC4TjUFgCqeJEnQ6XTMkQvRX72JGy9PxvXB46GtGYy6369FtRljoPGtomhdzBKJwiyRCMwRiaK2LEmyE912LyUlBYGBgVavTZkyBfv378eJEyeg0WjQq1cvhIeH45NPPrGs89xzz8HX1xcxMTEAgN9//x3PPfccVq9ejU6dOgEA4uPj0adPH8yfPx99+vSxq764uDgAQEREhF3vJyLXIucXIG3pVqQuWA+Nvy+CZrwJn6e6q+YfACIiIrJfWXsDpzrDdWezBQBNmzZFVlYWcnJykJiYiEuXLqF3795W6/Tp0wexsbEoKCgAABw9ehR+fn7o2LGjZZ2GDRuiadOmOHr0qMN1OlGPSi5IlmXo9XrmSGG5ubmIi4tDSkoK4uLikJuba7U8+5tfkNj5JaR8vAZ+rz6NerGb4Pt0D6dqtpglEoVZIhGYIxJFbVly+ptmnDx5EiEhIfDx8cHJkycBAA0aNLBap1GjRtDr9UhMTESjRo0QHx+PBg0aFPvFqGHDhoiPj3eoHrV88KQs5kh5ubm5OHPmDHx8fHDmzBkEBQXhwoULqO/hg6xZK5Fz4Bi8OrdGQMxUXNboUUUrwUvpokvALJEozBKJwByRKGrKklM3XL/++iv279+PyMhIAEB6ejoAwM/Pz2o989fm5RkZGfD19S02nr+/P86cOeNwXSUFQJKkuwbD3PiVtry83stxne+zMb/matvqTPtQ1Lh6gxFXbmRCbzAiNz0DyfPWwvvIKWgD/VE9ZhqqPNkVqampiDt0CLVq1YKXl5ei9d6p6GvOUhPHdf6aXC1LzliTq41bUTXJsmz5T2370NU/G1cb15YsVVRNZX1vSZy24bpx4wbeeecdtG3bFsOGDVO6HCt6vd7q7JlGo4Gbm5tl2Z3c3d0BAEajESaTyWqZm5sbJEmCyWSC0Wi0WmYe13xa9U7mp2+XNK5Wq4VWq4Usy8VuFGK+EBEofIr3nYEpr3HLsq1A8X1YXuOat1WSJJu3tSzjAiXvQ42mcCav6H1orrekmpTah+ZxS9uH5ZXv3Nxc/PXXX2jQoIGlUcrNzcU///yDWrVqISklAxcTk/DDmV/QNvkiDHN3ovbtVLgNewJ+77yKxFwjQjJyLfur6H4RvQ/tPUYU/QehpBsC8Rjh2Ljmba3oY0R57cPSjhFFVZZjxN221bystH1YkfkGXOf3CPO6PEbce1td7RhR0fvQvG3m9znrMcLcEN6LUzZcGRkZGDlyJAICArB48WLLL6j+/v4ACm/5HhwcbLV+0eV+fn64ceNGsXHT09Mt6ziitLummD+EkhQN8p00Go1lO+9U9IO3ddx7vdcc5Ioct7RtBUrfh6LHNX+OjmyrrZ+NLMswmUzch2VY5si4ubm5OHfuHOrWrWtZJzMzEydOnIC7uzty8wyocvsGXjz2F+peSsKtBtVx8sVOqNqiNs5v/RaJ1zNRt6YvurYMRnZ2NjIzM1G9enUA5ffZ2HqMMP9DwWNE+Y2rxDGirOOK3Naiv3Q42z5UKt+O/LvsLMcIs4rah3f+Yuos+S7PcSvLMaI8xy1pH5qzZF7mrMeIsjRbgBM2XHl5eXjttdeQmZmJbdu2WU0NbNiwIYDCOw6a/7/5a51Oh7p161rWi42NLdZ1JiQkIDQ01KH6JEmy/FfSsnu9155ljryX45bvuPa+1/yXoPLYnsqyD8s6riRJyMwuwPXkbHhpC/8CJhXoEXY0Dvf9cAa5nu744fGWuNWsNvLz85F84W9oZQn1vQGkAz8dkyABOHXqFBo1alTu9dq6zPyPgTPVxHGduyZXy5Iz1uRq41ZkTUX/KO0K9So9rjPW5CzjljVLFVmTLe8tyqkaLoPBgHHjxiE+Ph6bNm1CSEiI1fK6deuifv36OHjwIHr06GF5ff/+/Wjfvr3llHuXLl2wbNkyxMbGokOHDgAKm61z585hxIgRDtdpyw4mutO9Gi0SIy8vD3l5efj7Qjz2/XId8YnpaFjLE62u/IvmR+Ig3U7Dlc7hMLz8LOSbCejSJAx//PEHGjUOxY9n0yxnuB5pGYwL//yFli1bKr1JxTBLJAqzRCIwRySK2rLkVA3X9OnT8d1332HChAnIysqyepjxAw88AHd3d4wdOxbjx49HvXr10LZtW+zfvx+nT5/Gxo0bLeu2atUKnTp1wqRJkxAZGQkPDw9ER0cjLCwMPXv2dLjOss7XJCqJeUqhLaeiyXYXLlzA9evXcf36DUj5RrTSZ6PNpj9R93ISUu6vBf3EsbiJArR74D4kZ1xHzZo1cfnyZbR5qDXad6iCG8k5qBHkDUNBNm7e+BcBAQFKb1IxzBKJwiyRCMwRiaK2LDlVw/XTTz8BAObMmVNs2ZEjR1CnTh3069cPubm5iImJwcqVK9GgQQMsWbIErVq1slp/wYIFmD17NqKiomAwGNCpUydMnjy51LmYZWHLHUmI7sZoNJY6x5nE0Gq18PPwRpOfT6HZr/8gz9sDPz/ZGvntwtGsfi2E+/jA398f4eHh8PDwsLzPz8cDfj6FX6ekZCtVfpkwSyQKs0QiMEckipqyJMnsIMosLi4OsiwjIiJCFd02KcN8N53Sbr5Cjrt27Rp+W7AaDxz6HUhKQ96gPpCH9cLJuN/RpUsX1KhRw3L3QqDwJhsXLlxA48aNy/S6M2CWSBRmiURgjkgUV8lSXFwcACAiIqLU9ZzqDBcRkQj6+KswvDcPDxw9CbcuD6Lm7kVwb1QXKSkpiPvrLPz9/Ys1T15eXiUeMO/2OhEREVFZsOEiItUw5eQhdcEGpC3dAm31QOTPfA01hw2Au7c3gMLmKTw83OnOVBEREZF6seGykTOf1iTXoZY5yc5ClmVkf3UUyVMWw3g7FVXHDkHAW0Oh8fa0Wk+NZ6uYJRKFWSIRmCMSRU1ZYsNlBzZd5AhJkhy+eQv9n4KLV5A0YQFyvz8B7x7tUO3zBdA1rKN0WRWCWSJRmCUSgTkiUdSWJfVsSQXibeHJEUXvU8Mc2c+UnYvU6PVIW7YVbjWDUWPDbHj36lip9imzRKIwSyQCc0SiqC1LbLhsxJs6kgjmO++Q7WRZRva+HwqnDyaloeq4FxEw9gVovDzu/WYVYpZIFGaJRGCOSBQ1ZYkNFxG5jIILV5A08f9PH+zVEdVmvQVd/VpKl0VERER0V2y4iMjpmbJykDp/PdJWbINb7eqosekjVOnZQemyiIiIiO6JDRcROS1ZlpG99zskTV0KU0oaqr47DAFjhkDjWTmnDxIREZHrYcNFRE6p4O9LhdMHj56Ed+9OqDZzLHT3cfogERERuRY2XDaSJEkVd0sh5UiSBHd3d6XLcFqmrBykzFuL9E93QFe3Jmps+RhVerRTuiynxCyRKMwSicAckShqyxIbLiJyCrIsI2vPESRHLYUpPROB770K/zcGc/ogERERuTQ2XHbgc7jIEbIsw2g0QqvVMkf/X8GfCbg9cQHyjv2GKn27IGjmWOjq1lC6LKfHLJEozBKJwByRKGrLEhsuG/E5XCSCyWSCVqtVugzFmbJykPLxWqSv3AFdvZqouW0evLu1Vbosl8IskSjMEonAHJEoasoSGy4iqnCyLCNr1zdInroUpsxsBEYOR8DrgyF5qGe+NhERERHAhouIKlj++XgkTYhG3s9/oEq/RwqnD9YJUbosIiIionLBhouIKoQxIwupc9cgfdUu6BrURs0d8+H9aBulyyIiIiIqV2y4bKSGC/dIeW5uledHT5ZlZO08jOSpy2DKzkXgpJEIGD0IkrtO6dJUoTJlicoXs0QiMEckipqypJ4tqUBsusgRlelZbvlnLyBpwgLk/XIKVfp3Q7UZb8KtVnWly1KNypQlKl/MEonAHJEoassSGy478Lbw5AhZlmEymaDRaFSbI2N6JlI/WoP0Nbuha1QHNT+PhneXh5QuS3UqQ5aoYjBLJAJzRKKoLUtsuGzE28KTCEajERqNRukyhJNNJmRuP4SUGcthys5D4ORRCBj1LKcPliO1ZokqHrNEIjBHJIqassSGi4iEyI/7B0mR85F34gx8nu6OoOlvwq1msNJlERERESmKDRcROcSYnomU2auQsXYPdPfXQ63dC+HVqbXSZRERERE5BTZcRGQX2WRC5tYDSJ65AnJuPoKmvg7/kQMh6XhYISIiIjLjb0Y2UsOFe6Q8V5+TnH/qL9yeuAD5J87A55nHEDTtDbjVqKZ0WZWSq2eJnAezRCIwRySKmrLEhssObLrIEZIkueyzJYxpmUj5MAYZ6/bCPaw+au1ZBK+OrZQuq9Jy5SyRc2GWSATmiERRW5bUsyVELsTVHi0gm0zI3LwfybNWQM7XI2j6m/AfPoDTB52Aq2WJnBezRCIwRySKmrLE35ZsJMuyqgJAFU+WZej1euh0OpfIUf6pv3A7cj7yT56Dz7M9ERT1OqcPOglXyxI5L2aJRGCOSBS1ZYkNFxGVyJiSXjh9cP0XcG/aALW+WAKv9i2ULouIiIjIpbDhIiIrssmEzE37kDxrJaA3IGjWW/B/9SlIKppLTURERFRR+BsUEVnk/X4eSZHRyP/9PHwGPY6gqNFwCwlSuiwiIiIil8WGi4gKpw9+sBIZG76E+wONUGvfUni1ba50WUREREQujw2XjdRw4R4pT6fTKV0CAEA2GpGxcR9SPlgJGE2o9uHb8Hu5P6cPuhBnyRK5PmaJRGCOSBQ1ZYm/VdmBTRc5wlnyk3fybOH0wVN/wff5PgicMhpuwVWVLots4CxZItfHLJEIzBGJorYsseGyA28LT46QZRlGoxFarVaRHBmTUpE861NkbvoK7hH3o/b+5fBsE17hdZDjlM4SqQezRCIwRySK2rLEhstGsiwrXQKpgMlkglarrdDvKRuNyFj3BVJmxwCyjGofvQu/l56EVMF1kFhKZInUiVkiEZgjEkVNWWLDRVQJ5J04g9sTolFw+m/4vtAXQZNfg7Yapw8SERERlTc2XEQqZridipSZK5C5ZT/cm4ei9oEV8HyomdJlEREREVUabLiIVEg2GJDx2V6kzFkFSBKqffwf+L34BKcPEhEREVUwNlw2UsOFe6S88pyTnHv8NJIio1Fw7iJ8h/ZD0PujoA0KKLfvR8pSy/x2Uh6zRCIwRySKmrLEhssObLrIEZIklctBxHArBSkzliNz20F4tGyC2gdXwLP1A8K/DzmP8soSVT7MEonAHJEoassSGy478Lbw5AhZli0ZEpEj2WBA+po9SP1oNaDVIPiT9+D7Ql9OH6wERGeJKi9miURgjkgUtWWJDZeNeFt4EsFgMAh5gnpu7CkkTYxGwbl4+A17EoGTRkIb6C+gQnIVorJExCyRCMwRiaKmLLHhInJBhpvJSJ6xHFnbD8GjdVPUPrwSni2bKF0WEREREd2BDReRC5ENBqSv2oXUuWsAdzcER0fCd0gfSBqN0qURERERUQnYcBG5iNyf/0DShGgU/JkAv5efQuDEEdBW9VO6LCIiIiIqBRsuG6nhwj1Sni05MtxIQvK0Zcj6/Gt4PNQMdb6OgUeLsHKsjlwJj0kkCrNEIjBHJIqassSGyw5qCgBVPEmSynQRqKw3IH3VTqR8tAaSpzuCF06A73O9OX2QLMqaJaJ7YZZIBOaIRFFblthwETmh3J9+x+0J0dD/ffn/pg8G+CpdFhERERHZiA2XHfgcLnKELMswGAxwc3MrliPD9dtInroUWbuPwLNNOEK+WQWPiPsVqpScXWlZIrIFs0QiMEckitqyxIbLRnwOF4lwZ45kvQHpK3cg5eO10Hh7InjxJPgO6sXpg3RPPCaRKMwSicAckShqyhIbLiKF5fx4EkkToqG/kAj/4QNQNfJVaP05fZCIiIhIDdhwESnE8O8tJE9dhuy938KzbXOEHJkGj/DGSpdFRERERAKx4SKqYHKBHhnLtiBjwSZoqnih+tL34fNsL1XMUSYiIiIia2y4bMRfiskROd+fQNLEBdAnXIPfiAEI/O+r0Pr5KF0WuTA13TaXlMUskQjMEYmipiyx4bIDmy6yleHaTSRNWYLsL7+HZ/sWCFk9Ax4PNFK6LHJxPBaRKMwSicAckShqyxIbLjvwtvBUVnJ+AdKWb0Nq9HpofLxRffkUVBnQAyaTiTkih8myDKPRCK1WyyyRQ5glEoE5IlHUliU2XDZS0y0qqXzlfPe/wumDl/6F/6iBCHzvFWh8q0CWZZhMJmi1WqVLJBVglkgUZolEYI5IFDVliQ0XkWD6qzeRPHkxsr/6AZ4dW6HGZx/AvUkDpcsiIiIiIgWw4SISRM4vQNrSrUhdsB4af19UXzkVPk91V8WpcCIiIiKyDxsuIgGyv/kFyZMWQp94Hf6vPYvA8a9A4+OtdFlEREREpDA2XDbi2QoqSn/lOpImL0LOgWPw6twaNTZ8CPewe08fVMucZFIes0SiMEskAnNEoqgpSxqlCyjq8uXLiIqKQv/+/fHAAw+gX79+Ja63Y8cO9OrVCxEREXjyySfx3XffFVsnMzMTkyZNwsMPP4xWrVrhrbfewq1bt4TUyaaLTHn5SPnkMyR2HIr8P/5CSMx01Px8QZmaLUmSVHPXHVIWs0SiMEskAnNEoqgtS07VcP3zzz/44YcfcN9996FRo5KfUfTVV19hypQp6N27N2JiYtCyZUuMGTMGf/zxh9V648aNw08//YRp06Zh3rx5SEhIwMiRI2EwGByuk3cqrNyyD/+MxM4vIXXeZ/Af+Szq/bwRPk91K/NBwXyXQuaIHMUskSjMEonAHJEoasuSU00p7NatG3r06AEAmDBhAs6cOVNsnUWLFqFv374YN24cAKBdu3b4+++/sXTpUsTExAAAfv/9dxw7dgyrV69Gp06dAAANGjRAnz59cPjwYfTp08fuGtXywZPt9Jf/RdL7i5Bz6Cd4PfIQam7+CO7332fXWAaDQVVPUCflMEskCrNEIjBHJIqasuRUZ7g0mtLLSUxMxKVLl9C7d2+r1/v06YPY2FgUFBQAAI4ePQo/Pz907NjRsk7Dhg3RtGlTHD16VHzhpGqm3HykfLwWiZ1eRH7cPwhZPQM1d8y3u9kiIiIiosrDqc5w3Ut8fDyAwrNVRTVq1Ah6vR6JiYlo1KgR4uPj0aBBg2JTvBo2bGgZwxElneWSJOmuZ7/MdZS2vLzey3EdGzfn8M9ImrQQhuu3EfD6YAS8MwyaKl5W69j6fc2vOdu2KjWuM9bkKuMWfc1ZauK4zl+Tq2XJGWtytXErqiZZli3/qW0fuvpn42rj2pKliqqprO8tiUs1XOnp6QAAPz8/q9fNX5uXZ2RkwNfXt9j7/f39S5ymaCu9Xm/VzGk0Gri5uVmW3cnd3R0AYDQaYTKZrJa5ublBkiSYTCYYjUarZeZxZVkucVzzadaSxtVqtdBqtZBludh1a5IkWd5rMBiKBaa8xi3LtgLF92F5jWveVkmSim2r4dK/SJu6FLnf/AKvR9ug2obZ0DWuCyMAo15fpnGBkveh+Uyu6H1o/mxKqkmJfVh03JK2Vel8l7YPKzLfgP3HiKL/IJR0fSqPEY6Na97Wu+W7tG115BhRXvuwtGNEUTxGqOcYUdH70LwujxH33lZXO0ZU9D40b5v5fc56jDA3hPfiUg2XszAH427L7qZokO+k0WjuOqWy6Adv67j3eq85yBU5bmnbCpS+D0WPa/4czdtqyslD2qJNSF+6BdrgqghZOwvefTqX+sNk62dT9C82atyHJSltW5XKtyM/c+X12dh6jJBlGUajkceIchzX0XzfbVwzZ9mH5iyJHhfgMcKWcQHX/j3izl8+nSXf5TluZTlGlOe4Je1Dc5bMy5z1GFGWZgtwsYbL398fQOEt34ODgy2vZ2RkWC338/PDjRs3ir0/PT3dso69JEkq9YB2r/fas8yR93Lcso0LADkHjyFp8mIYbiQh4M3nUXXci9B4e97zfbZ+39Iy5Mi4ZVnmjOM6Y02uMm55Z8mR93Jc563J1bLkyHs5bsXWJEmS5WycyHFFLXPGcZ2xJmcY15YsVVRNtr63KKe6aca9NGzYEACKXYcVHx8PnU6HunXrWtZLSEgodgowISHBMgaRmT7+Km48/1/cGDYJ7vffh7pH1yFo0sgyNVtERERERKVxqYarbt26qF+/Pg4ePGj1+v79+9G+fXtLJ9ylSxekp6cjNjbWsk5CQgLOnTuHLl26OFyHLRfJkfMy5eQh+cMYXOk8DAV/X0KN9R+ixpa5cG9Ut1y/r3muMXNEjmKWSBRmiURgjkgUtWXJqaYU5ubm4ocffgAAXLt2DVlZWZbm6uGHH0ZgYCDGjh2L8ePHo169emjbti3279+P06dPY+PGjZZxWrVqhU6dOmHSpEmIjIyEh4cHoqOjERYWhp49ezpUo1o++MpMlmVkf3UUyVMWw3g7FVXHDkHAW0Mr9IwWc0SiMEskCrNEIjBHJIqasiTJTrQ1V69eRffu3Utctn79erRt2xYAsGPHDsTExODff/9FgwYN8O6776Jr165W62dmZmL27Nn4+uuvYTAY0KlTJ0yePBkhISF21xcXFwdZlhEREWHTvE1yHgUXryBp4kLkfvc/ePdoh2ofvA1dwzoVWoP5rzal3XyFqCyYJRKFWSIRmCMSxVWyFBcXBwCIiIgodT2naricHRsu12XKzkVq9HqkLd8GtxrVUO2Dt+Ddq6Min6OrHETI+TFLJAqzRCIwRySKq2SprA2XU00pJBJNlmVk7/uhcPpgUhqqvj0UAWNfgMbLQ+nSiIiIiKgSYMNlI2fusslawYUrSJq4ALnfn4B3r46oNust6OrXUrosAKU/14HIFswSicIskQjMEYmipiypZ0sqEJsu52bKykHq/PVIW7ENbrWro8amj1ClZwely7Io+iA/IkcwSyQKs0QiMEckitqyxIbLDnc+SZ2cgyzLyN77HZKmLoUpJQ1V3x2GgDFDoPF0rumDsizDZDLZ9IRyopIwSyQKs0QiMEckitqyxIbLRrzHiHMq+PtS4fTBoyfh3bsTqs0cC919zjF9sCRGoxEajUs9Bo+cFLNEojBLJAJzRKKoKUtsuMilmbJykDJvLdI/3QFd3ZqoseVjVOnRTumyiIiIiIgAsOEiFyXLMrL2HEFy1FKY0jMR+N6r8H9jsNNNHyQiIiKiyo0NF7mcgj8TcHviAuQd+w1V+nZB0Myx0NWtoXRZRERERETFsOGykRou3HNVpqwcpHy8Fukrd0BXryZqbpsH725tlS7LLmqZk0zKY5ZIFGaJRGCOSBQ1ZYkNlx3YdFUsWZaRtesbJE9dClNmNgIjhyPg9cGQPNyVLs0ukiSp6tkSpBxmiURhlkgE5ohEUVuW1LMlFYi3ha84+efjkTQhGnk//4Eq/R4pnD5YJ0TpshxS9E6XzBE5glkiUZglEoE5IlHUliU2XDbibeErhjEjC6lz1yB91S7oGtRGzR3z4f1oG6XLEkav10On0yldBqkAs0SiMEskAnNEoqgpS2y4yKnIsoysnYeRPHUZTNm5CJw0EgGjB0FyV8cPHBERERFVLmy4yGnkn72ApAkLkPfLKVTp3w3VZrwJt1rVlS6LiIiIiMhubLhIccb0TKR+tAbpa3ZD17AOan4eDe8uDyldFhERERGRw9hw2UgNF+45C1mWkbX9EJKnL4MpOw+Bk0chYNSzlWL6IHNEojBLJAqzRCIwRySKmrLEhssOagqAUvLPXEBS5Hzk/S8OPk93R9D0N+FWM1jpsiqEJEmquQiUlMUskSjMEonAHJEoassSGy6qUMb0TKTMXoWMtXugu78eau1eCK9OrZUui4iIiIioXLDhsgOfw2U72WRC5tYDSJ65AnJuPoKmvg7/kQMh6SpfBGVZhsFggJubG3NEDmGWSBRmiURgjkgUtWWp8v226yA+h8t2+af+wu2JC5B/4gx8nnkMQdPegFuNakqXpSjmiERhlkgUZolEYI5IFDVliQ0XlRtjWiZSPoxBxrq9cA+rj1p7FsGrYyulyyIiIiIiqjBsuEg42WRC5ub9SJ61AnK+HkHT34T/8AGVcvogEREREVVu/A2YhMo/9RduR85H/slz8Hm2J4KiXq/00weJiIiIqPJiw2UjNVy4Vx6MKemF0wfXfwH3pg1Q64sl8GrfQumynJabG3/0SAxmiURhlkgE5ohEUVOW1LMlFYhN1/+RTSZkbtqH5FkrAb0BQTPHwn/405BU9EMimiRJzBAJwSyRKMwSicAckShqyxJ/K7YDbwtfKO/380iKjEb+7+fhM+hxBEWNhltIkNJlOT1ZlmEymaDRaJgjcgizRKIwSyQCc0SiqC1LbLhspKZbVNrLmJKOlA9WImPDl3B/oBFq7VsKr7bNlS7LpRiNRmg0GqXLIBVglkgUZolEYI5IFDVliQ0XlZlsNCJj4z6kfLASMJpQ7cO34fdyf04fJCIiIiK6C/6mTGWSd/Js4fTBU3/B9/k+CJwyGm7BVZUui4iIiIjIqbHholIZk1KRPOtTZG76Cu4R96P2/uXwbBOudFlERERERC6BDZeN1HDhXlnIRiMy1n2BlNkxgCyj2kfvwu+lJyFptUqXpgpqmZNMymOWSBRmiURgjkgUNWWJDZcd1N505Z04g9sTolFw+m/4vtAXQZNfg7Yapw+KIkmSqp4tQcphlkgUZolEYI5IFLVlST1bUoHUelt4w+1UpMxcgcwt++HePBS1D6yA50PNlC5LdYre6VKNOaKKwyyRKMwSicAckShqyxIbLhup8bbwstGIjM/2Fk4flCRU+/g/8HvxCU4fLEd6vR46nU7pMkgFmCUShVkiEZgjEkVNWWLDVcnl/S8OtyOjUXD2AnyH9kPQ+6OgDQpQuiwiIiIiIlVgw1VJGW6lIGXGcmRuOwiPlk1Q++AKeLZ+QOmyiIiIiIhUhQ1XJSMbDEhfswepH60GtJr/1979x0VV53scfw8I/kAGYZew9UeAmZqk0Or6o1VDt23Ryh6lN7fSas3QVlvx4Srq6qbSPsx7vYVmm7+upblb2tImiq6lRqZ2yx4UV+9WBmmoK0LiDD9EYZj7Rxce4aCAnPHMHF/Pv+IMnPMZH+++8nbOD0Uu+71CHxnF6YMAAACAF1C4riPnD36u4jkv6OL/5ss+4T5FzJ2kwIgws8cCAAAALIvC1Uw2m83v7pZSXfidvlv0Z5Vt/oda395LnXatVpv4nmaPdd2y2WwKCgryuxzB95AlGIUswQjkCEaxWpYoXBbmrq6WY22GSpb+lxTcSpEvzFbowyNls9CD5PyVVRYQmI8swShkCUYgRzCKlbJE4boK/vAcrvMHPlNx6gu6+MU3sj8+WhFzJikw3G72WND3+XG5XAoMDPT5HMG3kSUYhSzBCOQIRrFalihczeTrz+GqPl2s7xa+rLK33lXrfr3V+d01at23h9lj4RI1NTUK5EYlMABZglHIEoxAjmAUK2WJwmUR7qpqOda+pbNL18vWOkiR6akKHZfE6YMAAACAiShcFnB+f46KUl9Q1VfHZX/8fkXMeVKBHULNHgsAAAC47lG4/Fj1v4r03R9Xquzt3WrTP05R761V69u6mz0WAAAAgP9H4WomX7hwz11VLcfqLTr77+sV0K6NIlfMVei/3c3pg37EKuckw3xkCUYhSzACOYJRrJQlCtdVMLN0Vez7VMWpL6jq6wKFTXxA4bN/o8AwTh/0JzabzVKLCMxDlmAUsgQjkCMYxWpZonBdBTNuC1996oyKF6xU+Tt71GZAH0Xtflat426+pjPAGG63uy5DvvCJKfwXWYJRyBKMQI5gFKtlicLVTNf6tvDui1U698pmlSx7TQEhbXXDynlqP/ZuS4TvelZdXa2goCCzx4AFkCUYhSzBCOQIRrFSlihcPqwi+9D3pw9+c1JhTz6g8Fm/UaC9vdljAQAAAGgiCpcPqj5ZqOL5L6k88321GdhXUesWqfWt3cweCwAAAEAzUbh8iPvCRZ3785sqeWGDAtq30w1/nq/2D97F6YMAAACAn6JwNZO3yk/F3o9VPOdFVR07pbCnxiji908oIDTEK8eC+QK4hT8MQpZgFLIEI5AjGMVKWaJwXQUjS1fViUJ994cVKt+erTZ3JKjjq88puGeMYfuH77HZbGrViv/10HJkCUYhSzACOYJRrJYl67wTP+O+cFHnVr6hkhc3KCAsVDes/qPa3z+C0wcBAAAAC6FwNdMPnwtwtcrf+0jfzU1XVcG/FJY8VhEzn1BA+3YGTglf5na7VVVVpaCgIAo2WoQswShkCUYgRzCK1bJE4bqGqr79l4r/sFwVOz5U2yG3q+PGPym4B6cPAgAAAFZF4boGaiov6NzKv+rcixsVEB6mqDULFTI60RKNHQAAAMDlUbi8rHzXARXPW67qE6fVYco4hc+YwOmDAAAAwHWCwuUlVcdPqfgPK1Sx80O1HdZPN/7leQV3v8nssQAAAABcQxSuZmrsNMCa8xd07qW/6Nzy1xUQ0UFR6xYp5N47OX0Q9QQFBZk9AiyCLMEoZAlGIEcwipWyZOnClZeXp7S0NOXk5CgkJESjR4/W9OnTFRwc3KL9Xq48lf9jv4rnpav6VJE6THlI4TMeU0BI2xYdC9ZD+YZRyBKMQpZgBHIEo1gtS5YtXA6HQ4899piio6O1YsUKFRYWasmSJaqsrNSCBQtatO9Lbwtf9c1JFc9LV8W7B9X2zv668Y3/UPDNXVv6FmBRbrdbLpdLgYGBlltQcG2RJRiFLMEI5AhGsVqWLFu43njjDZWXl+ull15Shw4dJEkul0sLFy5UcnKyoqKirmq/bre77r9rKip1bvnrOvfSXxUYGa6o9WkKGTXUEsGAd9XU1CgwMNDsMWABZAlGIUswAjmCUayUpQCzB/CWDz74QIMGDaorW5KUlJSkmpoa7d+/v0X7drvdKt+xTwVDJqhkxV8U9vQ4ddn/utrfM4yyBQAAAKCOZT/hys/P14MPPlhvm91uV2RkpPLz8696v7aTZ3T6T7N0fvd/q92Igbpx8zIFd+vS0nEBAAAAWJBlC5fT6ZTdbvfYHhYWJofDcVX7rKqqkn1imsojwlS1OFkVg/uouOKc9D/nWjYsrjuXXgcIXC2yBKOQJRiBHMEo/pClixcvNmlGyxYub7DZbHJu+09L3aYS5vD1BQT+gyzBKGQJRiBHMIo/ZMlms13fhctut6u0tNRju8PhUFhY2FXtMyEhoaVjAQAAALiOWPamGbGxsR7XapWWlqqoqEixsbEmTQUAAADgemLZwjV06FAdOHBATqezbtvOnTsVEBCgO+64w8TJAAAAAFwvbO4fPljKQhwOh0aNGqWYmBglJyfXPfj43nvvbfGDjwEAAACgKSxbuCQpLy9PixcvVk5OjkJCQjR69GilpKQoODjY7NEAAAAAXAcsXbgAAAAAwEyWvYYLAAAAAMxG4QIAAAAAL6FwAQAAAICXULgAAAAAwEsoXAAAAADgJRQuAAAAAPASChcAAAAAeEkrswfwB3l5eUpLS6v3AOXp06fzAGU0S0ZGhubMmeOxfdKkSZo5c6YJE8EfHD9+XOvWrdPnn3+uo0ePKjY2Vtu2bfP4vi1btmjt2rU6deqUYmJilJKSosTERBMmhq9qSpbGjx+vjz/+2ONns7Ky1K1bt2s1KnzYjh07tHXrVh05ckROp1M33XSTxo8frwcffFA2m63u+1iT0JimZMkqaxKFqxEOh0OPPfaYoqOjtWLFChUWFmrJkiWqrKzUggULzB4Pfmjt2rUKDQ2t+zoqKsrEaeDrjh49quzsbPXt21c1NTVq6Fn127dv1/z58zV58mQNHDhQWVlZmjp1qjZt2qT4+PhrPzR8UlOyJEm33367Zs+eXW9b586dr8WI8AOvvvqqOnXqpNTUVIWHh+vAgQOaP3++Tp8+ralTp0piTULTNCVLkjXWJJv7cisuJEmrVq3SK6+8or1796pDhw6SpDfffFMLFy7U3r17+WUZTVb7CdfBgwcVERFh9jjwEzU1NQoI+P7s79TUVB0+fNjjU4m7775bcXFxWrZsWd22cePGKTQ0VGvWrLmm88J3NSVL48ePV7t27bRq1SozRoQfOHv2rMffYfPnz1dWVpY++eQTBQQEsCahSZqSJausSVzD1YgPPvhAgwYNqitbkpSUlKSamhrt37/fvMEAXBdqf0G+nIKCAh07dkxJSUn1to8cOVIHDx7UxYsXvTke/EhjWQKaoqF/MOzVq5fKyspUUVHBmoQmayxLVsLq24j8/HzFxsbW22a32xUZGan8/HyTpoI/u+eee9SrVy+NGDFCq1atksvlMnsk+LHadSgmJqbe9m7duqmqqkoFBQVmjAU/9vHHHys+Pl633XabHn30UX3yySdmjwQf9+mnnyoqKkrt27dnTUKL/DBLtaywJnENVyOcTqfsdrvH9rCwMDkcDhMmgr+KjIzUtGnT1LdvX9lsNu3Zs0cvvviiCgsLuR4QV612Hbp0nar9mnUKzdG/f3+NHj1a0dHROnPmjNatW6cnnnhCGzduVEJCgtnjwQcdOnRIWVlZddfYsCbhal2aJck6axKFC7hGhgwZoiFDhtR9/fOf/1ytW7fWa6+9psmTJ+uGG24wcToAkJ555pl6X995552655579PLLL3PtDTycPn1aKSkpGjBggCZMmGD2OPBjl8uSVdYkTilshN1uV2lpqcd2h8OhsLAwEyaClSQlJcnlcumf//yn2aPAT9WuQ5euU06ns97rwNVo166dhg0bpiNHjpg9CnyM0+nUpEmT1KFDB61YsaLuGkHWJDTX5bLUEH9dkyhcjYiNjfW4Vqu0tFRFRUUe13YBwLVWuw5duk7l5+crKChIXbp0MWMsABZWWVmp5ORklZaWejzqhDUJzXGlLFkJhasRQ4cO1YEDB+r+ZUaSdu7cqYCAAN1xxx0mTgYryMrKUmBgoG699VazR4Gf6tKli6Kjo7Vz585627OysjRo0CAe0I4Wqaio0Pvvv6/bbrvN7FHgI6qrqzV9+nTl5+dr7dq1Ho/HYU1CUzWWpYb465rENVyNGDdunDZu3Kjf/va3Sk5OVmFhoZYuXapx48bxDC40y8SJEzVgwAD16NFDkrR7925t3rxZEyZMUGRkpMnTwVedP39e2dnZkqSTJ0+qrKys7heZn/3sZ4qIiNC0adM0c+ZMde3aVQMGDFBWVpZyc3P1+uuvmzk6fExjWar9peeuu+5Sp06ddObMGa1fv15FRUVKT083c3T4kNrnkKampqqsrEyfffZZ3Wu33nqrgoODWZPQJI1lKTc31zJrEg8+boK8vDwtXrxYOTk5CgkJ0ejRo5WSksK/0qBZ0tLStG/fPp0+fVo1NTWKjo7W2LFjNX78eNlsNrPHg486ceKERowY0eBrGzZs0IABAyRJW7Zs0Zo1a3Tq1CnFxMRoxowZSkxMvJajwsc1lqWOHTtq0aJF+vLLL3Xu3Dm1bdtWCQkJmjp1qvr06XONp4WvGj58uE6ePNnga7t371bnzp0lsSahcY1lyeVyWWZNonABAAAAgJdwDRcAAAAAeAmFCwAAAAC8hMIFAAAAAF5C4QIAAAAAL6FwAQAAAICXULgAAAAAwEsoXAAAAADgJRQuAAAaUF5erkGDBmnr1q1mj1KnpKRE8fHxys7ONnsUAEATUbgAAH5n06ZN6tGjh8aOHeu1Y2zYsEEhISEaNWqU147RXOHh4RozZozS09PNHgUA0EQULgCA38nMzFRQUJByc3N1/Phxw/dfVVWlDRs2aOzYsQoMDDR8/y3x61//WkeOHNHBgwfNHgUA0AQULgCAXykoKFBOTo6mTJmioKAgZWZmGn6M999/X2fPnlVSUpLh+26pbt266ZZbbtHbb79t9igAgCagcAEA/EpmZqYCAwP10EMPafDgwQ0WruXLl6tnz54enwLNnz9fcXFx+uKLL654jPfee0+dOnVS165d621PTU1VQkKCTp06peTkZCUkJGjIkCHatGmTJOnLL7/UhAkTFB8fr8TERI/ZMjIy1KNHDx06dEhpaWkaOHCg+vXrpwULFujixYtyOp2aNWuW+vfvr/79+2vp0qVyu90e8w0ePFh79+5t8DUAgG+hcAEA/EpmZqb69eunH//4x0pKStKxY8eUm5tb73umTJmiXr16ad68eSorK5Mk7du3T5s3b9bTTz+tnj17XvEYOTk56t27d4OvuVwuTZo0SR07dtTMmTPVqVMnLVq0SBkZGXryyScVFxenmTNnKiQkRLNnz1ZBQYHHPtLS0nTs2DFNmzZNw4cP15tvvqn09HRNnjxZLpdLKSkp+ulPf6p169bpnXfe8fj53r17y+l06ujRo039YwMAmITCBQDwG4cPH1Z+fr5GjhwpSfrFL37R4GmFQUFBev7553XmzBktWbJETqdT8+bNU1xcnJ566qkrHqO6ulrffvutOnfu3ODrFy5c0H333aeFCxfqkUce0erVq9WmTRvNnTtXc+bM0axZs/Too49q+fLlcrlc+vvf/+6xjx/96Edas2aNHnnkES1dulQJCQlat26dunfvrmXLlunhhx/WypUr1bFjR/3tb3/z+PkuXbpIkr7++uum/LEBAExE4QIA+I3MzEy1atVKv/zlLyVJoaGhGjJkiLKysuRyuep97y233KJnnnlGW7Zs0cSJE1VSUqLnn39erVq1uuIxHA6H3G637Hb7Zb/nh3dHtNvtiomJUdu2betd8xUbGyu73d7gJ1xjxoyRzWar+7pPnz5yu90aM2ZM3bbAwEDFxcU1+PO1s5WUlFzxvQAAzEfhAgD4BZfLpe3bt2vgwIGKiIio2z5y5EgVFxc3eNe+iRMnqmfPnsrNzdXUqVN18803N/l4l7s+qnXr1vWOL31f/Dp27FivRNVudzqdHvv4yU9+4vF9knTjjTd6bHc4HJed8dLjAQB8D4ULAOAXPvroIxUVFXncOXD48OFq06ZNgzfPKCgoqLtt/FdffdWk44SFhclmszVYlCRd9jbxl9veUHELCGj4r9/Lbb9UbQkLDw9v0vcDAMxD4QIA+IXaZ2/ddddd9baHhIRo2LBhevfdd1VZWVm3vaamRqmpqWrfvr0mT56sbdu2adeuXY0ep1WrVuratatOnDhh+HswSu1s3bp1M3kSAEBjKFwAAJ9XWVmpXbt2afDgwQoLC/N4/Ve/+pXKy8u1Z8+eum3r169XTk6OFi1apN/97ndKSEjQs88+q7NnzzZ6vPj4eB0+fNjQ92CkI0eOKDQ0VN27dzd7FABAI6585TAAAD5gz549Ki8vlyStXr3a4/Xz589LkrZu3aqRI0cqLy9P6enpeuCBBzR8+HBJ0pIlS3T//fdr4cKFSk9Pv+LxRowYoXfeeUfffPONYmJiDH43LXfgwAElJiZyDRcA+AEKFwDA523dulWSlJ2drezs7Mt+34cffqiSkhLNnj1b4eHhmjt3bt1r0dHRmjFjhp577jllZWXV3Vq+IYmJiQoPD9eOHTv09NNPG/dGDJCXl6evvvqq3nsDAPgum5vH1AMA4GHlypXKyMjQrl27LntDDDM899xzOnTokDIyMviECwD8ANdwAQDQgMcff1wVFRXavn272aPUKSkp0VtvvaXp06dTtgDAT/AJFwAAAAB4CZ9wAQAAAICXULgAAAAAwEsoXAAAAADgJRQuAAAAAPASChcAAAAAeAmFCwAAAAC8hMIFAAAAAF5C4QIAAAAAL6FwAQAAAICXULgAAAAAwEsoXAAAAADgJf8HrXBCbSSEOOUAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -496,47 +551,41 @@ } ], "source": [ - "\n", - "sns.set_theme(style=\"whitegrid\")\n", - "\n", "plt.figure(figsize=(10,6))\n", "\n", "# Seaborn scatter\n", - "sns.scatterplot(\n", - " data=data,\n", - " x=\"este\",\n", - " y=\"F\",\n", - " s=7\n", + "sns.scatterplot( data=data,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", ")\n", "\n", "# Barre d’errore\n", "plt.errorbar(\n", - " data[\"este\"],\n", - " data[\"F\"],\n", - " xerr=data[\"ueste\"],\n", - " yerr=data[\"uF\"],\n", - " fmt=\"none\",\n", - " ecolor=\"gray\",\n", - " elinewidth=1,\n", - " capsize=3,\n", - " alpha=0.7\n", + " data[\"x\"],\n", + " data[\"y\"],\n", + " xerr=data[\"ux\"],\n", + " yerr=data[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", ")\n", "\n", "# Linea di regressione\n", - "xfit = np.linspace(0, data[\"este\"].max(), 200)\n", - "yfit = intercetta + pente * xfit\n", - "\n", + "xfit = np.linspace(0, data[\"x\"].max(), 200)\n", + "yfit = Bols + Aols * xfit\n", "\n", "plt.plot(\n", - " xfit,\n", - " yfit,\n", - " color=\"crimson\",\n", - " linewidth=1,\n", - " zorder=10,\n", - " label=\"Fit lineare\"\n", + " xfit,\n", + " yfit,\n", + " color=\"crimson\",\n", + " linewidth=1,\n", + " zorder=10,\n", + " label=\"Fit lineare OLS\"\n", ")\n", "\n", - "\n", "plt.xlim(left=0)\n", "plt.ylim(bottom=0)\n", "\n", @@ -547,175 +596,71 @@ "plt.legend()\n", "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", "\n", - "plt.show()\n" + "plt.show()" ] }, { "cell_type": "code", - "execution_count": 314, - "id": "986ff4a6", + "execution_count": 11, + "id": "1d42b009", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Chi^2 = 12.06747\n", - "Gradi di libertà = 4\n", - "Chi^2 ridotto = 3.01687\n", - "Probabilità P(0 → chi^2) = 0.98314\n" + "Chi² = 6.07430\n", + "GdL = 4\n", + "Chi² rid = 1.51858\n", + "P(0, chi²)= 0.80633\n", + "\n", + "\n", + "############################################################\n", + "capiamo quale dato sta contribuendo maggiormente\n", + "0 1.582374\n", + "1 0.516368\n", + "2 0.051305\n", + "3 1.091998\n", + "4 2.022571\n", + "5 0.809686\n", + "dtype: float64\n" ] } ], "source": [ - "F_fit = intercetta + pente * data[\"este\"]\n", - "sigma = np.sqrt(data[\"uF\"]**2 + (pente * data[\"ueste\"])**2)\n", + "F_fit = Bols + Aols * data[\"x\"]\n", + "sigma = np.sqrt(data[\"uy\"]**2 + (Aols * data[\"ux\"])**2)\n", "\n", - "chi2_val = np.sum( ((data[\"F\"] - F_fit) / sigma)**2 )\n", + "chi2_val = np.sum( ((data[\"y\"] - F_fit) / sigma)**2 )\n", "\n", "N = len(data)\n", "nu = N - 2\n", "\n", "chi2_red = chi2_val / nu\n", - "P = chi2.cdf(chi2_val, df=nu)\n", + "Pols = chi2.cdf(chi2_val, df=nu)\n", "\n", "\n", - "print(f\"Chi^2 = {chi2_val:.5f}\")\n", - "print(f\"Gradi di libertà = {nu}\")\n", - "print(f\"Chi^2 ridotto = {chi2_red:.5f}\")\n", - "print(f\"Probabilità P(0 → chi^2) = {P:.5f}\")\n" + "print(f\"Chi² = {chi2_val:.5f}\")\n", + "print(f\"GdL = {nu}\")\n", + "print(f\"Chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {Pols:.5f}\")\n", + "print(\"\\n\\n\" + \"#\"*60)\n", + "print(\"capiamo quale dato sta contribuendo maggiormente\")\n", + "print(((data[\"y\"] - F_fit) / sigma)**2)" ] }, { - "cell_type": "code", - "execution_count": 315, - "id": "ef0817f4", + "cell_type": "markdown", + "id": "9f26f65e", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0 3.156242\n", - "1 1.028093\n", - "2 0.102207\n", - "3 2.169242\n", - "4 4.023666\n", - "5 1.588019\n", - "dtype: float64" - ] - }, - "execution_count": 315, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ - "((data[\"F\"] - F_fit) / sigma)**2" + "### Regressione lineare Carpi" ] }, { "cell_type": "code", - "execution_count": 316, - "id": "cebe6742", - "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", - "
esteuesteFuF
08.56350.112055196.3814930.140116
116.70500.087912389.9846200.144268
225.06800.096418587.5755200.151069
38.14150.070514193.6031270.140076
416.50450.080872391.1940270.144302
58.36300.041382197.5909000.140134
\n", - "
" - ], - "text/plain": [ - " este ueste F uF\n", - "0 8.5635 0.112055 196.381493 0.140116\n", - "1 16.7050 0.087912 389.984620 0.144268\n", - "2 25.0680 0.096418 587.575520 0.151069\n", - "3 8.1415 0.070514 193.603127 0.140076\n", - "4 16.5045 0.080872 391.194027 0.144302\n", - "5 8.3630 0.041382 197.590900 0.140134" - ] - }, - "execution_count": 316, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "data" - ] - }, - { - "cell_type": "code", - "execution_count": 317, - "id": "2d4b7144", + "execution_count": 12, + "id": "6a910226", "metadata": {}, "outputs": [ { @@ -723,10 +668,10 @@ "output_type": "stream", "text": [ "Ax + B : \n", - "A = 23.39301 +- 0.12446\n", - "B = 1.80115 +- 1.59592\n", - "cov_AB = -0.180473\n", - "p-value chi² = 0.9614234\n" + "AC = 23.3952 +- 0.1756\n", + "BC = 1.8060 +- 2.2463\n", + "cov_ABC = -0.358328\n", + "P(0, chi²)= 0.7197\n" ] } ], @@ -780,62 +725,23 @@ " return A, B, sigma_A, sigma_B, cov_AB, chi\n", "\n", "\n", - "A, B, sA, sB, covAB, chi = reg_lin(data[\"este\"], data[\"F\"], data[\"ueste\"], data[\"uF\"])\n", + "AC, BC, uAC, uBC, covABC, chiC = reg_lin(data[\"x\"], data[\"y\"], data[\"ux\"], data[\"uy\"])\n", "print(\"Ax + B : \")\n", - "print(f\"A = {A:.5f} +- {sA:.5f}\")\n", - "print(f\"B = {B:.5f} +- {sB:.5f}\")\n", - "print(f\"cov_AB = {covAB:.6f}\")\n", - "print(f\"p-value chi² = {chi:.7f}\")\n", - "\n", - "\n" + "print(f\"AC = {AC:.4f} +- {uAC:.4f}\")\n", + "print(f\"BC = {BC:.4f} +- {uBC:.4f}\")\n", + "print(f\"cov_ABC = {covABC:.6f}\")\n", + "print(f\"P(0, chi²)= {chiC:.4f}\")\n" ] }, { "cell_type": "code", - "execution_count": 318, - "id": "32e9948f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Chi^2 = 10.17614\n", - "Gradi di libertà = 4\n", - "Chi^2 ridotto = 2.54404\n", - "Probabilità P(0 → chi^2) = 0.96244\n" - ] - } - ], - "source": [ - "F_fit = B + A * data[\"este\"]\n", - "sigma = np.sqrt(data[\"uF\"]**2 + (A * data[\"ueste\"])**2)\n", - "\n", - "\n", - "chi2_val = np.sum( ((data[\"F\"] - F_fit) / sigma)**2 )\n", - "\n", - "N = len(data)\n", - "nu = N - 2\n", - "\n", - "chi2_red = chi2_val / nu\n", - "P = chi2.cdf(chi2_val, df=nu)\n", - "\n", - "\n", - "print(f\"Chi^2 = {chi2_val:.5f}\")\n", - "print(f\"Gradi di libertà = {nu}\")\n", - "print(f\"Chi^2 ridotto = {chi2_red:.5f}\")\n", - "print(f\"Probabilità P(0 → chi^2) = {P:.5f}\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": 319, - "id": "e2407a04", + "execution_count": 13, + "id": "b49ec5a3", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -845,44 +751,41 @@ } ], "source": [ - "\n", - "sns.set_theme(style=\"whitegrid\")\n", - "\n", "plt.figure(figsize=(10,6))\n", "\n", "# Seaborn scatter\n", "sns.scatterplot(\n", - " data=data,\n", - " x=\"este\",\n", - " y=\"F\",\n", - " s=7\n", + " data=data,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", ")\n", "\n", "# Barre d’errore\n", "plt.errorbar(\n", - " data[\"este\"],\n", - " data[\"F\"],\n", - " xerr=data[\"ueste\"],\n", - " yerr=data[\"uF\"],\n", - " fmt=\"none\",\n", - " ecolor=\"gray\",\n", - " elinewidth=1,\n", - " capsize=3,\n", - " alpha=0.7\n", + " data[\"x\"],\n", + " data[\"y\"],\n", + " xerr=data[\"ux\"],\n", + " yerr=data[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", ")\n", "\n", "# Linea di regressione\n", - "xfit = np.linspace(0, data[\"este\"].max(), 200)\n", - "yfit = B + A * xfit\n", + "xfit = np.linspace(0, data[\"x\"].max(), 200)\n", + "yfit = BC + AC * xfit\n", "\n", "\n", "plt.plot(\n", - " xfit,\n", - " yfit,\n", - " color=\"crimson\",\n", - " linewidth=1,\n", - " zorder=10,\n", - " label=\"Fit lineare\"\n", + " xfit,\n", + " yfit,\n", + " color=\"crimson\",\n", + " linewidth=1,\n", + " zorder=10,\n", + " label=\"Fit lineare Carpi\"\n", ")\n", "\n", "\n", @@ -901,7 +804,449 @@ }, { "cell_type": "code", - "execution_count": 320, + "execution_count": 14, + "id": "538ddb98", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chi² = 5.10905\n", + "GdL = 4\n", + "Chi² rid = 1.27726\n", + "P(0, chi²)= 0.72371\n", + "\n", + "\n", + "############################################################\n", + "capiamo quale dato sta contribuendo maggiormente\n", + "0 2.404581\n", + "1 0.797907\n", + "2 0.040448\n", + "3 0.332099\n", + "4 1.521888\n", + "5 0.012127\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "F_fit = BC + AC * data[\"x\"]\n", + "sigma = np.sqrt(data[\"uy\"]**2 + (AC * data[\"ux\"])**2)\n", + "\n", + "\n", + "chi2_val = np.sum( ((data[\"y\"] - F_fit) / sigma)**2 )\n", + "\n", + "N = len(data)\n", + "nu = N - 2\n", + "\n", + "chi2_red = chi2_val / nu\n", + "PC = chi2.cdf(chi2_val, df=nu)\n", + "\n", + "\n", + "print(f\"Chi² = {chi2_val:.5f}\")\n", + "print(f\"GdL = {nu}\")\n", + "print(f\"Chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {PC:.5f}\")\n", + "print(\"\\n\\n\" + \"#\"*60)\n", + "print(\"capiamo quale dato sta contribuendo maggiormente\")\n", + "print(((data[\"y\"] - F_fit) / sigma)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "4ec42f61", + "metadata": {}, + "source": [ + "### Regressione lineare pesata Yorkfit " + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "c7f54cf3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AY = 23.4018867 ± 0.1749174\n", + "BY = 1.7284277 ± 2.2381063\n", + "cov_ABY = -0.35570868522503013\n", + "chi² = 5.10759\n", + "chi² rid = 1.27690\n", + "P(0, chi²)= 0.72357\n" + ] + } + ], + "source": [ + "def york_fit(x, y, sx, sy, max_iter=50, tol=1e-15):\n", + " # Pesi iniziali\n", + " wx = 1 / sx**2\n", + " wy = 1 / sy**2\n", + "\n", + " # Stima iniziale della pendenza (OLS y|x)\n", + " A = np.cov(x, y, aweights=wy)[0,1] / np.cov(x, x, aweights=wy)[0,1]\n", + "\n", + " for _ in range(max_iter):\n", + " A_old = A\n", + "\n", + " # 1) Pesi combinati\n", + " Wi = (wx * wy) / (A**2 * wy + wx)\n", + "\n", + " # 2) x e y pesati (eq. 10)\n", + " X_bar = np.sum(Wi * x) / np.sum(Wi)\n", + " Y_bar = np.sum(Wi * y) / np.sum(Wi)\n", + "\n", + " # 3) Variabili centrate\n", + " Ui = x - X_bar\n", + " Vi = y - Y_bar\n", + "\n", + " # 4) beta\n", + " beta_i = Wi * (Ui / wy + A * Vi / wx)\n", + "\n", + " # 5) Aggiornamento pendenza\n", + " A = np.sum(Wi * beta_i * Vi) / np.sum(Wi * beta_i * Ui)\n", + "\n", + " # Convergenza\n", + " if abs(A - A_old) < tol:\n", + " break\n", + "\n", + " # 6) Intercetta\n", + " B = Y_bar - A * X_bar\n", + "\n", + " # S = somma Wi (xi - x)**2\n", + " S = np.sum(Wi * Ui**2)\n", + "\n", + " sA = np.sqrt(1 / S)\n", + " sB = np.sqrt(1 / np.sum(Wi) + X_bar**2 * sA**2)\n", + "\n", + " # cov(A,B)\n", + " cov_AB = -X_bar * sA**2\n", + "\n", + " # CHI QUADRATO\n", + " chi2 = np.sum(Wi * (Vi - A * Ui)**2)\n", + " dof = len(x) - 2\n", + " chi2_red = chi2 / dof\n", + "\n", + " return A, B, sA, sB, cov_AB, chi2, chi2_red\n", + "\n", + "AY, BY, uAY, uBY, cov_ABY, chi2_val, chi2_red = york_fit(data.x, data.y, data.ux, data.uy)\n", + "PY = chi2.cdf(chi2_val, df=nu)\n", + "\n", + "\n", + "print(f\"AY = {AY:.7f} ± {uAY:.7f}\")\n", + "print(f\"BY = {BY:.7f} ± {uBY:.7f}\")\n", + "print(f\"cov_ABY = {cov_ABY}\")\n", + "print(f\"chi² = {chi2_val:.5f}\")\n", + "print(f\"chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {PY:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "fc824066", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "# Seaborn scatter\n", + "sns.scatterplot( data=data,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", + ")\n", + "\n", + "# Barre d’errore\n", + "plt.errorbar(\n", + " data[\"x\"],\n", + " data[\"y\"],\n", + " xerr=data[\"ux\"],\n", + " yerr=data[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", + ")\n", + "\n", + "# Linea di regressione\n", + "xfit = np.linspace(0, data[\"x\"].max(), 200)\n", + "yfit = BY + AY * xfit\n", + "\n", + "plt.plot(\n", + " xfit,\n", + " yfit,\n", + " color=\"crimson\",\n", + " linewidth=1,\n", + " zorder=10,\n", + " label=\"Fit lineare York\"\n", + ")\n", + "\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "\n", + "\n", + "plt.xlabel(\"Δx (mm)\")\n", + "plt.ylabel(\"Forza F (mN)\")\n", + "plt.title(\"Legge di Hooke — punti permutati con errorbar\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "15a6fec5", + "metadata": {}, + "source": [ + "## Raccolta finale dei dati caso statico" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "1203e1a0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RISULTATI senza ERRORE STRUMENTALE INCLUSO:\n", + "Media pesata K = 23.52083 ± 0.07342\n", + "\n", + "RISULTATI REGRESSIONE OLS:\n", + "Aols = 23.46517 ± 0.22969\n", + "Bols = 0.13548 ± 3.49525\n", + "P(0, chi²)= 0.80633\n", + "\n", + "RISULTATI REGRESSIONE Carpi:\n", + "Ac = 23.39521 ± 0.17556\n", + "Bc = 1.80604 ± 2.24633\n", + "P(0, chi²)= 0.72371\n", + "\n", + "RISULTATI REGRESSIONE York:\n", + "Ay = 23.40189 ± 0.17492\n", + "By = 1.72843 ± 2.23811\n", + "P(0, chi²)= 0.72357\n" + ] + } + ], + "source": [ + "print(\"RISULTATI senza ERRORE STRUMENTALE INCLUSO:\")\n", + "print(f\"Media pesata K = {media:.5f} ± {uA:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE OLS:\")\n", + "print(f\"Aols = {Aols:.5f} ± {uAols:.5f}\")\n", + "print(f\"Bols = {Bols:.5f} ± {uBols:.5f}\")\n", + "print(f\"P(0, chi²)= {Pols:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE Carpi:\")\n", + "print(f\"Ac = {AC:.5f} ± {uAC:.5f}\")\n", + "print(f\"Bc = {BC:.5f} ± {uBC:.5f}\")\n", + "print(f\"P(0, chi²)= {PC:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE York:\")\n", + "print(f\"Ay = {AY:.5f} ± {uAY:.5f}\")\n", + "print(f\"By = {BY:.5f} ± {uBY:.5f}\")\n", + "print(f\"P(0, chi²)= {PY:.5f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "2dcfef24", + "metadata": {}, + "source": [ + "## Aggiunta degli errori strumentali" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "aaa95426", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "u_strum_m = 0.004082\n", + "u_strum_Dx = 0.020000\n", + "uF_strum = 0.072065\n", + "uK_strum = 0.462991\n" + ] + } + ], + "source": [ + "res_b = 0.01\n", + "res_c = 0.02\n", + "\n", + "# Incertezza strumentale su una differenza: res/sqrt(12) * sqrt(2) = res/sqrt(6)\n", + "u_strum_m = res_b / np.sqrt(6)\n", + "u_strum_Dx = res_c #incertezza delle misure di C DISCUTERE\n", + "\n", + "# Massimo tra campionario e strumentale, punto per punto\n", + "ueste_strum = np.maximum(ueste, u_strum_Dx)\n", + "umasse_strum = np.maximum(umasse, u_strum_m)\n", + "\n", + "# Worst-case scalare: prendi il massimo anche di ueste_strum\n", + "uF_strum = np.max(np.sqrt( (g * umasse_strum)**2 + (masse * ug)**2 ))\n", + "uDx_strum = np.max(ueste_strum)\n", + "\n", + "uK_strum = np.max(np.sqrt( (1/este)**2 * uF_strum**2 + (F/este**2)**2 * uDx_strum**2 ))\n", + "\n", + "print(f\"u_strum_m = {u_strum_m:.6f}\")\n", + "print(f\"u_strum_Dx = {u_strum_Dx:.6f}\")\n", + "print(f\"uF_strum = {uF_strum:.6f}\")\n", + "print(f\"uK_strum = {uK_strum:.6f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "23be271e", + "metadata": {}, + "source": [ + "### Propapazione dell'errore strumentale max" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "a9f2a9fc", + "metadata": {}, + "outputs": [], + "source": [ + "# Media pesata\n", + "uA_fin = np.sqrt(uA**2 + uK_strum**2)\n", + "\n", + "# OLS\n", + "uAols_fin = np.sqrt(uAols**2 + uK_strum**2)\n", + "uBols_fin = np.sqrt(uBols**2 + uK_strum**2)\n", + "\n", + "# Carpi\n", + "uAC_fin = np.sqrt(uAC**2 + uK_strum**2)\n", + "uBC_fin = np.sqrt(uBC**2 + uK_strum**2)\n", + "\n", + "# York\n", + "uAY_fin = np.sqrt(uAY**2 + uK_strum**2)\n", + "uBY_fin = np.sqrt(uBY**2 + uK_strum**2)\n", + "\n", + "\n", + "# Nuovo uy e ux per ricalcolare i chi^2\n", + "uy_fin = np.sqrt(data[\"uy\"]**2 + uF_strum**2)\n", + "ux_fin = np.sqrt(data[\"ux\"]**2 + uDx_strum**2)\n", + "\n", + "# OLS\n", + "F_fit_ols = Bols + Aols * data[\"x\"]\n", + "sigma_ols = np.sqrt(uy_fin**2 + (Aols * ux_fin)**2)\n", + "chi2_ols = np.sum(((data[\"y\"] - F_fit_ols) / sigma_ols)**2)\n", + "GdL = len(data) - 2\n", + "\n", + "# Carpi\n", + "F_fit_c = BC + AC * data[\"x\"]\n", + "sigma_c = np.sqrt(uy_fin**2 + (AC * ux_fin)**2)\n", + "chi2_c = np.sum(((data[\"y\"] - F_fit_c) / sigma_c)**2)\n", + "\n", + "# York\n", + "F_fit_y = BY + AY * data[\"x\"]\n", + "sigma_y_ = np.sqrt(uy_fin**2 + (AY * ux_fin)**2)\n", + "chi2_y = np.sum(((data[\"y\"] - F_fit_y) / sigma_y_)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "41baee7a", + "metadata": {}, + "source": [ + "## Risultati della propagazione dell'errore strumentale massimo" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "c95874fb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RISULTATI CON ERRORE STRUMENTALE INCLUSO:\n", + "Media pesata K = 23.52083 ± 0.46878\n", + "\n", + "RISULTATI REGRESSIONE OLS:\n", + "Aols = 23.46517 ± 0.51683\n", + "Bols = 0.13548 ± 3.52578\n", + "Chi² OLS = 2.10939 | rid = 0.52735 | P = 0.28435\n", + "\n", + "RISULTATI REGRESSIONE Carpi:\n", + "AC = 23.39521 ± 0.49516\n", + "BC = 1.80604 ± 2.29355\n", + "Chi² Carpi = 2.14027 | rid = 0.53507 | P = 0.29002\n", + "\n", + "RISULTATI REGRESSIONE York:\n", + "AY = 23.40189 ± 0.49493\n", + "BY = 1.72843 ± 2.28549\n", + "Chi² York = 2.13715 | rid = 0.53429 | P = 0.28945\n" + ] + } + ], + "source": [ + "print(\"RISULTATI CON ERRORE STRUMENTALE INCLUSO:\")\n", + "print(f\"Media pesata K = {media:.5f} ± {uA_fin:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE OLS:\")\n", + "print(f\"Aols = {Aols:.5f} ± {uAols_fin:.5f}\")\n", + "print(f\"Bols = {Bols:.5f} ± {uBols_fin:.5f}\")\n", + "print(f\"Chi² OLS = {chi2_ols:.5f} | rid = {chi2_ols/GdL:.5f}\" f\" | P = {chi2.cdf(chi2_ols, df=GdL):.5f}\")\n", + "\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE Carpi:\")\n", + "print(f\"AC = {AC:.5f} ± {uAC_fin:.5f}\")\n", + "print(f\"BC = {BC:.5f} ± {uBC_fin:.5f}\")\n", + "print(f\"Chi² Carpi = {chi2_c:.5f} | rid = {chi2_c/GdL:.5f}\" f\" | P = {chi2.cdf(chi2_c, df=GdL):.5f}\")\n", + "\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE York:\")\n", + "print(f\"AY = {AY:.5f} ± {uAY_fin:.5f}\")\n", + "print(f\"BY = {BY:.5f} ± {uBY_fin:.5f}\")\n", + "print(f\"Chi² York = {chi2_y:.5f} | rid = {chi2_y/GdL:.5f}\" f\" | P = {chi2.cdf(chi2_y, df=GdL):.5f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "fb210b61", + "metadata": {}, + "source": [ + "# Dinamica Sonar\n", + "Qui specifico la formula perché non è così ovvia:\n", + "- $M_{eq} = M + \\frac m 3$\n", + "- $\\omega = \\frac{2\\pi}{T} \\quad \\Rightarrow \\quad T = \\frac{2\\pi}{\\omega}$\n", + "- A: coefficiente della regressione lineare $A = \\frac{T^2}{M_{eq}}$\n", + "- $K = \\frac{4 \\pi^2}{A}$\n", + "\n", + "Nota: nelle formule comparirà un $/1000$, questo serve a riportare il valore in unità di misura standard: N/m" + ] + }, + { + "cell_type": "code", + "execution_count": 21, "id": "95dde99f", "metadata": {}, "outputs": [ @@ -914,30 +1259,152 @@ "2 0.258983\n", "3 0.291654\n", "Name: w, dtype: float64\n", - "0 0.000034\n", - "1 0.000045\n", - "2 0.000017\n", - "3 0.000010\n", + "0 0.000048\n", + "1 0.000063\n", + "2 0.000024\n", + "3 0.000004\n", "dtype: float64\n" ] } ], "source": [ - "## Dinamica davvero\n", - "\n", "Meq = df.m + ( m_mol / 3 )\n", "uMeq = np.sqrt( df.um**2 + um_mol**2 / 9 )\n", "\n", "T2 = ( 2 * np.pi / df.w )**2\n", - "uT2 = np.sqrt( (8*np.pi**2 / df.w**3)**2 * df.uw**2 ) \n", + "uT2 = np.sqrt( (8*np.pi**2 / df.w**3)**2 * df.uw**2 )\n", + "\n", "print(T2)\n", "print(uT2)" ] }, + { + "cell_type": "markdown", + "id": "7bd743d4", + "metadata": {}, + "source": [ + "## Calcolo dei K e media pesata\n", + "- Calcolo della Meq (massa equivalente)\n", + "- Calcolo della media pesata sui K" + ] + }, { "cell_type": "code", - "execution_count": 321, - "id": "1bb433f0", + "execution_count": 22, + "id": "8c9f5b44", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 23.081695\n", + "1 23.283699\n", + "2 23.402492\n", + "3 23.508497\n", + "dtype: float64\n", + "0 0.005798\n", + "1 0.006535\n", + "2 0.002247\n", + "3 0.000662\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "Ad = T2 / Meq\n", + "uAd = np.sqrt( (1/Meq)**2 * uT2**2 + (T2/Meq**2)**2 * uMeq**2 )\n", + "\n", + "Kd = 4 * np.pi**2 / Ad\n", + "uKd = np.sqrt( (4 * np.pi**2 / Ad**2)**2 * uAd**2 )\n", + "\n", + "Kd /= 1000\n", + "uKd /= 1000\n", + "\n", + "print(Kd)\n", + "print(uKd)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "0d899f17", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "K-medio: 23.49313065421719\n", + "sigmaC: 0.0006281179024013275\n" + ] + } + ], + "source": [ + "def mediaPesata(x, ux, dim = 0):\n", + " x_arr = x.to_numpy() if isinstance(x, (pd.Series, pd.DataFrame)) else np.asarray(x)\n", + " sigma_arr = ux.to_numpy() if isinstance(ux, (pd.Series, pd.DataFrame)) else np.asarray(ux)\n", + "\n", + " w = 1.0 / (sigma_arr ** 2)\n", + "\n", + " num = np.nansum(w * x_arr, axis=dim)\n", + " den = np.nansum(w, axis=dim)\n", + "\n", + " media = num / den\n", + " sigma = np.sqrt(1.0 / den)\n", + "\n", + " return media, sigma\n", + "\n", + "KdM, uKdM = mediaPesata(Kd, uKd)\n", + "print(\"K-medio:\", KdM)\n", + "print(\"sigmaC: \", uKdM)" + ] + }, + { + "cell_type": "markdown", + "id": "6741544e", + "metadata": {}, + "source": [ + "## Analisi con regressioni e grafici\n", + "Ogni blocco ha:\n", + "- Regressione\n", + "- grafico\n", + "- chi^2\n", + "\n", + "Nota: Ax + B" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "4b4c2682", + "metadata": {}, + "outputs": [], + "source": [ + "sns.set_theme(style=\"whitegrid\")\n", + "\n", + "datad = pd.DataFrame({\n", + " \"x\": Meq,\n", + " \"ux\": uMeq,\n", + " \"y\": T2,\n", + " \"uy\": uT2\n", + "})" + ] + }, + { + "cell_type": "markdown", + "id": "ad203fbd", + "metadata": {}, + "source": [ + "### Regressione lineare \"OLS\"\n", + "\n", + "Non tiene conto dei nostri errori, un risultato puro e semplice" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "90d191d5", "metadata": {}, "outputs": [ { @@ -946,11 +1413,11 @@ "text": [ " OLS Regression Results \n", "==============================================================================\n", - "Dep. Variable: tmp2 R-squared: 1.000\n", + "Dep. Variable: y R-squared: 1.000\n", "Model: OLS Adj. R-squared: 1.000\n", "Method: Least Squares F-statistic: 4.713e+05\n", - "Date: Thu, 02 Apr 2026 Prob (F-statistic): 2.12e-06\n", - "Time: 19:05:39 Log-Likelihood: 32.343\n", + "Date: Sun, 05 Apr 2026 Prob (F-statistic): 2.12e-06\n", + "Time: 21:57:06 Log-Likelihood: 32.343\n", "No. Observations: 4 AIC: -60.69\n", "Df Residuals: 2 BIC: -61.91\n", "Df Model: 1 \n", @@ -958,24 +1425,24 @@ "==============================================================================\n", " coef std err t P>|t| [0.025 0.975]\n", "------------------------------------------------------------------------------\n", - "const 0.0023 0.000 6.364 0.024 0.001 0.004\n", - "masse 0.0016 2.36e-06 686.488 0.000 0.002 0.002\n", + "const 0.0101 0.000 29.329 0.001 0.009 0.012\n", + "x 0.0016 2.36e-06 686.488 0.000 0.002 0.002\n", "==============================================================================\n", "Omnibus: nan Durbin-Watson: 2.752\n", "Prob(Omnibus): nan Jarque-Bera (JB): 0.628\n", "Skew: -0.880 Prob(JB): 0.730\n", - "Kurtosis: 2.180 Cond. No. 1.01e+03\n", + "Kurtosis: 2.180 Cond. No. 948.\n", "==============================================================================\n", "\n", "Notes:\n", "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", - "[2] The condition number is large, 1.01e+03. This might indicate that there are\n", - "strong multicollinearity or other numerical problems.\n", "\n", "RISULTATI REGRESSIONE:\n", - "B) = 0.0016212 ± 0.0000024\n", - "intercetta = 0.00226 ± 0.00035\n", - "R² = 1.00000\n" + "Adols = 0.00162 ± 0.00000\n", + "Bdols = 0.01007 ± 0.00034\n", + "R² = 1.00000\n", + "Kdols = 24.35158 ± 0.03547\n", + "KBdols = 3.92000 ± 0.13366\n" ] }, { @@ -988,65 +1455,43 @@ } ], "source": [ - "dfDin = pd.DataFrame({\n", - " \"masse\": Meq,\n", - " \"umasse\": uMeq,\n", - " \"tmp2\": T2,\n", - " \"utmp2\": uT2\n", - "})\n", - "\n", - "\n", - "X = sm.add_constant(dfDin[\"masse\"])\n", - "model = sm.OLS(dfDin[\"tmp2\"], X).fit()\n", + "X = sm.add_constant(datad[\"x\"])\n", + "model = sm.OLS(datad[\"y\"], X).fit()\n", "\n", "print(model.summary())\n", "\n", "# Estrazione parametri\n", - "intercetta = model.params[\"const\"]\n", - "pente = model.params[\"masse\"]\n", - "u_intercetta = model.bse[\"const\"]\n", - "u_pente = model.bse[\"masse\"]\n", + "Bdols = model.params[\"const\"]\n", + "Adols = model.params[\"x\"]\n", + "uBdols = model.bse[\"const\"]\n", + "uAdols = model.bse[\"x\"]\n", "R2 = model.rsquared\n", "\n", + "# Calcolo del K dai parametri\n", + "Kdols = (2*np.pi)**2 / Adols / 1000\n", + "uKdols = np.sqrt( (4*np.pi**2 / Adols**2)**2 * uAdols**2 ) / 1000\n", + "KBdols = (2*np.pi)**2 / Bdols / 1000\n", + "uKBdols = np.sqrt( (4*np.pi**2 / Bdols**2)**2 * uBdols**2 ) / 1000\n", + "\n", + "\n", + "\n", "print(\"\\nRISULTATI REGRESSIONE:\")\n", - "print(f\"B) = {pente:.7f} ± {u_pente:.7f}\")\n", - "print(f\"intercetta = {intercetta:.5f} ± {u_intercetta:.5f}\")\n", - "print(f\"R² = {R2:.5f}\")" + "print(f\"Adols = {Adols:.5f} ± {uAdols:.5f}\")\n", + "print(f\"Bdols = {Bdols:.5f} ± {uBdols:.5f}\")\n", + "print(f\"R² = {R2:.5f}\")\n", + "print(f\"Kdols = {Kdols:.5f} ± {uKdols:.5f}\")\n", + "print(f\"KBdols = {KBdols:.5f} ± {uKBdols:.5f}\")" ] }, { "cell_type": "code", - "execution_count": 322, - "id": "67d16b84", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "K : 24.351577653480003\n", - "uK : 1.1291301601259716e-05\n" - ] - } - ], - "source": [ - "\n", - "K = (2*np.pi)**2 / pente / 1000\n", - "uK = np.sqrt( (4*np.pi / pente**2)**2 * u_pente**2 ) / 1e6\n", - "\n", - "print(\"K : \", K)\n", - "print(\"uK :\", uK)" - ] - }, - { - "cell_type": "code", - "execution_count": 323, + "execution_count": 26, "id": "a0ba5c8d", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1056,63 +1501,110 @@ } ], "source": [ - "sns.set_theme(style=\"whitegrid\")\n", - "\n", "plt.figure(figsize=(10,6))\n", "\n", "# Seaborn scatter\n", - "sns.scatterplot(\n", - " data=dfDin,\n", - " x=\"masse\",\n", - " y=\"tmp2\",\n", - " s=7\n", + "sns.scatterplot( data=datad,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", ")\n", "\n", "# Barre d’errore\n", "plt.errorbar(\n", - " dfDin[\"masse\"],\n", - " dfDin[\"tmp2\"],\n", - " xerr=dfDin[\"umasse\"],\n", - " yerr=dfDin[\"utmp2\"],\n", - " fmt=\"none\",\n", - " ecolor=\"gray\",\n", - " elinewidth=1,\n", - " capsize=3,\n", - " alpha=0.7\n", + " datad[\"x\"],\n", + " datad[\"y\"],\n", + " xerr=datad[\"ux\"],\n", + " yerr=datad[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", ")\n", "\n", "# Linea di regressione\n", - "xfit = np.linspace(0, dfDin[\"masse\"].max(), 200)\n", - "yfit = intercetta + pente * xfit\n", - "\n", + "xfit = np.linspace(0, datad[\"x\"].max(), 200)\n", + "yfit = Bdols + Adols * xfit\n", "\n", "plt.plot(\n", - " xfit,\n", - " yfit,\n", - " color=\"crimson\",\n", - " linewidth=1,\n", - " zorder=10,\n", - " label=\"Fit lineare\"\n", + " xfit, yfit,\n", + " color=\"crimson\", linewidth=1, zorder=10, label=\"Fit lineare OLS\"\n", ")\n", "\n", - "\n", "plt.xlim(left=0)\n", "plt.ylim(bottom=0)\n", "\n", "\n", "plt.xlabel(\"Meq (g)\")\n", "plt.ylabel(\"T^2 (s^2)\")\n", - "plt.title(\"Legge di Stocazzo — punti permutati con errorbar\")\n", + "plt.title(\"Legge di ??\")\n", "plt.legend()\n", "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", "\n", - "plt.show()\n" + "plt.show()" ] }, { "cell_type": "code", - "execution_count": 324, - "id": "859f2337", + "execution_count": 27, + "id": "3c7c05e6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chi² = 17.93044\n", + "GdL = 2\n", + "Chi² rid = 8.96522\n", + "P(0, chi²)= 0.99987\n", + "\n", + "\n", + "############################################################\n", + "capiamo quale dato sta contribuendo maggiormente\n", + "0 2.355712\n", + "1 3.797810\n", + "2 0.836627\n", + "3 10.940294\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "F_fit = Bdols + Adols * datad[\"x\"]\n", + "sigma = np.sqrt(datad[\"uy\"]**2 + (Adols * datad[\"ux\"])**2)\n", + "\n", + "chi2_val = np.sum( ((datad[\"y\"] - F_fit) / sigma)**2 )\n", + "\n", + "N = len(datad)\n", + "nu = N - 2\n", + "\n", + "chi2_red = chi2_val / nu\n", + "Pdols = chi2.cdf(chi2_val, df=nu)\n", + "\n", + "\n", + "print(f\"Chi² = {chi2_val:.5f}\")\n", + "print(f\"GdL = {nu}\")\n", + "print(f\"Chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {Pdols:.5f}\")\n", + "print(\"\\n\\n\" + \"#\"*60)\n", + "print(\"capiamo quale dato sta contribuendo maggiormente\")\n", + "print(((datad[\"y\"] - F_fit) / sigma)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "a1296a66", + "metadata": {}, + "source": [ + "### Regressione lineare Carpi" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "698e3c48", "metadata": {}, "outputs": [ { @@ -1120,10 +1612,12 @@ "output_type": "stream", "text": [ "Ax + B : \n", - "A = 0.0016212 +- 0.0000007\n", - "B = 0.0022701 +- 0.0001084\n", - "cov_AB = -0.000000\n", - "p-value chi² = 0.9964\n" + "AdC = 0.00162 ± 0.00000\n", + "BdC = 0.01007 ± 0.00011\n", + "cov_ABdC = -0.000000\n", + "P(0,chi²)= 0.96181\n", + "KdC = 24.34964 ± 0.00989\n", + "KBdC = 3.91877 ± 0.04363\n" ] } ], @@ -1177,139 +1671,1290 @@ " return A, B, sigma_A, sigma_B, cov_AB, chi\n", "\n", "\n", - "A, B, sA, sB, covAB, chi = reg_lin(dfDin[\"masse\"], dfDin[\"tmp2\"], dfDin[\"umasse\"], dfDin[\"utmp2\"])\n", + "AdC, BdC, uAdC, uBdC, covABdC, chidC = reg_lin(datad[\"x\"], datad[\"y\"], datad[\"ux\"], datad[\"uy\"])\n", + "\n", + "# Calcolo del K dai parametri\n", + "KdC = (2*np.pi)**2 / AdC / 1000\n", + "uKdC = np.sqrt( (4*np.pi**2 / AdC**2)**2 * uAdC**2 ) / 1000\n", + "KBdC = (2*np.pi)**2 / BdC / 1000\n", + "uKBdC = np.sqrt( (4*np.pi**2 / BdC**2)**2 * uBdC**2 ) / 1000\n", + "\n", "print(\"Ax + B : \")\n", - "print(f\"A = {A:.7f} +- {sA:.7f}\")\n", - "print(f\"B = {B:.7f} +- {sB:.7f}\")\n", - "print(f\"cov_AB = {covAB:.6f}\")\n", - "print(f\"p-value chi² = {chi:.4f}\")\n", - "\n", - "\n" + "print(f\"AdC = {AdC:.5f} ± {uAdC:.5f}\")\n", + "print(f\"BdC = {BdC:.5f} ± {uBdC:.5f}\")\n", + "print(f\"cov_ABdC = {covABdC:.6f}\")\n", + "print(f\"P(0,chi²)= {chidC:.5f}\")\n", + "print(f\"KdC = {KdC:.5f} ± {uKdC:.5f}\")\n", + "print(f\"KBdC = {KBdC:.5f} ± {uKBdC:.5f}\")\n" ] }, { "cell_type": "code", - "execution_count": 325, - "id": "fef04a85", + "execution_count": 29, + "id": "a0ab8534", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "# Seaborn scatter\n", + "sns.scatterplot(\n", + " data=datad,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", + ")\n", + "\n", + "# Barre d’errore\n", + "plt.errorbar(\n", + " datad[\"x\"],\n", + " datad[\"y\"],\n", + " xerr=datad[\"ux\"],\n", + " yerr=datad[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", + ")\n", + "\n", + "# Linea di regressione\n", + "xfit = np.linspace(0, datad[\"x\"].max(), 200)\n", + "yfit = BdC + AdC * xfit\n", + "\n", + "\n", + "plt.plot(\n", + " xfit,\n", + " yfit,\n", + " color=\"crimson\",\n", + " linewidth=1,\n", + " zorder=10,\n", + " label=\"Fit lineare Carpi\"\n", + ")\n", + "\n", + "\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "\n", + "\n", + "plt.xlabel(\"Meq (g)\")\n", + "plt.ylabel(\"T^2 (s^2)\")\n", + "plt.title(\"Legge di ??\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "12bb0479", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "K nostro: 24.351020780404994\n", - "uK nostro: 0.24912686265195058\n" + "Chi² = 6.53021\n", + "GdL = 2\n", + "Chi² rid = 3.26511\n", + "P(0, chi²)= 0.96181\n", + "\n", + "\n", + "############################################################\n", + "capiamo quale dato sta contribuendo maggiormente\n", + "0 1.366019\n", + "1 5.154390\n", + "2 0.000185\n", + "3 0.009620\n", + "dtype: float64\n" ] } ], "source": [ - "K = (2*np.pi)**2 / A / 1000\n", - "uK = np.sqrt( (4*np.pi / A**2)**2 * uA**2 ) / 1e6\n", - "\n", - "print(\"K nostro: \", K)\n", - "print(\"uK nostro:\", uK)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 326, - "id": "5b191469", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Chi^2 = 11.23106\n", - "Gradi di libertà = 2\n", - "Chi^2 ridotto = 5.61553\n", - "Probabilità P(0 → chi^2) = 0.99636\n" - ] - } - ], - "source": [ - "F_fit = B + A * dfDin[\"masse\"]\n", - "sigma = np.sqrt(dfDin[\"utmp2\"]**2 + (A * dfDin[\"umasse\"])**2)\n", + "F_fit = BdC + AdC * datad[\"x\"]\n", + "sigma = np.sqrt(datad[\"uy\"]**2 + (AdC * datad[\"ux\"])**2)\n", "\n", "\n", - "chi2_val = np.sum( ((dfDin[\"tmp2\"] - F_fit) / sigma)**2 )\n", + "chi2_val = np.sum( ((datad[\"y\"] - F_fit) / sigma)**2 )\n", "\n", - "N = len(dfDin)\n", + "N = len(datad)\n", "nu = N - 2\n", "\n", "chi2_red = chi2_val / nu\n", - "P = chi2.cdf(chi2_val, df=nu)\n", + "PdC = chi2.cdf(chi2_val, df=nu)\n", "\n", "\n", - "print(f\"Chi^2 = {chi2_val:.5f}\")\n", - "print(f\"Gradi di libertà = {nu}\")\n", - "print(f\"Chi^2 ridotto = {chi2_red:.5f}\")\n", - "print(f\"Probabilità P(0 → chi^2) = {P:.5f}\")\n" + "print(f\"Chi² = {chi2_val:.5f}\")\n", + "print(f\"GdL = {nu}\")\n", + "print(f\"Chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {PdC:.5f}\")\n", + "print(\"\\n\\n\" + \"#\"*60)\n", + "print(\"capiamo quale dato sta contribuendo maggiormente\")\n", + "print(((datad[\"y\"] - F_fit) / sigma)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "f3bf75d6", + "metadata": {}, + "source": [ + "### Regressione lineare pesata Yorkfit" ] }, { "cell_type": "code", - "execution_count": 327, - "id": "9ac14621", + "execution_count": 31, + "id": "385db415", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "=== REGRESSIONE T^2 vs Meq (ODR/York) ===\n", - "A = 0.0016212 ± 0.0000016\n", - "B = 0.0022701 ± 0.0002570\n", - "cov(A,B) = -7.179292197278527e-11\n", - "chi² = 11.23106\n", - "chi² ridotto = 5.61553\n", - "\n", - "=== COSTANTE ELASTICA DINAMICA DA ODR ===\n", - "k = 24.351014 ± 0.023754 N/m\n" + "AdY = 0.0016213 ± 0.0000007\n", + "BdY = 0.0100742 ± 0.0001122\n", + "cov_ABdY = -7.370190718014568e-11\n", + "chi² = 6.53021\n", + "chi² rid = 3.26511\n", + "P(0, chi²)= 0.96181\n", + "KdY = 24.34964 ± 0.00989\n", + "KBdY = 3.91877 ± 0.04363\n" ] } ], "source": [ + "def york_fit(x, y, sx, sy, max_iter=50, tol=1e-15):\n", + " # Pesi iniziali\n", + " wx = 1 / sx**2\n", + " wy = 1 / sy**2\n", "\n", - "# --- DATI DELLA TUA ANALISI ---\n", - "x = Meq.to_numpy() # masse equivalenti\n", - "sx = uMeq.to_numpy() # errori masse equivalenti\n", - "y = T2.to_numpy() # T^2\n", - "sy = uT2.to_numpy() # errori di T^2\n", + " # Stima iniziale della pendenza (OLS y|x)\n", + " A = np.cov(x, y, aweights=wy)[0,1] / np.cov(x, x, aweights=wy)[0,1]\n", "\n", - "# --- MODELLO LINEARE ---\n", - "def f(B, x):\n", - " return B[0] * x + B[1] # A*x + B\n", + " for _ in range(max_iter):\n", + " A_old = A\n", "\n", - "# Pacchetto \"RealData\" con errori anche su x\n", - "dati = RealData(x, y, sx=sx, sy=sy)\n", + " # 1) Pesi combinati\n", + " Wi = (wx * wy) / (A**2 * wy + wx)\n", "\n", - "# Modello lineare\n", - "modello = Model(f)\n", + " # 2) x e y pesati (eq. 10)\n", + " X_bar = np.sum(Wi * x) / np.sum(Wi)\n", + " Y_bar = np.sum(Wi * y) / np.sum(Wi)\n", "\n", - "# Esecuzione ODR (metodo di York)\n", - "odr = ODR(dati, modello, beta0=[0.01, 0]) # stima iniziale: A≈0.01, B≈0\n", - "out = odr.run()\n", + " # 3) Variabili centrate\n", + " Ui = x - X_bar\n", + " Vi = y - Y_bar\n", "\n", - "A, B = out.beta\n", - "sA, sB = out.sd_beta\n", - "cov_AB = out.cov_beta[0, 1]\n", - "chi2 = out.sum_square\n", - "chi2_red = out.res_var\n", + " # 4) beta\n", + " beta_i = Wi * (Ui / wy + A * Vi / wx)\n", "\n", - "print(\"=== REGRESSIONE T^2 vs Meq (ODR/York) ===\")\n", - "print(f\"A = {A:.7f} ± {sA:.7f}\")\n", - "print(f\"B = {B:.7f} ± {sB:.7f}\")\n", - "print(f\"cov(A,B) = {cov_AB}\")\n", - "print(f\"chi² = {chi2:.5f}\")\n", - "print(f\"chi² ridotto = {chi2_red:.5f}\")\n", + " # 5) Aggiornamento pendenza\n", + " A = np.sum(Wi * beta_i * Vi) / np.sum(Wi * beta_i * Ui)\n", "\n", - "# --- COSTANTE ELASTICA ---\n", - "K = (2*np.pi)**2 / A / 1000 # k in N/m → convertito a N/mm?\n", - "uK = (2*np.pi)**2 / (A**2) * sA / 1000\n", + " # Convergenza\n", + " if abs(A - A_old) < tol:\n", + " break\n", "\n", - "print(\"\\n=== COSTANTE ELASTICA DINAMICA DA ODR ===\")\n", - "print(f\"k = {K:.6f} ± {uK:.6f} N/m\")\n" + " # 6) Intercetta\n", + " B = Y_bar - A * X_bar\n", + "\n", + " # S = somma Wi (xi - x)**2\n", + " S = np.sum(Wi * Ui**2)\n", + "\n", + " sA = np.sqrt(1 / S)\n", + " sB = np.sqrt(1 / np.sum(Wi) + X_bar**2 * sA**2)\n", + "\n", + " # cov(A,B)\n", + " cov_AB = -X_bar * sA**2\n", + "\n", + " # CHI QUADRATO\n", + " chi2 = np.sum(Wi * (Vi - A * Ui)**2)\n", + " dof = len(x) - 2\n", + " chi2_red = chi2 / dof\n", + "\n", + " return A, B, sA, sB, cov_AB, chi2, chi2_red\n", + "\n", + "AdY, BdY, uAdY, uBdY, cov_ABdY, chi2_val, chi2_red = york_fit(datad.x, datad.y, datad.ux, datad.uy)\n", + "PdY = chi2.cdf(chi2_val, df=nu)\n", + "\n", + "# Calcolo del K dai parametri\n", + "KdY = (2*np.pi)**2 / AdY / 1000\n", + "uKdY = np.sqrt( (4*np.pi**2 / AdY**2)**2 * uAdY**2 ) / 1000\n", + "KBdY = (2*np.pi)**2 / BdY / 1000\n", + "uKBdY = np.sqrt( (4*np.pi**2 / BdY**2)**2 * uBdY**2 ) / 1000\n", + "\n", + "\n", + "print(f\"AdY = {AdY:.7f} ± {uAdY:.7f}\")\n", + "print(f\"BdY = {BdY:.7f} ± {uBdY:.7f}\")\n", + "print(f\"cov_ABdY = {cov_ABdY}\")\n", + "print(f\"chi² = {chi2_val:.5f}\")\n", + "print(f\"chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {PdY:.5f}\")\n", + "print(f\"KdY = {KdY:.5f} ± {uKdY:.5f}\")\n", + "print(f\"KBdY = {KBdY:.5f} ± {uKBdY:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "698bc57c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "# Seaborn scatter\n", + "sns.scatterplot(\n", + " data=datad,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", + ")\n", + "\n", + "# Barre d’errore\n", + "plt.errorbar(\n", + " datad[\"x\"],\n", + " datad[\"y\"],\n", + " xerr=datad[\"ux\"],\n", + " yerr=datad[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", + ")\n", + "\n", + "# Linea di regressione\n", + "xfit = np.linspace(0, datad[\"x\"].max(), 200)\n", + "yfit = BdY + AdY * xfit\n", + "\n", + "\n", + "plt.plot(\n", + " xfit,\n", + " yfit,\n", + " color=\"crimson\",\n", + " linewidth=1,\n", + " zorder=10,\n", + " label=\"Fit lineare York\"\n", + ")\n", + "\n", + "\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "\n", + "\n", + "plt.xlabel(\"Meq (g)\")\n", + "plt.ylabel(\"T^2 (s^2)\")\n", + "plt.title(\"Legge di ??\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "2e612bc6", + "metadata": {}, + "source": [ + "## Raccolta finale di dati dinamici" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "fc32f9e6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RISULTATI senza ERRORE STRUMENTALE INCLUSO:\n", + "Media pesata K = 23.49313 ± 0.00063\n", + "\n", + "RISULTATI REGRESSIONE OLS:\n", + "Adols = 0.00162 ± 0.00000\n", + "Bdols = 0.01007 ± 0.00034\n", + "P(0,chi²)= 0.99987\n", + "Kdols = 24.35158 ± 0.03547\n", + "KBdols = 3.92000 ± 0.13366\n", + "\n", + "RISULTATI REGRESSIONE Carpi:\n", + "AdC = 0.00162 ± 0.00000\n", + "BdC = 0.01007 ± 0.00011\n", + "P(0,chi²)= 0.96181\n", + "KdC = 24.34964 ± 0.00989\n", + "KBdC = 3.91877 ± 0.04363\n", + "\n", + "RISULTATI REGRESSIONE York:\n", + "Ady = 0.00162 ± 0.00000\n", + "Bdy = 0.01007 ± 0.00011\n", + "P(0,chi²)= 0.96181\n", + "KdY = 24.34964 ± 0.00989\n", + "KBdY = 3.91877 ± 0.04363\n" + ] + } + ], + "source": [ + "print(\"RISULTATI senza ERRORE STRUMENTALE INCLUSO:\")\n", + "print(f\"Media pesata K = {KdM:.5f} ± {uKdM:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE OLS:\")\n", + "print(f\"Adols = {Adols:.5f} ± {uAdols:.5f}\")\n", + "print(f\"Bdols = {Bdols:.5f} ± {uBdols:.5f}\")\n", + "print(f\"P(0,chi²)= {Pdols:.5f}\")\n", + "print(f\"Kdols = {Kdols:.5f} ± {uKdols:.5f}\")\n", + "print(f\"KBdols = {KBdols:.5f} ± {uKBdols:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE Carpi:\")\n", + "print(f\"AdC = {AdC:.5f} ± {uAdC:.5f}\")\n", + "print(f\"BdC = {BdC:.5f} ± {uBdC:.5f}\")\n", + "print(f\"P(0,chi²)= {PdC:.5f}\")\n", + "print(f\"KdC = {KdC:.5f} ± {uKdC:.5f}\")\n", + "print(f\"KBdC = {KBdC:.5f} ± {uKBdC:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE York:\")\n", + "print(f\"Ady = {AdY:.5f} ± {uAdY:.5f}\")\n", + "print(f\"Bdy = {BdY:.5f} ± {uBdY:.5f}\")\n", + "print(f\"P(0,chi²)= {PdY:.5f}\")\n", + "print(f\"KdY = {KdY:.5f} ± {uKdY:.5f}\")\n", + "print(f\"KBdY = {KBdY:.5f} ± {uKBdY:.5f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "7caf197a", + "metadata": {}, + "source": [ + "## Aggiunta degli errori strumentali" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "f4897de3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "res_T = 0.001000\n", + "res_T2 = 0.001080\n", + "res_b = 0.004082\n", + "res_uAd = 0.000009\n", + "uKd_strum= 0.132923\n" + ] + } + ], + "source": [ + "res_b = 0.01 / np.sqrt(6) # riso bilancia\n", + "res_T = 0.001 # riso T\n", + "\n", + "T = 2 * np.pi / df.w\n", + "res_T2 = np.max(2 * T * res_T)\n", + "\n", + "res_uAd = np.max(np.sqrt( (1 / Meq)**2 * res_T2**2 + (T2 / Meq**2)**2 * res_b**2))\n", + "\n", + "uKd_strum = np.max(np.abs(4 * np.pi**2 / Ad**2) * res_uAd) / 1000\n", + "\n", + "print(f\"res_T = {res_T:.6f}\")\n", + "print(f\"res_T2 = {res_T2:.6f}\")\n", + "print(f\"res_b = {res_b:.6f}\")\n", + "print(f\"res_uAd = {res_uAd:.6f}\")\n", + "print(f\"uKd_strum= {uKd_strum:.6f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "37d88464", + "metadata": {}, + "outputs": [], + "source": [ + "uKdM_fin = np.sqrt(uKdM**2 + uKd_strum**2)\n", + "\n", + "uAdols_fin = np.sqrt(uAdols**2 + res_uAd**2)\n", + "uBdols_fin = np.sqrt(uBdols**2 + res_uAd**2)\n", + "uKdols_fin = np.sqrt(uKdols**2 + uKd_strum**2)\n", + "\n", + "uAdC_fin = np.sqrt(uAdC**2 + res_uAd**2)\n", + "uBdC_fin = np.sqrt(uBdC**2 + res_uAd**2)\n", + "uKdC_fin = np.sqrt(uKdC**2 + uKd_strum**2)\n", + "\n", + "uAdY_fin = np.sqrt(uAdY**2 + res_uAd**2)\n", + "uBdY_fin = np.sqrt(uBdY**2 + res_uAd**2)\n", + "uKdY_fin = np.sqrt(uKdY**2 + uKd_strum**2)\n", + "\n", + "\n", + "uy_fin_d = np.sqrt(datad[\"uy\"]**2 + res_T2**2)\n", + "ux_fin_d = np.sqrt(datad[\"ux\"]**2 + res_b**2)\n", + "\n", + "GdLd = len(datad) - 2\n", + "\n", + "\n", + "F_fit_dols = Bdols + Adols * datad[\"x\"]\n", + "sigma_dols = np.sqrt(uy_fin_d**2 + (Adols * ux_fin_d)**2)\n", + "chi2_dols = np.sum(((datad[\"y\"] - F_fit_dols) / sigma_dols)**2)\n", + "\n", + "F_fit_dC = BdC + AdC * datad[\"x\"]\n", + "sigma_dC = np.sqrt(uy_fin_d**2 + (AdC * ux_fin_d)**2)\n", + "chi2_dC = np.sum(((datad[\"y\"] - F_fit_dC) / sigma_dC)**2)\n", + "\n", + "F_fit_dY = BdY + AdY * datad[\"x\"]\n", + "sigma_dY = np.sqrt(uy_fin_d**2 + (AdY * ux_fin_d)**2)\n", + "chi2_dY = np.sum(((datad[\"y\"] - F_fit_dY) / sigma_dY)**2)\n" + ] + }, + { + "cell_type": "markdown", + "id": "42c27c50", + "metadata": {}, + "source": [ + "## Risultati sulla propagazione dell'errore" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "9075e52d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RISULTATI CON ERRORE STRUMENTALE INCLUSO:\n", + "Media pesata Kd = 23.49313 ± 0.13292\n", + "\n", + "RISULTATI OLS:\n", + "Adols = 0.00162 ± 0.00001\n", + "Bdols = 0.01007 ± 0.00034\n", + "Kdols = 24.35158 ± 0.13757\n", + "Chi² = 0.01897 | rid = 0.00949 | P = 0.00944\n", + "\n", + "RISULTATI Carpi:\n", + "AdC = 0.00162 ± 0.00001\n", + "BdC = 0.01007 ± 0.00011\n", + "KdC = 24.34964 ± 0.13329\n", + "Chi² = 0.02061 | rid = 0.01030 | P = 0.01025\n", + "\n", + "RISULTATI York:\n", + "AdY = 0.00162 ± 0.00001\n", + "BdY = 0.01007 ± 0.00011\n", + "KdY = 24.34964 ± 0.13329\n", + "Chi² = 0.02061 | rid = 0.01030 | P = 0.01025\n" + ] + } + ], + "source": [ + "print(\"RISULTATI CON ERRORE STRUMENTALE INCLUSO:\")\n", + "print(f\"Media pesata Kd = {KdM:.5f} ± {uKdM_fin:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI OLS:\")\n", + "print(f\"Adols = {Adols:.5f} ± {uAdols_fin:.5f}\")\n", + "print(f\"Bdols = {Bdols:.5f} ± {uBdols_fin:.5f}\")\n", + "print(f\"Kdols = {Kdols:.5f} ± {uKdols_fin:.5f}\")\n", + "print(f\"Chi² = {chi2_dols:.5f} | rid = {chi2_dols/GdLd:.5f} | P = {chi2.cdf(chi2_dols, GdLd):.5f}\")\n", + "\n", + "print(\"\\nRISULTATI Carpi:\")\n", + "print(f\"AdC = {AdC:.5f} ± {uAdC_fin:.5f}\")\n", + "print(f\"BdC = {BdC:.5f} ± {uBdC_fin:.5f}\")\n", + "print(f\"KdC = {KdC:.5f} ± {uKdC_fin:.5f}\")\n", + "print(f\"Chi² = {chi2_dC:.5f} | rid = {chi2_dC/GdLd:.5f} | P = {chi2.cdf(chi2_dC, GdLd):.5f}\")\n", + "\n", + "print(\"\\nRISULTATI York:\")\n", + "print(f\"AdY = {AdY:.5f} ± {uAdY_fin:.5f}\")\n", + "print(f\"BdY = {BdY:.5f} ± {uBdY_fin:.5f}\")\n", + "print(f\"KdY = {KdY:.5f} ± {uKdY_fin:.5f}\")\n", + "print(f\"Chi² = {chi2_dY:.5f} | rid = {chi2_dY/GdLd:.5f} | P = {chi2.cdf(chi2_dY, GdLd):.5f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "6f4edfa1", + "metadata": {}, + "source": [ + "# Dinamica Cronometro" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "0f407f81", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 NaN\n", + "1 NaN\n", + "2 NaN\n", + "3 NaN\n", + "Name: t, dtype: float64\n", + "0 NaN\n", + "1 NaN\n", + "2 NaN\n", + "3 NaN\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "T2t = (df.t / 20)**2\n", + "uT2t = 2 * (df.t / 20) * (df.ut / 20)\n", + "\n", + "print(T2t)\n", + "print(uT2t)" + ] + }, + { + "cell_type": "markdown", + "id": "8d097869", + "metadata": {}, + "source": [ + "## Calcolo dei K e media pesata" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "99bc83a7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 NaN\n", + "1 NaN\n", + "2 NaN\n", + "3 NaN\n", + "dtype: float64\n", + "0 NaN\n", + "1 NaN\n", + "2 NaN\n", + "3 NaN\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "Adt = T2t / Meq\n", + "uAdt = np.sqrt( (1/Meq)**2 * uT2t**2 + (T2t/Meq**2)**2 * uMeq**2 )\n", + "\n", + "Kdt = 4 * np.pi**2 / Adt\n", + "uKdt = (4 * np.pi**2 / Adt**2) * uAdt\n", + "\n", + "Kdt\n", + "uKdt\n", + "\n", + "print(Kdt)\n", + "print(uKdt)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "ae55d12a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "K-medio (t): nan\n", + "sigmaC (t): inf\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_299408/2995330097.py:10: RuntimeWarning: invalid value encountered in scalar divide\n", + " media = num / den\n", + "/tmp/ipykernel_299408/2995330097.py:11: RuntimeWarning: divide by zero encountered in scalar divide\n", + " sigma = np.sqrt(1.0 / den)\n" + ] + } + ], + "source": [ + "KdtM, uKdtM = mediaPesata(Kdt, uKdt)\n", + "KdtM /= 1e3\n", + "uKdtM /= 1e3\n", + "print(\"K-medio (t):\", KdtM)\n", + "print(\"sigmaC (t):\", uKdtM)" + ] + }, + { + "cell_type": "markdown", + "id": "634a06e9", + "metadata": {}, + "source": [ + "## Analisi con regressioni e grafici" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "75e94b0a", + "metadata": {}, + "outputs": [], + "source": [ + "datat = pd.DataFrame({\n", + " \"x\": Meq,\n", + " \"ux\": uMeq,\n", + " \"y\": T2t,\n", + " \"uy\": uT2t\n", + "})" + ] + }, + { + "cell_type": "markdown", + "id": "e7761130", + "metadata": {}, + "source": [ + "### Regressione lineare \"OLS\"\n", + "Non tiene conto dei nostri errori, un risultato puro e semplice" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "896388e2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " OLS Regression Results \n", + "==============================================================================\n", + "Dep. Variable: y R-squared: nan\n", + "Model: OLS Adj. R-squared: nan\n", + "Method: Least Squares F-statistic: nan\n", + "Date: Sun, 05 Apr 2026 Prob (F-statistic): nan\n", + "Time: 21:57:07 Log-Likelihood: nan\n", + "No. Observations: 4 AIC: nan\n", + "Df Residuals: 2 BIC: nan\n", + "Df Model: 1 \n", + "Covariance Type: nonrobust \n", + "==============================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "const nan nan nan nan nan nan\n", + "x nan nan nan nan nan nan\n", + "==============================================================================\n", + "Omnibus: nan Durbin-Watson: nan\n", + "Prob(Omnibus): nan Jarque-Bera (JB): nan\n", + "Skew: nan Prob(JB): nan\n", + "Kurtosis: nan Cond. No. 948.\n", + "==============================================================================\n", + "\n", + "Notes:\n", + "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", + "\n", + "RISULTATI REGRESSIONE OLS (t):\n", + "Atols = nan ± nan\n", + "Btols = nan ± nan\n", + "R² = nan\n", + "Kdtols = nan ± nan\n", + "KBdtols = nan ± nan\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jack/uni/lab/.venv/lib/python3.13/site-packages/statsmodels/stats/stattools.py:74: ValueWarning: omni_normtest is not valid with less than 8 observations; 4 samples were given.\n", + " warn(\"omni_normtest is not valid with less than 8 observations; %i \"\n" + ] + } + ], + "source": [ + "X = sm.add_constant(datat[\"x\"])\n", + "model = sm.OLS(datat[\"y\"], X).fit()\n", + "\n", + "print(model.summary())\n", + "\n", + "Btols = model.params[\"const\"]\n", + "Atols = model.params[\"x\"]\n", + "uBtols = model.bse[\"const\"]\n", + "uAtols = model.bse[\"x\"]\n", + "R2t = model.rsquared\n", + "\n", + "Kdtols = 4 * np.pi**2 / Atols / 1000\n", + "uKdtols = (4 * np.pi**2 / Atols**2) * uAtols / 1000\n", + "KBdtols = 4 * np.pi**2 / Btols / 1000\n", + "uKBdtols = (4 * np.pi**2 / Btols**2) * uBtols / 1000\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE OLS (t):\")\n", + "print(f\"Atols = {Atols:.5f} ± {uAtols:.5f}\")\n", + "print(f\"Btols = {Btols:.5f} ± {uBtols:.5f}\")\n", + "print(f\"R² = {R2t:.5f}\")\n", + "print(f\"Kdtols = {Kdtols:.5f} ± {uKdtols:.5f}\")\n", + "print(f\"KBdtols = {KBdtols:.5f} ± {uKBdtols:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "61e40e4c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "sns.scatterplot(data=datat, x=\"x\", y=\"y\", s=7)\n", + "\n", + "plt.errorbar(\n", + " datat[\"x\"], datat[\"y\"],\n", + " xerr=datat[\"ux\"], yerr=datat[\"uy\"],\n", + " fmt=\"none\", ecolor=\"gray\", elinewidth=1, capsize=3, alpha=0.7\n", + ")\n", + "\n", + "xfit = np.linspace(0, datat[\"x\"].max(), 200)\n", + "yfit = Btols + Atols * xfit\n", + "\n", + "plt.plot(xfit, yfit, color=\"crimson\", linewidth=1, zorder=10, label=\"Fit OLS t\")\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "plt.xlabel(\"Meq (g)\")\n", + "plt.ylabel(\"T² (s²)\")\n", + "plt.title(\"Legge di ?? — cronometro\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "354687ec", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chi² = 0.00000\n", + "GdL = 2\n", + "Chi² rid = 0.00000\n", + "P(0, chi²)= 0.00000\n", + "\n", + "\n", + "############################################################\n", + "capiamo quale dato sta contribuendo maggiormente\n", + "0 NaN\n", + "1 NaN\n", + "2 NaN\n", + "3 NaN\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "F_fit = Btols + Atols * datat[\"x\"]\n", + "sigma = np.sqrt(datat[\"uy\"]**2 + (Atols * datat[\"ux\"])**2)\n", + "\n", + "chi2_val = np.sum(((datat[\"y\"] - F_fit) / sigma)**2)\n", + "\n", + "N = len(datat)\n", + "nut = N - 2\n", + "\n", + "chi2_red = chi2_val / nut\n", + "Ptols = chi2.cdf(chi2_val, df=nut)\n", + "\n", + "print(f\"Chi² = {chi2_val:.5f}\")\n", + "print(f\"GdL = {nut}\")\n", + "print(f\"Chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {Ptols:.5f}\")\n", + "print(\"\\n\\n\" + \"#\"*60)\n", + "print(\"capiamo quale dato sta contribuendo maggiormente\")\n", + "print(((datat[\"y\"] - F_fit) / sigma)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "c28f2d34", + "metadata": {}, + "source": [ + "### Regressione lineare Carpi" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "8d6cd1df", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ax + B (Carpi, t):\n", + "AtC = nan ± nan\n", + "BtC = nan ± nan\n", + "cov_ABtC = nan\n", + "P(0,chi²)= nan\n", + "KdtC = nan ± nan\n", + "KBdtC = nan ± nan\n" + ] + } + ], + "source": [ + "AtC, BtC, uAtC, uBtC, covABtC, chitC = reg_lin(datat[\"x\"], datat[\"y\"], datat[\"ux\"], datat[\"uy\"])\n", + "\n", + "KdtC = 4 * np.pi**2 / AtC / 1000\n", + "uKdtC = (4 * np.pi**2 / AtC**2) * uAtC / 1000\n", + "KBdtC = 4 * np.pi**2 / BtC / 1000\n", + "uKBdtC = (4 * np.pi**2 / BtC**2) * uBtC / 1000\n", + "\n", + "print(\"Ax + B (Carpi, t):\")\n", + "print(f\"AtC = {AtC:.5f} ± {uAtC:.5f}\")\n", + "print(f\"BtC = {BtC:.5f} ± {uBtC:.5f}\")\n", + "print(f\"cov_ABtC = {covABtC:.6f}\")\n", + "print(f\"P(0,chi²)= {chitC:.5f}\")\n", + "print(f\"KdtC = {KdtC:.5f} ± {uKdtC:.5f}\")\n", + "print(f\"KBdtC = {KBdtC:.5f} ± {uKBdtC:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "592c257c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "sns.scatterplot(data=datat, x=\"x\", y=\"y\", s=7)\n", + "\n", + "plt.errorbar(\n", + " datat[\"x\"], datat[\"y\"],\n", + " xerr=datat[\"ux\"], yerr=datat[\"uy\"],\n", + " fmt=\"none\", ecolor=\"gray\", elinewidth=1, capsize=3, alpha=0.7\n", + ")\n", + "\n", + "xfit = np.linspace(0, datat[\"x\"].max(), 200)\n", + "yfit = BtC + AtC * xfit\n", + "\n", + "plt.plot(xfit, yfit, color=\"crimson\", linewidth=1, zorder=10, label=\"Fit Carpi (t)\")\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "plt.xlabel(\"Meq (g)\")\n", + "plt.ylabel(\"T² (s²)\")\n", + "plt.title(\"Legge di Hooke dinamica — cronometro\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "12f276cc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chi² = 0.00000\n", + "GdL = 2\n", + "Chi² rid = 0.00000\n", + "P(0, chi²)= 0.00000\n", + "\n", + "\n", + "############################################################\n", + "capiamo quale dato sta contribuendo maggiormente\n", + "0 NaN\n", + "1 NaN\n", + "2 NaN\n", + "3 NaN\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "F_fit = BtC + AtC * datat[\"x\"]\n", + "sigma = np.sqrt(datat[\"uy\"]**2 + (AtC * datat[\"ux\"])**2)\n", + "chi2_val = np.sum(((datat[\"y\"] - F_fit) / sigma)**2)\n", + "chi2_red = chi2_val / nut\n", + "PtC = chi2.cdf(chi2_val, df=nut)\n", + "\n", + "print(f\"Chi² = {chi2_val:.5f}\")\n", + "print(f\"GdL = {nut}\")\n", + "print(f\"Chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {PtC:.5f}\")\n", + "print(\"\\n\\n\" + \"#\"*60)\n", + "print(\"capiamo quale dato sta contribuendo maggiormente\")\n", + "print(((datat[\"y\"] - F_fit) / sigma)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "0823cca1", + "metadata": {}, + "source": [ + "### Regressione lineare pesata Yorkfit" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "d04ee20e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AtY = nan ± inf\n", + "BtY = nan ± nan\n", + "cov_ABtY = nan\n", + "chi² = 0.00000\n", + "chi² rid = 0.00000\n", + "P(0, chi²)= 0.00000\n", + "KdtY = nan ± nan\n", + "KBdtY = nan ± nan\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_299408/788188722.py:16: RuntimeWarning: invalid value encountered in scalar divide\n", + " X_bar = np.sum(Wi * x) / np.sum(Wi)\n", + "/tmp/ipykernel_299408/788188722.py:17: RuntimeWarning: invalid value encountered in scalar divide\n", + " Y_bar = np.sum(Wi * y) / np.sum(Wi)\n", + "/tmp/ipykernel_299408/788188722.py:27: RuntimeWarning: invalid value encountered in scalar divide\n", + " A = np.sum(Wi * beta_i * Vi) / np.sum(Wi * beta_i * Ui)\n", + "/tmp/ipykernel_299408/788188722.py:39: RuntimeWarning: divide by zero encountered in scalar divide\n", + " sA = np.sqrt(1 / S)\n", + "/tmp/ipykernel_299408/788188722.py:40: RuntimeWarning: divide by zero encountered in scalar divide\n", + " sB = np.sqrt(1 / np.sum(Wi) + X_bar**2 * sA**2)\n" + ] + } + ], + "source": [ + "AtY, BtY, uAtY, uBtY, cov_ABtY, chi2_val_t, chi2_red_t = york_fit(datat.x, datat.y, datat.ux, datat.uy)\n", + "PtY = chi2.cdf(chi2_val_t, df=nut)\n", + "\n", + "KdtY = 4 * np.pi**2 / AtY / 1000\n", + "uKdtY = (4 * np.pi**2 / AtY**2) * uAtY / 1000\n", + "KBdtY = 4 * np.pi**2 / BtY / 1000\n", + "uKBdtY = (4 * np.pi**2 / BtY**2) * uBtY / 1000\n", + "\n", + "print(f\"AtY = {AtY:.7f} ± {uAtY:.7f}\")\n", + "print(f\"BtY = {BtY:.7f} ± {uBtY:.7f}\")\n", + "print(f\"cov_ABtY = {cov_ABtY}\")\n", + "print(f\"chi² = {chi2_val_t:.5f}\")\n", + "print(f\"chi² rid = {chi2_red_t:.5f}\")\n", + "print(f\"P(0, chi²)= {PtY:.5f}\")\n", + "print(f\"KdtY = {KdtY:.5f} ± {uKdtY:.5f}\")\n", + "print(f\"KBdtY = {KBdtY:.5f} ± {uKBdtY:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "e795e732", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "sns.scatterplot(data=datat, x=\"x\", y=\"y\", s=7)\n", + "\n", + "plt.errorbar(\n", + " datat[\"x\"], datat[\"y\"],\n", + " xerr=datat[\"ux\"], yerr=datat[\"uy\"],\n", + " fmt=\"none\", ecolor=\"gray\", elinewidth=1, capsize=3, alpha=0.7\n", + ")\n", + "\n", + "xfit = np.linspace(0, datat[\"x\"].max(), 200)\n", + "yfit = BtY + AtY * xfit\n", + "\n", + "plt.plot(xfit, yfit, color=\"crimson\", linewidth=1, zorder=10, label=\"Fit York (t)\")\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "plt.xlabel(\"Meq (g)\")\n", + "plt.ylabel(\"T² (s²)\")\n", + "plt.title(\"Legge di Hooke dinamica — cronometro\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "038b2684", + "metadata": {}, + "source": [ + "## Raccolta finale di dati dinamici col cronometro" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "46ef07bd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RISULTATI senza ERRORE STRUMENTALE (cronometro):\n", + "Media pesata K = nan ± inf\n", + "\n", + "RISULTATI REGRESSIONE OLS:\n", + "Atols = nan ± nan\n", + "Btols = nan ± nan\n", + "P(0,chi²)= 0.00000\n", + "Kdtols = nan ± nan\n", + "KBdtols = nan ± nan\n", + "\n", + "RISULTATI REGRESSIONE Carpi:\n", + "AtC = nan ± nan\n", + "BtC = nan ± nan\n", + "P(0,chi²)= 0.00000\n", + "KdtC = nan ± nan\n", + "KBdtC = nan ± nan\n", + "\n", + "RISULTATI REGRESSIONE York:\n", + "AtY = nan ± inf\n", + "BtY = nan ± nan\n", + "P(0,chi²)= 0.00000\n", + "KdtY = nan ± nan\n", + "KBdtY = nan ± nan\n" + ] + } + ], + "source": [ + "print(\"RISULTATI senza ERRORE STRUMENTALE (cronometro):\")\n", + "print(f\"Media pesata K = {KdtM:.5f} ± {uKdtM:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE OLS:\")\n", + "print(f\"Atols = {Atols:.5f} ± {uAtols:.5f}\")\n", + "print(f\"Btols = {Btols:.5f} ± {uBtols:.5f}\")\n", + "print(f\"P(0,chi²)= {Ptols:.5f}\")\n", + "print(f\"Kdtols = {Kdtols:.5f} ± {uKdtols:.5f}\")\n", + "print(f\"KBdtols = {KBdtols:.5f} ± {uKBdtols:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE Carpi:\")\n", + "print(f\"AtC = {AtC:.5f} ± {uAtC:.5f}\")\n", + "print(f\"BtC = {BtC:.5f} ± {uBtC:.5f}\")\n", + "print(f\"P(0,chi²)= {PtC:.5f}\")\n", + "print(f\"KdtC = {KdtC:.5f} ± {uKdtC:.5f}\")\n", + "print(f\"KBdtC = {KBdtC:.5f} ± {uKBdtC:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE York:\")\n", + "print(f\"AtY = {AtY:.5f} ± {uAtY:.5f}\")\n", + "print(f\"BtY = {BtY:.5f} ± {uBtY:.5f}\")\n", + "print(f\"P(0,chi²)= {PtY:.5f}\")\n", + "print(f\"KdtY = {KdtY:.5f} ± {uKdtY:.5f}\")\n", + "print(f\"KBdtY = {KBdtY:.5f} ± {uKBdtY:.5f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "70201336", + "metadata": {}, + "source": [ + "## Aggiungi gli errori strumentali" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "dfcd391e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "res_t = 0.000500\n", + "res_t2 = nan\n", + "res_uAdt = nan\n", + "uKdt_strum = nan\n" + ] + } + ], + "source": [ + "res_t = 0.01 / 20 # risoluzione cronometro\n", + "res_t2 = np.max(2 * df.t * res_t)\n", + "\n", + "res_uAdt = np.max(np.sqrt( (1 / Meq)**2* res_t2**2 +(T2t / Meq**2)**2 * res_b**2))\n", + "uKdt_strum = np.max(np.abs(4 * np.pi**2 / Adt**2) * res_uAdt) / 1000\n", + "\n", + "print(f\"res_t = {res_t:.6f}\")\n", + "print(f\"res_t2 = {res_t2:.6f}\")\n", + "print(f\"res_uAdt = {res_uAdt:.6f}\")\n", + "print(f\"uKdt_strum = {uKdt_strum:.6f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "b52fea3d", + "metadata": {}, + "outputs": [], + "source": [ + "uKdtM_fin = np.sqrt(uKdtM**2 + uKdt_strum**2)\n", + "\n", + "uAtols_fin = np.sqrt(uAtols**2 + res_uAdt**2)\n", + "uBtols_fin = np.sqrt(uBtols**2 + res_uAdt**2)\n", + "uKdtols_fin = np.sqrt(uKdtols**2 + uKdt_strum**2)\n", + "\n", + "uAtC_fin = np.sqrt(uAtC**2 + res_uAdt**2)\n", + "uBtC_fin = np.sqrt(uBtC**2 + res_uAdt**2)\n", + "uKdtC_fin = np.sqrt(uKdtC**2 + uKdt_strum**2)\n", + "\n", + "uAtY_fin = np.sqrt(uAtY**2 + res_uAdt**2)\n", + "uBtY_fin = np.sqrt(uBtY**2 + res_uAdt**2)\n", + "uKdtY_fin = np.sqrt(uKdtY**2 + uKdt_strum**2)\n", + "\n", + "uy_fin_t = np.sqrt(datat[\"uy\"]**2 + res_t2**2)\n", + "ux_fin_t = np.sqrt(datat[\"ux\"]**2 + res_b**2)\n", + "\n", + "GdLt = len(datat) - 2\n", + "\n", + "F_fit_tols = Btols + Atols * datat[\"x\"]\n", + "sigma_tols = np.sqrt(uy_fin_t**2 + (Atols * ux_fin_t)**2)\n", + "chi2_tols = np.sum(((datat[\"y\"] - F_fit_tols) / sigma_tols)**2)\n", + "\n", + "F_fit_tC = BtC + AtC * datat[\"x\"]\n", + "sigma_tC = np.sqrt(uy_fin_t**2 + (AtC * ux_fin_t)**2)\n", + "chi2_tC = np.sum(((datat[\"y\"] - F_fit_tC) / sigma_tC)**2)\n", + "\n", + "F_fit_tY = BtY + AtY * datat[\"x\"]\n", + "sigma_tY = np.sqrt(uy_fin_t**2 + (AtY * ux_fin_t)**2)\n", + "chi2_tY = np.sum(((datat[\"y\"] - F_fit_tY) / sigma_tY)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "858bbff7", + "metadata": {}, + "source": [ + "## Risultati della propagazione dell'errore" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "0b1e4a1d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RISULTATI CON ERRORE STRUMENTALE (cronometro):\n", + "Media pesata K = nan ± nan\n", + "\n", + "RISULTATI OLS:\n", + "Atols = nan ± nan\n", + "Btols = nan ± nan\n", + "Kdtols = nan ± nan\n", + "Chi² = 0.00000 | rid = 0.00000 | P = 0.00000\n", + "\n", + "RISULTATI Carpi:\n", + "AtC = nan ± nan\n", + "BtC = nan ± nan\n", + "KdtC = nan ± nan\n", + "Chi² = 0.00000 | rid = 0.00000 | P = 0.00000\n", + "\n", + "RISULTATI York:\n", + "AtY = nan ± nan\n", + "BtY = nan ± nan\n", + "KdtY = nan ± nan\n", + "Chi² = 0.00000 | rid = 0.00000 | P = 0.00000\n" + ] + } + ], + "source": [ + "print(\"RISULTATI CON ERRORE STRUMENTALE (cronometro):\")\n", + "print(f\"Media pesata K = {KdtM:.5f} ± {uKdtM_fin:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI OLS:\")\n", + "print(f\"Atols = {Atols:.5f} ± {uAtols_fin:.5f}\")\n", + "print(f\"Btols = {Btols:.5f} ± {uBtols_fin:.5f}\")\n", + "print(f\"Kdtols = {Kdtols:.5f} ± {uKdtols_fin:.5f}\")\n", + "print(f\"Chi² = {chi2_tols:.5f} | rid = {chi2_tols/GdLt:.5f} | P = {chi2.cdf(chi2_tols, GdLt):.5f}\")\n", + "\n", + "print(\"\\nRISULTATI Carpi:\")\n", + "print(f\"AtC = {AtC:.5f} ± {uAtC_fin:.5f}\")\n", + "print(f\"BtC = {BtC:.5f} ± {uBtC_fin:.5f}\")\n", + "print(f\"KdtC = {KdtC:.5f} ± {uKdtC_fin:.5f}\")\n", + "print(f\"Chi² = {chi2_tC:.5f} | rid = {chi2_tC/GdLt:.5f} | P = {chi2.cdf(chi2_tC, GdLt):.5f}\")\n", + "\n", + "print(\"\\nRISULTATI York:\")\n", + "print(f\"AtY = {AtY:.5f} ± {uAtY_fin:.5f}\")\n", + "print(f\"BtY = {BtY:.5f} ± {uBtY_fin:.5f}\")\n", + "print(f\"KdtY = {KdtY:.5f} ± {uKdtY_fin:.5f}\")\n", + "print(f\"Chi² = {chi2_tY:.5f} | rid = {chi2_tY/GdLt:.5f} | P = {chi2.cdf(chi2_tY, GdLt):.5f}\")" ] } ], diff --git a/molla/dinamica/mollaDinamica2.ipynb b/molla/dinamica/mollaDinamica2.ipynb index 012c66a..928325d 100644 --- a/molla/dinamica/mollaDinamica2.ipynb +++ b/molla/dinamica/mollaDinamica2.ipynb @@ -1,8 +1,29 @@ { "cells": [ + { + "cell_type": "markdown", + "id": "a80529e4", + "metadata": {}, + "source": [ + "# Analisi dei dati con il sonar\n", + "Minimo Indice:\n", + "- Analisi dei dati statici\n", + "- Analisi dei dati dinamici\n", + " - Sonar\n", + " - Cronometro" + ] + }, + { + "cell_type": "markdown", + "id": "32702b8f", + "metadata": {}, + "source": [ + "## Import delle librerie e set di variabili gloabali" + ] + }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 603, "id": "f34c5b88", "metadata": {}, "outputs": [], @@ -11,23 +32,35 @@ "import pandas as pd\n", "import scipy as sc\n", "from scipy.stats import chi2\n", - "from scipy.odr import ODR, Model, RealData\n", "import seaborn as sns\n", "import matplotlib.pyplot as plt\n", "import matplotlib as mpl\n", "import statsmodels.api as sm\n", "\n", "\n", - "g = 9.806\n", + "g = 9.807\n", "ug = 0.001\n", "\n", "m_mol = 15.43\n", "um_mol = 0.01" ] }, + { + "cell_type": "markdown", + "id": "fd0b8b1d", + "metadata": {}, + "source": [ + "## Lettura dei dati e calcolo delle deviazioni standard campionarie\n", + "- Lettura del CSV\n", + "- Creazione del data frame\n", + "- Deviazioni standard\n", + "\n", + "ATTENZIONE: Linea cursed ~17" + ] + }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 604, "id": "08efb2be", "metadata": {}, "outputs": [], @@ -48,7 +81,6 @@ " else:\n", " media = valori.mean()\n", " sigma = valori.std(ddof=1)\n", - " sigma = sigma * np.sqrt(24) if prefix == \"w\" else sigma # Line cursed per non duplicare il codice\n", " return pd.Series({prefix: media, f\"u{prefix}\": sigma})\n", "\n", " stats = df.apply(riga_stats, axis=1)\n", @@ -59,14 +91,15 @@ "\n", "\n", "df = calcola_stats(df, \"w\", err_arbitrario=0.0002)\n", - "df = calcola_stats(df, \"m\", err_arbitrario=0.01)\n", + "df = calcola_stats(df, \"m\", err_arbitrario=0.0028867513)\n", "df = calcola_stats(df, \"c\", err_arbitrario=0.01)\n", - "df = calcola_stats(df, \"a\", err_arbitrario=0.01)" + "df = calcola_stats(df, \"a\", err_arbitrario=0.01)\n", + "df = calcola_stats(df, \"t\", err_arbitrario=0.01)" ] }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 605, "id": "5494409f", "metadata": {}, "outputs": [ @@ -128,6 +161,8 @@ " uc\n", " a\n", " ua\n", + " t\n", + " ut\n", " \n", " \n", " \n", @@ -163,13 +198,15 @@ " 0.011\n", " 15.87\n", " 7.657975\n", - " 0.008385\n", + " 0.001711\n", " 49.25\n", - " 0.01\n", + " 0.002887\n", " 484.70125\n", " 0.284314\n", " 9.362775\n", " 0.908254\n", + " 15.7075\n", + " 0.133010\n", " \n", " \n", " 1\n", @@ -203,13 +240,15 @@ " 0.014\n", " 18.16\n", " 6.559652\n", - " 0.002542\n", + " 0.000519\n", " 69.28\n", - " 0.01\n", + " 0.002887\n", " 423.41700\n", " 0.226641\n", " 10.427250\n", " 0.454472\n", + " 18.2700\n", + " 0.078740\n", " \n", " \n", " 2\n", @@ -243,13 +282,15 @@ " 0.011\n", " 20.49\n", " 5.845038\n", - " 0.003374\n", + " 0.000689\n", " 88.97\n", - " 0.01\n", + " 0.002887\n", " 363.24975\n", " 0.073109\n", " 11.257075\n", " 0.794837\n", + " 20.4350\n", + " 0.117331\n", " \n", " \n", " 3\n", @@ -283,13 +324,15 @@ " 0.010\n", " 22.15\n", " 5.328455\n", - " 0.003858\n", + " 0.000787\n", " 108.61\n", - " 0.01\n", + " 0.002887\n", " 303.60455\n", " 0.168669\n", " 10.106500\n", " 1.299853\n", + " 22.3650\n", + " 0.187172\n", " \n", " \n", " 4\n", @@ -323,13 +366,15 @@ " 0.015\n", " 24.26\n", " 4.925600\n", - " 0.004943\n", + " 0.001009\n", " 128.64\n", - " 0.01\n", + " 0.002887\n", " 242.93550\n", " 0.138954\n", " 10.637000\n", " 1.188344\n", + " 24.5150\n", + " 0.386480\n", " \n", " \n", "\n", @@ -357,22 +402,22 @@ "3 0.00030 303.842 0.016 22.55 9.959 0.014 5.32822 0.00020 303.445 \n", "4 0.00030 242.789 0.017 25.09 9.118 0.021 4.92610 0.00030 243.115 \n", "\n", - " uc4 t4 w uw m um c uc \\\n", - "0 0.011 15.87 7.657975 0.008385 49.25 0.01 484.70125 0.284314 \n", - "1 0.014 18.16 6.559652 0.002542 69.28 0.01 423.41700 0.226641 \n", - "2 0.011 20.49 5.845038 0.003374 88.97 0.01 363.24975 0.073109 \n", - "3 0.010 22.15 5.328455 0.003858 108.61 0.01 303.60455 0.168669 \n", - "4 0.015 24.26 4.925600 0.004943 128.64 0.01 242.93550 0.138954 \n", + " uc4 t4 w uw m um c uc \\\n", + "0 0.011 15.87 7.657975 0.001711 49.25 0.002887 484.70125 0.284314 \n", + "1 0.014 18.16 6.559652 0.000519 69.28 0.002887 423.41700 0.226641 \n", + "2 0.011 20.49 5.845038 0.000689 88.97 0.002887 363.24975 0.073109 \n", + "3 0.010 22.15 5.328455 0.000787 108.61 0.002887 303.60455 0.168669 \n", + "4 0.015 24.26 4.925600 0.001009 128.64 0.002887 242.93550 0.138954 \n", "\n", - " a ua \n", - "0 9.362775 0.908254 \n", - "1 10.427250 0.454472 \n", - "2 11.257075 0.794837 \n", - "3 10.106500 1.299853 \n", - "4 10.637000 1.188344 " + " a ua t ut \n", + "0 9.362775 0.908254 15.7075 0.133010 \n", + "1 10.427250 0.454472 18.2700 0.078740 \n", + "2 11.257075 0.794837 20.4350 0.117331 \n", + "3 10.106500 1.299853 22.3650 0.187172 \n", + "4 10.637000 1.188344 24.5150 0.386480 " ] }, - "execution_count": 28, + "execution_count": 605, "metadata": {}, "output_type": "execute_result" } @@ -384,9 +429,25 @@ "df" ] }, + { + "cell_type": "markdown", + "id": "9b8d8cb4", + "metadata": {}, + "source": [ + "# Analisi statica" + ] + }, + { + "cell_type": "markdown", + "id": "fd1b1164", + "metadata": {}, + "source": [ + "## Permutazioni" + ] + }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 606, "id": "976d5531", "metadata": {}, "outputs": [ @@ -403,8 +464,8 @@ " 0.26584645 0.18383143 0.15701353 0.21853469]\n", "############################################################\n", "[-20.03 -39.72 -59.36 -79.39 -19.69 -39.33 -59.36 -19.64 -39.67 -20.03]\n", - "[0.01414214 0.01414214 0.01414214 0.01414214 0.01414214 0.01414214\n", - " 0.01414214 0.01414214 0.01414214 0.01414214]\n" + "[0.00408248 0.00408248 0.00408248 0.00408248 0.00408248 0.00408248\n", + " 0.00408248 0.00408248 0.00408248 0.00408248]\n" ] } ], @@ -430,9 +491,19 @@ "print(umasse)" ] }, + { + "cell_type": "markdown", + "id": "d37fbd7c", + "metadata": {}, + "source": [ + "## Calcolo dei K e media pesata\n", + "- Calcolo del K\n", + "- Calcolo della media pesata (sui K)" + ] + }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 607, "id": "2ad19283", "metadata": {}, "outputs": [ @@ -440,10 +511,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "[3.20496996 3.20699473 3.21421738 3.22005222 3.20905709 3.21894745\n", - " 3.22517355 3.22892437 3.23323314 3.23746919]\n", - "[0.01915174 0.00784216 0.00592618 0.00426631 0.01291295 0.00768498\n", - " 0.00482359 0.01022511 0.00438647 0.01188811]\n" + "[3.20529679 3.20732177 3.21454516 3.2203806 3.20938434 3.21927571\n", + " 3.22550245 3.22925365 3.23356286 3.23779934]\n", + "[0.01903074 0.00776638 0.00588125 0.00423125 0.01272429 0.00760543\n", + " 0.00476765 0.00998087 0.00424581 0.01168613]\n" ] } ], @@ -461,7 +532,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 608, "id": "5f59d6c9", "metadata": {}, "outputs": [ @@ -469,8 +540,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "K-medio: 3.222622761146456\n", - "sigmaC: 0.002054455999024885\n" + "K-medio: 3.22307834012753\n", + "sigmaC: 0.0020227911977321114\n" ] } ], @@ -494,9 +565,50 @@ "print(\"sigmaC: \", uA)" ] }, + { + "cell_type": "markdown", + "id": "21baebb4", + "metadata": {}, + "source": [ + "## Analisi con regressioni e grafici\n", + "Ogni blocco ha:\n", + "- Regressione\n", + "- grafico\n", + "- chi^2\n", + "\n", + "Nota: Ax + B" + ] + }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 609, + "id": "5be377eb", + "metadata": {}, + "outputs": [], + "source": [ + "sns.set_theme(style=\"whitegrid\")\n", + "\n", + "data = pd.DataFrame({\n", + " \"x\": este,\n", + " \"ux\": ueste,\n", + " \"y\": - F,\n", + " \"uy\": uF\n", + "})" + ] + }, + { + "cell_type": "markdown", + "id": "6ec60a92", + "metadata": {}, + "source": [ + "### Regressione lineare \"OLS\"\n", + "\n", + "Non tiene conto dei nostri errori, un risultato puro e semplice" + ] + }, + { + "cell_type": "code", + "execution_count": 610, "id": "aefe7756", "metadata": {}, "outputs": [ @@ -506,11 +618,11 @@ "text": [ " OLS Regression Results \n", "==============================================================================\n", - "Dep. Variable: F R-squared: 1.000\n", + "Dep. Variable: y R-squared: 1.000\n", "Model: OLS Adj. R-squared: 1.000\n", "Method: Least Squares F-statistic: 3.114e+05\n", - "Date: Fri, 03 Apr 2026 Prob (F-statistic): 1.19e-19\n", - "Time: 11:31:18 Log-Likelihood: -14.035\n", + "Date: Sun, 05 Apr 2026 Prob (F-statistic): 1.19e-19\n", + "Time: 21:52:51 Log-Likelihood: -14.036\n", "No. Observations: 10 AIC: 32.07\n", "Df Residuals: 8 BIC: 32.68\n", "Df Model: 1 \n", @@ -518,8 +630,8 @@ "==============================================================================\n", " coef std err t P>|t| [0.025 0.975]\n", "------------------------------------------------------------------------------\n", - "const 0.0101 0.778 0.013 0.990 -1.785 1.805\n", - "este 3.2197 0.006 558.014 0.000 3.206 3.233\n", + "const 0.0101 0.779 0.013 0.990 -1.785 1.805\n", + "x 3.2201 0.006 558.014 0.000 3.207 3.233\n", "==============================================================================\n", "Omnibus: 0.921 Durbin-Watson: 0.565\n", "Prob(Omnibus): 0.631 Jarque-Bera (JB): 0.614\n", @@ -531,86 +643,40 @@ "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", "\n", "RISULTATI REGRESSIONE:\n", - "k (pendenza) = 3.21975 ± 0.00577\n", - "intercetta = 0.01011 ± 0.77845\n", + "Aols = 3.22008 ± 0.00577\n", + "Bols = 0.01011 ± 0.77853\n", "R² = 0.99997\n" ] } ], "source": [ - "data = pd.DataFrame({\n", - " \"este\": este,\n", - " \"ueste\": ueste,\n", - " \"F\": - F,\n", - " \"uF\": uF\n", - "})\n", - "\n", - "\n", - "X = sm.add_constant(data[\"este\"])\n", - "model = sm.OLS(data[\"F\"], X).fit()\n", + "X = sm.add_constant(data[\"x\"])\n", + "model = sm.OLS(data[\"y\"], X).fit()\n", "\n", "print(model.summary())\n", "\n", "# Estrazione parametri\n", - "intercetta = model.params[\"const\"]\n", - "pente = model.params[\"este\"]\n", - "u_intercetta = model.bse[\"const\"]\n", - "u_pente = model.bse[\"este\"]\n", + "Bols = model.params[\"const\"]\n", + "Aols = model.params[\"x\"]\n", + "uBols = model.bse[\"const\"]\n", + "uAols = model.bse[\"x\"]\n", "R2 = model.rsquared\n", "\n", "print(\"\\nRISULTATI REGRESSIONE:\")\n", - "print(f\"k (pendenza) = {pente:.5f} ± {u_pente:.5f}\")\n", - "print(f\"intercetta = {intercetta:.5f} ± {u_intercetta:.5f}\")\n", + "print(f\"Aols = {Aols:.5f} ± {uAols:.5f}\")\n", + "print(f\"Bols = {Bols:.5f} ± {uBols:.5f}\")\n", "print(f\"R² = {R2:.5f}\")" ] }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 611, "id": "8d795186", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Chi^2 = 18.49884\n", - "Gradi di libertà = 8\n", - "Chi^2 ridotto = 2.31235\n", - "Probabilità P(0 → chi^2) = 0.98222\n" - ] - } - ], - "source": [ - "## X^2 sui dai fatti così\n", - "F_fit = intercetta + pente * data[\"este\"]\n", - "sigma = np.sqrt(data[\"uF\"]**2 + (pente * data[\"ueste\"])**2)\n", - "\n", - "\n", - "chi2_val = np.sum( ((data[\"F\"] - F_fit) / sigma)**2 )\n", - "\n", - "N = len(data)\n", - "nu = N - 2\n", - "\n", - "chi2_red = chi2_val / nu\n", - "P = chi2.cdf(chi2_val, df=nu)\n", - "\n", - "\n", - "print(f\"Chi^2 = {chi2_val:.5f}\")\n", - "print(f\"Gradi di libertà = {nu}\")\n", - "print(f\"Chi^2 ridotto = {chi2_red:.5f}\")\n", - "print(f\"Probabilità P(0 → chi^2) = {P:.5f}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "id": "1d42b009", - "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -620,47 +686,41 @@ } ], "source": [ - "\n", - "sns.set_theme(style=\"whitegrid\")\n", - "\n", "plt.figure(figsize=(10,6))\n", "\n", "# Seaborn scatter\n", - "sns.scatterplot(\n", - " data=data,\n", - " x=\"este\",\n", - " y=\"F\",\n", - " s=7\n", + "sns.scatterplot( data=data,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", ")\n", "\n", "# Barre d’errore\n", "plt.errorbar(\n", - " data[\"este\"],\n", - " data[\"F\"],\n", - " xerr=data[\"ueste\"],\n", - " yerr=data[\"uF\"],\n", - " fmt=\"none\",\n", - " ecolor=\"gray\",\n", - " elinewidth=1,\n", - " capsize=3,\n", - " alpha=0.7\n", + " data[\"x\"],\n", + " data[\"y\"],\n", + " xerr=data[\"ux\"],\n", + " yerr=data[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", ")\n", "\n", "# Linea di regressione\n", - "xfit = np.linspace(0, data[\"este\"].max(), 200)\n", - "yfit = intercetta + pente * xfit\n", - "\n", + "xfit = np.linspace(0, data[\"x\"].max(), 200)\n", + "yfit = Bols + Aols * xfit\n", "\n", "plt.plot(\n", - " xfit,\n", - " yfit,\n", - " color=\"crimson\",\n", - " linewidth=1,\n", - " zorder=10,\n", - " label=\"Fit lineare\"\n", + " xfit,\n", + " yfit,\n", + " color=\"crimson\",\n", + " linewidth=1,\n", + " zorder=10,\n", + " label=\"Fit lineare OLS\"\n", ")\n", "\n", - "\n", "plt.xlim(left=0)\n", "plt.ylim(bottom=0)\n", "\n", @@ -671,211 +731,75 @@ "plt.legend()\n", "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", "\n", - "plt.show()\n" + "plt.show()" ] }, { "cell_type": "code", - "execution_count": 35, - "id": "986ff4a6", + "execution_count": 612, + "id": "1d42b009", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Chi^2 = 18.49884\n", - "Gradi di libertà = 8\n", - "Chi^2 ridotto = 2.31235\n", - "Probabilità P(0 → chi^2) = 0.98222\n" + "Chi² = 19.38156\n", + "GdL = 8\n", + "Chi² rid = 2.42269\n", + "P(0, chi²)= 0.98705\n", + "\n", + "\n", + "############################################################\n", + "capiamo quale dato sta contribuendo maggiormente\n", + "0 0.611114\n", + "1 2.711326\n", + "2 0.899704\n", + "3 0.003816\n", + "4 0.723766\n", + "5 0.013567\n", + "6 1.272428\n", + "7 0.818954\n", + "8 10.045360\n", + "9 2.281521\n", + "dtype: float64\n" ] } ], "source": [ - "F_fit = intercetta + pente * data[\"este\"]\n", - "sigma = np.sqrt(data[\"uF\"]**2 + (pente * data[\"ueste\"])**2)\n", + "F_fit = Bols + Aols * data[\"x\"]\n", + "sigma = np.sqrt(data[\"uy\"]**2 + (Aols * data[\"ux\"])**2)\n", "\n", - "chi2_val = np.sum( ((data[\"F\"] - F_fit) / sigma)**2 )\n", + "chi2_val = np.sum( ((data[\"y\"] - F_fit) / sigma)**2 )\n", "\n", "N = len(data)\n", "nu = N - 2\n", "\n", "chi2_red = chi2_val / nu\n", - "P = chi2.cdf(chi2_val, df=nu)\n", + "Pols = chi2.cdf(chi2_val, df=nu)\n", "\n", "\n", - "print(f\"Chi^2 = {chi2_val:.5f}\")\n", - "print(f\"Gradi di libertà = {nu}\")\n", - "print(f\"Chi^2 ridotto = {chi2_red:.5f}\")\n", - "print(f\"Probabilità P(0 → chi^2) = {P:.5f}\")\n" + "print(f\"Chi² = {chi2_val:.5f}\")\n", + "print(f\"GdL = {nu}\")\n", + "print(f\"Chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {Pols:.5f}\")\n", + "print(\"\\n\\n\" + \"#\"*60)\n", + "print(\"capiamo quale dato sta contribuendo maggiormente\")\n", + "print(((data[\"y\"] - F_fit) / sigma)**2)" ] }, { - "cell_type": "code", - "execution_count": 36, - "id": "ef0817f4", + "cell_type": "markdown", + "id": "9f26f65e", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0 0.603364\n", - "1 2.659042\n", - "2 0.885979\n", - "3 0.003753\n", - "4 0.702764\n", - "5 0.013285\n", - "6 1.242733\n", - "7 0.779930\n", - "8 9.404606\n", - "9 2.203380\n", - "dtype: float64" - ] - }, - "execution_count": 36, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ - "((data[\"F\"] - F_fit) / sigma)**2" + "### Regressione lineare Carpi" ] }, { "cell_type": "code", - "execution_count": 37, - "id": "cebe6742", - "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", - "
esteuesteFuF
061.284250.363594196.414180.140117
1121.451500.293563389.494320.144254
2181.096700.330580582.084160.150848
3241.765750.316453778.498340.159795
460.167250.238141193.080140.140069
5119.812450.282516385.669980.144147
6180.481500.265846582.084160.150848
759.645200.183831192.589840.140062
8120.314250.157014389.004020.144240
960.669050.218535196.414180.140117
\n", - "
" - ], - "text/plain": [ - " este ueste F uF\n", - "0 61.28425 0.363594 196.41418 0.140117\n", - "1 121.45150 0.293563 389.49432 0.144254\n", - "2 181.09670 0.330580 582.08416 0.150848\n", - "3 241.76575 0.316453 778.49834 0.159795\n", - "4 60.16725 0.238141 193.08014 0.140069\n", - "5 119.81245 0.282516 385.66998 0.144147\n", - "6 180.48150 0.265846 582.08416 0.150848\n", - "7 59.64520 0.183831 192.58984 0.140062\n", - "8 120.31425 0.157014 389.00402 0.144240\n", - "9 60.66905 0.218535 196.41418 0.140117" - ] - }, - "execution_count": 37, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "data" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "id": "2d4b7144", + "execution_count": 613, + "id": "6a910226", "metadata": {}, "outputs": [ { @@ -883,10 +807,10 @@ "output_type": "stream", "text": [ "Ax + B : \n", - "A = 3.21951 +- 0.00470\n", - "B = 0.42600 +- 0.57172\n", - "cov_AB = -0.002417\n", - "p-value chi² = 0.9584088\n" + "AC = 3.2199 +- 0.0046\n", + "BC = 0.4357 +- 0.5627\n", + "cov_ABC = -0.002350\n", + "P(0, chi²)= 0.9661\n" ] } ], @@ -940,62 +864,23 @@ " return A, B, sigma_A, sigma_B, cov_AB, chi\n", "\n", "\n", - "A, B, sA, sB, covAB, chi = reg_lin(data[\"este\"], data[\"F\"], data[\"ueste\"], data[\"uF\"])\n", + "AC, BC, uAC, uBC, covABC, chiC = reg_lin(data[\"x\"], data[\"y\"], data[\"ux\"], data[\"uy\"])\n", "print(\"Ax + B : \")\n", - "print(f\"A = {A:.5f} +- {sA:.5f}\")\n", - "print(f\"B = {B:.5f} +- {sB:.5f}\")\n", - "print(f\"cov_AB = {covAB:.6f}\")\n", - "print(f\"p-value chi² = {chi:.7f}\")\n", - "\n", - "\n" + "print(f\"AC = {AC:.4f} +- {uAC:.4f}\")\n", + "print(f\"BC = {BC:.4f} +- {uBC:.4f}\")\n", + "print(f\"cov_ABC = {covABC:.6f}\")\n", + "print(f\"P(0, chi²)= {chiC:.4f}\")\n" ] }, { "cell_type": "code", - "execution_count": 39, - "id": "32e9948f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Chi^2 = 16.05746\n", - "Gradi di libertà = 8\n", - "Chi^2 ridotto = 2.00718\n", - "Probabilità P(0 → chi^2) = 0.95843\n" - ] - } - ], - "source": [ - "F_fit = B + A * data[\"este\"]\n", - "sigma = np.sqrt(data[\"uF\"]**2 + (A * data[\"ueste\"])**2)\n", - "\n", - "\n", - "chi2_val = np.sum( ((data[\"F\"] - F_fit) / sigma)**2 )\n", - "\n", - "N = len(data)\n", - "nu = N - 2\n", - "\n", - "chi2_red = chi2_val / nu\n", - "P = chi2.cdf(chi2_val, df=nu)\n", - "\n", - "\n", - "print(f\"Chi^2 = {chi2_val:.5f}\")\n", - "print(f\"Gradi di libertà = {nu}\")\n", - "print(f\"Chi^2 ridotto = {chi2_red:.5f}\")\n", - "print(f\"Probabilità P(0 → chi^2) = {P:.5f}\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "id": "e2407a04", + "execution_count": 614, + "id": "b49ec5a3", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1005,44 +890,41 @@ } ], "source": [ - "\n", - "sns.set_theme(style=\"whitegrid\")\n", - "\n", "plt.figure(figsize=(10,6))\n", "\n", "# Seaborn scatter\n", "sns.scatterplot(\n", - " data=data,\n", - " x=\"este\",\n", - " y=\"F\",\n", - " s=7\n", + " data=data,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", ")\n", "\n", "# Barre d’errore\n", "plt.errorbar(\n", - " data[\"este\"],\n", - " data[\"F\"],\n", - " xerr=data[\"ueste\"],\n", - " yerr=data[\"uF\"],\n", - " fmt=\"none\",\n", - " ecolor=\"gray\",\n", - " elinewidth=1,\n", - " capsize=3,\n", - " alpha=0.7\n", + " data[\"x\"],\n", + " data[\"y\"],\n", + " xerr=data[\"ux\"],\n", + " yerr=data[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", ")\n", "\n", "# Linea di regressione\n", - "xfit = np.linspace(0, data[\"este\"].max(), 200)\n", - "yfit = B + A * xfit\n", + "xfit = np.linspace(0, data[\"x\"].max(), 200)\n", + "yfit = BC + AC * xfit\n", "\n", "\n", "plt.plot(\n", - " xfit,\n", - " yfit,\n", - " color=\"crimson\",\n", - " linewidth=1,\n", - " zorder=10,\n", - " label=\"Fit lineare\"\n", + " xfit,\n", + " yfit,\n", + " color=\"crimson\",\n", + " linewidth=1,\n", + " zorder=10,\n", + " label=\"Fit lineare Carpi\"\n", ")\n", "\n", "\n", @@ -1061,7 +943,453 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 615, + "id": "538ddb98", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chi² = 16.65269\n", + "GdL = 8\n", + "Chi² rid = 2.08159\n", + "P(0, chi²)= 0.96606\n", + "\n", + "\n", + "############################################################\n", + "capiamo quale dato sta contribuendo maggiormente\n", + "0 1.288557\n", + "1 4.292682\n", + "2 1.730222\n", + "3 0.095836\n", + "4 1.932287\n", + "5 0.311997\n", + "6 0.452119\n", + "7 0.042871\n", + "8 5.653755\n", + "9 0.852360\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "F_fit = BC + AC * data[\"x\"]\n", + "sigma = np.sqrt(data[\"uy\"]**2 + (AC * data[\"ux\"])**2)\n", + "\n", + "\n", + "chi2_val = np.sum( ((data[\"y\"] - F_fit) / sigma)**2 )\n", + "\n", + "N = len(data)\n", + "nu = N - 2\n", + "\n", + "chi2_red = chi2_val / nu\n", + "PC = chi2.cdf(chi2_val, df=nu)\n", + "\n", + "\n", + "print(f\"Chi² = {chi2_val:.5f}\")\n", + "print(f\"GdL = {nu}\")\n", + "print(f\"Chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {PC:.5f}\")\n", + "print(\"\\n\\n\" + \"#\"*60)\n", + "print(\"capiamo quale dato sta contribuendo maggiormente\")\n", + "print(((data[\"y\"] - F_fit) / sigma)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "4ec42f61", + "metadata": {}, + "source": [ + "### Regressione lineare pesata Yorkfit " + ] + }, + { + "cell_type": "code", + "execution_count": 616, + "id": "c7f54cf3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AY = 3.2199987 ± 0.0046395\n", + "BY = 0.4236310 ± 0.5627057\n", + "cov_ABY = -0.0023499728735626884\n", + "chi² = 16.65212\n", + "chi² rid = 2.08151\n", + "P(0, chi²)= 0.96606\n" + ] + } + ], + "source": [ + "def york_fit(x, y, sx, sy, max_iter=50, tol=1e-15):\n", + " # Pesi iniziali\n", + " wx = 1 / sx**2\n", + " wy = 1 / sy**2\n", + "\n", + " # Stima iniziale della pendenza (OLS y|x)\n", + " A = np.cov(x, y, aweights=wy)[0,1] / np.cov(x, x, aweights=wy)[0,1]\n", + "\n", + " for _ in range(max_iter):\n", + " A_old = A\n", + "\n", + " # 1) Pesi combinati\n", + " Wi = (wx * wy) / (A**2 * wy + wx)\n", + "\n", + " # 2) x e y pesati (eq. 10)\n", + " X_bar = np.sum(Wi * x) / np.sum(Wi)\n", + " Y_bar = np.sum(Wi * y) / np.sum(Wi)\n", + "\n", + " # 3) Variabili centrate\n", + " Ui = x - X_bar\n", + " Vi = y - Y_bar\n", + "\n", + " # 4) beta\n", + " beta_i = Wi * (Ui / wy + A * Vi / wx)\n", + "\n", + " # 5) Aggiornamento pendenza\n", + " A = np.sum(Wi * beta_i * Vi) / np.sum(Wi * beta_i * Ui)\n", + "\n", + " # Convergenza\n", + " if abs(A - A_old) < tol:\n", + " break\n", + "\n", + " # 6) Intercetta\n", + " B = Y_bar - A * X_bar\n", + "\n", + " # S = somma Wi (xi - x)**2\n", + " S = np.sum(Wi * Ui**2)\n", + "\n", + " sA = np.sqrt(1 / S)\n", + " sB = np.sqrt(1 / np.sum(Wi) + X_bar**2 * sA**2)\n", + "\n", + " # cov(A,B)\n", + " cov_AB = -X_bar * sA**2\n", + "\n", + " # CHI QUADRATO\n", + " chi2 = np.sum(Wi * (Vi - A * Ui)**2)\n", + " dof = len(x) - 2\n", + " chi2_red = chi2 / dof\n", + "\n", + " return A, B, sA, sB, cov_AB, chi2, chi2_red\n", + "\n", + "AY, BY, uAY, uBY, cov_ABY, chi2_val, chi2_red = york_fit(data.x, data.y, data.ux, data.uy)\n", + "PY = chi2.cdf(chi2_val, df=nu)\n", + "\n", + "\n", + "print(f\"AY = {AY:.7f} ± {uAY:.7f}\")\n", + "print(f\"BY = {BY:.7f} ± {uBY:.7f}\")\n", + "print(f\"cov_ABY = {cov_ABY}\")\n", + "print(f\"chi² = {chi2_val:.5f}\")\n", + "print(f\"chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {PY:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 617, + "id": "fc824066", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "# Seaborn scatter\n", + "sns.scatterplot( data=data,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", + ")\n", + "\n", + "# Barre d’errore\n", + "plt.errorbar(\n", + " data[\"x\"],\n", + " data[\"y\"],\n", + " xerr=data[\"ux\"],\n", + " yerr=data[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", + ")\n", + "\n", + "# Linea di regressione\n", + "xfit = np.linspace(0, data[\"x\"].max(), 200)\n", + "yfit = BY + AY * xfit\n", + "\n", + "plt.plot(\n", + " xfit,\n", + " yfit,\n", + " color=\"crimson\",\n", + " linewidth=1,\n", + " zorder=10,\n", + " label=\"Fit lineare York\"\n", + ")\n", + "\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "\n", + "\n", + "plt.xlabel(\"Δx (mm)\")\n", + "plt.ylabel(\"Forza F (mN)\")\n", + "plt.title(\"Legge di Hooke — punti permutati con errorbar\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "15a6fec5", + "metadata": {}, + "source": [ + "## Raccolta finale dei dati caso statico" + ] + }, + { + "cell_type": "code", + "execution_count": 618, + "id": "1203e1a0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RISULTATI senza ERRORE STRUMENTALE INCLUSO:\n", + "Media pesata K = 3.22308 ± 0.00202\n", + "\n", + "RISULTATI REGRESSIONE OLS:\n", + "Aols = 3.22008 ± 0.00577\n", + "Bols = 0.01011 ± 0.77853\n", + "P(0, chi²)= 0.98705\n", + "\n", + "RISULTATI REGRESSIONE Carpi:\n", + "Ac = 3.21989 ± 0.00464\n", + "Bc = 0.43570 ± 0.56269\n", + "P(0, chi²)= 0.96606\n", + "\n", + "RISULTATI REGRESSIONE York:\n", + "Ay = 3.22000 ± 0.00464\n", + "By = 0.42363 ± 0.56271\n", + "P(0, chi²)= 0.96606\n" + ] + } + ], + "source": [ + "print(\"RISULTATI senza ERRORE STRUMENTALE INCLUSO:\")\n", + "print(f\"Media pesata K = {media:.5f} ± {uA:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE OLS:\")\n", + "print(f\"Aols = {Aols:.5f} ± {uAols:.5f}\")\n", + "print(f\"Bols = {Bols:.5f} ± {uBols:.5f}\")\n", + "print(f\"P(0, chi²)= {Pols:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE Carpi:\")\n", + "print(f\"Ac = {AC:.5f} ± {uAC:.5f}\")\n", + "print(f\"Bc = {BC:.5f} ± {uBC:.5f}\")\n", + "print(f\"P(0, chi²)= {PC:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE York:\")\n", + "print(f\"Ay = {AY:.5f} ± {uAY:.5f}\")\n", + "print(f\"By = {BY:.5f} ± {uBY:.5f}\")\n", + "print(f\"P(0, chi²)= {PY:.5f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "2dcfef24", + "metadata": {}, + "source": [ + "## Aggiunta degli errori strumentali" + ] + }, + { + "cell_type": "code", + "execution_count": 619, + "id": "aaa95426", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "u_strum_m = 0.004082\n", + "u_strum_Dx = 0.020000\n", + "uF_strum = 0.088914\n", + "uK_strum = 0.019742\n" + ] + } + ], + "source": [ + "res_b = 0.01\n", + "res_c = 0.02\n", + "\n", + "# Incertezza strumentale su una differenza: res/sqrt(12) * sqrt(2) = res/sqrt(6)\n", + "u_strum_m = res_b / np.sqrt(6)\n", + "u_strum_Dx = res_c #incertezza delle misure di C DISCUTERE\n", + "\n", + "# Massimo tra campionario e strumentale, punto per punto\n", + "ueste_strum = np.maximum(ueste, u_strum_Dx)\n", + "umasse_strum = np.maximum(umasse, u_strum_m)\n", + "\n", + "# Worst-case scalare: prendi il massimo anche di ueste_strum\n", + "uF_strum = np.max(np.sqrt( (g * umasse_strum)**2 + (masse * ug)**2 ))\n", + "uDx_strum = np.max(ueste_strum)\n", + "\n", + "uK_strum = np.max(np.sqrt( (1/este)**2 * uF_strum**2 + (F/este**2)**2 * uDx_strum**2 ))\n", + "\n", + "print(f\"u_strum_m = {u_strum_m:.6f}\")\n", + "print(f\"u_strum_Dx = {u_strum_Dx:.6f}\")\n", + "print(f\"uF_strum = {uF_strum:.6f}\")\n", + "print(f\"uK_strum = {uK_strum:.6f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "23be271e", + "metadata": {}, + "source": [ + "### Propapazione dell'errore strumentale max" + ] + }, + { + "cell_type": "code", + "execution_count": 620, + "id": "a9f2a9fc", + "metadata": {}, + "outputs": [], + "source": [ + "# Media pesata\n", + "uA_fin = np.sqrt(uA**2 + uK_strum**2)\n", + "\n", + "# OLS\n", + "uAols_fin = np.sqrt(uAols**2 + uK_strum**2)\n", + "uBols_fin = np.sqrt(uBols**2 + uK_strum**2)\n", + "\n", + "# Carpi\n", + "uAC_fin = np.sqrt(uAC**2 + uK_strum**2)\n", + "uBC_fin = np.sqrt(uBC**2 + uK_strum**2)\n", + "\n", + "# York\n", + "uAY_fin = np.sqrt(uAY**2 + uK_strum**2)\n", + "uBY_fin = np.sqrt(uBY**2 + uK_strum**2)\n", + "\n", + "\n", + "# Nuovo uy e ux per ricalcolare i chi^2\n", + "uy_fin = np.sqrt(data[\"uy\"]**2 + uF_strum**2)\n", + "ux_fin = np.sqrt(data[\"ux\"]**2 + uDx_strum**2)\n", + "\n", + "# OLS\n", + "F_fit_ols = Bols + Aols * data[\"x\"]\n", + "sigma_ols = np.sqrt(uy_fin**2 + (Aols * ux_fin)**2)\n", + "chi2_ols = np.sum(((data[\"y\"] - F_fit_ols) / sigma_ols)**2)\n", + "GdL = len(data) - 2\n", + "\n", + "# Carpi\n", + "F_fit_c = BC + AC * data[\"x\"]\n", + "sigma_c = np.sqrt(uy_fin**2 + (AC * ux_fin)**2)\n", + "chi2_c = np.sum(((data[\"y\"] - F_fit_c) / sigma_c)**2)\n", + "\n", + "# York\n", + "F_fit_y = BY + AY * data[\"x\"]\n", + "sigma_y_ = np.sqrt(uy_fin**2 + (AY * ux_fin)**2)\n", + "chi2_y = np.sum(((data[\"y\"] - F_fit_y) / sigma_y_)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "41baee7a", + "metadata": {}, + "source": [ + "## Risultati della propagazione dell'errore strumentale massimo" + ] + }, + { + "cell_type": "code", + "execution_count": 621, + "id": "c95874fb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RISULTATI CON ERRORE STRUMENTALE INCLUSO:\n", + "Media pesata K = 3.22308 ± 0.01985\n", + "\n", + "RISULTATI REGRESSIONE OLS:\n", + "Aols = 3.22008 ± 0.02057\n", + "Bols = 0.01011 ± 0.77878\n", + "Chi² OLS = 4.80671 | rid = 0.60084 | P = 0.22198\n", + "\n", + "RISULTATI REGRESSIONE Carpi:\n", + "AC = 3.21989 ± 0.02028\n", + "BC = 0.43570 ± 0.56303\n", + "Chi² Carpi = 5.14076 | rid = 0.64260 | P = 0.25757\n", + "\n", + "RISULTATI REGRESSIONE York:\n", + "AY = 3.22000 ± 0.02028\n", + "BY = 0.42363 ± 0.56305\n", + "Chi² York = 5.14358 | rid = 0.64295 | P = 0.25787\n" + ] + } + ], + "source": [ + "print(\"RISULTATI CON ERRORE STRUMENTALE INCLUSO:\")\n", + "print(f\"Media pesata K = {media:.5f} ± {uA_fin:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE OLS:\")\n", + "print(f\"Aols = {Aols:.5f} ± {uAols_fin:.5f}\")\n", + "print(f\"Bols = {Bols:.5f} ± {uBols_fin:.5f}\")\n", + "print(f\"Chi² OLS = {chi2_ols:.5f} | rid = {chi2_ols/GdL:.5f}\" f\" | P = {chi2.cdf(chi2_ols, df=GdL):.5f}\")\n", + "\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE Carpi:\")\n", + "print(f\"AC = {AC:.5f} ± {uAC_fin:.5f}\")\n", + "print(f\"BC = {BC:.5f} ± {uBC_fin:.5f}\")\n", + "print(f\"Chi² Carpi = {chi2_c:.5f} | rid = {chi2_c/GdL:.5f}\" f\" | P = {chi2.cdf(chi2_c, df=GdL):.5f}\")\n", + "\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE York:\")\n", + "print(f\"AY = {AY:.5f} ± {uAY_fin:.5f}\")\n", + "print(f\"BY = {BY:.5f} ± {uBY_fin:.5f}\")\n", + "print(f\"Chi² York = {chi2_y:.5f} | rid = {chi2_y/GdL:.5f}\" f\" | P = {chi2.cdf(chi2_y, df=GdL):.5f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "fb210b61", + "metadata": {}, + "source": [ + "# Dinamica Sonar\n", + "Qui specifico la formula perché non è così ovvia:\n", + "- $M_{eq} = M + \\frac m 3$\n", + "- $\\omega = \\frac{2\\pi}{T} \\quad \\Rightarrow \\quad T = \\frac{2\\pi}{\\omega}$\n", + "- A: coefficiente della regressione lineare $A = \\frac{T^2}{M_{eq}}$\n", + "- $K = \\frac{4 \\pi^2}{A}$\n", + "\n", + "Nota: nelle formule comparirà un $/1000$, questo serve a riportare il valore in unità di misura standard: N/m" + ] + }, + { + "cell_type": "code", + "execution_count": 622, "id": "95dde99f", "metadata": {}, "outputs": [ @@ -1075,31 +1403,155 @@ "3 1.390456\n", "4 1.627202\n", "Name: w, dtype: float64\n", - "0 0.001474\n", - "1 0.000711\n", - "2 0.001334\n", - "3 0.002013\n", - "4 0.003266\n", + "0 0.000301\n", + "1 0.000145\n", + "2 0.000272\n", + "3 0.000411\n", + "4 0.000667\n", "dtype: float64\n" ] } ], "source": [ - "## Dinamica davvero\n", - "\n", "Meq = df.m + ( m_mol / 3 )\n", "uMeq = np.sqrt( df.um**2 + um_mol**2 / 9 )\n", "\n", "T2 = ( 2 * np.pi / df.w )**2\n", - "uT2 = np.sqrt( (8*np.pi**2 / df.w**3)**2 * df.uw**2 ) \n", + "uT2 = np.sqrt( (8*np.pi**2 / df.w**3)**2 * df.uw**2 )\n", + "\n", "print(T2)\n", "print(uT2)" ] }, + { + "cell_type": "markdown", + "id": "7bd743d4", + "metadata": {}, + "source": [ + "## Calcolo dei K e media pesata\n", + "- Calcolo della Meq (massa equivalente)\n", + "- Calcolo della media pesata sui K" + ] + }, { "cell_type": "code", - "execution_count": 42, - "id": "1bb433f0", + "execution_count": 623, + "id": "8c9f5b44", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 3.189874\n", + "1 3.202365\n", + "2 3.215332\n", + "3 3.229734\n", + "4 3.245789\n", + "dtype: float64\n", + "0 0.001449\n", + "1 0.000541\n", + "2 0.000772\n", + "3 0.000963\n", + "4 0.001334\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "Ad = T2 / Meq\n", + "uAd = np.sqrt( (1/Meq)**2 * uT2**2 + (T2/Meq**2)**2 * uMeq**2 )\n", + "\n", + "Kd = 4 * np.pi**2 / Ad\n", + "uKd = np.sqrt( (4 * np.pi**2 / Ad**2)**2 * uAd**2 )\n", + "\n", + "Kd /= 1000\n", + "uKd /= 1000\n", + "\n", + "print(Kd)\n", + "print(uKd)" + ] + }, + { + "cell_type": "code", + "execution_count": 624, + "id": "0d899f17", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "K-medio: 3.212034524173708\n", + "sigmaC: 0.0003724442799985059\n" + ] + } + ], + "source": [ + "def mediaPesata(x, ux, dim = 0):\n", + " x_arr = x.to_numpy() if isinstance(x, (pd.Series, pd.DataFrame)) else np.asarray(x)\n", + " sigma_arr = ux.to_numpy() if isinstance(ux, (pd.Series, pd.DataFrame)) else np.asarray(ux)\n", + "\n", + " w = 1.0 / (sigma_arr ** 2)\n", + "\n", + " num = np.nansum(w * x_arr, axis=dim)\n", + " den = np.nansum(w, axis=dim)\n", + "\n", + " media = num / den\n", + " sigma = np.sqrt(1.0 / den)\n", + "\n", + " return media, sigma\n", + "\n", + "KdM, uKdM = mediaPesata(Kd, uKd)\n", + "print(\"K-medio:\", KdM)\n", + "print(\"sigmaC: \", uKdM)" + ] + }, + { + "cell_type": "markdown", + "id": "6741544e", + "metadata": {}, + "source": [ + "## Analisi con regressioni e grafici\n", + "Ogni blocco ha:\n", + "- Regressione\n", + "- grafico\n", + "- chi^2\n", + "\n", + "Nota: Ax + B" + ] + }, + { + "cell_type": "code", + "execution_count": 625, + "id": "4b4c2682", + "metadata": {}, + "outputs": [], + "source": [ + "sns.set_theme(style=\"whitegrid\")\n", + "\n", + "datad = pd.DataFrame({\n", + " \"x\": Meq,\n", + " \"ux\": uMeq,\n", + " \"y\": T2,\n", + " \"uy\": uT2\n", + "})" + ] + }, + { + "cell_type": "markdown", + "id": "ad203fbd", + "metadata": {}, + "source": [ + "### Regressione lineare \"OLS\"\n", + "\n", + "Non tiene conto dei nostri errori, un risultato puro e semplice" + ] + }, + { + "cell_type": "code", + "execution_count": 626, + "id": "90d191d5", "metadata": {}, "outputs": [ { @@ -1108,11 +1560,11 @@ "text": [ " OLS Regression Results \n", "==============================================================================\n", - "Dep. Variable: tmp2 R-squared: 1.000\n", + "Dep. Variable: y R-squared: 1.000\n", "Model: OLS Adj. R-squared: 1.000\n", "Method: Least Squares F-statistic: 7.624e+04\n", - "Date: Fri, 03 Apr 2026 Prob (F-statistic): 1.05e-07\n", - "Time: 11:31:19 Log-Likelihood: 23.705\n", + "Date: Sun, 05 Apr 2026 Prob (F-statistic): 1.05e-07\n", + "Time: 21:52:52 Log-Likelihood: 23.705\n", "No. Observations: 5 AIC: -43.41\n", "Df Residuals: 3 BIC: -44.19\n", "Df Model: 1 \n", @@ -1121,7 +1573,7 @@ " coef std err t P>|t| [0.025 0.975]\n", "------------------------------------------------------------------------------\n", "const 0.0219 0.004 5.124 0.014 0.008 0.035\n", - "masse 0.0120 4.35e-05 276.124 0.000 0.012 0.012\n", + "x 0.0120 4.35e-05 276.124 0.000 0.012 0.012\n", "==============================================================================\n", "Omnibus: nan Durbin-Watson: 1.430\n", "Prob(Omnibus): nan Jarque-Bera (JB): 0.670\n", @@ -1133,9 +1585,11 @@ "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", "\n", "RISULTATI REGRESSIONE:\n", - "B) = 0.0120187 ± 0.0000435\n", - "intercetta = 0.02190 ± 0.00427\n", - "R² = 0.99996\n" + "Adols = 0.01202 ± 0.00004\n", + "Bdols = 0.02190 ± 0.00427\n", + "R² = 0.99996\n", + "Kdols = 3.28476 ± 0.01190\n", + "KBdols = 1.80288 ± 0.35183\n" ] }, { @@ -1148,65 +1602,43 @@ } ], "source": [ - "dfDin = pd.DataFrame({\n", - " \"masse\": Meq,\n", - " \"umasse\": uMeq,\n", - " \"tmp2\": T2,\n", - " \"utmp2\": uT2\n", - "})\n", - "\n", - "\n", - "X = sm.add_constant(dfDin[\"masse\"])\n", - "model = sm.OLS(dfDin[\"tmp2\"], X).fit()\n", + "X = sm.add_constant(datad[\"x\"])\n", + "model = sm.OLS(datad[\"y\"], X).fit()\n", "\n", "print(model.summary())\n", "\n", "# Estrazione parametri\n", - "intercetta = model.params[\"const\"]\n", - "pente = model.params[\"masse\"]\n", - "u_intercetta = model.bse[\"const\"]\n", - "u_pente = model.bse[\"masse\"]\n", + "Bdols = model.params[\"const\"]\n", + "Adols = model.params[\"x\"]\n", + "uBdols = model.bse[\"const\"]\n", + "uAdols = model.bse[\"x\"]\n", "R2 = model.rsquared\n", "\n", + "# Calcolo del K dai parametri\n", + "Kdols = (2*np.pi)**2 / Adols / 1000\n", + "uKdols = np.sqrt( (4*np.pi**2 / Adols**2)**2 * uAdols**2 ) / 1000\n", + "KBdols = (2*np.pi)**2 / Bdols / 1000\n", + "uKBdols = np.sqrt( (4*np.pi**2 / Bdols**2)**2 * uBdols**2 ) / 1000\n", + "\n", + "\n", + "\n", "print(\"\\nRISULTATI REGRESSIONE:\")\n", - "print(f\"B) = {pente:.7f} ± {u_pente:.7f}\")\n", - "print(f\"intercetta = {intercetta:.5f} ± {u_intercetta:.5f}\")\n", - "print(f\"R² = {R2:.5f}\")" + "print(f\"Adols = {Adols:.5f} ± {uAdols:.5f}\")\n", + "print(f\"Bdols = {Bdols:.5f} ± {uBdols:.5f}\")\n", + "print(f\"R² = {R2:.5f}\")\n", + "print(f\"Kdols = {Kdols:.5f} ± {uKdols:.5f}\")\n", + "print(f\"KBdols = {KBdols:.5f} ± {uKBdols:.5f}\")" ] }, { "cell_type": "code", - "execution_count": 43, - "id": "67d16b84", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "K : 3.284762657868823\n", - "uK : 3.786606732225535e-06\n" - ] - } - ], - "source": [ - "\n", - "K = (2*np.pi)**2 / pente / 1000\n", - "uK = np.sqrt( (4*np.pi / pente**2)**2 * u_pente**2 ) / 1e6\n", - "\n", - "print(\"K : \", K)\n", - "print(\"uK :\", uK)" - ] - }, - { - "cell_type": "code", - "execution_count": 44, + "execution_count": 627, "id": "a0ba5c8d", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1216,63 +1648,111 @@ } ], "source": [ - "sns.set_theme(style=\"whitegrid\")\n", - "\n", "plt.figure(figsize=(10,6))\n", "\n", "# Seaborn scatter\n", - "sns.scatterplot(\n", - " data=dfDin,\n", - " x=\"masse\",\n", - " y=\"tmp2\",\n", - " s=7\n", + "sns.scatterplot( data=datad,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", ")\n", "\n", "# Barre d’errore\n", "plt.errorbar(\n", - " dfDin[\"masse\"],\n", - " dfDin[\"tmp2\"],\n", - " xerr=dfDin[\"umasse\"],\n", - " yerr=dfDin[\"utmp2\"],\n", - " fmt=\"none\",\n", - " ecolor=\"gray\",\n", - " elinewidth=1,\n", - " capsize=3,\n", - " alpha=0.7\n", + " datad[\"x\"],\n", + " datad[\"y\"],\n", + " xerr=datad[\"ux\"],\n", + " yerr=datad[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", ")\n", "\n", "# Linea di regressione\n", - "xfit = np.linspace(0, dfDin[\"masse\"].max(), 200)\n", - "yfit = intercetta + pente * xfit\n", - "\n", + "xfit = np.linspace(0, datad[\"x\"].max(), 200)\n", + "yfit = Bdols + Adols * xfit\n", "\n", "plt.plot(\n", - " xfit,\n", - " yfit,\n", - " color=\"crimson\",\n", - " linewidth=1,\n", - " zorder=10,\n", - " label=\"Fit lineare\"\n", + " xfit, yfit,\n", + " color=\"crimson\", linewidth=1, zorder=10, label=\"Fit lineare OLS\"\n", ")\n", "\n", - "\n", "plt.xlim(left=0)\n", "plt.ylim(bottom=0)\n", "\n", "\n", "plt.xlabel(\"Meq (g)\")\n", "plt.ylabel(\"T^2 (s^2)\")\n", - "plt.title(\"Legge di Stocazzo — punti permutati con errorbar\")\n", + "plt.title(\"Legge di ??\")\n", "plt.legend()\n", "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", "\n", - "plt.show()\n" + "plt.show()" ] }, { "cell_type": "code", - "execution_count": 45, - "id": "859f2337", + "execution_count": 628, + "id": "3c7c05e6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chi² = 226.04638\n", + "GdL = 3\n", + "Chi² rid = 75.34879\n", + "P(0, chi²)= 1.00000\n", + "\n", + "\n", + "############################################################\n", + "capiamo quale dato sta contribuendo maggiormente\n", + "0 64.351872\n", + "1 52.297643\n", + "2 83.029405\n", + "3 11.357915\n", + "4 15.009549\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "F_fit = Bdols + Adols * datad[\"x\"]\n", + "sigma = np.sqrt(datad[\"uy\"]**2 + (Adols * datad[\"ux\"])**2)\n", + "\n", + "chi2_val = np.sum( ((datad[\"y\"] - F_fit) / sigma)**2 )\n", + "\n", + "N = len(datad)\n", + "nu = N - 2\n", + "\n", + "chi2_red = chi2_val / nu\n", + "Pdols = chi2.cdf(chi2_val, df=nu)\n", + "\n", + "\n", + "print(f\"Chi² = {chi2_val:.5f}\")\n", + "print(f\"GdL = {nu}\")\n", + "print(f\"Chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {Pdols:.5f}\")\n", + "print(\"\\n\\n\" + \"#\"*60)\n", + "print(\"capiamo quale dato sta contribuendo maggiormente\")\n", + "print(((datad[\"y\"] - F_fit) / sigma)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "a1296a66", + "metadata": {}, + "source": [ + "### Regressione lineare Carpi" + ] + }, + { + "cell_type": "code", + "execution_count": 629, + "id": "698e3c48", "metadata": {}, "outputs": [ { @@ -1280,10 +1760,12 @@ "output_type": "stream", "text": [ "Ax + B : \n", - "A = 0.0120540 +- 0.0000313\n", - "B = 0.0198573 +- 0.0025536\n", - "cov_AB = -0.000000\n", - "p-value chi² = 0.9131\n" + "AdC = 0.01205 ± 0.00001\n", + "BdC = 0.01985 ± 0.00053\n", + "cov_ABdC = -0.000000\n", + "P(0,chi²)= 1.00000\n", + "KdC = 3.27519 ± 0.00175\n", + "KBdC = 1.98906 ± 0.05297\n" ] } ], @@ -1337,197 +1819,172 @@ " return A, B, sigma_A, sigma_B, cov_AB, chi\n", "\n", "\n", - "A, B, sA, sB, covAB, chi = reg_lin(dfDin[\"masse\"], dfDin[\"tmp2\"], dfDin[\"umasse\"], dfDin[\"utmp2\"])\n", + "AdC, BdC, uAdC, uBdC, covABdC, chidC = reg_lin(datad[\"x\"], datad[\"y\"], datad[\"ux\"], datad[\"uy\"])\n", + "\n", + "# Calcolo del K dai parametri\n", + "KdC = (2*np.pi)**2 / AdC / 1000\n", + "uKdC = np.sqrt( (4*np.pi**2 / AdC**2)**2 * uAdC**2 ) / 1000\n", + "KBdC = (2*np.pi)**2 / BdC / 1000\n", + "uKBdC = np.sqrt( (4*np.pi**2 / BdC**2)**2 * uBdC**2 ) / 1000\n", + "\n", "print(\"Ax + B : \")\n", - "print(f\"A = {A:.7f} +- {sA:.7f}\")\n", - "print(f\"B = {B:.7f} +- {sB:.7f}\")\n", - "print(f\"cov_AB = {covAB:.6f}\")\n", - "print(f\"p-value chi² = {chi:.4f}\")\n", - "\n", - "\n" + "print(f\"AdC = {AdC:.5f} ± {uAdC:.5f}\")\n", + "print(f\"BdC = {BdC:.5f} ± {uBdC:.5f}\")\n", + "print(f\"cov_ABdC = {covABdC:.6f}\")\n", + "print(f\"P(0,chi²)= {chidC:.5f}\")\n", + "print(f\"KdC = {KdC:.5f} ± {uKdC:.5f}\")\n", + "print(f\"KBdC = {KBdC:.5f} ± {uKBdC:.5f}\")\n" ] }, { "cell_type": "code", - "execution_count": 46, - "id": "fef04a85", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "K nostro: 3.275133343668113\n", - "uK nostro: 0.0001776827257612153\n" - ] - } - ], - "source": [ - "K = (2*np.pi)**2 / A / 1000\n", - "uK = np.sqrt( (4*np.pi / A**2)**2 * uA**2 ) / 1e6\n", - "\n", - "print(\"K nostro: \", K)\n", - "print(\"uK nostro:\", uK)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "id": "5b191469", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Chi^2 = 6.57093\n", - "Gradi di libertà = 3\n", - "Chi^2 ridotto = 2.19031\n", - "Probabilità P(0 → chi^2) = 0.91309\n" - ] - } - ], - "source": [ - "F_fit = B + A * dfDin[\"masse\"]\n", - "sigma = np.sqrt(dfDin[\"utmp2\"]**2 + (A * dfDin[\"umasse\"])**2)\n", - "\n", - "\n", - "chi2_val = np.sum( ((dfDin[\"tmp2\"] - F_fit) / sigma)**2 )\n", - "\n", - "N = len(dfDin)\n", - "nu = N - 2\n", - "\n", - "chi2_red = chi2_val / nu\n", - "P = chi2.cdf(chi2_val, df=nu)\n", - "\n", - "\n", - "print(f\"Chi^2 = {chi2_val:.5f}\")\n", - "print(f\"Gradi di libertà = {nu}\")\n", - "print(f\"Chi^2 ridotto = {chi2_red:.5f}\")\n", - "print(f\"Probabilità P(0 → chi^2) = {P:.5f}\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": 48, - "id": "ee9d9744", + "execution_count": 630, + "id": "a0ab8534", "metadata": {}, "outputs": [ { "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2MAAAIsCAYAAAB/SHEEAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAoKlJREFUeJzs3Xd4FPX6NvB7tqSTCiRUERAEQSmCFEUPYgFUUGmCGgQUBRuohyJSpQhKC1U6SJciqCDYQMHGsVEUkSZFSnpPtsz7B+/ml5BkN2125knuz3Wd6zrs7Hz32blnxn0yTVFVVQURERERERF5lUnvAoiIiIiIiCoiNmNEREREREQ6YDNGRERERESkAzZjREREREREOmAzRkREREREpAM2Y0RERERERDpgM0ZERERERKQDNmNEREREREQ6YDNGRERERESkAzZjREREGnvqqafw1FNP5fz7/PnzaNiwIbZu3apjVUREpDc2Y0RE5DVbt25Fw4YNcfjwYb1LEeH8+fN4++238cADD+C2225D586dsX79+jzv+euvvzBq1Ch06tQJzZo1Q7du3bBnzx6dKiYiouKw6F0AERFRRVOjRg38/vvvsFjc/2d43rx5+PXXX9GtWzdERETgs88+w/jx4+Hr64vHHnsMADBp0iSkp6ejT58+CAgIwJYtW/Dyyy9j5cqVaNOmjTe+DhERlRCbMSIiIi9TFAW+vr4e39evXz9MnjwZZrMZAPD444+jU6dO2LlzZ04z9vrrr+O2227LmeeRRx5B27Zt8fHHH7MZIyIyOJ6mSEREhnP58mWMGjUK7dq1Q5MmTdC1a1d8+OGH+d534cIFPP/882jWrBnatm2LKVOm4JtvvkHDhg3xww8/5Hnv2rVrce+99+LWW29Fjx49cOjQoXzXcgFAdnY25s6di/vuuw9NmjTB3XffjenTpyM7O7tItW/cuBGdOnXK8znXK+o1Y02bNs1pxADAYrHAYrHAZrPlvJa7EQMAHx8fmEymPO8hIiJj4pExIiIylNjYWPTq1QuKoqBfv34IDw/H/v378eabbyI1NRX9+/cHAKSnpyM6OhpXr17F008/jcqVK+Pjjz/O14QBwLp16zBx4kTcfvvt6N+/Py5cuIChQ4ciODgYUVFROe9zOp144YUX8L///Q+9evVCvXr18Ndff2HVqlU4c+YMFixY4Lb2zZs3Y+zYsWjevDmio6Nx7tw5vPDCCwgJCUG1atVKvWzWrFmDc+fOYejQoYW+Z+bMmcjKyso5ckZERMbFZoyIiAxl1qxZcDgc2LlzJ8LCwgAATzzxBIYPH4558+ahT58+8PPzw8aNG3Hu3DnMnz8fnTp1AgD06dMH3bt3zzNednY25syZg6ZNm2LVqlU512k1bNgQI0eOzNOM7dy5EwcPHsSaNWtw++2357x+0003Ydy4cfj555/RokWLAuu22WyYNWsWGjVqhNWrV8PHxwcAUL9+fbz11lulbsZ27NiByZMno0+fPnj00UcLfM/ixYuxYsUKvPbaa7jjjjtK9XlERKQ9nqZIRESGoaoq9uzZg44dO0JVVcTHx+f8784770RKSgqOHj0KAPjmm28QGRmJe++9N2d+X19f9OrVK8+YR44cQWJiInr16pXnhhkPP/wwQkJC8rx39+7dqFevHurWrZvns13XXhV01C3358TFxaFPnz45jRgAPProo6hUqVLJFwqAkydPYvTo0bj33nsxbty4At9z8OBBzJw5E0899RSee+65Un0eERF5B4+MERGRYcTHxyM5ORkbN27Exo0bC30PcO16sdq1a0NRlDzTa9euneffFy9eLPB1i8WCGjVq5Hnt7NmzOHnyJNq2bVvgZ8fFxRVau+tzbrjhhjyvW61W1KpVq9D5iuLTTz+FzWbDuHHjYDIV/HfUHTt2IDAwEP/9739L9VlEROQ9bMaIiMgwnE4ngGt3BCzsVLyGDRtq+vkNGjTAqFGjCpye+5RGb0pMTAQAVK1a1e17QkND8xyVIyIiY2MzRkREhhEeHo7AwEA4nU60a9fO7Xtr1KiBv//+G6qq5jk69s8//+R5X/Xq1XNez32rd7vdjgsXLuRp7mrXro0///wTbdu2zXfEzRPX55w9ezbPkTWbzYbz58/j5ptvLtZ4ud1+++1QVdXte+6++240bty4xJ9BRETex2vGiIjIMMxmMx544AF89tln+Ouvv/JNd52iCAB33nknLl++jC+++CLntaysLGzatCnPPE2aNEFoaCg2bdoEu92e8/rOnTuRlJSU572dO3fG5cuX840BAJmZmUhPTy+09iZNmiA8PBwbNmzIcxv8bdu2ITk52c239qxly5bo16+f2/fcfffd+W5eQkRExsYjY0RE5HVbtmzBN998k+/1p59+Gq+99hp++OEH9OrVCz179kT9+vWRlJSEo0eP4rvvvsOPP/4IAOjduzc++OADvPbaa3j66adRpUoV7Ny5M+dhyq4jWz4+PnjppZcwadIkREdHo3Pnzrhw4QK2bt2a7zqybt26YdeuXRg3bhx++OEHtGjRAg6HA6dOncLu3buxdOlSNG3atMDvZLVa8eqrr2Ls2LGIjo5Gly5dcP78eWzdurXU14zNnDkT27Ztw/Hjxwt9z4gRI3DhwgV8+eWXpfosIiLyHjZjRETkdevXry/w9cceewxRUVHYvHkz5s+fj71792L9+vUIDQ1F/fr18frrr+e8NzAwEKtWrcLbb7+N1atXIyAgAN27d0fz5s3x0ksv5TRlAPDkk09CVVWsWLEC77zzDm6++WYsXLgQb7/9dp73mUwmzJ8/HytXrsRHH32EvXv3wt/fHzVr1sRTTz2FG2+80e336t27NxwOB5YtW4bp06ejQYMGWLhwIebMmVPKJUZEROWRono6CZ2IiEiQlStXYurUqdi/fz8iIyMLfZ/T6UTbtm1x33334e233/ZihURERNfwmjEiIhIrMzMzz7+zsrKwceNG1KlTJ08jlpWVle8GGNu3b0diYiJat27tlVqJiIiux9MUiYhIrBdffBHVq1fHzTffjNTUVOzYsQOnTp3Cu+++m+d9v/76K6ZOnYoHH3wQoaGhOHbsGD788EM0aNAADz74oE7VExFRRcdmjIiIxLrzzjvx4YcfYufOnXA4HKhfvz5mzZqFLl265HlfjRo1EBUVhTVr1iApKQkhISHo1q0bXn/9dT6Xi4iIdMNrxoiIiIiIiHTAa8aIiIiIiIh0wGaMiIiIiIhIB7xmrBC//PILVFWF1WrVuxQiIiIiItKRzWaDoiho3rx5mY7LZqwQqqrmuw0yERERERFVPFr1BWzGCmG1WqGqKpo0aQJFUfQuh4pIVVXYbDZYrVbmJgyzk4m5ycTc5GJ2MjE3mXLnduTIEU0+g9eMERERERER6YDNGBERERERkQ7YjBEREREREemAzRgREREREZEO2Iy5wQssZeLjCORidjIxN5mYm1zMTibmJpPWufFuih4UpSFzOByw2WxeqIaodKxWK8xms95lFIh//JCJucnE3ORidjIxN5m8kRubMQ9UVS00CFVVcenSJSQmJnq3KHLLXWYEhIaGIioqynDLSFVVOBwOmM1mw9VGhWNuMjE3uZidTMxNpty5aYXNmBueHu7masSqVq2KgIAAblwG4HpYt6IozOM6qqoiPT0dV65cAQBUq1ZN54ryczqdhj1yR4VjbjIxN7mYnUzMTSatc2MzVkIOhyOnEYuIiNC7HPr/2Iy55+/vDwC4cuUKqlatyv8oEBEREemIN/AoIdc1YgEBATpXQlQ8rnWW1zkSERER6YvNWCnx6AtJw3WWiIiIyBjYjLnBH60yMTe5eNqkTMxNJuYmF7OTibnJpHVubMY8qAg/7GNiYtCwYcN8/3vooYcAAA0bNsSyZcty3r9161bs3LmzSGN37NgREydOzPn3yJEjc8bVgutaMT1yO3ToEF544QW0bdsWTZo0QYcOHfD666/j8OHDXq1j69ataNiwIeLj4736uaWlKArvMiUQc5OJucnF7GRibjJ5IzfewMODinKbdD8/P6xatSrfawCwceNGVK9ePef1bdu2ISAgAA8//HCxP2fIkCFIT08vXbFu5L4DpjdzW7t2LSZNmoQ2bdrgzTffRGRkJC5fvoydO3diwIAB+Omnn7xWyz333IONGzciODjYa59ZFnjzFZmYm0zMTS5mJxNzkyl3blphM+aGp1vblycmkwnNmjUrcFphr5dE7dq1y2yswhR3o8nOzobFYoHJVLIDxX/++SemTJmCbt26Ydq0aXk++6GHHsJXX31VonFzy8zMzGmOPQkPD0d4eHipP1MPdrtd8yfdU9ljbjIxN7mYnUzMTSatc+NpiuRR7tMUn3rqKfz444/4+uuvc05njImJKfJY15+m6Dql7tixYxg0aBCaNWuG+++/H9u3b88379dff42ePXvi1ltvRZs2bTBu3Lg8R9nS09MxceJEdO7cGc2aNUPHjh0xduxYpKSk5BnHderkkiVL8J///Ae33nprzoO7t27diocffhhNmzbFXXfdhVmzZsHhcLj9TqtXr4aiKBgxYkSBTeB//vOfnP+/fft2PPHEE2jdujVatWqFp556Cr///nue98fExKB58+b4/fff0bt3bzRt2hRr167F+fPn0bBhQ2zbtg2jR49Gy5Yt0bp1a0ydOhV2uz3fMpV2miIRERFRRcMjY5Qj9w96AAWeIztu3Di88cYb8PPzw4gRIwAAUVFRpf7s119/Hb169cIzzzyDTZs2YeTIkWjatCnq1asHANi9ezeGDRuGxx57DC+99BKuXr2K9957D8nJyZg1axaAa0ePnE4nXn31VYSHh+PSpUtYtGgRhgwZgjVr1uT5vD179uCGG27Am2++CZPJhICAAKxYsQIzZsxAdHQ0Ro4ciZMnT+Y0Y6+//nqhtf/0009o0qRJkY5GnT9/Ht27d0ft2rWRnZ2NTz75BP369cOOHTtw44035rzPZrPhtddeQ//+/TFs2DCEhobmTJs5cybuvPNOzJ49G8eOHcPcuXNhtVrd1khERERExsNmjABcO6p0yy235Hlt+vTp6NatW57X6tevj6CgIAQEBJTp6Yv9+vVDv379AADNmzfHvn378Nlnn2HIkCFQVRXTp09Hly5dMHny5Jx5qlSpgueeew5DhgzBTTfdhPDwcIwfPz7nNEWHw4GaNWuib9++OH36dL5mZ8mSJTnP3EpNTcXcuXMxaNAgDB8+HADQvn17WK1WTJs2DQMHDkRYWFiBtV++fBlNmzYt0vd88cUXc/6/0+lE+/bt8fvvv2Pbtm05n+uqb9iwYejSpUvOa+fPnwdw7VTPqVOnAgDuuusuZGZmYsWKFXj22WcREhJSpDqIiIiIjCo+Ph7ff/892rRpI/bSi6JiM+ZGSS/Ws525CGdSiuc3ljFTSCVY61T3/MYC+Pn54YMPPsjzWq1atcqirCK58847c/5/QEAAqlevjkuXLgEATp8+jQsXLmD06NF5jt61bt0aJpMJR44cwU033QQA+Oijj7By5UqcPXs2zymMZ86cydOM3XHHHXke2P3LL78gPT0dDz74YJ7PaNeuHTIzM3HixAm0bt260PqLuq6cPHkSM2fOxC+//IK4uLg89V3v7rvvLnCM++67L8+/H3jgASxYsAB//fUXWrVqVaQ6jIoXNcvE3GRibnIxO5mYW9ElJSXh2LFjaNSoke7NmNa5sRnzoLgBOOIS8c8dTwBOp0YVuWE2o87R7TBHhBZ7VpPJVOSjO1qoVKlSnn9brVZkZ2cDABISEgAAQ4cOLXDef//9FwCwd+9ejBgxAr179845te/q1asYOnQosrKy8swTERGR59+uz3j00UfdfkZBIiMjcfHixUKnu6SmpmLAgAEIDw/HyJEjUb16dfj6+mLMmDH56vP390dgYGCB41y/U6pcuTIA4OrVqx5rMDJFUXhhs0DMTSbmJhezk4m5FZ0zMwtZK3ai+pmzSOuSrWst3siNzVgZM0eEovYP63U7MlaSRszoXNdLjR07Frfeemu+6VWrVgVw7bqyRo0a5Xmu2Y8//ljgmNc32a7T++bNm1fgNXA1a9YstL7WrVtjx44dSExMzHNt1/V+/fVXXLp0CYsXL8bNN9+c83pKSkq+z3T3R4Drb8wRGxsL4Nppm0REREQSZWRkIOnT/UibvATmC1fhuOtmbPjsMJ4LDkFQgA/8/f3h7++vd5lljs2YByV5tkBJTxWUwmq15juSo6W6desiKioK586dy7murCCZmZmwWq1wOp05z/Eo6sOpmzdvDn9/f1y6dCnfaYCePPXUU9i+fTveeeednGu5cvv6669xzz33IDMzEwDy/IXl559/xoULF3JOsyyKvXv3on///jn//uyzz+Dv748GDRoUq26jUVUVdrsdFouFp3IIwtxkYm5yMTuZmJt72Sf/wdmXJsP60zHE1quOL3veiczKPrDF/41PPklCgJ8FTZo0QcuWLb1aV+7ctMJmzI2K9Jyx4qhbty62b9+OL7/8ElWqVEHVqlURGRmp2ecpioKRI0fi9ddfR3p6Ou655x74+/vj4sWL2LdvH4YNG4Ybb7wR7dq1w8SJE7FgwQI0b94c+/fvx3fffVekzwgODsbLL7+MGTNm4NKlS2jdujXMZjPOnTuHL774AjExMYX+Nebmm2/G6NGjMWnSJFy+fBmPP/54zkOfP/nkExw6dAg//vgjmjVrhoCAAEyYMAHPPfccLl++jJiYmGIvu3/++QejRo1Cly5dcOzYMbz//vuIjo4uFzfv4DYnE3OTibnJxexkYm75OVPTkTBzNRIXbYQpPBjH+nfClZtrIfPfBMCeCj9fK3ys+j6JS+vcDNWMnT17FsuWLcNvv/2GEydOoG7duvj444+LNO/ly5cxc+ZM7Nu3D+np6ahRowZeeOEFPPLIIxpXXfE8++yz+OeffzBixAgkJyfjxRdfxEsvvaTpZ3bu3BnBwcFYtGhRztGuGjVq4K677sq5ZqpPnz44d+4c1q5di+XLl+POO+/Ee++9h169ehXpMwYMGIDIyEisWLECH3zwASwWC2rXro177rnH4/nC/fr1y3ke28SJE5Gamorw8HC0adMGK1asAHDt2q45c+Zg+vTpGDJkCOrUqYMJEyZg6dKlxVoWw4YNw48//ohXXnkFZrMZffv2xbBhw4o1BhEREZFeVFVF6tbPETd+AZyJyQgb/jT8Bj6Kyuq1ey789fcpfPXF5/jPvXejQf26AFAuT1EEAEU1UJv++eefY9KkSbjttttw+vRpqKpapGbsypUr6NWrF2688Ub07dsXQUFBOHHiBAICAtCjR48S1XL48GGoqoqmTZsWeDg5MzMz53bpfn5+JfoMKnuqquacWlreTgM4f/487r33XsyZMwcPPvhgiccx6rqrqipsNhusVmu5y648Y24yMTe5mJ1MzO3/ZB0+gdhRs5H5w+8IfOhuREx8EdZaea+dP336NLZs2YLHH388z92wvS13bkeOHAGAMr/hnaGOjHXs2BGdOnUCAIwcOTLnS3syY8YMREVFYenSpTCbzQCAtm3balYnEREREREVnSM+CfHTliJ51Q5Y69dCtS2zENDh9gLfGxISgsaNG5eLSzA8MVQzZjIV/5zQ1NRU7Nq1C1OmTMlpxMpKRf/LhVTMTS7e9lcm5iYTc5OL2clUUXNTHQ4kr9mJ+ClLALsDEROGImTgY1Cshbch4eHh6NKlixerLBxvbe/B0aNHYbPZYLFY8OSTT+KXX35BaGgounfvjldffbXUC5A/7GUpz3nVrFkTx48f17sMzZTn7Moz5iYTc5OL2clUUXPL+P53xI6ajewjJ1DpiS4IHzMYlqr6PsS5OLyRm/hmzPWMpTFjxqBXr1548cUX8fvvv2Pu3LkwmUx47bXXSjW+6zbpuSmKknNnFdc1SrmnuV4vSO55C5pWmnk5rnvMBnleu37d9Ua97uYFAIfDAZPJ5HabK+uapI1rtJoA97kZrd6KlI2n3HI/BsQo9ZZm3ooyLsBtTuK4gDG3Oa3Gtf17FfETFiJ1y174Nr8Z1Xctgl/LxuL2EbnvRaAV8c2Y03ntrivt2rXDyJEjAQBt2rRBWloali9fjqFDh5b4JgWui/ZyB2AymXKeNeAKqKBmzDU9t6JMc/cDuSTjXj92RRjX3Y6wsPeURb2lmdeb47o4nU7YbLY8r+Vev6+fBiDnwmOHw5Gz7bm4np2iqteeyVHQuK5tqqBxXZ95/Q8Ms9kMs9lc4LiKouTMa7fb831f1zSn0wmHw5FnWmnGdX3Xgsb1tAx9fHwAwO0ydDeup2VY0LhlsQwLG9dkMsFut+f7gaHVMtQyG3frt7tlWJRxgbLPxt13dY1bUE2KosBiseSbpyjj6r2P0Gr9lraPKGib03sZenP9lriPMJvNcDgcBf6wN+I+oqTjKnYHUpdtRcJ7q6D4+SLs3dcQ2PtBKCZTnhuYSNlHuPaVJpNJs6ZMfDMWHBwM4FoDllvbtm2xaNEinD17Fg0bNizx+O7ueuN63dP04kwrSsglGbcoY5f3ca//oWiEmvQY17WjMZlMbk/jLWiaa7zcO/GC3lPYuO6m5a6psPzczevugYwmk6nQa1K1Ghdwf565u2VYmnpLmg3g/rsWZdzC1kWtlmFZj1va9buwcV20yqa0y7Cw3PRYhnqt39L2Ee62OSPvI0oybnncRxS2zUlfhulf/oC4N+fCduYiggc+irA3noE5pFKeeaTtI3L/ZtLq6Jj4Zqx+/fpup2dlZZVq/Ov/8uTi+stVRkYGAgICCpzP3ZiePrOsp1WUcQs7SqlnTUYbNyMjA8C1dbikfxTQ4ru6/uJU2DZnpGWo57hGq8lTbqWpSdJyMGpNnvaVWuSm17wVZVxuczLHNeo2Vxbj2s5cROxbMUjf/S387myByBVvw7dRXU3qLc28Wu63SkN8M1ajRg00aNAABw8exJNPPpnz+sGDB+Hn5+exWSsps9mM0NBQXLlyBQAQEBCgaVBUNLnP7WUeeamqivT0dFy5cgWhoaFlfvdRIiIiqjicaRlInLsWifPXw1w5FJFLJyLwkXv4+6uYDNWMZWRkYN++fQCACxcuIDU1Fbt37wYAtG7dGuHh4YiOjsbFixexd+/enPmGDRuGIUOGYPLkybjnnntw+PBhLF++HAMHDizwqFVReVqZoqKuPaDO1ZCRMWh9oaV0oaGhOeuu0bBBlIm5ycTc5GJ2MpWX3FRVRdpHXyFu/Hw4YhMR+uITCH2pH0yB/nqXpgmtc1NUd1f4e9n58+dx7733Fjht9erVuOOOO/DUU0/hwoUL+PLLL/NM//TTT7FgwQKcOXMGVatWRe/evfHcc8+V+Ef54cOHARTtKdsOh6PAiwmJjMZqtZab/xgQERGRd2X9cQqxo+cg89ufEdD5TlSe+BKsdarrXZZXFKc3KA5DNWNG4lrgTZo04VEWQXiaolzMTibmJhNzk4vZySQ9N0dSChKmLUPSiu2w1qmOypNfQcC9d+hdluZy53bkyBEAZd+MGeo0RaNhnyqT3W6vsE+5l47ZycTcZGJucjE7mSTmpjqdSFn7CeImL4aamY3wMc8h9LmeUHxkfY/S0Do3NmNERERERJRH5v+OInbkbGT9+ieCej2AiLeehyWqst5llTtsxoiIiIiICABgvxKP+EmLkLJhF3ya3oTqH8+H/x236l1WucVmjIiIiIioglNtdiQt/RAJM1YCVgsqv/s6gp98CApv/KUpNmNuSLzAkpibZMxOJuYmE3OTi9nJZOTc0vcdQuzo2bD9fQ7B0d0QPmoQzGHBepdlCFrnxmbMAyNvOJSfoijiLo6la5idTMxNJuYmF7OTyai52f75F3Fj5yPtk33wa3MbIr8YD98m9fUuyzC8kRubMSIiIiKiCsSZkYXEeeuQOPcDmEKDUXXxOAQ9ei8PQuiAzZgHrmcLkAyqqsJut8NisTA3YZidTMxNJuYmF7OTySi5qaqKtE+/QdzYebD/exWhL/RG2LCnYQoK0K0mI8udm1bYjLnB54zJxNzkYnYyMTeZmJtczE4mvXPL/usMYkfPQca+Qwjo1AbVNr0Hn3q1dK1JAq1zYzNGRERERFROOVPSED9jBZKWfAhLzShErZ2GwPvb610W/X9sxoiIiIiIyhnV6UTKps8QP3ERnGnpCB8xEKEv9Ibi66N3aZQLmzEiIiIionIk89c/ETtqNrIOHUXQo/ciYvwQWKpX1bssKgCbMTd4YaxMWl5kSdpidjIxN5mYm1zMTiZv5OaITUDc5PeRsvYT+DS6EdW3z4V/++aaf255pnVu3Jo9YEMmi6IozEwoZicTc5OJucnF7GTSOjfVbkfyiu2If2cZAKDy1FcRHP0IFDbupeKN7Y0JecBb28uiqiqcTidMJhNzE4bZycTcZGJucjE7mbTMLePAL4gdNRvZf55G8FMPI3z0szBHhJbpZ1RUuXPTCpsxN/S+BSmVjMPh0HSjIe0wO5mYm0zMTS5mJ1NZ52a/cBmx4xYg7aMv4duqCWruXQLf2xqW2fh0jdbbG5sxIiIiIiIhnJlZSFqwEQlz1sAUFICq899EUI/7obBBF4nNGBERERGRwamqivQ9BxE7Zi7s5y8jZHBPhL/WH6ZKgXqXRqXAZoyIiIiIyMCyT/6DuDdjkP7F9/C/pxWqrZsOn5tu0LssKgNsxtzghbEy8Tx6uZidTMxNJuYmF7OTqSS5OVPTkTBzFRIXbYKlWhVErZqMgM538TeqF2m9vbEZ84AruyyKovD5K0IxO5mYm0zMTS5mJ1Nxc1NVFalb9iJuwkI4E5MRNvxphA7tC5O/r4ZV0vW8sb1xa/aAt7aXJfcdMJmbLMxOJuYmE3OTi9nJVJzcsg6fQOyo2cj84XcEPnwPIiYMhbVWlNYlUgG8cWd1NmNu8Nb2MtlsNlitVr3LoBJgdjIxN5mYm1zMTiZPuTnikxA/bSmSV+2A9abaqLZlFgI63O7FCqkgWm9vbMaIiIiIiHSiOhxIXr0D8VOXAnYHIiYMRcjAx6BY+TO9ImDKREREREQ6yPj+d8SOmo3sIydQqW9XhI8ZDEuVML3LIi9iM0ZERERE5EX2S7GIm7AAqR/uhW/zRqjx2WL4tWisd1mkAzZjREREREReoGZlI/H9D5Hw3iooAb6oMnskKj3RGQofV1BhsRlzQ1EU3qlIGEVR4OPjo3cZVALMTibmJhNzk4vZyaQoCmz7f8alN+fAdvZfhAx6DGFvPANzSCW9SyM3vLG9sRkjIiIiItKI7fQFxL4Vg/TPDsD/rhaIWjUFPjffqHdZZBBsxjzgc8ZkUVUVDocDZrOZuQnD7GRibjIxN7mYnRzOtAwkzF6DxAUbYKkajspLxqPSI/+BiackipF7e9MKmzE3+JwxmZxOp6YbDWmH2cnE3GRibnIxO2NTVRVp279E7PgFcMYlIuylvgh5qR8cVjbQEmm9vbEZIyIiIiIqA1nHTiJ29BxkHvgFAZ3vROWJL8Fap/q1Iyw2m97lkQGxGSMiIiIiKgVHYgoS3lmGpBXbYb2xBqptfBcBHe/QuywSgM0YEREREVEJqA4HUtZ9irjJi6FmZiPircEIebYHFB+r3qWREGzG3OB5vTJZLFytpWJ2MjE3mZibXMzOGDIPHUXsyFnI+u04gno9gIi3noclqnKh72duMmmdG9cKD9iQycJnw8nF7GRibjIxN7mYnf7sl+MQP2kRUjbuhk/Tm1DjkwXwa93U7TzMTSZv5MZmzAPe2l4WVVXhdDphMpmYmzDMTibmJhNzk4vZ6Ue12ZG09EPET18BxceKKu+9gUr9ukIpwp32mJtMuXPTCpsxN3hre5kcDgef4SEUs5OJucnE3ORidt6X/vVPiH1zDmx/n0Nw/+4IHzkQ5rDgYo3B3GTSOjc2Y0REREREBbD98y/ixs5D2if74df2NkQuHg/fJvX1LovKETZjRERERES5ODOykBizFokxa2EKC0HV98chqPu9PMWQyhybMSIiIiIiXLtEJe2T/YgbOw/2y3EIfaE3wl59CqagAL1Lo3LKUCeunj17FmPHjkW3bt3QuHFjPPTQQ8UeY+XKlWjYsCEGDx5c6nr41w+ZeD62XMxOJuYmE3OTi9lpI/v4afzbczguPzMGPjffiNrfrEbEmMFl1ogxN5m0zs1QR8ZOnDiBffv24bbbboPT6Sz2DTSuXr2K+fPnIyIiosxqYkMmi6IofI6HUMxOJuYmE3OTi9mVPUdyKhJmrEDS0i2w1qqGqLXvIPD+dmX6GcxNJm/kZqi1omPHjujUqRMAYOTIkThy5Eix5p8xYwY6duyIixcvalEeCcHHEcjF7GRibjIxN7mYXdlQnU6kbNyN+EmL4UzLQPjIQQh9vhcUXx9tPo+5iaR1boY6Xlqaw4CHDh3C559/jtdee63M6lFVlbe3F0ZVVdhsNuYmELOTibnJxNzkYnZlI/PXP3Gh6xBcfXkq/O9qgdrffYCwV57UtBFjbvJ4IzdDHRkrKYfDgUmTJuH5559H1apV9S6HiIiIiAwgPj4e33//Pdq0aYPw8HA4YhMQ9/ZipKz7FD6N66L6RzHwb9dM7zKpAisXzdi6deuQkZGB/v37l/nYBXXCiqIU2iG7DmO6m67VvBwXOfMVlltp6i3NvBzX87yuad7e5qSNa7SaXPNpsc1JWg5GrcnTX3ONVq8RazLauK5p3OaKNm5iYiKOHTuGhvVvgunDL5DwznLApCBiyisIjn4EisWSZxwt95UlnVfvZWikcb1dk+s1HhlzIy4uDnPnzsU777wDH5+yP7Rss9nynCdqMplyLuSz2Wz53u+qweFwwOl05plmsVigKAqcTiccDkeeaa5xXYdDr2e1Wgsd12w2w2w2Q1VV2O32PNMURcmZ126351uZtBq3KN8VyL8MSzuu2WzOGff683utVisURSn2d/WUuR7L0DVuQTVplY3ruxa2DF3juluGntZvp9OZL7uyWL/dLUNvrt9A+dtHmEymnJpy52bUfURJ1+/yto9w1Xv9Z3oaV+99hFbrt7R9REHbnN7L0Ki/I1JSsxB2+gocT45B3Jl/UemphxEx+lkgtBLsDgeQa34t9xGefp94exmW198RWixDADk3Frw+u7IgvhmbM2cOGjZsiNtvvx3JyckAri1Mu92O5ORkBAQElOouKK6VprBphcm9kl/PZDIVen1c7pWiuON6mtfdctBqXHffFXC/DEs77vW5uf5dmu+qRzZ6LsPrlXYZeloOJpOp0G1Oq2WoVzblcR9R2L6yoqzfhY3rYtR9RGG5GXEfoccyNOI+wt02Z+R9REnGLckyjI+PR1JSEtLOXMLVsYtxz58ncblGFIIXj4FyW31YFCfCdNxHFLbNGWkZajWutH2EqzkzmUyaNGJAOWjGTp8+jZ9++gmtWrXKN61Vq1ZYsmQJOnToUKKxFUXJ+V9B0zzNW5JppZmX417baFx/VSzsPeXlu0oc1910T9lJ+64VZR+h5TYnaTkYtSZ3ubl+lBhpX1maeSvKuNzmPE/7Yf+3sK/eiQbf/YVIHwu+7XQL/r6pOgL/+hWWk7+jcePG6NKli1frNeo2J21cPWpy18CVBfHN2OjRo3OOiLlMmTIFfn5+GD58OBo2bFiq8bXqgkkbzEsuZicTc5OJucnF7AqnqirSPzuAmyeugfPiVdh63oet1WrClnUOCK6Hhzq3RKC/D0JCQrxeG3OTyRu5GaoZy8jIwL59+wAAFy5cQGpqKnbv3g0AaN26NcLDwxEdHY2LFy9i7969AIBGjRrlGyc4OBgBAQG44447Sl2TVueHkjZUVYXD4YDZbGZuwjA7mZibTMxNLmZXsOyT/yB29FxkfPkD/P/TGpU3vgufm27A48eO4+OdV/BQ55Zo0rh0f6AvDeYmU+7ctGKoZiwuLg6vvPJKntdc/169ejXuuOOOAi8W1IqWd04h7TidTk03GtIOs5OJucnE3ORidv/HmZqOhJmrkLhoEyzVqyBq9RQEPHhnTsMT6O8Di9mEQH9tnh9WHMxNJq1zM1QzVrNmTRw/ftzte9asWeNxnKK8h4iIiIhkUlUVqR/uQdyEhXAmpyLstWiEDnkCJn/fPO8LCQlB48aNdTk1kagoDNWMERERERG5k/X7X4gdNRuZPx5G4CP/QcT4IbDWiirwveHh4W5v1kGkNzZjRERERGR4jvgkxE9dguRVO2BtWAfVts5GwF0t9S6LqFTYjLnBCyxl4vnYcjE7mZibTMxNroqWnepwIHn1DsRPXQo4nIiY9BJCBjwKxSrrZ2xFy6280Do3WWuxDtiQyaIoCnd2QjE7mZibTMxNroqWXcZ3vyF21GxkH/0blfp2RfiYwbBUCdO7rGKraLmVF97Ijc2YB7y1vSyqquZkxtxkYXYyMTeZmJtcFSU7+79XETdhIVK37IVvi0ao8dli+LVorHdZJVZRcitvcuemFTZjbvDW9jLZ7XbNn5ZO2mB2MjE3mZibXOU5OzUrG4mLNyPhvVUwBfqhypyRqNSnMxSTSe/SSq0851aeaZ0bmzEiIiIi0l3a3u8QN2YubGf/RcigxxD2xjMwh1TSuywiTbEZIyIiIiLd2E6dR+xbMUjfcxD+d7VA1Kop8Ln5Rr3LIvIKNmNERERE5HXOtAwkzF6DxAUbYKkajsjlkxD40N28pooqFDZjbnBnIBNzk4vZycTcZGJucknPTlVVpG3/ErHjF8AZl4iwl/sh9KV+MAX46V2apqTnVlFpnRubMQ+44ciiKAovjhWK2cnE3GRibnJJzy7r6N+IHT0HmQd/RWCXuxAx8UVYb6iud1mak55bReWN3NiMEREREZGmHIkpiJ+2FMkrtsNatyaqbXoPAf9prXdZRLpjM+YBnzMmi6qqsNvtsFgszE0YZicTc5OJucklLTvV4UDKuk8QN/l9qJnZiBj7PEKe7QHFp2IdJZKWG12TOzetsBlzg88Zk4m5ycXsZGJuMjE3uaRkl3noKGJHzkLWb8cR1OtBRLw1GJaoynqXpRspuVFeWufGZoyIiIiIyoz9chziJy1Cysbd8Lm1AWp8sgB+rZvqXRaRIbEZIyIiIqJSU212JC35EPEzVkDxsaLKe2+gUr+uUMxmvUsjMiw2Y0RERERUKulf/4TY0XNgO3kOwc90R/jIQTCHVtK7LCLDYzPmBi+wlIm3jpWL2cnE3GRibnIZKTvbP/8ibuw8pH2yH35tb0PkkvHwvaW+3mUZkpFyo6Ljre11xoZMFuYlF7OTibnJxNzkMkp2zvRMJMasReK8dTCFhaDq++MQ1P1ew9RnNFwuMnkjNzZjHvDW9rKoqgqHwwGz2czchGF2MjE3mZibXHpnp6oq0j7eh7ix82C/Eo/QIX0Q9sqTMAUFeL0WSfTOjUomd25aYTPmBm9BKpPT6dR0oyHtMDuZmJtMzE0uvbLLPn4asaPnIGP//xBwfztU3zIb1ro1vV6HVNzmZNI6NzZjRERERFQoR3IqEqYvR9LSrbDWroaoddMReF9bvcsiKhfYjBERERFRPqrTiZQNuxD/9mI40zIRPmoQQp/vBcXXR+/SiMoNNmNERERElEfmL38gdtRsZP3vGIIe64SI8UNgqVZF77KIyh02Y27wAkuZeD62XMxOJuYmE3OTS8vs7FcTED95MVLWfQqfxvVQfcc8+Le9TbPPq0i4zcmkdW5sxjxgQyaLoijc2QnF7GRibjIxN7m0yk6125G0bBsSpi8HTAoqTxuG4KcfhmLhT8WywG1OJm/kxi3MA97aXhZVVXMyY26yMDuZmJtMzE0uLbLL+PZnXB01G7bjZxD89CMIHzUI5ojQMhmbruE2J1Pu3LTCZswN3tpeJrvdzqfcC8XsZGJuMjE3ucoqO9v5y4gbNx9pO76CX6smiNy7BL63NSyDCqkg3OZk0jo3NmNEREREFYgzMwtJ8zcgYc4amIKDUHXBGAT1uJ9HbIh0wGaMiIiIqAJQVRXpu79F7FsxsF+8itDBPRH2Wn+YggL0Lo2owmIzRkRERFTOZf/9D2JHz0HGVz/C/z+tUW3Du/CpX1vvsogqPDZjbvBwvUzMTS5mJxNzk4m5yVWc7Jyp6Uh4byUSF2+GpXoVRK2ZioAH2jN/HXCZy6R1bmzGPOCGI4uiKLw4VihmJxNzk4m5yVXU7FRVReqHexA3YSGcyakIf60/Qob2gcnP1wtV0vW4zcnkjdzYjBERERGVI1m/HUfsqNnI/OkIAh/5DyImDIW1ZqTeZRFRAdiMecDnjMmiqirsdjssFgtzE4bZycTcZGJucrnLzhGfhPgpS5C8egesDeug2tbZCLirpU6VUm7c5mTKnZtW2Iy5weeMycTc5GJ2MjE3mZibXNdnp9rtSF69E/FTlwBOFRFvv4yQZ7pDsfJnnpFwm5NJ69y4lRIREREJlfHdb4gdNRvZx06iUt8uCH9zMCxVwvQui4iKiM0YERERkTD2f68ifsJCpG79HL4tGqHGZ4vh17yR3mURUTGxGSMiIiISQs3KRvKCDUiesxamQD9UmTMSlfp0hmIy6V0aEZUAmzE3eIGlTFpeZEnaYnYyMTeZmJs8aXu/Q9yYubCd/Rchgx5H2H+fgTk4SO+yqIi4zcmkdW5cKzxgQyaLoijMTChmJxNzk4m5yWI7dR6xb8Ugfc9B+HdoiajVU+DT8Ea9y6Ji4DYnkzdyM1QzdvbsWSxbtgy//fYbTpw4gbp16+Ljjz92O8+VK1ewcuVKHDhwAP/88w8qVaqEVq1aYfjw4ahRo0apa+Kt7WVRVRVOpxMmk4m5CcPsZGJuMjE3GZxpGUiYtRqJCzfCUjUckcsnIaBrB6iqyt8nwnCbkyl3bloxVDN24sQJ7Nu3D7fddhucTmeRbiV59OhR7N27F48//jhuu+02JCQkYOHChejZsyc+/vhjhIeHl7ge3oJUJofDoelGQ9phdjIxN5mYm3GpqorU7V8gbtwCOOOTEPZyP4S+1A+mAL+c5x4xO3m4zcmkdW6GasY6duyITp06AQBGjhyJI0eOeJynZcuW2LVrV57zOVu0aIF77rkH27dvx4ABAzSrl4iIiKgsZR39G7Gj5yDz4K8I7NoBEROGwnpDdb3LIiKNGKoZK0nXGRwcnO+1qKgohIeH48qVK2VRFhEREZGmHAnJiH9nGZJXbIe1Xi1U2zwTAfe00rssItKYoZqxsnL69GnExcWhXr16epdCREREVCjV4UDK2k8QN/l9qNk2RIx7ASGDHofiY9W7NCLygnLXjKmqirfffhtVq1ZF165dSzWWoigFXjdW2Ouuaa46ijNmWczLcd1PZzb6j+tuXnfzS/yuFWUf4W66EeutSNl4ys1kMhmu3tLMK3HczJ+OIHb0HGT/dhxBvR9E+JjnYI2q4nZcd2Mb+btW9HEBY25z0sb1dk2qqrrNrSyUu2YsJiYG33//PZYuXYqAgIBSj2e32/P822Qy5VyfZrPZ8r3fx8cHwLWL/ZxOZ55pFosFiqLA6XTC4XAUOK6qqgWOa7VaCx3XbDbDbDbnXNSbm6IoOfPa7fZ8K5NW4xbluwL5l2FZjGuxWApdhoqiFPu7espcj2XoGregmrTKxvVdC1uGrnHdLUN367fr9rHXz1sW67e7ZejN9Rson/sIs9ksah9R0Liu71qR9hGufaWUfQSg3frt7X0E4pIQN3EhUjd9BuutDVD1o7nwvf0W5B6lsGVoMplgMpkMtwzL0++IgsZ1fdfS7CMsFguys7MLHBcw3j6iJOOWx32ExWKBw+GAqmpzB9Ny1Yxt2rQJ8+fPx+TJk9G2bdsyGdO1YhTEFV5Bcq/k13PtSAuSe6Uo7rie5nX30DqtxnX3XQH3y7Ak46rqtdv9FpSb69+l+a56ZOPtZehu3NIuQ3fTXH99Kuy2v1otQ72yKS/7CNd/uNztKyvK+l3YuC5G2ke4cjObzYXmZrR9RGnGBYyxj1CzbUhatAkJ762C4mtF5ffeQKW+XaAU8J3cbXOKohS6zRltH1HaccvLPqIo+0ouw/97j1H2Ea7cXH8w1kK5acb27t2L8ePH4+WXX0aPHj3KZEzXDq+wnZ077qZrNS/HRc5fPVx/eTFCTRy3aNM9ZSftu1aUfYSW25yk5WDUmtzlZrPZDLevLM28Rh83/asfETt6DmynziP4me4IHzkI5tBKxR6X25zMcY26zUkbV4+aXLlppVw0Yz/88AOGDx+Onj17YujQoXqXQ0RERAQAsJ29iLix85D26Tfwa9cMkUsnwPeW+nqXRUQGYahmLCMjA/v27QMAXLhwAampqdi9ezcAoHXr1ggPD0d0dDQuXryIvXv3AgBOnjyJoUOHok6dOujWrRt+/fXXnPHCw8NRu3Ztr38PIiIiqtic6ZlInPsBEuethykiFJHvj0dg946anepERDIZqhmLi4vDK6+8kuc1179Xr16NO+64I9/Fgr/99htSUlKQkpKCJ554Is+8jz76KKZNm6Z94URERES4djpa2s6vETduPuxX4hE6pA/CXn0KpkB/vUsjIgNSVC3v1SjY4cOHAQBNmjThX7EEcZ1L7+4CWTImZicTc5OJuWkj+8/TiH1zDjL2/w8B97dD5UkvwVq3Zpl+BrOTibnJlDu3I0eOAACaNm1app9hqCNjRsQNRhZPd8oh42J2MjE3mZhb2XIkpyJh+nIkLd0K6w3VELVuOgLvK5u7Ol+P2cnE3GTyRm5sxoiIiIiKID4+Ht9//z3atGmD8PBwqE4nUjbsQvzbi+FMy0T46GcROrgnFF8fvUslIiHYjHmg1QPeSBs8DUAuZicTc5OJuZVMUlISjh07hkaNGiHgzCXEjpqNrJ//QNDj9yFi3AuwVKuieQ3MTibmJlPu3LTCZswNXk4nE3OTi9nJxNxkYm7Fl5aRDXNyBrLHv48Ln34Ln1vqo/qOefBve5tX62B2MjE3mbTOjc0YERERUSHi4+ORlJSEtJR0/D5lDR745gc4TGY4X+0Hpfd9yAgPA++TSEQlxWaMiIiIqBDff/89ruzah1v3HkbruBT8dUsN/HzHTbBYkmHZvg2NGzdGly5d9C6TiIRiM0ZERERUANv5y2iybh9snx2Eo2l97Hj4AcQHJAPB9dCnc0sE+vsgJCRE7zKJSDA2Y27wAkuZtLzIkrTF7GRibjIxt8I5M7OQOH89Eud8AFNwEKouGIOgHvfj/j/+wsc7P8JDnVuiSeOGutXH7GRibjJpnRvXCg/YkMmiKAozE4rZycTcZGJuBVNVFem7v0XsWzGwX7yK0Od7IWx4NExBAQCAQH8fWMwmBPrrd+t6ZicTc5PJG7mxGfOAt7aXRVVVOJ1OmEwm5iYMs5OJucnE3PLL/vsfxI6eg4yvfoR/xztQbcO78KlfO897QkJC0LhxY11PTWR2MjE3mXLnphU2Y27wFqQyORwOTTca0g6zk4m5ycTcrnGmpCH+vZVIWrwZlpqRiFozFQEPtC/wB3N4eLghbtbB7GRibjJpnRubMSIiIqpwVFVF6ubPEDdhIZwpaQh/YwBChvSGyc9X79KIqAJhM0ZEREQVStZvxxE7ajYyfzqCwG4dUXnCEFhqROpdFhFVQGzGiIiIqEJwxCUifsoSJK/ZCZ+bb0T1bXPgf2cLvcsiogqMzZgbvMBSJp6PLRezk4m5yVSRclPtdiSv2oH4aUsBp4qIt19GyIDuUITearwiZVeeMDeZtM5N5l7Ii9iQyaIoCp/jIRSzk4m5yVSRcss4+CtiR89G9rFTqNS3C8LfHAxLlTC9yyqxipRdecLcZPJGblwrPOCt7WXJfQdM5iYLs5OJuclUEXKzX7yCuAkLkbr1c/i2bIwany2GX/NGepdVahUhu/KIucnkjTursxlzg7e2l8lms8FqtepdBpUAs5OJuclUXnNTs7KRuHAjEmatgSnQD1XmjkKl3g9CKUeniJXX7Mo75iaT1rmxGSMiIqJyIW3PQcSNiYHt3L8IGfQ4wt54BubgIL3LIiIqFJsxIiIiEs126jxix8xF+t7v4N+hJaLWTIFPwxv1LouIyCM2Y0RERCSSMzUdCbPXIHHhRlgiIxC54m0Edu3Aa3KISAw2Y0RERCSKqqpI3fYF4sYvgDMhCWGvPInQF/vCFOCnd2lERMXCZswNRVH41zVhFEWB1WplbgIxO5mYm0ySc8s6+jdiR81G5ne/IbDr3YiYOBTW2tX0LstrJGdXkTE3mbyRG5sxKne4o5OL2cnE3GSSlpsjIRnx05YheeV2WOvVQrXNMxFwTyu9y9KFtOzoGuYmk9a5sRnzgM8Zk0VVVTgcDpjNZuYmDLOTibnJJCk31eFAytpPEDf5fajZNkSMfwEhg3pAsVbMnzCSsqP/w9xkyp2bVirmnqyI+JwxmZxOp6YbDWmH2cnE3GSSkFvmj4dxddRsZP/+Fyr1fhDhbz0PS2SE3mXpTkJ2lB9zk0nr3NiMERERkaHYL8UibtIipG76DL63NUSNTxfCr1UTvcsiIipzbMaIiIjIENRsG5KWfIj4d1dC8bWiysz/olLfLlB4NIGIyik2Y0RERKS79C9/QOybc2E7dR4hAx5F2IiBMIdW0rssIiJNsRlzgxdYysTzseVidjIxN5mMkpvtzEXEjo1B+q5v4deuGSKXTYRv43p6l2VoRsmOioe5yaR1bmzGPGBDJouiKNzZCcXsZGJuMhkhN2d6JhLnfoDEeethighF5PvjEdi9I/+764ERsqPiY24yeSM3NmMe8Nb2sqiqmpMZc5OF2cnE3GTSMzdVVZG282vEjZsP+5V4hA59AmGvPAlToL9X65CK25xMzE2m3Llphc2YG7y1vUx2ux1Wq1XvMqgEmJ1MzE0mPXLL/vM0YkfPRsY3PyPggfaovvUlWG+s4dUaygNuczIxN5m0zo3NGBEREWnKkZSChOkrkLRsK6w3VEPU+hkI7NRG77KIiHTHZoyIiIg0oTqdSFm/C3FvL4KanoXw0c8idHBPKL4+epdGRGQIbMaIiIiozGX+fAyxo2Yj6+c/ENTjPkSMGwJLVGW9yyIiMhQ2Y27wAkuZTCaT3iVQCTE7mZibTFrlZr8Sj/jJ7yNl3SfwaXITqu+cD/82t2ryWRUVtzmZmJtMWufGZswDNmSyKIoCi4WrtUTMTibmJpMWuak2O5KWbUXC9OWAxYzK04cj+OlHoPB23mWK25xMzE0mb+TGtYKIiIhKJf2b/yF29BzY/jqL4OhHED5yEMzhIXqXRURkeGzG3PDGswWobKmqCpvNBqvVytyEYXYyMTeZyio32/nLiBs7D2k7v4Zf66aI3LsEvrc2KLtCKR9uczIxN5ly56YVNmNERERULM6MLCTOX4fEuWthCg5C1YVvIejx+/gjk4iomAzVjJ09exbLli3Db7/9hhMnTqBu3br4+OOPPc6nqiqWLFmCdevWIT4+Ho0aNcKoUaPQrFkz7YsmIiKqIFRVRfqubxD71jzY/72K0Od7IWx4NExBAXqXRkQkkqFu63LixAns27cPN9xwA+rVq1fk+ZYsWYK5c+eif//+WLx4MapUqYIBAwbg3LlzGlZLRERUcWSfOIt/e72GS9Fvwlq/NmrtX4WIsS+wESMiKgVDNWMdO3bEvn37MHfuXNxyyy1FmicrKwuLFy/GgAED0L9/f7Rt2xYzZ85EaGgoli1bpnHFRERE5ZszJQ2x4+bjXIdo2M5cQNQH01Btwwz41K+td2lEROKV6DTFP//8E//73/9w8uRJJCQkQFEUhIWFoW7dumjRogUaNWpUomJKch//n3/+GampqejcuXPOaz4+Prjvvvuwd+/eEtXhwnPfZdLyIkvSFrOTibnJ5Ck31elE6uY9iJu4EM7UdIS/MQAhQ3rD5OfrpQqpMNzmZGJuMmmdW5Gbsbi4OKxbtw7bt2/HxYsXoaoqrFYrQkJCoKoqkpOTYbPZoCgKqlWrhkcffRRPPPEEKleurGX9OHXqFACgbt26eV6vV68eVq1ahczMTPj5+ZV4fDZksjAvuZidTMxNJk+5Zf12HFdHzUbWT0cQ2K0jKk8YAkuNSC9VR+5wm5OJucnkjdyK1IzNmDED69atQ2BgIB588EG0a9cOt9xyCyIj8+6YL1++jKNHj+LAgQPYtGkTli9fjieffBKvvfaaJsUDQHJyMnx8fODrm/cvdcHBwVBVFUlJSaVqxpxOZ74gFEWBqqoFvt/1XnfTtZqX415jt9thNpsLzK009ZZmXo7reV7AfXbSvmtF2UcA2m1zkpaDUWtyl5vD4YDJZMqTmyMuEfFTliDlg49hvbkOqm2bA//2zfPUwGWo77gAtzmJ4wIFb3N61iRxXG/XpKoqnE5nic7eK6oiNWOHDh3CjBkzcO+997rtECMjIxEZGYmOHTtizJgx+OKLL7B06dIyK9bbXM8WyP2dTSZTzpO4bTZbvnl8fHwAXNvgnE5nnmkWiwWKosDpdMLhcOSZ5hrX9ZnXcx0iLWhcs9kMs9kMVVVht9vzTFMUJWdeu92eb0XTatyifFcg/zIs7bhmsxlOp7PAJtr1bI/ifldPmeuxDF3jFlSTVtm4vmthy9A1rrtl6Gn9ttvt+bIri/Xb3TL05voNlL99hMlkypmWOzej7iNKun6Xt32ExWLJ2VcCgGp3IHXNTiTNWAEFQOXJLyPw6YfhVJQ88+u9j9Bq/Za2jyhom9N7GZaX3xFa7SNcv08cDkeBv08AY+0jpP6O0GIZ5uwnVW2ePVykZmzjxo3FHlhRFHTq1AmdOnUq9rzFERwcjOzsbGRlZeU5OpacnAxFURASElKq8d09nM/dOaS5V/LrmUymQjvs3CtFccf1NK9r4/DmuO6+K+B+GZZ23ML+Ylia76pHNnouw+uVdhl6Wg4mk6nQbU6rZahXNuVxH1HYvrKirN+Fjeti1H1E5ve/IW7UHGT/cQqV+nVF+OjnYKkSBlVVUXC1hY+r9T5Cj2VoxH2Eu23OyPuIkoxbHvcRhe0ruQz/7z1G2Ue4mrPCjmiWBUM9Z6wkXNeKnT59GjfffHPO66dOnUL16tVLdYoicC24wnZ2nuYrybTSzMtx/++vFoXlpkdNHLdo0z1lJ+27VpR9hJbbnKTlYNSa3OVmv3gV8VOWIG3bF/Bt2Rg1PlsMv+aNPM6rZb2lmbeijMttTua4uU/z5e+T8ldTaYhvxlq0aIGgoCDs2rUrpxmz2WzYs2cPOnTooHN1RERExqJmZSNh4UYkzlwNU6A/qswdhUq9H4Si4TURRERUsGI1Y3///Tfef/99nDx5EmFhYejatSu6d++er1vcsWMHRowYgT/++KNYxWRkZGDfvn0AgAsXLiA1NRW7d+8GALRu3Rrh4eGIjo7GxYsXc25b7+vri8GDByMmJgbh4eFo0KAB1q9fj8TERAwcOLBYn389Lbtg0k5hh6fJ+JidTMxNjrQ9BxD7Zgzs5y8heODjCH+jP8whlfQui4qJ25xMzE0mrXMrcjN25swZ9OzZEw6HA/Xr18eJEycwatQobN68GXPmzEGVKlVKXUxcXBxeeeWVPK+5/r169WrccccdBV4s+Oyzz0JVVSxfvhzx8fFo1KgRli1bhlq1apW6JjZksiiKwp2dUMxOJuYmQ/bJc4gbMxfpn38P/7tvR7W10+DToI7eZVEJcJuTibnJ5I3cityMzZ49G4GBgVi7di1uuOEGAMBHH32ESZMmoXfv3li6dGm+Z30VV82aNXH8+HG371mzZk2+1xRFweDBgzF48OBSfX5BtLpzCmlDVdU859OTHMxOJuZmbM7UdCTMWo3ERZtgiYxA5Iq3Edj12in8rrvxMTdZuM3JxNxkyp2bVop8gvhvv/2GJ598MqcRA4Bu3bph48aNMJlM6Nu3L37//XdNitSLu2dFkHFdf9tSkoPZycTcjEdVVaRs/Rz/tHsSSe9vRtirT6HWgQ8Q9NDdOT8qmJtczE4m5iaT1rkVuRlLTExE5cqV871er149bNiwAVFRUYiOjsY333xTpgUSERFR0WUd+RsXH3kJVwZPgF+Lxqh14AOEv/EMTP6+nmcmIiKvKvJpijVq1Cj0FMLKlSvjgw8+wODBg/HCCy/wLoZERERe5khIRvzUpUhe9RGs9Wuh2oezEHD37XqXRUREbhT5yFjr1q2xe/fuQg/VBQUFYcWKFbjrrrvw5ZdfllmBREREVDjV4UDSqo/wT5u+SP1wDyImDEGtr1eyESMiEqDIR8YeffRRxMbG4siRI2jWrFmB7/Hx8cH8+fMxdepU/Pnnn2VVo254gaVMzE0uZicTc9NPxg+/I3bUbGQfPoFKfTojfMxgWCIjijQvc5OL2cnE3GTSOjdF5V0qCnT48GEAQNOmTXWuhIiIKC/7pVjETVyI1M174NvsZlSe+ir8br9F77KIiMotrXqDYj30mYiIiPSjZtuQ+P5mJLy7EoqfD6rM/C8q9esKxVTkqw6IiMhAStyMZWRkwN/fvyxrMSQ+Z0wWVVVht9thsViYmzDMTibm5j3pX/6A2Dfnwnb6AkKe6Y6wEQNhDq1UorGYm1zMTibmJlPu3LRSoj+lxcbGol+/fmVdi+HwDE6ZmJtczE4m5qYt25mL+PfpUfi39+swR0ag5pfLUHnqqyVuxFyYm1zMTibmJpPWuRW7zTt9+jQGDRpU4DPHiIiIqGw40zOROOcDJM5fD1NEKCKXTEBgt//wr+pEROVIsZqx//3vfxgyZAhuuOEGLFu2TKuaiIiIKixVVZG242vEjZsH+9UEhA59AmGvPAlTYPm/NICIqKIp8mmKu3fvxjPPPINatWph2bJlCAoK0rIuIiKici8+Ph6ffvop4uPjAQDZf57GxcdexeVBY+HT5CbU/nYNIkY/y0aMiKicKvKRsWHDhqFx48ZYsWIFKlUq3XnqUvBUEJm0vMiStMXsZGJuJZeUlIRjx47h5pq14XzvAyQt2wprneqIWj8DgZ3aaPrZzE0uZicTc5NJ69yKPLqfnx9iY2ORmJhYYZoxgA2ZNIqiMDOhmJ1MzK100tIyUfPXM3Au/i+SbXaEv/ksQgf3guJj1fRzmZtczE4m5iaTN3Ir8mmKa9euhcPhwNNPP43z589rWZOh8M43sqiqCofDwdwEYnYyMbfii4+Px+nTp3H0w11I7TsGrT77DSdrVEP66klIfKgdElJTNK+BucnF7GRibjJ5I7ciN2ONGzfGxo0b4e/vj6eeegoXLlzQrCij4AYjk8Ph0LsEKiFmJxNzK56fPvsCpweOgd8LU2CyZWD3Y7fj27vr4OPv9mHLli34/vvvvVIHc5OL2cnE3GTSOrdinQRZo0YNbNiwAS+88AKeeuopfPnll1rVRUREVK6oNjuSlm1B/XeWAyYF2cOfxE5LINTU00BwPTzUuSUC/X0QEhKid6lEROQlxb4iLTg4GCtWrMCIESO0qIeIiKjcSd9/CLGj58B24h8ERz+C8JGDYA4PQe9jx/Hxzot4qHNLNGncUO8yiYjIy0p0exAfHx/MmjWrrGshIiIqV2znLiFu7DykfbwPfnfcisjPl8K36U050wP9fWAxmxDo76NjlUREpBfeY9MN3vVGJrPZrHcJVELMTibmlp8zIwuJ89chce5amEIqoeqisQh6rFO+/66EhISgcePGupyayNzkYnYyMTeZtM6tTJuxc+fOITs7G/Xq1SvLYXXFhkwWRVG4sxOK2cnE3PJSVRVpn36DuLHzYP/3KkKf742w4U/DFBRQ4PvDw8PRpUsXL1fJ3CRjdjIxN5m8kVuJmrHVq1fjl19+yXOq4qhRo7B9+3YAQKNGjbBkyRJERESUSZF6UlWVDZkgue+AydxkYXYyMbf/k33iLGJHz0HG1z8h4N42qLbpXfjUq613WQVibnIxO5mYm0zeuLN6kW9tn9vmzZvzNFrffPMNtm3bhl69emHMmDE4f/485s2bV2ZF6oW3tpfJZrPpXQKVELOTqaLn5kxJQ+y4+TjXIRq2MxcQ9cE0RK2fbthGzKWi5yYZs5OJucmkdW4lOjJ28eLFPKci7tq1CzVr1sSECRMAALGxsfjoo4/KpkIiIiIDUp1OpG7eg7iJC+FMTUf4fwcg5IXeMPn56l0aEREJUaJm7PojRgcOHMC9996b8+8aNWogNja2dJUREREZVNZvx3F11Gxk/XQEQd07ImL8EFhqROpdFhERCVOi0xTr1KmDzz//HMC1UxSvXLmCDh065Ey/dOkSgoODy6ZCIiIig3DEJuDK8Ok4f9+zUNPSUX37XEQumcBGjIiISqRER8YGDhyI1157Da1atUJGRgbq1auHO++8M2f6Dz/8gJtvvrnMitQLL7CUibnJxexkqgi5qXY7kld+hPhpSwEAlSe/jOBnukOxyH1CTEXIrbxidjIxN5m0zq1E/xXp2rUrQkNDsW/fPgQHB6Nv376w/P//ICUmJiIkJATdunUr00L1wg1HFkVRYLVa9S6DSoDZyVQRcss48AtiR89G9h+nUenJhxAx+lmYK4fpXVapVITcyitmJxNzk8kbuSkqbxlYoMOHDwMAmjZtqnMlRESkB/vFK4gbNx+p27+E7+23oPLUV+HXTP5ZH0REVHxa9QZyz6/wEj5nTBZVVWG322GxWJibMMxOpvKYmzMzC0kLNyJh9hqYAgNQJWY0KvV6AIqpRJdZG1J5zK2iYHYyMTeZcuemlSL9l6VLly7Yvn07srOzizxwdnY2tmzZgi5dupS4OL3xoKFMzE0uZidTecotbc8BnLsrGvHTlyO4f3fU+n4tgvt0LleNmEt5yq2iYXYyMTeZtM6tSG3eo48+iqlTp2Ly5Mno2LEj2rZti1tuuQU1a9aEv78/ACA9PR3nz5/HkSNHcPDgQXz11VewWq0YOHCgpl+AiIiotLJPnkPcmLlI//x7+N/TCtXWToNPgzp6l0VEROVckZqxZ599Fk888QQ+/PBDbNu2DR999FHOIVaz2QwAcDgcAK51jzfddBNeeukl9OjRA0FBQRqVTkREVDrO1HQkzFyNxEUbYalWBZErJyOwy108jYiIiLyiyCdABgUFoX///ujfvz/Onz+PX375BadOnUJiYiIAIDQ0FHXr1kWzZs1Qq1YtreolIiIqNVVVkbr1c8SNXwBnYjLChj2N0Bf7wuTvq3dpRERUgZToarSaNWuiZs2aZV2L4fAvozJpeZElaYvZySQtt6wjfyN21Gxkfv8bAh+6GxEThsJau5reZXmdtNzo/zA7mZibTFrnxrXCAzZksiiKwsyEYnYyScrNkZCM+KlLkLxqB6z1a6Hah7MQcPftepelC0m5UV7MTibmJpM3cmMz5gFvbS+LqqpwOp0wmUzMTRhmJ5OE3FSHA8lrdiJ+yhLA7kDEhCEIGfg4FGvF/U+ghNyoYMxOJuYmU+7ctFJx/0tUBLwFqUwOh0PTjYa0w+xkMnJuGT/8jthRs5F9+AQq9emM8Leeh6VquN5lGYKRcyP3mJ1MzE0mrXNjM0ZEROWO/VIs4iYuROrmPfBt3gg1di+CX8tb9C6LiIgoDzZjRERUbqjZNiQu3oSE91ZB8fdFlVkjUKlvl3L50GYiIpKPzRgREZUL6V/8gNg358B25iJCBjyKsBEDYA6ppHdZREREhdLkT4WZmZm4ePFiieY9efIknnnmGTRr1gzt27fH9OnTkZ2d7XG+hIQEjB07Fvfccw+aNWuGhx56COvXry9RDS68wFImno8tF7OTSe/cbGcu4t+nRuHfPq/DHFUZNb9chspTXmEj5oHeuVHJMTuZmJtMWudWrCNj3333HebNm4eTJ08iLCwMXbt2xcCBA+Hv75/nfXv27MGIESPwxx9/FKuYpKQkREdHo06dOoiJicHly5cxbdo0ZGZmYuzYsW7nfeWVV3Dq1CkMHz4c1apVw/79+zF+/HiYzWb06tWrWHXkxoZMFkVR+BwPoZidTHrm5kzLQOLctUicvx6miFBELpmAwG7/4X67CLi9ycXsZGJuMnkjtyKPfuTIEQwaNAghISFo3bo1rl69ivnz52Pnzp1YsGAB6tWrV+piNmzYgLS0NMybNw+hoaEArt3BZMKECRg8eDAiIyMLnO/q1av44YcfMHXqVDz22GMAgLZt2+Lw4cP45JNPStWM8db2suS+AyZzk4XZyaRHbqqqIu2jrxA3fj4csYkIHfoEQl/uB1Ogv+eZCQC3N8mYnUzMTSZv3Fm9yMfdYmJiULNmTXz66aeYO3cu1q9fjzVr1iAzMxNPPPEEDh06VOpi9u/fj7Zt2+Y0YgDQuXNnOJ1OHDhwoND57HY7AKBSpbynpAQFBZVqIfLW9jLZbDa9S6ASYnYyeTO3rD9O4eJjr+Lys+Pg07QBan27BuGjBrERKwFub3IxO5mYm0xa51bkI2NHjx7FgAED8jRKt99+O7Zt24bnnnsOAwcOxHvvvYdOnTqVuJhTp07h8ccfz/NacHAwqlSpglOnThU6X7Vq1XDnnXdi0aJFuPHGGxEVFYX9+/fjwIEDePfdd0tcD1BwQ6YoSqGNmuuvHe6mazUvx0XOfIXlVpp6SzMvx/U8r2uat7c5aeMarSbXfFpsc7mnOZJSkDB9OZKXb4e1TnVU2/Au/Du2LnB8ZuN5movR6jViTUYb1zVN622O45btuC5GqkniuN6uyfWalgdoityMpaen5zvyBADh4eFYs2YNXnzxRbz66qsYN24cfH19S1RMcnIygoOD870eEhKCpKQkt/PGxMRg2LBh6Nq1KwDAbDZjzJgxeOCBB0pUi4vNZstzONlkMuWcO1pQp+zj4wPg2umVTqczzzSLxQJFUeB0OuFwOPJMc42rqmqB41qt1kLHNZvNMJvNUFU15yihi6IoOfPa7fZ8K5NW4xbluwL5l2FpxzWbzTnjXn8agNVqhaIoxf6unjLXYxm6xi2oJq2ycX3Xwpaha1x3y9DT+u10OvNlVxbrt7tl6M31Gyh/+wiTyZRTU+7cymoZZmdlIW3DLiRNXQY1KxuhowYi/IU+UHyssNlsXlu/y9s+wlXv9Z/paVy99xFard/S9hEFbXN6L8Py8jtCq32Ep98ngLH2EVJ/R2ixDIFr+whV1ebSpSI3Y7Vr18bvv/+Onj175pvm7++PRYsW4b///S/Gjh2LZs2alWWNHqmqilGjRuHMmTN47733UKVKFRw8eBBTpkxBSEhIToNWEq6VprBphcm9kl/PZDIVemeW3CtFccf1NK+7CxC1GtfddwXcL8PSjnt9bq5/l+a76pGNnsvweqVdhp6Wg8lkKnSb02oZ6pVNedxHFLavLOkyzPzfMcSNmo2sX/9EUI/7ET72eViiKud8jtHW78LGdTHqPqKw3Iy4j9BjGRpxH+FumzPyPqIk45an/wa6xi1sm+My/L/3GGUf4WrOTCaTJo0YUIxmrF27dtiyZQtGjx6d7+6JwLUFPnPmTISGhmL9+vUlKjg4OBgpKSn5Xk9KSkJISEih83399dfYvXs3duzYgYYNGwIA7rjjDsTFxWHatGmlasYURSl0Z+dpvpJMK828HPf/brhSWG561MRxizbdU3bSvmtF2Udosc3Zr8QjftIipGzYBZ8mN6H6x/Phf8etZVKvp2l6zevtcV0/MIy2ryzNvBVlXC3/O2e071qexjXqNidtXKPWVBpFbsZ69OgBVVVx+vRpNG7cuMD3KIqCcePG4YYbbsDx48eLXUzdunXzXRuWkpKCq1evom7duoXO9/fff8NsNqNBgwZ5Xm/UqBE2b96MjIyMAhtIT9xtMGRMrr96MDd5mJ1MZZmbarMjadkWJExfAVjMqPzu6wh+8iEohfyVk0qO25tczE4m5iaTN3IrcjNWt25djBgxokjv7d+/f4mK6dChAxYtWpTn2rHdu3fDZDKhffv2hc5Xo0YNOBwOHD9+HDfffHPO60ePHkVERESJGjGSizs6uZidTGWRW/q+Q4gdPRu2v88hOLobwkcNgjks/zXEVHa4vcnF7GRibjJpnZuhHgXep08fBAYGYujQofj222+xZcsWTJ8+HX369MnzjLHo6Gjcd999Of/u0KEDqlevjpdffhkfffQRvvvuO8yYMQPbtm3Dk08+WaqatLx7CpU918WZzE0eZidTaXOz/fMvLvUfg397DIM5LAQ1P1+KKtOHsxHTGLc3uZidTMxNJm/kVuJHSsfGxqJy5cplWQtCQkKwatUqTJo0CUOHDkVgYCB69OiBYcOG5Xnf9XdvCQoKwsqVKzFr1iy8++67SElJQc2aNTFy5MhSNWPcYGRyOp2FXrxJxsbsZCpJbs6MLCTOW4fEuR/AFBqMqovGIuixTvzLsRdxe5OL2cnE3GTSOjdFLUHHcfLkSTz77LP48ssvtajJEA4fPgxVVdG0aVP+OBDEdctTnpctD7OTqbi5qaqKtE+/QdzYebD/exWhz/dG2PCnYQoK8EK15MLtTS5mJxNzkyl3bkeOHAEANG3atEw/o9hHxg4dOoShQ4eiZcuWZVoIERGVb9l/nUHs6DnI2HcIAZ3aoNqm9+BTr5beZREREemmWM3Yrl27MHLkSLRt2xZz587VqiYiIipHnClpiJ+xAklLPoSlZhSi1k5D4P2F35SJiIiooihyM7Z8+XLMmDEDd999N+bNm+f2IXDlBQ8jy1QR1s3yitnJVFhuqtOJlE2fIX7iIjjT0hH+3wEIeaE3TH6+Xq6QCsLtTS5mJxNzk0nr3Io8+vTp09GqVSvExMRUqJWJDZksfDacXMxOpsJyy/rtOK6OnIWsQ0cR1L0jIsYPgaVGZAEjkB64vcnF7GRibjJ5I7cid1WVK1fGn3/+iT/++AO33nqrljUZiutJ9ySDqqo5mTE3WZidTNfn5ohNQNyUJUj54GP4NLoR1bfPhX/75nqXSdfh9iYXs5OJucmUOzetFPk5Y5s2bULVqlUxcODAnLuJlHe8tb1Mdrtd7xKohJidTHa7HardjqQlH+KfNn2RtuMrVJ7yCmp+sYyNmIFxe5OL2cnE3GTSOrciN2PVq1fH+vXr0bBhQwwYMABHjx7Vsi4iIhIi8+CvuHDvIMS+ORdB3Tqi9vfrEDLocSgV6JR2IiKikihyMwYAwcHBWL58Odq3b48BAwZoVRMREQlgv3AZl58dh6s9X4MS6I+ae5egyntvwFw5TO/SiIiIRCj2ny19fHwwa9YsTJ8+XYt6iIjI4JyZWUhasBEJc9bAFBiA8NkjENKnM0xms96lERERiVLic0j++9//lmUdhsQLLGUymYp1wJcMhNkZm6qqSN9zELFj5sJ+/jJCnuuJsNeioQb4QWF24nB7k4vZycTcZNI6tyI3Yz/99BPq1auH8PBwLesxHDZksiiKUqEevVCeMDtjyz75D+LejEH6F9/D/55WqLb2Hfg0qKN3WVRC3N7kYnYyMTeZvJFbkVu9p59+GgcOHNCyFqIywbtgysXsjMeZmo64iQtx7q5oZJ84i6hVk1Ft03t5GjHmJhNzk4vZycTcZNI6tyK3ehVxBfLGswWobKmqCpvNBqvVytyEYXbGoqoqUrfsRdyEhXAmJiNs+NMIHdoXJn/ffO9jbvIwN7mYnUzMTabcuWmFx0uJiCiPrMMnEDtqNjJ/+B2BD92NiIkvwlorSu+yiIiIyp1iNWPs5ImIyi9HfBLipy1F8qodsNavhWpbZiGgw+16l0VERFRuFasZe+ONN/DGG28U6b2KouDYsWMlKoqIiLxHdTiQvGYn4qcsAewOREwYipCBj0Gx8uQJIiIiLRXrv7Tt2rVDnTp1NCqFiIi8LeP73xE7ajayj5xApSe6IHzMYFiqVqy75hIREemlWM1Y9+7d8fDDD2tVi+HwtEyZtLzIkrTF7LzHfikWcRMWIPXDvfBt3gg1di+CX8tbSjQWc5OJucnF7GRibjJpnRvPQfGADZkszEsuZucdarYNiYs3IeG9VVD8fVFl1ghU6tulxA9tZm4yMTe5mJ1MzE0mb+TGZswD3tpeFlVV4XA4YDabmZswzE57aZ9/j7gxc2E7cxEhAx5F2IgBMIdUKtWYzE0m5iYXs5OJucmUOzetsBlzoyI+W608cDqdmm40pB1mpw3b6QuIfSsG6Z8dgN+dLRC54m34NqpbZuMzN5mYm1zMTibmJpPWuRW5Gfvzzz81K4KIiMqeMy0DCXM+QNKCDTBXDkXk0okIfOQe/lWWiIjIIHhkjIionFFVFWnbv0Ts+AVwxiUi9MUnEPpSP5gC/fUujYiIiHJhM0ZEJFx8fDy+//57tGnTBoGXEhA7eg4yD/yCgM53ovLEl2CtU13vEomIiKgAbMbc4Kk8MvF8bLmYXckkJSXhxM+/ouEnh5Cw5UtY61RHtQ3vIuDeO7zy+cxNJuYmF7OTibnJpHVubMY8YEMmi6Io3NkJxexKRnU4kLn5c9z3/hdQoSBizHMIfa4nFB/vPM+GucnE3ORidjIxN5m8kRubMQ94a3tZVFXNyYy5ycLsiic+Ph6J3/4Pjumr4HP8LP5uUA2H7rsP3Tq2ROKF8wgJCUF4eLjmdTA3mZibXMxOJuYmU+7ctMJmzA3e2l4mu93Op9wLxeyKxn45Dmeefwsh3x5GUtVgfPdoK8RVD4FDvYSPd34Ei9mExo0bo0uXLt6ph7mJxNzkYnYyMTeZtM6NzRgRkRCqzY6kpR8iYcZKhJpNwMj+8Lu/HS7v+QVIPgkE18NDnVsi0N8HISEhepdLREREHrAZIyISIH3fIcSOng3b3+cQHN0N4aMGwRwWDADoYzbh453n8VDnlmjSuKHOlRIREVFRsRkjIjIw2z//Im7sfKR9sg9+bW5D5Bfj4dukfp73BPr7wGI2IdDfR6cqiYiIqCTYjLnBCyxlYm5yMbv/48zIQmLMWiTGrIUpNBhVF49D0KP3FriMQkJC0LhxY91OTWRuMjE3uZidTMxNJq1zYzPmATccWRRF4cWxQjG7a1RVRdon+xE3dh7sl2IR+kJvhA17GqaggELnCQ8P99rNOq7H3GRibnIxO5mYm0zeyI3NGBGRQWT/dQaxo+cgY98hBHRqg2qbZ8KnXi29yyIiIiKNsBnzgM8Zk0VVVdjtdlgsFuYmTEXOzpGcioR3VyJpyYew1IxC1NppCLy/vd5lFUlFzk0y5iYXs5OJucmUOzetsBlzg88Zk4m5yVXRslOdTqRs3I34SYvhTEtH+IiBCH2hNxRfWTfiqGi5lRfMTS5mJxNzk0nr3NiMERHpIPPXPxE7ajayDh1F0KP3ImL8EFiqV9W7LCIiIvIiNmNERF7kiE1A3NuLkbLuU/g0uhHVt8+Ff/vmepdFREREOmAzRkTkBardjqTl25HwzjJAASpPfRXB0Y9A0fA8dCIiIjI2/gpwgxdYysRbx8pVXrPLOPALYkfNRvafpxH81MMIH/0szBGhepdVZsprbuUdc5OL2cnE3GTire11xoZMFuYlV3nMzn7hMmLHLUDaR1/Ct1UT1Ny7BL63NdS7rDJVHnOrCJibXMxOJuYmkzdyM2n+CcV08uRJPPPMM2jWrBnat2+P6dOnIzs7u0jzXr58GSNGjECbNm1w6623onPnztixY0ep6uGdb2RRVRUOh4O5CVSesnNmZiFh5mr80+5JZH73K6rOfxM1Pp5f7hoxoHzlVpEwN7mYnUzMTSZv5GaoI2NJSUmIjo5GnTp1EBMTg8uXL2PatGnIzMzE2LFj3c575coV9O7dGzfeeCMmTZqEoKAgnDhxosiNXEG4wcjkcDhgMhnu7wxUBNKzU1UV6Z8dQOxbMbCfv4yQwT0R/lp/mCoF6l2apqTnVlExN7mYnUzMTSatczNUM7ZhwwakpaVh3rx5CA0NBXBtAUyYMAGDBw9GZGRkofPOmDEDUVFRWLp0KcxmMwCgbdu23iibiAjZJ/9B7Oi5yPjyB/jf0wrV1k2Hz0036F0WERERGZih2vP9+/ejbdu2OY0YAHTu3BlOpxMHDhwodL7U1FTs2rULffv2zWnEiIi8wZmajriJC3HurmjY/v4HUasmo9qm99iIERERkUeGOjJ26tQpPP7443leCw4ORpUqVXDq1KlC5zt69ChsNhssFguefPJJ/PLLLwgNDUX37t3x6quvluouKAWdqqgoSqGnMLou9HM3Xat5OS5y5isst9LUW5p5Oa7neV3TvL3NlabelA/3IH7CQjiTUhA27GmEDH0CJn/fCrWPcM2nxTYnaTkYtSZPp9sbrV4j1mS0cV3TuM3JGtfFSDVJHNfbNbleqzDXjCUnJyM4ODjf6yEhIUhKSip0vtjYWADAmDFj0KtXL7z44ov4/fffMXfuXJhMJrz22mslrslms+W5k4rJZILl/z8XyGaz5Xu/j48PgGunVzqdzjzTLBYLFEWB0+mEw+HIM801rqqqBY7raigLGtdsNsNsNkNVVdjt9jzTFEXJmddut+dbmbQatyjfFci/DEs7rqvm63NzfVdFUYr9XT1lrscydI1bUE1aZeP6roUtQ9e47pahp/Xb9bm5syuL9dvdMizJuI4/TiF+9Fxk/ngY/l07IHTs87DUjIQDgOpwVKh9hMlkgslkypebUfcRJV2/y9s+wmKxwGw25/tMT+PqvY/Qav0u631EaZZhUfYRiqIU+vvEaPsIab8jtNpHePp9AhhrHyH1d4QWy9BsNsPpdEJV1XzZlQVDNWMl5Vro7dq1w8iRIwEAbdq0QVpaGpYvX46hQ4fCz8+v2OMqipKzUyyIuyNuuVfy67l+vBT2mSUd19O8ro3Dm+O6+66A+2VYknEVRSn0u7g2oNJ8Vz2y8fYydDduaZehp2nutjetlmFxxnXEJyF+6lKkrNkJ6021Ue3DWfDv0LLQeSvCPsL1w96dirJ+Fzaui5H2Ea59pbv5jLaPKM24gHf2EcUZFyjZ+uKpHqPtI0o7bnnZRxRlm+My/L/3GGkfYTKZNGvEAIM1Y8HBwUhJScn3elJSEkJCQtzOB1xrwHJr27YtFi1ahLNnz6Jhw5LfUrqghe8pEHfTtZqX4/7fqRuuvxwaoSaOW7TpnrLT87uqDgeSV+9A/NSlgN2BiAlDETLwMSjWwnehFWUfoeU2J2k5GLUmafvK0sxbUcblNidzXKNuc9LG9XZNqqrC6XRq1ogBBmvG6tatm+/asJSUFFy9ehV169YtdL769eu7HTcrK6tE9Wh5fihpx2638yn3Qhkxu4zvfkPsqNnIPvo3KvXtivAxg2GpEqZ3WYZixNzIM+YmF7OTibnJpHVuhrqbYocOHXDw4EEkJyfnvLZ7926YTCa0b9++0Plq1KiBBg0a4ODBg3leP3jwIPz8/Dw2a0RE17P/exWXn5+Ii4+8CMXHihqfLUbVOSPZiBEREVGZMVQz1qdPHwQGBmLo0KH49ttvsWXLFkyfPh19+vTJ84yx6Oho3HfffXnmHTZsGL788ktMnjwZBw4cwKJFi7B8+XL0798fAQEB3v4qRCSUmpWNhLlr8U+bfkjf9xOqzB6JGrsXwa9FY71LIyIionLGUKcphoSEYNWqVZg0aRKGDh2KwMBA9OjRA8OGDcvzvoLu3tKxY0fMnDkTCxYswPr161G1alW89NJLeO6557z5FYhIsLTPv0fcm3NgO/svQgY9hrA3noE5pJLeZREREVE5pai8MKpAhw8fBgA0adJE04v2qGy5blvquj0qyaFndrbTFxA7Zi7S9xyE/10tUHnKq/C5+Uav1iAVtzmZmJtczE4m5iZT7tyOHDkCAGjatGmZfoahjowZETcYWTzdtpSMS4/snGkZSJi9BokLNsBSJQyRyyYi8OF7uN0XA7c5mZibXMxOJuYmkzdyYzNGRBWOqqpI2/4lYscvgDMuEWEv9UXoy0/CFFD85xESERERlRSbMQ+0fMgblT2eBiCXt7LLOnYSsaPnIPPALwjofCcqT3wJ1jrVNfu88o7bnEzMTS5mJxNzkyl3blphM+YGL6eTibnJpWV2jsQUxE9biuQV22GtWxPVNr6LgI53aPZ5FQm3OZmYm1zMTibmJpPWubEZI6JyTXU4kLLuE8RNfh9qZjYixj6PkGd7QPHhuftERESkLzZjRFRuZR46itiRs5D123EE9XoAEW89D0tUZb3LIiIiIgLAZoyIyiH75TjET1qElI274dP0JtT4ZAH8WpftrWiJiIiISovNmBu8wFImLS+yJG2VNjvVZkfSkg8RP2MFFB8rqrz3Bir16wrFbC6jCqkg3OZkYm5yMTuZmJtMWufGtcIDNmSyKIrCzIQqbXbpX/+E2NFzYDt5DsH9uyN85ECYw4LLsEIqCLc5mZibXMxOJuYmkzdyYzPmAW9tL4uqqnA6nTCZTMxNmJJmZ/vnX8SNnYe0T/bDr+1tiHx/PHyb1NewUsqN25xMzE0uZicTc5Mpd25aYTPmBm9BKpPD4dB0oyHtFCc7Z0YWEmPWIjFmLUxhIaj6/jgEdb+X/5HTAbc5mZibXMxOJuYmk9a5sRkjIlFUVUXax/sQN24+7JfjEPpCb4S9+hRMQQF6l0ZERERULGzGiEiM7OOnETt6DjL2/w8B97VFtc0z4VOvlt5lEREREZUImzEiMjxHcioSZqxA0tItsNaqhqi17yDw/nZ6l0VERERUKmzG3OC1JzLxfGy5rs9OdTqRsmEX4t9eDGdaJsJHDkLo872g+ProVCEVhNucTMxNLmYnE3OTSevc2Ix5wIZMFkVR+BwPoa7PLvOXPxA7ajay/ncMQY91QsS4F2CpXlXHCqkg3OZkYm5yMTuZmJtM3siNa4UHvLW9LLnvgMncZHFl57iagPgp7yNl3afwaVwX1T+KgX+7ZvoWR4XiNicTc5OL2cnE3GTyxp3V2Yy5wVvby2Sz2WC1WvUug4pJtduRsHQLkt9dBZgUVJ76KoKjH4HCvyQaHrc5mZibXMxOJuYmk9a58VcOEeku49ufcXXUbNiOn0Glpx5GxOhnYY4I1bssIiIiIk2xGSMi3djOX0bcuPlI2/EVfFs1QeSuBQhscQtP4SAiIqIKgc0YEXmdMzMLSfM3IGHOGpgqBaLq/DcR2ON+2O12vUsjIiIi8ho2Y0TkNaqqIn33t4h9Kwb2C1cQMrgnwl/rD1OlQF6jSURERBUOmzE3FEXh6VLCKIoCHx8+g8qIsv/+B7Gj5yDjqx/hf08rVFs/Az433ZAzndnJxNxkYm5yMTuZmJtM3siNzRgRacqZmo6E91YicfFmWKpXQdTqKQh48E7+oYOIiIgqPDZjHvA5Y7KoqgqHwwGz2czcdKaqKlI/3IO4CQvhTE5F2GvRCB3yBEz+voW+n9nJw9xkYm5yMTuZmJtMuXPTCpsxN3gNi0xOp1PTjYY8y/r9L8SOmo3MHw8j8JH/IGL8EFhrRXmcj9nJxNxkYm5yMTuZmJtMWufGZoyIyowjPgnxU5cgedUOWBvWQbWtsxFwV0u9yyIiIiIyJDZjRFRqqsOB5FU7ED91CeBUETHpJYQMeBSKlbsYIiIiosLwlxIRlUrGd78hdtRsZB/9G5X6dkX4mMGwVAnTuywiIiIiw2Mz5gYvsJTJYuFq7Q32f68ibvwCpG79HL4tGqHGZ4vh16JxqcZkdjIxN5mYm1zMTibmJpPWuXGt8IANmSx8Npz21KxsJC7ahISZq2EK9EOVOSNRqU9nKCZTqcZldjIxN5mYm1zMTibmJpM3cmMz5gFvbS+LqqpwOp0wmUzMTQNpe79D3Ji5sJ39FyGDHkPYG8/AHFKpTMZmdjIxN5mYm1zMTibmJlPu3LTCZswN3tpeJofDoelGUxHZTp1H7FsxSN9zEP53tUDUqinwufnGMv8cZicTc5OJucnF7GRibjJpnRubMSIqlDMtAwmzViNx4UZYqoYjcvkkBD50N/+qR0RERFQG2IwRUT6qqiJ1+xeIG7cAzvgkhL3cD6Ev9YMpwE/v0oiIiIjKDTZjRJRH1tG/ETt6DjIP/orALnchYuKLsN5QXe+yiIiIiModNmNu8FQsmXg+dsk4ElMQP20pkldsh7VuTVTb9B4C/tPaqzUwO5mYm0zMTS5mJxNzk0nr3NiMecCGTBZFUfgcj2JSHQ6krPsEcZPfh5qZjYixzyPk2R5QfKxerYPZycTcZGJucjE7mZibTN7IjWsFlTt8HEHRZf50BLGjZiPrt+MI6vUgIt4aDEtUZd3qYXYyMTeZmJtczE4m5iaT1rmxGXNDVVVuOMKoqgqbzQar1crc3LBfjkPcxEVI3bQbPrc2QI1PFsCvdVNda2J2MjE3mZibXMxOJuYmU+7ctGK4k1dPnjyJZ555Bs2aNUP79u0xffp0ZGdnF2uMlStXomHDhhg8eLBGVRLJpGbbkLhgA/5p0xfpn3+HKu+9gZp73te9ESMiIiKqiAx1ZCwpKQnR0dGoU6cOYmJicPnyZUybNg2ZmZkYO3Zskca4evUq5s+fj4iICI2rJZIl/asfEfvmXNhOnkPwM90RPnIQzKGV9C6LiIiIqMIyVDO2YcMGpKWlYd68eQgNDQVw7anXEyZMwODBgxEZGelxjBkzZqBjx464ePGixtUSyWA7exFxY+ch7dNv4Nf2NkQuGQ/fW+rrXRYRERFRhWeo0xT379+Ptm3b5jRiANC5c2c4nU4cOHDA4/yHDh3C559/jtdee03DKolkcKZnIv6dZTh351PI/OVPVH1/HKp/FMNGjIiIiMggDHVk7NSpU3j88cfzvBYcHIwqVarg1KlTbud1OByYNGkSnn/+eVStWrVM6uEFljJpeZGlBKqqIm3n14gbNx/2K/EIHdIHYa88CVNQgN6leVTRs5OKucnE3ORidjIxN5m0zs1QzVhycjKCg4PzvR4SEoKkpCS3865btw4ZGRno379/mdelqmqefyuKku+13NMKmscb83LcvNMKyq0045ZFTVqPm/3nacS9ORcZ3/wPAfe3Q7UPZ8Fat2a+z9Cr3qLO681tTtq4RqxJq21O2nIwYk1FGbeg93AZyhi3om9z0sZ1zWukbU7auEarqSwYqhkrqbi4OMydOxfvvPMOfHx8ymxcVVWRnZ2d5wiZyWTKefibzWbLN4/r8x0OB5xOZ55pFosFiqLA6XTC4XDkmeYa13ULzeu5uvKCxjWbzTCbzVBVFXa7Pc80RVFy5rXb7flWJq3GLcp3BfIvw9KOazabYbfb4XQ68x3ZdN1Otrjf1VPmeixD17iumpzJqUh6bzVSV2yDpXY1RK2bjsD72sJms+WruaTZuL5rYcvQNa67Zehu/VZVFVlZWVAUJU92ZbF+u1uG3ly/gfK3jzCZTLDZbFDVvI8BMeo+oqTrt/R9xPXjWiyWAuvxNK6e+whAu/Vb0j4CQM5dpgv6fWK0fYS03xFa7SPMZjMcDgccDkeBv08AY+0j9FiGRtxHuPaVgHbPGzNUMxYcHIyUlJR8ryclJSEkJKTQ+ebMmYOGDRvi9ttvR3JyMoBrC9RutyM5ORkBAQElfnq2u+dBuDtsmXslv57JZILJVPDlerlXiuKO62led8tAq3HdfVfA/TIs6bhOp7PA3Fz/Ls131SMbd99VdTqR+eFexE9aDGd6JsJHDULI4F4w+fmWalyg4O9a2mXoaTm4phe0zWm1DPVav8vTPkJVVbf7SqPtIwobtzzuI9zV5HQ6c378lNW4Wu8j9FiGRtxHuOYtyb6SvyNKPm5p1+/Cfp+4cBn+33uMso9QVdXjvrK0DNWM1a1bN9+1YSkpKbh69Srq1q1b6HynT5/GTz/9hFatWuWb1qpVKyxZsgQdOnQoUU3X/5U+9+ue5ivJtNLMy3H/768WheWmR01ajZv5yx+IHTUbWf87hqDHOiFi/BBYqlUxbL2epnvKTlI2Wo5rtJq03OYkLQej1uQuN9d0I+0rSzNvRRmX25zMcY26zUkb16g1lYahmrEOHTpg0aJFea4d2717N0wmE9q3b1/ofKNHj845IuYyZcoU+Pn5Yfjw4WjYsKGmdRN5k/1qAuLfXoyUdZ/A55b6qL5jHvzb3qZ3WURERERUTIZqxvr06YM1a9Zg6NChGDx4MC5fvozp06ejT58+eZ4xFh0djYsXL2Lv3r0AgEaNGuUbKzg4GAEBAbjjjju8Vj+RllSbHUnLtyFh+nLApKDyO8MR/PTDUEp4Ci4RERER6ctQv+JCQkKwatUqTJo0CUOHDkVgYCB69OiBYcOG5XlfQRcMakHLQ5KkHXfn2EuV8e3PuDpqNmzHzyD46UcQPmoQzBGhepdV5spjdhUBc5OJucnF7GRibjJpnZuianmvRsEOHz4MAGjatKnOlVBFZjt/GXHj5iNtx1fwa9UElae+Ct/beNotERERkTdp1RsY6siYEWl1G0vShuv5He4ukJXAmZmFxPnrkTjnA5iCg1B1wRgE9bhf9HfypLxkV9EwN5mYm1zMTibmJlPu3LTCZswNHjSUyW63i33KvaqqSN/9LWLfioH94lWEDu6JsNf6wxQUoHdpXiE5u4qMucnE3ORidjIxN5m0zo3NGJFBZP/9D2JHz0HGVz/C/z+tUW3Du/CpX1vvsoiIiIhII2zGiHTmTElD/HsrkbR4Myw1qiJqzVQEPNCepzEQERERlXNsxoh0oqoqUjd/hrgJC+FMSUP4688gZGgfmPx89S6NiIiIiLyAzZgbPDIhk4Tcsn47jthRs5H50xEEPvIfREwYCmvNSM8zlnMSsqP8mJtMzE0uZicTc5NJ69zYjHnADUcWRVEMfXGsIy4R8VOWIHnNTlgb1kG1rbMRcFdLvcsyBKNnRwVjbjIxN7mYnUzMTSZv5MZmjMgLVLsdyat2IH7aUsCpIuLtlxHyTHcoVm6CRERERBUVfwl6wOeMyaKqKux2OywWi2Fyyzj4K2JHz0H2sZOo1LcLwt8cDEuVML3LMhwjZkeeMTeZmJtczE4m5iZT7ty0wmbMDT5nTCaj5Gb/9yrixi9A6tbP4duiEWp8thh+zRvpXZahGSU7Kh7mJhNzk4vZycTcZNI6NzZjRGVMzcpG4qJNSJi5GqZAP1SZMxKV+nSGYjLpXRoRERERGQibMaIylLbnIOLGxMD2z78IefZxhL3xDMzBQXqXRUREREQGxGaMqAzYTp1H7Ji5SN/7Hfw7tETUminwaXij3mURERERkYGxGXODF1jK5M1bxzpT05Ewew0SF26EpWo4IpdPQuBDd3PdKSHe9lcm5iYTc5OL2cnE3GTire11xh/VsngrL1VVkbrtC8SNXwBnfBLCXu6H0Jf6wRTg55XPL4+4rcnE3GRibnIxO5mYm0zeyI3NmAe8tb0sqqrC4XDAbDZrllvW0b8RO2o2Mr/7DYFd7kLExBdhvaG6Jp9VkXgjOyp7zE0m5iYXs5OJucmUOzetsBlzg7cglcnpdGqy0TgSkhE/bRmSV26HtV4tVNv0HgL+07rMP6ci0yo70hZzk4m5ycXsZGJuMmmdG5sxIg9UhwMpaz9B3OT3oWbbEDHuBYQMehyKD8/9JiIiIqKSYzNG5Ebmj4dxddRsZP/+Fyr1fhDhYwbDElVZ77KIiIiIqBxgM0ZUAPulWMRNWoTUTZ/B97aGqPHpQvi1aqJ3WURERERUjrAZc4MXWMpUmvN61WwbkpZ8iPh3V0LxtaLKzDdQqW9XKDzH2yt4Lr1MzE0m5iYXs5OJucmkdW5sxjxgQyaLoigl3mjSv/oRsaPnwHbqPIKf6Y7wkYNgDq1UxhVSYUqTHemHucnE3ORidjIxN5m8kRubMQ94a3tZVFXNyayoudnOXkTsWzFI3/Ut/No1Q+TSCfC9pb7GldL1SpId6Y+5ycTc5GJ2MjE3mXLnphU2Y27w1vYy2e32Ij0t3ZmeicS5HyBx3nqYIkIR+f54BHbvyJ2kjoqaHRkLc5OJucnF7GRibjJpnRubMapwVFVF2s6vETduPuxX4hE6pA/CXn0KpkB/vUsjIiIiogqEzRhVKNl/nkbs6NnI+OZnBNzfDtW3zIa1bk29yyIiIiKiCojNGFUIjqQUJExfgaRlW2GtXQ1R66Yj8L62epdFRERERBUYmzE3eO2QTLlzU51OpKzfhfjJi+FMy0T46GcROrgnFF8fHSukwnCbk4m5ycTc5GJ2MjE3mbTOjc2YB9xwZFEUJeciy8yfjyF21Gxk/fwHgh6/DxHjXoClWhWdK6TC5M6O5GBuMjE3uZidTMxNJm/kxmaMyh37lXjET34fKes+gc8t9VF9xzz4t71N77KIiIiIiPJgM+YBnzMmh2qzI2nZFsRPXwHFbELld4YjOPoRKHzIogiqqsJut8NisXCbE4S5ycTc5GJ2MjE3mXLnphU2Y27wOWNypH/zP8SOngPb8TMIfPIhVH7zOVgiQvUui4qJ25xMzE0m5iYXs5OJucmkdW5sxkg02/nLiBs7D2k7v4Zf66ao+vkSmG6+EWael01EREREBsdmjERyZmYhcf56JM75AKbgIFRdMAZBPe4HANhsNp2rIyIiIiLyjM0YiaKqKtJ3fYPYsfNgv3gVoc/3QtjwaJiCAnKmExERERFJwGbMDV5gaSzZJ84idvQcZHz9E/w73oFqG96FT/3a+d6n5UWWpC1mJxNzk4m5ycXsZGJuMmmdG9cKD9iQ6c+Zkob491YiafFmWGpGImrNVAQ80L7AbBRFYWZCMTuZmJtMzE0uZicTc5PJG7mxGfOAt7bXj+p0InXzHsRNXAhnShrC3xiAkCG9YfLzLXweVYXT6YTJZGJuwjA7mZibTMxNLmYnE3OTKXduWmEz5gavP9JP1m/HcXXUbGT9dASB3Tqi8oQhsNSILNK8DodD042GtMPsZGJuMjE3uZidTMxNJq1zYzNGhuKIS0T8lCVIXrMTPjffiOrb5sD/zhZ6l0VEREREVObYjJEhqHY7klftQPy0pYBTRcTbLyNkQHcovNiViIiIiMopw/3SPXnyJN5++2388ssvCAwMRLdu3fDqq6/Cx8en0HmuXLmClStX4sCBA/jnn39QqVIltGrVCsOHD0eNGjW8WD2VRMbBXxE7ejayj51Cpb5dEP7mYFiqhOldFhERERGRpgzVjCUlJSE6Ohp16tRBTEwMLl++jGnTpiEzMxNjx44tdL6jR49i7969ePzxx3HbbbchISEBCxcuRM+ePfHxxx8jPDy8RPXwAktt2S9eQdz4BUjd9gV8WzZGjc8Ww695o1KPy/Ox5WJ2MjE3mZibXMxOJuYmk9a5GaoZ27BhA9LS0jBv3jyEhoYCuHbR3IQJEzB48GBERhZ8A4eWLVti165deZ4D0KJFC9xzzz3Yvn07BgwYUOKa2JCVPTUrG4kLNyJh1mqYAv1RZe4oVOr9IJQyWNkVReFzPIRidjIxN5mYm1zMTibmJpM3cjNUi75//360bds2pxEDgM6dO8PpdOLAgQOFzhccHJxvQUVFRSE8PBxXrlwpVU28o2LZSttzEOfuikb8O8sQ/PQjqPX9OgQ/0aVMGjHgWl6u/5EszE4m5iYTc5OL2cnE3GTyRm6GasZOnTqFunXr5nktODgYVapUwalTp4o11unTpxEXF4d69eqVuB5uMGUn++Q5/Nv3v7jUbwQstSJR6+sVqDzpJZiDg8r8s2w2W5mPSd7B7GRibjIxN7mYnUzMTSatczPU8dLk5GQEBwfnez0kJARJSUlFHkdVVbz99tuoWrUqunbtWqqaCmrIFEUptFFzndbobrpW8xpxXEdKGhJnr0Hiok2wREYgcvkkBHTtAJPJpEm9rvkKy62k45bHbPQY1928rmne3uakjWu0mlzzabHNSVoORq3J0x8VjVavEWsy2riuadzmZI3rYqSaJI7r7Zpcr2l5gMZQzVhZiYmJwffff4+lS5ciICCgVGPZbLY8142ZTKacUyIL6pRdd310OBxwOp15plksFiiKAqfTCYfDkWeaa1xVVQsc12q1Fjqu2WyG2WyGqqqw2+15pimKkjOv3W7PtzJpNa7ZbEb6R18hbvx8OBOSEfziE6g0pDdM/n55nmR+/Xf1NK6nZWg2m3PGvf56P6vVeq1BLOZ39ZS5VsvQ3Xd1jVtQTaVdhp6+a2HL0DWuu2Xoaf12Op35siuL9dvdMizrbCraPsL1h5Xrc9NqGeq1fpe3fYSr3us/09O4eu8jtFq/pe0jCtrm9F6G3ly/Je4jPP0+AYy1j5D6O0KLZQhc20eoqpovu7JgqGYsODgYKSkp+V5PSkpCSEhIkcbYtGkT5s+fj8mTJ6Nt27alrsm10hQ2rTC5V/LrmUymQu/MknulKO64nuZ1dwFiWY6bdeRvXH1zDjK/+w0BXTsgYsJQWGtXK3Dektbrbhm6xr0+N9e/S/Nd9cimKN/VW+OWdhl6Wg4mk6nQbU6rZahXNuVxH1HYvrKirN+Fjeti1H1EYbkZcR+hxzI04j7C3TZn5H1EScYtj/uIwrY5LsP/e49R9hGu5sxkMmnSiAEGa8bq1q2b79qwlJQUXL16Nd+1ZAXZu3cvxo8fj5dffhk9evQodT2KouT8r6BpnuYtybTSzKv3uI6EZMRPXYrkVR/BWq8Wqm2eiYB7Wnm1XlVVczaYwt5j5GVY3sd1N91TdtK+a0XZR2i5zUlaDkatyV1u7v4bV5rP1GveijIutzmZ4xp1m5M2rh41ucusLBiqGevQoQMWLVqU59qx3bt3w2QyoX379m7n/eGHHzB8+HD07NkTQ4cOLbOatFz45YXqcCD5g48RP2UJ1GwbIsa/gJBBPaBYvb96efqrBxkXs5OJucnE3ORidjIxN5m8kZuhmrE+ffpgzZo1GDp0KAYPHozLly9j+vTp6NOnT55njEVHR+PixYvYu3cvAODkyZMYOnQo6tSpg27duuHXX3/NeW94eDhq167t7a9SYWT+eBhXR81G9u9/oVLvBxH+1vOwREboXRYRERERkeEZqhkLCQnBqlWrMGnSJAwdOhSBgYHo0aMHhg0blud9118w+NtvvyElJQUpKSl44okn8rz30UcfxbRp00pck1YX60lnvxSLuIkLkbp5D3xva4gany6EX6smepeVc3Gmu+sgyJiYnUzMTSbmJhezk4m5yZQ7N60oqpb3ahTs8OHDUFUVTZs25UaTi5ptQ+L7m5Hw7koofj6IeHMwKvXtAqWQiyW9zXWXHXcXyJIxMTuZmJtMzE0uZicTc5Mpd25HjhwBADRt2rRMP8NQR8bI2NK//AGxb86F7dR5hAx4FGEjBsIcWknvsoiIiIiIRGIzRh7ZzlxE7NgYpO/6Fn7tmiFy2UT4Nq6nd1lERERERKKxGaNCOdMzkTjnAyTOXw9TRCgi3x+PwO4deXidiIiIiKgMsBlzo6I2HaqqIm3H14gbNw/2qwkIHfoEwl55EqZAf71LKxItL7IkbTE7mZibTMxNLmYnE3OTSevcuFZ4UNEasuw/TyN29GxkfPMzAh5oj+qTXoL1xhp6l1VkWj+Yj7TD7GRibjIxN7mYnUzMTSZv5MZmzIOKcmt7R1IKEqavQNKyrbDeUA1R62cgsFMbvcsqNlVV4XQ6YTKZKkRu5Qmzk4m5ycTc5GJ2MjE3mXLnphU2Y25UhLv+q04nUtZ9irjJi6GmZyF89LMIHdwTiq+P3qWVmMPh0HSjIe0wO5mYm0zMTS5mJxNzk0nr3NiMVWCZPx9D7MjZyPrlDwQ9fh8ixr0AS7UqepdFRERERFQhsBmrgOxX4hH/9mKkrP8UPk1uQvWd8+Hf5la9yyIiIiIiqlDYjFUgqs2OpGVbkTB9OWAxo/L04Qh++hEoZrPepRERERERVThsxtwoTxdYpu8/hNjRc2A78Q+Cox9B+MhBMIeH6F2WJng+tlzMTibmJhNzk4vZycTcZNI6NzZjHkhvyGznLiFu7DykfbwPfq2bInLvEvje2kDvsjSjKAqf4yEUs5OJucnE3ORidjIxN5m8kRvXCg+k3tremZGFxPnrkDh3LUzBQai68C0EPX6fyO9SHLnvgFnev2t5w+xkYm4yMTe5mJ1MzE0mb9xZnc2YGxJvba+qKtI+/QZxY+fB/u9VhD7fC2HDo2EKCtC7NK+x2WywWq16l0ElwOxkYm4yMTe5mJ1MzE0mrXNjM1aOZJ84i9jRc5Dx9U/w73gHqm18Fz71a+tdFhERERERFYDNWDngTElD/LsrkfT+ZlhqRiLqg2kIuL8dD4MTERERERkYmzHBVKcTqZv3IG7iQjhT0xH+xgCEDOkNk5+v3qUREREREZEHbMaEyvrtOK6Omo2sn44gsFtHVJ4wBJYakXqXRURERERERcRmzA1FUQx3qp8jLhFxk99Hygcfw+fmG1F92xz439lC77IMQ1EUWK1Ww+VGnjE7mZibTMxNLmYnE3OTyRu5sRkTQrXbkbzyI8RPWwoAqDz5ZQQ/0x0Kn1mRD3d0cjE7mZibTMxNLmYnE3OTSevc+EveAyM8ZyzjwC+IHT0b2X+cRqV+XRHx5nMwVw7TtSajUlUVDocDZrNZ99yoeJidTMxNJuYmF7OTibnJlDs3rbAZc0Pv54zZL15B3PgFSN32BXxbNkaNzxbDr3kjXWuSwOl0arrRkHaYnUzMTSbmJhezk4m5yaR1bmzGDEjNykbigg1ImL0GpkB/VJk7CpV6PwjFZNK7NCIiIiIiKiNsxgwmbc8BxL4ZA/v5Swh5tgfCXu8Pc3CQ3mUREREREVEZYzNmENknzyFuzFykf/49/O++HdXWToNPgzp6l0VERERERBphM+aGNy6wdKamI2HmaiQu2ghLVGVErngbgV078OLOUuD52HIxO5mYm0zMTS5mJxNzk0nr3NiMeaBVU6SqKlK3fo648QvgTExG2LCnEfpiX5j8fTX5vIpCURTu7IRidjIxN5mYm1zMTibmJpM3cmMz5oEWt7bPOvI3YkfNRub3vyGw692ImDgU1trVyvQzKipVVXMy49FFWZidTMxNJuYmF7OTibnJlDs3rbAZc6Osb23vSEhG/NSlSF71Eaz1a6Hah7MQcPftZfoZBNjtdlitVr3LoBJgdjIxN5mYm1zMTibmJpPWubEZ8wLV4UDymp2In7IEqs2OiPEvIGRQDyhWLn4iIiIiooqK3YDGMn74HbGjZiP78AlU6tMZ4WMGwxIZoXdZRERERESkMzZjGrFfikXcxIVI3bwHvs1uRo1di+B3+y16l0VERERERAbBZsyNklysp2bbkPj+ZiS8uxKKnw+qzPwvKvXrCsVk0qBCKoiJy1osZicTc5OJucnF7GRibjJpnRubMQ+K05Clf/EDYt+cA9uZiwh5pjvCRgyEObSShtXR9RRFgcXC1VoiZicTc5OJucnF7GRibjJ5IzeuFWXAduYiYt+KQfrub+HXvjkil0+Cb+N6epdFREREREQGxmbMDU/PFnCmZyJxzgdInL8epohQRC6ZgMBu/+HzI3SkqipsNhusVitzEIbZycTcZGJucjE7mZibTLlz0wqbsRJQVRVpH32FuPHzYb+agNChTyDslSdhCvTXuzQiIiIiIhKCzVgxZf1xCrGj5yDz258R8EB7VJ/0Eqw31tC7LCIiIiIiEobNWBE5klKQ8M5yJC3fBmud6ohaPwOBndroXRYREREREQnFZswD1elEyrpPETd5MdTMbIS/+SxCB/eC4qPduaNERERERFT+sRlzw/znGVx8PQZZv/yJoJ73I2LsC7BEVda7LPJAy4ssSVvMTibmJhNzk4vZycTcZNI6N8M9fe7kyZN45pln0KxZM7Rv3x7Tp09Hdna2x/lUVcX777+Pe+65B7feeit69+6NX3/9tVS1+A2dAdXmQPWP5yNywVtsxARQFCXnfyQLs5OJucnE3ORidjIxN5m8kZuhmrGkpCRER0fDZrMhJiYGw4YNw6ZNmzBt2jSP8y5ZsgRz585F//79sXjxYlSpUgUDBgzAuXPnSlxP1n+fQo2978P/jltLPAZ5l6qqsNvtUFVV71KomJidTMxNJuYmF7OTibnJ5I3cDHWa4oYNG5CWloZ58+YhNDQUAOBwODBhwgQMHjwYkZGRBc6XlZWFxYsXY8CAAejfvz8AoGXLlnjwwQexbNkyjB8/vkT12B9oA8VsLtG8pB+n0wkzcxOJ2cnE3GRibnIxO5mYm0xa52aoI2P79+9H27ZtcxoxAOjcuTOcTicOHDhQ6Hw///wzUlNT0blz55zXfHx8cN9992H//v1alkxERERERFQihmrGTp06hbp16+Z5LTg4GFWqVMGpU6fczgcg37z16tXDxYsXkZmZWfbFEhERERERlYKhTlNMTk5GcHBwvtdDQkKQlJTkdj4fHx/4+vrmeT04OBiqqiIpKQl+fn7FqsVms0FVVRw5cqRY85H+VFXlBbJCMTuZmJtMzE0uZicTc5PJlVt2drYm+RmqGTMSbixyMTu5mJ1MzE0m5iYXs5OJucnkyk2ruyoaqhkLDg5GSkpKvteTkpIQEhLidr7s7GxkZWXlOTqWnJwMRVHczluY5s2bF3seIiIiIiKiojLUNWN169bNd21YSkoKrl69mu96sOvnA4DTp0/nef3UqVOoXr16sU9RJCIiIiIi0pqhmrEOHTrg4MGDSE5Oznlt9+7dMJlMaN++faHztWjRAkFBQdi1a1fOazabDXv27EGHDh00rZmIiIiIiKgkDHWaYp8+fbBmzRoMHToUgwcPxuXLlzF9+nT06dMnzzPGoqOjcfHiRezduxcA4Ovri8GDByMmJgbh4eFo0KAB1q9fj8TERAwcOFCvr0NERERERFQoQzVjISEhWLVqFSZNmoShQ4ciMDAQPXr0wLBhw/K8z+l0wuFw5Hnt2WefhaqqWL58OeLj49GoUSMsW7YMtWrV8uZXICIiIiIiKhJFVVVV7yKIiIiIiIgqGkNdM0ZERERERFRRsBkjIiIiIiLSAZsxIiIiIiIiHbAZIyIiIiIi0gGbMSIiIiIiIh2wGSMiIiIiItIBmzEiIiIiIiIdsBm7zsmTJ/HMM8+gWbNmaN++PaZPn47s7Gy9y6Jcdu3ahRdeeAEdOnRAs2bN0K1bN3z44Ye4/pF5mzdvxgMPPICmTZvikUcewVdffaVTxVSQtLQ0dOjQAQ0bNsThw4fzTGN2xrNt2zZ0794dTZs2xR133IFBgwYhMzMzZ/qXX36JRx55BE2bNsUDDzyALVu26FgtuXzxxRfo2bMnmjdvjjvvvBOvvPIKzp07l+993Ob0c/bsWYwdOxbdunVD48aN8dBDDxX4vqJklJKSgtGjR6N169Zo3rw5Xn75ZVy5ckXrr1AhecotNTUVMTEx6NGjB26//Xa0a9cOzz//PI4fP55vLObmXUXd5lw+//xzNGzYsMD3lUV2bMZySUpKQnR0NGw2G2JiYjBs2DBs2rQJ06ZN07s0ymXlypXw9/fHyJEjsXDhQnTo0AFvvfUW5s+fn/OeTz75BG+99RY6d+6MJUuWoFmzZnjxxRfx66+/6lc45bFgwQI4HI58rzM741m4cCEmTZqELl26YNmyZZg4cSJq1qyZk9+hQ4fw4osvolmzZliyZAk6d+6MN998E7t379a58orthx9+wIsvvoj69etj/vz5GD16NP78808MGDAgTyPNbU5fJ06cwL59+3DDDTegXr16Bb6nqBm9+uqrOHDgAMaPH493330Xp0+fxrPPPgu73e6Fb1KxeMrt4sWL2LhxI9q3b4/Zs2dj0qRJSElJQe/evXHy5Mk872Vu3lWUbc4lMzMTU6ZMQeXKlQucXibZqZRj0aJFarNmzdSEhISc1zZs2KA2atRIvXTpkn6FUR5xcXH5XhszZozaokUL1eFwqKqqqvfff786fPjwPO/p3bu3OmjQIK/USO79/fffarNmzdT169erDRo0UH///fecaczOWE6ePKk2btxY/frrrwt9z4ABA9TevXvneW348OFq586dtS6P3HjrrbfUjh07qk6nM+e17777Tm3QoIH6008/5bzGbU5frv9uqaqqjhgxQu3atWu+9xQlo59//llt0KCB+s033+S8dvLkSbVhw4bqJ598okHlFZun3NLS0tT09PQ8r6WmpqqtW7dWJ06cmPMac/O+omxzLrNnz1b79etX4PvKKjseGctl//79aNu2LUJDQ3Ne69y5M5xOJw4cOKBfYZRHeHh4vtcaNWqE1NRUpKen49y5czhz5gw6d+6c5z1dunTBd999x9NODeDtt99Gnz7/r717D4qqfOMA/gVlMRcWxHEkEEbAEWQFjbgIOpCoBSKR5tjaKEyYUhoqjRlewgsm5iWiUrwwFt5q1LwEMThmKFMahamJ64zAoghexsBllxBc3P39Qey47irbL+Ts1vczs3/s+77n7MM+cw7n2fOec2Tw8vIyaGfuLM+hQ4cwaNAgREVFmey/f/8+ysrKEBMTY9A+ceJEVFdXo66urifCJBPa29shFothY2Ojb3N0dAQA/bRubnPCs7V98qGYuTkqLS2FRCLB6NGj9WO8vb0xbNgwlJaWdn/g/3Fd5a1v37545plnDNrEYjE8PT0NprExbz2vq9x1qq2txRdffIHly5eb7O+u3LEYe4hCoYC3t7dBm0QiwYABA6BQKASKisxx9uxZDBw4EA4ODvpcPXqg7+PjA41GY/J6Ceo5xcXFuHLlCubNm2fUx9xZngsXLmDo0KHYsmULwsPDMXz4cMhkMly4cAFAxz8rjUZjtO/snPrBfadwpkyZgurqauzduxdqtRrXr1/Hxx9/DH9/fwQFBQHgNmcNzM2RQqGAl5eXQfENdBwccju0DCqVCpWVlQb7S+bNcn344YdISEiAn5+fyf7uyh2LsYeoVCpIJBKjdicnJzQ1NQkQEZmjvLwcRUVFSE5OBgB9rh7NZed75lI49+7dw7p165CWlgYHBwejfubO8ty5cwc//vgjjh49ihUrVmDz5s2wsbFBcnIyGhoamDMLFhwcjM8//xybNm1CcHAwxo8fj4aGBuzYsQO9evUCwG3OGpibI5VKpT/z+TAew1iODRs2wMbGBtOnT9e3MW+W6YcffsC5c+ewYMGCx47prtyxGCOrduvWLaSlpSEsLAyJiYlCh0NdyM3NRf/+/fHqq68KHQqZSafToaWlBTk5OYiJiUFUVBRyc3Oh0+mwZ88eocOjJ/jtt9+wePFiTJs2Dfn5+cjJyYFWq8WcOXMMbuBBRE/fN998g/379yMjIwOurq5Ch0NP0NbWhrVr1yI1NdXkpTHdjcXYQyQSCdRqtVF7U1MTnJycBIiInkSlUmH27NlwdnbGZ599pp8D3JmrR3OpUqkM+qln1dfXY+fOnZg/fz7UajVUKhVaWloAAC0tLfjzzz+ZOwskkUjg7OxsME3D2dkZ/v7+qKqqYs4s2Jo1azBq1Cikp6dj1KhRiImJwfbt2yGXy3H06FEA3F9aA3NzJJFI0NzcbLQ8j2GEd+rUKWRkZGDu3LmYPHmyQR/zZnny8/Nha2uLuLg4qFQqqFQqaDQaaLVaqFQq/XWa3ZU7FmMPMTXHU61W486dO0bXQ5CwWltbkZKSArVajby8PIPTxJ25ejSXCoUCdnZ28PDw6NFYqUNdXR00Gg3mzJmDkJAQhISE4K233gIAJCYm4o033mDuLNCQIUMe29fW1gZPT0/Y2dmZzBkA7jsFVF1dbXStg6urK/r164fa2loA3F9aA3Nz5O3tjZqaGqNnbtbU1HA7FND58+exYMECvPLKKyanvDFvlkehUODatWsIDw/XH68UFhaiuroaISEh+udodlfuWIw9JDIyEqdPn9b/2gR03GzA1tbW4E4pJKz29nYsXLgQCoUCeXl5GDhwoEG/h4cHBg8ebPSMo6KiIoSHh0MkEvVkuPSXYcOGYdeuXQavJUuWAABWrVqFFStWMHcWaOzYsVAqlbh8+bK+7e7du7h06RKkUilEIhHCwsJw7Ngxg+WKiorg4+ODQYMG9XTI9Bc3NzfI5XKDtvr6ety9exfu7u4AuL+0BubmKDIyEk1NTThz5ox+TE1NDeRyOSIjI3s0ZupQVVWFlJQUjBo1CqtWrTI5hnmzPLNnzzY6XhkzZgzc3d2xa9cuREdHA+i+3PXu9r/AislkMuzevRvz5s1DSkoKbt++jfXr10Mmkxkd8JNwVq1ahZKSEqSnp6O5udngoZf+/v4QiURITU3FokWL4OnpibCwMBQVFeH333/nNS4CkkgkCAsLM9knlUohlUoBgLmzMOPHj0dAQADmz5+PtLQ02NvbY/v27RCJRHj99dcBAG+//TYSExOxcuVKxMbGoqysDIWFhcjOzhY4+v82mUyGtWvXYs2aNYiOjoZSqdRft/nwbdK5zQnr3r17OHXqFICOYrm5uVlfeIWGhsLFxcWsHD333HMYM2YMli5divfffx/29vbIzs6Gr68vXnzxRUH+tn+zrvKm0+kwa9Ys2NvbIykpCRUVFfplHRwc9LMOmLee11XufHx8jB4GffjwYdy+fdvgOKa7cmeje/Tc2n9cdXU1MjMzce7cOYjFYiQkJCAtLY2/DlqQ6Oho1NfXm+w7ceKE/pf4AwcOYMeOHbhx4wa8vLzw7rvvYuzYsT0ZKnWhrKwMiYmJOHjwIAICAvTtzJ1laWxsRFZWFkpKSqDRaBAcHIwlS5YYTGE8ceIEPvnkE9TU1MDNzQ1z5szB1KlTBYyadDodvv76a3z11Ve4fv06xGIxRo4cibS0NKMDDW5zwqmrq8O4ceNM9u3atUt/8GdOjtRqNbKysnD8+HG0t7djzJgxWL58OX9Qfgq6yhuAx95YLDQ0FLt379a/Z956lrnb3MPS09NRUVGBwsJCg/buyB2LMSIiIiIiIgHwmjEiIiIiIiIBsBgjIiIiIiISAIsxIiIiIiIiAbAYIyIiIiIiEgCLMSIiIiIiIgGwGCMiIiIiIhIAizEiIiIiIiIBsBgjIiLqRjdv3kRAQADOnj37t5etqqqCv78/rly58hQiIyIiS8NijIiIrMKhQ4fg6+sLX19flJeXG/XrdDpERUXB19cXKSkpAkTYYfPmzRgxYgSef/75v73skCFDEBUVhU8//fQpREZERJaGxRgREVkVe3t7FBYWGrX/8ssvuHXrFkQikQBRdWhsbMSRI0cgk8n+73XIZDIcP34ctbW13RgZERFZIhZjRERkVaKiolBcXIz29naD9sLCQkilUgwYMECgyIBvv/0WvXr1wtixY//vdURERMDJyQmHDx/uxsiIiMgSsRgjIiKrEhcXB6VSiZ9++knfdv/+fRw7dgzx8fEml9Fqtfjyyy8RFxeHgIAAREREICMjA01NTQbjdDodtmzZgsjISIwYMQIzZ85EZWUloqOjkZ6e3mVs33//PQIDAyEWi4369u7di3HjxiEwMBBTp05FeXk5Zs6ciZkzZxqMs7OzQ2hoKE6cOGHO10FERFaMxRgREVkVd3d3jBw5Et99952+rbS0FGq1GhMnTjS5TEZGBjZs2ICgoCAsW7YMU6ZMQUFBAWbNmgWNRqMfl5OTg5ycHPj5+WHx4sXw8PBAcnIyWlpauoxLo9Hg4sWLkEqlRn379u3D6tWr4erqivfeew/BwcGYN28ebt26ZXJdUqkUlZWVaG5u7vJziYjIevUWOgAiIqK/Kz4+Hps2bUJrayv69OmDgoIChISEYODAgUZjy8vLceDAAWzcuNHgzFlYWBjefPNNFBcXIz4+Ho2NjcjLy8MLL7yArVu3wsbGBgCQnZ2NrVu3dhnTzZs30draikGDBhm0379/Hzk5OQgICEB+fj569+741+vr64v09HS4uroarcvDwwNarRYKhQKBgYF/67shIiLrwTNjRERkdWJjY9HW1oaSkhI0Nzfj5MmTj52iWFxcDEdHR4wePRqNjY36l1QqRd++fVFWVgYAOH36NDQaDWbMmKEvxAAgKSnJrJiUSiUAQCKRGLRXVFRAqVRi2rRp+kIM6CgonZycTK6rcx13794167OJiMg68cwYERFZHRcXF4SHh6OwsBCtra148OABXnrpJZNjr127BrVajfDwcJP9DQ0NAIAbN24AAAYPHmz0WY8rmkzR6XQG7zvX6+npadDeu3dvuLu7m7UOIiL6d2IxRkREVmnSpEn44IMP8McffyAyMtLojFQnrVaL/v37Y+PGjSb7XVxcuiUeZ2dnAIBKpfrH6+pcR79+/f7xuoiIyHJxmiIREVmlCRMmwNbWFufPn8ekSZMeO87T0xNKpRJBQUGIiIgwevn5+QEA3NzcAABXr141WL6xsdHoroumPPvss+jTpw/q6uoM2jvX++hzw9rb21FfX29yXXV1dbC1tYWXl1eXn0tERNaLxRgREVklsViMlStXIjU1FdHR0Y8dFxsbiwcPHmDLli1Gfe3t7fqzUBEREbCzs8OePXsMpgnm5+ebFY+dnR2GDx+OiooKg/bhw4fD2dkZ+/fvN3g2WkFBwWOLvEuXLmHIkCFwdHQ067OJiMg6cZoiERFZrcmTJ3c5JjQ0FK+99hq2bduGy5cvY/To0bCzs8PVq1dRXFyMZcuWISYmBi4uLkhOTsa2bduQkpKCqKgoyOVylJaWmj1dcNy4ccjOzkZzczMcHBwAACKRCKmpqcjMzERSUhJiY2NRX1+PQ4cOGV1HBnTcIv/XX3/F9OnT/96XQUREVodnxoiI6F9v9erVyMzMRENDA7Kzs7Fp0yb8/PPPePnllxEUFKQft3DhQqSmpkIul2P9+vWora3Fzp070bdvX7M+JyEhAVqt1uiBzTNmzMDy5ctx8+ZNfPTRRygvL0dubi4cHR1hb29vMPbMmTNQKpVmFZpERGTdbHS8ZRMREdETRUdHIzQ0FOvWrety7NKlS3H16lXs27fvieO0Wi3Cw8MxYcIErFmzRt8+d+5c2NjYYPPmzf84biIismw8M0ZERNSN3nnnHVy8eBFnz57Vt7W1tRndrv7IkSNQKpUIDQ3Vt1VXV+PkyZNYsGBBj8VLRETC4TVjRERE3cjNzQ0XL140aDt//jyysrIQExMDZ2dnyOVyHDx4EEOHDkVMTIx+nI+PD+RyeU+HTEREAmExRkRE9JS5u7vD1dUVu3fvRlNTE5ycnJCQkIBFixZBJBIJHR4REQmE14wREREREREJgNeMERERERERCYDFGBERERERkQBYjBEREREREQmAxRgREREREZEAWIwREREREREJgMUYERERERGRAFiMERERERERCYDFGBERERERkQBYjBEREREREQngfwyyyfLfZ54ZAAAAAElFTkSuQmCC", "text/plain": [ - "0 2.486198\n", - "1 0.533770\n", - "2 0.859257\n", - "3 0.083522\n", - "4 2.608185\n", - "dtype: float64" + "
" ] }, - "execution_count": 48, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ - "((dfDin[\"tmp2\"] - F_fit) / sigma)**2\n" + "plt.figure(figsize=(10,6))\n", + "\n", + "# Seaborn scatter\n", + "sns.scatterplot(\n", + " data=datad,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", + ")\n", + "\n", + "# Barre d’errore\n", + "plt.errorbar(\n", + " datad[\"x\"],\n", + " datad[\"y\"],\n", + " xerr=datad[\"ux\"],\n", + " yerr=datad[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", + ")\n", + "\n", + "# Linea di regressione\n", + "xfit = np.linspace(0, datad[\"x\"].max(), 200)\n", + "yfit = BdC + AdC * xfit\n", + "\n", + "\n", + "plt.plot(\n", + " xfit,\n", + " yfit,\n", + " color=\"crimson\",\n", + " linewidth=1,\n", + " zorder=10,\n", + " label=\"Fit lineare Carpi\"\n", + ")\n", + "\n", + "\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "\n", + "\n", + "plt.xlabel(\"Meq (g)\")\n", + "plt.ylabel(\"T^2 (s^2)\")\n", + "plt.title(\"Legge di ??\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "\n", + "plt.show()\n" ] }, { "cell_type": "code", - "execution_count": 49, - "id": "59281ecb", + "execution_count": 631, + "id": "12bb0479", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "=== REGRESSIONE T^2 vs Meq (ODR/York) ===\n", - "A = 0.0120540 ± 0.0000463\n", - "B = 0.0198570 ± 0.0037792\n", - "cov(A,B) = -7.804236195803344e-08\n", - "chi² = 6.57093\n", - "chi² ridotto = 2.19031\n", + "Chi² = 154.21640\n", + "GdL = 3\n", + "Chi² rid = 51.40547\n", + "P(0, chi²)= 1.00000\n", "\n", - "=== COSTANTE ELASTICA DINAMICA DA ODR ===\n", - "k = 3.275132 ± 0.012588 N/m\n" + "\n", + "############################################################\n", + "capiamo quale dato sta contribuendo maggiormente\n", + "0 57.239249\n", + "1 12.808689\n", + "2 21.014741\n", + "3 1.756058\n", + "4 61.397667\n", + "dtype: float64\n" ] } ], "source": [ + "F_fit = BdC + AdC * datad[\"x\"]\n", + "sigma = np.sqrt(datad[\"uy\"]**2 + (AdC * datad[\"ux\"])**2)\n", "\n", - "# --- DATI DELLA TUA ANALISI ---\n", - "x = Meq.to_numpy() # masse equivalenti\n", - "sx = uMeq.to_numpy() # errori masse equivalenti\n", - "y = T2.to_numpy() # T^2\n", - "sy = uT2.to_numpy() # errori di T^2\n", "\n", - "# --- MODELLO LINEARE ---\n", - "def f(B, x):\n", - " return B[0] * x + B[1] # A*x + B\n", + "chi2_val = np.sum( ((datad[\"y\"] - F_fit) / sigma)**2 )\n", "\n", - "# Pacchetto \"RealData\" con errori anche su x\n", - "dati = RealData(x, y, sx=sx, sy=sy)\n", + "N = len(datad)\n", + "nu = N - 2\n", "\n", - "# Modello lineare\n", - "modello = Model(f)\n", + "chi2_red = chi2_val / nu\n", + "PdC = chi2.cdf(chi2_val, df=nu)\n", "\n", - "# Esecuzione ODR (metodo di York)\n", - "odr = ODR(dati, modello, beta0=[0.01, 0]) # stima iniziale: A≈0.01, B≈0\n", - "out = odr.run()\n", "\n", - "A, B = out.beta\n", - "sA, sB = out.sd_beta\n", - "cov_AB = out.cov_beta[0, 1]\n", - "chi2 = out.sum_square\n", - "chi2_red = out.res_var\n", - "\n", - "print(\"=== REGRESSIONE T^2 vs Meq (ODR/York) ===\")\n", - "print(f\"A = {A:.7f} ± {sA:.7f}\")\n", - "print(f\"B = {B:.7f} ± {sB:.7f}\")\n", - "print(f\"cov(A,B) = {cov_AB}\")\n", - "print(f\"chi² = {chi2:.5f}\")\n", - "print(f\"chi² ridotto = {chi2_red:.5f}\")\n", - "\n", - "# --- COSTANTE ELASTICA ---\n", - "K = (2*np.pi)**2 / A / 1000 # k in N/m → convertito a N/mm?\n", - "uK = (2*np.pi)**2 / (A**2) * sA / 1000\n", - "\n", - "print(\"\\n=== COSTANTE ELASTICA DINAMICA DA ODR ===\")\n", - "print(f\"k = {K:.6f} ± {uK:.6f} N/m\")\n" + "print(f\"Chi² = {chi2_val:.5f}\")\n", + "print(f\"GdL = {nu}\")\n", + "print(f\"Chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {PdC:.5f}\")\n", + "print(\"\\n\\n\" + \"#\"*60)\n", + "print(\"capiamo quale dato sta contribuendo maggiormente\")\n", + "print(((datad[\"y\"] - F_fit) / sigma)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "f3bf75d6", + "metadata": {}, + "source": [ + "### Regressione lineare pesata Yorkfit" ] }, { "cell_type": "code", - "execution_count": 50, - "id": "a53e863f", + "execution_count": 632, + "id": "385db415", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "=== REGRESSIONE T^2 vs Meq (Metodo di Y0RK 2004) ===\n", - "A = 0.0120540 ± 0.0000313\n", - "B = 0.0198570 ± 0.0025536\n", - "cov(A,B) = -7.804416866416002e-08\n", - "chi² = 6.57093\n", - "chi² ridotto = 2.19031\n", - "\n", - "=== COSTANTE ELASTICA DINAMICA (York 2004) ===\n", - "k = 3.275132 ± 0.008506 N/m\n" + "AdY = 0.0120538 ± 0.0000065\n", + "BdY = 0.0198466 ± 0.0005286\n", + "cov_ABdY = -3.327136085608824e-09\n", + "chi² = 154.21640\n", + "chi² rid = 51.40547\n", + "P(0, chi²)= 1.00000\n", + "KdY = 3.27519 ± 0.00175\n", + "KBdY = 1.98918 ± 0.05298\n" ] } ], "source": [ - "# --- DATI ---\n", - "x = Meq.to_numpy().astype(float)\n", - "sx = uMeq.to_numpy().astype(float)\n", - "y = T2.to_numpy().astype(float)\n", - "sy = uT2.to_numpy().astype(float)\n", - "\n", - "# --- METODO DI YORK 2004 ---\n", "def york_fit(x, y, sx, sy, max_iter=50, tol=1e-15):\n", " # Pesi iniziali\n", " wx = 1 / sx**2\n", @@ -1539,10 +1996,10 @@ " for _ in range(max_iter):\n", " A_old = A\n", "\n", - " # 1) Pesi combinati (eq. 9)\n", + " # 1) Pesi combinati\n", " Wi = (wx * wy) / (A**2 * wy + wx)\n", "\n", - " # 2) x̄ e ȳ pesati (eq. 10)\n", + " # 2) x e y pesati (eq. 10)\n", " X_bar = np.sum(Wi * x) / np.sum(Wi)\n", " Y_bar = np.sum(Wi * y) / np.sum(Wi)\n", "\n", @@ -1550,21 +2007,20 @@ " Ui = x - X_bar\n", " Vi = y - Y_bar\n", "\n", - " # 4) β (eq. 11)\n", + " # 4) beta\n", " beta_i = Wi * (Ui / wy + A * Vi / wx)\n", "\n", - " # 5) Aggiornamento pendenza (eq. 12)\n", + " # 5) Aggiornamento pendenza\n", " A = np.sum(Wi * beta_i * Vi) / np.sum(Wi * beta_i * Ui)\n", "\n", " # Convergenza\n", " if abs(A - A_old) < tol:\n", " break\n", "\n", - " # 6) Intercetta (eq. 13)\n", + " # 6) Intercetta\n", " B = Y_bar - A * X_bar\n", "\n", - " # --- ERRORI (eq. 14–16) ---\n", - " # S = Σ Wi (xi - x̄)²\n", + " # S = somma Wi (xi - x)**2\n", " S = np.sum(Wi * Ui**2)\n", "\n", " sA = np.sqrt(1 / S)\n", @@ -1573,26 +2029,1061 @@ " # cov(A,B)\n", " cov_AB = -X_bar * sA**2\n", "\n", - " # CHI QUADRATO (eq. 17)\n", + " # CHI QUADRATO\n", " chi2 = np.sum(Wi * (Vi - A * Ui)**2)\n", " dof = len(x) - 2\n", " chi2_red = chi2 / dof\n", "\n", " return A, B, sA, sB, cov_AB, chi2, chi2_red\n", "\n", - "A, B, sA, sB, cov_AB, chi2, chi2_red = york_fit(x, y, sx, sy)\n", + "AdY, BdY, uAdY, uBdY, cov_ABdY, chi2_val, chi2_red = york_fit(datad.x, datad.y, datad.ux, datad.uy)\n", + "PdY = chi2.cdf(chi2_val, df=nu)\n", "\n", - "print(\"=== REGRESSIONE T^2 vs Meq (Metodo di Y0RK 2004) ===\")\n", - "print(f\"A = {A:.7f} ± {sA:.7f}\")\n", - "print(f\"B = {B:.7f} ± {sB:.7f}\")\n", - "print(f\"cov(A,B) = {cov_AB}\")\n", - "print(f\"chi² = {chi2:.5f}\")\n", - "print(f\"chi² ridotto = {chi2_red:.5f}\")\n", - "K = (2*np.pi)**2 / A / 1000\n", - "uK = (2*np.pi)**2 / (A**2) * sA / 1000\n", + "# Calcolo del K dai parametri\n", + "KdY = (2*np.pi)**2 / AdY / 1000\n", + "uKdY = np.sqrt( (4*np.pi**2 / AdY**2)**2 * uAdY**2 ) / 1000\n", + "KBdY = (2*np.pi)**2 / BdY / 1000\n", + "uKBdY = np.sqrt( (4*np.pi**2 / BdY**2)**2 * uBdY**2 ) / 1000\n", "\n", - "print(\"\\n=== COSTANTE ELASTICA DINAMICA (York 2004) ===\")\n", - "print(f\"k = {K:.6f} ± {uK:.6f} N/m\")" + "\n", + "print(f\"AdY = {AdY:.7f} ± {uAdY:.7f}\")\n", + "print(f\"BdY = {BdY:.7f} ± {uBdY:.7f}\")\n", + "print(f\"cov_ABdY = {cov_ABdY}\")\n", + "print(f\"chi² = {chi2_val:.5f}\")\n", + "print(f\"chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {PdY:.5f}\")\n", + "print(f\"KdY = {KdY:.5f} ± {uKdY:.5f}\")\n", + "print(f\"KBdY = {KBdY:.5f} ± {uKBdY:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 633, + "id": "698bc57c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2MAAAIsCAYAAAB/SHEEAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAn9ZJREFUeJzs3Xd0FHX7NvBrtqSTCiRUERAEQZp0RR/EAqig0hQ1CChKbGADRKoggkoJVTooHURQQVAUFBQ7AioiTYoC6T3ZMu8fvJtfQpLdtNmZO7k+5zznPOzsfPfeuWbGvTNNUVVVBREREREREXmVSe8CiIiIiIiIKiM2Y0RERERERDpgM0ZERERERKQDNmNEREREREQ6YDNGRERERESkAzZjREREREREOmAzRkREREREpAM2Y0RERERERDpgM0ZERERERKQDNmNEREQae/TRR/Hoo4/m/vvcuXNo3LgxtmzZomNVRESkNzZjRETkNVu2bEHjxo1x+PBhvUsR4dy5c3jjjTdw1113oUWLFujevTvWrl2b7z1//fUXRo8ejW7duqFly5bo1asXdu3apVPFRERUEha9CyAiIqpsatWqhd9++w0Wi/v/DM+dOxe//vorevXqhYiICHz22WeYMGECfH198cADDwAAJk+ejIyMDAwYMAABAQHYvHkznnvuOaxYsQIdOnTwxtchIqJSYjNGRETkZYqiwNfX1+P7Bg4ciClTpsBsNgMAHnzwQXTr1g3bt2/PbcZeeukltGjRInee++67Dx07dsTHH3/MZoyIyOB4miIRERnOxYsXMXr0aHTq1AnNmjVDz549sWnTpgLvO3/+PJ566im0bNkSHTt2xNSpU/H111+jcePGOHjwYL73fvDBB7j99ttx4403ok+fPvjxxx8LXMsFADk5OZgzZw7uuOMONGvWDLfeeiumT5+OnJycYtW+fv16dOvWLd/nXK2414w1b948txEDAIvFAovFApvNlvta3kYMAHx8fGAymfK9h4iIjIlHxoiIyFDi4uLQr18/KIqCgQMHIjw8HPv27cNrr72GtLQ0DBo0CACQkZGB6OhoXL58GY899hiqVq2Kjz/+uEATBgBr1qzBpEmTcNNNN2HQoEE4f/48YmJiEBwcjKioqNz3OZ1OPP300/jpp5/Qr18/NGjQAH/99RdWrlyJ06dPY/78+W5r37hxI8aNG4dWrVohOjoaZ8+exdNPP42QkBDUqFGjzMtm9erVOHv2LGJiYop8z7vvvovs7OzcI2dERGRcbMaIiMhQZs6cCYfDge3btyMsLAwA8NBDD2HkyJGYO3cuBgwYAD8/P6xfvx5nz57FvHnz0K1bNwDAgAED0Lt373zj5eTkYPbs2WjevDlWrlyZe51W48aNMWrUqHzN2Pbt23HgwAGsXr0aN910U+7r1113HcaPH4+ff/4ZrVu3LrRum82GmTNnokmTJli1ahV8fHwAAA0bNsTrr79e5mZs27ZtmDJlCgYMGID777+/0PcsWrQIy5cvx4svvoj27duX6fOIiEh7PE2RiIgMQ1VV7Nq1C127doWqqkhISMj9380334zU1FQcPXoUAPD1118jMjISt99+e+78vr6+6NevX74xjxw5gqSkJPTr1y/fDTPuvfdehISE5Hvvzp070aBBA9SvXz/fZ7uuvSrsqFvez4mPj8eAAQNyGzEAuP/++1GlSpXSLxQAJ06cwJgxY3D77bdj/Pjxhb7nwIEDePfdd/Hoo4/iySefLNPnERGRd/DIGBERGUZCQgJSUlKwfv16rF+/vsj3AFeuF6tbty4URck3vW7duvn+feHChUJft1gsqFWrVr7Xzpw5gxMnTqBjx46FfnZ8fHyRtbs+55prrsn3utVqRZ06dYqcrzg+/fRT2Gw2jB8/HiZT4X9H3bZtGwIDA/HKK6+U6bOIiMh72IwREZFhOJ1OAFfuCFjUqXiNGzfW9PMbNWqE0aNHFzo97ymN3pSUlAQAqF69utv3hIaG5jsqR0RExsZmjIiIDCM8PByBgYFwOp3o1KmT2/fWqlULf//9N1RVzXd07J9//sn3vpo1a+a+nvdW73a7HefPn8/X3NWtWxd//vknOnbsWOCImyeuzzlz5ky+I2s2mw3nzp3D9ddfX6Lx8rrpppugqqrb99x6661o2rRpqT+DiIi8j9eMERGRYZjNZtx111347LPP8NdffxWY7jpFEQBuvvlmXLx4EV988UXua9nZ2diwYUO+eZo1a4bQ0FBs2LABdrs99/Xt27cjOTk533u7d++OixcvFhgDALKyspCRkVFk7c2aNUN4eDjWrVuX7zb4H374IVJSUtx8a8/atGmDgQMHun3PrbfeWuDmJUREZGw8MkZERF63efNmfP311wVef+yxx/Diiy/i4MGD6NevH/r27YuGDRsiOTkZR48exbfffovvv/8eANC/f3+8//77ePHFF/HYY4+hWrVq2L59e+7DlF1Htnx8fPDss89i8uTJiI6ORvfu3XH+/Hls2bKlwHVkvXr1wo4dOzB+/HgcPHgQrVu3hsPhwMmTJ7Fz504sWbIEzZs3L/Q7Wa1WvPDCCxg3bhyio6PRo0cPnDt3Dlu2bCnzNWPvvvsuPvzwQxw7dqzI97z66qs4f/489uzZU6bPIiIi72EzRkREXrd27dpCX3/ggQcQFRWFjRs3Yt68edi9ezfWrl2L0NBQNGzYEC+99FLuewMDA7Fy5Uq88cYbWLVqFQICAtC7d2+0atUKzz77bG5TBgCPPPIIVFXF8uXL8dZbb+H666/HggUL8MYbb+R7n8lkwrx587BixQp89NFH2L17N/z9/VG7dm08+uijuPbaa91+r/79+8PhcGDp0qWYPn06GjVqhAULFmD27NllXGJERFQRKaqnk9CJiIgEWbFiBd58803s27cPkZGRRb7P6XSiY8eOuOOOO/DGG294sUIiIqIreM0YERGJlZWVle/f2dnZWL9+PerVq5evEcvOzi5wA4ytW7ciKSkJ7dq180qtREREV+NpikREJNYzzzyDmjVr4vrrr0daWhq2bduGkydP4u233873vl9//RVvvvkm7r77boSGhuL333/Hpk2b0KhRI9x99906VU9ERJUdmzEiIhLr5ptvxqZNm7B9+3Y4HA40bNgQM2fORI8ePfK9r1atWoiKisLq1auRnJyMkJAQ9OrVCy+99BKfy0VERLrhNWNEREREREQ64DVjREREREREOmAzRkREREREpANeM1aEX375Baqqwmq16l0KERERERHpyGazQVEUtGrVqlzHZTNWBFVVC9wGmYiIiIiIKh+t+gI2Y0WwWq1QVRXNmjWDoih6l0PFpKoqbDYbrFYrcxOG2cnE3GRibnIxO5mYm0x5czty5Igmn8FrxoiIiIiIiHTAZoyIiIiIiEgHbMaIiIiIiIh0wGaMiIiIiIhIB2zG3OAFljLxcQRyMTuZmJtMzE0uZicTc5NJ69x4N0UPitOQORwO2Gw2L1RD5J7VaoXZbNa7jFLhHz9kYm4yMTe5mJ1MzE0mb+TGZswDVVWLDEJVVfz3339ISkryblHklrvMKoPQ0FBERUWJWwaqqsLhcMBsNourvTJjbjIxN7mYnUzMTaa8uWmFzZgbnh7u5mrEqlevjoCAAG5cBuB6WLeiKJUuD1VVkZGRgUuXLgEAatSooXNFJed0OsUe2avMmJtMzE0uZicTc5NJ69zYjJWSw+HIbcQiIiL0Lof+v8rcjAGAv78/AODSpUuoXr06d/pEREREBsYbeJSS6xqxgIAAnSshys+1TvI6RiIiIiJjYzNWRpXx6AsZG9dJIiIiIhnYjLnBH7UyMTe5eFqlTMxNJuYmF7OTibnJpHVubMY8qAw/7GNjY9G4ceMC/7vnnnsAAI0bN8bSpUtz379lyxZs3769WGN37doVkyZNyv33qFGjcsfVgutaMW/lNmrUKHTo0KHQO2q+9dZbaNWqFf77779Sjx8bG4tWrVqVoUI5FEXhXaYEYm4yMTe5mJ1MzE0mb+TGG3h4UFluk+7n54eVK1cWeA0A1q9fj5o1a+a+/uGHHyIgIAD33ntviT9n+PDhyMjIKFuxbuS9A6Y3cnvllVfw5ZdfYsaMGZgyZUru68eOHcOqVavw8ssvIyoqSvM6KoLKfvMVqZibTMxNLmYnE3OTKW9uWmEz5oanW9tXJCaTCS1btix0WlGvl0bdunXLbayilHSjycnJgcVigclU8gPF4eHhGDVqFEaPHo0HHngAbdq0gaqqmDBhAho3boxHH320xGPmramysdvtmj/pnsofc5OJucnF7GRibjJpnRtPUySP8p6m+Oijj+L777/HV199lXs6Y2xsbLHHuvo0xS1btqBx48b4/fffMXToULRs2RJ33nkntm7dWmDer776Cn379sWNN96IDh06YPz48fmOsmVkZGDSpEno3r07WrZsia5du2LcuHFITU3NN47r1MnFixfjf//7H2688cbc0wy3bNmCe++9F82bN8ctt9yCmTNnwuFwuP1O999/P9q1a4cJEybAbrdj8+bNOHToECZNmgSz2Yzz58/jueeeQ5s2bdCyZUsMGTIEx44dK3ZNV5s7dy5atGiBvXv3uq2LiIiIiIyt8v3pnYpkt9vz/buwc2THjx+Pl19+GX5+fnj11VcBoFxOw3vppZfQr18/PP7449iwYQNGjRqF5s2bo0GDBgCAnTt3YsSIEXjggQfw7LPP4vLly3jnnXeQkpKCmTNnAgCysrLgdDrxwgsvIDw8HP/99x8WLlyI4cOHY/Xq1fk+b9euXbjmmmvw2muvwWQyISAgAMuXL8eMGTMQHR2NUaNG4cSJE7nN2EsvveS2/okTJ+K+++7DzJkzsWnTJgwcOBDNmjVDWloaHn30UZhMJkycOBG+vr5YsGABHnnkEWzbti3fg5kLq+lqb731FtatW4f33nsP7du3L+tiJyIiIiIdsRkjAFeOKt1www35Xps+fTp69eqV77WGDRsiKCgIAQEB5Xr64sCBAzFw4EAAQKtWrbB371589tlnGD58OFRVxfTp09GjR49812VVq1YNTz75JIYPH47rrrsO4eHhmDBhQu5pig6HA7Vr18bDDz+MU6dO4dprr82d12azYfHixbkNT1paGubMmYOhQ4di5MiRAIDOnTvDarVi2rRpGDJkCMLCwoqs/9prr8WwYcMQGxuLqKgovPDCCwCuHGm7cOECPvnkk9zGsm3btvjf//6HlStXYtSoUUXWlJfr1McdO3ZgxYoVaNGiRSmXNBEREZGxJSQk4LvvvkOHDh0QHh6udzmaYjPmRmkv1rOdvgBncqrnN5YzU0gVWOvV9PzGQvj5+eH999/P91qdOnXKo6xiufnmm3P/f0BAAGrWrJl7F8JTp07h/PnzGDNmTL6jd+3atYPJZMKRI0dw3XXXAQA++ugjrFixAmfOnMl3CuPp06fzNWPt27fP1/T88ssvyMjIwN13353vMzp16oSsrCwcP34c7dq1c/sdnnzyScTGxuKhhx5CYGAgAODHH3/Eddddl9uIAUBoaCg6deqEn376Kd/8V9fkoqoqXnnlFezfvx+rVq3C9ddf77YOyXhRs0zMTSbmJhezk4m5FV9ycjJ+//13NGnSRPdmTOvc2Ix5UNIAHPFJ+Kf9Q4DTqVFFbpjNqHd0K8wRoSWe1WQyoXnz5uVfUzFVqVIl37+tVitycnIAAImJiQCAmJiYQuf9999/AQC7d+/Gq6++iv79+2PEiBEIDQ3F5cuXERMTg+zs7HzzRERE5Pu36zPuv/9+t5/hjo+PT27tLikpKahatWqB90ZEROD48eNua3Kx2WzYs2cPOnXqhEaNGnmsQypFUXhhs0DMTSbmJhezk4m5FZ8zKxvZy7ej5ukzSO+Ro2st3siNzVg5M0eEou7BtbodGStNI2Z0oaGhAIBx48bhxhtvLDC9evXqAK5cV9akSZN8zzX7/vvvCx3z6iY7JCQEwJWbYxR2DVzt2rVLVXtISAhOnTpV4PX4+PjczyyqJhcfHx8sWrQITzzxBCZMmJDv+xERERFVBJmZmUj+dB/SpyyG+fxlOG65Hus+O4wng0MQFOADf39/+Pv7611muWMz5kFpni1Q2lMFpbBarQWONGmpfv36iIqKwtmzZ3OvKytMVlYWrFYrnE5n7nM8ivtw6latWsHf3x///fcf7rjjjvIqHW3atMFnn32GkydPon79+gCuHHo/cOAA+vfvX+xxbrrpJsyfPx/Dhg2Dr68vXnvttXKr0ShUVYXdbofFYuGpHIIwN5mYm1zMTibm5l7OiX9w5tkpsP7wO+Ia1MSevjcjq6oPbAl/45NPkhHgZ0GzZs3Qpk0br9aVNzetsBlzozI9Z6wk6tevj61bt2LPnj2oVq0aqlevjsjISM0+T1EUjBo1Ci+99BIyMjJw2223wd/fHxcuXMDevXsxYsQIXHvttejUqRMmTZqE+fPno1WrVti3bx++/fbbYn1GcHAwnnvuOcyYMQP//fcf2rVrB7PZjLNnz+KLL75AbGxsqf4a88ADD2DFihUYNmwYXnjhhdy7KVosFkRHR5dorI4dOyI2NhYxMTHw9/fPvdFIRcJtTibmJhNzk4vZycTcCnKmZSDx3VVIWrgepvBg/D6oGy5dXwdZ/yYC9jT4+VrhY9X3SVxa52aoZuzMmTNYunQpDh06hOPHj6N+/fr4+OOPizXvxYsX8e6772Lv3r3IyMhArVq18PTTT+O+++7TuOrK54knnsA///yDV199FSkpKXjmmWfw7LPPavqZ3bt3R3BwMBYuXJh7tKtWrVq45ZZbcq/JGjBgAM6ePYsPPvgAy5Ytw80334x33nkH/fr1K9ZnDB48GJGRkVi+fDnef/99WCwW1K1bF7fddlupzxcOCgrC6tWrMW3aNLz++utwOp1o3bo13n///Xy3tS+uW2+9FbNmzcLzzz8PX1/fIq+jIyIiIjIqVVWRtuVzxE+YD2dSCsJGPga/Ifejqnrlngt//X0SX37xOf53+61o1PDKmUUV8RRFAFBUA7Xpn3/+OSZPnowWLVrg1KlTUFW1WM3YpUuX0K9fP1x77bV4+OGHERQUhOPHjyMgIAB9+vQpVS2HDx+Gqqpo3rx5oYeTs7Kycm+X7ufnV6rPoPKnqmruqaWV9TQAqeumqqqw2WywWq2VNjuJmJtMzE0uZicTc/s/2YePI270LGQd/A2B99yKiEnPwFon//X6p06dwubNm/Hggw/muxu2t+XN7ciRIwBQ7je8M9SRsa5du6Jbt24AgFGjRuV+aU9mzJiBqKgoLFmyBGazGcCVU7qIiIiIiEh/joRkJExbgpSV22BtWAc1Ns9EQJebCn1vSEgImjZtWuBmZxWRoZoxk6nk54SmpaVhx44dmDp1am4jVl4q+18upGJucvG2vzIxN5mYm1zMTqbKmpvqcCBl9XYkTF0M2B2ImBiDkCEPQLEW3YaEh4ejR48eXqyyaLy1vQdHjx6FzWaDxWLBI488gl9++QWhoaHo3bs3XnjhhTIvQP6wl4V5ycXsZGJuMjE3uZidTJU1t8zvfkPc6FnIOXIcVR7qgfCxw2Cpru9DnEvCG7mJb8bi4uIAAGPHjkW/fv3wzDPP4LfffsOcOXNgMpnw4osvlml8123S81IUJffOKq5rlPJOc71emLzzFjatLPNyXPcqSzZ5XzNave7mBQCHwwGTyeR2myvvmqSNa7SaAPe5Ga3eypSNp9zyPgbEKPWWZd7KMi7AbU7iuIAxtzmtxrX9exkJExcgbfNu+La6HjV3LIRfm6bi9hF570WgFfHNmNN55a4rnTp1wqhRowAAHTp0QHp6OpYtW4aYmJhS38TAddFe3gBMJlPuswZcARXWjLmm51WcaVePV9Zxrx67MozrbkdY1HvKo96yzFue4+b9t91uLzDd9YwTp9MJh8ORb1re9dtmsxWoyXXhscPhyN32rh5XVa88k6OwcV3bVGHjuj7z6h8YZrMZZrO50HEVRcmdt7Dv6ppW2Hcty7hlWYY+Pj4A4HYZuhvX0zIsbNzyWIZFjWsymWC32wv8wNBqGWqZjbv1290yLM64QPln4+67usYtrCZFUWCxWArMU5xx9d5HaLV+S9tHFLbN6b0Mvbl+S9xHmM1mOByOQn/YG3EfUdpxFbsDaUu3IPGdlVD8fBH29osI7H83FJMp3w1MpOwjXPtKk8mkWVMmvhkLDg4GcKUBy6tjx45YuHAhzpw5g8aNG5d6fHd3vXG97ml6SaYVJ+TSjFucsSv6uFf/UDRCTVqP6+4hhSaTye11moWd4uv6rLw78cLeU9Tpwe6muWoqapvzNG9pv6tW4wLuzzN3twzLUm9pswHcf9fijFvUuqjVMjTa+l3UuC5aZVPWZVhUbkbcR+ixDI24j3C3zRl5H1GacSviPqKobU76MszYcxDxr82B7fQFBA+5H2EvPw5zSJV880jbR7ias8KORJcX8c1Yw4YN3U7Pzs4u0/hX/+XJxfWXq8zMTAQEBBQ6n7sxPX1meU+rLOMWdZRSz5q8PW5mZiYA9zv8snymVvO6/uJU1DZXEbLRe16ttjl3uZWlJknLwag1edpXapGbXvNWlnG5zckc16jbXHmMazt9AXGvxyJj5zfwu7k1Ipe/Ad8m9TWptyzzarnfKgvxzVitWrXQqFEjHDhwAI888kju6wcOHICfn5/HZq20zGYzQkNDcenSJQBAQECApkFR8eQ9t7ey5aGqKjIyMnDp0iWEhoaW+91FiYiIiFyc6ZlImvMBkuathblqKCKXTELgfbdVut9fZWWoZiwzMxN79+4FAJw/fx5paWnYuXMnAKBdu3YIDw9HdHQ0Lly4gN27d+fON2LECAwfPhxTpkzBbbfdhsOHD2PZsmUYMmRIoUetisvTyhQVdeUBda6GjIxB6wstjS40NDR33ZSGDaRMzE0m5iYXs5OpouSmqirSP/oS8RPmwRGXhNBnHkLoswNhCvTXuzRNaJ2borq724GXnTt3Drfffnuh01atWoX27dvj0Ucfxfnz57Fnz5580z/99FPMnz8fp0+fRvXq1dG/f388+eSTpf5RfvjwYQDFe8q2w+Eo9GJCIm+zWq0VZmdPRERExpL9x0nEjZmNrG9+RkD3m1F10rOw1qupd1leUZLeoCQM1YwZiWuBN2vWrFIfZZGmMp+mKB2zk4m5ycTc5GJ2MknPzZGcisRpS5G8fCus9Wqi6pTnEXB7e73L0lze3I4cOQKg/JsxQ52maDTsU2Wy2+2V9in30jE7mZibTMxNLmYnk8TcVKcTqR98gvgpi6Bm5SB87JMIfbIvFB9Z36MstM6NzRgREREREeWT9dNRxI2ahexf/0RQv7sQ8fpTsERV1busCofNGBERERERAQDslxKQMHkhUtftgE/z61Dz43nwb3+j3mVVWGzGiIiIiIgqOdVmR/KSTUicsQKwWlD17ZcQ/Mg9UHhjME2xGXND4gWWxNwkY3YyMTeZmJtczE4mI+eWsfdHxI2ZBdvfZxEc3Qvho4fCHBasd1mGoHVubMY8MPKGQwUpiiLu4li6gtnJxNxkYm5yMTuZjJqb7Z9/ET9uHtI/2Qu/Di0Q+cUE+DZrqHdZhuGN3NiMERERERFVIs7MbCTNXYOkOe/DFBqM6ovGI+j+23kQQgdsxjxwPVuAZFBVFXa7HRaLhbkJw+xkYm4yMTe5mJ1MRslNVVWkf/o14sfNhf3fywh9uj/CRjwGU1CAbjUZWd7ctMJmzA0+Z0wm5iYXs5OJucnE3ORidjLpnVvOX6cRN2Y2Mvf+iIBuHVBjwzvwaVBH15ok0Do3NmNERERERBWUMzUdCTOWI3nxJlhqRyHqg2kIvLOz3mXR/8dmjIiIiIioglGdTqRu+AwJkxbCmZ6B8FeHIPTp/lB8ffQujfJgM0ZEREREVIFk/fon4kbPQvaPRxF0/+2ImDAclprV9S6LCsFmzA1eGCuTlhdZkraYnUzMTSbmJhezk8kbuTniEhE/5T2kfvAJfJpci5pb58C/cyvNP7ci0zo3bs0esCGTRVEUZiYUs5OJucnE3ORidjJpnZtqtyNl+VYkvLUUAFD1zRcQHH0fFDbuZeKN7Y0JecBb28uiqiqcTidMJhNzE4bZycTcZGJucjE7mbTMLXP/L4gbPQs5f55C8KP3InzMEzBHhJbrZ1RWeXPTCpsxN/S+BSmVjsPh0HSjIe0wO5mYm0zMTS5mJ1N552Y/fxFx4+cj/aM98G3bDLV3L4Zvi8blNj5dofX2xmaMiIiIiEgIZ1Y2kuevR+Ls1TAFBaD6vNcQ1OdOKGzQRWIzRkRERERkcKqqImPXAcSNnQP7uYsIGdYX4S8OgqlKoN6lURmwGSMiIiIiMrCcE/8g/rVYZHzxHfxva4saa6bD57pr9C6LygGbMTd4YaxMPI9eLmYnE3OTibnJxexkKk1uzrQMJL67EkkLN8BSoxqiVk5BQPdb+BvVi7Te3tiMecCVXRZFUfj8FaGYnUzMTSbmJhezk6mkuamqirTNuxE/cQGcSSkIG/kYQmMehsnfV8Mq6Wre2N64NXvAW9vLkvcOmMxNFmYnE3OTibnJxexkKklu2YePI270LGQd/A2B996GiIkxsNaJ0rpEKoQ37qzOZswN3tpeJpvNBqvVqncZVArMTibmJhNzk4vZyeQpN0dCMhKmLUHKym2wXlcXNTbPRECXm7xYIRVG6+2NzRgRERERkU5UhwMpq7Yh4c0lgN2BiIkxCBnyABQrf6ZXBkyZiIiIiEgHmd/9hrjRs5Bz5DiqPNwT4WOHwVItTO+yyIvYjBEREREReZH9vzjET5yPtE274duqCWp9tgh+rZvqXRbpgM0YEREREZEXqNk5SHpvExLfWQklwBfVZo1ClYe6Q+HjCiotNmNuKIrCOxUJoygKfHx89C6DSoHZycTcZGJucjE7mRRFgW3fz/jvtdmwnfkXIUMfQNjLj8McUkXv0sgNb2xvbMaIiIiIiDRiO3Ueca/HIuOz/fC/pTWiVk6Fz/XX6l0WGQSbMQ/4nDFZVFWFw+GA2WxmbsIwO5mYm0zMTS5mJ4czPROJs1Yjaf46WKqHo+riCahy3/9g4imJYuTd3rTCZswNPmdMJqfTqelGQ9phdjIxN5mYm1zMzthUVUX61j2ImzAfzvgkhD37MEKeHQiHlQ20RFpvb2zGiIiIiIjKQfbvJxA3Zjay9v+CgO43o+qkZ2GtV/PKERabTe/yyIDYjBERERERlYEjKRWJby1F8vKtsF5bCzXWv42Aru31LosEYDNGRERERFQKqsOB1DWfIn7KIqhZOYh4fRhCnugDxceqd2kkBJsxN3her0wWC1drqZidTMxNJuYmF7MzhqwfjyJu1ExkHzqGoH53IeL1p2CJqlrk+5mbTFrnxrXCAzZksvDZcHIxO5mYm0zMTS5mpz/7xXgkTF6I1PU74dP8OtT6ZD782jV3Ow9zk8kbubEZ84C3tpdFVVU4nU6YTCbmJgyzk4m5ycTc5GJ2+lFtdiQv2YSE6cuh+FhR7Z2XUWVgTyjFuNMec5Mpb25aYTPmBm9tL5PD4eAzPIRidjIxN5mYm1zMzvsyvvoBca/Nhu3vswge1Bvho4bAHBZcojGYm0xa58ZmjIiIiIioELZ//kX8uLlI/2Qf/Dq2QOSiCfBt1lDvsqgCYTNGRERERJSHMzMbSbEfICn2A5jCQlD9vfEI6n07TzGkcsdmjIiIiIgIVy5RSf9kH+LHzYX9YjxCn+6PsBcehSkoQO/SqIIy1ImrZ86cwbhx49CrVy80bdoU99xzT4nHWLFiBRo3boxhw4aVuR7+9UMmno8tF7OTibnJxNzkYnbayDl2Cv/2HYmLj4+Fz/XXou7XqxAxdli5NWLMTSatczPUkbHjx49j7969aNGiBZxOZ4lvoHH58mXMmzcPERER5VYTGzJZFEXhczyEYnYyMTeZmJtczK78OVLSkDhjOZKXbIa1Tg1EffAWAu/sVK6fwdxk8kZuhlorunbtim7dugEARo0ahSNHjpRo/hkzZqBr1664cOGCFuWREHwcgVzMTibmJhNzk4vZlQ/V6UTq+p1ImLwIzvRMhI8aitCn+kHx9dHm85ibSFrnZqjjpWU5DPjjjz/i888/x4svvlhu9aiqytvbC6OqKmw2G3MTiNnJxNxkYm5yMbvykfXrnzjfczguP/cm/G9pjbrfvo+w5x/RtBFjbvJ4IzdDHRkrLYfDgcmTJ+Opp55C9erV9S6HiIiIiAwgISEB3333HTp06IDw8HA44hIR/8YipK75FD5N66PmR7Hw79RS7zKpEqsQzdiaNWuQmZmJQYMGlfvYhXXCiqIU2SG7DmO6m67VvBwXufMVlVtZ6i3LvBzX87yuad7e5qSNa7SaXPNpsc1JWg5GrcnTX3ONVq8RazLauK5p3OaKN25SUhJ+//13NG54HUybvkDiW8sAk4KIqc8jOPo+KBZLvnG03FeWdl69l6GRxvV2Ta7XeGTMjfj4eMyZMwdvvfUWfHzK/9CyzWbLd56oyWTKvZDPZrMVeL+rBofDAafTmW+axWKBoihwOp1wOBz5prnGdR0OvZrVai1yXLPZDLPZDFVVYbfb801TFCV3XrvdXmBl0mrc4nxXoOAyLOu4ZrM5d9yrz++1Wq1QFKXE39VT5nosQ9e4hdWkVTau71rUMnSN624Zelq/nU5ngezKY/12twy9uX4DFW8fYTKZcmvKm5tR9xGlXb8r2j7CVe/Vn+lpXL33EVqt39L2EYVtc3ovQ6P+jkhNy0bYqUtwPDIW8af/RZVH70XEmCeA0CqwOxxAnvm13Ed4+n3i7WVYUX9HaLEMAeTeWPDq7MqD+GZs9uzZaNy4MW666SakpKQAuLIw7XY7UlJSEBAQUKa7oLhWmqKmFSXvSn41k8lU5PVxeVeKko7raV53y0Grcd19V8D9MizruFfn5vp3Wb6rHtnouQyvVtZl6Gk5mEymIrc5rZahXtlUxH1EUfvKyrJ+FzWui1H3EUXlZsR9hB7L0Ij7CHfbnJH3EaUZtzTLMCEhAcnJyUg//R8uj1uE2/48gYu1ohC8aCyUFg1hUZwI03EfUdQ2Z6RlqNW40vYRrubMZDJp0ogBFaAZO3XqFH744Qe0bdu2wLS2bdti8eLF6NKlS6nGVhQl93+FTfM0b2mmlWVejntlo3H9VbGo91SU7ypxXHfTPWUn7btWln2EltucpOVg1Jrc5eb6UWKkfWVZ5q0s43Kb8zzt4L5vYF+1HY2+/QuRPhZ80+0G/H1dTQT+9SssJ35D06ZN0aNHD6/Wa9RtTtq4etTkroErD+KbsTFjxuQeEXOZOnUq/Pz8MHLkSDRu3LhM42vVBZM2mJdczE4m5iYTc5OL2RVNVVVkfLYf109aDeeFy7D1vQNbatSGLfssENwA93Rvg0B/H4SEhHi9NuYmkzdyM1QzlpmZib179wIAzp8/j7S0NOzcuRMA0K5dO4SHhyM6OhoXLlzA7t27AQBNmjQpME5wcDACAgLQvn37Mtek1fmhpA1VVeFwOGA2m5mbMMxOJuYmE3OTi9kVLufEP4gbMweZew7C/3/tUHX92/C57ho8+PsxfLz9Eu7p3gbNmpbtD/RlwdxkypubVgzVjMXHx+P555/P95rr36tWrUL79u0LvVhQK1reOYW043Q6Nd1oSDvMTibmJhNzk4vZ/R9nWgYS312JpIUbYKlZDVGrpiLg7ptzG55Afx9YzCYE+mvz/LCSYG4yaZ2boZqx2rVr49ixY27fs3r1ao/jFOc9RERERCSTqqpI27QL8RMXwJmShrAXoxE6/CGY/H3zvS8kJARNmzbV5dREouIwVDNGRERERORO9m9/IW70LGR9fxiB9/0PEROGw1onqtD3hoeHu71ZB5He2IwRERERkeE5EpKR8OZipKzcBmvjeqixZRYCbmmjd1lEZcJmzA1eYCkTz8eWi9nJxNxkYm5yVbbsVIcDKau2IeHNJYDDiYjJzyJk8P1QrLJ+xla23CoKrXOTtRbrgA2ZLIqicGcnFLOTibnJxNzkqmzZZX57CHGjZyHn6N+o8nBPhI8dBku1ML3LKrHKlltF4Y3c2Ix5wFvby6Kqam5mzE0WZicTc5OJuclVWbKz/3sZ8RMXIG3zbvi2boJany2CX+umepdVapUlt4omb25aYTPmBm9tL5Pdbtf8aemkDWYnE3OTibnJVZGzU7NzkLRoIxLfWQlToB+qzR6FKgO6QzGZ9C6tzCpybhWZ1rmxGSMiIiIi3aXv/hbxY+fAduZfhAx9AGEvPw5zSBW9yyLSFJsxIiIiItKN7eQ5xL0ei4xdB+B/S2tErZwKn+uv1bssIq9gM0ZEREREXudMz0TirNVImr8OlurhiFw2GYH33MprqqhSYTPmBncGMjE3uZidTMxNJuYml/TsVFVF+tY9iJswH874JIQ9NxChzw6EKcBP79I0JT23ykrr3NiMecANRxZFUXhxrFDMTibmJhNzk0t6dtlH/0bcmNnIOvArAnvcgohJz8B6TU29y9Kc9NwqK2/kxmaMiIiIiDTlSEpFwrQlSFm+Fdb6tVFjwzsI+F87vcsi0h2bMQ/4nDFZVFWF3W6HxWJhbsIwO5mYm0zMTS5p2akOB1LXfIL4Ke9BzcpBxLinEPJEHyg+lesokbTc6Iq8uWmFzZgbfM6YTMxNLmYnE3OTibnJJSW7rB+PIm7UTGQfOoagfncj4vVhsERV1bss3UjJjfLTOjc2Y0RERERUbuwX45EweSFS1++Ez42NUOuT+fBr11zvsogMic0YEREREZWZarMjefEmJMxYDsXHimrvvIwqA3tCMZv1Lo3IsNiMEREREVGZZHz1A+LGzIbtxFkEP94b4aOGwhxaRe+yiAyPzZgbvMBSJt46Vi5mJxNzk4m5yWWk7Gz//Iv4cXOR/sk++HVsgcjFE+B7Q0O9yzIkI+VGxcdb2+uMDZkszEsuZicTc5OJuclllOycGVlIiv0ASXPXwBQWgurvjUdQ79sNU5/RcLnI5I3c2Ix5wFvby6KqKhwOB8xmM3MThtnJxNxkYm5y6Z2dqqpI/3gv4sfNhf1SAkKHD0DY84/AFBTg9Vok0Ts3Kp28uWmFzZgbvAWpTE6nU9ONhrTD7GRibjIxN7n0yi7n2CnEjZmNzH0/IeDOTqi5eRas9Wt7vQ6puM3JpHVubMaIiIiIqEiOlDQkTl+G5CVbYK1bA1FrpiPwjo56l0VUIbAZIyIiIqICVKcTqet2IOGNRXCmZyF89FCEPtUPiq+P3qURVRhsxoiIiIgon6xf/kDc6FnI/ul3BD3QDREThsNSo5reZRFVOGzG3OAFljLxfGy5mJ1MzE0m5iaXltnZLyciYcoipK75FD5NG6Dmtrnw79hCs8+rTLjNyaR1bmzGPGBDJouiKNzZCcXsZGJuMjE3ubTKTrXbkbz0QyROXwaYFFSdNgLBj90LxcKfiuWB25xM3siNW5gHvLW9LKqq5mbG3GRhdjIxN5mYm1xaZJf5zc+4PHoWbMdOI/ix+xA+eijMEaHlMjZdwW1Opry5aYXNmBu8tb1MdrudT7kXitnJxNxkYm5ylVd2tnMXET9+HtK3fQm/ts0QuXsxfFs0LocKqTDc5mTSOjc2Y0RERESViDMrG8nz1iFx9mqYgoNQff5YBPW5k0dsiHTAZoyIiIioElBVFRk7v0Hc67GwX7iM0GF9EfbiIJiCAvQujajSYjNGREREVMHl/P0P4sbMRuaX38P/f+1QY93b8GlYV++yiCo9NmNu8HC9TMxNLmYnE3OTibnJVZLsnGkZSHxnBZIWbYSlZjVErX4TAXd1Zv464DKXSevc2Ix5wA1HFkVReHGsUMxOJuYmE3OTq7jZqaqKtE27ED9xAZwpaQh/cRBCYgbA5OfrhSrpatzmZPJGbmzGiIiIiCqQ7EPHEDd6FrJ+OILA+/6HiIkxsNaO1LssIioEmzEP+JwxWVRVhd1uh8ViYW7CMDuZmJtMzE0ud9k5EpKRMHUxUlZtg7VxPdTYMgsBt7TRqVLKi9ucTHlz0wqbMTf4nDGZmJtczE4m5iYTc5Pr6uxUux0pq7Yj4c3FgFNFxBvPIeTx3lCs/JlnJNzmZNI6N26lREREREJlfnsIcaNnIef3E6jycA+EvzYMlmphepdFRMXEZoyIiIhIGPu/l5EwcQHStnwO39ZNUOuzRfBr1UTvsoiohNiMEREREQmhZucgZf46pMz+AKZAP1SbPQpVBnSHYjLpXRoRlQKbMTd4gaVMWl5kSdpidjIxN5mYmzzpu79F/Ng5sJ35FyFDH0TYK4/DHBykd1lUTNzmZNI6N64VHrAhk0VRFGYmFLOTibnJxNxksZ08h7jXY5Gx6wD8u7RB1Kqp8Gl8rd5lUQlwm5PJG7kZqhk7c+YMli5dikOHDuH48eOoX78+Pv74Y7fzXLp0CStWrMD+/fvxzz//oEqVKmjbti1GjhyJWrVqlbkm3tpeFlVV4XQ6YTKZmJswzE4m5iYTc5PBmZ6JxJmrkLRgPSzVwxG5bDICenaBqqr8fSIMtzmZ8uamFUM1Y8ePH8fevXvRokULOJ3OYt1K8ujRo9i9ezcefPBBtGjRAomJiViwYAH69u2Ljz/+GOHh4aWuh7cglcnhcGi60ZB2mJ1MzE0m5mZcqqoibesXiB8/H86EZIQ9NxChzw6EKcAv97lHzE4ebnMyaZ2boZqxrl27olu3bgCAUaNG4ciRIx7nadOmDXbs2JHvfM7WrVvjtttuw9atWzF48GDN6iUiIiIqT9lH/0bcmNnIOvArAnt2QcTEGFivqal3WUSkEUM1Y6XpOoODgwu8FhUVhfDwcFy6dKk8yiIiIiLSlCMxBQlvLUXK8q2wNqiDGhvfRcBtbfUui4g0ZqhmrLycOnUK8fHxaNCggd6lEBERERVJdTiQ+sEniJ/yHtQcGyLGP42QoQ9C8bHqXRoReUGFa8ZUVcUbb7yB6tWro2fPnmUaS1GUQq8bK+p11zRXHSUZszzm5bjupzMb/cd1N6+7+SV+18qyj3A33Yj1VqZsPOVmMpkMV29Z5pU4btYPRxA3ZjZyDh1DUP+7ET72SVijqrkd193YRv6ulX1cwJjbnLRxvV2TqqpucysPFa4Zi42NxXfffYclS5YgICCgzOPZ7fZ8/zaZTLnXp9lstgLv9/HxAXDlYj+n05lvmsVigaIocDqdcDgchY6rqmqh41qt1iLHNZvNMJvNuRf15qUoSu68dru9wMqk1bjF+a5AwWVYHuNaLJYil6GiKCX+rp4y12MZusYtrCatsnF916KWoWtcd8vQ3frtun3s1fOWx/rtbhl6c/0GKuY+wmw2i9pHFDau67tWpn2Ea18pZR8BaLd+e3sfgfhkxE9agLQNn8F6YyNU/2gOfG+6AXlHKWoZmkwmmEwmwy3DivQ7orBxXd+1LPsIi8WCnJycQscFjLePKM24FXEfYbFY4HA4oKra3MG0QjVjGzZswLx58zBlyhR07NixXMZ0rRiFcYVXmLwr+dVcO9LC5F0pSjqup3ndPbROq3HdfVfA/TIszbiqeuV2v4Xl5vp3Wb6rHtl4exm6G7esy9DdNNdfn4q67a9Wy1CvbCrKPsL1Hy53+8rKsn4XNa6LkfYRrtzMZnORuRltH1GWcQFj7CPUHBuSF25A4jsrofhaUfWdl1Hl4R5QCvlO7rY5RVGK3OaMto8o67gVZR9RnH0ll+H/vcco+whXbq4/GGuhwjRju3fvxoQJE/Dcc8+hT58+5TKma4dX1M7OHXfTtZqX4yL3rx6uv7wYoSaOW7zpnrKT9l0ryz5Cy21O0nIwak3ucrPZbIbbV5ZlXqOPm/Hl94gbMxu2k+cQ/HhvhI8aCnNolRKPy21O5rhG3eakjatHTa7ctFIhmrGDBw9i5MiR6Nu3L2JiYvQuh4iIiAgAYDtzAfHj5iL906/h16klIpdMhO8NDfUui4gMwlDNWGZmJvbu3QsAOH/+PNLS0rBz504AQLt27RAeHo7o6GhcuHABu3fvBgCcOHECMTExqFevHnr16oVff/01d7zw8HDUrVvX69+DiIiIKjdnRhaS5ryPpLlrYYoIReR7ExDYu6tmpzoRkUyGasbi4+Px/PPP53vN9e9Vq1ahffv2BS4WPHToEFJTU5GamoqHHnoo37z3338/pk2bpn3hRERERLhyOlr69q8QP34e7JcSEDp8AMJeeBSmQH+9SyMiA1JULe/VKNjhw4cBAM2aNeNfsQRxnUvv7gJZMiZmJxNzk4m5aSPnz1OIe202Mvf9hIA7O6Hq5GdhrV+7XD+D2cnE3GTKm9uRI0cAAM2bNy/XzzDUkTEj4gYji6c75ZBxMTuZmJtMzK18OVLSkDh9GZKXbIH1mhqIWjMdgXeUz12dr8bsZGJuMnkjNzZjRERERMWQkJCA7777Dh06dEB4eDhUpxOp63Yg4Y1FcKZnIXzMEwgd1heKr4/epRKREGzGPNDqAW+kDZ4GIBezk4m5ycTcSic5ORm///47mjRpgoDT/yFu9Cxk//wHgh68AxHjn4alRjXNa2B2MjE3mfLmphU2Y27wcjqZmJtczE4m5iYTcyu59MwcmFMykTPhPZz/9Bv43NAQNbfNhX/HFl6tg9nJxNxk0jo3NmNERERERUhISEBycjLSUzPw29TVuOvrg3CYzHC+MBBK/zuQGR4G3ieRiEqLzRgRERFREb777jtc2rEXN+4+jHbxqfjrhlr4uf11sFhSYNn6IZo2bYoePXroXSYRCcVmjIiIiKgQtnMX0WzNXtg+OwBH84bYdu9dSAhIAYIbYED3Ngj090FISIjeZRKRYGzG3OAFljJpeZElaYvZycTcZGJuRXNmZSNp3lokzX4fpuAgVJ8/FkF97sSdf/yFj7d/hHu6t0Gzpo11q4/ZycTcZNI6N64VHrAhk0VRFGYmFLOTibnJxNwKp6oqMnZ+g7jXY2G/cBmhT/VD2MhomIICAACB/j6wmE0I9Nfv1vXMTibmJpM3cmMz5gFvbS+LqqpwOp0wmUzMTRhmJxNzk4m5FZTz9z+IGzMbmV9+D/+u7VFj3dvwaVg333tCQkLQtGlTXU9NZHYyMTeZ8uamFTZjbvAWpDI5HA5NNxrSDrOTibnJxNyucKamI+GdFUhetBGW2pGIWv0mAu7qXOgP5vDwcEPcrIPZycTcZNI6NzZjREREVOmoqoq0jZ8hfuICOFPTEf7yYIQM7w+Tn6/epRFRJcJmjIiIiCqV7EPHEDd6FrJ+OILAXl1RdeJwWGpF6l0WEVVCbMaIiIioUnDEJyFh6mKkrN4On+uvRc0PZ8P/5tZ6l0VElRibMTd4gaVMPB9bLmYnE3OTqTLlptrtSFm5DQnTlgBOFRFvPIeQwb2hCL3VeGXKriJhbjJpnZvMvZAXsSGTRVEUPsdDKGYnE3OTqTLllnngV8SNmYWc30+iysM9EP7aMFiqheldVqlVpuwqEuYmkzdy41rhAW9tL0veO2AyN1mYnUzMTabKkJv9wiXET1yAtC2fw7dNU9T6bBH8WjXRu6wyqwzZVUTMTSZv3FmdzZgbvLW9TDabDVarVe8yqBSYnUzMTaaKmpuanYOkBeuROHM1TIF+qDZnNKr0vxtKBTpFrKJmV9ExN5m0zo3NGBEREVUI6bsOIH5sLGxn/0XI0AcR9vLjMAcH6V0WEVGR2IwRERGRaLaT5xA3dg4ydn8L/y5tELV6KnwaX6t3WUREHrEZIyIiIpGcaRlInLUaSQvWwxIZgcjlbyCwZxdek0NEYrAZIyIiIlFUVUXah18gfsJ8OBOTEfb8Iwh95mGYAvz0Lo2IqETYjLmhKAr/uiaMoiiwWq3MTSBmJxNzk0lybtlH/0bc6FnI+vYQAnveiohJMbDWraF3WV4jObvKjLnJ5I3c2IxRhcMdnVzMTibmJpO03ByJKUiYthQpK7bC2qAOamx8FwG3tdW7LF1Iy46uYG4yaZ0bmzEP+JwxWVRVhcPhgNlsZm7CMDuZmJtMknJTHQ6kfvAJ4qe8BzXHhogJTyNkaB8o1sr5E0ZSdvR/mJtMeXPTSuXckxUTnzMmk9Pp1HSjIe0wO5mYm0wScsv6/jAuj56FnN/+QpX+dyP89adgiYzQuyzdSciOCmJuMmmdG5sxIiIiMhT7f3GIn7wQaRs+g2+Lxqj16QL4tW2md1lEROWOzRgREREZgppjQ/LiTUh4ewUUXyuqvfsKqjzcAwqPJhBRBcVmjIiIiHSXsecg4l6bA9vJcwgZfD/CXh0Cc2gVvcsiItIUmzE3eIGlTDwfWy5mJxNzk8koudlOX0DcuFhk7PgGfp1aInLpJPg2baB3WYZmlOyoZJibTFrnxmbMAzZksiiKwp2dUMxOJuYmkxFyc2ZkIWnO+0iauxamiFBEvjcBgb278r+7HhghOyo55iaTN3JjM+YBb20vi6qquZkxN1mYnUzMTSY9c1NVFenbv0L8+HmwX0pAaMxDCHv+EZgC/b1ah1Tc5mRibjLlzU0rbMbc4K3tZbLb7bBarXqXQaXA7GRibjLpkVvOn6cQN2YWMr/+GQF3dUbNLc/Cem0tr9ZQEXCbk4m5yaR1bmzGiIiISFOO5FQkTl+O5KVbYL2mBqLWzkBgtw56l0VEpDs2Y0RERKQJ1elE6todiH9jIdSMbISPeQKhw/pC8fXRuzQiIkNgM0ZERETlLuvn3xE3ehayf/4DQX3uQMT44bBEVdW7LCIiQ2Ez5gYvsJTJZDLpXQKVErOTibnJpFVu9ksJSJjyHlLXfAKfZteh5vZ58O9woyafVVlxm5OJucmkdW5sxjxgQyaLoiiwWLhaS8TsZGJuMmmRm2qzI3npFiROXwZYzKg6fSSCH7sPCm/nXa64zcnE3GTyRm5cK4iIiKhMMr7+CXFjZsP21xkER9+H8FFDYQ4P0bssIiLDYzPmhjeeLUDlS1VV2Gw2WK1W5iYMs5OJuclUXrnZzl1E/Li5SN/+FfzaNUfk7sXwvbFR+RVKBXCbk4m5yZQ3N62wGSMiIqIScWZmI2neGiTN+QCm4CBUX/A6gh68gz8yiYhKyFDN2JkzZ7B06VIcOnQIx48fR/369fHxxx97nE9VVSxevBhr1qxBQkICmjRpgtGjR6Nly5baF01ERFRJqKqKjB1fI+71ubD/exmhT/VD2MhomIIC9C6NiEgkQ93W5fjx49i7dy+uueYaNGjQoNjzLV68GHPmzMGgQYOwaNEiVKtWDYMHD8bZs2c1rJaIiKjyyDl+Bv/2exH/Rb8Ga8O6qLNvJSLGPc1GjIioDAzVjHXt2hV79+7FnDlzcMMNNxRrnuzsbCxatAiDBw/GoEGD0LFjR7z77rsIDQ3F0qVLNa6YiIioYnOmpiNu/Dyc7RIN2+nziHp/GmqsmwGfhnX1Lo2ISLxSnab4559/4qeffsKJEyeQmJgIRVEQFhaG+vXro3Xr1mjSpEmpiinNffx//vlnpKWloXv37rmv+fj44I477sDu3btLVYcLz32XScuLLElbzE4m5iaTp9xUpxNpG3chftICONMyEP7yYIQM7w+Tn6+XKqSicJuTibnJpHVuxW7G4uPjsWbNGmzduhUXLlyAqqqwWq0ICQmBqqpISUmBzWaDoiioUaMG7r//fjz00EOoWrWqlvXj5MmTAID69evne71BgwZYuXIlsrKy4OfnV+rx2ZDJwrzkYnYyMTeZPOWWfegYLo+ehewfjiCwV1dUnTgcllqRXqqO3OE2JxNzk8kbuRWrGZsxYwbWrFmDwMBA3H333ejUqRNuuOEGREbm3zFfvHgRR48exf79+7FhwwYsW7YMjzzyCF588UVNigeAlJQU+Pj4wNc3/1/qgoODoaoqkpOTy9SMOZ3OAkEoigJVVQt9v+u97qZrNS/HvcJut8NsNheaW1nqLcu8HNfzvID77KR918qyjwC02+YkLQej1uQuN4fDAZPJlC83R3wSEqYuRur7H8N6fT3U+HA2/Du3ylcDl6G+4wLc5iSOCxS+zelZk8RxvV2TqqpwOp2lOnuvuIrVjP3444+YMWMGbr/9drcdYmRkJCIjI9G1a1eMHTsWX3zxBZYsWVJuxXqb69kCeb+zyWTKfRK3zWYrMI+Pjw+AKxuc0+nMN81isUBRFDidTjgcjnzTXOO6PvNqrkOkhY1rNpthNpuhqirsdnu+aYqi5M5rt9sLrGhajVuc7woUXIZlHddsNsPpdBbaRLue7VHS7+opcz2WoWvcwmrSKhvXdy1qGbrGdbcMPa3fdru9QHblsX67W4beXL+BirePMJlMudPy5mbUfURp1++Kto+wWCy5+0oAUO0OpK3ejuQZy6EAqDrlOQQ+di+cipJvfr33EVqt39L2EYVtc3ovw4ryO0KrfYTr94nD4Sj09wlgrH2E1N8RWizD3P2kqs2zh4vVjK1fv77EAyuKgm7duqFbt24lnrckgoODkZOTg+zs7HxHx1JSUqAoCkJCQso0vruH87k7hzTvSn41k8lUZIedd6Uo6bie5nVtHN4c1913Bdwvw7KOW9RfDMvyXfXIRs9leLWyLkNPy8FkMhW5zWm1DPXKpiLuI4raV1aW9buocV2Muo/I+u4Q4kfPRs4fJ1FlYE+Ej3kSlmphUFUVhVdb9Lha7yP0WIZG3Ee42+aMvI8ozbgVcR9R1L6Sy/D/3mOUfYSrOSvqiGZ5MNRzxkrDda3YqVOncP311+e+fvLkSdSsWbNMpygCV4Iramfnab7STCvLvBz3//5qUVRuetTEcYs33VN20r5rZdlHaLnNSVoORq3JXW72C5eRMHUx0j/8Ar5tmqLWZ4vg16qJx3m1rLcs81aWcbnNyRw372m+/H1S8WoqC/HNWOvWrREUFIQdO3bkNmM2mw27du1Cly5ddK6OiIjIWNTsHCQuWI+kd1fBFOiPanNGo0r/u6FoeE0EEREVrkTN2N9//4333nsPJ06cQFhYGHr27InevXsX6Ba3bduGV199FX/88UeJisnMzMTevXsBAOfPn0daWhp27twJAGjXrh3Cw8MRHR2NCxcu5N623tfXF8OGDUNsbCzCw8PRqFEjrF27FklJSRgyZEiJPv9qWnbBpJ2iDk+T8TE7mZibHOm79iPutVjYz/2H4CEPIvzlQTCHVNG7LCohbnMyMTeZtM6t2M3Y6dOn0bdvXzgcDjRs2BDHjx/H6NGjsXHjRsyePRvVqlUrczHx8fF4/vnn873m+veqVavQvn37Qi8WfOKJJ6CqKpYtW4aEhAQ0adIES5cuRZ06dcpcExsyWRRF4c5OKGYnE3OTIefEWcSPnYOMz7+D/603ocYH0+DTqJ7eZVEpcJuTibnJ5I3cit2MzZo1C4GBgfjggw9wzTXXAAA++ugjTJ48Gf3798eSJUsKPOurpGrXro1jx465fc/q1asLvKYoCoYNG4Zhw4aV6fMLo9WdU0gbqqrmO5+e5GB2MjE3Y3OmZSBx5iokLdwAS2QEIpe/gcCeV07hd92Nj7nJwm1OJuYmU97ctFLsE8QPHTqERx55JLcRA4BevXph/fr1MJlMePjhh/Hbb79pUqRe3D0rgozr6tuWkhzMTibmZjyqqiJ1y+f4p9MjSH5vI8JeeBR19r+PoHtuzf1RwdzkYnYyMTeZtM6t2M1YUlISqlatWuD1Bg0aYN26dYiKikJ0dDS+/vrrci2QiIiIii/7yN+4cN+zuDRsIvxaN0Wd/e8j/OXHYfL39TwzERF5VbFPU6xVq1aRpxBWrVoV77//PoYNG4ann36adzEkIiLyMkdiChLeXIKUlR/B2rAOamyaiYBbb9K7LCIicqPYR8batWuHnTt3FnmoLigoCMuXL8ctt9yCPXv2lFuBREREVDTV4UDyyo/wT4eHkbZpFyImDkedr1awESMiEqDYR8buv/9+xMXF4ciRI2jZsmWh7/Hx8cG8efPw5ptv4s8//yyvGnXDCyxlYm5yMTuZmJt+Mg/+hrjRs5Bz+DiqDOiO8LHDYImMKNa8zE0uZicTc5NJ69wUlXepKNThw4cBAM2bN9e5EiIiovzs/8UhftICpG3cBd+W16Pqmy/A76Yb9C6LiKjC0qo3KNFDn4mIiEg/ao4NSe9tROLbK6D4+aDau6+gysCeUEzFvuqAiIgMpNTNWGZmJvz9/cuzFkPic8ZkUVUVdrsdFouFuQnD7GRibt6Tsecg4l6bA9up8wh5vDfCXh0Cc2iVUo3F3ORidjIxN5ny5qaVUv0pLS4uDgMHDizvWgyHZ3DKxNzkYnYyMTdt2U5fwL+Pjca//V+COTICtfcsRdU3Xyh1I+bC3ORidjIxN5m0zq3Ebd6pU6cwdOjQQp85RkREROXDmZGFpNnvI2neWpgiQhG5eCICe/2Pf1UnIqpAStSM/fTTTxg+fDiuueYaLF26VKuaiIiIKi1VVZG+7SvEj58L++VEhMY8hLDnH4EpsOJfGkBEVNkU+zTFnTt34vHHH0edOnWwdOlSBAUFaVkXERFRhZeQkIBPP/0UCQkJAICcP0/hwgMv4OLQcfBpdh3qfrMaEWOeYCNGRFRBFfvI2IgRI9C0aVMsX74cVaqU7Tx1KXgqiExaXmRJ2mJ2MjG30ktOTsbvv/+O62vXhfOd95G8dAus9Woiau0MBHbroOlnMze5mJ1MzE0mrXMr9uh+fn6Ii4tDUlJSpWnGADZk0iiKwsyEYnYyMbeySU/PQu1fT8O56BWk2OwIf+0JhA7rB8XHqunnMje5mJ1MzE0mb+RW7NMUP/jgAzgcDjz22GM4d+6cljUZCu98I4uqqnA4HMxNIGYnE3MruYSEBJw6dQpHN+1A2sNj0fazQzhRqwYyVk1G0j2dkJiWqnkNzE0uZicTc5PJG7kVuxlr2rQp1q9fD39/fzz66KM4f/68ZkUZBTcYmRwOh94lUCkxO5mYW8n88NkXODVkLPyengqTLRM7H7gJ39xaDx9/uxebN2/Gd99955U6mJtczE4m5iaT1rmV6CTIWrVqYd26dXj66afx6KOPYs+ePVrVRUREVKGoNjuSl25Gw7eWASYFOSMfwXZLINS0U0BwA9zTvQ0C/X0QEhKid6lEROQlJb4iLTg4GMuXL8err76qRT1EREQVTsa+HxE3ZjZsx/9BcPR9CB81FObwEPT//Rg+3n4B93Rvg2ZNG+tdJhEReVmpbg/i4+ODmTNnlnctREREFYrt7H+IHzcX6R/vhV/7GxH5+RL4Nr8ud3qgvw8sZhMC/X10rJKIiPTCe2y6wbveyGQ2m/UugUqJ2cnE3ApyZmYjad4aJM35AKaQKqi+cByCHuhW4L8rISEhaNq0qS6nJjI3uZidTMxNJq1zK9dm7OzZs8jJyUGDBg3Kc1hdsSGTRVEU7uyEYnYyMbf8VFVF+qdfI37cXNj/vYzQp/ojbORjMAUFFPr+8PBw9OjRw8tVMjfJmJ1MzE0mb+RWqmZs1apV+OWXX/Kdqjh69Ghs3boVANCkSRMsXrwYERER5VKknlRVZUMmSN47YDI3WZidTMzt/+QcP4O4MbOR+dUPCLi9A2pseBs+DerqXVahmJtczE4m5iaTN+6sXuxb2+e1cePGfI3W119/jQ8//BD9+vXD2LFjce7cOcydO7fcitQLb20vk81m07sEKiVmJ1Nlz82Zmo648fNwtks0bKfPI+r9aYhaO92wjZhLZc9NMmYnE3OTSevcSnVk7MKFC/lORdyxYwdq166NiRMnAgDi4uLw0UcflU+FREREBqQ6nUjbuAvxkxbAmZaB8FcGI+Tp/jD5+epdGhERCVGqZuzqI0b79+/H7bffnvvvWrVqIS4urmyVERERGVT2oWO4PHoWsn84gqDeXRExYTgstSL1LouIiIQp1WmK9erVw+effw7gyimKly5dQpcuXXKn//fffwgODi6fComIiAzCEZeISyOn49wdT0BNz0DNrXMQuXgiGzEiIiqVUh0ZGzJkCF588UW0bdsWmZmZaNCgAW6++ebc6QcPHsT1119fbkXqhRdYysTc5GJ2MlWG3FS7HSkrPkLCtCUAgKpTnkPw472hWOQ+IaYy5FZRMTuZmJtMWudWqv+K9OzZE6Ghodi7dy+Cg4Px8MMPw/L//4OUlJSEkJAQ9OrVq1wL1Qs3HFkURYHVatW7DCoFZidTZcgtc/8viBszCzl/nEKVR+5BxJgnYK4apndZZVIZcquomJ1MzE0mb+SmqLxlYKEOHz4MAGjevLnOlRARkR7sFy4hfvw8pG3dA9+bbkDVN1+AX0v5Z30QEVHJadUbyD2/wkv4nDFZVFWF3W6HxWJhbsIwO5kqYm7OrGwkL1iPxFmrYQoMQLXYMajS7y4oplJdZm1IFTG3yoLZycTcZMqbm1aK9V+WHj16YOvWrcjJySn2wDk5Odi8eTN69OhR6uL0xoOGMjE3uZidTBUpt/Rd+3H2lmgkTF+G4EG9Uee7DxA8oHuFasRcKlJulQ2zk4m5yaR1bsVq8+6//368+eabmDJlCrp27YqOHTvihhtuQO3ateHv7w8AyMjIwLlz53DkyBEcOHAAX375JaxWK4YMGaLpFyAiIiqrnBNnET92DjI+/w7+t7VFjQ+mwadRPb3LIiKiCq5YzdgTTzyBhx56CJs2bcKHH36Ijz76KPcQq9lsBgA4HA4AV7rH6667Ds8++yz69OmDoKAgjUonIiIqG2daBhLfXYWkhethqVENkSumILDHLTyNiIiIvKLYJ0AGBQVh0KBBGDRoEM6dO4dffvkFJ0+eRFJSEgAgNDQU9evXR8uWLVGnTh2t6iUiIiozVVWRtuVzxE+YD2dSCsJGPIbQZx6Gyd9X79KIiKgSKdXVaLVr10bt2rXLuxbD4V9GZdLyIkvSFrOTSVpu2Uf+RtzoWcj67hAC77kVERNjYK1bQ++yvE5abvR/mJ1MzE0mrXPjWuEBGzJZFEVhZkIxO5kk5eZITEHCm4uRsnIbrA3roMammQi49Sa9y9KFpNwoP2YnE3OTyRu5sRnzgLe2l0VVVTidTphMJuYmDLOTSUJuqsOBlNXbkTB1MWB3IGLicIQMeRCKtfL+J1BCblQ4ZicTc5Mpb25aqbz/JSoG3oJUJofDoelGQ9phdjIZObfMg78hbvQs5Bw+jioDuiP89adgqR6ud1mGYOTcyD1mJxNzk0nr3NiMERFRhWP/Lw7xkxYgbeMu+LZqglo7F8KvzQ16l0VERJQPmzEiIqow1BwbkhZtQOI7K6H4+6LazFdR5eEeFfKhzUREJB+bMSIiqhAyvjiIuNdmw3b6AkIG34+wVwfDHFJF77KIiIiKpMmfCrOysnDhwoVSzXvixAk8/vjjaNmyJTp37ozp06cjJyfH43yJiYkYN24cbrvtNrRs2RL33HMP1q5dW6oaXHiBpUw8H1suZieT3rnZTl/Av4+Oxr8DXoI5qipq71mKqlOfZyPmgd65UekxO5mYm0xa51aiI2Pffvst5s6dixMnTiAsLAw9e/bEkCFD4O/vn+99u3btwquvvoo//vijRMUkJycjOjoa9erVQ2xsLC5evIhp06YhKysL48aNczvv888/j5MnT2LkyJGoUaMG9u3bhwkTJsBsNqNfv34lqiMvNmSyKIrC53gIxexk0jM3Z3omkuZ8gKR5a2GKCEXk4okI7PU/7reLgdubXMxOJuYmkzdyK/boR44cwdChQxESEoJ27drh8uXLmDdvHrZv34758+ejQYMGZS5m3bp1SE9Px9y5cxEaGgrgyh1MJk6ciGHDhiEyMrLQ+S5fvoyDBw/izTffxAMPPAAA6NixIw4fPoxPPvmkTM0Yb20vS947YDI3WZidTHrkpqoq0j/6EvET5sERl4TQmIcQ+txAmAL9Pc9MALi9ScbsZGJuMnnjzurFPu4WGxuL2rVr49NPP8WcOXOwdu1arF69GllZWXjooYfw448/lrmYffv2oWPHjrmNGAB0794dTqcT+/fvL3I+u90OAKhSJf8pKUFBQWVaiLy1vUw2m03vEqiUmJ1M3swt+4+TuPDAC7j4xHj4NG+EOt+sRvjooWzESoHbm1zMTibmJpPWuRX7yNjRo0cxePDgfI3STTfdhA8//BBPPvkkhgwZgnfeeQfdunUrdTEnT57Egw8+mO+14OBgVKtWDSdPnixyvho1auDmm2/GwoULce211yIqKgr79u3D/v378fbbb5e6HqDwhkxRlCIbNddfO9xN12pejovc+YrKrSz1lmVejut5Xtc0b29z0sY1Wk2u+bTY5vJOcySnInH6MqQs2wprvZqose5t+HdtV+j4zMbzNBej1WvEmow2rmua1tscxy3fcV2MVJPEcb1dk+s1LQ/QFLsZy8jIKHDkCQDCw8OxevVqPPPMM3jhhRcwfvx4+Pr6lqqYlJQUBAcHF3g9JCQEycnJbueNjY3FiBEj0LNnTwCA2WzG2LFjcdddd5WqFhebzZbvcLLJZMo9d7SwTtnHxwfAldMrnU5nvmkWiwWKosDpdMLhcOSb5hpXVdVCx7VarUWOazabYTaboapq7lFCF0VRcue12+0FViatxi3OdwUKLsOyjms2m3PHvfo0AKvVCkVRSvxdPWWuxzJ0jVtYTVpl4/quRS1D17julqGn9dvpdBbIrjzWb3fL0JvrN1Dx9hEmkym3pry5ldcyzMnORvq6HUh+cynU7ByEjh6C8KcHQPGxwmazeW39rmj7CFe9V3+mp3H13kdotX5L20cUts3pvQwryu8IrfYRnn6fAMbaR0j9HaHFMgSu7CNUVZtLl4rdjNWtWxe//fYb+vbtW2Cav78/Fi5ciFdeeQXjxo1Dy5Yty7NGj1RVxejRo3H69Gm88847qFatGg4cOICpU6ciJCQkt0ErDddKU9S0ouRdya9mMpmKvDNL3pWipON6mtfdBYhajevuuwLul2FZx706N9e/y/Jd9chGz2V4tbIuQ0/LwWQyFbnNabUM9cqmIu4jitpXlnYZZv30O+JHz0L2r38iqM+dCB/3FCxRVXM/x2jrd1Hjuhh1H1FUbkbcR+ixDI24j3C3zRl5H1GacSvSfwNd4xa1zXEZ/t97jLKPcDVnJpNJk0YMKEEz1qlTJ2zevBljxowpcPdE4MoCf/fddxEaGoq1a9eWquDg4GCkpqYWeD05ORkhISFFzvfVV19h586d2LZtGxo3bgwAaN++PeLj4zFt2rQyNWOKohS5s/M0X2mmlWVejvt/N1wpKjc9auK4xZvuKTtp37Wy7CO02ObslxKQMHkhUtftgE+z61Dz43nwb39judTraZpe83p7XNcPDKPtK8syb2UZV8v/zhntu1akcY26zUkb16g1lUWxm7E+ffpAVVWcOnUKTZs2LfQ9iqJg/PjxuOaaa3Ds2LESF1O/fv0C14alpqbi8uXLqF+/fpHz/f333zCbzWjUqFG+15s0aYKNGzciMzOz0AbSE3cbDBmT668ezE0eZidTeeam2uxIXroZidOXAxYzqr79EoIfuQdKEX/lpNLj9iYXs5OJucnkjdyK3YzVr18fr776arHeO2jQoFIV06VLFyxcuDDftWM7d+6EyWRC586di5yvVq1acDgcOHbsGK6//vrc148ePYqIiIhSNWIkF3d0cjE7mcojt4y9PyJuzCzY/j6L4OheCB89FOawgtcQU/nh9iYXs5OJucmkdW6GehT4gAEDEBgYiJiYGHzzzTfYvHkzpk+fjgEDBuR7xlh0dDTuuOOO3H936dIFNWvWxHPPPYePPvoI3377LWbMmIEPP/wQjzzySJlq0vLuKVT+XBdnMjd5mJ1MZc3N9s+/+G/QWPzbZwTMYSGo/fkSVJs+ko2Yxri9ycXsZGJuMnkjt1I/UjouLg5Vq1Ytz1oQEhKClStXYvLkyYiJiUFgYCD69OmDESNG5Hvf1XdvCQoKwooVKzBz5ky8/fbbSE1NRe3atTFq1KgyNWPcYGRyOp1FXrxJxsbsZCpNbs7MbCTNXYOkOe/DFBqM6gvHIeiBbvzLsRdxe5OL2cnE3GTSOjdFLUXHceLECTzxxBPYs2ePFjUZwuHDh6GqKpo3b84fB4K4bnnK87LlYXYylTQ3VVWR/unXiB83F/Z/LyP0qf4IG/kYTEEBXqiWXLi9ycXsZGJuMuXN7ciRIwCA5s2bl+tnlPjI2I8//oiYmBi0adOmXAshIqKKLeev04gbMxuZe39EQLcOqLHhHfg0qKN3WURERLopUTO2Y8cOjBo1Ch07dsScOXO0qomIiCoQZ2o6EmYsR/LiTbDUjkLUB9MQeGfRN2UiIiKqLIrdjC1btgwzZszArbfeirlz57p9CFxFwcPIMlWGdbOiYnYyFZWb6nQidcNnSJi0EM70DIS/MhghT/eHyc/XyxVSYbi9ycXsZGJuMmmdW7FHnz59Otq2bYvY2NhKtTKxIZOFz4aTi9nJVFRu2YeO4fKomcj+8SiCendFxIThsNSKLGQE0gO3N7mYnUzMTSZv5Fbsrqpq1ar4888/8ccff+DGG2/UsiZDcT3pnmRQVTU3M+YmC7OT6ercHHGJiJ+6GKnvfwyfJtei5tY58O/cSu8y6Src3uRidjIxN5ny5qaVYj9nbMOGDahevTqGDBmSezeRio63tpfJbrfrXQKVErOTyW63Q7Xbkbx4E/7p8DDSt32JqlOfR+0vlrIRMzBub3IxO5mYm0xa51bsZqxmzZpYu3YtGjdujMGDB+Po0aNa1kVEREJkHfgV528firjX5iCoV1fU/W4NQoY+CKUSndJORERUGsVuxgAgODgYy5YtQ+fOnTF48GCtaiIiIgHs5y/i4hPjcbnvi1AC/VF792JUe+dlmKuG6V0aERGRCCX+s6WPjw9mzpyJ6dOna1EPEREZnDMrG8nz1yNx9mqYAgMQPutVhAzoDpPZrHdpREREopT6HJJXXnmlPOswJF5gKZPJVKIDvmQgzM7YVFVFxq4DiBs7B/ZzFxHyZF+EvRgNNcAPCrMTh9ubXMxOJuYmk9a5FbsZ++GHH9CgQQOEh4drWY/hsCGTRVGUSvXohYqE2Rlbzol/EP9aLDK++A7+t7VFjQ/egk+jenqXRaXE7U0uZicTc5PJG7kVu9V77LHHsH//fi1rISoXvAumXMzOeJxpGYiftABnb4lGzvEziFo5BTU2vJOvEWNuMjE3uZidTMxNJq1zK3arVxlXIG88W4DKl6qqsNlssFqtzE0YZmcsqqoibfNuxE9cAGdSCsJGPobQmIdh8vct8D7mJg9zk4vZycTcZMqbm1Z4vJSIiPLJPnwccaNnIevgbwi851ZETHoG1jpRepdFRERU4ZSoGWMnT0RUcTkSkpEwbQlSVm6DtWEd1Ng8EwFdbtK7LCIiogqrRM3Yyy+/jJdffrlY71UUBb///nupiiIiIu9RHQ6krN6OhKmLAbsDERNjEDLkAShWnjxBRESkpRL9l7ZTp06oV6+eRqUQEZG3ZX73G+JGz0LOkeOo8lAPhI8dBkv1ynXXXCIiIr2UqBnr3bs37r33Xq1qMRyelimTlhdZkraYnffY/4tD/MT5SNu0G76tmqDWzoXwa3NDqcZibjIxN7mYnUzMTSatc+M5KB6wIZOFecnF7LxDzbEhadEGJL6zEoq/L6rNfBVVHu5R6oc2MzeZmJtczE4m5iaTN3JjM+YBb20vi6qqcDgcMJvNzE0YZqe99M+/Q/zYObCdvoCQwfcj7NXBMIdUKdOYzE0m5iYXs5OJucmUNzetsBlzozI+W60icDqdmm40pB1mpw3bqfOIez0WGZ/th9/NrRG5/A34NqlfbuMzN5mYm1zMTibmJpPWuRW7Gfvzzz81K4KIiMqfMz0TibPfR/L8dTBXDUXkkkkIvO82/lWWiIjIIHhkjIioglFVFelb9yBuwnw445MQ+sxDCH12IEyB/nqXRkRERHmwGSMiEi4hIQHfffcdOnTogMD/EhE3Zjay9v+CgO43o+qkZ2GtV1PvEomIiKgQbMbc4Kk8MvF8bLmYXekkJyfj+M+/ovEnPyJx8x5Y69VEjXVvI+D29l75fOYmE3OTi9nJxNxk0jo3NmMesCGTRVEU7uyEYnalozocyNr4Oe547wuoUBAx9kmEPtkXio93nmfD3GRibnIxO5mYm0zeyI3NmAe8tb0sqqrmZsbcZGF2JZOQkICkb36CY/pK+Bw7g78b1cCPd9yBXl3bIOn8OYSEhCA8PFzzOpibTMxNLmYnE3OTKW9uWmEz5gZvbS+T3W7nU+6FYnbFY78Yj9NPvY6Qbw4juXowvr2/LeJrhsCh/oePt38Ei9mEpk2bokePHt6ph7mJxNzkYnYyMTeZtM6NzRgRkRCqzY7kJZuQOGMFQs0mYNQg+N3ZCRd3/QKknACCG+Ce7m0Q6O+DkJAQvcslIiIiD9iMEREJkLH3R8SNmQXb32cRHN0L4aOHwhwWDAAYYDbh4+3ncE/3NmjWtLHOlRIREVFxsRkjIjIw2z//In7cPKR/shd+HVog8osJ8G3WMN97Av19YDGbEOjvo1OVREREVBpsxtzgBZYyMTe5mN3/cWZmIyn2AyTFfgBTaDCqLxqPoPtvL3QZhYSEoGnTprqdmsjcZGJucjE7mZibTFrnxmbMA244siiKwotjhWJ2V6iqivRP9iF+3FzY/4tD6NP9ETbiMZiCAoqcJzw83Gs367gac5OJucnF7GRibjJ5Izc2Y0REBpHz12nEjZmNzL0/IqBbB9TY+C58GtTRuywiIiLSCJsxD/icMVlUVYXdbofFYmFuwlTm7BwpaUh8ewWSF2+CpXYUoj6YhsA7O+tdVrFU5twkY25yMTuZmJtMeXPTCpsxN/icMZmYm1yVLTvV6UTq+p1ImLwIzvQMhL86BKFP94fiK+tGHJUtt4qCucnF7GRibjJpnRubMSIiHWT9+ifiRs9C9o9HEXT/7YiYMByWmtX1LouIiIi8iM0YEZEXOeISEf/GIqSu+RQ+Ta5Fza1z4N+5ld5lERERkQ7YjBEReYFqtyN52VYkvrUUUICqb76A4Oj7oGh4HjoREREZG38FuMELLGXirWPlqqjZZe7/BXGjZyHnz1MIfvRehI95AuaIUL3LKjcVNbeKjrnJxexkYm4y8db2OmNDJgvzkqsiZmc/fxFx4+cj/aM98G3bDLV3L4Zvi8Z6l1WuKmJulQFzk4vZycTcZPJGbibNP6GETpw4gccffxwtW7ZE586dMX36dOTk5BRr3osXL+LVV19Fhw4dcOONN6J79+7Ytm1bmerhnW9kUVUVDoeDuQlUkbJzZmUj8d1V+KfTI8j69ldUn/caan08r8I1YkDFyq0yYW5yMTuZmJtM3sjNUEfGkpOTER0djXr16iE2NhYXL17EtGnTkJWVhXHjxrmd99KlS+jfvz+uvfZaTJ48GUFBQTh+/HixG7nCcIORyeFwwGQy3N8ZqBikZ6eqKjI+24+412NhP3cRIcP6IvzFQTBVCdS7NE1Jz62yYm5yMTuZmJtMWudmqGZs3bp1SE9Px9y5cxEaGgrgygKYOHEihg0bhsjIyCLnnTFjBqKiorBkyRKYzWYAQMeOHb1RNhERck78g7gxc5C55yD8b2uLGmumw+e6a/Qui4iIiAzMUO35vn370LFjx9xGDAC6d+8Op9OJ/fv3FzlfWloaduzYgYcffji3ESMi8gZnWgbiJy3A2VuiYfv7H0StnIIaG95hI0ZEREQeGerI2MmTJ/Hggw/mey04OBjVqlXDyZMni5zv6NGjsNlssFgseOSRR/DLL78gNDQUvXv3xgsvvFCmu6AUdqqioihFnsLoutDP3XSt5uW4yJ2vqNzKUm9Z5uW4nud1TfP2NleWelM37ULCxAVwJqcibMRjCIl5CCZ/30q1j3DNp8U2J2k5GLUmT6fbG61eI9ZktHFd07jNyRrXxUg1SRzX2zW5Xqs014ylpKQgODi4wOshISFITk4ucr64uDgAwNixY9GvXz8888wz+O233zBnzhyYTCa8+OKLpa7JZrPlu5OKyWSC5f8/F8hmsxV4v4+PD4Arp1c6nc580ywWCxRFgdPphMPhyDfNNa6qqoWO62ooCxvXbDbDbDZDVVXY7fZ80xRFyZ3XbrcXWJm0Grc43xUouAzLOq6r5qtzc31XRVFK/F09Za7HMnSNW1hNWmXj+q5FLUPXuO6Woaf12/W5ebMrj/Xb3TIszbiOP04iYcwcZH1/GP49uyB03FOw1I6EA4DqcFSqfYTJZILJZCqQm1H3EaVdvyvaPsJiscBsNhf4TE/j6r2P0Gr9Lu99RFmWYXH2EYqiFPn7xGj7CGm/I7TaR3j6fQIYax8h9XeEFsvQbDbD6XRCVdUC2ZUHQzVjpeVa6J06dcKoUaMAAB06dEB6ejqWLVuGmJgY+Pn5lXhcRVFyd4qFcXfELe9KfjXXj5eiPrO043qa17VxeHNcd98VcL8MSzOuoihFfhfXBlSW76pHNt5ehu7GLesy9DTN3fam1TIsybiOhGQkvLkEqau3w3pdXdTYNBP+XdoUOW9l2Ee4fti7U1nW76LGdTHSPsK1r3Q3n9H2EWUZF/DOPqIk4wKlW1881WO0fURZx60o+4jibHNchv/3HiPtI0wmk2aNGGCwZiw4OBipqakFXk9OTkZISIjb+YArDVheHTt2xMKFC3HmzBk0blz6W0oXtvA9BeJuulbzctz/O3XD9ZdDI9TEcYs33VN2en5X1eFAyqptSHhzCWB3IGJiDEKGPADFWvQutLLsI7Tc5iQtB6PWJG1fWZZ5K8u43OZkjmvUbU7auN6uSVVVOJ1OzRoxwGDNWP369QtcG5aamorLly+jfv36Rc7XsGFDt+NmZ2eXqh4tzw8l7djtdj7lXigjZpf57SHEjZ6FnKN/o8rDPRE+dhgs1cL0LstQjJgbecbc5GJ2MjE3mbTOzVB3U+zSpQsOHDiAlJSU3Nd27twJk8mEzp07FzlfrVq10KhRIxw4cCDf6wcOHICfn5/HZo2I6Gr2fy/j4lOTcOG+Z6D4WFHrs0WoPnsUGzEiIiIqN4ZqxgYMGIDAwEDExMTgm2++webNmzF9+nQMGDAg3zPGoqOjcccdd+Sbd8SIEdizZw+mTJmC/fv3Y+HChVi2bBkGDRqEgIAAb38VIhJKzc5B4pwP8E+HgcjY+wOqzRqFWjsXwq91U71LIyIiogrGUKcphoSEYOXKlZg8eTJiYmIQGBiIPn36YMSIEfneV9jdW7p27Yp3330X8+fPx9q1a1G9enU8++yzePLJJ735FYhIsPTPv0P8a7NhO/MvQoY+gLCXH4c5pIreZREREVEFpai8MKpQhw8fBgA0a9ZM04v2qHy5blvquj0qyaFndrZT5xE3dg4ydh2A/y2tUXXqC/C5/lqv1iAVtzmZmJtczE4m5iZT3tyOHDkCAGjevHm5foahjowZETcYWTzdtpSMS4/snOmZSJy1Gknz18FSLQyRSych8N7buN2XALc5mZibXMxOJuYmkzdyYzNGRJWOqqpI37oHcRPmwxmfhLBnH0boc4/AFFDy5xESERERlRabMQ+0fMgblT+eBiCXt7LL/v0E4sbMRtb+XxDQ/WZUnfQsrPVqavZ5FR23OZmYm1zMTibmJlPe3LTCZswNXk4nE3OTS8vsHEmpSJi2BCnLt8JavzZqrH8bAV3ba/Z5lQm3OZmYm1zMTibmJpPWubEZI6IKTXU4kLrmE8RPeQ9qVg4ixj2FkCf6QPHhuftERESkLzZjRFRhZf14FHGjZiL70DEE9bsLEa8/BUtUVb3LIiIiIgLAZoyIKiD7xXgkTF6I1PU74dP8OtT6ZD782pXvrWiJiIiIyorNmBu8wFImLS+yJG2VNTvVZkfy4k1ImLEcio8V1d55GVUG9oRiNpdThVQYbnMyMTe5mJ1MzE0mrXPjWuEBGzJZFEVhZkKVNbuMr35A3JjZsJ04i+BBvRE+agjMYcHlWCEVhtucTMxNLmYnE3OTyRu5sRnzgLe2l0VVVTidTphMJuYmTGmzs/3zL+LHzUX6J/vg17EFIt+bAN9mDTWslPLiNicTc5OL2cnE3GTKm5tW2Iy5wVuQyuRwODTdaEg7JcnOmZmNpNgPkBT7AUxhIaj+3ngE9b6d/5HTAbc5mZibXMxOJuYmk9a5sRkjIlFUVUX6x3sRP34e7BfjEfp0f4S98ChMQQF6l0ZERERUImzGiEiMnGOnEDdmNjL3/YSAOzqixsZ34dOgjt5lEREREZUKmzEiMjxHShoSZyxH8pLNsNapgagP3kLgnZ30LouIiIioTNiMucFrT2Ti+dhyXZ2d6nQidd0OJLyxCM70LISPGorQp/pB8fXRqUIqDLc5mZibXMxOJuYmk9a5sRnzgA2ZLIqi8DkeQl2dXdYvfyBu9Cxk//Q7gh7ohojxT8NSs7qOFVJhuM3JxNzkYnYyMTeZvJEb1woPeGt7WfLeAZO5yeLKznE5EQlT30Pqmk/h07Q+an4UC/9OLfUtjorEbU4m5iYXs5OJucnkjTursxlzg7e2l8lms8FqtepdBpWQarcjcclmpLy9EjApqPrmCwiOvg8K/5JoeNzmZGJucjE7mZibTFrnxl85RKS7zG9+xuXRs2A7dhpVHr0XEWOegDkiVO+yiIiIiDTFZoyIdGM7dxHx4+chfduX8G3bDJE75iOw9Q08hYOIiIgqBTZjROR1zqxsJM9bh8TZq2GqEojq815DYJ87Ybfb9S6NiIiIyGvYjBGR16iqioyd3yDu9VjYz19CyLC+CH9xEExVAnmNJhEREVU6bMbcUBSFp0sJoygKfHz4DCojyvn7H8SNmY3ML7+H/21tUWPtDPhcd03udGYnE3OTibnJxexkYm4yeSM3NmNEpClnWgYS31mBpEUbYalZDVGrpiLg7pv5hw4iIiKq9NiMecDnjMmiqiocDgfMZjNz05mqqkjbtAvxExfAmZKGsBejETr8IZj8fYt8P7OTh7nJxNzkYnYyMTeZ8uamFTZjbvAaFpmcTqemGw15lv3bX4gbPQtZ3x9G4H3/Q8SE4bDWifI4H7OTibnJxNzkYnYyMTeZtM6NzRgRlRtHQjIS3lyMlJXbYG1cDzW2zELALW30LouIiIjIkNiMEVGZqQ4HUlZuQ8KbiwGniojJzyJk8P1QrNzFEBERERWFv5SIqEwyvz2EuNGzkHP0b1R5uCfCxw6DpVqY3mURERERGR6bMTd4gaVMFgtXa2+w/3sZ8RPmI23L5/Bt3QS1PlsEv9ZNyzQms5OJucnE3ORidjIxN5m0zo1rhQdsyGThs+G0p2bnIGnhBiS+uwqmQD9Umz0KVQZ0h2IylWlcZicTc5OJucnF7GRibjJ5Izc2Yx7w1vayqKoKp9MJk8nE3DSQvvtbxI+dA9uZfxEy9AGEvfw4zCFVymVsZicTc5OJucnF7GRibjLlzU0rbMbc4K3tZXI4HJpuNJWR7eQ5xL0ei4xdB+B/S2tErZwKn+uvLffPYXYyMTeZmJtczE4m5iaT1rmxGSOiIjnTM5E4cxWSFqyHpXo4IpdNRuA9t/KvekRERETlgM0YERWgqirStn6B+PHz4UxIRthzAxH67ECYAvz0Lo2IiIiowmAzRkT5ZB/9G3FjZiPrwK8I7HELIiY9A+s1NfUui4iIiKjCYTPmBk/FkonnY5eOIykVCdOWIGX5Vljr10aNDe8g4H/tvFoDs5OJucnE3ORidjIxN5m0zo3NmAdsyGRRFIXP8Sgh1eFA6ppPED/lPahZOYgY9xRCnugDxcfq1TqYnUzMTSbmJhezk4m5yeSN3LhWUIXDxxEUX9YPRxA3ehayDx1DUL+7EfH6MFiiqupWD7OTibnJxNzkYnYyMTeZtM6NzZgbqqpywxFGVVXYbDZYrVbm5ob9YjziJy1E2oad8LmxEWp9Mh9+7ZrrWhOzk4m5ycTc5GJ2MjE3mfLmphXDnbx64sQJPP7442jZsiU6d+6M6dOnIycnp0RjrFixAo0bN8awYcM0qpJIJjXHhqT56/BPh4eR8fm3qPbOy6i96z3dGzEiIiKiyshQR8aSk5MRHR2NevXqITY2FhcvXsS0adOQlZWFcePGFWuMy5cvY968eYiIiNC4WiJZMr78HnGvzYHtxFkEP94b4aOGwhxaRe+yiIiIiCotQzVj69atQ3p6OubOnYvQ0FAAV556PXHiRAwbNgyRkZEex5gxYwa6du2KCxcuaFwtkQy2MxcQP24u0j/9Gn4dWyBy8QT43tBQ77KIiIiIKj1Dnaa4b98+dOzYMbcRA4Du3bvD6XRi//79Huf/8ccf8fnnn+PFF1/UsEoiGZwZWUh4aynO3vwosn75E9XfG4+aH8WyESMiIiIyCEMdGTt58iQefPDBfK8FBwejWrVqOHnypNt5HQ4HJk+ejKeeegrVq1cvl3p4gaVMWl5kKYGqqkjf/hXix8+D/VICQocPQNjzj8AUFKB3aR5V9uykYm4yMTe5mJ1MzE0mrXMzVDOWkpKC4ODgAq+HhIQgOTnZ7bxr1qxBZmYmBg0aVO51qaqa79+KohR4Le+0wubxxrwcN/+0wnIry7jlUZPW4+b8eQrxr81B5tc/IeDOTqixaSas9WsX+Ay96i3uvN7c5qSNa8SatNrmpC0HI9ZUnHELew+XoYxxK/s2J21c17xG2uakjWu0msqDoZqx0oqPj8ecOXPw1ltvwcfHp9zGVVUVOTk5+Y6QmUym3Ie/2Wy2AvO4Pt/hcMDpdOabZrFYoCgKnE4nHA5HvmmucV230LyaqysvbFyz2Qyz2QxVVWG32/NNUxQld1673V5gZdJq3OJ8V6DgMizruGazGXa7HU6ns8CRTdftZEv6XT1lrscydI3rqsmZkobkd1YhbfmHsNStgag10xF4R0fYbLYCNZc2G9d3LWoZusZ1twzdrd+qqiI7OxuKouTLrjzWb3fL0JvrN1Dx9hEmkwk2mw2qmv8xIEbdR5R2/Za+j7h6XIvFUmg9nsbVcx8BaLd+S9pHAMi9y3Rhv0+Mto+Q9jtCq32E2WyGw+GAw+Eo9PcJYKx9hB7L0Ij7CNe+EtDueWOGasaCg4ORmppa4PXk5GSEhIQUOd/s2bPRuHFj3HTTTUhJSQFwZYHa7XakpKQgICCg1E/Pdvc8CHeHLfOu5FczmUwwmQq/XC/vSlHScT3N624ZaDWuu+8KuF+GpR3X6XQWmpvr32X5rnpk4+67qk4nsjbtRsLkRXBmZCF89FCEDOsHk59vmcYFCv+uZV2GnpaDa3ph25xWy1Cv9bsi7SNUVXW7rzTaPqKocSviPsJdTU6nM/fHT3mNq/U+Qo9laMR9hGve0uwr+Tui9OOWdf0u6veJC5fh/73HKPsIVVU97ivLylDNWP369QtcG5aamorLly+jfv36Rc536tQp/PDDD2jbtm2BaW3btsXixYvRpUuXUtV09V/p877uab7STCvLvBz3//5qUVRuetSk1bhZv/yBuNGzkP3T7wh6oBsiJgyHpUY1w9brabqn7CRlo+W4RqtJy21O0nIwak3ucnNNN9K+sizzVpZxuc3JHNeo25y0cY1aU1kYqhnr0qULFi5cmO/asZ07d8JkMqFz585FzjdmzJjcI2IuU6dOhZ+fH0aOHInGjRtrWjeRN9kvJyLhjUVIXfMJfG5oiJrb5sK/Ywu9yyIiIiKiEjJUMzZgwACsXr0aMTExGDZsGC5evIjp06djwIAB+Z4xFh0djQsXLmD37t0AgCZNmhQYKzg4GAEBAWjfvr3X6ifSkmqzI3nZh0icvgwwKaj61kgEP3YvlFKegktERERE+jLUr7iQkBCsXLkSkydPRkxMDAIDA9GnTx+MGDEi3/sKu2BQC1oekiTtuDvHXqrMb37G5dGzYDt2GsGP3Yfw0UNhjgjVu6xyVxGzqwyYm0zMTS5mJxNzk0nr3BRVy3s1Cnb48GEAQPPmzXWuhCoz27mLiB8/D+nbvoRf22ao+uYL8G3B026JiIiIvEmr3sBQR8aMSKvbWJI2XM/vcHeBrATOrGwkzVuLpNnvwxQchOrzxyKoz52iv5MnFSW7yoa5ycTc5GJ2MjE3mfLmphU2Y27woKFMdrtd7FPuVVVFxs5vEPd6LOwXLiN0WF+EvTgIpqAAvUvzCsnZVWbMTSbmJhezk4m5yaR1bmzGiAwi5+9/EDdmNjK//B7+/2uHGuvehk/DunqXRUREREQaYTNGpDNnajoS3lmB5EUbYalVHVGr30TAXZ15GgMRERFRBcdmjEgnqqoibeNniJ+4AM7UdIS/9DhCYgbA5Oerd2lERERE5AVsxtzgkQmZJOSWfegY4kbPQtYPRxB43/8QMTEG1tqRnmes4CRkRwUxN5mYm1zMTibmJpPWubEZ84AbjiyKohj64lhHfBISpi5GyurtsDauhxpbZiHgljZ6l2UIRs+OCsfcZGJucjE7mZibTN7Ijc0YkReodjtSVm5DwrQlgFNFxBvPIeTx3lCs3ASJiIiIKiv+EvSAzxmTRVVV2O12WCwWw+SWeeBXxI2ZjZzfT6DKwz0Q/towWKqF6V2W4RgxO/KMucnE3ORidjIxN5ny5qYVNmNu8DljMhklN/u/lxE/YT7StnwO39ZNUOuzRfBr1UTvsgzNKNlRyTA3mZibXMxOJuYmk9a5sRkjKmdqdg6SFm5A4rurYAr0Q7XZo1BlQHcoJpPepRERERGRgbAZIypH6bsOIH5sLGz//IuQJx5E2MuPwxwcpHdZRERERGRAbMaIyoHt5DnEjZ2DjN3fwr9LG0StngqfxtfqXRYRERERGRibMTd4gaVM3rx1rDMtA4mzViNpwXpYqocjctlkBN5zK9edUuJtf2VibjIxN7mYnUzMTSbe2l5n/FEti7fyUlUVaR9+gfgJ8+FMSEbYcwMR+uxAmAL8vPL5FRG3NZmYm0zMTS5mJxNzk8kbubEZ84C3tpdFVVU4HA6YzWbNcss++jfiRs9C1reHENjjFkRMegbWa2pq8lmViTeyo/LH3GRibnIxO5mYm0x5c9MKmzE3eAtSmZxOpyYbjSMxBQnTliJlxVZYG9RBjQ3vIOB/7cr9cyozrbIjbTE3mZibXMxOJuYmk9a5sRkj8kB1OJD6wSeIn/Ie1BwbIsY/jZChD0Lx4bnfRERERFR6bMaI3Mj6/jAuj56FnN/+QpX+dyN87DBYoqrqXRYRERERVQBsxogKYf8vDvGTFyJtw2fwbdEYtT5dAL+2zfQui4iIiIgqEDZjbvACS5nKcl6vmmND8uJNSHh7BRRfK6q9+zKqPNwTCs/x9gqeSy8Tc5OJucnF7GRibjJpnRubMQ/YkMmiKEqpN5qML79H3JjZsJ08h+DHeyN81FCYQ6uUc4VUlLJkR/phbjIxN7mYnUzMTSZv5MZmzAPe2l4WVVVzMytubrYzFxD3eiwydnwDv04tEblkInxvaKhxpXS10mRH+mNuMjE3uZidTMxNpry5aYXNmBu8tb1Mdru9WE9Ld2ZkIWnO+0iauxamiFBEvjcBgb27ciepo+JmR8bC3GRibnIxO5mYm0xa58ZmjCodVVWRvv0rxI+fB/ulBIQOH4CwFx6FKdBf79KIiIiIqBJhM0aVSs6fpxA3ZhYyv/4ZAXd2Qs3Ns2CtX1vvsoiIiIioEmIzRpWCIzkVidOXI3npFljr1kDUmukIvKOj3mURERERUSXGZswNXjskU97cVKcTqWt3IGHKIjjTsxA+5gmEDusLxddHxwqpKNzmZGJuMjE3uZidTMxNJq1zYzPmATccWRRFyb3IMuvn3xE3ehayf/4DQQ/egYjxT8NSo5rOFVJR8mZHcjA3mZibXMxOJuYmkzdyYzNGFY79UgISpryH1DWfwOeGhqi5bS78O7bQuywiIiIionzYjHnA54zJodrsSF66GQnTl0Mxm1D1rZEIjr4PCh+yKIKqqrDb7bBYLNzmBGFuMjE3uZidTMxNpry5aYXNmBt8zpgcGV//hLgxs2E7dhqBj9yDqq89CUtEqN5lUQlxm5OJucnE3ORidjIxN5m0zo3NGIlmO3cR8ePmIn37V/Br1xzVP18M0/XXwszzsomIiIjI4NiMkUjOrGwkzVuLpNnvwxQchOrzxyKoz50AAJvNpnN1RERERESesRkjUVRVRcaOrxE3bi7sFy4j9Kl+CBsZDVNQQO50IiIiIiIJ2Iy5wQssjSXn+BnEjZmNzK9+gH/X9qix7m34NKxb4H1aXmRJ2mJ2MjE3mZibXMxOJuYmk9a5ca3wgA2Z/pyp6Uh4ZwWSF22EpXYkola/iYC7OheajaIozEwoZicTc5OJucnF7GRibjJ5Izc2Yx7w1vb6UZ1OpG3chfhJC+BMTUf4y4MRMrw/TH6+Rc+jqnA6nTCZTMxNGGYnE3OTibnJxexkYm4y5c1NK2zG3OD1R/rJPnQMl0fPQvYPRxDYqyuqThwOS63IYs3rcDg03WhIO8xOJuYmE3OTi9nJxNxk0jo3NmNkKI74JCRMXYyU1dvhc/21qPnhbPjf3FrvsoiIiIiIyh2bMTIE1W5HysptSJi2BHCqiHjjOYQM7g2FF7sSERERUQVluF+6J06cwBtvvIFffvkFgYGB6NWrF1544QX4+PgUOc+lS5ewYsUK7N+/H//88w+qVKmCtm3bYuTIkahVq5YXq6fSyDzwK+LGzELO7ydR5eEeCH9tGCzVwvQui4iIiIhIU4ZqxpKTkxEdHY169eohNjYWFy9exLRp05CVlYVx48YVOd/Ro0exe/duPPjgg2jRogUSExOxYMEC9O3bFx9//DHCw8NLVQ8vsNSW/cIlxE+Yj7QPv4Bvm6ao9dki+LVqUuZxeT62XMxOJuYmE3OTi9nJxNxk0jo3QzVj69atQ3p6OubOnYvQ0FAAVy6amzhxIoYNG4bIyMJv4NCmTRvs2LEj33MAWrdujdtuuw1bt27F4MGDS10TG7Lyp2bnIGnBeiTOXAVToD+qzRmNKv3vhlIOK7uiKHyOh1DMTibmJhNzk4vZycTcZPJGboZq0fft24eOHTvmNmIA0L17dzidTuzfv7/I+YKDgwssqKioKISHh+PSpUtlqol3VCxf6bsO4Owt0Uh4aymCH7sPdb5bg+CHepRLIwZcycv1P5KF2cnE3GRibnIxO5mYm0zeyM1QzdjJkydRv379fK8FBwejWrVqOHnyZInGOnXqFOLj49GgQYNS18MNpvzknDiLfx9+Bf8NfBWWOpGo89VyVJ38LMzBQeX+WTabrdzHJO9gdjIxN5mYm1zMTibmJpPWuRnqeGlKSgqCg4MLvB4SEoLk5ORij6OqKt544w1Ur14dPXv2LFNNhTVkiqIU2ai5Tmt0N12reY04riM1HUmzViNp4QZYIiMQuWwyAnp2gclk0qRe13xF5VbacStiNnqM625e1zRvb3PSxjVaTa75tNjmJC0Ho9bk6Y+KRqvXiDUZbVzXNG5zssZ1MVJNEsf1dk2u17Q8QGOoZqy8xMbG4rvvvsOSJUsQEBBQprFsNlu+68ZMJlPuKZGFdcquuz46HA44nc580ywWCxRFgdPphMPhyDfNNa6qqoWOa7VaixzXbDbDbDZDVVXY7fZ80xRFyZ3XbrcXWJm0GtdsNiPjoy8RP2EenIkpCH7mIVQZ3h8mf798TzK/+rt6GtfTMjSbzbnjXn29n9VqvdIglvC7espcq2Xo7ru6xi2sprIuQ0/ftahl6BrX3TL0tH47nc4C2ZXH+u1uGZZ3NpVtH+H6w8rVuWm1DPVavyvaPsJV79Wf6WlcvfcRWq3f0vYRhW1zei9Db67fEvcRnn6fAMbaR0j9HaHFMgSu7CNUVS2QXXkwVDMWHByM1NTUAq8nJycjJCSkWGNs2LAB8+bNw5QpU9CxY8cy1+RaaYqaVpS8K/nVTCZTkXdmybtSlHRcT/O6uwCxPMfNPvI3Lr82G1nfHkJAzy6ImBgDa90ahc5b2nrdLUPXuFfn5vp3Wb6rHtkU57t6a9yyLkNPy8FkMhW5zWm1DPXKpiLuI4raV1aW9buocV2Muo8oKjcj7iP0WIZG3Ee42+aMvI8ozbgVcR9R1DbHZfh/7zHKPsLVnJlMJk0aMcBgzVj9+vULXBuWmpqKy5cvF7iWrDC7d+/GhAkT8Nxzz6FPnz5lrkdRlNz/FTbN07ylmVaWefUe15GYgoQ3lyBl5UewNqiDGhvfRcBtbb1ar6qquRtMUe8x8jKs6OO6m+4pO2nftbLsI7Tc5iQtB6PW5C43d/+NK8tn6jVvZRmX25zMcY26zUkbV4+a3GVWHgzVjHXp0gULFy7Md+3Yzp07YTKZ0LlzZ7fzHjx4ECNHjkTfvn0RExNTbjVpufArCtXhQMr7HyNh6mKoOTZETHgaIUP7QLF6f/Xy9FcPMi5mJxNzk4m5ycXsZGJuMnkjN0M1YwMGDMDq1asRExODYcOG4eLFi5g+fToGDBiQ7xlj0dHRuHDhAnbv3g0AOHHiBGJiYlCvXj306tULv/76a+57w8PDUbduXW9/lUoj6/vDuDx6FnJ++wtV+t+N8NefgiUyQu+yiIiIiIgMz1DNWEhICFauXInJkycjJiYGgYGB6NOnD0aMGJHvfVdfMHjo0CGkpqYiNTUVDz30UL733n///Zg2bVqpa9LqYj3p7P/FIX7SAqRt3AXfFo1R69MF8GvbTO+yci/OdHcdBBkTs5OJucnE3ORidjIxN5ny5qYVRdXyXo2CHT58GKqqonnz5txo8lBzbEh6byMS314Bxc8HEa8NQ5WHe0Ap4mJJb3PdZcfdBbJkTMxOJuYmE3OTi9nJxNxkypvbkSNHAADNmzcv188w1JExMraMPQcR99oc2E6eQ8jg+xH26hCYQ6voXRYRERERkUhsxsgj2+kLiBsXi4wd38CvU0tELp0E36YN9C6LiIiIiEg0NmNUJGdGFpJmv4+keWthighF5HsTENi7Kw+vExERERGVAzZjblTWpkNVVaRv+wrx4+fCfjkRoTEPIez5R2AK9Ne7tGLR8iJL0hazk4m5ycTc5GJ2MjE3mbTOjWuFB5WtIcv58xTixsxC5tc/I+Cuzqg5+VlYr62ld1nFpvWD+Ug7zE4m5iYTc5OL2cnE3GTyRm5sxjyoLLe2dySnInH6ciQv3QLrNTUQtXYGArt10LusElNVFU6nEyaTqVLkVpEwO5mYm0zMTS5mJxNzkylvblphM+ZGZbjrv+p0InXNp4ifsghqRjbCxzyB0GF9ofj66F1aqTkcDk03GtIOs5OJucnE3ORidjIxN5m0zo3NWCWW9fPviBs1C9m//IGgB+9AxPinYalRTe+yiIiIiIgqBTZjlZD9UgIS3liE1LWfwqfZdai5fR78O9yod1lERERERJUKm7FKRLXZkbx0CxKnLwMsZlSdPhLBj90HxWzWuzQiIiIiokqHzZgbFekCy4x9PyJuzGzYjv+D4Oj7ED5qKMzhIXqXpQmejy0Xs5OJucnE3ORidjIxN5m0zo3NmAfSGzLb2f8QP24u0j/eC792zRG5ezF8b2ykd1maURSFz/EQitnJxNxkYm5yMTuZmJtM3siNa4UHUm9t78zMRtK8NUia8wFMwUGovuB1BD14h8jvUhJ574BZ0b9rRcPsZGJuMjE3uZidTMxNJm/cWZ3NmBsSb22vqirSP/0a8ePmwv7vZYQ+1Q9hI6NhCgrQuzSvsdlssFqtepdBpcDsZGJuMjE3uZidTMxNJq1zYzNWgeQcP4O4MbOR+dUP8O/aHjXWvw2fhnX1LouIiIiIiArBZqwCcKamI+HtFUh+byMstSMR9f40BNzZiYfBiYiIiIgMjM2YYKrTibSNuxA/aQGcaRkIf3kwQob3h8nPV+/SiIiIiIjIAzZjQmUfOobLo2ch+4cjCOzVFVUnDoelVqTeZRERERERUTGxGXNDURTDnerniE9C/JT3kPr+x/C5/lrU/HA2/G9urXdZhqEoCqxWq+FyI8+YnUzMTSbmJhezk4m5yeSN3NiMCaHa7UhZ8RESpi0BAFSd8hyCH+8Nhc+sKIA7OrmYnUzMTSbmJhezk4m5yaR1bvwl74ERnjOWuf8XxI2ZhZw/TqHKwJ6IeO1JmKuG6VqTUamqCofDAbPZrHtuVDLMTibmJhNzk4vZycTcZMqbm1bYjLmh93PG7BcuIX7CfKR9+AV82zRFrc8Wwa9VE11rksDpdGq60ZB2mJ1MzE0m5iYXs5OJucmkdW5sxgxIzc5B0vx1SJy1GqZAf1SbMxpV+t8NxWTSuzQiIiIiIionbMYMJn3XfsS9Fgv7uf8Q8kQfhL00CObgIL3LIiIiIiKicsZmzCByTpxF/Ng5yPj8O/jfehNqfDANPo3q6V0WERERERFphM2YG964wNKZloHEd1chaeF6WKKqInL5Gwjs2YUXd5YBz8eWi9nJxNxkYm5yMTuZmJtMWufGZswDrZoiVVWRtuVzxE+YD2dSCsJGPIbQZx6Gyd9Xk8+rLBRF4c5OKGYnE3OTibnJxexkYm4yeSM3NmMeaHFr++wjfyNu9CxkfXcIgT1vRcSkGFjr1ijXz6isVFXNzYxHF2VhdjIxN5mYm1zMTibmJlPe3LTCZsyN8r61vSMxBQlvLkHKyo9gbVgHNTbNRMCtN5XrZxBgt9thtVr1LoNKgdnJxNxkYm5yMTuZmJtMWufGZswLVIcDKau3I2HqYqg2OyImPI2QoX2gWLn4iYiIiIgqK3YDGss8+BviRs9CzuHjqDKgO8LHDoMlMkLvsoiIiIiISGdsxjRi/y8O8ZMWIG3jLvi2vB61diyE30036F0WEREREREZBJsxN0pzsZ6aY0PSexuR+PYKKH4+qPbuK6gysCcUk0mDCqkwJi5rsZidTMxNJuYmF7OTibnJpHVubMY8KElDlvHFQcS9Nhu20xcQ8nhvhL06BObQKhpWR1dTFAUWC1driZidTMxNJuYmF7OTibnJ5I3cuFaUA9vpC4h7PRYZO7+BX+dWiFw2Gb5NG+hdFhERERERGRibMTc8PVvAmZGFpNnvI2neWpgiQhG5eCICe/2Pz4/QkaqqsNlssFqtzEEYZicTc5OJucnF7GRibjLlzU0rbMZKQVVVpH/0JeInzIP9ciJCYx5C2POPwBTor3dpREREREQkBJuxEsr+4yTixsxG1jc/I+Cuzqg5+VlYr62ld1lERERERCQMm7FiciSnIvGtZUhe9iGs9Woiau0MBHbroHdZREREREQkFJsxD1SnE6lrPkX8lEVQs3IQ/toTCB3WD4qPdueOEhERERFRxcdmzA3zn6dx4aVYZP/yJ4L63omIcU/DElVV77LIAy0vsiRtMTuZmJtMzE0uZicTc5NJ69wM9/S5EydO4PHHH0fLli3RuXNnTJ8+HTk5OR7nU1UV7733Hm677TbceOON6N+/P3799dcy1eIXMwOqzYGaH89D5PzX2YgJoChK7v9IFmYnE3OTibnJxexkYm4yeSM3QzVjycnJiI6Ohs1mQ2xsLEaMGIENGzZg2rRpHuddvHgx5syZg0GDBmHRokWoVq0aBg8ejLNnz5a6nuxXHkWt3e/Bv/2NpR6DvEtVVdjtdqiqqncpVELMTibmJhNzk4vZycTcZPJGboY6TXHdunVIT0/H3LlzERoaCgBwOByYOHEihg0bhsjIyELny87OxqJFizB48GAMGjQIANCmTRvcfffdWLp0KSZMmFCqeux3dYBiNpdqXtKP0+mEmbmJxOxkYm4yMTe5mJ1MzE0mrXMz1JGxffv2oWPHjrmNGAB0794dTqcT+/fvL3K+n3/+GWlpaejevXvuaz4+Prjjjjuwb98+LUsmIiIiIiIqFUM1YydPnkT9+vXzvRYcHIxq1arh5MmTbucDUGDeBg0a4MKFC8jKyir/YomIiIiIiMrAUKcppqSkIDg4uMDrISEhSE5Odjufj48PfH19870eHBwMVVWRnJwMPz+/EtVis9mgqiqOHDlSovlIf6qq8gJZoZidTMxNJuYmF7OTibnJ5MotJydHk/wM1YwZCTcWuZidXMxOJuYmE3OTi9nJxNxkcuWm1V0VDdWMBQcHIzU1tcDrycnJCAkJcTtfTk4OsrOz8x0dS0lJgaIobuctSqtWrUo8DxERERERUXEZ6pqx+vXrF7g2LDU1FZcvXy5wPdjV8wHAqVOn8r1+8uRJ1KxZs8SnKBIREREREWnNUM1Yly5dcODAAaSkpOS+tnPnTphMJnTu3LnI+Vq3bo2goCDs2LEj9zWbzYZdu3ahS5cumtZMRERERERUGoY6TXHAgAFYvXo1YmJiMGzYMFy8eBHTp0/HgAED8j1jLDo6GhcuXMDu3bsBAL6+vhg2bBhiY2MRHh6ORo0aYe3atUhKSsKQIUP0+jpERERERERFMlQzFhISgpUrV2Ly5MmIiYlBYGAg+vTpgxEjRuR7n9PphMPhyPfaE088AVVVsWzZMiQkJKBJkyZYunQp6tSp482vQEREREREVCyKqqqq3kUQERERERFVNoa6ZoyIiIiIiKiyYDNGRERERESkAzZjREREREREOmAzRkREREREpAM2Y0RERERERDpgM0ZERERERKQDNmNEREREREQ6YDN2lRMnTuDxxx9Hy5Yt0blzZ0yfPh05OTl6l0V57NixA08//TS6dOmCli1bolevXti0aROufmTexo0bcdddd6F58+a477778OWXX+pUMRUmPT0dXbp0QePGjXH48OF805id8Xz44Yfo3bs3mjdvjvbt22Po0KHIysrKnb5nzx7cd999aN68Oe666y5s3rxZx2rJ5YsvvkDfvn3RqlUr3HzzzXj++edx9uzZAu/jNqefM2fOYNy4cejVqxeaNm2Ke+65p9D3FSej1NRUjBkzBu3atUOrVq3w3HPP4dKlS1p/hUrJU25paWmIjY1Fnz59cNNNN6FTp0546qmncOzYsQJjMTfvKu425/L555+jcePGhb6vPLJjM5ZHcnIyoqOjYbPZEBsbixEjRmDDhg2YNm2a3qVRHitWrIC/vz9GjRqFBQsWoEuXLnj99dcxb9683Pd88skneP3119G9e3csXrwYLVu2xDPPPINff/1Vv8Ipn/nz58PhcBR4ndkZz4IFCzB58mT06NEDS5cuxaRJk1C7du3c/H788Uc888wzaNmyJRYvXozu3bvjtddew86dO3WuvHI7ePAgnnnmGTRs2BDz5s3DmDFj8Oeff2Lw4MH5Gmluc/o6fvw49u7di2uuuQYNGjQo9D3FzeiFF17A/v37MWHCBLz99ts4deoUnnjiCdjtdi98k8rFU24XLlzA+vXr0blzZ8yaNQuTJ09Gamoq+vfvjxMnTuR7L3PzruJscy5ZWVmYOnUqqlatWuj0cslOpVwLFy5UW7ZsqSYmJua+tm7dOrVJkybqf//9p19hlE98fHyB18aOHau2bt1adTgcqqqq6p133qmOHDky33v69++vDh061Cs1knt///232rJlS3Xt2rVqo0aN1N9++y13GrMzlhMnTqhNmzZVv/rqqyLfM3jwYLV///75Xhs5cqTavXt3rcsjN15//XW1a9euqtPpzH3t22+/VRs1aqT+8MMPua9xm9OX679bqqqqr776qtqzZ88C7ylORj///LPaqFEj9euvv8597cSJE2rjxo3VTz75RIPKKzdPuaWnp6sZGRn5XktLS1PbtWunTpo0Kfc15uZ9xdnmXGbNmqUOHDiw0PeVV3Y8MpbHvn370LFjR4SGhua+1r17dzidTuzfv1+/wiif8PDwAq81adIEaWlpyMjIwNmzZ3H69Gl0794933t69OiBb7/9lqedGsAbb7yBAQMG4Nprr833OrMzni1btqB27dq49dZbC52ek5ODgwcP4u677873eo8ePXDixAmcO3fOG2VSIex2OwIDA6EoSu5rVapUAYDc07q5zenPZHL/U6y4Ge3btw/BwcHo3Llz7nvq16+PJk2aYN++feVfeCXnKbeAgAD4+/vney0wMBB169bNdxobc/M+T9m5/PPPP1i+fDnGjh1b6PTyyo7NWB4nT55E/fr1870WHByMatWq4eTJkzpVRcXx008/ITIyEkFBQblZXf1Dv0GDBrD9v/buPSiqso8D+Bd0F0cQEKeRQBgJRowFNeIuAwlakBJpjmEjMGFCaYg0ZngJRU1MJaJCvI0T3mrUvCQxOEaoUxqFiYnrjFxFEB0Dlt0NwcXd9w9edlx3lfUNObu938/M/rHP85xnf+xvzuH89txUKoPXS9DgKSkpwbVr17Bo0SK9PubO9Fy6dAnjxo3D1q1bERwcDG9vb8TFxeHSpUsAev9ZqVQqvW1n36kf3HYKZ9asWaitrcX+/fuhUChw48YNfPbZZ/Dy8oKvry8ArnPmwNgc1dXVwc3NTaf4Bnp3Drkemga5XI7q6mqd7SXzZro++eQTxMbGYvz48Qb7Byp3LMYeIJfLYWtrq9duZ2eHjo4OASIiY1RUVKC4uBhJSUkAoM3Vw7nse89cCufu3bvYuHEj0tPTYWNjo9fP3JmeO3fu4Oeff8bx48exevVq5Ofnw8LCAklJSWhtbWXOTJifnx+++uor5OTkwM/PD1OnTkVrayt27tyJIUOGAOA6Zw6MzZFcLtce+XwQ92FMx+bNm2FhYYG5c+dq25g30/TTTz/h4sWLSEtLe+SYgcodizEya7du3UJ6ejoCAwORkJAgdDjUj4KCAowaNQpvvPGG0KGQkTQaDTo7O5GXl4eoqCiEh4ejoKAAGo0G+/btEzo8eow//vgDy5Ytw5w5c1BYWIi8vDyo1WokJyfr3MCDiJ6+7777DgcPHkRmZiYcHR2FDoceo7u7Gxs2bEBqaqrBS2MGGouxB9ja2kKhUOi1d3R0wM7OToCI6HHkcjkWLFgAe3t7fPnll9pzgPty9XAu5XK5Tj8NrubmZuzevRuLFy+GQqGAXC5HZ2cnAKCzsxN///03c2eCbG1tYW9vr3Oahr29Pby8vFBTU8OcmbD169cjKCgIGRkZCAoKQlRUFHbs2AGpVIrjx48D4PbSHBibI1tbWyiVSr3luQ8jvDNnziAzMxMLFy7EzJkzdfqYN9NTWFgIS0tLTJ8+HXK5HHK5HCqVCmq1GnK5XHud5kDljsXYAwyd46lQKHDnzh296yFIWF1dXUhJSYFCocCuXbt0DhP35erhXNbV1UEkEsHFxWVQY6VeTU1NUKlUSE5Ohr+/P/z9/fHuu+8CABISEvD2228zdybIw8PjkX3d3d1wdXWFSCQymDMA3HYKqLa2Vu9aB0dHR4wcORKNjY0AuL00B8bm6LnnnkN9fb3eMzfr6+u5HgqosrISaWlpeP311w2e8sa8mZ66ujpcv34dwcHB2v2VoqIi1NbWwt/fX/sczYHKHYuxB4SFheHcuXPaX5uA3psNWFpa6twphYTV09ODJUuWoK6uDrt27cLo0aN1+l1cXDB27Fi9ZxwVFxcjODgYYrF4MMOl/3r++eexZ88endfy5csBAFlZWVi9ejVzZ4KmTJkCmUyGq1evatva29tx5coVSCQSiMViBAYG4uTJkzrLFRcXw93dHWPGjBnskOm/nJycIJVKddqam5vR3t4OZ2dnANxemgNjcxQWFoaOjg6cP39eO6a+vh5SqRRhYWGDGjP1qqmpQUpKCoKCgpCVlWVwDPNmehYsWKC3vxIaGgpnZ2fs2bMHERERAAYud0MH/C8wY3Fxcdi7dy8WLVqElJQU3L59G5s2bUJcXJzeDj8JJysrC2VlZcjIyIBSqdR56KWXlxfEYjFSU1OxdOlSuLq6IjAwEMXFxfjzzz95jYuAbG1tERgYaLBPIpFAIpEAAHNnYqZOnQofHx8sXrwY6enpsLKywo4dOyAWi/HWW28BAN577z0kJCRgzZo1iI6ORnl5OYqKipCbmytw9P/f4uLisGHDBqxfvx4RERGQyWTa6zYfvE061zlh3b17F2fOnAHQWywrlUpt4RUQEAAHBwejcvTCCy8gNDQUK1aswEcffQQrKyvk5ubC09MTL7/8siB/279Zf3nTaDSYP38+rKyskJiYiKqqKu2yNjY22rMOmLfB11/u3N3d9R4GffToUdy+fVtnP2agcmehefjY2v+52tparFu3DhcvXoS1tTViY2ORnp7OXwdNSEREBJqbmw32lZaWan+JP3ToEHbu3ImbN2/Czc0NH3zwAaZMmTKYoVI/ysvLkZCQgMOHD8PHx0fbztyZlra2NmRnZ6OsrAwqlQp+fn5Yvny5zimMpaWl+Pzzz1FfXw8nJyckJydj9uzZAkZNGo0G3377Lb755hvcuHED1tbWmDRpEtLT0/V2NLjOCaepqQmRkZEG+/bs2aPd+TMmRwqFAtnZ2Th16hR6enoQGhqKVatW8Qflp6C/vAF45I3FAgICsHfvXu175m1wGbvOPSgjIwNVVVUoKirSaR+I3LEYIyIiIiIiEgCvGSMiIiIiIhIAizEiIiIiIiIBsBgjIiIiIiISAIsxIiIiIiIiAbAYIyIiIiIiEgCLMSIiIiIiIgGwGCMiIiIiIhIAizEiIqIB1NLSAh8fH1y4cOGJl62pqYGXlxeuXbv2FCIjIiJTw2KMiIjMwpEjR+Dp6QlPT09UVFTo9Ws0GoSHh8PT0xMpKSkCRNgrPz8fEydOxIsvvvjEy3p4eCA8PBxffPHFU4iMiIhMDYsxIiIyK1ZWVigqKtJr/+2333Dr1i2IxWIBourV1taGY8eOIS4u7n+eIy4uDqdOnUJjY+MARkZERKaIxRgREZmV8PBwlJSUoKenR6e9qKgIEokEzzzzjECRAd9//z2GDBmCKVOm/M9zhISEwM7ODkePHh3AyIiIyBSxGCMiIrMyffp0yGQy/PLLL9q2e/fu4eTJk4iJiTG4jFqtxtdff43p06fDx8cHISEhyMzMREdHh844jUaDrVu3IiwsDBMnTkR8fDyqq6sRERGBjIyMfmP78ccfMWHCBFhbW+v17d+/H5GRkZgwYQJmz56NiooKxMfHIz4+XmecSCRCQEAASktLjfk6iIjIjLEYIyIis+Ls7IxJkybhhx9+0LadPXsWCoUCr776qsFlMjMzsXnzZvj6+mLlypWYNWsWTpw4gfnz50OlUmnH5eXlIS8vD+PHj8eyZcvg4uKCpKQkdHZ29huXSqXC5cuXIZFI9PoOHDiAtWvXwtHRER9++CH8/PywaNEi3Lp1y+BcEokE1dXVUCqV/X4uERGZr6FCB0BERPSkYmJikJOTg66uLgwbNgwnTpyAv78/Ro8erTe2oqIChw4dwpYtW3SOnAUGBuKdd95BSUkJYmJi0NbWhl27duGll17Ctm3bYGFhAQDIzc3Ftm3b+o2ppaUFXV1dGDNmjE77vXv3kJeXBx8fHxQWFmLo0N5/vZ6ensjIyICjo6PeXC4uLlCr1airq8OECROe6LshIiLzwSNjRERkdqKjo9Hd3Y2ysjIolUqcPn36kacolpSUYMSIEZg8eTLa2tq0L4lEguHDh6O8vBwAcO7cOahUKsybN09biAFAYmKiUTHJZDIAgK2trU57VVUVZDIZ5syZoy3EgN6C0s7OzuBcfXO0t7cb9dlERGSeeGSMiIjMjoODA4KDg1FUVISuri7cv38fr7zyisGx169fh0KhQHBwsMH+1tZWAMDNmzcBAGPHjtX7rEcVTYZoNBqd933zurq66rQPHToUzs7ORs1BRET/TizGiIjILM2YMQMff/wx/vrrL4SFhekdkeqjVqsxatQobNmyxWC/g4PDgMRjb28PAJDL5f94rr45Ro4c+Y/nIiIi08XTFImIyCxNmzYNlpaWqKysxIwZMx45ztXVFTKZDL6+vggJCdF7jR8/HgDg5OQEAGhoaNBZvq2tTe+ui4Y8++yzGDZsGJqamnTa++Z9+LlhPT09aG5uNjhXU1MTLC0t4ebm1u/nEhGR+WIxRkREZsna2hpr1qxBamoqIiIiHjkuOjoa9+/fx9atW/X6enp6tEehQkJCIBKJsG/fPp3TBAsLC42KRyQSwdvbG1VVVTrt3t7esLe3x8GDB3WejXbixIlHFnlXrlyBh4cHRowYYdRnExGReeJpikREZLZmzpzZ75iAgAC8+eab2L59O65evYrJkydDJBKhoaEBJSUlWLlyJaKiouDg4ICkpCRs374dKSkpCA8Ph1QqxdmzZ40+XTAyMhK5ublQKpWwsbEBAIjFYqSmpmLdunVITExEdHQ0mpubceTIEb3ryIDeW+T//vvvmDt37pN9GUREZHZ4ZIyIiP711q5di3Xr1qG1tRW5ubnIycnBr7/+itdeew2+vr7acUuWLEFqaiqkUik2bdqExsZG7N69G8OHDzfqc2JjY6FWq/Ue2Dxv3jysWrUKLS0t+PTTT1FRUYGCggKMGDECVlZWOmPPnz8PmUxmVKFJRETmzULDWzYRERE9VkREBAICArBx48Z+x65YsQINDQ04cODAY8ep1WoEBwdj2rRpWL9+vbZ94cKFsLCwQH5+/j+Om4iITBuPjBEREQ2g999/H5cvX8aFCxe0bd3d3Xq3qz927BhkMhkCAgK0bbW1tTh9+jTS0tIGLV4iIhIOrxkjIiIaQE5OTrh8+bJOW2VlJbKzsxEVFQV7e3tIpVIcPnwY48aNQ1RUlHacu7s7pFLpYIdMREQCYTFGRET0lDk7O8PR0RF79+5FR0cH7OzsEBsbi6VLl0IsFgsdHhERCYTXjBEREREREQmA14wREREREREJgMUYERERERGRAFiMERERERERCYDFGBERERERkQBYjBEREREREQmAxRgREREREZEAWIwREREREREJgMUYERERERGRAFiMERERERERCeA/riN+DmTnVfYAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "# Seaborn scatter\n", + "sns.scatterplot(\n", + " data=datad,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", + ")\n", + "\n", + "# Barre d’errore\n", + "plt.errorbar(\n", + " datad[\"x\"],\n", + " datad[\"y\"],\n", + " xerr=datad[\"ux\"],\n", + " yerr=datad[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", + ")\n", + "\n", + "# Linea di regressione\n", + "xfit = np.linspace(0, datad[\"x\"].max(), 200)\n", + "yfit = BdY + AdY * xfit\n", + "\n", + "\n", + "plt.plot(\n", + " xfit,\n", + " yfit,\n", + " color=\"crimson\",\n", + " linewidth=1,\n", + " zorder=10,\n", + " label=\"Fit lineare York\"\n", + ")\n", + "\n", + "\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "\n", + "\n", + "plt.xlabel(\"Meq (g)\")\n", + "plt.ylabel(\"T^2 (s^2)\")\n", + "plt.title(\"Legge di ??\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "2e612bc6", + "metadata": {}, + "source": [ + "## Raccolta finale di dati dinamici" + ] + }, + { + "cell_type": "code", + "execution_count": 634, + "id": "fc32f9e6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RISULTATI senza ERRORE STRUMENTALE INCLUSO:\n", + "Media pesata K = 3.21203 ± 0.00037\n", + "\n", + "RISULTATI REGRESSIONE OLS:\n", + "Adols = 0.01202 ± 0.00004\n", + "Bdols = 0.02190 ± 0.00427\n", + "P(0,chi²)= 1.00000\n", + "Kdols = 3.28476 ± 0.01190\n", + "KBdols = 1.80288 ± 0.35183\n", + "\n", + "RISULTATI REGRESSIONE Carpi:\n", + "AdC = 0.01205 ± 0.00001\n", + "BdC = 0.01985 ± 0.00053\n", + "P(0,chi²)= 1.00000\n", + "KdC = 3.27519 ± 0.00175\n", + "KBdC = 1.98906 ± 0.05297\n", + "\n", + "RISULTATI REGRESSIONE York:\n", + "Ady = 0.01205 ± 0.00001\n", + "Bdy = 0.01985 ± 0.00053\n", + "P(0,chi²)= 1.00000\n", + "KdY = 3.27519 ± 0.00175\n", + "KBdY = 1.98918 ± 0.05298\n" + ] + } + ], + "source": [ + "print(\"RISULTATI senza ERRORE STRUMENTALE INCLUSO:\")\n", + "print(f\"Media pesata K = {KdM:.5f} ± {uKdM:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE OLS:\")\n", + "print(f\"Adols = {Adols:.5f} ± {uAdols:.5f}\")\n", + "print(f\"Bdols = {Bdols:.5f} ± {uBdols:.5f}\")\n", + "print(f\"P(0,chi²)= {Pdols:.5f}\")\n", + "print(f\"Kdols = {Kdols:.5f} ± {uKdols:.5f}\")\n", + "print(f\"KBdols = {KBdols:.5f} ± {uKBdols:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE Carpi:\")\n", + "print(f\"AdC = {AdC:.5f} ± {uAdC:.5f}\")\n", + "print(f\"BdC = {BdC:.5f} ± {uBdC:.5f}\")\n", + "print(f\"P(0,chi²)= {PdC:.5f}\")\n", + "print(f\"KdC = {KdC:.5f} ± {uKdC:.5f}\")\n", + "print(f\"KBdC = {KBdC:.5f} ± {uKBdC:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE York:\")\n", + "print(f\"Ady = {AdY:.5f} ± {uAdY:.5f}\")\n", + "print(f\"Bdy = {BdY:.5f} ± {uBdY:.5f}\")\n", + "print(f\"P(0,chi²)= {PdY:.5f}\")\n", + "print(f\"KdY = {KdY:.5f} ± {uKdY:.5f}\")\n", + "print(f\"KBdY = {KBdY:.5f} ± {uKBdY:.5f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "7caf197a", + "metadata": {}, + "source": [ + "## Aggiunta degli errori strumentali" + ] + }, + { + "cell_type": "code", + "execution_count": 635, + "id": "f4897de3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "res_T = 0.001000\n", + "res_T2 = 0.002551\n", + "res_b = 0.004082\n", + "res_uAd = 0.000047\n", + "uKd_strum= 0.012519\n" + ] + } + ], + "source": [ + "res_b = 0.01 / np.sqrt(6) # riso bilancia\n", + "res_T = 0.001 # riso T\n", + "\n", + "T = 2 * np.pi / df.w\n", + "res_T2 = np.max(2 * T * res_T)\n", + "\n", + "res_uAd = np.max(np.sqrt( (1 / Meq)**2 * res_T2**2 + (T2 / Meq**2)**2 * res_b**2))\n", + "\n", + "uKd_strum = np.max(np.abs(4 * np.pi**2 / Ad**2) * res_uAd) / 1000\n", + "\n", + "print(f\"res_T = {res_T:.6f}\")\n", + "print(f\"res_T2 = {res_T2:.6f}\")\n", + "print(f\"res_b = {res_b:.6f}\")\n", + "print(f\"res_uAd = {res_uAd:.6f}\")\n", + "print(f\"uKd_strum= {uKd_strum:.6f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 636, + "id": "37d88464", + "metadata": {}, + "outputs": [], + "source": [ + "uKdM_fin = np.sqrt(uKdM**2 + uKd_strum**2)\n", + "\n", + "uAdols_fin = np.sqrt(uAdols**2 + res_uAd**2)\n", + "uBdols_fin = np.sqrt(uBdols**2 + res_uAd**2)\n", + "uKdols_fin = np.sqrt(uKdols**2 + uKd_strum**2)\n", + "\n", + "uAdC_fin = np.sqrt(uAdC**2 + res_uAd**2)\n", + "uBdC_fin = np.sqrt(uBdC**2 + res_uAd**2)\n", + "uKdC_fin = np.sqrt(uKdC**2 + uKd_strum**2)\n", + "\n", + "uAdY_fin = np.sqrt(uAdY**2 + res_uAd**2)\n", + "uBdY_fin = np.sqrt(uBdY**2 + res_uAd**2)\n", + "uKdY_fin = np.sqrt(uKdY**2 + uKd_strum**2)\n", + "\n", + "\n", + "uy_fin_d = np.sqrt(datad[\"uy\"]**2 + res_T2**2)\n", + "ux_fin_d = np.sqrt(datad[\"ux\"]**2 + res_b**2)\n", + "\n", + "GdLd = len(datad) - 2\n", + "\n", + "\n", + "F_fit_dols = Bdols + Adols * datad[\"x\"]\n", + "sigma_dols = np.sqrt(uy_fin_d**2 + (Adols * ux_fin_d)**2)\n", + "chi2_dols = np.sum(((datad[\"y\"] - F_fit_dols) / sigma_dols)**2)\n", + "\n", + "F_fit_dC = BdC + AdC * datad[\"x\"]\n", + "sigma_dC = np.sqrt(uy_fin_d**2 + (AdC * ux_fin_d)**2)\n", + "chi2_dC = np.sum(((datad[\"y\"] - F_fit_dC) / sigma_dC)**2)\n", + "\n", + "F_fit_dY = BdY + AdY * datad[\"x\"]\n", + "sigma_dY = np.sqrt(uy_fin_d**2 + (AdY * ux_fin_d)**2)\n", + "chi2_dY = np.sum(((datad[\"y\"] - F_fit_dY) / sigma_dY)**2)\n" + ] + }, + { + "cell_type": "markdown", + "id": "42c27c50", + "metadata": {}, + "source": [ + "## Risultati sulla propagazione dell'errore" + ] + }, + { + "cell_type": "code", + "execution_count": 637, + "id": "9075e52d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RISULTATI CON ERRORE STRUMENTALE INCLUSO:\n", + "Media pesata Kd = 3.21203 ± 0.01252\n", + "\n", + "RISULTATI OLS:\n", + "Adols = 0.01202 ± 0.00006\n", + "Bdols = 0.02190 ± 0.00427\n", + "Kdols = 3.28476 ± 0.01727\n", + "Chi² = 3.32681 | rid = 1.10894 | P = 0.65607\n", + "\n", + "RISULTATI Carpi:\n", + "AdC = 0.01205 ± 0.00005\n", + "BdC = 0.01985 ± 0.00053\n", + "KdC = 3.27519 ± 0.01264\n", + "Chi² = 5.09243 | rid = 1.69748 | P = 0.83485\n", + "\n", + "RISULTATI York:\n", + "AdY = 0.01205 ± 0.00005\n", + "BdY = 0.01985 ± 0.00053\n", + "KdY = 3.27519 ± 0.01264\n", + "Chi² = 5.09342 | rid = 1.69781 | P = 0.83492\n" + ] + } + ], + "source": [ + "print(\"RISULTATI CON ERRORE STRUMENTALE INCLUSO:\")\n", + "print(f\"Media pesata Kd = {KdM:.5f} ± {uKdM_fin:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI OLS:\")\n", + "print(f\"Adols = {Adols:.5f} ± {uAdols_fin:.5f}\")\n", + "print(f\"Bdols = {Bdols:.5f} ± {uBdols_fin:.5f}\")\n", + "print(f\"Kdols = {Kdols:.5f} ± {uKdols_fin:.5f}\")\n", + "print(f\"Chi² = {chi2_dols:.5f} | rid = {chi2_dols/GdLd:.5f} | P = {chi2.cdf(chi2_dols, GdLd):.5f}\")\n", + "\n", + "print(\"\\nRISULTATI Carpi:\")\n", + "print(f\"AdC = {AdC:.5f} ± {uAdC_fin:.5f}\")\n", + "print(f\"BdC = {BdC:.5f} ± {uBdC_fin:.5f}\")\n", + "print(f\"KdC = {KdC:.5f} ± {uKdC_fin:.5f}\")\n", + "print(f\"Chi² = {chi2_dC:.5f} | rid = {chi2_dC/GdLd:.5f} | P = {chi2.cdf(chi2_dC, GdLd):.5f}\")\n", + "\n", + "print(\"\\nRISULTATI York:\")\n", + "print(f\"AdY = {AdY:.5f} ± {uAdY_fin:.5f}\")\n", + "print(f\"BdY = {BdY:.5f} ± {uBdY_fin:.5f}\")\n", + "print(f\"KdY = {KdY:.5f} ± {uKdY_fin:.5f}\")\n", + "print(f\"Chi² = {chi2_dY:.5f} | rid = {chi2_dY/GdLd:.5f} | P = {chi2.cdf(chi2_dY, GdLd):.5f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "6f4edfa1", + "metadata": {}, + "source": [ + "# Dinamica Cronometro" + ] + }, + { + "cell_type": "code", + "execution_count": 638, + "id": "0f407f81", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 0.616814\n", + "1 0.834482\n", + "2 1.043973\n", + "3 1.250483\n", + "4 1.502463\n", + "Name: t, dtype: float64\n", + "0 0.010446\n", + "1 0.007193\n", + "2 0.011988\n", + "3 0.020931\n", + "4 0.047373\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "T2t = (df.t / 20)**2\n", + "uT2t = 2 * (df.t / 20) * (df.ut / 20)\n", + "\n", + "print(T2t)\n", + "print(uT2t)" + ] + }, + { + "cell_type": "markdown", + "id": "8d097869", + "metadata": {}, + "source": [ + "## Calcolo dei K e media pesata" + ] + }, + { + "cell_type": "code", + "execution_count": 639, + "id": "99bc83a7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 3481.378680\n", + "1 3520.884276\n", + "2 3558.947648\n", + "3 3591.253438\n", + "4 3515.263991\n", + "dtype: float64\n", + "0 58.960824\n", + "1 30.349344\n", + "2 40.869090\n", + "3 60.110320\n", + "4 110.836582\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "Adt = T2t / Meq\n", + "uAdt = np.sqrt( (1/Meq)**2 * uT2t**2 + (T2t/Meq**2)**2 * uMeq**2 )\n", + "\n", + "Kdt = 4 * np.pi**2 / Adt\n", + "uKdt = (4 * np.pi**2 / Adt**2) * uAdt\n", + "\n", + "Kdt\n", + "uKdt\n", + "\n", + "print(Kdt)\n", + "print(uKdt)" + ] + }, + { + "cell_type": "code", + "execution_count": 640, + "id": "ae55d12a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "K-medio (t): 3.533948573536872\n", + "sigmaC (t): 0.02071589620414334\n" + ] + } + ], + "source": [ + "KdtM, uKdtM = mediaPesata(Kdt, uKdt)\n", + "KdtM /= 1e3\n", + "uKdtM /= 1e3\n", + "print(\"K-medio (t):\", KdtM)\n", + "print(\"sigmaC (t):\", uKdtM)" + ] + }, + { + "cell_type": "markdown", + "id": "634a06e9", + "metadata": {}, + "source": [ + "## Analisi con regressioni e grafici" + ] + }, + { + "cell_type": "code", + "execution_count": 641, + "id": "75e94b0a", + "metadata": {}, + "outputs": [], + "source": [ + "datat = pd.DataFrame({\n", + " \"x\": Meq,\n", + " \"ux\": uMeq,\n", + " \"y\": T2t,\n", + " \"uy\": uT2t\n", + "})" + ] + }, + { + "cell_type": "markdown", + "id": "e7761130", + "metadata": {}, + "source": [ + "### Regressione lineare \"OLS\"\n", + "Non tiene conto dei nostri errori, un risultato puro e semplice" + ] + }, + { + "cell_type": "code", + "execution_count": 642, + "id": "896388e2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " OLS Regression Results \n", + "==============================================================================\n", + "Dep. Variable: y R-squared: 0.999\n", + "Model: OLS Adj. R-squared: 0.998\n", + "Method: Least Squares F-statistic: 2631.\n", + "Date: Sun, 05 Apr 2026 Prob (F-statistic): 1.63e-05\n", + "Time: 21:52:54 Log-Likelihood: 15.713\n", + "No. Observations: 5 AIC: -27.43\n", + "Df Residuals: 3 BIC: -28.21\n", + "Df Model: 1 \n", + "Covariance Type: nonrobust \n", + "==============================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "const 0.0107 0.021 0.506 0.648 -0.057 0.078\n", + "x 0.0110 0.000 51.298 0.000 0.010 0.012\n", + "==============================================================================\n", + "Omnibus: nan Durbin-Watson: 2.074\n", + "Prob(Omnibus): nan Jarque-Bera (JB): 0.262\n", + "Skew: -0.213 Prob(JB): 0.877\n", + "Kurtosis: 1.963 Cond. No. 344.\n", + "==============================================================================\n", + "\n", + "Notes:\n", + "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", + "\n", + "RISULTATI REGRESSIONE OLS (t):\n", + "Atols = 0.01104 ± 0.00022\n", + "Btols = 0.01070 ± 0.02113\n", + "R² = 0.99886\n", + "Kdtols = 3.57541 ± 0.06970\n", + "KBdtols = 3.69021 ± 7.28924\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jack/uni/lab/.venv/lib/python3.13/site-packages/statsmodels/stats/stattools.py:74: ValueWarning: omni_normtest is not valid with less than 8 observations; 5 samples were given.\n", + " warn(\"omni_normtest is not valid with less than 8 observations; %i \"\n" + ] + } + ], + "source": [ + "X = sm.add_constant(datat[\"x\"])\n", + "model = sm.OLS(datat[\"y\"], X).fit()\n", + "\n", + "print(model.summary())\n", + "\n", + "Btols = model.params[\"const\"]\n", + "Atols = model.params[\"x\"]\n", + "uBtols = model.bse[\"const\"]\n", + "uAtols = model.bse[\"x\"]\n", + "R2t = model.rsquared\n", + "\n", + "Kdtols = 4 * np.pi**2 / Atols / 1000\n", + "uKdtols = (4 * np.pi**2 / Atols**2) * uAtols / 1000\n", + "KBdtols = 4 * np.pi**2 / Btols / 1000\n", + "uKBdtols = (4 * np.pi**2 / Btols**2) * uBtols / 1000\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE OLS (t):\")\n", + "print(f\"Atols = {Atols:.5f} ± {uAtols:.5f}\")\n", + "print(f\"Btols = {Btols:.5f} ± {uBtols:.5f}\")\n", + "print(f\"R² = {R2t:.5f}\")\n", + "print(f\"Kdtols = {Kdtols:.5f} ± {uKdtols:.5f}\")\n", + "print(f\"KBdtols = {KBdtols:.5f} ± {uKBdtols:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 643, + "id": "61e40e4c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "sns.scatterplot(data=datat, x=\"x\", y=\"y\", s=7)\n", + "\n", + "plt.errorbar(\n", + " datat[\"x\"], datat[\"y\"],\n", + " xerr=datat[\"ux\"], yerr=datat[\"uy\"],\n", + " fmt=\"none\", ecolor=\"gray\", elinewidth=1, capsize=3, alpha=0.7\n", + ")\n", + "\n", + "xfit = np.linspace(0, datat[\"x\"].max(), 200)\n", + "yfit = Btols + Atols * xfit\n", + "\n", + "plt.plot(xfit, yfit, color=\"crimson\", linewidth=1, zorder=10, label=\"Fit OLS t\")\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "plt.xlabel(\"Meq (g)\")\n", + "plt.ylabel(\"T² (s²)\")\n", + "plt.title(\"Legge di ?? — cronometro\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 644, + "id": "354687ec", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chi² = 1.29720\n", + "GdL = 3\n", + "Chi² rid = 0.43240\n", + "P(0, chi²)= 0.27020\n", + "\n", + "\n", + "############################################################\n", + "capiamo quale dato sta contribuendo maggiormente\n", + "0 0.279626\n", + "1 0.079511\n", + "2 0.241451\n", + "3 0.601922\n", + "4 0.094687\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "F_fit = Btols + Atols * datat[\"x\"]\n", + "sigma = np.sqrt(datat[\"uy\"]**2 + (Atols * datat[\"ux\"])**2)\n", + "\n", + "chi2_val = np.sum(((datat[\"y\"] - F_fit) / sigma)**2)\n", + "\n", + "N = len(datat)\n", + "nut = N - 2\n", + "\n", + "chi2_red = chi2_val / nut\n", + "Ptols = chi2.cdf(chi2_val, df=nut)\n", + "\n", + "print(f\"Chi² = {chi2_val:.5f}\")\n", + "print(f\"GdL = {nut}\")\n", + "print(f\"Chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {Ptols:.5f}\")\n", + "print(\"\\n\\n\" + \"#\"*60)\n", + "print(\"capiamo quale dato sta contribuendo maggiormente\")\n", + "print(((datat[\"y\"] - F_fit) / sigma)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "c28f2d34", + "metadata": {}, + "source": [ + "### Regressione lineare Carpi" + ] + }, + { + "cell_type": "code", + "execution_count": 645, + "id": "8d6cd1df", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ax + B (Carpi, t):\n", + "AtC = 0.01078 ± 0.00030\n", + "BtC = 0.03084 ± 0.02321\n", + "cov_ABtC = -0.000007\n", + "P(0,chi²)= 0.08857\n", + "KdtC = 3.66092 ± 0.10078\n", + "KBdtC = 1.28007 ± 0.96319\n" + ] + } + ], + "source": [ + "AtC, BtC, uAtC, uBtC, covABtC, chitC = reg_lin(datat[\"x\"], datat[\"y\"], datat[\"ux\"], datat[\"uy\"])\n", + "\n", + "KdtC = 4 * np.pi**2 / AtC / 1000\n", + "uKdtC = (4 * np.pi**2 / AtC**2) * uAtC / 1000\n", + "KBdtC = 4 * np.pi**2 / BtC / 1000\n", + "uKBdtC = (4 * np.pi**2 / BtC**2) * uBtC / 1000\n", + "\n", + "print(\"Ax + B (Carpi, t):\")\n", + "print(f\"AtC = {AtC:.5f} ± {uAtC:.5f}\")\n", + "print(f\"BtC = {BtC:.5f} ± {uBtC:.5f}\")\n", + "print(f\"cov_ABtC = {covABtC:.6f}\")\n", + "print(f\"P(0,chi²)= {chitC:.5f}\")\n", + "print(f\"KdtC = {KdtC:.5f} ± {uKdtC:.5f}\")\n", + "print(f\"KBdtC = {KBdtC:.5f} ± {uKBdtC:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 646, + "id": "592c257c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "sns.scatterplot(data=datat, x=\"x\", y=\"y\", s=7)\n", + "\n", + "plt.errorbar(\n", + " datat[\"x\"], datat[\"y\"],\n", + " xerr=datat[\"ux\"], yerr=datat[\"uy\"],\n", + " fmt=\"none\", ecolor=\"gray\", elinewidth=1, capsize=3, alpha=0.7\n", + ")\n", + "\n", + "xfit = np.linspace(0, datat[\"x\"].max(), 200)\n", + "yfit = BtC + AtC * xfit\n", + "\n", + "plt.plot(xfit, yfit, color=\"crimson\", linewidth=1, zorder=10, label=\"Fit Carpi (t)\")\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "plt.xlabel(\"Meq (g)\")\n", + "plt.ylabel(\"T² (s²)\")\n", + "plt.title(\"Legge di Hooke dinamica — cronometro\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 647, + "id": "12f276cc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chi² = 0.53371\n", + "GdL = 3\n", + "Chi² rid = 0.17790\n", + "P(0, chi²)= 0.08857\n", + "\n", + "\n", + "############################################################\n", + "capiamo quale dato sta contribuendo maggiormente\n", + "0 0.003198\n", + "1 0.022511\n", + "2 0.021599\n", + "3 0.113281\n", + "4 0.373119\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "F_fit = BtC + AtC * datat[\"x\"]\n", + "sigma = np.sqrt(datat[\"uy\"]**2 + (AtC * datat[\"ux\"])**2)\n", + "chi2_val = np.sum(((datat[\"y\"] - F_fit) / sigma)**2)\n", + "chi2_red = chi2_val / nut\n", + "PtC = chi2.cdf(chi2_val, df=nut)\n", + "\n", + "print(f\"Chi² = {chi2_val:.5f}\")\n", + "print(f\"GdL = {nut}\")\n", + "print(f\"Chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {PtC:.5f}\")\n", + "print(\"\\n\\n\" + \"#\"*60)\n", + "print(\"capiamo quale dato sta contribuendo maggiormente\")\n", + "print(((datat[\"y\"] - F_fit) / sigma)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "0823cca1", + "metadata": {}, + "source": [ + "### Regressione lineare pesata Yorkfit" + ] + }, + { + "cell_type": "code", + "execution_count": 648, + "id": "d04ee20e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AtY = 0.0107837 ± 0.0002969\n", + "BtY = 0.0308408 ± 0.0232061\n", + "cov_ABtY = -6.719211797637951e-06\n", + "chi² = 0.53371\n", + "chi² rid = 0.17790\n", + "P(0, chi²)= 0.08857\n", + "KdtY = 3.66092 ± 0.10078\n", + "KBdtY = 1.28007 ± 0.96319\n" + ] + } + ], + "source": [ + "AtY, BtY, uAtY, uBtY, cov_ABtY, chi2_val_t, chi2_red_t = york_fit(datat.x, datat.y, datat.ux, datat.uy)\n", + "PtY = chi2.cdf(chi2_val_t, df=nut)\n", + "\n", + "KdtY = 4 * np.pi**2 / AtY / 1000\n", + "uKdtY = (4 * np.pi**2 / AtY**2) * uAtY / 1000\n", + "KBdtY = 4 * np.pi**2 / BtY / 1000\n", + "uKBdtY = (4 * np.pi**2 / BtY**2) * uBtY / 1000\n", + "\n", + "print(f\"AtY = {AtY:.7f} ± {uAtY:.7f}\")\n", + "print(f\"BtY = {BtY:.7f} ± {uBtY:.7f}\")\n", + "print(f\"cov_ABtY = {cov_ABtY}\")\n", + "print(f\"chi² = {chi2_val_t:.5f}\")\n", + "print(f\"chi² rid = {chi2_red_t:.5f}\")\n", + "print(f\"P(0, chi²)= {PtY:.5f}\")\n", + "print(f\"KdtY = {KdtY:.5f} ± {uKdtY:.5f}\")\n", + "print(f\"KBdtY = {KBdtY:.5f} ± {uKBdtY:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 649, + "id": "e795e732", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "sns.scatterplot(data=datat, x=\"x\", y=\"y\", s=7)\n", + "\n", + "plt.errorbar(\n", + " datat[\"x\"], datat[\"y\"],\n", + " xerr=datat[\"ux\"], yerr=datat[\"uy\"],\n", + " fmt=\"none\", ecolor=\"gray\", elinewidth=1, capsize=3, alpha=0.7\n", + ")\n", + "\n", + "xfit = np.linspace(0, datat[\"x\"].max(), 200)\n", + "yfit = BtY + AtY * xfit\n", + "\n", + "plt.plot(xfit, yfit, color=\"crimson\", linewidth=1, zorder=10, label=\"Fit York (t)\")\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "plt.xlabel(\"Meq (g)\")\n", + "plt.ylabel(\"T² (s²)\")\n", + "plt.title(\"Legge di Hooke dinamica — cronometro\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "038b2684", + "metadata": {}, + "source": [ + "## Raccolta finale di dati dinamici col cronometro" + ] + }, + { + "cell_type": "code", + "execution_count": 650, + "id": "46ef07bd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RISULTATI senza ERRORE STRUMENTALE (cronometro):\n", + "Media pesata K = 3.53395 ± 0.02072\n", + "\n", + "RISULTATI REGRESSIONE OLS:\n", + "Atols = 0.01104 ± 0.00022\n", + "Btols = 0.01070 ± 0.02113\n", + "P(0,chi²)= 0.27020\n", + "Kdtols = 3.57541 ± 0.06970\n", + "KBdtols = 3.69021 ± 7.28924\n", + "\n", + "RISULTATI REGRESSIONE Carpi:\n", + "AtC = 0.01078 ± 0.00030\n", + "BtC = 0.03084 ± 0.02321\n", + "P(0,chi²)= 0.08857\n", + "KdtC = 3.66092 ± 0.10078\n", + "KBdtC = 1.28007 ± 0.96319\n", + "\n", + "RISULTATI REGRESSIONE York:\n", + "AtY = 0.01078 ± 0.00030\n", + "BtY = 0.03084 ± 0.02321\n", + "P(0,chi²)= 0.08857\n", + "KdtY = 3.66092 ± 0.10078\n", + "KBdtY = 1.28007 ± 0.96319\n" + ] + } + ], + "source": [ + "print(\"RISULTATI senza ERRORE STRUMENTALE (cronometro):\")\n", + "print(f\"Media pesata K = {KdtM:.5f} ± {uKdtM:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE OLS:\")\n", + "print(f\"Atols = {Atols:.5f} ± {uAtols:.5f}\")\n", + "print(f\"Btols = {Btols:.5f} ± {uBtols:.5f}\")\n", + "print(f\"P(0,chi²)= {Ptols:.5f}\")\n", + "print(f\"Kdtols = {Kdtols:.5f} ± {uKdtols:.5f}\")\n", + "print(f\"KBdtols = {KBdtols:.5f} ± {uKBdtols:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE Carpi:\")\n", + "print(f\"AtC = {AtC:.5f} ± {uAtC:.5f}\")\n", + "print(f\"BtC = {BtC:.5f} ± {uBtC:.5f}\")\n", + "print(f\"P(0,chi²)= {PtC:.5f}\")\n", + "print(f\"KdtC = {KdtC:.5f} ± {uKdtC:.5f}\")\n", + "print(f\"KBdtC = {KBdtC:.5f} ± {uKBdtC:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE York:\")\n", + "print(f\"AtY = {AtY:.5f} ± {uAtY:.5f}\")\n", + "print(f\"BtY = {BtY:.5f} ± {uBtY:.5f}\")\n", + "print(f\"P(0,chi²)= {PtY:.5f}\")\n", + "print(f\"KdtY = {KdtY:.5f} ± {uKdtY:.5f}\")\n", + "print(f\"KBdtY = {KBdtY:.5f} ± {uKBdtY:.5f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "70201336", + "metadata": {}, + "source": [ + "## Aggiungi gli errori strumentali" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dfcd391e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "res_t = 0.000500\n", + "res_t2 = 0.024515\n", + "res_uAdt = 0.000451\n", + "uKdt_strum = 0.147238\n" + ] + } + ], + "source": [ + "res_t = 0.01 / 20 # risoluzione cronometro\n", + "res_t2 = np.max(2 * df.t * res_t)\n", + "\n", + "res_uAdt = np.max(np.sqrt( (1 / Meq)**2* res_t2**2 +(T2t / Meq**2)**2 * res_b**2))\n", + "uKdt_strum = np.max(np.abs(4 * np.pi**2 / Adt**2) * res_uAdt) / 1000\n", + "\n", + "print(f\"res_t = {res_t:.6f}\")\n", + "print(f\"res_t2 = {res_t2:.6f}\")\n", + "print(f\"res_uAdt = {res_uAdt:.6f}\")\n", + "print(f\"uKdt_strum = {uKdt_strum:.6f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 652, + "id": "b52fea3d", + "metadata": {}, + "outputs": [], + "source": [ + "uKdtM_fin = np.sqrt(uKdtM**2 + uKdt_strum**2)\n", + "\n", + "uAtols_fin = np.sqrt(uAtols**2 + res_uAdt**2)\n", + "uBtols_fin = np.sqrt(uBtols**2 + res_uAdt**2)\n", + "uKdtols_fin = np.sqrt(uKdtols**2 + uKdt_strum**2)\n", + "\n", + "uAtC_fin = np.sqrt(uAtC**2 + res_uAdt**2)\n", + "uBtC_fin = np.sqrt(uBtC**2 + res_uAdt**2)\n", + "uKdtC_fin = np.sqrt(uKdtC**2 + uKdt_strum**2)\n", + "\n", + "uAtY_fin = np.sqrt(uAtY**2 + res_uAdt**2)\n", + "uBtY_fin = np.sqrt(uBtY**2 + res_uAdt**2)\n", + "uKdtY_fin = np.sqrt(uKdtY**2 + uKdt_strum**2)\n", + "\n", + "uy_fin_t = np.sqrt(datat[\"uy\"]**2 + res_t2**2)\n", + "ux_fin_t = np.sqrt(datat[\"ux\"]**2 + res_b**2)\n", + "\n", + "GdLt = len(datat) - 2\n", + "\n", + "F_fit_tols = Btols + Atols * datat[\"x\"]\n", + "sigma_tols = np.sqrt(uy_fin_t**2 + (Atols * ux_fin_t)**2)\n", + "chi2_tols = np.sum(((datat[\"y\"] - F_fit_tols) / sigma_tols)**2)\n", + "\n", + "F_fit_tC = BtC + AtC * datat[\"x\"]\n", + "sigma_tC = np.sqrt(uy_fin_t**2 + (AtC * ux_fin_t)**2)\n", + "chi2_tC = np.sum(((datat[\"y\"] - F_fit_tC) / sigma_tC)**2)\n", + "\n", + "F_fit_tY = BtY + AtY * datat[\"x\"]\n", + "sigma_tY = np.sqrt(uy_fin_t**2 + (AtY * ux_fin_t)**2)\n", + "chi2_tY = np.sum(((datat[\"y\"] - F_fit_tY) / sigma_tY)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "858bbff7", + "metadata": {}, + "source": [ + "## Risultati della propagazione dell'errore" + ] + }, + { + "cell_type": "code", + "execution_count": 653, + "id": "0b1e4a1d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RISULTATI CON ERRORE STRUMENTALE (cronometro):\n", + "Media pesata K = 3.53395 ± 0.14869\n", + "\n", + "RISULTATI OLS:\n", + "Atols = 0.01104 ± 0.00050\n", + "Btols = 0.01070 ± 0.02114\n", + "Kdtols = 3.57541 ± 0.16290\n", + "Chi² = 0.42434 | rid = 0.14145 | P = 0.06483\n", + "\n", + "RISULTATI Carpi:\n", + "AtC = 0.01078 ± 0.00054\n", + "BtC = 0.03084 ± 0.02321\n", + "KdtC = 3.66092 ± 0.17842\n", + "Chi² = 0.34851 | rid = 0.11617 | P = 0.04934\n", + "\n", + "RISULTATI York:\n", + "AtY = 0.01078 ± 0.00054\n", + "BtY = 0.03084 ± 0.02321\n", + "KdtY = 3.66092 ± 0.17842\n", + "Chi² = 0.34851 | rid = 0.11617 | P = 0.04934\n" + ] + } + ], + "source": [ + "print(\"RISULTATI CON ERRORE STRUMENTALE (cronometro):\")\n", + "print(f\"Media pesata K = {KdtM:.5f} ± {uKdtM_fin:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI OLS:\")\n", + "print(f\"Atols = {Atols:.5f} ± {uAtols_fin:.5f}\")\n", + "print(f\"Btols = {Btols:.5f} ± {uBtols_fin:.5f}\")\n", + "print(f\"Kdtols = {Kdtols:.5f} ± {uKdtols_fin:.5f}\")\n", + "print(f\"Chi² = {chi2_tols:.5f} | rid = {chi2_tols/GdLt:.5f} | P = {chi2.cdf(chi2_tols, GdLt):.5f}\")\n", + "\n", + "print(\"\\nRISULTATI Carpi:\")\n", + "print(f\"AtC = {AtC:.5f} ± {uAtC_fin:.5f}\")\n", + "print(f\"BtC = {BtC:.5f} ± {uBtC_fin:.5f}\")\n", + "print(f\"KdtC = {KdtC:.5f} ± {uKdtC_fin:.5f}\")\n", + "print(f\"Chi² = {chi2_tC:.5f} | rid = {chi2_tC/GdLt:.5f} | P = {chi2.cdf(chi2_tC, GdLt):.5f}\")\n", + "\n", + "print(\"\\nRISULTATI York:\")\n", + "print(f\"AtY = {AtY:.5f} ± {uAtY_fin:.5f}\")\n", + "print(f\"BtY = {BtY:.5f} ± {uBtY_fin:.5f}\")\n", + "print(f\"KdtY = {KdtY:.5f} ± {uKdtY_fin:.5f}\")\n", + "print(f\"Chi² = {chi2_tY:.5f} | rid = {chi2_tY/GdLt:.5f} | P = {chi2.cdf(chi2_tY, GdLt):.5f}\")" ] } ], diff --git a/molla/dinamica/ripara.py b/molla/dinamica/ripara.py index 34349c5..aaf6624 100644 --- a/molla/dinamica/ripara.py +++ b/molla/dinamica/ripara.py @@ -16,7 +16,6 @@ def replace_every_second_comma(text, replacement=","): return "".join(result) -# Esempio d'uso csv_line1 = "49,25,9,7171,0,016,7,6565,0,0004,484,455,0,011,15,62,8,911,0,015,7,6569,0,0004,484,516,0,011,15,58,10,446,0,027,7,6603,0,0005,485,082,0,019,15,76,8,377,0,016,7,6582,0,0004,484,752,0,011,15,87" csv_line2 = "69,28,9,860,0,016,6,55968,0,00029,423,352,0,011,18,31,10,390,0,012,6,55891,0,00022,423,154,0,009,18,27,10,491,0,013,6,56002,0,00024,423,697,0,01,18,34,10,968,0,019,6,56,0,0003,423,465,0,014,18,16" csv_line3 = "88,97,11,584,0,014,5,84417,0,0002,363,229,0,01,20,27,10,1763,0,017,5,84585,0,00028,363,354,0,012,20,44,12,044,0,018,5,845,0,00026,363,183,0,013,20,54,11,224,0,016,5,84513,0,00025,363,233,0,011,20,49" @@ -33,4 +32,3 @@ for csv_line in csv_lines: with open("miofile.txt", "a", encoding="utf-8") as f: f.write(fixed_line) f.write("\n") - \ No newline at end of file diff --git a/molla/statica/mollaStatica1.ipynb b/molla/statica/mollaStatica1.ipynb index eda7072..d6ab88b 100644 --- a/molla/statica/mollaStatica1.ipynb +++ b/molla/statica/mollaStatica1.ipynb @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 58, "id": "f34c5b88", "metadata": {}, "outputs": [], @@ -51,7 +51,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 59, "id": "08efb2be", "metadata": {}, "outputs": [], @@ -86,7 +86,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 60, "id": "5494409f", "metadata": {}, "outputs": [ @@ -215,7 +215,7 @@ "4 168.53 0.002887 " ] }, - "execution_count": 3, + "execution_count": 60, "metadata": {}, "output_type": "execute_result" } @@ -226,7 +226,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 61, "id": "976d5531", "metadata": {}, "outputs": [ @@ -282,7 +282,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 62, "id": "2ad19283", "metadata": {}, "outputs": [ @@ -311,7 +311,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 63, "id": "5f59d6c9", "metadata": {}, "outputs": [ @@ -360,7 +360,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 64, "id": "7e75ec05", "metadata": {}, "outputs": [], @@ -387,7 +387,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 65, "id": "aefe7756", "metadata": {}, "outputs": [ @@ -400,8 +400,8 @@ "Dep. Variable: y R-squared: 1.000\n", "Model: OLS Adj. R-squared: 1.000\n", "Method: Least Squares F-statistic: 2.238e+04\n", - "Date: Fri, 03 Apr 2026 Prob (F-statistic): 4.46e-15\n", - "Time: 15:28:32 Log-Likelihood: -27.238\n", + "Date: Sat, 04 Apr 2026 Prob (F-statistic): 4.46e-15\n", + "Time: 19:37:55 Log-Likelihood: -27.238\n", "No. Observations: 10 AIC: 58.48\n", "Df Residuals: 8 BIC: 59.08\n", "Df Model: 1 \n", @@ -449,7 +449,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 66, "id": "1d42b009", "metadata": {}, "outputs": [ @@ -515,7 +515,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 67, "id": "986ff4a6", "metadata": {}, "outputs": [ @@ -577,7 +577,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 68, "id": "2d4b7144", "metadata": {}, "outputs": [ @@ -586,8 +586,8 @@ "output_type": "stream", "text": [ "Ax + B : \n", - "AC = 24.0474 +- 0.1316\n", - "BC = -1.5698 +- 2.0811\n", + "AC = 24.0474 ± 0.1316\n", + "BC = -1.5698 ± 2.0811\n", "cov_ABC = -0.246370\n", "P(0, chi²)= 0.9979\n" ] @@ -645,15 +645,15 @@ "\n", "AC, BC, uAC, uBC, covABC, chiC = reg_lin(data[\"x\"], data[\"y\"], data[\"ux\"], data[\"uy\"])\n", "print(\"Ax + B : \")\n", - "print(f\"AC = {AC:.4f} +- {uAC:.4f}\")\n", - "print(f\"BC = {BC:.4f} +- {uBC:.4f}\")\n", + "print(f\"AC = {AC:.4f} ± {uAC:.4f}\")\n", + "print(f\"BC = {BC:.4f} ± {uBC:.4f}\")\n", "print(f\"cov_ABC = {covABC:.6f}\")\n", "print(f\"P(0, chi²)= {chiC:.4f}\")\n" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 69, "id": "e2407a04", "metadata": {}, "outputs": [ @@ -722,7 +722,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 70, "id": "32e9948f", "metadata": {}, "outputs": [ @@ -785,7 +785,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 71, "id": "bfb895c6", "metadata": {}, "outputs": [ @@ -868,7 +868,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 72, "id": "202de438", "metadata": {}, "outputs": [ @@ -942,7 +942,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 73, "id": "caf23dbe", "metadata": {}, "outputs": [ @@ -950,6 +950,8 @@ "name": "stdout", "output_type": "stream", "text": [ + "RISULTATI senza ERRORE STRUMENTALE INCLUSO:\n", + "Media pesata K = 23.95113 ± 0.05732\n", "\n", "RISULTATI REGRESSIONE OLS:\n", "Aols = 23.96871 ± 0.16022\n", @@ -969,9 +971,10 @@ } ], "source": [ - "print(\"\")\n", + "print(\"RISULTATI senza ERRORE STRUMENTALE INCLUSO:\")\n", + "print(f\"Media pesata K = {media:.5f} ± {uA:.5f}\")\n", "\n", - "print(\"RISULTATI REGRESSIONE OLS:\")\n", + "print(\"\\nRISULTATI REGRESSIONE OLS:\")\n", "print(f\"Aols = {Aols:.5f} ± {uAols:.5f}\")\n", "print(f\"Bols = {Bols:.5f} ± {uBols:.5f}\")\n", "print(f\"P(0, chi²)= {Pols:.5f}\")\n", @@ -997,7 +1000,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 74, "id": "8f5c8bb7", "metadata": {}, "outputs": [ @@ -1046,7 +1049,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 75, "id": "a1dc24c9", "metadata": {}, "outputs": [], @@ -1098,7 +1101,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 76, "id": "c8e264fa", "metadata": {}, "outputs": [ diff --git a/molla/statica/mollaStatica2.ipynb b/molla/statica/mollaStatica2.ipynb index d840a8c..f09bde9 100644 --- a/molla/statica/mollaStatica2.ipynb +++ b/molla/statica/mollaStatica2.ipynb @@ -5,7 +5,7 @@ "id": "3a8dfc0e", "metadata": {}, "source": [ - "# Analisi della molla statica 2" + "# Analisi della molla statica con calibro 2" ] }, { @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 141, + "execution_count": 82, "id": "f34c5b88", "metadata": {}, "outputs": [], @@ -51,7 +51,7 @@ }, { "cell_type": "code", - "execution_count": 142, + "execution_count": 83, "id": "08efb2be", "metadata": {}, "outputs": [], @@ -86,7 +86,7 @@ }, { "cell_type": "code", - "execution_count": 143, + "execution_count": 84, "id": "5494409f", "metadata": {}, "outputs": [ @@ -199,7 +199,7 @@ "3 0.188750 108.610000 0.002887 " ] }, - "execution_count": 143, + "execution_count": 84, "metadata": {}, "output_type": "execute_result" } @@ -210,7 +210,7 @@ }, { "cell_type": "code", - "execution_count": 144, + "execution_count": 85, "id": "976d5531", "metadata": {}, "outputs": [ @@ -265,7 +265,7 @@ }, { "cell_type": "code", - "execution_count": 145, + "execution_count": 86, "id": "2ad19283", "metadata": {}, "outputs": [ @@ -292,7 +292,7 @@ }, { "cell_type": "code", - "execution_count": 146, + "execution_count": 87, "id": "5f59d6c9", "metadata": {}, "outputs": [ @@ -341,7 +341,7 @@ }, { "cell_type": "code", - "execution_count": 147, + "execution_count": 88, "id": "7e75ec05", "metadata": {}, "outputs": [], @@ -368,7 +368,7 @@ }, { "cell_type": "code", - "execution_count": 148, + "execution_count": 89, "id": "aefe7756", "metadata": {}, "outputs": [ @@ -381,8 +381,8 @@ "Dep. Variable: y R-squared: 1.000\n", "Model: OLS Adj. R-squared: 1.000\n", "Method: Least Squares F-statistic: 1.277e+05\n", - "Date: Fri, 03 Apr 2026 Prob (F-statistic): 3.68e-10\n", - "Time: 15:05:08 Log-Likelihood: -7.2422\n", + "Date: Sat, 04 Apr 2026 Prob (F-statistic): 3.68e-10\n", + "Time: 19:38:07 Log-Likelihood: -7.2422\n", "No. Observations: 6 AIC: 18.48\n", "Df Residuals: 4 BIC: 18.07\n", "Df Model: 1 \n", @@ -438,7 +438,7 @@ }, { "cell_type": "code", - "execution_count": 149, + "execution_count": 90, "id": "1d42b009", "metadata": {}, "outputs": [ @@ -504,7 +504,7 @@ }, { "cell_type": "code", - "execution_count": 150, + "execution_count": 91, "id": "986ff4a6", "metadata": {}, "outputs": [ @@ -562,7 +562,7 @@ }, { "cell_type": "code", - "execution_count": 151, + "execution_count": 92, "id": "2d4b7144", "metadata": {}, "outputs": [ @@ -571,8 +571,8 @@ "output_type": "stream", "text": [ "Ax + B : \n", - "AC = 3.2005 +- 0.0092\n", - "BC = 0.1195 +- 0.9524\n", + "AC = 3.2005 ± 0.0092\n", + "BC = 0.1195 ± 0.9524\n", "cov_ABC = -0.007942\n", "P(0, chi²)= 0.4020\n" ] @@ -630,15 +630,15 @@ "\n", "AC, BC, uAC, uBC, covABC, chiC = reg_lin(data[\"x\"], data[\"y\"], data[\"ux\"], data[\"uy\"])\n", "print(\"Ax + B : \")\n", - "print(f\"AC = {AC:.4f} +- {uAC:.4f}\")\n", - "print(f\"BC = {BC:.4f} +- {uBC:.4f}\")\n", + "print(f\"AC = {AC:.4f} ± {uAC:.4f}\")\n", + "print(f\"BC = {BC:.4f} ± {uBC:.4f}\")\n", "print(f\"cov_ABC = {covABC:.6f}\")\n", "print(f\"P(0, chi²)= {chiC:.4f}\")\n" ] }, { "cell_type": "code", - "execution_count": 152, + "execution_count": 93, "id": "e2407a04", "metadata": {}, "outputs": [ @@ -707,7 +707,7 @@ }, { "cell_type": "code", - "execution_count": 153, + "execution_count": 94, "id": "32e9948f", "metadata": {}, "outputs": [ @@ -766,7 +766,7 @@ }, { "cell_type": "code", - "execution_count": 154, + "execution_count": 95, "id": "bfb895c6", "metadata": {}, "outputs": [ @@ -849,7 +849,7 @@ }, { "cell_type": "code", - "execution_count": 155, + "execution_count": 96, "id": "202de438", "metadata": {}, "outputs": [ @@ -923,7 +923,7 @@ }, { "cell_type": "code", - "execution_count": 160, + "execution_count": 97, "id": "caf23dbe", "metadata": {}, "outputs": [ @@ -931,6 +931,8 @@ "name": "stdout", "output_type": "stream", "text": [ + "RISULTATI senza ERRORE STRUMENTALE INCLUSO:\n", + "Media pesata K = 3.20156 ± 0.00386\n", "\n", "RISULTATI REGRESSIONE OLS:\n", "Aols = 3.20145 ± 0.00896\n", @@ -950,9 +952,10 @@ } ], "source": [ - "print(\"\")\n", + "print(\"RISULTATI senza ERRORE STRUMENTALE INCLUSO:\")\n", + "print(f\"Media pesata K = {media:.5f} ± {uA:.5f}\")\n", "\n", - "print(\"RISULTATI REGRESSIONE OLS:\")\n", + "print(\"\\nRISULTATI REGRESSIONE OLS:\")\n", "print(f\"Aols = {Aols:.5f} ± {uAols:.5f}\")\n", "print(f\"Bols = {Bols:.5f} ± {uBols:.5f}\")\n", "print(f\"P(0, chi²)= {Pols:.5f}\")\n", @@ -978,7 +981,7 @@ }, { "cell_type": "code", - "execution_count": 157, + "execution_count": 98, "id": "8f5c8bb7", "metadata": {}, "outputs": [ @@ -1027,7 +1030,7 @@ }, { "cell_type": "code", - "execution_count": 158, + "execution_count": 99, "id": "a1dc24c9", "metadata": {}, "outputs": [], @@ -1074,12 +1077,12 @@ "id": "2e57c7d8", "metadata": {}, "source": [ - "## Risutltati della propagazione dell'errore strumentale massimo" + "## Risultati della propagazione dell'errore strumentale massimo" ] }, { "cell_type": "code", - "execution_count": 164, + "execution_count": 100, "id": "c8e264fa", "metadata": {}, "outputs": [