diff --git a/molla/compatibilita/comp1.ipynb b/molla/compatibilita/comp1.ipynb new file mode 100644 index 0000000..2127e4c --- /dev/null +++ b/molla/compatibilita/comp1.ipynb @@ -0,0 +1,99 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "ba4e56bc", + "metadata": {}, + "source": [ + "## Valori dinamici\n", + "N = 10\n", + "\n", + "A = 23.96 +- 0.16 " + ] + }, + { + "cell_type": "markdown", + "id": "aaf30c1f", + "metadata": {}, + "source": [ + "## Valori statici\n", + "N = 6\n", + "\n", + "A = 23.46 +- 0.23\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "b349ba73", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from scipy.stats import t as student_t" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "a68eb302", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "t = 1.717\n", + "p-value (two-tailed) = 10.8084 %\n" + ] + } + ], + "source": [ + "# Valori dimanici (sonar)\n", + "Nd = 10\n", + "Ad = 23.96\n", + "uAd = 0.16 * 3\n", + "\n", + "#Valori statici (calibro)\n", + "Ns = 6\n", + "As = 23.46\n", + "uAs = 0.23 * 3\n", + "\n", + "#Nomi coerenti con Cannelli\n", + "GdL = Nd + Ns - 2\n", + "\n", + "s2 = ( (Nd - 1) * uAd**2 + (Ns - 1) * uAs**2 ) / GdL\n", + "\n", + "sigma2 = ( s2 / Nd ) + ( s2 / Ns )\n", + "\n", + "t = ( Ad - As ) / np.sqrt( sigma2 )\n", + "\n", + "\n", + "p_value = 2 * (1 - student_t.cdf(abs(t), df=GdL))\n", + "print(f\"t = {t:.3f}\")\n", + "print(f\"p-value (two-tailed) = {p_value * 100:.4f} %\")\n" + ] + } + ], + "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/compatibilita/comp2.ipynb b/molla/compatibilita/comp2.ipynb new file mode 100644 index 0000000..3ec4daf --- /dev/null +++ b/molla/compatibilita/comp2.ipynb @@ -0,0 +1,99 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "ba4e56bc", + "metadata": {}, + "source": [ + "## Valori dinamici\n", + "N = 10\n", + "\n", + "A = 3.21951 +- 0.00470 " + ] + }, + { + "cell_type": "markdown", + "id": "aaf30c1f", + "metadata": {}, + "source": [ + "## Valori statici\n", + "N = 6\n", + "\n", + "A = 3.2002 +- 0.0092\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b349ba73", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from scipy.stats import t as student_t" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "a68eb302", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "t = 5.774\n", + "p-value (two-tailed) = 0.0048 %\n" + ] + } + ], + "source": [ + "# Valori dimanici (sonar)\n", + "Nd = 10\n", + "Ad = 3.220\n", + "uAd = 0.005\n", + "\n", + "#Valori statici (calibro)\n", + "Ns = 6\n", + "As = 3.200\n", + "uAs = 0.009\n", + "\n", + "#Nomi coerenti con Cannelli\n", + "GdL = Nd + Ns - 2\n", + "\n", + "s2 = ( (Nd - 1) * uAd**2 + (Ns - 1) * uAs**2 ) / GdL\n", + "\n", + "sigma2 = ( s2 / Nd ) + ( s2 / Ns )\n", + "\n", + "t = ( Ad - As ) / np.sqrt( sigma2 )\n", + "\n", + "\n", + "p_value = 2 * (1 - student_t.cdf(abs(t), df=GdL))\n", + "print(f\"t = {t:.3f}\")\n", + "print(f\"p-value (two-tailed) = {p_value * 100:.4f} %\")\n" + ] + } + ], + "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/dinamica1.csv b/molla/dinamica/dinamica1.csv new file mode 100644 index 0000000..111742b --- /dev/null +++ b/molla/dinamica/dinamica1.csv @@ -0,0 +1,5 @@ +m1,a1,ua1,w1,uw1,c1,uc1,a2,ua2,w2,uw2,c2,uc2 +108.61,9.21,0.029,14.2459,0.0008,268.151,0.02,10.69,0.04,14.2434,0.0009,268.326,0.026 +128.636666666667,10.037,0.025,13.1939,0.0007,259.605,0.018,9.744,0.027,13.1913,0.0009,259.745,0.02 +148.38,9.93,0.03,12.3469,0.0007,251.525,0.021,11.41,0.03,12.3461,0.0006,251.542,0.023 +168.53,11.34,0.03,11.6345,0.0005,243.211,0.021,11.5,0.03,11.6344,0.0006,243.13,0.021 diff --git a/molla/dinamica/dinamica2.csv b/molla/dinamica/dinamica2.csv new file mode 100644 index 0000000..1a240c2 --- /dev/null +++ b/molla/dinamica/dinamica2.csv @@ -0,0 +1,6 @@ +m1,a1,ua1,w1,uw1,c1,uc1,t1,a2,ua2,w2,uw2,c2,uc2,t2,a3,ua3,w3,uw3,c3,uc3,t3,a4,ua4,w4,uw4,c4,uc4,t4 +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 +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 +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 +108.61,11.542,0.026,5.3278,0.0003,303.5502,0.019,22.49,8.424,0.017,5.3282,0.0003,303.581,0.012,22.27,10.501,0.022,5.3296,0.0003,303.842,0.016,22.55,9.959,0.014,5.32822,0.0002,303.445,0.01,22.15 +128.64,11.574,0.020,4.92663,0.00023,242.962,0.014,24.33,11.592,0.023,4.92537,0.00029,242.876,0.017,24.38,10.264,0.023,4.9243,0.0003,242.789,0.017,25.09,9.118,0.021,4.9261,0.0003,243.115,0.015,24.26 diff --git a/molla/dinamica/mollaDinamica1.ipynb b/molla/dinamica/mollaDinamica1.ipynb new file mode 100644 index 0000000..e42ebba --- /dev/null +++ b/molla/dinamica/mollaDinamica1.ipynb @@ -0,0 +1,1231 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 181, + "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", + "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 = 29.89\n", + "um_mol = 0.01" + ] + }, + { + "cell_type": "code", + "execution_count": 182, + "id": "08efb2be", + "metadata": {}, + "outputs": [], + "source": [ + "df = pd.read_csv(r'dinamica1.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.max() - valori.min() ) / 2\n", + " sigma = max(sigma, err_arbitrario) 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.025)\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": 183, + "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", + "
m1a1ua1w1uw1c1uc1a2ua2w2uw2c2uc2wuwmumcucaua
0108.6100009.2100.02914.24590.0008268.1510.02010.6900.04014.24340.0009268.3260.02614.244650.025108.6100000.01268.23850.08759.95000.7400
1128.63666710.0370.02513.19390.0007259.6050.0189.7440.02713.19130.0009259.7450.02013.192600.025128.6366670.01259.67500.07009.89050.1465
2148.3800009.9300.03012.34690.0007251.5250.02111.4100.03012.34610.0006251.5420.02312.346500.025148.3800000.01251.53350.008510.67000.7400
3168.53000011.3400.03011.63450.0005243.2110.02111.5000.03011.63440.0006243.1300.02111.634450.025168.5300000.01243.17050.040511.42000.0800
\n", + "
" + ], + "text/plain": [ + " m1 a1 ua1 w1 uw1 c1 uc1 a2 ua2 \\\n", + "0 108.610000 9.210 0.029 14.2459 0.0008 268.151 0.020 10.690 0.040 \n", + "1 128.636667 10.037 0.025 13.1939 0.0007 259.605 0.018 9.744 0.027 \n", + "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.025 108.610000 0.01 \n", + "1 13.1913 0.0009 259.745 0.020 13.19260 0.025 128.636667 0.01 \n", + "2 12.3461 0.0006 251.542 0.023 12.34650 0.025 148.380000 0.01 \n", + "3 11.6344 0.0006 243.130 0.021 11.63445 0.025 168.530000 0.01 \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 " + ] + }, + "execution_count": 183, + "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": 184, + "id": "976d5531", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]\n", + "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", + "############################################################\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" + ] + } + ], + "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": 185, + "id": "2ad19283", + "metadata": {}, + "outputs": [ + { + "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" + ] + } + ], + "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": 186, + "id": "5f59d6c9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "K-medio: 23.518009860547757\n", + "sigmaC: 0.052106970693817985\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": 187, + "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: 1.044e+04\n", + "Date: Thu, 02 Apr 2026 Prob (F-statistic): 5.50e-08\n", + "Time: 17:16:40 Log-Likelihood: -14.806\n", + "No. Observations: 6 AIC: 33.61\n", + "Df Residuals: 4 BIC: 33.20\n", + "Df Model: 1 \n", + "Covariance Type: nonrobust \n", + "==============================================================================\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", + "==============================================================================\n", + "Omnibus: nan Durbin-Watson: 0.555\n", + "Prob(Omnibus): nan Jarque-Bera (JB): 0.395\n", + "Skew: -0.285 Prob(JB): 0.821\n", + "Kurtosis: 1.880 Cond. No. 37.4\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) = 23.46278 ± 0.22966\n", + "intercetta = 0.13546 ± 3.49489\n", + "R² = 0.99962\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; 6 samples were given.\n", + " warn(\"omni_normtest is not valid with less than 8 observations; %i \"\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": 188, + "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": 189, + "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": 190, + "id": "986ff4a6", + "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": [ + "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": 191, + "id": "ef0817f4", + "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": 191, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "((data[\"F\"] - F_fit) / sigma)**2" + ] + }, + { + "cell_type": "code", + "execution_count": 192, + "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": 192, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data" + ] + }, + { + "cell_type": "code", + "execution_count": 193, + "id": "2d4b7144", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "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" + ] + } + ], + "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": 194, + "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": 195, + "id": "e2407a04", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1wAAAIsCAYAAADmsKixAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAozBJREFUeJzs3Xd4FOXaBvB7drNppJEQQhcCJiAJxUIHaYIUQREBEbFQRAVFxUPoRRREIKEEkFAEAWkCKk1QEUSRo6gQBAuEEjrpPdky3x98uydLQsjuvsnsTu7fdXmdk93Zd5+ZvTPsk5l5R5JlWQYREREREREJp1G6ACIiIiIiIrViw0VERERERFRG2HARERERERGVETZcREREREREZYQNFxERERERURlhw0VERERERFRG2HARERERERGVETZcREREREREZYQNFxERERERURlhw0VEdA/PP/88nn/+ecvPly9fRnh4OLZv365gVaUTFRWF5s2bK12GqoSHh2Px4sVKl6FKnTt3RlRUlNJlqMrzzz+P3r17K10GUYXGhouISm379u0IDw9HfHy80qW4hGPHjiE8PBz79u0r9nk2Q87r0KFDbKqKkZubi8WLF+PYsWN2j/Hbb79h8eLFyMjIEFgZEZHzclO6ACIiV1OzZk2cPHkSbm7charVoUOHsGHDBowZM6bIcydPnoRWq1WgKuXl5uZiyZIlGD16NFq2bGnXGL///juWLFmCp556Cn5+flbP7du3D5IkiSiViMhp8AgXEZGNJEmCh4dHhf3SXdF5eHg4TbOdk5OjdAlCubu7Q6fTKV1GuZBlGXl5ecU+l5+fD5PJ5ND45ZkNg8GAgoKCcns/IlfDhouIhLtx4wYmTJiANm3aICIiAr169cK2bduKLHflyhWMGjUKzZo1Q+vWrfHBBx/ghx9+QHh4eJFTljZs2IAuXbqgSZMm6N+/P3799dci11YBQEFBARYtWoTHHnsMERERePTRRzF37txSfxnYvHkzunbtavU+dyrra7g2bNiAXr16ISIiAu3atcOMGTOKPf1q79696NevH5o0aYKWLVti3LhxuHHjxj3HP3PmDFq1aoXnn38e2dnZAEr/mZUX8zZetWoVPvnkE3Tq1AlNmjTBkCFD8M8//1gtW1wOgNunbHbu3LnYMc2fc0REBJ5++mmcPHnS6nUbNmwAcPt6LfN/ZqW5hst8OumePXuwYMECtG3bFs2aNcOoUaNw7dq1IsufOHECw4YNw0MPPYSmTZtiyJAhOH78uNUyixcvRnh4OM6ePYt33nkHjzzyCAYPHgzg9rVPr7zyCo4dO2bJxBNPPGH5Pdq/fz+eeOIJREZGol+/fjh9+rTN2/Dy5cto3bo1AGDJkiWW7WLeFn/99ReioqLQpUsXREZGom3btpgwYQJSU1Ot1mHu3LkAgC5duljGuHz5smU9SnMNl8lkwtq1ay3r1KpVKwwbNszqdGeDwYDY2FjL59y5c2csWLCgyL7AvO1+/fVX9O/fH5GRkejSpQt27tx5zzrMtXzyySfo1asXIiMj0aZNG0ydOhXp6enFvs8PP/xg+Yw2bdpkycru3bsRHR2N9u3bo2nTpsjKygJQut9z8+nJly5dwogRI9C8eXOMGzfOaplTp05h0KBBaNKkCTp37ozPPvvM6vmCggIsXLgQ/fr1w0MPPYRmzZph8ODB+Pnnn62Wu/N3s2vXroiMjMS5c+dKtb2IKiLn+BMdEalGUlISBgwYAEmS8NxzzyEwMBCHDx/GpEmTkJWVhRdffBHA7b++vvDCC7h16xaGDh2KKlWqYNeuXcVeG7Jx40bMnDkTDz/8MF588UVcuXIFr7/+Ovz8/FCtWjXLciaTCa+++iqOHz+OAQMGoH79+vjnn3+wdu1aXLhwAUuXLi2x9q1bt2Lq1Klo3rw5XnjhBSQmJuLVV1+Fv78/qlevbvc2yc7ORkpKSpHHi2sCFy9ejCVLlqBNmzZ49tlncf78eXz22WeIj4/HZ599Zvnr//bt2zFhwgRERkbi7bffRnJyMtatW4fffvsNO3fuLHKqltnJkycxfPhwREREYOnSpfD09Cz1Z6aEnTt3Ijs7G4MHD0Z+fj4+/fRTvPDCC/jqq69QpUoVu8bctWsXsrOzMXDgQEiShJUrV2LMmDH45ptvoNPpMHDgQNy8eRM//vijpTmw17JlyyBJEkaMGIHk5GSsXbsWL774Ir744gt4enoCAI4ePYoRI0YgIiICo0ePhiRJ2L59O1544QVs3LgRTZo0sRrzzTffxH333Ye33noLsixbHr948SLeeecdDBo0CH369MHq1asxatQozJgxA9HR0Xj22WcBACtWrMDYsWOxb98+aDSl/7trYGAgpk+fjunTp+Oxxx7DY489BgCWZvSnn35CYmIi+vXrh+DgYPz777/YsmULzp49iy1btkCSJDz22GO4cOECdu3ahQkTJqBy5cqWsW0xadIkbN++HR06dED//v1hNBrx66+/4sSJE4iMjAQATJ48GTt27ED37t3x0ksv4eTJk/j4449x7tw5xMbGWo138eJFvPnmm+jfvz+eeuopfP7554iKikLjxo1x//33l1jL1KlTsWPHDvTr1w/PP/88Ll++jA0bNuD06dNWv7MAcP78ebzzzjsYOHAgBgwYgHr16lmeW7p0KXQ6HYYNG4aCggLodDqbfs8NBoOlaR8/frwlXwCQnp6OkSNHokePHujVqxf27t2L6dOnQ6fToX///gCArKwsbN26Fb1798YzzzyD7OxsbNu2DcOHD8fWrVvRqFEjq/Xevn078vPzMWDAALi7u8Pf39+mz5CoQpGJiErp888/l8PCwuSTJ0/edZmJEyfKbdu2lVNSUqwef+utt+SHHnpIzs3NlWVZllevXi2HhYXJBw4csCyTl5cnP/7443JYWJj8888/y7Isy/n5+XKLFi3kp59+Wtbr9ZZlt2/fLoeFhclDhgyxPLZz5065YcOG8i+//GL13p999pkcFhYmHz9+/K51FxQUyK1bt5b79u0r5+fnWx7fvHlzkfdJTEyUw8LC5M8///yu48myLP/8889yWFhYif81a9bMsnxycrLcuHFj+eWXX5aNRqPl8fXr18thYWHytm3brGrt3bu3nJeXZ1nu4MGDclhYmLxw4ULLY+PHj7e8x6+//io/+OCD8siRI63WsbSfWXkyb+MmTZrI169ftzx+4sQJOSwsTP7ggw8sjw0ZMsTq8zEbP3683KlTpyJjtmjRQk5LS7M8/s0338hhYWHyd999Z3lsxowZclhYWLG1hYWFyYsWLSqxfvNn3759ezkzM9Py+J49e+SwsDB57dq1sizLsslkkrt16ya//PLLsslksiyXm5srd+7cWX7ppZcsjy1atEgOCwuT33777SLv16lTJzksLEz+7bffLI/98MMPlm145coVy+ObNm2y+h2T5dJvw+Tk5Luuf3E52bVrlxwWFmb1O7ly5Uo5LCxMTkxMLHY9xo8fX+Txwo4ePSqHhYXJ7733XpHnzNvwzJkzclhYmDxp0iSr5+fMmSOHhYXJR48etXrPO2tMTk6WIyIi5Dlz5pRYyy+//CKHhYXJX375pdXjhw8fLvK4+X0OHz5staw5K126dLHahrb+noeFhcnz5s0rUuOQIUPksLAwefXq1ZbH8vPz5b59+8qtW7eWCwoKZFmWZYPBYLVfkGVZTk9Pl9u0aSNPmDDB8pj59+jBBx+Uk5OTS9w+RHQbTykkImFkWcb+/fvRuXNnyLKMlJQUy3/t2rVDZmYm/vzzTwDADz/8gJCQEHTp0sXyeg8PDwwYMMBqzFOnTiEtLQ0DBgywum7miSeeKPIX1X379qF+/foIDQ21eu9WrVoBQIkzq506dQrJyckYNGgQ3N3dLY8/9dRT8PX1tX+jAHj99dexZs2aIv+1a9fOarmffvoJer0eQ4cOtTry8Mwzz8DHxweHDh2yqvXZZ5+Fh4eHZbmOHTsiNDQU33//fZEafv75ZwwfPhytW7fG4sWLLetoy2emhK5duyIkJMTyc5MmTdC0aVPLtrBHz549rbLz8MMPAwASExPtL/QunnzySfj4+Fh+fvzxxxEcHGyp/8yZM7hw4QKeeOIJpKamWrZ9Tk4OWrdujV9++aXItTyDBg0q9r0aNGhgNetl06ZNAQCtWrVCjRo1ijwuen0LH1HJz89HSkqK5b1EZmj//v2QJAmjR48u8px5wg3z9n3ppZesnn/55Zetnjdr0KCBJQfA7SNu9erVu+c22rdvH3x9fdG2bVur353GjRvD29u7yD6nVq1aaN++fbFjPfnkk1bb0J7fc/NRzDu5ublh4MCBlp/d3d0xcOBAJCcnWz4brVZr2S+YTCakpaXBYDAgIiKiyCmoANCtWzebj0wSVVQ8pZCIhElJSUFGRgY2b96MzZs333UZ4Pb1W3Xq1CkyI1mdOnWsfr569Wqxj7u5uaFmzZpWj128eBHnzp2zXGdyp+Tk5LvWbn6f++67z+pxnU6H2rVr3/V1pREWFoY2bdoUefzLL78stobQ0FCrx93d3VG7dm1cuXLFarnCpyOZhYaGFrn2Jz8/H6+88goaN26MmJgYq8bVls+sOGlpadDr9Xd9viT+/v5WzW1x7vw8AKBu3brYu3evXe8JoMjpoebmqyymKb+zfkmScN9991k+ywsXLgAAxo8ff9cxMjMzrRrEWrVqFbvcnetl/kNB4dNuAVgaQNHrm5aWhiVLlmDPnj1FftcyMzOFvc+lS5dQtWpVBAQE3HWZK1euQKPRFNlvBAcHw8/Pz7L9zYo7Zdjf37/IdVh3unjxIjIzM0u9z7nbZ1fcc7b+nru5uRX5rM2qVq0Kb29vq8fq1q0L4Pa2atasGQBgx44dWL16Nc6fP2/1e11c3SWtCxFZY8NFRMKY/xLfp08fPPXUU8UuU3jygbJ4/7CwMEyYMKHY5+/2ZUTt3N3d0aFDB3z33Xf44Ycf0KlTJ8tzjn5mY8aMwX//+1+76lq3bp3dU4uXhtFoLPbxu80uKRe6Hqq8mN/zP//5T5FrZMzu/KJc+GhHYXdbL0fW927bsDhjx47F77//jmHDhqFRo0bw9vaGyWTC8OHDFdm2AEo9xby9M46aTCYEBQVh3rx5xT5/5xGgwkew7lTSc6Xh7u5u0zV5d/riiy8QFRWFrl27YtiwYQgKCoJWq8XHH39c7JE+R+slqkjYcBGRMIGBgahUqRJMJlOxR3QKq1mzJs6ePQtZlq2+FF26dMlqOfOpUJcuXbKcGgjcvkD8ypUrVs1AnTp18Ndff6F169Y238vH/D4XL160+mu1Xq/H5cuX0bBhQ5vGs4e5hoSEBKujagUFBbh8+bJlm5qXO3/+fJG/rJ8/f97q9DHg9pfOefPm4bXXXsObb76JuLg4S6Njy2dWnPHjx9t9pKQ02/TixYtFHrtw4YLV0U1/f/9ivxCajxDYQ9S9oO6sX5ZlXLx40ZJb8+fs4+Nj1/YXpbTb8G7bJT09HUePHsWYMWOsTvUzH8ErzRilVadOHRw5cgRpaWl3PcpVs2ZNmEwmXLx4EfXr17c8npSUhIyMjCJHxx2p5ejRo3jwwQeFNyC2/p6X5ObNm8jJybFq3s2fjXlbfP3116hduzaWLFli9RktWrTI3lUgov/Ha7iISBitVovu3bvj66+/LjJ1N2B9alq7du1w48YNfPvtt5bH8vPzsWXLFqvXREREICAgAFu2bIHBYLA8/tVXXxU53adHjx64ceNGkTEAIC8vr8T70kRERCAwMBCbNm2ymj1wx44dZXKqWXHatGkDnU6HTz/91OqIwLZt25CZmYlHH33UUmtQUFCRWg8dOoRz586hY8eORcZ2d3fHkiVLEBkZiVGjRlmmQbflMytOREQE2rRpY9d/pZnV7JtvvrGaAvvkyZM4ceIEOnToYHmsdu3aSEhIsKr1r7/+wm+//XbP8e/Gy8sLgOOn3e3cudMyvTdw+5qfW7duWeqPiIhAnTp1sHr1assU/YXda/uLUtpteLftcrcjRGvXri3ymHkMe08z7NatG2RZxpIlS4o8Z/69Mf+u3Pn+a9assXreUT169IDRaCx2BlSDweBQfuz5Pb8bg8FgdcpwQUEBNm/ejMDAQDRu3BjA/z7DwvueEydO4I8//rB7HYjoNh7hIiKbff755/jhhx+KPD506FC88847OHbsGAYMGIBnnnkGDRo0QHp6Ov78808cPXrUcvrZwIEDsX79erzzzjsYOnQogoOD8dVXX1lOlzL/hdXd3R1jxozBe++9hxdeeAE9evTAlStXsH379iLXZ/Tt2xd79+7FtGnTcOzYMTz44IMwGo1ISEjAvn37sHLlSsuU0XfS6XQYO3Yspk6dihdeeAE9e/bE5cuXsX37doev4SqtwMBAvPLKK1iyZAmGDx+Ozp074/z589i4cSMiIyPRp08fS63jxo3DhAkTMGTIEPTq1csyXXTNmjXvOo27p6cnPv74YwwdOhQjRozAp59+irCwsFJ/ZkqoU6cOnn32WTz77LMoKCjAunXrEBAQgOHDh1uW6d+/Pz755BMMGzYM/fv3R3JyMjZt2oQGDRoU28SUhvlL6KxZs9CuXTtotVr06tXL5nH8/f0xePBg9OvXzzIt/H333WeZHEaj0WDWrFkYMWIEevfujX79+iEkJAQ3btzAsWPH4OPjg+XLl9u1DrYo7Tb09PREgwYNsHfvXtStWxcBAQG4//77ERYWhkceeQQrV66EXq9HSEgIfvzxR8v9tQozb9vo6Gj07NkTOp0OnTp1KnLq5N20atUKffv2xaeffoqLFy+iffv2MJlMOH78OFq2bIkhQ4agYcOGeOqpp7B582ZkZGTgkUceQXx8PHbs2IGuXbtaHS13RIsWLTBw4EB8/PHHOHPmDNq2bQudTocLFy5g3759mDRpEh5//HG7xrb397w4VatWRVxcHK5cuYK6detiz549OHPmDN577z3LtPUdO3bE/v378frrr6Njx464fPmyJQNqu8E2UXljw0VENrvzhplm/fr1Q7Vq1bB161bExsbiwIED+OyzzxAQEIAGDRpY3YizUqVKWLt2LWbNmoV169bB29sbTz75JJo3b44xY8ZYXacyZMgQyLKMNWvW4MMPP0TDhg2xbNkyzJo1y2o5jUaD2NhYfPLJJ/jiiy9w4MABeHl5oVatWnj++eeLvfi8sIEDB8JoNGLVqlWYO3cuwsLCsGzZMixcuNDBLVZ6Y8aMQWBgINavX4/Zs2fD398fAwYMwNtvv211P59+/frB09MTcXFxmDdvHry9vdG1a1e8++67d70HF3D71LVVq1ZhyJAhePnll7Fhwwbcd999pfrMlPDkk09Co9Fg7dq1SE5ORpMmTTBlyhRUrVrVskz9+vXx4YcfYtGiRZg9ezYaNGiAuXPnYteuXXY3i926dcPzzz+P3bt348svv4Qsy3Y1XKNGjcLff/+NFStWIDs7G61bt8a0adMsR3kAoGXLlti8eTOWLl2K9evXIycnB8HBwWjSpInVzHJlyZZtOGvWLLz33nuYPXs29Ho9Ro8ejbCwMMyfPx/vvfceNm7cCFmW0bZtW8TFxRWZla9JkyZ48803sWnTJvzwww8wmUz49ttvS91wAcDs2bMRHh6Obdu2Ye7cufD19UVERITVLI2zZs1CrVq1sGPHDnzzzTeoUqUKXnnllWJnN3TEzJkzERERgU2bNiE6OhparRY1a9ZEnz598OCDDzo0tr2/53fy9/fHnDlzMGvWLGzZsgVVqlTB1KlTrWaF7devH5KSkrB582YcOXIEDRo0wEcffYR9+/Yp+kcXIjWQZKWuZCUiKsYnn3yC2bNn4/Dhw1bTgd/JZDKhdevWeOyxxzBr1qxyrJDKw+XLl9GlSxf85z//wbBhw5Qux2bHjh3D0KFDsXDhQruPcBARkTrwGi4iUkxeXp7Vz/n5+di8eTPq1q1r1Wzl5+cXmeVs586dSEtLQ4sWLcqlViIiIiJ78JRCIlLM6NGjUaNGDTRs2BBZWVn48ssvkZCQUGSK5T/++AOzZ8/G448/joCAAJw+fRrbtm1DWFgYjx4QERGRU2PDRUSKadeuHbZt24avvvoKRqMRDRo0sFxIX1jNmjVRrVo1fPrpp0hPT4e/vz/69u2LcePG3fPGuURERERK4jVcREREREREZYTXcBEREREREZURNlxERERERERlhNdw2eD333+HLMtW98IhIiIiIqKKR6/XQ5Ikq3sAFocNlw1kWS4yNTUREREREVU8pe0L2HDZQKfTQZZlREREQJIkpcshFyXLMvR6PXQ6HXNEDmGWSBRmiURgjkgUV8lSfHx8qZbjNVxERERERERlhA0XERERERFRGWHDRUREREREVEbYcBEREREREZURNlw2cuYL98h18NYCJAqzRKIwSyQCc0SiqClLTjlL4Y4dO7B27VqcO3cO3t7eiIyMxJIlS+Dp6QkA+O677xATE4Pz58+jRo0aGDlyJJ5++mmrMQoKChAdHY0vv/wS2dnZaN68OaZMmYLQ0FCH67tX02U0GqHX6x1+H3I9Op0OWq22xGXYtJMozBKJwiyRCMwRiaK2LDldw7Vs2TLExcVh1KhRaNasGVJTU3H06FEYjUYAwK+//orRo0ejf//+mDhxIn7++WdMmjQJlSpVwuOPP24ZZ9asWdizZw+ioqIQEhKC5cuX48UXX8Tu3bvh6+vrUI2yLBcbBFmWcf36daSlpTk0Prm2gIAAVKtW7a47C1mWYTQaodVqVbdDofLFLJEozBKJwByRKGrLkiQ70Z18ExIS8MQTT2Dp0qV49NFHi11m2LBhyM7OxqZNmyyPvfPOOzhz5gz27NkDALh+/To6d+6MadOmYeDAgQCAtLQ0dOrUCa+99hpGjBhhV33x8fGQZRmRkZHFfvjXrl1DWloaqlatCm9vb1UEhEpPlmXk5OTg5s2bCAgIQPXq1e+6nCvcW4KcH7NEojBLJAJzRKK4SpbM9+GKjIwscTmnOsK1fft21KpV667NVkFBAY4dO4Zx48ZZPd6zZ0/s2rULly9fRq1atXDkyBGYTCarI14BAQFo27YtDh8+bHfDVRKj0WhptoKCgoSPT67By8sLAHDz5k1UrVr1nqcXEhEREZG6OdWkGSdOnEBYWBiWLl2K1q1bIyIiAoMGDcKJEycAAJcuXYJery9yHVb9+vUB3D5CZv7foKAg+Pv7F1nOvIxo5mu2vL29y2R8ch3mDPA6PiIiIiJyqiNct27dwqlTp/DPP/9g2rRp8PLywvLly/Hyyy9j//79SE9PBwD4+flZvc78s/n5jIyMYq/T8vPzsyzjiHudhXnn8+ZDoXd7nSRJJT7nyGs5btmOW9Jr7/ac+TFXW1cltqHa1lX0uIUfc5aaOK7z1+RqWXLGmlxt3PKqSZZly39q24au/tm42ri2ZKm8airta4vjVA2X+RqYhQsXomHDhgCApk2bonPnzli/fj3atWuncIW36fV6q/NJNZr/HSg0h6Owwsva81xxYzoy7p1jV+RxSxrb3nEL/2w0GmEymaye12g00Gq1kGUZBoOhyLjmaVANBkORsd3c3CBJEkwmk2UiGTOtVms5hfHOo2uOjKvRaODm5lbsuAAs51cXt67mcYtbV/O4sizfdVyg+G1oXld7tqH5uZK2oejP5l7b0N3d/a7rWtK4kiTdtd7C61pW21D0uPZuQ6XyXdK6lmZcoHy3YUn7CPPz9ozLfUTpxlViH1He2/DO7yvcR6hnH1He27Bww2X+2Rn3EeaG8F6cquHy8/NDQECApdkCbl979cADD+Ds2bPo1asXACAzM9PqdRkZGQBgOYXQz88PWVlZRcbPyMgocpqhrSRJsuz4CjN/WJIklbjh7XmuNB+kyPdcvHgxYmNjizx+//3346uvvkJ4eDjeffddDBs2DMDta+90Oh2eeOKJe75n586d8eijj2Lq1KkAgKioKPz555/46quvHF4Xe15b+DFR27Dwz4V3XncuI8uyVbN+J/POqTgajabE15Z07wrR45rX927ral7mbjWV9Jwj4wL2r2tZjQuU/NmUtK53G9e8/ZXYhkp8NoBr5ftu45o50zY0r6uzbUPuI/7Hnn0EoNw2dKZ8l9W4FWkfUVbjuvI+ojTf0QEna7gaNGiAS5cuFftcfn4+6tSpA51Oh4SEBLRv397ynPm6LPO1XaGhoUhKSkJ6erpVg5WQkCDkPlxAyc2RPY2T6EbCkXElSYKnpyfWrl1r9binpyckScLmzZtRo0YNy2t37twJb29v9OnTp9Q1mZ9//fXXkZOTY/nZmbaDva+9VxMnyzJMJlOZNOf3es4Zx3XGmlxl3LLOkiOv5bjOW5OrZcmR13Lc8q2p8ClgIscV9ZwzjuuMNTnDuLZkqbxqsvW1hTnVpBmdOnVCWloazpw5Y3ksNTUVf/75Jxo3bgx3d3e0bNkSX3/9tdXr9uzZg/r166NWrVoAgHbt2kGj0WD//v2WZdLT03HkyBF06NDBoRptOV/TlWk0GjRr1szqP/ORx2bNmqFq1apC3qdOnTpWRzSdQUFBQZFDz6IVd/oXkT2YJRKFWSIRmCMSRU1ZcqqGq2vXroiMjMQbb7yBPXv24Ntvv8WoUaPg7u6OwYMHAwBeffVV/PHHH5g+fTqOHTuGRYsWYdeuXRgzZoxlnGrVqqF///6YO3cuPv/8cxw5cgSjR4+Gr68vBg0apNTqqUZ4eDhWrVoFAHj++efx3//+F99//z3Cw8MRHh6OxYsXl3qsqKgo9O7d2/Lz9u3bER4ejtOnT2P48OFo1qwZunXrhp07dxZ57ffff49nnnkGTZo0QatWrTBt2jTk5ORYns/JycHMmTPRvXt3y7WAU6dOLXJKaufOnTFz5kzExcWhU6dOaNKkieXm1du3b8cTTzyByMhItG/fHtHR0UXOTSYiIiIiuhunOqVQo9FgxYoVmD17NqZOnQq9Xo+HH34YGzZsQHBwMADg4YcfxuLFixETE4Nt27ahRo0amDVrFnr06GE11uTJk1GpUiXMnz8f2dnZePDBB7FmzZpiZy+k4t35l4Xi7vY9bdo0vPvuu/D09MT48eMB3G54HTVu3DgMGDAAL730ErZs2YKoqChERkZabgGwb98+vPXWW+jXrx/GjBmDW7duYf78+cjIyEB0dDQAIC8vD0ajEW+99RYCAwNx7do1LF++HK+99ho+/fRTq/fbv38/7rvvPkyaNAkajQbe3t5Ys2YNPvroI7zwwguIiorCuXPnLA3XnfeCIyIiIiIqjlM1XAAQGBiIjz76qMRlunTpgi5dupS4jLu7O8aPH29pAsg2OTk5aNy4sdVjc+fORd++fa0ea9CgAXx8fODt7Y1mzZoJe//nnnsOzz33HACgefPmOHToEL7++mu89tprkGUZc+fORc+ePfH+++9bXhMcHIyRI0fitddew/3334/AwEDMmDHD8rzBYECtWrUwePBgnD9/HvXq1bM8p9frERcXZ7mHVlZWFhYtWoThw4fj7bffBgC0bdsWOp0Oc+bMwbBhw1C5cmVh60tEREREQG5uLv7991/cd999VhNa5Obm4uzZs2jQoAG8vLwUrNB2TtdwOTtbLpArTH/hKkzpmfdeUDCNvy90dWvY/DpPT0+sX7/e6rHatWuLKuueCt8CwNvbGzVq1MD169cBAOfPn8eVK1cwceJEq6NwLVq0gEajwalTp3D//fcDuD2hxyeffIKLFy9anW544cIFq4arZcuWVjet/v3335GTk4PHH3/c6j3atGmDvLw8/Pvvv2jRooXd62dvjojuxCyRKMwSicAckaNyc3Nx6tSpImdMmR+vWbMmG66KwNadiTE5DZdaPguU8UQMxdJqUffPndAGBdj0Mo1Gg8jIyLKpqRTuPPVTp9OhoKAAwO2JVIDbMxwW59q1awCAAwcOYPz48Rg4cCDeeustBAQE4NatW3j99deRn59v9ZqgoCCrn83v8dRTT5X4Hva41xSkRKXFLJEozBKJwByRKJJ0+z6TSbuPIEXrjurtmyldkkPYcJUDbVAA6hz7TLEjXLY2W84uICAAADB16lQ0adKkyPPmGRT37duHRo0aYebMmZbn/vvf/xY75p1NtPl2AkuWLCn2mjTzjJhEREREJE5aWhqMCZdxbeA4eJ04ix+aP4gLfyWic7NgZGZmIi0tDYGBgUqXaRM2XHYo7V2lC7PntD5XodPpihwxKkuhoaGoVq0aEhMTLdd5FScvL6/IX9oK32C5JM2bN4eXlxeuX7+Oxx57zKF672S+q7n5ruxE9mKWSBRmiURgjshRpqwc3Ji6GC0OHEeOjye+69kMl+sFQZt+GkeOSJAA/PHHH8Luq1te2HDZqKLch8sWoaGh2LlzJ7777jsEBwejatWqCAkJKbP3kyQJUVFRGDduHHJyctCxY0d4eXnh6tWrOHToEN566y3Uq1cPbdq0wcyZMxEbG2uZeOPo0aOleg8/Pz+88cYb+Oijj3D9+nW0aNECWq0WiYmJ+Pbbb7F48WKHzh9mjkgUZolEYZZIBOaI7CHLMrK/OIikabGompyKhE5NoBnaFxf/TkfitUzUru6LR5sF4+y/fwudpK28sOEih40YMQKXLl3C+PHjkZGRgdGjR1vdF60s9OjRA35+fli+fLnlqFXNmjXRvn17VKlSBQAwaNAgXL58GevXr8eqVavQrl07zJ8/HwMGDCjVe7z88ssICQnBmjVrsH79eri5uaFOnTro2LEjz1EnIiIiEqDg7/NImhCD3B9+g3ePdnB7Zyhu/fk7ujzUBA+398eNlFxUC/KGoSAbN65ftVxa4kokmX+KKLX4+HjIsozIyMgih8rz8vIsU417enoqVCE5g3tlQZZl6PV66HQ6nnJBDmGWSBRmiURgjsgWpqwcpHy0BukrtkJXuzqCPngTlbq2QkpKCvbt24cuXbqgatWqliylpKTg66+/Rvfu3Z3mGq74+HgAuOdEczzCRURERERE5UKWZWRt/wbJ02JhyshC4H9eRsBrgyB5uAMAvLy8EBERUeSP1ubHXW1KeIANl834FxsSgackkijMEonCLJEIzBGVJP/0OSRFRSPv6AlUeqIjgmaOhq6W9XX/Xl5exR4xutvjroANlx3YdJEjmB8ShVkiUZglEoE5orsxZmQh9cPVSF+1Hbp6NVF96wJ4d3zkrsurLUtsuOxgz7TwRGayLMNkMkGj0TBH5BBmiURhlkgE5ojuJJtMyNzyNVJmLoMpOw+Bk0ciYOQzkNxLPhKqtiyx4bIR5xghEYxGIzQajdJlkAowSyQKs0QiMEdklh//L5LGL0DeL6fg81QXBM14HW7Vg0v9ejVliQ2XYGzIiBkgIiKiisqYlomU2SuR8clO6O6vgxo7FsKr3YNKl6UoNlyCmC8SzcnJccnZU0icnJwcALxwmIiIiCoO2WRC5sY9SJ61HHK+HkEzXoP/sKch6dhucAsIotVqERAQgJs3bwIAvL29VXHOKZWeLMvIycnBzZs3ERAQAK1Wq3RJRERERGUu74+/kBQVjfzjp+HzTDcETX0VbtWqKF2W02DDZaOSmqhq1aoBgKXpooopICDAkoW7YTNGojBLJAqzRCIwRxWLMSUdKR/EIWPdl3B/IBQ1vlwCr9ZNhYytpiyx4bLD3ZouSZJQvXp1VK1aFXq9vpyrImeg0+nuuYOQJElVOxFSDrNEojBLJAJzVHHIRiMy1u9CyvsrAKMJVd5/A34vPQnJTUxrobYsseGyw72mhddqtaoKCYkly7IlQzztlBzBLJEozBKJwBxVDHnH/0TS+Gjkn/gbvoN6IHDKKLhVDRT6HmrLEhsuG3EGOhLBYDBwUg0SglkiUZglEoE5Ui9jUiqS3/sYmRt3wz3yftTcswyej0SU2fupKUtsuIiIiIiIqFiy0YiMT75Ayuw4QJJQZe7b8BvaBxLP5io1NlxERERERFRE7rGTSIqKQcGfZ+E7pDeCJo2ENihA6bJcDhsuIiIiIiKyMNxMQfKMZcjasg8ezRuh5r7l8HzwAaXLcllsuGykhgv3SHnMEYnCLJEozBKJwBy5NtlgQPqqHUj9cBWgc0Pwgnfh+1xvSBpNudeipiyx4bKDmgJA5U+SJNVcBErKYpZIFGaJRGCOXFvuT38gKSoaBX+dh9+LfRE4YQS0lf0UqUVtWWLDRURERERUQRmuJyF5+lJkfX4AHg83Rq0DcfBoGq50WarChssO97oPF1FJZFmGwWCAm5sbc0QOYZZIFGaJRGCOXIusNyA9bhtS5q6G5OWB4IVR8B3UQ5HTB4vUprIsseGyEe/DRSIwRyQKs0SiMEskAnPkGnIO/4qkCTHQn02E/8tPoXLUMGj9fZUuy4qassSGi4iIiIioAjBcuYGkqbHI/vIgPFs2Qci30+ER0UDpslSPDRcRERERkYrJ+QVIW74FqQvWQuPjjapLJ8OnfzdVnK7nCthwERERERGpVM53x5A0cSH0F67Cf8TTCPzPy9D4VlK6rAqFDZeN+JcAEsHNjb96JAazRKIwSyQCc+Q89InXkTxlMbJ3H4Znm2YIWTMLHo1ClS6r1NSUJfWsSTli00WOkCSJGSIhmCUShVkiEZgj52DKy0d67CakLvwUGn9fVF0xDT5PdnGpz0ZtWWLDZQdOC0+OkGUZJpMJGo2GOSKHMEskCrNEIjBHysve/xOSJi2C4fJ1BLw6EJXffgEaH2+ly7KZ2rLEhstGapqikpRjNBqhcYL7XJDrY5ZIFGaJRGCOlKG/cBVJkxch5+sf4fXow6i+8UO433+f0mU5RE1ZYsNFREREROSCTLn5SFu0HmmLN0JbJQAhq99Dpd6PquKokJqw4SIiIiIiciGyLCNn3xEkTV4Mw/UkBLw2CJXHPg9NJS+lS6NisOEiIiIiInIRBecSkTxpEXK+/RlenVui+pb5cK9fW+myqARsuGzEQ7QkglrOSSblMUskCrNEIjBHZceUnYvUmE+RtnQT3KpVQbV1H8D78Xaq/W6qpiyx4bKDWoNN5UOSJFXdW4KUwyyRKMwSicAclQ1ZlpG96xCSpyyGMSkNld94DgFvDIHGy0Pp0sqM2rKknjUpR5wWnhxReKZL5ogcwSyRKMwSicAciVfw70UkTVyI3O9/gXf3tqjy3hjo6tVUuqwyp7YsseGyEaeFJxH0ej10Op3SZZAKMEskCrNEIjBHYpiycpC6YC3Slm+BW82qqLbhQ1Tq1kbpssqVmrLEhouIiIiIyAnIsozsnd8haVosTKnpqPzOCwh4/VloPNV7+mBFwIaLiIiIiEhhBX+dx60JMcg78hsq9eqAoJmjoatTXemySAA2XERERERECjFlZiPlozVIj9sGXZ3qqL55Hrw7t1S6LBKIDRcRERERUTmTZRlZ2/YjefpSmLJyEBg1HAGjBkDycFe6NBKMDZeNJElSxWwppBxJkuDuzp0pOY5ZIlGYJRKBOSq9/D/PIikqBnk/n0ClPp1QZebrcKsZonRZTkNtWWLDRURERERUDozpmUj9cDXSV++ALrQWqm+LhvejDytdFpUxNlx24H24yBGyLMNoNEKr1TJH5BBmiURhlkgE5ujuZJMJmZv3IeW95TDl5CFoyivwH9Efkrs6pj0XTW1ZYsNlI96Hi0QwmUzQarVKl0EqwCyRKMwSicAcFZV/8h/ciopG/i+n4NOvK4Kmvwa36sFKl+X01JQlNlxERERERIIZUzOQMjsOGWu/hC7sPtTYuQhebZsrXRYpgA0XEREREZEgssmEzA27kDxrBaA3IGjG6/Af1g+Sjl+7Kyp+8kREREREAuT9fgZJ46OR//sZ+AzojqCpr8ItJEjpskhhbLhspIYL90h5bm781SMxmCUShVkiESpqjozJaUh+fwUy1++C+wP1UeOrWHi1aqJ0WS5NTVlSz5qUIzZd5Ajey41EYZZIFGaJRKiIOZKNRmSs+xIpH8QBJhlVPngTfi/2haSiZkEJassS02AHTgtPjpBlGSaTCRqNhjkihzBLJAqzRCJUtBzl/XIKt6KiUXDyH/gO7oXAya/ALbiy0mWpgtqyxIbLRpwWnkQwGo3QaDRKl0EqwCyRKMwSiVARcmS4lYqU95Yj87M9cG8Shpp7l8Pz4cZKl6U6asoSGy4iIiIionuQDQZkrNmJlDmrAK0GVeaNg9+Q3pBUcq8oKjtsuIiIiIiISpD780kkRS1AwekE+D3/BAInjYQ20F/psshFsOEiIiIiIiqG4XoSkmcuQ9bW/fB4sBFq7l8Bz2YNlS6LXAwbLhup4cI9Up5azkkm5TFLJAqzRCKoJUey3oD0VZ8j5cPVkDx0CI4eD9/BPSGpZP1cgVqyBLDhsgubLnKEJEmqurcEKYdZIlGYJRJBLTnK/fF33IqKhv6fi/B78UkERg2DtrKf0mVVKGrJkpl61oTIhfDWAiQKs0SiMEskgivnyHDtFpKnxSJrx7fwfCQCIQfi4NEkTOmyKixXztKdnOpY3fbt2xEeHl7kv3nz5lktt3XrVnTv3h2RkZHo06cPDh48WGSszMxMTJw4ES1atEDz5s3xxhtv4ObNmw7XKMsyp4Ynh8iyDL1ezxyRw5glEoVZIhFcNUdygR6pSzbiUuvnkHvkNwQvnogau2LZbCnIVbN0N055hGvlypXw9fW1/BwSEmL5/7t378aUKVMwatQotGrVCnv27MHo0aOxYcMGNGvWzLLc2LFjcfbsWUyfPh0eHh6IiYnBiBEj8Pnnn6vqECURERER2Sfn0K9ImhADfcJl+A/rh8r/eQlaf997v5DIBk7ZeTRu3BiBgYHFPrdo0SL06tULY8eOBQC0atUK//zzD2JjYxEXFwcA+P3333HkyBGsWrUK7dq1AwDUq1cPPXv2xP79+9GzZ89yWQ8iIiIicj6GKzeQNGUJsr/6Hp6tmiIkbjo8GjdQuixSKac6pfBeEhMTceHCBfTo0cPq8Z49e+Lo0aMoKCgAABw+fBh+fn5o27atZZnQ0FA0atQIhw8fLteaiYiIiMg5yPkFSI35FJfaDEHesZOoumwKany5mM0WlSmnPMLVu3dvpKamokaNGhgwYACGDx8OrVaLhIQEALePVhVWv3596PV6JCYmon79+khISEC9evWKXGgXGhpqGYOIiIiIKo6cb48haWIM9JeuwX/kMwgc9yI0vpWULosqAKdquIKDgzFmzBg0bdoUkiThu+++Q0xMDG7cuIGpU6ciPT0dAODnZz01p/ln8/MZGRlW14CZ+fv749SpUw7VKElSsRfw3e1x83MASny+rF7LcZ3vs5FlGTqdzuXW1Zm2IceFZXmdTudUNXFc56/J1bLkjDW52rjlVZMsy3Bzc7PMLucs9eovXUPK1CXI3vMDPNs1R8jaD+AeXtfqfdT+2bjauLZkqbxqKu1ri+NUDVf79u3Rvn17y8/t2rWDh4cH1q5di1GjRilYmTWDwWD1s0ajsUzEodfriyzv7u4OADAajTCZTFbPubm5QZIkmEwmGI3GYsc1z9RyJ/M/jsWNq9VqodVqIctykXolSbK81mAwFAlMWY1bmnUFim7DshrXvK6SJNm8rqUZF7j7NtRoNMV+ro6sq7ne4mpSahuaxy1pGyqV75K2YXnmG+A+wpZ1BZwn32W5jyiLbVjafURxM4NxH+H4uNxHOD6urdtQzitAxrJNyFzyGTSV/RESNwPuPdtZLWPPuHeua0XbR5T39wgATruPMDeE9+JUDVdxevTogdWrV+PMmTPw9/cHcHvK9+DgYMsyGRkZAGB53s/PD9evXy8yVnp6umUZR5hDVRzzh1CcwkG+k0ajuesdtQt/8LaOe6/XljRjY1mNW9K6AiVvQ9Hjmj9HR9bV1s/G/Mut0Wi4De/xnCPjAvavq1L5tnUfYc6SVqvlPqKMxlViH1HacUWua+EsOds25D7if5z9e4QsyzAajZYvoUrmO3v/T0ietAiGqzfhP2oAAt9+ARof7xKPSnAfUbqaymMfYc5S4WWccR9RmmYLcIGGq7DQ0FAAQEJCguX/m3/W6XSoXbu2ZbmjR48W6TrPnz+PsDDH7qlgHrO4DXyvjV7S82X1Wo5btuPa+1qTyQStVlsm61NRtiHHva0ss+TIazmu89bkally5LUct/xrKvzdS4l6DReuImnyIuTs/wleHR9B9U0fwb1BHYfHVcNn42rjljZL5VmTLa8tzOlnKdyzZw+0Wi0eeOAB1K5dG3Xr1sW+ffuKLNO6dWvLIfcOHTogPT0dR48etSxz/vx5nD59Gh06dCjX+omIiIiobJly8pAyZyUS2w9FwelzCFkzC9W3zLdqtoiU4lRHuIYNG4aWLVsiPDwcAPDtt99iy5YtGDp0qOUUwjFjxmDcuHGoU6cOWrZsiT179uDkyZNYv369ZZzmzZujXbt2mDhxIsaPHw8PDw9ER0cjPDwc3bp1U2TdiIiIiEgsWZaRs/cHJE1eDMONZAS8/iwqj30eGm9PpUsjsnCqhqtevXr4/PPPcf36dZhMJtStWxcTJ07E888/b1mmd+/eyM3NRVxcHFasWIF69ephyZIlaN68udVYMTExmD17NqZOnQqDwYB27dph8uTJJZ6LSURERESuoeDcJSRNXITc747Bu0srVN+6AO71aytdFlERkmzLnIYVXHx8PAAgIiLCpvM2iQqTZRkmk8mmiy2JisMskSjMEolQXjkyZecidcFapC3bDLfqwajy/hvw7t6W2VURV9knmXuDyMjIEpfj4R47OPMHT87PPHMTkaOYJRKFWSIRyjpHsiwj+8vvkTR1CUzJaag89nkEjHkOGi+PMntPUoba9klsuOxQ2jn3iYojy3KJs10SlRazRKIwSyRCWeao4J8LSJoQg9zDx+H9eDtUeW8MdHVrCH0Pch5q2yex4bIRz8AkEQwGQ4n3fSAqLWaJRGGWSATROTJl5SBl3hqkf7wVbrWqodrGuaj0WGth45PzUtM+iQ0XERERETkVWZaRteNbJE+LhSk9E4Hvvgz/1wZC48nTB8n1sOEiIiIiIqeRfyYBSVHRyPvpD1Tq9SiC3hsNXe1qSpdFZDc2XERERESkOGNGFlLnrkb6yu3Q1a2B6lvmw7tTC6XLInIYGy4bqeHCPVIec0SiMEskCrNEItiTI1mWkbX1ayRPXwZTdi4CJ45AwKgBkNzVcf0O2UdN+yQ2XHZQUwCo/EmSpJqLQElZzBKJwiyRCPbkKP/UWSSNX4C8/8bD58nOCJrxOtxqVC2jCslVqG2fxIaLiIiIiMqVMT0TKbNXImPNTujur4Pq22Pg3f4hpcsiKhNsuOzA+3CRI2RZhsFggJubG3NEDmGWSBRmiUQoTY5kkwmZn+1F8qzlkPMKEDT9VfgP7w9Jx6+k9D9q2ycx3TbifbhIBOaIRGGWSBRmiUQoKUf5J/7Graho5P/6J3z6P4agaa/BrVqVcqyOXIma9klsuIiIiIiozBhTM5DywQpkrP0S7o3qocYXi+HVppnSZRGVGzZcRERERCScbDQic8NuJL+/AtAbEDTrDfi//CQkN379pIqFiSciIiIiofJ+O42k8dHI/+Mv+A58HIFTX4Vb1UClyyJSBBsuG6nhwj1SnpqmOiVlMUskCrNEImjSs3HrgxXI3LAb7o0boObupfBsEal0WeSC1LRPYsNlBzZd5Ajmh0RhlkgUZokcJRuNyFj7JVJmxwGyjCpz3oLfC30gabVKl0YuSG37JDZcduC08OQIWZZhNBqh1WqZI3IIs0SiMEvkiLxfTuHW+AUoiP8XPoN7ImjyKLgFV1a6LHJhatsnseGykZqmqCTlmEwmaPlXPxKAWSJRmCWyleFmClJmLkPm5n3waNYQNfYthzbyfmhVdCoYKUdN+yQ2XERERERUarLBgPTVO5H64SpAq0Hw/Hfh+1wvQKOBXq9Xujwip8OGi4iIiIhKJfenP5A0IRoFZ87D74U+CJwwAtpAfwA8C4jobthwEREREVGJDNeTkDxjKbK2HYDHQw+g1oE4eDQNV7osIpfAhstGarhwj5SnlnOSSXnMEonCLFFxZL0B6Su3IWXuGkgeOgTHRMH32R6QNJpil2eOSBQ1ZYkNlx3YdJEjJElS1U6ElMMskSjMEhUn98hvuBUVDf2/l+D30pMIjBoObYDvXZdnjkgUtWWJDZcdOC08OUKWZUuGmCNyBLNEojBLVJjh6k0kTY1F9hffwbNFJEK+WQmPyPvv+TrmiERRW5bYcNmIF4SSCAaDQVV3UCflMEskCrNEcoEeacu3IHX+WmgqeaHqkknwGdDdpi+8zBGJoqYsseEiIiIiquByDv4XSRNioL9wFf7D+6Hyf16G1s9H6bKIVIENFxEREVEFpb98A8mTFyN79yF4tm6KkNXvweOB+kqXRaQqbLiIiIiIKhg5vwBpsZuQGrMOGj8fVP14Gnye6qKK62WInA0bLhtxR0QiMEckCrNEojBLFUf2gaNInrQI+sRr8H/lGQSOewkaH28hYzNHJIqassSGyw5qCgCVP0mSVHMRKCmLWSJRmKWKQX/xKpImL0bOviPwav8gqn36AdzD6wkbnzkiUdSWJTZcRERERCpmys1H2pKNSFu0HprAAISsnIlKfTryD8hE5YQNlx14Hy5yhCzLMBgMcHNzY47IIcwSicIsqZMsy8j5+kckTV4Ew9VbCHhtECqPfV7Y6YPFvR9zRCKoLUtsuGzE+3CRCMwRicIskSjMkrroEy4jadJC5HzzM7w6tUD1zfPgXr9Omb8vc0SiqClLbLiIiIiIVMKUk4fUmE+RFvsZ3EKCUG3t+/Du0V4VRwmIXBUbLiIiIiIXJ8sysncfRvKUxTDeSkXlMYMR8MYQaLw9lS6NqMJjw0VERETkwgrOXkLShBjkfv8LvB9rjSrb34SuXk2lyyKi/8eGy0Y8JE8iuLnxV4/EYJZIFGbJ9ZiycpC6YB3Slm+GW82qqLZhDip1a6toTcwRiaKmLKlnTcoRmy5yhCRJzBAJwSyRKMySa5FlGdlfHETStFiYUtJQ+e2hCBg9GBpPD0XrYo5IFLVliQ2XHTgtPDlClmWYTCZoNBrmiBzCLJEozJLrKPj7/O3TB3/4DZV6tkfQzNHQ3VdD6bIAMEckjtqyxIbLRmqaopKUYzQaodFolC6DVIBZIlGYJedmyspBykdrkL5iK3S1q6P6pnnw7tJS6bKKYI5IFDVliQ0XERERkZOSZRlZ279B8rRYmDKyEPiflxHw2iBIHu5Kl0ZEpcSGi4iIiMgJ5Z8+h6SoaOQdPYFKT3S8ffpgrRClyyIiG7HhIiIiInIixowspH64GumrtkNXryaqb10A746PKF0WEdmJDZeN1HDhHilPLeckk/KYJRKFWVKebDIhc8vXSJm5DKbsPAROHomAkc9ActcpXVqpMUckipqyxIbLDmy6yBGSJKnq3hKkHGaJRGGWlJcf/y+Sxi9A3i+n4PNUFwTNeB1u1YOVLssmzBGJorYsqWdNyhGnhSdHFJ7pkjkiRzBLJAqzpBxjWiZSZq9Exic7obu/DmrsWAivdg8qXZZdmCMSRW1ZYsNlI04LTyLo9XrodK5zigg5L2aJRGGWypdsMiFz4x4kz1oOOV+PoBmvwX/Y05B0rv3VjDkiUdSUJdf+rSYiIiJyMXl//IWk8QuQ/9sZ+DzTDUFTX4VbtSpKl0VEZYQNFxEREVE5MKakI+X9Fcj49Cu4PxCKGl8ugVfrpkqXRURljA0XERERURmSjUZkfPoVUj6IA4wmVHn/Dfi99CQkFU0KQER3x990G6nhwj1SHnNEojBLJAqzVDbyfv0TSVHRyD/xN3wH9UDglFFwqxqodFllhjkiUdSUJTZcdlBTAKj8SZKkmotASVnMEonCLIlnTEpF8nsfI3PjbrhH3o+ae5bB85EIpcsqU8wRiaK2LLHhIiIiIhJENhiQ8ckXSJmzEpAkVJn7NvyG9oGk1SpdGhEphA2XHXgfLnKELMswGAxwc3NjjsghzBKJwiyJkXvsJJLGR6Pg9Dn4DumNoEkjoQ0KULqscsMckShqyxIbLhvxPlwkAnNEojBLJAqzZD/DjWQkz1yOrC374NG8EWruWw7PBx9QuixFMEckipqyxIaLiIiIyA6ywYD0lduROnc1oHND8IL/wPe5XpA0GqVLIyInwoaLiIiIyEa5P/6OpAkxKPjrPPxe7IvACSOgreyndFlE5ITYcBERERGVkuF6EpKnxSJr+zfweCQCtQ7EwaNpuNJlEZETY8NlIzVcuEfKc+PNLkkQZolEYZZKJusNSF+xFSkfrYHk5YHgRRPgO/Bxnj54B+aIRFFTltSzJuWITRc5QpIkZoiEYJZIFGapZDmHf0XShBjozybCf1g/VB7/MrT+vkqX5XSYIxJFbVliw2UHTgtPjpBlGSaTCRqNhjkihzBLJAqzVDzDlRtImhqL7C8PwrNlE4R8Nx0ejRsoXZbTYo5IFLVliQ2XjdQ0RSUpx2g0QsPTUEgAZolEYZb+R84vQNryLUhdsBYaH29UXToZPv27qeKLX1ljjkgUNWXJadciOzsbHTp0QHh4OOLj462e27p1K7p3747IyEj06dMHBw8eLPL6zMxMTJw4ES1atEDz5s3xxhtv4ObNm+VVPhEREbmgnO+OIfHRF5EyeyX8XuiLOj9vhO8z3dlsEZHdnLbhWrp0KYxGY5HHd+/ejSlTpqBHjx6Ii4tDs2bNMHr0aPzxxx9Wy40dOxY//vgjpk+fjnnz5uH8+fMYMWIEDAZDOa0BERERuQp94nVcf3ESrg0cB221Kqj9/RpUmTkaGt9KSpdGRC7OKU8pPHfuHDZu3Ijx48dj2rRpVs8tWrQIvXr1wtixYwEArVq1wj///IPY2FjExcUBAH7//XccOXIEq1atQrt27QAA9erVQ8+ePbF//3707NmzXNeHiIiInJMpLx/psZuQuvBTaPx9UXXFNPg82YVHtIhIGKc8wjVr1iwMGjQI9erVs3o8MTERFy5cQI8ePawe79mzJ44ePYqCggIAwOHDh+Hn54e2bdtalgkNDUWjRo1w+PBhh2rjDphEUMs5yaQ8ZolEqYhZyt7/ExLbv4CUeWvgP/xp1Dm6Ab5PdeW/9Q6oiDmisqGmLDndmuzbtw///PMPXn/99SLPJSQkAECRRqx+/frQ6/VITEy0LFevXr0iO8zQ0FDLGI7gjpgcIUkS3NzcmCNyGLNEolS0LOkvXMW1IVG4/tx46O6rjtqH1yJo6qvQ+HgrXZpLq2g5orKjtiw51SmFubm5mDNnDt566y34+PgUeT49PR0A4OfnZ/W4+Wfz8xkZGfD1LXp/DH9/f5w6dcrhOk0mU5EASJJ01xkMzcuW9HxZvZbjOt9nY76twN1uL+Cs6+pM25DjwrL8vf4xUsu6uuq4zliTq2XJkdfe+ZwpNx9pizYgfclGaKsEoOqqmajU+9EiyzrTZyNi3PKqqfD/12g0Tl+vM4zrjDU5w7i2ZKm8airta4vjVA3XsmXLEBQUhKefflrpUu5KlmXo9Xqrf5g0Go3lbth6vb7Ia9zd3QHcnt7SZDJZPWfu3k0mU5FJQszjmt/zTjqd7q7jarVaaLVayLJcZKIQSZIsrzUYDEUCU1bjlmZdgaLbsKzGNa+rJEk2r2tpxgWK34YajQYmkwlarVboNjTXW1xNSm1D87glbUOl8l3SNizPfAP27yPM29bNza3YCYG4j3BsXPO6lvc+oqy2YUn7iMJ1qXEfIcsy8vb/hNRpS2G8kYyA1wah8tjnYXQv+rujpn1Eee9nzct6eXkJHdeWdQW4j1DD9wjzunl6elr9XNy4Sn6PKM0fqwAnariuXLmC1atXIzY2FpmZmQCAnJwcy/9mZ2fD398fwO0p34ODgy2vzcjIAADL835+frh+/XqR90hPT7cs4whzMO723N0UDvKdNBrNXc9VLfzB2zruvV5r/gUoz3FLWleg5G0oelzz5+jIutr62ciybDlKym2oXL4d+Z0rq8/G1n2E+R8K7iPKblwl9hGlHVfkuhb+0uFs29DRfCPxOpInLULut8fg1bklqmydD/f6dW4/X8JfqNWwjzArr33EnV9MnSXfZTluRdlHlOW4xW1Dc5bMzznr94jSNFuAEzVcly9fhl6vx8iRI4s8N3ToUDRt2hTz588HcPsardDQUMvzCQkJ0Ol0qF27NoDb12odPXq0SNd5/vx5hIWFOVyrJEnFbuDSnI5hz3OOvJbjlu24jtZUFutT0bYhx3XOmjiu89bkauPa+1pTdi5SYz5F2tJNcKtWBdXWfQDvx9tZLe9s6+ps29CecQv/2+YK9So9rjPW5CzjljZL5VmTLa8tzGkarkaNGmHdunVWj505cwazZ8/GjBkzEBkZidq1a6Nu3brYt28funbtalluz549aN26teWQe4cOHbB06VIcPXoUbdq0AXC72Tp9+jSGDx9efitFREREQuTm5uLs2bNo0KCB5ZS13NxcnD59GgDwwAMPwMvLC7IsI/Xz/UieFgtNehYqv/EcAt4YAo2Xh5LlE1EF5jQNl5+fH1q2bFnsc40bN0bjxo0BAGPGjMG4ceNQp04dtGzZEnv27MHJkyexfv16y/LNmzdHu3btMHHiRIwfPx4eHh6Ijo5GeHg4unXrVi7rQ0REROLk5ubi1KlTqFmzplXDZZ4Mq169etBevomkCTHIPfQr0iPq4r4NsxHYrLGSZRMROU/DVVq9e/dGbm4u4uLisGLFCtSrVw9LlixB8+bNrZaLiYnB7NmzMXXqVBgMBrRr1w6TJ08u8VzM0rjXaWBE92I+X5g5IkcxSySKK2QpLy8PBQUFSE9PR1ZOAW6m5sJTWwC9Xg9tvh6Zs1cidf0eyCHBcFsUhX+RgdA61ZUuu0JxhRyRa1BbliTZljkNK7j4+HgAQGRkpMKVEBERVSyHDx/G0aNH4evrhxupuSjIz4e7zg0Nzl5Cs0Nn4FlgwB9tWuOr2uGoU8cH9/mko2vXzqhWrZrliBgRkUil7Q1c7giXMyjtFJBExZFlGUajEVqtljkihzBLJIqrZMlkMiEtPQ3GAgOqpGai5Q9/ofqVVFwKDcbvHRoh1dsLdZEIOQ24maPFd999h2bNmuGhhx5SuvQKwVVyRM5PbVliw2UjHhAkEcz34SJyFLNEojh7lho0aIBz587hgXr34/q8z9Hov8eRVdkfPw1sg8Qa/vD184cmPf/2kS93HbTaovfPobLn7Dki16GmLLHhIiIiIqfn4eGBmvEXEfzRDlTJyoXp9ecR9Pzj0H9/AFVNJnTp0gVanRdupebCQ1uA47/8jA4dOqBatWpKl05EFRwbLiIiInJq+afOImvcR6h//DTcHm+LGnPeglvNEKSkpFhuaurv74/AwEDUqQWkpKQg3t0d/v7+vH6LiBTHhouIiIickjE9E6lzViF99Q64hdZE3kdvoMbA3nD7/ybKy8sLERERlv9vZn6czRYROQM2XDZSw4V7pDy1nJNMymOWSBRnypJsMiFz8z6kvLccppw8BE0dBf8R/SG566yW8/LyKnZCDC8vL84orBBnyhG5NjVliQ2XHdh0kSMkSVLVToSUwyyRKM6UpfwTf+PWhBjk/3IKPk8/hqDpr8GtWhWly6JScKYckWtTW5bYcNmB08KTI2RZtmSIOSJHMEskijNkyZiagZTZccj45Au4N6yHGjsXwattc0VqIfs4Q45IHdSWJTZcNuIUsySCwWCATqe794JE98AskShKZUk2mZC5YReSZ60A9AYEvTcG/i8/BUnHryiuiPskEkVNWeLejIiIiBSR9/sZJI2PRv7vZ+Az4HEETR0Ft5AgpcsiIhKKDRcRERGVK2NyGpLfX4HM9bvg/kB91NgVC6+WTZQui4ioTNjccF2+fBnffvstfvvtN5w7dw6pqamQJAmVK1dGaGgoHnzwQXTu3Bm1a9cui3qJiIjIRclGIzLWfYmUD+IAWUaV2WPh90IfSG78+y8RqVep93AHDx7E6tWrcfz4cciyjDp16qBWrVoICwuDLMvIyMjAX3/9hf3792POnDl46KGHMGzYMHTq1Kks6y93arhwj5Sn0WiULoFUglkiUco6S3m/nMKtqGgUnPwHvoN7IXDyK3ALrlym70nlj/skEkVNWSpVwzVgwAD89ddf6NKlC2JiYtCmTRv4+PgUu2xWVhZ+/PFHfP311xg7diwaNmyIzZs3Cy1aaWy6yBGSJMGNf80lAZglEqUss2S4lYqU95Yj87M9cG8Shpp7l8Pz4cZl8l6kLO6TSBS1ZalUa9KyZUssXboUVarc+z4YPj4+6N69O7p3745bt25h3bp1DhdJRERErkU2GJCxZidS5qwCtBpUmTcOfkN6Q1LRvXWIiEpDkjnPeanFx8dDlmVERkbyKBfZTZZl6PV66HQ65ogcwiyRKKKzlPvzSSRFLUDB6QT4Pf8EAieNhDbQX0Cl5My4TyJRXCVL8fHxAIDIyMgSl1PPsToiIiJSlOF6EpJnLkPW1v3weLARau5fAc9mDZUui4hIUaVuuP7880+bB2/cmOdoExERqZ2sNyB91edI+XA1JA8dgqPHw3dwT0gquuidiMhepW64nn76aZsO6UmShNOnT9tVFBEREbmG3B9/x62oaOj/uQi/F59EYNQwaCv7KV0WEZHTKHXDNXv27Hsuk5eXhy1btuDMmTMOFUVERETOzXDtFpKnxSJrx7fwfCQCIQfi4NEkTOmyiIicTqkbrqeeeuquzxUUFGDTpk2Ii4vDrVu38Mgjj2DMmDFCCnQ2znzhHrkOnU6ndAmkEswSiVLaLMkFeqR9vAWp89ZCU8kTwYsnwndAd54+SAC4TyJx1JQlhybNKCgowGeffYaVK1fi1q1baNGiBRYsWIBHHnlEVH1OiU0XOYL5IVGYJRKltFnKOfQrkibEQJ9wGf7D+qHyf16C1t+3jKsjV8F9EomitizZ1XAVFBRg48aNWLVqFW7duoWWLVtWiEbLTJZl1QWByo8syzAajdBqtcwROYRZIlHulSX95RtInrIY2bsOwbNVU4TETYdH4wYKVErOjPskEkVtWbKp4crPz7cc0UpKSkLLli0RHR2Nhx9+uKzqczq8bRmJYDKZoOXNP0kAZolEKS5Lcn4B0pZuQmrMp9D4eKPqsinwefoxVXwBorLBfRKJoqYslbrh+uSTT7By5UokJyejVatWWLhwIR566KGyrI2IiIgUkvPtMSRNjIH+0jX4j3wGgeNehMa3ktJlERG5nFI3XHPmzIEkSWjUqBHq16+PvXv3Yu/evSW+ZvLkyQ4XSEREROVHf+kakiYvQs7eI/Bs9yCqrfsA7uH1lC6LiMhl2XRKoSzLOH36dKnuryVJEhsuIiIiFyHnFSB14QakLVoPTWV/hMTNQKW+nXj6IBGRg0rdcP31119lWYfL4D88JIJazkkm5TFLJEL21z8iefJiGK7eRMCogaj89lBofLyVLotcEPdJJIqasuTQtPAVFZsucoQkSaraiZBymCVylP78FSRNWoicA0fh1fERVN/0Edwb1FG6LHJR3CeRKGrLEhsuO3BaeHKELMuWDDFH5AhmiexlyslD2qL1SFvyGbTBlRGy+j149WwPDW9eTA7gPolEUVuW7G64vvjiC3z++ee4fPky0tPTi0yXLkkSjh8/7nCBzobTwpMIBoNBVXdQJ+UwS2QLWZaRvecHJE9ZDMONZFQePRgBbw6B5OUBvV7Phoscxn0SiaKmLNnVcH300UdYvXo1QkJCEBERAV9f3mWeiIjImRWcu4SkCQuRe/C/8O7aCjW2RUMXWgsA/5hIRFSW7Gq4tm7dio4dOyI2NpZ/DSMiInJipuxcpC5Yi7Rlm+FWIxjV1s+Bd7c2qjhNh4jIFdh9SuGjjz7KZouIiMhJybKM7C+/R9LUJTClpKHyW0MRMHowNF4eSpdGRFSh2NUxdezYUZXXZ5UG/yJIIjBHJAqzRMUp+OcCrvV/CzeGT4VHkzDUPvIpAt99qcRmi1kiEZgjEkVNWZJkO07czszMxKhRoxAeHo6nn34a1atXL/ZoV0BAgIganUZ8fDwAIDIyUuFKiIiIijJl5SBl3hqkf7wVutrVEfT+G6j0WGulyyIiUqXS9gZ2nVLo5eWF5s2bY9WqVfjss8/uutyZM2fsGZ6IiIhsIMsysnZ8i+RpsTClZyLw3Zfh/9pAaDx5+iARkdLsarhmzpyJrVu3omnTpmjatGmFm6WQ9+EiR8iyDIPBADc3N+aIHMIsEQDkn0lAUlQ08n76A5V6P4qgmaOhq13NpjGYJRKBOSJR1JYluxquvXv3om/fvpgzZ47oepwep84lEZgjEoVZqriMGVlInbsa6Su3Q1evJqpvmQ/vTi3sHo9ZIhGYIxJFTVmyq+Fyc3ND06ZNRddCRERE9yDLMrK2fo3k6ctgys5F4MQRCBg1AJK7Om4QSkSkNnbNUtirVy8cPHhQdC1ERERUgvxTZ3G19+u4+fr78GrbDHWOrkflN55js0VE5MTsOsLVo0cPzJo1CyNHjrTMUqjVaoss17hxY4cLJCIiquiM6ZlImb0SGWt2Qnd/HVTfHgPv9g8pXRYREZWCXQ3Xc889B+D2LIQ//PBDkefNk0qocZZCNVy4R8pzc7P7nuNEVpgldZNNJmR+thfJs5ZDzitA0PRX4T+8PySd+M+dWSIRmCMSRU1ZsmtNZs+eLboOl8KmixwhSRIzREIwS+qWf+Jv3Bq/APnHT8On/2MImvYa3KpVKZP3YpZIBOaIRFFbluxquJ566inRdbgUTgtPjpBlGSaTCRqNhjkihzBL6mRMSUfKB3HIWPcl3BvVQ40vFsOrTbMyfU9miURgjkgUtWVJPcfqyomapqgk5RiNRmg0ds1ZQ2SFWVIP2WhE5obdSJ71MWAwImjWG/B/+UlI5XRaDbNEIjBHJIqaslSqtZg6dSoSExNtHvzSpUuYOnWqza8jIiKqSPKO/4krj4/CrXc+QqVubVD7540IGNm/3JotIiIqO6Xak1+7dg09evRAq1at0LNnT7Ru3RrVq1cvdtnLly/j6NGj2Lt3L44dO4a2bdsKLZiIiEgtjEmpSJ71MTI37IZ7xP2ouXspPFtEKl0WEREJVKqGKy4uDsePH8fq1asxdepUGI1GBAQEoGbNmvD394csy0hPT8fly5eRkZEBrVaLDh06YO3atXj44YfLeh2IiIhcimw0IuOTL5AyOw4AUOXDt+H3Qh9IxdxihYiIXFupz1V46KGH8NBDDyElJQUHDx7EH3/8gYSEBFy/fh0AEBAQgG7duqFZs2bo2LEjgoKCyqxoJanhwj1SXnH3rSOyB7PkevL+G49b46NRcOpf+D7XC0GTX4G2SmWly2KWSAjmiERRU5YkmbNAlFp8fDwAIDKSp3sQEZFtDDdTkDJzGTI374NHs4ao8uFb8HzwAaXLIiIiO5W2N+DVuHbgtPDkiMJ/42COyBHMkmuQDQakr9qB1A9XAW5aBM9/F77P9XKq0weZJRKBOSJR1JYlNlw24gFBEkGv10On0yldBqkAs+Tccn/6A0kTolFw5jz8XuiDwAkjoA30V7qsYjFLJAJzRKKoKUtsuIiIiAQzXE9C8oylyNp2AB4PPYBaB+Lg0TRc6bKIiEgBbLiIiIgEkfUGpMdtQ8rc1ZA83REcEwXfZ3tAUsnNO4mIyHZsuIiIiATIPfIbbkVFQ//vJfi99CQCo4ZDG+CrdFlERKQwNlw2UsOFe6Q85ohEYZaUZ7h6E0lTY5H9xXfwbNkEId+ugkdEA6XLshmzRCIwRySKmrJU6nMcFixYgL/++qssa3EZagoAlT9JkqDT6ZgjchizpCy5QI/URRtwqfUQ5P30B6rGTkKNr5a4bLPFLJGjmCMSRW1ZKnXDtWLFCvz777+Wn1NTU9GoUSMcPXq0TAojIiJyVjkH/4vEDi8g5YM4+D3fG7V/3gDfAY+r5ssBERGJ49AphRV1inTeh4scIcsyDAYD3NzcmCNyCLNU/vSXbyB58mJk7z4EzzbNELJmFjwahSpdlsOYJRKBOSJR1JYlXsNlo4raZJJYzBGJwiyVDzm/AGmxm5Aasw4af19U/XgafJ7qooovAmbMEonAHJEoasoSGy4iIqISZB84iuRJi6BPvIaAUQNQ+Z0XofHxVrosIiJyETY1XFeuXMGff/4JAMjMzAQAXLx4EX5+fsUu37hxY5uKOXToEOLi4nD27FlkZWUhJCQEXbt2xejRo+Hr+7+pdb/77jvExMTg/PnzqFGjBkaOHImnn37aaqyCggJER0fjyy+/RHZ2Npo3b44pU6YgNNT1T/0gIqKyp794FUmTFyNn3xF4dXgI1dbPhntYXaXLIiIiFyPJpTxe17BhwyKnTtztWibz42fOnLGpmC+++AJ///03mjZtioCAAPz7779YvHgxGjdujNWrVwMAfv31VwwdOhT9+/dHz5498fPPP2P58uWIiYnB448/bhlr6tSp2LNnD6KiohASEoLly5cjMTERu3fvtmrebBEfHw9ZlhEZGamq00iofMmyDL1er6rZd0gZzFLZMOXmI23JRqQtWg9NYACqzByNSn06qnobM0skAnNEorhKluLj4wEAkZGRJS5X6iNcs2fPdqyiUujbt6/Vzy1btoS7uzumTJmCGzduICQkBMuWLUOTJk0wc+ZMAECrVq2QmJiIRYsWWRqu69evY9u2bZg2bRr69+8P4PaG6NSpEzZt2oQRI0bYXaMzf+jkOtzceDYvicEsiSPLMnK+/hFJkxfBcPUWAl4bhMpvDYWmkpfSpZULZolEYI5IFDVlqdRr8tRTT5VlHXcVEBAAANDr9SgoKMCxY8cwbtw4q2V69uyJXbt24fLly6hVqxaOHDkCk8lkdcQrICAAbdu2xeHDhx1quAA2XeQYSZKYIRKCWRJHn3AZSZMWIuebn+HVqQWqb54H9/p1lC6r3DBLJAJzRKKoLUulvg9XeTIajcjPz8eff/6J2NhYdO7cGbVq1cKlS5eg1+uLXIdVv359AEBCQoLlf4OCguDv719kOfMyjlDTrClU/mRZhtFoZI7IYcyS40w5eUj+IA6X2g9Fwd8XUG3t+xWu2QKYJRKDOSJR1JYlpzxW16lTJ9y4cQMA0L59e8yfPx8AkJ6eDgBFJukw/2x+PiMjo9jrtPz8/CzL2EuW5WI/fEmS7hoKc4de0vNl9VqO63yfjXkncre/3DjrujrTNuS4sCxvNBqh0WicpiZXGVeWZWTvOoSUabEw3kpFwOjBCHjjOWi8Pa3GqSj5duYsOfJajlu+NZnvnWS+7sbZ63WGcZ2xJmcY15YslVdNpX1tcZyy4VqxYgVyc3Nx9uxZLFu2DKNGjcKaNWuULstCr9dbfVnWaDSW80z1en2R5d3d3QHcPnJnMpmsnjPf0M1kMsFoNFo9Zx7XfOHgnXQ63V3H1Wq10Gq1lsAWJkmS5bUGg6FIYMpq3NKsK1B0G5bVuOZ1lSTJ5nUtzbhA8dtQo7l9YFn0NjTXW1xNSm1D87glbUOl8l3SNizPfAP27yMK/4NwZ72F15X7COtx9WcTkTplMfIPH4dX11aosX0h3OrWgF6vh/GOsZXYR5TVNixpH1EY9xHq2UeU9zYs/CVZ5Li2rCvgPP8GqmkfUd7b0Lxu5tc56z5CloufQPBOTtlwNWzYEADQvHlzREZGom/fvjhw4AAaNGgA4H9T0ptlZGQAgOUUQj8/P2RlZRUZNyMjo8hphvYoacYU84dQnMJBvpNGo7F8Eb9T4Q/e1nHv9dqSLkgsq3FLWleg5G0oelzz5+jIutr62ciyDJPJxG1YiuccGRewf12V+mxs3UeY/6HgPqJ04yInDxnR65C+fAvcalRFyPo5qNStjeULv7PsI0o7rshtWPhLB/cRt6lhH2FWXtvwzi+mzpLvshy3ouwjynLc4rbhnWcZOOs+ojTNFuCkDVdh4eHh0Ol0uHTpEjp37gydToeEhAS0b9/esoz5uizztV2hoaFISkpCenq6VYOVkJAg5D5cklT8hXz32uglPV9Wr+W4ZTuuozWVxfpUtG3IcZ2zJmcaV5ZlZO34FknTYmFKTUflt4ciYPRgaDw9yrxeR17LcZ23JlcbtzxrKvxvmyvUq/S4zliTs4xb2iyVZ022vLYwp5w0o7ATJ05Ar9ejVq1acHd3R8uWLfH1119bLbNnzx7Ur18ftWrVAgC0a9cOGo0G+/fvtyyTnp6OI0eOoEOHDg7VY8vGJbqbkv76Q2QLZqlkBX+fx7Wnx+LGyOnwbN4QtY98isBxL1k1W3Qbs0QiMEckipqy5NARLr1ej4SEBGRmZhZ74dgjjzxi03ijR49GREQEwsPD4enpib/++gurVq1CeHg4unbtCgB49dVXMXToUEyfPh09evTAsWPHsGvXLkRHR1vGqVatGvr374+5c+dCo9EgJCQEH3/8MXx9fTFo0CBHVhkAmy5yjCRJqrq3BCmHWbo7U2Y2Uj5ag/S4bdDVro7qm+bBu0tLpctyWswSicAckShqy5Ik2zLFxv8zmUyYP38+Nm7ciLy8vLsud+bMGZvGXbFiBfbs2YNLly5BlmXUrFkTjz32GIYNGwYfHx/Lct9++y1iYmJw/vx51KhRAyNHjrTc4NisoKAA0dHR+OKLL5CdnY0HH3wQkydPtkwhbw/z3aQjIiLYdJHdCv/KMUfkCGapKFmWkfX5ASRPXwpTRhYqvzUUAa8NguThrnRpTo1ZIhGYIxLFVbJk7g0iIyNLXM6uhmvp0qVYtGgRBg4ciIceegj/+c9/MG7cOPj5+WHjxo2QJAnvvvsu2rRpY1/1Tio+Ph6yLCMyMtKpP3xybubZdEqafIWoNJgla/mnzyEpKhp5R0+g0hMdETRzNHS1QpQuyyUwSyQCc0SiuEqWSttw2XVy5I4dO9CjRw/MmDHDMnlF48aNMWDAAGzZsgWSJOHnn3+2Z2giIiKbGNMzkTRxIS53HgbjrVRU37oA1Va/x2aLiIicgl0N1/Xr19GqVSsA/7s3REFBgeXnPn364IsvvhBUIhERUVGyyYSMTXuR2Po5ZGzYjcDJI1H70Cfw7mjb9cNERERlya6r0QICApCTkwMAqFSpEnx8fJCYmGi1jPneWERERKLln/zn9umDv5yCz1NdEDTjdbhVD1a6LCIioiLsargeeOAByzmLANCyZUusXbsWjRo1gizLWLduHcLDw4UVSUREBADGtEykfBCHjLVfQHd/HdTYsRBe7R5UuiwiIqK7suuUwgEDBqCgoMByGuFbb72FjIwMDBkyBEOGDEF2djaioqKEFuos7nWzWqJ7kSTJ6S8CJddQkbIkm0zIWL8Ll1o9i8ytXyNoxmuofXANmy1BKlKWqOwwRySK2rJk1yyFxcnMzMSxY8eg1WrRvHlzBAQEiBjWqZR2JhIiIhIn74+/kDR+AfJ/OwOfAd0RNGUU3KpVUbosIiKq4ErbGwi7o5ivr6/l5sRqJ8uyajpuKn+yLMNoNEKr1TJH5BC1Z8mYko6U91cg49Ov4P5AKGp8FQuvVk2ULkuV1J4lKh/MEYmitizZdUphly5dMHDgQCQkJBT7/DfffIMuXbo4VJizEnRAkCo4k8mkdAmkEmrMkmw0Iv2TnbjUajCydn6HKh+8iVrfrGSzVcbUmCUqf8wRiaKmLNnVcF25cgV//vknnnnmGXzzzTdFns/JycHVq1cdLo6IiCqWvF//xJXuryDp3fmo9Hg71P55I/yHPw3JTdgJGUREROXKroYLACZMmIBHHnkEY8aMQUxMjMCSiIioojEmpeLmm3NwpccoyLKMmnuWoeqiCXALrqx0aURERA6x+0+Gfn5+WL58OZYsWYKlS5fi9OnTmD9/Pnx9fUXWR0REKiYbDMj45AukzFkJSBKqfPQO/J5/ApJWq3RpREREQth9hMts9OjRWL58OU6cOIH+/fvj33//FVGX01LDhXukPDeeHkWCuHKWco+dxOWuI5A0cSEq9emEOj9vhP+LT7LZUogrZ4mcB3NEoqgpSw43XADQoUMHbNu2DV5eXhgwYAC+/fZbEcM6LTZd5AhJkqDRaJgjcpirZslwIxk3Xn8fV3u/Dsldh5pff4yqC/4DbVCA0qVVWK6aJXIuzBGJorYsCWm4AKB27drYvHkzunXrhq+//lrUsE6JMxWSI2RZhslkYo7IYa6WJdlgQNryLUhs/RxyvjmK4AX/Qc19y+HZvJHSpVV4rpYlck7MEYmitizZdaxu3bp1aNCgQZHHPTw88OGHH6Jnz55ISUlxuDhnpJYPnpRlMBig0+mULoNUwFWylPvj70iaEIOCv87D78W+CJwwAtrKfkqXRYW4SpbIuTFHJIqasmRzw5Wbm4s5c+bgmWeewbPPPlvsMo8++qjDhRERkeszXE9C8rRYZG3/Bh6PRKDWgTh4NA1XuiwiIqJyY3PD5eXlhcuXL6vmnEoiIhJPLtAjbcVWpM77BJKXB4IXTYDvwMchaYSdyU5EROQS7PqXr3379jhy5IjoWoiISAVyDv+KxI4vIeW9j+E3uBfq/LwRfs/2ZLNFREQVkl3/+r322mu4cOEC3n33Xfz666+4ceMG0tLSivynRjyyRyJo+MWTBHGmLBmu3MD1YVNx7em3oA30R63vVqHKB29C68/7M7oCZ8oSuS7miERRU5bsmjSjV69eAICzZ89i165dd13uzJkz9lXl5Nh0kSMkSVLVvSVIOc6SJTm/AGnLNiM1eh00Pt6ounQyfPp3477ShThLlsi1MUckitqyZNeavP766/yHlMgBsizzd4iEUDpLOd8dQ9KEGOgvXoP/yP4IfPclaHwrKVYP2U/pLJE6MEckipqyZFfDNWbMGNF1uAxZllUVACp/sixDr9dDp9MxR+QQJbOkv3QNyVMWI3vPD/Bs2xzV1n4A94b1yrUGEof7JRKBOSJR1JYlIcfq8vLyAACenp4ihiMiIidlystHWuxnSIv5FJoAP1RdMQ0+T3ZRxT+IREREZcHuhuvq1atYvHgxDh06hNTUVABA5cqV8eijj2L06NGoWbOmsCKJiEh52ft/QtKkRTBcvo6AVwei8tsvQOPjrXRZRERETs2uhuvcuXMYPHgwMjMz0aZNG9SvXx8AkJCQgC+++AIHDx7Exo0bERoaKrRYIiIqf/oLV5E0aSFy9v8Er0cfRvWNH8L9/vuULouIiMgl2NVwzZ8/HxqNBjt27EB4eLjVc//88w9efPFFzJ8/H7GxsUKKJCKi8mfKzUfaovVIW7wR2ioBCFn9Hir1fpSnDxIREdnArobrl19+wUsvvVSk2QKAsLAwPPfcc/jkk08crc0p8YsGiaDT6ZQugVSiLLIkyzJy9v6ApClLYLiehIDXBqHy2OehqeQl/L3IeXC/RCIwRySKmrJkV8NlMBhKnCDDy8sLBoPB7qKcHZsucgTzQ6KURZYKziUiaeJC5H53DF6dW6L6lvlwr19b+PuQc+F+iURgjkgUtWXJrls4N2rUCFu3bkVmZmaR57KysrBt2zY88MADDhfnrGRZVroEcmGyLMNgMDBH5DCRWTJl5yL5/RVI7PAC9Gcvodq6D1B900dstioI7pdIBOaIRFFbluy+D9eIESPQo0cP9OvXD3Xr1gUAnD9/Hjt27EBaWhqmTp0qsk6noZYPnpRlMpmg1WqVLoNUwNEsybKM7K++R/LUJTAmpaHyG88h4I0h0Hh5iCuSXAL3SyQCc0SiqClLdjVcrVu3xooVKzB37lysWLHC6rlGjRrho48+QqtWrYQUSEREZaPg34tImhCD3EO/wrt7W1SZ9QZ0dWsoXRYREZGq2H0frjZt2mDnzp24desWrl69CgCoUaMGgoODhRVHRETimbJykDr/E6Qt3wK3WtVQbcOHqNStjdJlERERqVKpG64FCxagZ8+eaNiwodXjwcHBbLKIiFyALMvI2vktkqfGwpSeicBxL8H/9UHQePL0QSIiorJS6kkzVqxYgX///dfyc2pqKho1aoSjR4+WSWHOSm2zppAy1HJOMimvtFkq+Os8rvYbi5sjZ8DzoQdQ+8f1qPzOC2y2yIL7JRKBOSJR1JQlu08pBCruBBJsusgRkiSpaidCyilNlkyZ2UiZuxrpcZ9DV7cGqm+eB+/OLcupQnIV3C+RCMwRiaK2LDnUcFVUsiyz6SK7ybJsyRBzRI4oKUuyLCNr234kT18KU1YOAicMR8CoAZA83BWqlpwZ90skAnNEoqgtS2y4bFRRj+qRWAaDQVV3UCflFJel/FNnkRQVjbxjJ1Gpb2dUmfEa3GqGKFQhuQrul0gE5ohEUVOWbGq4rly5gj///BMALDc9vnjxIvz8/IpdvnHjxg6WR0REpWVMz0TqnFVIX70Duga1Uf3zaHh3eFjpsoiIiCo0SS7lIZuGDRsWe8pKcYf5zI+fOXNGTJVOIj4+HrIsIzIyUhWHN0kZsixDr9dDp9MxR+QQc5bctFpkbd6H5PeWQ87NR+C7L8F/RH9I7ur4yyCVPe6XSATmiERxlSzFx8cDACIjI0tcrtRHuGbPnu1YRUREJFxB/D+4OWkJ8o//CZ+nH0PQ9NfgVq2K0mURERHR/yt1w/XUU0+VZR0uw5m7bHIdzBE5ypiageT3VyBz3ZfQNayLGjsXwattc6XLIhfG/RKJwByRKGrKEifNsIOaAkDlT5Ik1VwESuVPNpmQuWEXkmetAPQGBL03Bv4vPwVJx9052Y/7JRKBOSJR1JYl/gtNROQi8n47jaSoGOT/fgY+Ax5H0NRRcAsJUrosIiIiKgEbLjvwPlzkCFmWYTAY4ObmxhxRqRiT05A862NkbtgN9wfqo8auWHi1bPK/STOYJXIQ90skAnNEoqgtS2y4bMT7cJEIzBGVhmw0ImPdl0j5IA6QZVSZPRZ+L/SB5Pa/XTezRKIwSyQCc0SiqClLbLiIiJxQ3i+ncGv8AhTE/wvfwb0QOPkVuAVXVrosIiIishEbLiIiJ2K4lYqUmcuQuWkv3JuEoebe5fB8mDeRJyIiclVsuIiInIBsMCBjzU6kzFkFaDWoMm8c/Ib0hqTVKl0aEREROYANl43UcOEeKU9NU52S43KPnkDShGgUnE6A3/NPIHDSSGgD/Uv1WmaJRGGWSATmiERRU5bYcNmBTRc5gvkhM8P1JCTPXIasrfvh8WAj1Ny/Ap7NGpb69cwSicIskQjMEYmitiyx4bIDp4UnR8iyDJPJBI1GwxxVULLegPSV25Aydw0kDx2Co8fDd3BPSBqNbeMwSyQIs0QiMEckitqyxIbLRmqaopKUYzQaobHxyzWpQ+6Pv+NWVDT0/1yE34tPIjBqGLSV/ewej1kiUZglEoE5IlHUlCU2XERE5cBw7RaSp8Uia8e38HwkAiEH4uDRJEzpsoiIiKiMseEiIipDcoEeaR9vQeq8tdBU8kTw4onwHdDd5tMHiYiIyDWx4SIiKiM5h35F0oQY6BMuw39YP1Qe/zK0fj5Kl0VERETliA2XjdRw4R4pT8t7K6ma/vINJE9ZjOxdh+DZuilCVs6AxwP1y+S9mCUShVkiEZgjEkVNWWLDZQc2XeQISZJUtROh/5HzC5C2dBNSYz6FxrcSqi6fCp9+Xctsn8EskSjMEonAHJEoassSGy47cFp4coQsy5YMMUfqkfPtMSRNjIH+0jX4j3wGgeNehMa3Upm+J7NEojBLJAJzRKKoLUtsuGzEaeFJBIPBoKo7qFdk+kvXkDR5EXL2HoFX+wdRbd0HcA+vV27vzyyRKMwSicAckShqyhIbLiIiO5jy8pG2ZCPSFq6HprI/QuJmoFLfTqr4SxwRERGJw4aLiMhG2V//iKTJi2C4chMBrw5E5beGQuPjrXRZRERE5ITYcBERlZL+/BUkTVqInANH4dXxEVT/7CO4N6ijdFlERETkxJzqzpt79+7Fq6++ig4dOqBZs2bo27cvtm3bVuS6qa1bt6J79+6IjIxEnz59cPDgwSJjZWZmYuLEiWjRogWaN2+ON954Azdv3nS4Rp4uRCIwR67FlJOHlNkrcand8yg4k4CQNbNQfct8p2i2mCUShVkiEZgjEkVNWXKqhuuTTz6Bl5cXoqKisGzZMnTo0AFTpkxBbGysZZndu3djypQp6NGjB+Li4tCsWTOMHj0af/zxh9VYY8eOxY8//ojp06dj3rx5OH/+PEaMGAGDweBwnWoKAJU/SZKg0+mYIxcgyzKydh9GYrvnkbpkIyqPHozaP66HT+9HneLzY5ZIFGaJRGCOSBS1ZUmSnWjavZSUFAQGBlo9NmXKFOzZswe//PILNBoNunfvjoiICMyfP9+yzKBBg+Dr64u4uDgAwO+//45BgwZh1apVaNeuHQAgISEBPXv2xIIFC9CzZ0+76ouPjwcAREZG2vV6InIdBecuISkqBrnf/wLvrq1Q5f03oQutpXRZRERE5CRK2xs41RGuO5stAGjUqBGysrKQk5ODxMREXLhwAT169LBapmfPnjh69CgKCgoAAIcPH4afnx/atm1rWSY0NBSNGjXC4cOHHa7TiXpUckGyLEOv1zNHCsvNzUV8fDxSUlIQHx+P3NxcAIApOxfJ7y1HYvsXoD9/GdXWz0G1jXOdstlilkgUZolEYI5IFLVlyeknzTh+/DhCQkLg4+OD48ePAwDq1bO+x039+vWh1+uRmJiI+vXrIyEhAfXq1StyGDI0NBQJCQkO1aOWD56UxRwpLzc3F6dOnYKPjw9OnTqFwMBApG8/AK+4LyCnZqDyW0MRMHow8mHCqVOn0KBBA3h5eSlddhHMEonCLJEIzBGJoqYsOXXD9euvv2LPnj0YP348ACA9PR0A4OfnZ7Wc+Wfz8xkZGfD19S0ynr+/P06dOuVwXcUFQJKkuwbD3PiV9HxZvZbjOt9nY37M1dbVmbahqHH1BiMuXc+E25Uk5I2YCY9fTkPbuQWqffg2dPfVAADk/P8RsBo1algaLmfZhoUfc5aaOK7z1+RqWXLGmlxt3PKqSZZly39q24au/tm42ri2ZKm8airta4vjtA3X9evX8dZbb6Fly5YYOnSo0uVY0ev1VkfPNBoN3NzcLM/dyd3dHQBgNBphMpmsnnNzc4MkSTCZTDAajVbPmcc1H1a9k/nu28WNq9VqodVqIctykYlCzBciArfv4n1nYMpq3NKsK1B0G5bVuOZ1lSTJ5nUtzbhA8dtQo7l9Jq/obWiut7ialNqG5nFL2oZlle/c3Fz8/fffqFevnqVRys3Nxb///osaNWogKSUDF89dg3b1D2hx+gwMIUH46+VueOTNYcjxqYyr55MQEuht2V6Ft4vobWjvPqLwPwjFTQjEfYRj45rXtbz3EWW1DUvaRxRWUfYRd1tX83MlbcPyzDfgOt8jzMtyH3HvdXW1fUR5b0Pzuplf56z7CHNDeC9O2XBlZGRgxIgRCAgIwOLFiy1fUP39/QHcnvI9ODjYavnCz/v5+eH69etFxk1PT7cs44iSZk0xfwjFKRzkO2k0Gst63qnwB2/ruPd6rTnI5TluSesKlLwNRY9r/hwdWVdbPxtZlmEymbgNS/GcI+Pm5ubi9OnTqF27tmWZzMxM/PLLL3DX6RDwy1k8ue8XuBcY8McjobjSsSly9XnIOngIZ27qkHgtE7Wr+6JTs2BkZ2cjMzMTVatWBVB2n42t+wjzPxTcR5TduErsI0o7rsh1Lfylw9m2oVL5duTfZWfZR5iV1za884ups+S7LMetKPuIshy3uG1ozpL5OWfdR5Sm2QKcsOHKy8vDK6+8gszMTGzevNnq1MDQ0FAAt2ccNP9/8886nQ61a9e2LHf06NEiXef58+cRFhbmUH2SJFn+K+65e73WnucceS3HLdtx7X2t+S9BZbE+FWUblnZcSZKQmV2Aa8nZ8NLq4XMjDY32HEfl8zdwsX4Ifm7dEAUBXvA0FqCgoABnz/4DrSyhrjeAdODHIxIkACdOnED9+vXLvF5bnzP/Y+BMNXFc567J1bLkjDW52rjlWVPhP0q7Qr1Kj+uMNTnLuKXNUnnWZMtrC3OqhstgMGDs2LFISEjAhg0bEBISYvV87dq1UbduXezbtw9du3a1PL5nzx60bt3acsi9Q4cOWLp0KY4ePYo2bdoAuN1snT59GsOHD3e4Tls2MNGd7tVokRh5eXnIy8vDP2cTsOvna7hy7iae+vcPtDp+AqhZFYb5Y3HekIGH7gvH5Yt/o1HDcPzxxx+o3yAMP/yZZjnC9WizYJz99280a9ZM6VUqglkiUZglEoE5IlHUliWnarhmzJiBgwcPIioqCllZWVY3M37ggQfg7u6OMWPGYNy4cahTpw5atmyJPXv24OTJk1i/fr1l2ebNm6Ndu3aYOHEixo8fDw8PD0RHRyM8PBzdunVzuM7Snq9JVBzzKYW2HIom2509exbXrl3DtavX0OBkIgYd/QdueiNOtr4f6T1aokHdYHhfKUBYaHWk3LyI6tWr4+LFi3jk4QfRuk0lXE/OQbUgbxgKsnHj+lUEBAQovUpFMEskCrNEIjBHJIrasuRUDdePP/4IAJgzZ06R57799lvUqlULvXv3Rm5uLuLi4rBixQrUq1cPS5YsQfPmza2Wj4mJwezZszF16lQYDAa0a9cOkydPLvFczNKwZUYSorsxGo0lnuNMYgQmZ+Hh7/9C5Uu3cK5BdfzeIRJyZR2qaDXQ6XSIiIiAv78/IiIi4OHhYXmdn48H/Hxu/5ySkq1U+aXCLJEozBKJwByRKGrKkiSzgyi1+Ph4yLKMyMhIVXTbpAzzbDolTb5CjjGmZSJx8kIYtuyHVLcGtFHDkHx/A3hoC3D8l5/RoUMHVKtWzeq+Wrm5uTh79myR+23d7XFnwCyRKMwSicAckSiukqX4+HgAQGRkZInLOdURLiIiR8gmEzI/24vkWcthys1HYt/WaDLrHQSFVEVdACkpKYh3d4e/v3+R5snLy6vYHebdHiciIiIqDTZcRKQK+Sf+xq3xC5B//DR8+j+GSuNfRk5mKrz9/jfTqZeXFyIiIpzuSBURERGpFxsuGznzYU1yHWo5J9kZGFPSkfJBHDLWfQn3RvVQ44vF8GrTDAAQiVpWy6rxaBWzRKIwSyQCc0SiqClLbLjswKaLHCFJksOTtxAgG43I3LAbybM+BgxGBM16A/4vPwmpAm1bZolEYZZIBOaIRFFbltSzJuWI08KTIwrPU8Mc2Sfv+J9IiopB/h9/wXdQDwROGQW3qoFKl1XumCUShVkiEZgjEkVtWWLDZSNO6kgimGfeIdsYk1KRPOtjZG7YDffI+1Fz91J4tlDXKYK2YpZIFGaJRGCOSBQ1ZYkNFxE5PdloRMYnXyBldhwAoMqHb8PvhT6QtFqFKyMiIiIqGRsuInJqef+Nx63x0Sj48yx8n+uFoEkjoa1SWemyiIiIiEqFDRcROSXDzRSkzFyGzM374NGsIWruWw7PBx9QuiwiIiIim7DhIiKnIhsMSF+1A6kfrgJ0bghe8C58B/fi6YNERETkkthw2UiSJFXMlkLKkSQJ7u7uSpfhlHJ/+gNJE6JRcOY8/F7og8AJI6AN9Fe6LKfFLJEozBKJwByRKGrLEhsuIlKc4XoSkqcvRdbnB+Dx0AOodSAOHk3DlS6LiIiIyGFsuOzA+3CRI2RZhtFohFarrfA5kvUGpMdtQ8rc1ZC8PBC8MAq+g3pAUtHd5csSs0SiMEskAnNEoqgtS2y4bMT7cJEIJpMJ2gp+TVLOD8eRFBUN/dlE+L30JAKjhkMb4Kt0WS6HWSJRmCUSgTkiUdSUJTZcRFSuDFdvImlqLLK/+A6eLZsg5Nvp8IhooHRZRERERGWCDRcRlQu5QI+0ZZuRumAtNJW8UTV2Enye6a6KUwWIiIiI7oYNFxGVuZyD/0XShBjoL1yF//B+qPyfl6H181G6LCIiIqIyx4bLRvxrPIng5lYxfvX0ideRPGUJsncfgmebZghZMwsejUKVLktVKkqWqOwxSyQCc0SiqClL6lmTcsSmixxREe7lZsrLR3rsJqQu/BQaf19U/XgafJ7qovr1Lm8VIUtUPpglEoE5IlHUliU2XHbgtPDkCFmWYTKZoNFoVJmj7ANHkTRxIQyXryNg1ABUfudFaHy8lS5LldSeJSo/zBKJwByRKGrLEhsuG3FaeBLBaDRCo7J7TekvXEXS5EXI+fpHeHV4CNU3zIF7WF2ly1I9NWaJlMEskQjMEYmipiyx4SIih5hy85G2eAPSFm2AJigAIStnolKfjqr4ixQRERGRo9hwEZFdZFlGztc/ImnyIhiu3kLAa4NQ+a2h0FTyUro0IiIiIqfBhouIbKZPuIykiQuR8+3P8OrUAtU3z4N7/TpKl0VERETkdNhw2YinSZEIrnpOsiknD6kxnyIt9jO4hQSh2tr34d2jPX8vFOSqWSLnwyyRCMwRiaKmLLHhsgO/XJIjJElyuXtLyLKM7F2HkDx1CYy3UlF5zGAEvDEEGm9PpUur0FwxS+ScmCUSgTkiUdSWJfWsCZELcaVbCxScvYSkCTHI/f4XeD/WGlW2vwldvZpKl0X/z5WyRM6NWSIRmCMSRU1ZYsNlI1mWVRUAKn+yLEOv10On0zl1jkxZOUhdsA5pyzfDrWZVVNswB5W6tVW6LCrEVbJEzo9ZIhGYIxJFbVliw0VEVmRZRvbO75A0LRam1HRUfnsoAkYPhsbTQ+nSiIiIiFwOGy4isij4+/zt0wd/+A2VerZH0HtjoKtTXemyiIiIiFwWGy4igikzGykfrUF63Dbo6lRH9U3z4N2lpdJlEREREbk8NlxEFZgsy8j6/ACSpy+FKTMbgeOHIeDVgZA83JUujYiIiEgV2HDZSA0X7pHydDqd0iUg//Q5JEVFI+/oCVR6oiOCZo6GrlaI0mWRjZwhS6QOzBKJwByRKGrKEhsuO7DpIkconR9jeiZSP1yN9NU7oAutherbouH96MOK1kT2UTpLpB7MEonAHJEoassSGy47cFp4coQsyzAajdBqteWaI9lkQuaWr5EycxlM2XkInDwSASOfgeSunr8gVTRKZYnUh1kiEZgjEkVtWWLDZSNZlpUugVTAZDJBq9WW2/vln/wHt6Kikf/LKfj064qg6a/BrXpwub0/lZ3yzhKpF7NEIjBHJIqassSGi0jFjKkZSJm9Ehlrv4Au7D7U2LkIXm2bK10WERERUYXBhotIhWSTCZkbdiP5/Y8h5+sRNOM1+A97GpKOv/JERERE5YnfvohUJu+Pv5A0fgHyfzsDnwHdETT1VbiFBCldFhEREVGFxIbLRmq4cI+UVxbnJBuT05D8/gpkrt8F9wdCUeOrWHi1aiL8fci5qOX8dlIes0QiMEckipqyxIbLDmy6yBGSJAndichGIzI+/QopH8QBRhOqfPAm/F7sC8mNv95qJzpLVHExSyQCc0SiqC1L/EZmB04LT46QZdmSIUdzlPfrn7g1fgEKTv4D32d7InDKKLgFVxZUKTk7kVmiio1ZIhGYIxJFbVliw2UjTgtPIhgMBofuoG64lYqU95Yj87M9cG8Shpp7lsHzkQiBFZKrcDRLRGbMEonAHJEoasoSGy4iFyIbDMj45AukzFkJSBKqfPQO/J5/ApKKDrsTERERqQkbLiIXkfvzSSRFRaPg9Dn4DumNoEkjoQ0KULosIiIiIioBGy4iJ2e4kYzkmcuQteVreDRvhJpffwzP5o2ULouIiIiISoENl43UcOEeKa80OZL1BqSv2o7UuasBnRuCF/wHvs/1gqTRlEOF5Cq4TyJRmCUSgTkiUdSUJTZcdlBTAKj8SZJ0z4tAc3/8HUkTYlDw13n4vdgXgRNGQFvZr5wqJFdRmiwRlQazRCIwRySK2rLEhovIiRiuJyF5Wiyytn8Dj0ciUOtAHDyahitdFhERERHZiQ2XHXgfLnKELMswGAxwc3Oz5Egu0CNtxVakzvsEkpcHghdNgO/Ax3n6IJWouCwR2YNZIhGYIxJFbVliw2Uj3oeLRCico5zDvyIpKgb6c4nwH9YPlce/DK2/r4LVkSvhPolEYZZIBOaIRFFTlthwESnEcOUGkqctRfaXB+HZsglC4qbDo3EDpcsiIiIiIoHYcBGVMzm/ABmxnyFj0QZofLxRdelk+PTvpopD5kRERERkjQ0XUTnK+e4YkibEQH/xKvxH9Efgf16GxreS0mURERERURlhw2UjHoUge+gvXUPylMXI3vMDPNs1R8gn78O9YT3miRympmlzSVnMEonAHJEoasoSGy478EsylZYpLx9psZ8hLeZTaCr7I2TFdFR6sjMzREIwRyQKs0QiMEckitqyxIbLDpwWnkoje/9PSJq0CIYrNxAwagAqv/0CND7elqlOtVotc0QOkWUZRqORWSKHMUskAnNEoqgtS2y4bKSmKSqpbOjPX0HS5EXI2f8TvDo+guobP4T7/fdZLWMymaDVahWqkNSEWSJRmCUSgTkiUdSUJTZcRIKYcvKQtmg90pZ8Bm2VAISsfg+Vej+qir/MEBEREZF92HAROUiWZeTs/QFJkxfDcCMZAa8/i8pvDoGmkpfSpRERERGRwthwETmg4NwlJE1chNzvjsG7SytU37oA7vVrK10WERERETkJNlw24ulhBACm7FykRq9D2rLNcKtWBdXWfQDvx9uVOh9qOSeZlMcskSjMEonAHJEoasqSRukCCrt48SKmTp2Kvn374oEHHkDv3r2LXW7r1q3o3r07IiMj0adPHxw8eLDIMpmZmZg4cSJatGiB5s2b44033sDNmzeF1Mmmq+KSZRlZXx5EYtshSF++BZXfHILaRz5FpR7tS50LSZJUM+sOKYtZIlGYJRKBOSJR1JYlp2q4/v33Xxw6dAj33Xcf6tevX+wyu3fvxpQpU9CjRw/ExcWhWbNmGD16NP744w+r5caOHYsff/wR06dPx7x583D+/HmMGDECBoPB4To5U2HFVPDPBVx75m3cGDYV7hH3o/aRTxH4n5eh8fKwaRxZlmEymZgjchizRKIwSyQCc0SiqC1LTnVKYefOndG1a1cAQFRUFE6dOlVkmUWLFqFXr14YO3YsAKBVq1b4559/EBsbi7i4OADA77//jiNHjmDVqlVo164dAKBevXro2bMn9u/fj549e9pdo1o+eCo9U1YOUud/grTlW+BWqxqqbfgQlbq1cWhMg8Ggqjuok3KYJRKFWSIRmCMSRU1ZcqojXBpNyeUkJibiwoUL6NGjh9XjPXv2xNGjR1FQUAAAOHz4MPz8/NC2bVvLMqGhoWjUqBEOHz4svnBSJVmWkbn9G1xq/RzSV21H4LiXUPuHtQ43W0RERERUcTjVEa57SUhIAHD7aFVh9evXh16vR2JiIurXr4+EhATUq1evyHmfoaGhljEcUdxRLkmS7nr0y1xHSc+X1Ws5rn3jFpxJQNLEhcj78Xd492yPoPfGQFe7mtWy9tZkfsxZ1lXpcZ2xJlcZt/BjzlITx3X+mlwtS85Yk6uNW141ybJs+U9t29DVPxtXG9eWLJVXTaV9bXFcquFKT08HAPj5+Vk9bv7Z/HxGRgZ8fX2LvN7f37/Y0xRtpdfrrZo5jUYDNzc3y3N3cnd3BwAYjUaYTCar59zc3CBJEkwmE4xGo9Vz5nFlWS52XPNh1uLG1Wq10Gq1kGW5yHVrkiRZXmswGIoEpqzGLc26AkW3YVmNa15XSZIs62rKyEL6gnXIWr0DbnVrovrmefDs+AgMBoPV60szLlD8NjQfyRW9Dc2fTXE1lec2LG7c4tZV6XyXtA3LM9+A/fuIwv8gFHd9KvcRjo1rXte75bukdXVkH1FW27CkfURh3EeoZx9R3tvQvCz3EfdeV1fbR5T3NjSvm/l1zrqPMDeE9+JSDZezMAfjbs/dTeEg30mj0dz1lMrCH7yt497rteYgl+e4Ja0rUPI2FD2u+XPUaDTI+fwbpMxYBlN2DgInDIf/KwOg8fSALMsl1mTrZ1P4LzZq2ob25kWpfDvyO1dWn42t+whZlmE0GrmPKMNxHc333cY1c5ZtaM6S6HEB7iNsGRdw7e8Rd375dJZ8l+W4FWUfUZbjFrcNzVkyP+es+4jSNFuAizVc/v7+AG5P+R4cHGx5PCMjw+p5Pz8/XL9+vcjr09PTLcvYS5KkEndo93qtPc858lqOe+/n8k+dRVJUNPKOnUSlvp1RZcZrcKsZUmY1lZQhR8YtzXPOOK4z1uQq45Z1lhx5Lcd13ppcLUuOvJbjlm9NkiRZjsaJHFfUc844rjPW5Azj2pKl8qrJ1tcW5lSTZtxLaGgoABS5DishIQE6nQ61a9e2LHf+/PkihwDPnz9vGYPImJ6JpAkxuNxlGIyp6aj+eTSqrZxh1WwRERERETnCpRqu2rVro27duti3b5/V43v27EHr1q0tnXCHDh2Qnp6Oo0ePWpY5f/48Tp8+jQ4dOjhchy0XyZHzkU0mZGzcjUutBiPjsz0ImjoKtQ+ugXeHh8vn/f//XGPmiBzFLJEozBKJwByRKGrLklOdUpibm4tDhw4BAK5cuYKsrCxLc9WiRQsEBgZizJgxGDduHOrUqYOWLVtiz549OHnyJNavX28Zp3nz5mjXrh0mTpyI8ePHw8PDA9HR0QgPD0e3bt0cqlEtH3xFlX/ib9yKikb+r3/C5+nHEDT9NbhVq1LudTBHJAqzRKIwSyQCc0SiqClLkuxEa3P58mV06dKl2OfWrVuHli1bAgC2bt2KuLg4XL16FfXq1cPbb7+NTp06WS2fmZmJ2bNn48CBAzAYDGjXrh0mT56MkBD7TxeLj4+HLMuIjIy06bxNUp4xNQMpH6xAxtov4d6wHqrMHguvts0VqcX8V5uSJl8hKg1miURhlkgE5ohEcZUsxcfHAwAiIyNLXM6pGi5nx4bL9cgmEzI37ELyrBWA3oDK44fB/+WnIOmUO7jrKjsRcn7MEonCLJEIzBGJ4ipZKm3D5VSnFBKJlPfbaSRFxSD/9zPwGfA4gqaOgltIkNJlEREREVEFwobLRs7cZdNtxuQ0JM/6GJkbdsP9gfqosSsWXi2bKF2WlZLu60BkC2aJRGGWSATmiERRU5bUsybliE2Xc5KNRmSs+xIpH8QBsowqs8fC74U+kJzsF7bwjfyIHMEskSjMEonAHJEoasuSc30TdRF33kmdlJf3yyncGr8ABfH/wndwLwROfgVuwZWVLqtYsizDZDLZdIdyouIwSyQKs0QiMEckitqyxIbLRpxjxLkYbqUiZeYyZG7aC4+m4ai5bzk8H2qsdFn3ZDQaodG41G3wyEkxSyQKs0QiMEckipqyxIaLXJJsMCBjzU6kzFkFaDWoMm8c/Ib0hqTVKl0aEREREZEFGy5yOblHTyBpQjQKTifAb2gfBE4cAW2gv9JlEREREREVwYaLXIbhehKSZyxF1rYD8HjoAdTcvwKezRoqXRYRERER0V2x4bKRGi7cczWy3oD0lduQMncNJA8dgmOi4PtsD0gufF6vWs5JJuUxSyQKs0QiMEckipqyxIbLDmy6yk/ukd9wKyoa+n8vwe/FJxE4YTi0Ab5Kl+UQSZJUdW8JUg6zRKIwSyQCc0SiqC1L6lmTcsRp4cue4epNJE+LRdbO7+D5SARCvlkJj8j7lS5LiMIzXTJH5AhmiURhlkgE5ohEUVuW2HDZiNPCly25QI+0j7cgdd5aaCp5oeqSSfAZ0F0Vv2yF6fV66HQ6pcsgFWCWSBRmiURgjkgUNWWJDRc5jZzvf0HShBjoz1+B/7B+qDz+ZWj9fJQui4iIiIjIbmy4SHH6yzeQPGUxsncdgmfrpghZNRMeD9RXuiwiIiIiIoex4SLFyPkFSIvdhNSYddD4+aDq8qnw6ddVdacPEhEREVHFxYbLRmwGxMj+5mckT1wIfeI1+I98BoHjXoTGt5LSZZUb5ohEYZZIFGaJRGCOSBQ1ZYkNlx3UFIDypr94FUlTFiNn7xF4tX8Q1T79AO7h9ZQuq1xJkqSai0BJWcwSicIskQjMEYmitiyx4aJyYcrNR9qSjUhbtB6ayv4IiZuBSn07sXklIiIiIlVjw2UH3ofLNtlf/4ikSQthuHoLAa8OROW3hkLj4610WYqRZRkGgwFubm7METmEWSJRmCUSgTkiUdSWJTZcNuJ9uEpPn3AZSZMXIefAUXh1fATVN82De4M6SpflFJgjEoVZIlGYJRKBOSJR1JQlNlwknCknD2kL1yN1yUa4VQ1EyJpZqNSrgyr+QkFEREREZAs2XCSMLMvI3vMDkqcshuFGMiqPHoyAN4dA4+2pdGlERERERIpgw0VCFJy7hKSoGOR+/wu8u7ZCjW3R0IXWUrosIiIiIiJFseGyEU+Ls2bKzkXqgrVIW7YZbjWCUW39HHh3a8PtdA9ubvzVIzGYJRKFWSIRmCMSRU1ZUs+alCM2E/9/+uAXB5E0LRamlDRUfmsoAkYPhsbLQ+nSnJ4kScwQCcEskSjMEonAHJEoassSGy47VPRp4Qv+uYCkCTHIPXwc3o+3Q5VZY6C7r4bSZbkMWZZhMpmg0WgqdI7IccwSicIskQjMEYmitiyx4bKRmqaotJUpKwcp89Yg/eOt0NWujmob56LSY62VLsslGY1GaDQapcsgFWCWSBRmiURgjkgUNWWJDRfdkyzLyNr+DZKnxcKUkYXAd1+G/2sDofHk6YNERERERCVhw0Ulyj+TgKSoaOT99Acq/V979x8XVZ3vcfw9wPgL+ekvDHUBM3+ECpWhtlboVotWdlvdtUytNUNNXWm9iXp1U/GmPrYfaLaZuqXmPkrL8hd5LTUqtat2Ka/erQyypbz+QHEGUBRm5v6xFx4RKCBnODPH1/M/zgznfMbH26/zduacc+8dajVvkuwdo8weCwAAAPALFC7UyOUsVuGiv8qxaqPssdFqv/45tUi+1eyxAAAAAL9C4aonK5y4dyUet1vFG3bozNy/yF1yQZGzxik89beyNbGbPZqlWOU7yTAfWYJRyBKMQI5gFCtlicJ1Faxaui7+91EVTH9epQcOq+UDA9Vq7pMKuq6t2WNZjs1ms9S9JWAesgSjkCUYgRzBKFbLknVeSSOy2mXhXeeKdPbZlXK+/p7sXTrpuncz1fyXN5k9lmX99EqXVsoRGh9ZglHIEoxAjmAUq2WJwlVPVrosvMftVtHfsnQm4xV5Lpap1TMTFPb4MNnsxMLbysrKZLfzNU00HFmCUcgSjECOYBQrZYl31teo0i++UkH6C7r4+f+o5fC71WrOBAVFtTZ7LAAAAMBSKFzXGNdZh87++wo512xWk+6xum7zS2rer7fZYwEAAACWROG6RnhcLjnf2KqzC16Vyl1qlTFFYb9/QDYLnZAIAAAA+BrebV8DSj8/ooLpL+jil18rZESKImePV1DbSLPHAgAAACyPwlVPNpvNb66W4ioo1Jn5y1X0t21q0rOLore9rGa39jR7rGuezWaT3W73mxzBd5ElGIUswQjkCEaxWpYoXBbkcbnkfH2Tzj67QpLUetFTCh1zv2yBgSZPhgpWWUBgPrIEo5AlGIEcwShWyhKF6yr48n24LvznIRWkv6hLR75VyMghajXrCQW2jjB7LPyEx+ORy+VSYGCgz+YI/oEswShkCUYgRzCK1bJE4aonX70PV/mpszoz9y8qXr9dTRO6KXr7K2p2Uw+zx8JluN1uBfKJIwxAlmAUsgQjkCMYxUpZonD5OU95uRyr3lXholWSPUhtnv9XhTw8hK8PAgAAAD6AwuXHLuz9QgXpL+jSV98pdMz9ipwxToGRYWaPBQAAAOD/Ubj8UPmJAp155mUVv/OBmt7cQx0+WKGmvbuaPRYAAACAn6Fw1ZOZJ+55ysrlWPG2zi7+q2zNm6pNZrpCRqTIFhBg2ky4Olb5TjLMR5ZgFLIEI5AjGMVKWaJwXQUzStf5Tz5XQfoLKvs2X6GPPaDI9McVGB7S6HOg4Ww2m6UWEZiHLMEoZAlGIEcwitWyROG6Co15Wfjy46dUMGeZSjbtUrOkXmq38xk1jb++UY4N7/B4PJUZssKlTmEesgSjkCUYgRzBKFbLEoWrnhrrsvCeS2U695e3VPj8agUEt1DbZbPUcvg9lggdpPLyctntdrPHgAWQJRiFLMEI5AhGsVKWKFw+6Pzu/SqY8aLKjh1X2OMPKuLp3yswtKXZYwEAAACoJwqXDynLP6Ezs19SybZsNeufoHavZahp9zizxwIAAABwlShcPsBdelGOZW+qMHOtAsJC1Hb5n9TyXwbx9UEAAADAz1G46snoElTywT4VzMxU+Q8nFD7+t4r446MKaNnC0GPA9wRwKX8YhCzBKGQJRiBHMIqVskThugpGlK6yY8dV8G9LdP4/9qj57Ter/bqFanJDTMOHg8+z2WwKCuKvHhqOLMEoZAlGIEcwitWyZJ1X4ifcFy7q3NJ1OrdknQJbh6vdqnkKvu9Ovj4IAAAAWBCFq55+el+A+v7e+e2fquDflqr8f08rfOIIRaSNVkBwcy9NCl/l8XhUVlYmu91O0UaDkCUYhSzBCOQIRrFalihcjeBSbr7OzFqi8zs/U/OBSWq//s9q0rmT2WMBAAAA8DIKlxe5Sy6o8MW1Ovfymwpq10pRqxeoRcoASzR1AAAAALWjcHmBx+NRydZsnZm9VK6Cc4qYMlLhk0cqoEUzs0cDAAAA0IgoXAa7dPR7FczM1IWPDqjF3f3VOmOK7LHRZo8FAAAAwAQUrnq63NcB3cXnVfj8ap17Zb2Cotsqat1CBd99WyNPB39ht9vNHgEWQZZgFLIEI5AjGMVKWbJ04crNzVVGRoZycnIUHBysoUOHaurUqWrSpEmD9vvT0uXxeFTy3i4V/GmZ3IUORfxxjMKffEgBzZo2dHxYFOfwwShkCUYhSzACOYJRrJYlyxYuh8OhMWPGKCYmRkuXLtXJkye1cOFClZaWas6cOQ3ad8Vl4S999Z1Oz3hRpZ/+l4IHD1Cr+ZNl79TeoFcAq/J4PHK5XAoMDLTcgoLGRZZgFLIEI5AjGMVqWbJs4XrzzTdVUlKil156SeHh4ZIkl8uluXPnKjU1Ve3atbuq/Xo8HrmLSlT459flWPG27J3aq/2bf1aLQUkGTg+rc7vdCgwMNHsMWABZglHIEoxAjmAUK2UpwOwBvOXjjz9Wv379KsuWJKWkpMjtdmvPnj1Xvd/AD/crv99IOVdvUuT0ser48WrKFgAAAIAaWbZw5eXlKS4ursq20NBQtWnTRnl5eVe932bPrlazpF7quOcNRUwdJVvThp0PBgAAAMC6LPuVQqfTqdDQ0Grbw8LC5HA4rmqfZWVlKn52os4nxet04Smp8FRDx8Q1quI8QKChyBKMQpZgBHIEo/hDli5dulSnGS37CZc32Gw2uW7qavYYsABfX0DgP8gSjEKWYARyBKP4Q5ZsNlud5rTsJ1yhoaEqKiqqtt3hcCgsLOyq9pmYmNjQsQAAAABcQyz7CVdcXFy1c7WKiop0+vTpaud2AQAAAIA3WLZw3X777dq7d6+cTmfltu3btysgIEC33XabiZMBAAAAuFbYPB6Px+whvMHhcGjIkCGKjY1Vampq5Y2P77vvvgbf+BgAAAAA6sKyhUuScnNzNX/+fOXk5Cg4OFhDhw5VWlqamjThUu4AAAAAvM/ShQsAAAAAzGTZc7gAAAAAwGwULgAAAADwEgoXAAAAAHgJhQsAAAAAvITCBQAAAABeQuECAAAAAC+hcAEAAACAlwSZPYA/yM3NVUZGRpUbKE+dOpUbKKNeNm7cqBkzZlTbPm7cOE2bNs2EieAPvv/+e61atUpffvmljh49qri4OG3durXa8zZs2KCVK1fq+PHjio2NVVpampKTk02YGL6qLlkaNWqU9u/fX+13s7Ky1Llz58YaFT7s/fff1+bNm3XkyBE5nU794he/0KhRo/Sb3/xGNput8nmsSahNXbJklTWJwlULh8OhMWPGKCYmRkuXLtXJkye1cOFClZaWas6cOWaPBz+0cuVKhYSEVP7crl07E6eBrzt69Kiys7PVu3dvud1u1XSv+m3btmn27NkaP368+vbtq6ysLE2aNEnr1q1TQkJC4w8Nn1SXLEnSTTfdpOnTp1fZ1qFDh8YYEX7g9ddfV3R0tNLT0xUREaG9e/dq9uzZOnHihCZNmiSJNQl1U5csSdZYk2yey624kCQtX75cr7zyinbv3q3w8HBJ0ltvvaW5c+dq9+7dvFlGnVV8wrVv3z5FRkaaPQ78hNvtVkDAP7/9nZ6ersOHD1f7VOKee+5RfHy8nnvuucptI0aMUEhIiFasWNGo88J31SVLo0aNUosWLbR8+XIzRoQfOHv2bLV/w2bPnq2srCwdOHBAAQEBrEmok7pkySprEudw1eLjjz9Wv379KsuWJKWkpMjtdmvPnj3mDQbgmlDxBvly8vPzdezYMaWkpFTZPnjwYO3bt0+XLl3y5njwI7VlCaiLmv7DsHv37iouLtb58+dZk1BntWXJSlh9a5GXl6e4uLgq20JDQ9WmTRvl5eWZNBX82b333qvu3btr0KBBWr58uVwul9kjwY9VrEOxsbFVtnfu3FllZWXKz883Yyz4sf379yshIUE9e/bUI488ogMHDpg9Enzc559/rnbt2qlly5asSWiQn2apghXWJM7hqoXT6VRoaGi17WFhYXI4HCZMBH/Vpk0bTZ48Wb1795bNZtOuXbv04osv6uTJk5wPiKtWsQ79fJ2q+Jl1CvXRp08fDR06VDExMTp16pRWrVqlxx57TGvXrlViYqLZ48EHHTx4UFlZWZXn2LAm4Wr9PEuSddYkChfQSAYMGKABAwZU/vzLX/5STZs21erVqzV+/Hi1bdvWxOkAQJoyZUqVn++8807de++9evnllzn3BtWcOHFCaWlpSkpK0ujRo80eB37sclmyyprEVwprERoaqqKiomrbHQ6HwsLCTJgIVpKSkiKXy6W///3vZo8CP1WxDv18nXI6nVUeB65GixYtdMcdd+jIkSNmjwIf43Q6NW7cOIWHh2vp0qWV5wiyJqG+LpelmvjrmkThqkVcXFy1c7WKiop0+vTpaud2AUBjq1iHfr5O5eXlyW63q2PHjmaMBcDCSktLlZqaqqKiomq3OmFNQn1cKUtWQuGqxe233669e/dW/s+MJG3fvl0BAQG67bbbTJwMVpCVlaXAwED16NHD7FHgpzp27KiYmBht3769yvasrCz169ePG7SjQc6fP6+PPvpIPXv2NHsU+Ijy8nJNnTpVeXl5WrlyZbXb47Amoa5qy1JN/HVN4hyuWowYMUJr167Vk08+qdTUVJ08eVKLFy/WiBEjuAcX6mXs2LFKSkpS165dJUk7d+7U+vXrNXr0aLVp08bk6eCrLly4oOzsbEnSjz/+qOLi4so3MrfeeqsiIyM1efJkTZs2TZ06dVJSUpKysrJ06NAhvfHGG2aODh9TW5Yq3vTcddddio6O1qlTp/Taa6/p9OnTyszMNHN0+JCK+5Cmp6eruLhYX3zxReVjPXr0UJMmTViTUCe1ZenQoUOWWZO48XEd5Obmav78+crJyVFwcLCGDh2qtLQ0/pcG9ZKRkaFPPvlEJ06ckNvtVkxMjIYPH65Ro0bJZrOZPR581A8//KBBgwbV+NiaNWuUlJQkSdqwYYNWrFih48ePKzY2Vk899ZSSk5Mbc1T4uNqyFBUVpXnz5unrr7/WuXPn1Lx5cyUmJmrSpEnq1atXI08LXzVw4ED9+OOPNT62c+dOdejQQRJrEmpXW5ZcLpdl1iQKFwAAAAB4CedwAQAAAICXULgAAAAAwEsoXAAAAADgJRQuAAAAAPASChcAAAAAeAmFCwAAAAC8hMIFAAAAAF5C4QIAoAYlJSXq16+fNm/ebPYolQoLC5WQkKDs7GyzRwEA1BGFCwDgd9atW6euXbtq+PDhXjvGmjVrFBwcrCFDhnjtGPUVERGhYcOGKTMz0+xRAAB1ROECAPidLVu2yG6369ChQ/r+++8N339ZWZnWrFmj4cOHKzAw0PD9N8RDDz2kI0eOaN++fWaPAgCoAwoXAMCv5OfnKycnRxMmTJDdbteWLVsMP8ZHH32ks2fPKiUlxfB9N1Tnzp11ww036N133zV7FABAHVC4AAB+ZcuWLQoMDNTvfvc79e/fv8bCtWTJEnXr1q3ap0CzZ89WfHy8vvrqqyse48MPP1R0dLQ6depUZXt6eroSExN1/PhxpaamKjExUQMGDNC6deskSV9//bVGjx6thIQEJScnV5tt48aN6tq1qw4ePKiMjAz17dtXt9xyi+bMmaNLly7J6XTq6aefVp8+fdSnTx8tXrxYHo+n2nz9+/fX7t27a3wMAOBbKFwAAL+yZcsW3XLLLWrdurVSUlJ07NgxHTp0qMpzJkyYoO7du2vWrFkqLi6WJH3yySdav369Jk6cqG7dul3xGDk5ObrxxhtrfMzlcmncuHGKiorStGnTFB0drXnz5mnjxo16/PHHFR8fr2nTpik4OFjTp09Xfn5+tX1kZGTo2LFjmjx5sgYOHKi33npLmZmZGj9+vFwul9LS0nTzzTdr1apV2rRpU7Xfv/HGG+V0OnX06NG6/rEBAExC4QIA+I3Dhw8rLy9PgwcPliT96le/qvFrhXa7XYsWLdKpU6e0cOFCOZ1OzZo1S/Hx8XriiSeueIzy8nL94x//UIcOHWp8/OLFi7r//vs1d+5cjRw5Uq+++qqaNWummTNnasaMGXr66af1yCOPaMmSJXK5XHrvvfeq7aNVq1ZasWKFRo4cqcWLFysxMVGrVq1Sly5d9Nxzz+nhhx/WsmXLFBUVpXfeeafa73fs2FGS9O2339bljw0AYCIKFwDAb2zZskVBQUG6++67JUkhISEaMGCAsrKy5HK5qjz3hhtu0JQpU7RhwwaNHTtWhYWFWrRokYKCgq54DIfDIY/Ho9DQ0Ms+56dXRwwNDVVsbKyaN29e5ZyvuLg4hYaG1vgJ17Bhw2Sz2Sp/7tWrlzwej4YNG1a5LTAwUPHx8TX+fsVshYWFV3wtAADzUbgAAH7B5XJp27Zt6tu3ryIjIyu3Dx48WAUFBTVetW/s2LHq1q2bDh06pEmTJun666+v8/Eud35U06ZNqxxf+mfxi4qKqlKiKrY7nc5q+7juuuuqPU+S2rdvX227w+G47Iw/Px4AwPdQuAAAfuGzzz7T6dOnq105cODAgWrWrFmNF8/Iz8+vvGz8N998U6fjhIWFyWaz1ViUJF32MvGX215TcQsIqPmf38tt/7mKEhYREVGn5wMAzEPhAgD4hYp7b911111VtgcHB+uOO+7QBx98oNLS0srtbrdb6enpatmypcaPH6+tW7dqx44dtR4nKChInTp10g8//GD4azBKxWydO3c2eRIAQG0oXAAAn1daWqodO3aof//+CgsLq/b4r3/9a5WUlGjXrl2V21577TXl5ORo3rx5+sMf/qDExEQ988wzOnv2bK3HS0hI0OHDhw19DUY6cuSIQkJC1KVLF7NHAQDU4spnDgMA4AN27dqlkpISSdKrr75a7fELFy5IkjZv3qzBgwcrNzdXmZmZevDBBzVw4EBJ0sKFC/XAAw9o7ty5yszMvOLxBg0apE2bNum7775TbGyswa+m4fbu3avk5GTO4QIAP0DhAgD4vM2bN0uSsrOzlZ2dfdnnffrppyosLNT06dMVERGhmTNnVj4WExOjp556SgsWLFBWVlblpeVrkpycrIiICL3//vuaOHGicS/EALm5ufrmm2+qvDYAgO+yebhNPQAA1SxbtkwbN27Ujh07LntBDDMsWLBABw8e1MaNG/mECwD8AOdwAQBQg0cffVTnz5/Xtm3bzB6lUmFhod5++21NnTqVsgUAfoJPuAAAAADAS/iECwAAAAC8hMIFAAAAAF5C4QIAAAAAL6FwAQAAAICXULgAAAAAwEsoXAAAAADgJRQuAAAAAPASChcAAAAAeAmFCwAAAAC8hMIFAAAAAF5C4QIAAAAAL/k/iJtcuwkRU8QAAAAASUVORK5CYII=", + "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": 196, + "id": "95dde99f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 0.194561\n", + "1 0.226829\n", + "2 0.258983\n", + "3 0.291654\n", + "Name: w, dtype: float64\n", + "0 0.000683\n", + "1 0.000860\n", + "2 0.001049\n", + "3 0.001253\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": 197, + "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: 4.713e+05\n", + "Date: Thu, 02 Apr 2026 Prob (F-statistic): 2.12e-06\n", + "Time: 17:16:41 Log-Likelihood: 32.343\n", + "No. Observations: 4 AIC: -60.69\n", + "Df Residuals: 2 BIC: -61.91\n", + "Df Model: 1 \n", + "Covariance Type: nonrobust \n", + "==============================================================================\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", + "==============================================================================\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", + "==============================================================================\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" + ] + }, + { + "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": [ + "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": 198, + "id": "67d16b84", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "24351.577653480002\n", + "0.0016211852129718464\n", + "Forse K 24.351577653480003\n", + "Forse uK 16717.076316471204\n" + ] + } + ], + "source": [ + "Kstrano = (4 * np.pi**2) / pente\n", + "uKstrano = (4 * np.pi**2) / u_pente\n", + "print(Kstrano)\n", + "print(pente)\n", + "\n", + "K = Kstrano / 1000\n", + "uK = uKstrano / 1000\n", + "print(\"Forse K \", K)\n", + "print(\"Forse uK \", uK)" + ] + }, + { + "cell_type": "code", + "execution_count": 199, + "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": 200, + "id": "859f2337", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ax + B : \n", + "A = 0.0016202 +- 0.0000212\n", + "B = 0.0023963 +- 0.0029727\n", + "cov_AB = -0.000000\n", + "p-value chi² = 0.0156\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": 203, + "id": "fef04a85", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "K nostro: 24.36602987010158\n", + "uK nostro: 0.2494340628966531\n" + ] + } + ], + "source": [ + "\n", + "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" + ] + } + ], + "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/mollaDinamica2.ipynb b/molla/dinamica/mollaDinamica2.ipynb new file mode 100644 index 0000000..92c5068 --- /dev/null +++ b/molla/dinamica/mollaDinamica2.ipynb @@ -0,0 +1,1058 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 34, + "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", + "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": 35, + "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", + " 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.01)\n", + "df = calcola_stats(df, \"m\", err_arbitrario=0.01)\n", + "df = calcola_stats(df, \"t\", 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": 36, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
m1a1ua1w1uw1c1uc1t1a2ua2w2uw2c2uc2t2a3ua3w3uw3c3uc3t3a4ua4w4uw4c4uc4t4wuwmumtutcucaua
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.00171149.250.0115.70750.133010484.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.00051969.280.0118.27000.078740423.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.00068988.970.0120.43500.117331363.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.000787108.610.0122.36500.187172303.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.001009128.640.0124.51500.386480242.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 t ut \\\n", + "0 0.011 15.87 7.657975 0.001711 49.25 0.01 15.7075 0.133010 \n", + "1 0.014 18.16 6.559652 0.000519 69.28 0.01 18.2700 0.078740 \n", + "2 0.011 20.49 5.845038 0.000689 88.97 0.01 20.4350 0.117331 \n", + "3 0.010 22.15 5.328455 0.000787 108.61 0.01 22.3650 0.187172 \n", + "4 0.015 24.26 4.925600 0.001009 128.64 0.01 24.5150 0.386480 \n", + "\n", + " c uc a ua \n", + "0 484.70125 0.284314 9.362775 0.908254 \n", + "1 423.41700 0.226641 10.427250 0.454472 \n", + "2 363.24975 0.073109 11.257075 0.794837 \n", + "3 303.60455 0.168669 10.106500 1.299853 \n", + "4 242.93550 0.138954 10.637000 1.188344 " + ] + }, + "execution_count": 36, + "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": 48, + "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": 38, + "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": 39, + "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": 40, + "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: Thu, 02 Apr 2026 Prob (F-statistic): 1.19e-19\n", + "Time: 14:02:46 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}\")\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "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": 42, + "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": 43, + "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": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "((data[\"F\"] - F_fit) / sigma)**2" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "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": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "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": 46, + "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 = 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": 47, + "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" + ] + } + ], + "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/ripara.py b/molla/dinamica/ripara.py new file mode 100644 index 0000000..34349c5 --- /dev/null +++ b/molla/dinamica/ripara.py @@ -0,0 +1,36 @@ +def replace_every_second_comma(text, replacement=","): + result = [] + comma_count = 0 + + for char in text: + if char == ",": + comma_count += 1 + if comma_count % 2 == 0: + result.append(replacement) + continue + else: + result.append(".") + continue + result.append(char) + + 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" +csv_line4 = "108,61,11,542,0,026,5,3278,0,0003,303,5502,0,019,22,49,8,424,0,017,5,3282,0,0003,303,581,0,012,22,27,10,501,0,022,5,3296,0,0003,303,842,0,016,22,55,9,959,0,014,5,32822,0,0002,303,445,0,01,22,15" +csv_line5 = "128,64,11,574,0,020,4,92663,0,00023,242,962,0,014,24,33,11,592,0,023,4,92537,0,00029,242,876,0,017,24,38,10,264,0,023,4,9243,0,0003,242,789,0,017,25,09,9,118,0,021,4,9261,0,0003,243,115,0,015,24,26" + +csv_lines = [csv_line1, csv_line2, csv_line3, csv_line4, csv_line5] + + +for csv_line in csv_lines: + fixed_line = replace_every_second_comma(csv_line) + + print(fixed_line) + 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/mollaStatica.ipynb b/molla/statica/mollaStatica.ipynb similarity index 100% rename from molla/mollaStatica.ipynb rename to molla/statica/mollaStatica.ipynb diff --git a/molla/mollaStatica1.ipynb b/molla/statica/mollaStatica1.ipynb similarity index 98% rename from molla/mollaStatica1.ipynb rename to molla/statica/mollaStatica1.ipynb index 6fb0734..4ff2f93 100644 --- a/molla/mollaStatica1.ipynb +++ b/molla/statica/mollaStatica1.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 145, + "execution_count": null, "id": "f34c5b88", "metadata": {}, "outputs": [], @@ -23,7 +23,7 @@ }, { "cell_type": "code", - "execution_count": 146, + "execution_count": null, "id": "08efb2be", "metadata": {}, "outputs": [ @@ -100,39 +100,12 @@ " return media, sigma\n", "\n", "df = calcola_Dx_stats(df, err_arbitrario_DX=0.01)\n", - "df = calcola_m_stats(df, err_arbitrario_m=0.0028867513)\n", - "\n", - "\n", - "\n", - "'''\n", - "df[\"K\"] = df.m * g / df.Dx\n", - "df[\"uK\"] = np.sqrt( (df.m * g / df.Dx**2)**2 * df.uDx**2 + (g/df.Dx)**2 * df.um**2 + (df.m / df.Dx)**2 * ug**2)\n", - "\n", - "df[\"F\"] = df.m * g\n", - "df[\"uF\"] = np.sqrt( df.m**2 * ug**2 + g**2 * df.um**2)\n", - "media_K, sigma_K = mediaPesata(df[\"K\"], df[\"uK\"])\n", - "\n", - "\n", - "#chi 2\n", - "chi2_val = np.sum((df[\"K\"] - media_K)**2 / df[\"uK\"]**2) # formula corretta\n", - "dof = len(df[\"K\"]) - 1 # -1 perché stimi solo la media\n", - "chi2_rid = chi2_val / dof\n", - "p_value = 1 - sc.stats.chi2.cdf(chi2_val, dof)\n", - "\n", - "print(\"#\"*60)\n", - "print(\"Valori di K\")\n", - "print(\"media pesata K:\", media_K)\n", - "print(\"sigma K:\", sigma_K)\n", - "print(f\"Chi2 : {chi2_val:.4f}\")\n", - "print(f\"DOF : {dof}\")\n", - "print(f\"Chi2 ridotto : {chi2_rid:.4f} (ideale ~ 1)\")\n", - "print(f\"p-value : {p_value:.4f}\")\n", - "'''" + "df = calcola_m_stats(df, err_arbitrario_m=0.0028867513)\n" ] }, { "cell_type": "code", - "execution_count": 147, + "execution_count": null, "id": "5494409f", "metadata": {}, "outputs": [ @@ -272,7 +245,7 @@ }, { "cell_type": "code", - "execution_count": 148, + "execution_count": null, "id": "976d5531", "metadata": {}, "outputs": [ @@ -304,6 +277,7 @@ "\n", "\n", "print(perm)\n", + "print(len(perm))\n", "\n", "print(\"#\"* 60)\n", "print(este)\n", @@ -316,7 +290,7 @@ }, { "cell_type": "code", - "execution_count": 149, + "execution_count": null, "id": "2ad19283", "metadata": {}, "outputs": [ @@ -345,7 +319,7 @@ }, { "cell_type": "code", - "execution_count": 150, + "execution_count": null, "id": "5f59d6c9", "metadata": {}, "outputs": [ @@ -380,7 +354,7 @@ }, { "cell_type": "code", - "execution_count": 151, + "execution_count": null, "id": "aefe7756", "metadata": {}, "outputs": [ @@ -451,7 +425,7 @@ }, { "cell_type": "code", - "execution_count": 152, + "execution_count": null, "id": "1d42b009", "metadata": {}, "outputs": [ @@ -523,7 +497,7 @@ }, { "cell_type": "code", - "execution_count": 153, + "execution_count": null, "id": "986ff4a6", "metadata": {}, "outputs": [ @@ -559,7 +533,7 @@ }, { "cell_type": "code", - "execution_count": 154, + "execution_count": null, "id": "ef0817f4", "metadata": {}, "outputs": [ @@ -590,7 +564,7 @@ }, { "cell_type": "code", - "execution_count": 155, + "execution_count": null, "id": "cebe6742", "metadata": {}, "outputs": [ @@ -721,7 +695,7 @@ }, { "cell_type": "code", - "execution_count": 160, + "execution_count": null, "id": "2d4b7144", "metadata": {}, "outputs": [ @@ -799,7 +773,7 @@ }, { "cell_type": "code", - "execution_count": 157, + "execution_count": null, "id": "32e9948f", "metadata": {}, "outputs": [ @@ -836,7 +810,7 @@ }, { "cell_type": "code", - "execution_count": 158, + "execution_count": null, "id": "e2407a04", "metadata": {}, "outputs": [ diff --git a/molla/mollaStatica2.ipynb b/molla/statica/mollaStatica2.ipynb similarity index 98% rename from molla/mollaStatica2.ipynb rename to molla/statica/mollaStatica2.ipynb index 9b704af..f032cfe 100644 --- a/molla/mollaStatica2.ipynb +++ b/molla/statica/mollaStatica2.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 29, + "execution_count": 1, "id": "f34c5b88", "metadata": {}, "outputs": [], @@ -23,7 +23,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": null, "id": "08efb2be", "metadata": {}, "outputs": [ @@ -33,7 +33,7 @@ "'\\ndf[\"K\"] = df.m * g / df.Dx\\ndf[\"uK\"] = np.sqrt( (df.m * g / df.Dx**2)**2 * df.uDx**2 + (g/df.Dx)**2 * df.um**2 + (df.m / df.Dx)**2 * ug**2)\\n\\ndf[\"F\"] = df.m * g\\ndf[\"uF\"] = np.sqrt( df.m**2 * ug**2 + g**2 * df.um**2)\\nmedia_K, sigma_K = mediaPesata(df[\"K\"], df[\"uK\"])\\n\\n\\n#chi 2\\nchi2_val = np.sum((df[\"K\"] - media_K)**2 / df[\"uK\"]**2) # formula corretta\\ndof = len(df[\"K\"]) - 1 # -1 perché stimi solo la media\\nchi2_rid = chi2_val / dof\\np_value = 1 - sc.stats.chi2.cdf(chi2_val, dof)\\n\\nprint(\"#\"*60)\\nprint(\"Valori di K\")\\nprint(\"media pesata K:\", media_K)\\nprint(\"sigma K:\", sigma_K)\\nprint(f\"Chi2 : {chi2_val:.4f}\")\\nprint(f\"DOF : {dof}\")\\nprint(f\"Chi2 ridotto : {chi2_rid:.4f} (ideale ~ 1)\")\\nprint(f\"p-value : {p_value:.4f}\")\\n'" ] }, - "execution_count": 30, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } @@ -100,39 +100,12 @@ " return media, sigma\n", "\n", "df = calcola_Dx_stats(df, err_arbitrario_DX=0.01)\n", - "df = calcola_m_stats(df, err_arbitrario_m=0.0028867513)\n", - "\n", - "\n", - "\n", - "'''\n", - "df[\"K\"] = df.m * g / df.Dx\n", - "df[\"uK\"] = np.sqrt( (df.m * g / df.Dx**2)**2 * df.uDx**2 + (g/df.Dx)**2 * df.um**2 + (df.m / df.Dx)**2 * ug**2)\n", - "\n", - "df[\"F\"] = df.m * g\n", - "df[\"uF\"] = np.sqrt( df.m**2 * ug**2 + g**2 * df.um**2)\n", - "media_K, sigma_K = mediaPesata(df[\"K\"], df[\"uK\"])\n", - "\n", - "\n", - "#chi 2\n", - "chi2_val = np.sum((df[\"K\"] - media_K)**2 / df[\"uK\"]**2) # formula corretta\n", - "dof = len(df[\"K\"]) - 1 # -1 perché stimi solo la media\n", - "chi2_rid = chi2_val / dof\n", - "p_value = 1 - sc.stats.chi2.cdf(chi2_val, dof)\n", - "\n", - "print(\"#\"*60)\n", - "print(\"Valori di K\")\n", - "print(\"media pesata K:\", media_K)\n", - "print(\"sigma K:\", sigma_K)\n", - "print(f\"Chi2 : {chi2_val:.4f}\")\n", - "print(f\"DOF : {dof}\")\n", - "print(f\"Chi2 ridotto : {chi2_rid:.4f} (ideale ~ 1)\")\n", - "print(f\"p-value : {p_value:.4f}\")\n", - "'''" + "df = calcola_m_stats(df, err_arbitrario_m=0.0028867513)\n" ] }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 3, "id": "5494409f", "metadata": {}, "outputs": [ @@ -245,7 +218,7 @@ "3 0.188750 108.610000 0.002887 " ] }, - "execution_count": 31, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -256,7 +229,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 15, "id": "976d5531", "metadata": {}, "outputs": [ @@ -265,6 +238,7 @@ "output_type": "stream", "text": [ "[(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]\n", + "6\n", "############################################################\n", "[ 61.75666667 121.72666667 181.94666667 59.97 120.19\n", " 60.22 ]\n", @@ -287,6 +261,7 @@ "\n", "\n", "print(perm)\n", + "print(len(perm))\n", "\n", "print(\"#\"* 60)\n", "print(este)\n", @@ -299,7 +274,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 5, "id": "2ad19283", "metadata": {}, "outputs": [ @@ -326,7 +301,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 6, "id": "5f59d6c9", "metadata": {}, "outputs": [ @@ -361,7 +336,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 7, "id": "aefe7756", "metadata": {}, "outputs": [ @@ -374,8 +349,8 @@ "Dep. Variable: F R-squared: 1.000\n", "Model: OLS Adj. R-squared: 1.000\n", "Method: Least Squares F-statistic: 1.277e+05\n", - "Date: Wed, 01 Apr 2026 Prob (F-statistic): 3.68e-10\n", - "Time: 11:24:04 Log-Likelihood: -7.2416\n", + "Date: Thu, 02 Apr 2026 Prob (F-statistic): 3.68e-10\n", + "Time: 14:04:37 Log-Likelihood: -7.2416\n", "No. Observations: 6 AIC: 18.48\n", "Df Residuals: 4 BIC: 18.07\n", "Df Model: 1 \n", @@ -440,7 +415,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 8, "id": "1d42b009", "metadata": {}, "outputs": [ @@ -512,7 +487,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 9, "id": "986ff4a6", "metadata": {}, "outputs": [ @@ -548,7 +523,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 10, "id": "ef0817f4", "metadata": {}, "outputs": [ @@ -564,7 +539,7 @@ "dtype: float64" ] }, - "execution_count": 38, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -575,7 +550,7 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 11, "id": "cebe6742", "metadata": {}, "outputs": [ @@ -663,7 +638,7 @@ "5 60.220000 0.210270 192.622527 0.044592" ] }, - "execution_count": 39, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -674,7 +649,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 12, "id": "2d4b7144", "metadata": {}, "outputs": [ @@ -752,7 +727,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 13, "id": "32e9948f", "metadata": {}, "outputs": [ @@ -789,7 +764,7 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 14, "id": "e2407a04", "metadata": {}, "outputs": [ diff --git a/molla/statica1.csv b/molla/statica/statica1.csv similarity index 100% rename from molla/statica1.csv rename to molla/statica/statica1.csv diff --git a/molla/statica2.csv b/molla/statica/statica2.csv similarity index 100% rename from molla/statica2.csv rename to molla/statica/statica2.csv