diff --git a/benchmark/Data_Analysis.ipynb b/benchmark/Data_Analysis.ipynb new file mode 100644 index 00000000..8f2ad70f --- /dev/null +++ b/benchmark/Data_Analysis.ipynb @@ -0,0 +1,3718 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 13, + "id": "initial_id", + "metadata": { + "ExecuteTime": { + "end_time": "2024-06-21T14:43:44.931314Z", + "start_time": "2024-06-21T14:43:43.168541Z" + }, + "collapsed": true + }, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from scipy.stats import shapiro\n", + "import pingouin as pg\n", + "import matplotlib as mpl" + ] + }, + { + "cell_type": "markdown", + "id": "865ca8bb47658a98", + "metadata": { + "collapsed": false + }, + "source": [ + "# Read df" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "b3b8229df5d7ca29", + "metadata": { + "ExecuteTime": { + "end_time": "2024-06-21T15:00:21.260867Z", + "start_time": "2024-06-21T15:00:21.152696Z" + }, + "collapsed": false + }, + "outputs": [], + "source": [ + "medical = pd.read_csv(\"results/medical_exam.csv\")\n", + "medical_failure = pd.read_csv(\"results/medical_exam_failure_modes.csv\")\n", + "\n", + "\n", + "# Data Cleaning/ Removing models due to deprecation\n", + "dpr = [\"gpt-3.5-turbo-0613\"]\n", + "for model in dpr:\n", + " medical = medical.drop(medical.query(\"model_name == @model\").index)\n", + " medical_failure = medical_failure.drop(medical_failure.query(\"model_name == @model\").index)\n", + " \n", + " \n", + "#display(medical.query(\"subtask == 'dichotomous:biochemistry:de'\"))\n", + "#display(medical_failure.query(\"subtask == 'dichotomous:biochemistry:de'\")) \n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "5357788f419658e6", + "metadata": { + "ExecuteTime": { + "end_time": "2024-06-21T15:00:49.351973Z", + "start_time": "2024-06-21T15:00:49.343491Z" + }, + "collapsed": false + }, + "outputs": [], + "source": [ + "def score_helper(df):\n", + " \"\"\"\n", + " The input is a DataFrame containing the data to process. These are the results \n", + " of the benchmarking test cases extracted from a csv file. \n", + " From that data the scores are extracted and the results are aggregated per \n", + " Iteration and per model. It returns the raw results, as well as the aggregated \n", + " scores and the aggregated scores per iteration.\n", + " \"\"\"\n", + " raw_results = df.copy()\n", + " raw_results[\"score_possible\"] = raw_results[\"score\"].apply(\n", + " lambda x: float(x.split(\"/\")[1])\n", + " )\n", + " raw_results[\"scores\"] = raw_results[\"score\"].apply(\n", + " lambda x: x.split(\"/\")[0]\n", + " )\n", + " raw_results[\"score_achieved_total\"] = raw_results[\"scores\"].apply(\n", + " lambda x: np.sum([float(score) for score in x.split(\";\")])\n", + " )\n", + " raw_results[\"iteration_scores\"] = raw_results[\"scores\"].apply(\n", + " lambda x: [float(score) for score in x.split(\";\")]\n", + " )\n", + " raw_results[\"iteration_index\"] = raw_results[\"iteration_scores\"].apply(\n", + " lambda x: list(range(1, len(x) + 1))\n", + " )\n", + "\n", + " # Explode the iteration scores and iteration index to have a row for each iteration\n", + " exploded_results = raw_results.explode([\"iteration_scores\", \"iteration_index\"])\n", + " exploded_results[\"iteration_scores\"] = exploded_results[\"iteration_scores\"].astype(float)\n", + " exploded_results[\"iteration_index\"] = exploded_results[\"iteration_index\"].astype(int)\n", + " \n", + " aggregated_results_iteration = exploded_results.groupby([\"model_name\", \"iteration_index\"]).agg(\n", + " score_possible=(\"score_possible\", \"sum\"),\n", + " score_achieved_total=(\"iteration_scores\", \"sum\"),\n", + " ).reset_index()\n", + " \n", + " aggregated_scores = raw_results.groupby([\"model_name\"]).agg(\n", + " score_possible=(\"score_possible\", \"sum\"),\n", + " score_achieved_total=(\"score_achieved_total\", \"sum\"),\n", + " iterations=(\"iterations\", \"first\")\n", + " ).reset_index()\n", + " \n", + " \n", + " aggregated_scores['score_possible_total'] = aggregated_scores['score_possible'] * raw_results.iloc[:, 3][0]\n", + " aggregated_scores['score_achieved_avg'] = aggregated_scores['score_achieved_total'] / raw_results.iloc[:, 3][0]\n", + " \n", + " std_results = aggregated_results_iteration.groupby([\"model_name\"])[\"score_achieved_total\"].std().reset_index()\n", + " aggregated_scores['score_achieved_std'] = std_results.iloc[:,1]\n", + " \n", + " return raw_results, aggregated_scores, aggregated_results_iteration" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "3c8f967ae7a6a26a", + "metadata": { + "ExecuteTime": { + "end_time": "2024-06-21T15:00:50.825360Z", + "start_time": "2024-06-21T15:00:50.673251Z" + }, + "collapsed": false + }, + "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", + "
model_nameiteration_indexscore_possiblescore_achieved_total
0chatglm3:6:ggmlv3:q4_01357.0155.0
1chatglm3:6:ggmlv3:q4_02357.0148.0
2chatglm3:6:ggmlv3:q4_03357.0154.0
3gpt-3.5-turbo-01251357.0237.0
4gpt-3.5-turbo-01252357.0241.0
\n", + "
" + ], + "text/plain": [ + " model_name iteration_index score_possible \\\n", + "0 chatglm3:6:ggmlv3:q4_0 1 357.0 \n", + "1 chatglm3:6:ggmlv3:q4_0 2 357.0 \n", + "2 chatglm3:6:ggmlv3:q4_0 3 357.0 \n", + "3 gpt-3.5-turbo-0125 1 357.0 \n", + "4 gpt-3.5-turbo-0125 2 357.0 \n", + "\n", + " score_achieved_total \n", + "0 155.0 \n", + "1 148.0 \n", + "2 154.0 \n", + "3 237.0 \n", + "4 241.0 " + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "agg =score_helper(medical)\n", + "agg[2].head()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "cd92903e6cebd613", + "metadata": { + "ExecuteTime": { + "end_time": "2024-06-21T15:00:56.282770Z", + "start_time": "2024-06-21T15:00:55.797761Z" + }, + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Achieved score per model')" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the score per model\n", + "fig, ax = plt.subplots(1,1, figsize=(7,5))\n", + "\n", + "df = agg[1].copy()\n", + "df = df.sort_values(by=\"score_achieved_avg\", ascending=True)\n", + "\n", + "ax = df.plot.bar(x=\"model_name\", y=\"score_achieved_avg\", yerr=\"score_achieved_std\", capsize = 5, ax=ax, legend=False , color=\"#c61a27\")\n", + "plt.axhline(y=df.iloc[:, 1][0], linestyle=\"--\", color=\"#c61a27\")\n", + "\n", + "ax.set_xlabel(\"\")\n", + "ax.set_ylabel(\"Score\")\n", + "\n", + "ax.get_xticklabels()[-1].set_color('red') # Change color for label 'B' specificall\n", + "ax.get_xticklabels()[0].set_color('red') # Change color for label 'B' specifically\n", + "\n", + " \n", + "ax.set_title(\"Achieved score per model\")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "27128d40", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Average Accuracy for Model Architectures')" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the average accuracy of the different model-architectures\n", + "model_root_names = [\"chatglm\", \"gpt\", \"llama\", \"mixtral\", \"openhermes\"]\n", + "\n", + "df = agg[2].copy()\n", + "df_avg_std_acc = []\n", + "for root_name in model_root_names:\n", + " df_temp = df[df[\"model_name\"].str.contains(root_name, na=False)]\n", + " individual_accuracies = df_temp[\"score_achieved_total\"] / df_temp[\"score_possible\"]\n", + " avg_accuracy = individual_accuracies.mean()\n", + " std_accuracy = individual_accuracies.std()\n", + " \n", + " # Use aggregated scores to calculate overall accuracy for display\n", + " overall_acc = df_temp[\"score_achieved_total\"].sum() / df_temp[\"score_possible\"].sum()\n", + " df_avg_std_acc.append((root_name, avg_accuracy, std_accuracy, overall_acc))\n", + "\n", + "df_avg_std_acc = pd.DataFrame(df_avg_std_acc, columns=[\"model_name\", \"score_achieved_avg\", \"score_achieved_std\", \"accuracy\"])\n", + "\n", + "fig, ax = plt.subplots(1,1, figsize=(4,2))\n", + "ax.set_ylim(0.2, 0.9)\n", + "\n", + "ax.plot(df_avg_std_acc[\"model_name\"], df_avg_std_acc[\"accuracy\"], marker=\"o\", ls=\"\", color=\"#c61a27\", ms=8)\n", + "ax.errorbar(df_avg_std_acc[\"model_name\"], df_avg_std_acc[\"accuracy\"], yerr=df_avg_std_acc[\"score_achieved_std\"], capsize=6, ls=\"\", color=\"#c61a27\", linewidth=3)\n", + "ax.set_ylabel(\"Accuracy\")\n", + "ax.set_title(\"Average Accuracy for Model Architectures\")" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "b922c78ff5d961b", + "metadata": { + "ExecuteTime": { + "end_time": "2024-06-21T15:52:10.892155Z", + "start_time": "2024-06-21T15:52:10.885321Z" + }, + "collapsed": false + }, + "outputs": [], + "source": [ + "# Extract best and worst model\n", + "df = agg[1].copy()\n", + "df = df.sort_values(by=\"score_achieved_avg\", ascending=True)\n", + "\n", + "best_model = df.iloc[-1]\n", + "worst_model = df.iloc[0]\n", + "best_model_name = best_model.iloc[0]\n", + "worst_model_name = worst_model.iloc[0]" + ] + }, + { + "cell_type": "markdown", + "id": "6e7b88e8548035b2", + "metadata": { + "collapsed": false + }, + "source": [ + "# Best&Worst Model Analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "1ad06489fe927a50", + "metadata": { + "ExecuteTime": { + "end_time": "2024-06-21T15:52:14.190794Z", + "start_time": "2024-06-21T15:52:13.406841Z" + }, + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0.98, 'Comparison of Failure Modes')" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot a comparison of the failure modes between the best and the worst model\n", + "dfs = []\n", + "titels = [\"Best\", \"Worst\"]\n", + "\n", + "dfs.append(medical_failure.query(\"model_name == @best_model_name\"))\n", + "dfs.append(medical_failure.query(\"model_name == @worst_model_name\"))\n", + "\n", + "fig, ax = plt.subplots(1,2, figsize=(15,5))\n", + "for i, df in enumerate(dfs):\n", + " failure_mode_count = df[\"failure_modes\"].value_counts()\n", + " failure_mode_count.plot.bar(ax=ax[i], title=f\"{titels[i]} Model\", color=\"#c61a27\")\n", + " ax[i].set_xlabel(\"\")\n", + " ax[i].set_ylabel(\"Counts\")\n", + "fig.suptitle('Comparison of Failure Modes', fontsize=16)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "id": "d3b605684447353d", + "metadata": { + "ExecuteTime": { + "end_time": "2024-06-21T15:57:28.626068Z", + "start_time": "2024-06-21T15:57:28.317083Z" + }, + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0.98, 'Comparison of Task Type')" + ] + }, + "execution_count": 64, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot a comparison of the task type between the best and the worst model\n", + "fig, ax = plt.subplots(1,2, figsize=(15,5))\n", + "for i, df in enumerate(dfs):\n", + " question_type = df.query(\"failure_modes == 'Other'\")\n", + " question_type = question_type['subtask'].str.split(':').str[0]\n", + " subtask_counts = question_type.value_counts()\n", + " subtask_counts.plot.bar(ax=ax[i], title=f\"{titels[i]} Model\", color=\"#c61a27\")\n", + " y_hline = subtask_counts.max() / 2\n", + " ax[i].axhline(y=y_hline, linestyle=\"--\", color=\"black\")\n", + " \n", + " ax[i].set_xlabel(\"\")\n", + " ax[i].set_ylabel(\"Counts\")\n", + "fig.suptitle('Comparison of Task Type', fontsize=16)" + ] + }, + { + "cell_type": "markdown", + "id": "40e1a1d06ac1b3e6", + "metadata": { + "collapsed": false + }, + "source": [ + "# Unterschied der Modes" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "id": "35bee7118cdff41e", + "metadata": { + "ExecuteTime": { + "end_time": "2024-06-21T15:26:53.664581Z", + "start_time": "2024-06-21T15:26:53.662153Z" + }, + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0, '')" + ] + }, + "execution_count": 62, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the frequency of failures by the task type\n", + "fig, ax = plt.subplots(1,1, figsize=(5,3))\n", + "question_type = agg[0].copy()\n", + "question_type = question_type['subtask'].str.split(':').str[0]\n", + "subtask_counts = question_type.value_counts()\n", + "subtask_counts.plot.bar(ax=ax, title=f\"Task type failure frequency\", color=\"#c61a27\")\n", + "y_hline = subtask_counts.max() / 2\n", + "ax.axhline(y=y_hline, linestyle=\"--\", color=\"black\")\n", + "ax.set_ylabel(\"Counts\")\n", + "ax.set_xlabel(\"\")" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "id": "4c445132", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0, '')" + ] + }, + "execution_count": 61, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAdcAAAHvCAYAAAAGrZUBAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAABk0ElEQVR4nO3deVyN6f8/8NeptK+WJJJSlsjaIPsUUmFsYydlHWXL/hnLYIZhZgyDYXxQGOsYjG1sRXyIxpKUndRYipFKpf3+/eHX/XW0WOZ07rvO6/l4nIfOfV/nnNd9ynmf+76v67oVgiAIICIiIpXRkjoAERFRecPiSkREpGIsrkRERCrG4kpERKRiLK5EREQqxuJKRESkYiyuREREKsbiSkREpGIsrkRERCrG4koa59SpU1AoFDh16pS4bPjw4ahVq5ZkmeSoqPfp30pMTETfvn1RqVIlKBQKLF++XGXPTSQnLK5UZgQHB0OhUBR5mzlzptTx6D1MnjwZR48exaxZs7BlyxZ07dpV6khEpUJH6gBEH2rBggWws7NTWtawYcP3fnz79u3x6tUr6OrqqjoavUNoaCg+++wzTJ06VeooRKWKxZXKHE9PT7i4uHz047W0tKCvr6/CRIWlp6fDyMioVF+jLHr69CnMzc3f2Y7vH5V1PCxM5UZcXBzGjRuHunXrwsDAAJUqVcLnn3+OBw8eKLV7n3OJxbV58OABFAoFgoODxWXDhw+HsbEx7t27By8vL5iYmGDw4MEAgPz8fCxfvhwNGjSAvr4+qlatijFjxuDFixfv3J6C542Pj0e3bt1gbGyM6tWrY/Xq1QCAa9euwc3NDUZGRrC1tcW2bdsKPcf9+/fx+eefo2LFijA0NESrVq1w6NChQu0ePnyInj17wsjICJaWlpg8eTKysrKKzHXhwgV07doVZmZmMDQ0RIcOHXD27NkSt6XgkL4gCFi9erV4OP/NdWFhYRg3bhwsLS1Ro0YN8bF//vkn2rVrByMjI5iYmMDb2xsxMTGFXmPfvn1o2LAh9PX10bBhQ+zdu7fQufQP+b0CwM2bN9G3b19UrFgR+vr6cHFxwf79+4vctrNnzyIwMBBVqlSBkZERevXqhWfPnhXK+eeff6JDhw4wMTGBqakpPvnkE/F3N2/ePFSoUKHIx40ePRrm5ubIzMws8b0meWBxpTInJSUF//zzj9INAP766y+cO3cOAwYMwE8//YSxY8ciJCQEHTt2REZGRqlmys3NhYeHBywtLfH999+jT58+AIAxY8Zg2rRpaNOmDVasWAFfX19s3boVHh4eyMnJeefz5uXlwdPTEzY2Nli6dClq1aqFgIAABAcHo2vXrnBxccGSJUtgYmKCYcOGITY2VnxsYmIiWrdujaNHj2LcuHH45ptvkJmZiR49emDv3r1iu1evXsHd3R1Hjx5FQEAAvvzyS5w5cwbTp08vlCc0NBTt27dHamoq5s2bh0WLFiE5ORlubm6IiIgodjvat2+PLVu2AAA6d+6MLVu2iPcLjBs3DtevX8fcuXPFc+hbtmyBt7c3jI2NsWTJEsyZMwfXr19H27Ztlb40HTt2DH369IFCocDixYvRs2dP+Pr64uLFi+98j4sTExODVq1a4caNG5g5cyZ++OEHGBkZoWfPnkrvX4Hx48fj6tWrmDdvHr744gscOHAAAQEBSm2Cg4Ph7e2NpKQkzJo1C99++y2aNGmCI0eOAACGDh2K3Nxc7Ny5U+lx2dnZ2L17N/r06VPqR11IRQSiMiIoKEgAUORNEAQhIyOj0GPCw8MFAMLmzZvFZSdPnhQACCdPnhSX+fj4CLa2tiW2EQRBiI2NFQAIQUFBSo8FIMycOVOp7ZkzZwQAwtatW5WWHzlypMjlbyt43kWLFonLXrx4IRgYGAgKhULYsWOHuPzmzZsCAGHevHniskmTJgkAhDNnzojLXr58KdjZ2Qm1atUS8vLyBEEQhOXLlwsAhF27dont0tPTBQcHB6X3ID8/X3B0dBQ8PDyE/Px8sW1GRoZgZ2cndO7cucTtEQRBACD4+/srLSv4vbZt21bIzc1Vympubi6MGjVKqX1CQoJgZmamtLxJkyZCtWrVhOTkZHHZsWPHBAAf/Xt1d3cXnJ2dhczMTHFZfn6+0Lp1a8HR0bFQ/k6dOim9L5MnTxa0tbXFTMnJyYKJiYnQsmVL4dWrV0qv/+bjXF1dhZYtWyqt37NnT5G5Sb6450plzurVq3H8+HGlGwAYGBiIbXJycvD8+XM4ODjA3Nwcly9fLvVcX3zxhdL93377DWZmZujcubPSXnbz5s1hbGyMkydPvtfzjhw5UvzZ3NwcdevWhZGREfr16ycur1u3LszNzXH//n1x2eHDh9GiRQu0bdtWXGZsbIzRo0fjwYMHuH79utiuWrVq6Nu3r9jO0NAQo0ePVsoRGRmJO3fuYNCgQXj+/Lm4Penp6XB3d8fp06eRn5//XttUlFGjRkFbW1u8f/z4cSQnJ2PgwIFK75+2tjZatmwpvn9PnjxBZGQkfHx8YGZmJj6+c+fOcHJy+qgsSUlJCA0NRb9+/fDy5UvxtZ8/fw4PDw/cuXMHjx49UnrM6NGjxUPdANCuXTvk5eUhLi5O3J6XL19i5syZhfY+33zcsGHDcOHCBdy7d09ctnXrVtjY2KBDhw4ftT2kfuzQRGVOixYtiuzQ9OrVKyxevBhBQUF49OgRBEEQ16WkpJRqJh0dHaXzhABw584dpKSkwNLSssjHPH369J3Pq6+vjypVqigtMzMzQ40aNZQ+kAuWv3kuNy4uDi1btiz0nPXr1xfXN2zYEHFxcXBwcCj0fHXr1i20PQDg4+NTbN6UlBRYWFi8c7uK8nYP8ILXc3NzK7K9qakpAIjFy9HRsVCbunXrftQXq7t370IQBMyZMwdz5swpss3Tp09RvXp18X7NmjWV1he8DwW/k4Ji+a6e7f3798ekSZOwdetWzJ07FykpKTh48CAmT55c6HdE8sXiSuXG+PHjERQUhEmTJsHV1RVmZmZQKBQYMGDAB+9RFfchlpeXV+RyPT09aGkpHwjKz8+HpaUltm7dWuRj3i6aRXlzT+59lr/5hULVCt7D7777Dk2aNCmyjbGx8Uc//5tHHt58vS1btsDKyqpQex2dD//4et/fa8FrT506FR4eHkU+xsHBQem+qn4nFhYW6Natm1hcd+/ejaysLAwZMuSDnoekxeJK5cbu3bvh4+ODH374QVyWmZmJ5OTkD36ugr2Otx9bsJf0PmrXro0TJ06gTZs2hQqHOtja2uLWrVuFlt+8eVNcX/BvdHQ0BEFQKj5vP7Z27doAXu8xdurUqbRiF3o9S0vLEl+vYDsK9nTf9PY2vO/v1d7eHgBQoUIFlW1rwfZER0cXKsxvGzZsGD777DP89ddf2Lp1K5o2bYoGDRqoJAepB8+5Urmhra1daC9h5cqVxe5tlsTW1hba2to4ffq00vKff/75vZ+jX79+yMvLw8KFCwuty83N/aii/yG8vLwQERGB8PBwcVl6ejrWrVuHWrVqiecjvby88PjxY+zevVtsl5GRgXXr1ik9X/PmzVG7dm18//33SEtLK/R6RQ0f+Tc8PDxgamqKRYsWFdmzuuD1qlWrhiZNmmDTpk1Kh/+PHz8unlcu8L6/V0tLS3Ts2BG//PILnjx5Uuxrf4guXbrAxMQEixcvLjSc5u2/W09PT1SuXBlLlixBWFgY91rLIO65UrnRrVs3bNmyBWZmZnByckJ4eDhOnDiBSpUqffBzmZmZ4fPPP8fKlSuhUChQu3ZtHDx48L3Okxbo0KEDxowZg8WLFyMyMhJdunRBhQoVcOfOHfz2229YsWKFUiciVZs5cya2b98OT09PTJgwARUrVsSmTZsQGxuL33//XTyMPWrUKKxatQrDhg3DpUuXUK1aNWzZsgWGhoZKz6elpYX169fD09MTDRo0gK+vL6pXr45Hjx7h5MmTMDU1xYEDB1SW39TUFGvWrMHQoUPRrFkzDBgwAFWqVEF8fDwOHTqENm3aYNWqVQCAxYsXw9vbG23btoWfnx+SkpKwcuVKNGjQQOmLwIf8XlevXo22bdvC2dkZo0aNgr29PRITExEeHo6HDx/i6tWrH7w9P/74I0aOHIlPPvkEgwYNgoWFBa5evYqMjAxs2rRJbFuhQgUMGDAAq1atgra2NgYOHPiR7yJJRsKeykQfpGDIw19//VXk+hcvXgi+vr5C5cqVBWNjY8HDw0O4efOmYGtrK/j4+Ijt3mcojiAIwrNnz4Q+ffoIhoaGgoWFhTBmzBghOjq6yKE4RkZGxeZet26d0Lx5c8HAwEAwMTERnJ2dhenTpwuPHz8ucXuLe94OHToIDRo0KLTc1tZW8Pb2Vlp27949oW/fvoK5ubmgr68vtGjRQjh48GChx8bFxQk9evQQDA0NhcqVKwsTJ04Uhwy9PfzjypUrQu/evYVKlSoJenp6gq2trdCvXz8hJCSkxO0RhJKH4hT3ez158qTg4eEhmJmZCfr6+kLt2rWF4cOHCxcvXlRq9/vvvwv169cX9PT0BCcnJ2HPnj3/6vda8P4NGzZMsLKyEipUqCBUr15d6Natm7B79+535i9u2M/+/fuF1q1bCwYGBoKpqanQokULYfv27YW2OyIiQgAgdOnSpcj3heRNIQil2AOCiEhCw4cPx6lTpwrN0lUWXL16FU2aNMHmzZsxdOhQqePQB+I5VyIiGfrvf/8LY2Nj9O7dW+oo9BF4zpWISEYOHDiA69evY926dQgICOAFDMooFlciIhkZP348EhMT4eXlhfnz50sdhz4Sz7kSERGpGM+5EhERqRiLKxERkYrxnOt7yM/Px+PHj2FiYsKJs4mINJggCHj58iWsra0LzSf+JhbX9/D48WPY2NhIHYOIiGTi77//LnQlrDexuL4HExMTAK/fzILLXBERkeZJTU2FjY2NWBeKw+L6HgoOBZuamrK4EhHRO08RskMTERGRirG4EhERqRiLKxERkYqxuBIREakYiysREZGKsbgSERGpGIsrERGRirG4EhERqRgnkSAitQmvXk/qCHB9dFPqCKQBuOdKRESkYiyuREREKsbiSkREpGIsrkRERCrG4kpERKRiLK5EREQqxuJKRESkYiyuREREKiZpcV28eDE++eQTmJiYwNLSEj179sStW7eU2nTs2BEKhULpNnbsWKU28fHx8Pb2hqGhISwtLTFt2jTk5uYqtTl16hSaNWsGPT09ODg4IDg4uLQ3j4iINJSkxTUsLAz+/v44f/48jh8/jpycHHTp0gXp6elK7UaNGoUnT56It6VLl4rr8vLy4O3tjezsbJw7dw6bNm1CcHAw5s6dK7aJjY2Ft7c3Pv30U0RGRmLSpEkYOXIkjh49qrZtJSIizaEQBEGQOkSBZ8+ewdLSEmFhYWjfvj2A13uuTZo0wfLly4t8zJ9//olu3brh8ePHqFq1KgBg7dq1mDFjBp49ewZdXV3MmDEDhw4dQnR0tPi4AQMGIDk5GUeOHCn0nFlZWcjKyhLvp6amwsbGBikpKTA1NVXhFhNpFk5/SGVdamoqzMzM3lkPZHXONSUlBQBQsWJFpeVbt25F5cqV0bBhQ8yaNQsZGRniuvDwcDg7O4uFFQA8PDyQmpqKmJgYsU2nTp2UntPDwwPh4eFF5li8eDHMzMzEm42NjUq2j4iININsJu7Pz8/HpEmT0KZNGzRs2FBcPmjQINja2sLa2hpRUVGYMWMGbt26hT179gAAEhISlAorAPF+QkJCiW1SU1Px6tUrGBgYKK2bNWsWAgMDxfsFe65ERETvQzbF1d/fH9HR0fjf//6ntHz06NHiz87OzqhWrRrc3d1x79491K5du1Sy6OnpQU9Pr1Sem4iIyj9ZHBYOCAjAwYMHcfLkSdSoUaPEti1btgQA3L17FwBgZWWFxMREpTYF962srEpsY2pqWmivlYiI6N+StLgKgoCAgADs3bsXoaGhsLOze+djIiMjAQDVqlUDALi6uuLatWt4+vSp2Ob48eMwNTWFk5OT2CYkJETpeY4fPw5XV1cVbQkREdH/kbS4+vv749dff8W2bdtgYmKChIQEJCQk4NWrVwCAe/fuYeHChbh06RIePHiA/fv3Y9iwYWjfvj0aNWoEAOjSpQucnJwwdOhQXL16FUePHsXs2bPh7+8vHtodO3Ys7t+/j+nTp+PmzZv4+eefsWvXLkyePFmybSciovJL0qE4CoWiyOVBQUEYPnw4/v77bwwZMgTR0dFIT0+HjY0NevXqhdmzZyt1gY6Li8MXX3yBU6dOwcjICD4+Pvj222+ho/N/p5RPnTqFyZMn4/r166hRowbmzJmD4cOHv1fO9+16TUQl41AcKuvetx7IapyrXLG4EqkGiyuVdWVynCsREVF5wOJKRESkYiyuREREKsbiSkREpGIsrkRERCrG4kpERKRiLK5EREQqxuJKRESkYiyuREREKsbiSkREpGIsrkRERCrG4kpERKRiLK5EREQqxuJKRESkYiyuREREKsbiSkREpGIsrkRERCrG4kpERKRiLK5EREQqxuJKRESkYiyuREREKsbiSkREpGIsrkRERCrG4kpERKRiLK5EREQqxuJKRESkYiyuREREKsbiSkREpGIsrkRERCrG4kpERKRikhbXxYsX45NPPoGJiQksLS3Rs2dP3Lp1S6lNZmYm/P39UalSJRgbG6NPnz5ITExUahMfHw9vb28YGhrC0tIS06ZNQ25urlKbU6dOoVmzZtDT04ODgwOCg4NLe/OIiEhDSVpcw8LC4O/vj/Pnz+P48ePIyclBly5dkJ6eLraZPHkyDhw4gN9++w1hYWF4/PgxevfuLa7Py8uDt7c3srOzce7cOWzatAnBwcGYO3eu2CY2Nhbe3t749NNPERkZiUmTJmHkyJE4evSoWreXiIg0g0IQBEHqEAWePXsGS0tLhIWFoX379khJSUGVKlWwbds29O3bFwBw8+ZN1K9fH+Hh4WjVqhX+/PNPdOvWDY8fP0bVqlUBAGvXrsWMGTPw7Nkz6OrqYsaMGTh06BCio6PF1xowYACSk5Nx5MiRd+ZKTU2FmZkZUlJSYGpqWjobT6QBwqvXkzoCXB/dlDoClWHvWw9kdc41JSUFAFCxYkUAwKVLl5CTk4NOnTqJberVq4eaNWsiPDwcABAeHg5nZ2exsAKAh4cHUlNTERMTI7Z58zkK2hQ8x9uysrKQmpqqdCMiInpfsimu+fn5mDRpEtq0aYOGDRsCABISEqCrqwtzc3OltlWrVkVCQoLY5s3CWrC+YF1JbVJTU/Hq1atCWRYvXgwzMzPxZmNjo5JtJCIizSCb4urv74/o6Gjs2LFD6iiYNWsWUlJSxNvff/8tdSQiIipDdKQOAAABAQE4ePAgTp8+jRo1aojLrayskJ2djeTkZKW918TERFhZWYltIiIilJ6voDfxm23e7mGcmJgIU1NTGBgYFMqjp6cHPT09lWwbERFpHkn3XAVBQEBAAPbu3YvQ0FDY2dkprW/evDkqVKiAkJAQcdmtW7cQHx8PV1dXAICrqyuuXbuGp0+fim2OHz8OU1NTODk5iW3efI6CNgXPQUREpEqS7rn6+/tj27Zt+OOPP2BiYiKeIzUzM4OBgQHMzMwwYsQIBAYGomLFijA1NcX48ePh6uqKVq1aAQC6dOkCJycnDB06FEuXLkVCQgJmz54Nf39/ce9z7NixWLVqFaZPnw4/Pz+EhoZi165dOHTokGTbTkRE5ZekQ3EUCkWRy4OCgjB8+HAAryeRmDJlCrZv346srCx4eHjg559/Fg/5AkBcXBy++OILnDp1CkZGRvDx8cG3334LHZ3/++5w6tQpTJ48GdevX0eNGjUwZ84c8TXehUNxiFSDQ3GorHvfeiCrca5yxeJKpBosrlTWlclxrkREROUBiysREZGKsbgSERGpGIsrERGRirG4EhERqRiLKxERkYqxuBIREakYiysREZGKsbgSERGpGIsrERGRirG4EhERqRiLKxERkYqxuBIREakYiysREZGKsbgSERGpGIsrERGRirG4EhERqRiLKxERkYqxuBIREakYiysREZGKsbgSERGpGIsrERGRin1Ucb18+TKuXbsm3v/jjz/Qs2dP/Oc//0F2drbKwhEREZVFH1Vcx4wZg9u3bwMA7t+/jwEDBsDQ0BC//fYbpk+frtKAREREZc1HFdfbt2+jSZMmAIDffvsN7du3x7Zt2xAcHIzff/9dlfmIiIjKnI8qroIgID8/HwBw4sQJeHl5AQBsbGzwzz//qC4dERFRGfRRxdXFxQVff/01tmzZgrCwMHh7ewMAYmNjUbVqVZUGJCIiKms+qrj++OOPuHz5MgICAvDll1/CwcEBALB79260bt1apQGJiIjKGp2PeVDjxo2VegsX+O6776Cj81FPSUREVG581J6rvb09nj9/Xmh5ZmYm6tSp869DERERlWUfVVwfPHiAvLy8QsuzsrLw8OHD936e06dPo3v37rC2toZCocC+ffuU1g8fPhwKhULp1rVrV6U2SUlJGDx4MExNTWFubo4RI0YgLS1NqU1UVBTatWsHfX192NjYYOnSpe+/sURERB/og47h7t+/X/z56NGjMDMzE+/n5eUhJCQEdnZ27/186enpaNy4Mfz8/NC7d+8i23Tt2hVBQUHifT09PaX1gwcPxpMnT3D8+HHk5OTA19cXo0ePxrZt2wAAqamp6NKlCzp16oS1a9fi2rVr8PPzg7m5OUaPHv3eWYmIiN7XBxXXnj17AgAUCgV8fHyU1lWoUAG1atXCDz/88N7P5+npCU9PzxLb6OnpwcrKqsh1N27cwJEjR/DXX3/BxcUFALBy5Up4eXnh+++/h7W1NbZu3Yrs7Gxs3LgRurq6aNCgASIjI7Fs2TIWVyIiKhUfdFg4Pz8f+fn5qFmzJp4+fSrez8/PR1ZWFm7duoVu3bqpNOCpU6dgaWmJunXr4osvvlA61xseHg5zc3OxsAJAp06doKWlhQsXLoht2rdvD11dXbGNh4cHbt26hRcvXhT5mllZWUhNTVW6ERERva+POucaGxuLypUrqzpLIV27dsXmzZsREhKCJUuWICwsDJ6enuL53oSEBFhaWio9RkdHBxUrVkRCQoLY5u2xtwX3C9q8bfHixTAzMxNvNjY2qt40IiIqxz563ExISAhCQkLEPdg3bdy48V8HA4ABAwaIPzs7O6NRo0aoXbs2Tp06BXd3d5W8RlFmzZqFwMBA8X5qaioLLBERvbePKq7z58/HggUL4OLigmrVqkGhUKg6V5Hs7e1RuXJl3L17F+7u7rCyssLTp0+V2uTm5iIpKUk8T2tlZYXExESlNgX3izuXq6enV6jjFBER0fv6qOK6du1aBAcHY+jQoarOU6KHDx/i+fPnqFatGgDA1dUVycnJuHTpEpo3bw4ACA0NRX5+Plq2bCm2+fLLL5GTk4MKFSoAAI4fP466devCwsJCrfmJiEgzfNQ51+zsbJVMc5iWlobIyEhERkYCeH0uNzIyEvHx8UhLS8O0adNw/vx5PHjwACEhIfjss8/g4OAADw8PAED9+vXRtWtXjBo1ChERETh79iwCAgIwYMAAWFtbAwAGDRoEXV1djBgxAjExMdi5cydWrFihdNiXiIhIlT6quI4cOVIcR/pvXLx4EU2bNkXTpk0BAIGBgWjatCnmzp0LbW1tREVFoUePHqhTpw5GjBiB5s2b48yZM0qHbLdu3Yp69erB3d0dXl5eaNu2LdatWyeuNzMzw7FjxxAbG4vmzZtjypQpmDt3LofhEBFRqVEIgiB86IMmTpyIzZs3o1GjRmjUqJF4uLXAsmXLVBZQDlJTU2FmZoaUlBSYmppKHYeozAqvXk/qCHB9dFPqCFSGvW89+KhzrlFRUeLF0qOjo5XWqatzExERkVx9VHE9efKkqnMQERGVGx91zpWIiIiK91F7rp9++mmJh39DQ0M/OhAREVFZ91HFteB8a4GcnBxERkYiOjq60IT+REREmuajiuuPP/5Y5PKvvvqq0LVUiYiICmhKj/GPnlu4KEOGDEGLFi3w/fffq/JpZSM9PR3a2tqFlmtra0NfX1+pXXG0tLRgYGDwUW0zMjJQ3MgphUIBQ0PDj2r76tWrQvNDv8nIyOij2mZmZooXWfi3bQ0NDcVTEVlZWcjNzVVJWwMDA2hpve56kJ2djZycHJW01dfXF/9WPqRtTk4OsrOzi22rp6cHHR2dD26bm5uLrKysYtvq6uqKQ+o+pG1eXh4yMzOLbVuhQgXxilR5eXl4VcLfjo5CgQr///eWLwjIKmGU4Ie01VYAuorXvzdBEEr8P6ejoyOOoxcEARkZGcU/7wf8v+dnRNGyhHzklzAY1EBL673b6isU4v/7bCEfeSW0FQThoz8jSvp9vP0iKrN582ahWrVqqnxKWUhJSREAFHvz8vJSam9oaFhs2w4dOii1rVy5crFtXVxclNra2toW29bJyUmprZOTU7FtbW1tldq6uLgU27Zy5cpKbTt06FBsW0NDQ6W2Xl5eJb5vb+rbt2+JbdPS0sS2Pj4+JbZ9+vSp2HbcuHElto2NjRXbTp06tcS20dHRYtt58+aV2DYiIkJsu3Tp0hLbnjx5Umy7atWqEtsePHhQbBsUFFRi2127doltd+3aVWLboKAgse3BgwdLbLtq1Sqx7cmTJ0tsu3TpUrFtREREiW39jCsJ56zrCues6wq/VqlVYttBRhZi298t7Uts29vQXGx7qGrtEtv6+PiIedPS0kps27dvX6W/4ZLa8jPi9c3Q0FD8XZyzriu46hmV+L692fZTfeMS24ZYOYptvQxMS2yris+IlJQUoSQftefau3dvpfuCIODJkye4ePEi5syZ8zFPSUREVG581AxNvr6+Sve1tLRQpUoVuLm5oUuXLioLJxcFM3I8fvy4yBk5eMin6LY8LMzDwm8fFg6rUb/Ytuo6LNz4zuXin5eHhYtsq8rPiKg6zcWfpTos/OnjWx/9GfH8+XNYW1u/c4amjyqumobTHxKphqZ0ZqHilfW/gVKd/rDApUuXcOPGDQBAgwYNxAn4iYiINNlHFdenT59iwIABOHXqFMzNzQEAycnJ+PTTT7Fjxw5UqVJFlRmJiIjKlI+a/nD8+PF4+fIlYmJikJSUhKSkJERHRyM1NRUTJkxQdUYiIqIy5aP2XI8cOYITJ06gfv3/65zg5OSE1atXl8sOTURERB/io/Zc8/PzC13DFXjdM/B9Bw8TERGVVx9VXN3c3DBx4kQ8fvxYXPbo0SNMnjwZ7u7uKgtHRERUFn1UcV21ahVSU1NRq1Yt1K5dG7Vr14adnR1SU1OxcuVKVWckIiIqUz7qnKuNjQ0uX76MEydO4ObN1+OF6tevj06dOqk0HBERUVn0QXuuoaGhcHJyQmpqKhQKBTp37ozx48dj/Pjx+OSTT9CgQQOcOXOmtLISERGVCR9UXJcvX45Ro0YVOSuFmZkZxowZg2XLlqksHBERUVn0QcX16tWr6Nq1a7Hru3TpgkuXLv3rUERERGXZBxXXxMTEIofgFNDR0cGzZ8/+dSgiIqKy7IOKa/Xq1REdHV3s+qioKFSrVu1fhyIiIirLPqi4enl5Yc6cOUVeYurVq1eYN28eunXrprJwREREZdEHDcWZPXs29uzZgzp16iAgIAB169YFANy8eROrV69GXl4evvzyy1IJSkREVFZ8UHGtWrUqzp07hy+++AKzZs0SL7SrUCjg4eGB1atXo2rVqqUSlIiIqKz44EkkbG1tcfjwYbx48QJ3796FIAhwdHSEhYVFaeQjIiIqcz76YukWFhb45JNPVJmFiIioXPiouYWJiIioeB+950pERB8uvHo9SV/f9dFNSV9fU0i653r69Gl0794d1tbWUCgU2Ldvn9J6QRAwd+5cVKtWDQYGBujUqRPu3Lmj1CYpKQmDBw+GqakpzM3NMWLECKSlpSm1iYqKQrt27aCvrw8bGxssXbq0tDeNiIg0mKTFNT09HY0bN8bq1auLXL906VL89NNPWLt2LS5cuAAjIyN4eHgojbMdPHgwYmJicPz4cRw8eBCnT5/G6NGjxfWpqano0qULbG1tcenSJXz33Xf46quvsG7dulLfPiIi0kySHhb29PSEp6dnkesEQcDy5csxe/ZsfPbZZwCAzZs3o2rVqti3bx8GDBiAGzdu4MiRI/jrr7/g4uICAFi5ciW8vLzw/fffw9raGlu3bkV2djY2btwIXV1dNGjQAJGRkVi2bJlSESYiIlIV2XZoio2NRUJCgtI1Ys3MzNCyZUuEh4cDAMLDw2Fubi4WVgDo1KkTtLS0cOHCBbFN+/btoaurK7bx8PDArVu38OLFiyJfOysrC6mpqUo3IiKi9yXb4pqQkAAAhSalqFq1qrguISEBlpaWSut1dHRQsWJFpTZFPcebr/G2xYsXw8zMTLzZ2Nj8+w0iIiKNIdviKqVZs2YhJSVFvP39999SRyIiojJEtsXVysoKwOvL3L0pMTFRXGdlZYWnT58qrc/NzUVSUpJSm6Ke483XeJuenh5MTU2VbkRERO9LtsXVzs4OVlZWCAkJEZelpqbiwoULcHV1BQC4uroiOTlZ6QLtoaGhyM/PR8uWLcU2p0+fRk5Ojtjm+PHjqFu3LqdsJCKiUiFpcU1LS0NkZCQiIyMBvO7EFBkZifj4eCgUCkyaNAlff/019u/fj2vXrmHYsGGwtrZGz549AQD169dH165dMWrUKERERODs2bMICAjAgAEDYG1tDQAYNGgQdHV1MWLECMTExGDnzp1YsWIFAgMDJdpqIiIq7yQdinPx4kV8+umn4v2Cgufj44Pg4GBMnz4d6enpGD16NJKTk9G2bVscOXIE+vr64mO2bt2KgIAAuLu7Q0tLC3369MFPP/0krjczM8OxY8fg7++P5s2bo3Llypg7dy6H4RARUalRCAXXjaNipaamwszMDCkpKTz/SvQvSD31HyD99H9Svweavv3Av3sP3rceyPacKxERUVnF4kpERKRiLK5EREQqxuJKRESkYiyuREREKsbiSkREpGKSjnMlzSJ1F3yphyAQkebgnisREZGKsbgSERGpGIsrERGRirG4EhERqRg7NBGpETt1EWkG7rkSERGpGIsrERGRirG4EhERqRiLKxERkYqxuBIREakYiysREZGKsbgSERGpGIsrERGRirG4EhERqRiLKxERkYqxuBIREakYiysREZGKsbgSERGpGIsrERGRirG4EhERqRiLKxERkYqxuBIREakYiysREZGKybq4fvXVV1AoFEq3evXqieszMzPh7++PSpUqwdjYGH369EFiYqLSc8THx8Pb2xuGhoawtLTEtGnTkJubq+5NISIiDaIjdYB3adCgAU6cOCHe19H5v8iTJ0/GoUOH8Ntvv8HMzAwBAQHo3bs3zp49CwDIy8uDt7c3rKyscO7cOTx58gTDhg1DhQoVsGjRIrVvCxERaQbZF1cdHR1YWVkVWp6SkoINGzZg27ZtcHNzAwAEBQWhfv36OH/+PFq1aoVjx47h+vXrOHHiBKpWrYomTZpg4cKFmDFjBr766ivo6uqqe3OIiEgDyPqwMADcuXMH1tbWsLe3x+DBgxEfHw8AuHTpEnJyctCpUyexbb169VCzZk2Eh4cDAMLDw+Hs7IyqVauKbTw8PJCamoqYmJhiXzMrKwupqalKNyIiovcl6+LasmVLBAcH48iRI1izZg1iY2PRrl07vHz5EgkJCdDV1YW5ubnSY6pWrYqEhAQAQEJCglJhLVhfsK44ixcvhpmZmXizsbFR7YYREVG5JuvDwp6enuLPjRo1QsuWLWFra4tdu3bBwMCg1F531qxZCAwMFO+npqaywBIR0XuT9Z7r28zNzVGnTh3cvXsXVlZWyM7ORnJyslKbxMRE8RytlZVVod7DBfeLOo9bQE9PD6ampko3IiKi91WmimtaWhru3buHatWqoXnz5qhQoQJCQkLE9bdu3UJ8fDxcXV0BAK6urrh27RqePn0qtjl+/DhMTU3h5OSk9vxERKQZZH1YeOrUqejevTtsbW3x+PFjzJs3D9ra2hg4cCDMzMwwYsQIBAYGomLFijA1NcX48ePh6uqKVq1aAQC6dOkCJycnDB06FEuXLkVCQgJmz54Nf39/6OnpSbx1RERUXsm6uD58+BADBw7E8+fPUaVKFbRt2xbnz59HlSpVAAA//vgjtLS00KdPH2RlZcHDwwM///yz+HhtbW0cPHgQX3zxBVxdXWFkZAQfHx8sWLBAqk0iIiINIOviumPHjhLX6+vrY/Xq1Vi9enWxbWxtbXH48GFVRyMiIipWmTrnSkREVBawuBIREakYiysREZGKsbgSERGpGIsrERGRirG4EhERqRiLKxERkYqxuBIREakYiysREZGKsbgSERGpGIsrERGRirG4EhERqRiLKxERkYqxuBIREakYiysREZGKsbgSERGpGIsrERGRirG4EhERqRiLKxERkYqxuBIREakYiysREZGKsbgSERGpGIsrERGRirG4EhERqRiLKxERkYrpSB1Ak4RXryfp67s+uinp6xMRaQruuRIREakYiysREZGKsbgSERGpGIsrERGRirG4EhERqZhGFdfVq1ejVq1a0NfXR8uWLRERESF1JCIiKoc0prju3LkTgYGBmDdvHi5fvozGjRvDw8MDT58+lToaERGVMxpTXJctW4ZRo0bB19cXTk5OWLt2LQwNDbFx40apoxERUTmjEZNIZGdn49KlS5g1a5a4TEtLC506dUJ4eHih9llZWcjKyhLvp6SkAABSU1P/VY70/Lx/9fh/69/m/7c0ffsBvgdSbz/A90DTtx/4d+9BwWMFQSixnUYU13/++Qd5eXmoWrWq0vKqVavi5s3CsxYtXrwY8+fPL7Tcxsam1DKqhZmZ1AmkpenbD/A9APgeaPr2Ayp5D16+fAmzEp5HI4rrh5o1axYCAwPF+/n5+UhKSkKlSpWgUCgkyZSamgobGxv8/fffMDU1lSSDlDR9+wG+B5q+/QDfA0D690AQBLx8+RLW1tYlttOI4lq5cmVoa2sjMTFRaXliYiKsrKwKtdfT04Oenp7SMnNz89KM+N5MTU019j8VwO0H+B5o+vYDfA8Aad+DkvZYC2hEhyZdXV00b94cISEh4rL8/HyEhITA1dVVwmRERFQeacSeKwAEBgbCx8cHLi4uaNGiBZYvX4709HT4+vpKHY2IiMoZjSmu/fv3x7NnzzB37lwkJCSgSZMmOHLkSKFOTnKlp6eHefPmFTpcrSk0ffsBvgeavv0A3wOg7LwHCuFd/YmJiIjog2jEOVciIiJ1YnElIiJSMRZXIiIiFWNxJSIiUjEWV5lKT0+XOoKk3NzckJycXGh5amoq3Nzc1B9IzXJzc7FgwQI8fPhQ6iiSyc3NxebNmwtN/kKa5f79+1JH+CjsLSxTxsbG6NevH/z8/NC2bVup46idlpYWEhISYGlpqbT86dOnqF69OnJyciRKpj4mJia4du0aatWqJXUUyRgaGuLGjRuwtbWVOook8vLyEBwcjJCQEDx9+hT5+flK60NDQyVKpj5aWlro0KEDRowYgb59+0JfX1/qSO+Fe64y9euvvyIpKQlubm6oU6cOvv32Wzx+/FjqWKUuKioKUVFRAIDr16+L96OionDlyhVs2LAB1atXlzileri5uSEsLEzqGJJq0aIFIiMjpY4hmYkTJ2LixInIy8tDw4YN0bhxY6WbJrh8+TIaNWqEwMBAWFlZYcyYMYiIiJA61jtxz1Xmnj17hi1btiA4OBg3btyAh4cH/Pz80KNHD+jolL85QLS0tMSLIxT1p2lgYICVK1fCz89P3dHUbu3atZg/fz4GDx6M5s2bw8jISGl9jx49JEqmPrt27cKsWbMwefLkIt+DRo0aSZRMPSpXrozNmzfDy8tL6iiSy83Nxf79+xEcHIwjR46gTp068PPzw9ChQ1GlShWp4xXC4lqGrFy5EtOmTUN2djYqV66MsWPHYubMmTA0NJQ6msrExcVBEATY29sjIiJC6T+Nrq4uLC0toa2tLWFC9dHSKv7AkkKhQF6e9NfFLG1FvQcKhQKCIGjEe2BtbY1Tp06hTp06UkeRjaysLPz888+YNWsWsrOzoauri379+mHJkiWoVq2a1PFELK4yl5iYiE2bNiE4OBhxcXHo1asXRowYgYcPH2LJkiWwtrbGsWPHpI5JVCri4uJKXF/ez8X+8MMPuH//PlatWiXZ5S7l4uLFi9i4cSN27NgBIyMj+Pj4iJ+F8+fPR2pqqqwOF7O4ytSePXsQFBSEo0ePwsnJCSNHjsSQIUOULn1379491K9fH9nZ2dIFLSWLFy9G1apVCx3+3bhxI549e4YZM2ZIlIyodPXu3VvpfmhoKCpWrIgGDRqgQoUKSuv27NmjzmiSWLZsGYKCgnDr1i14eXlh5MiR8PLyUjqq8fDhQ9SqVQu5ubkSJlXGDk0y5evrC2tra5w9exaRkZEICAgodE1Za2trfPnll9IELGW//PIL6tWrV2h5gwYNsHbtWgkSSSMsLAzdu3eHg4MDHBwc0KNHD5w5c0bqWGq1ZcsWtGnTBtbW1uKe7PLly/HHH39InKx0mJmZKd169eqFDh06oHLlyoXWaYI1a9Zg0KBBiIuLw759+9CtW7dCpwssLS2xYcMGiRIWjXuuMpWRkVGuzqV+KH19fdy4cQN2dnZKy+/fvw8nJydkZmZKlEx9fv31V/j6+qJ3795o06YNAODs2bPYu3cvgoODMWjQIIkTlr41a9Zg7ty5mDRpEr755htER0fD3t4ewcHB2LRpE06ePCl1RCplDx48QM2aNQsVVEEQ8Pfff6NmzZoSJXsHgWRJS0tLSExMLLT8n3/+EbS0tCRIpF4ODg7Cli1bCi3fvHmzYGdnJ0Ei9atXr56wbNmyQst/+OEHoV69ehIkUr/69esLe/fuFQRBEIyNjYV79+4JgiAI165dEypVqiRhMvW4f/++cPv27ULLb9++LcTGxqo/kATK6mchDwvLlFDMAYWsrCzo6uqqOY36jRo1CpMmTUJQUBDi4uIQFxeHjRs3YvLkyRg1apTU8dTi/v376N69e6HlPXr0QGxsrASJ1C82NhZNmzYttFxPT08jZjEbPnw4zp07V2j5hQsXMHz4cPUHkkBxn4VpaWmynlCi/A2ULON++uknAK+HG6xfvx7Gxsbiury8PJw+fbrIc5HlzbRp0/D8+XOMGzdO7LClr6+PGTNmYNasWRKnUw8bGxuEhITAwcFBafmJEydgY2MjUSr1srOzQ2RkZKFewUeOHEH9+vUlSqU+V65cEU8JvKlVq1YICAiQIJH6BAYGAnj9WTh37lyl02R5eXm4cOECmjRpIlG6d2NxlZkff/wRwOtva2vXrlUa06mrq4tatWppRIcehUKBJUuWYM6cObhx4wYMDAzg6OgIPT09qaOpzZQpUzBhwgRERkaidevWAF6fcw0ODsaKFSskTqcegYGB8Pf3R2ZmJgRBQEREBLZv347Fixdj/fr1UscrdQqFAi9fviy0PCUlpdyP8b1y5QqA15+F165dUzpip6uri8aNG2Pq1KlSxXs3SQ9KU7E6duwoJCUlSR1Dcnfu3BGOHDkiZGRkCIIgCPn5+RInUq89e/YIbdq0ESpWrChUrFhRaNOmjbBv3z6pY6nVr7/+Kjg4OAgKhUJQKBRC9erVhfXr10sdSy26desmfP7550Jubq64LDc3V+jTp4/QtWtXCZOpz/Dhw4WUlBSpY3ww9hYmWXr+/Dn69euHkydPQqFQ4M6dO7C3t4efnx8sLCzwww8/SB2xVOXm5mLRokXw8/NDjRo1pI4jCxkZGUhLSyt0MYfyLCYmBh06dIC5uTnatWsHADhz5gxSU1MRGhqKhg0bSpyQisPiKiOBgYFYuHAhjIyMxPMNxVm2bJmaUklj2LBhePr0KdavX4/69evj6tWrsLe3x9GjRxEYGIiYmBipI5Y6Y2NjREdHa/RVcQh4/PgxVq1ahatXr8LAwACNGjVCQEAAKlasKHW0UtO7d28EBwfD1NS00KQab5PrRBo85yojV65cES+lVnC+oSiaMA3asWPHcPTo0UJ7bY6Oju+cEq+8cHd3R1hYmEYX18TEREydOlW85Nrb+wLl/bxjfHw8bGxssGjRoiLXyXaM579kZmYmfs6ZmpqWyc88FlcZeXNAvKYPjk9PTy9yEo2kpCSN6dTk6emJmTNn4tq1axp7VZzhw4cjPj4ec+bMQbVq1crkh+y/YWdnhydPnhQ6FP78+XPY2dmV2y8XQUFB4s/BwcHSBfkXeFhYpn799Vf07t1bY2dp8vLyQvPmzbFw4UKYmJggKioKtra2GDBgAPLz87F7926pI5Y6XhXn9QXjz5w5I+shF6VJS0sLiYmJhS6pFhcXBycnJ40Y6/v1119j8ODBhWZrkzsWV5mqUqUKXr16hR49emDIkCHw8PDQmEutAUB0dDTc3d3RrFkzhIaGokePHoiJiUFSUhLOnj2L2rVrSx2R1MDJyQlbt24tciKJ8qygz8WKFSswatSoIsd4amtr4+zZs1JFVJvGjRsjOjoaLVu2xJAhQ9CvXz9UrlxZ6ljvxBmaZOrJkyfYsWMHFAoF+vXrh2rVqsHf37/I2VrKo4YNG+L27dto27YtPvvsM6Snp6N37964cuWKRhTWnJwc6OjoIDo6Wuooklq+fDlmzpyJBw8eSB1Fra5cuYIrV66IYzwL7l+5cgU3b95E48aNy+zh0g919epVREVFoWPHjvj+++9hbW0Nb29vbNu2DRkZGVLHKxb3XMuAjIwM7N27F9u2bcOJEydQo0YN3Lt3T+pYpSYnJwddu3bF2rVr4ejoKHUcydjb22Pv3r1o3Lix1FHUysLCQuncanp6OnJzc2FoaFjokmtJSUnqjqdWvr6+WLFiBUxNTaWOIhtnz57Ftm3b8NtvvyEzMxOpqalSRyoSOzSVAYaGhvDw8MCLFy8QFxeHGzduSB2pVFWoUAFRUVFSx5Dcl19+if/85z/YsmVLuR528bbly5dLHUE23uzYQ68ZGRnBwMAAurq6Rc5eJRfcc5Wxgj3WrVu3IiQkBDY2Nhg4cCAGDx5c7ucXnjx5MvT09PDtt99KHUUyTZs2xd27d5GTkwNbW9tCvYUvX74sUTJSp4sXL2LXrl2Ij48X59kuINcxnqoWGxuLbdu2Ydu2bbh16xY6dOiAQYMGoW/fvrK9ri33XGVqwIABOHjwIAwNDdGvXz/MmTMHrq6uUsdSm9zcXGzcuBEnTpwochhKeZ9EAwB69uwpdQTJaWtrFzsUxdLSstz3mN6xYweGDRsGDw8PHDt2DF26dMHt27eRmJiIXr16SR1PLVq1aoW//voLjRo1gq+vLwYOHIjq1atLHeudWFxlSltbG7t27dK4XsIFoqOj0axZMwDA7du3ldZpyljHefPmSR1BcsUdWNOUSy8uWrQIP/74I/z9/WFiYoIVK1bAzs4OY8aMQbVq1aSOpxbu7u7YuHEjnJycpI7yQXhYmGQnLy8PZ8+ehbOzMywsLKSOo3YRERFo3rx5sV+qsrKy8Mcff6Bfv35qTqY+BZdenDx5MhYuXFjkpRcfPHhQ4kxm5YGRkRFiYmJQq1YtVKpUCadOnYKzszNu3LgBNzc3PHnyROqIVAzuucrITz/9hNGjR0NfX1/8cCnOhAkT1JRK/bS1tdGlSxfcuHFDI4urq6ur0qFQU1NTREZGwt7eHgCQnJyMgQMHluviyksvvmZhYSF22qlevTqio6Ph7OyM5ORkWQ9D+bfKwzzrLK4y8uOPP2Lw4MHQ19cXP1yKolAoynVxBV6Pc71//36Zm5VFFd4+mFTUwaXyfsApNjYWAPDpp59iz549yM3NhUKhKBOTB6hS+/btcfz4cTg7O+Pzzz/HxIkTERoaiuPHj8Pd3V3qeKXmfedZlzMeFiZZOnLkCGbNmoWFCxcW2aGpPI/709LSQkJCgrjnamJiIl4VCHg9mb21tXW578yTnJyM//znP9i1axdevHgB4PWe3IABA/D111/D3Nxc2oBqkJSUhMzMTFhbWyM/Px9Lly7FuXPn4OjoiNmzZ2vkkZ2ygsVVphYsWICpU6cWmlv41atX+O677zB37lyJkqnHm/PqvtmBSRCEcj+vLovr66Li6uqKR48eYfDgwahfvz4A4Pr169i2bRtsbGxw7tw5FhcN4OfnhxUrVsDExERpeXp6OsaPH4+NGzdKlKxkLK4ypelDEMLCwkpc36FDBzUlUT8tLS2EhoaKE0e0bt0au3btEi+/988//6Bz587l+m9g0qRJCAkJwYkTJ1C1alWldQkJCejSpQvc3d1LPH1C5UNxn4X//PMPrKyskJubK1GykrG4ylRxV8MIDQ1F//798ezZM4mSUWnT0tKCQqEo8rxqwfLyvvdeq1Yt/PLLL/Dw8Chy/ZEjRzB27NhyO+fw+w6/K89/A6mpqRAEARYWFrhz547SZ2FeXh4OHDiAmTNn4vHjxxKmLB47NMlMwbyqCoUCderUUTokmpeXh7S0NIwdO1bChOqTnJyMDRs2iNM9NmjQAH5+frKdkUVVCjrzaLInT56gQYMGxa5v2LAhEhIS1JhIvQRBgK2tLXx8fDTuikAFzM3NlT4L36ZQKDB//nwJkr0f7rnKzKZNmyAIAvz8/LB8+XKlQlIwBEETZmq6ePEiPDw8YGBggBYtWgAA/vrrL7x69QrHjh0TJ5ig8ql69erYuXMn2rZtW+T6M2fOoH///rLda/m3Ll68iA0bNmDHjh2ws7ODn58fBg8erFHnmMPCwiAIAtzc3PD7778rza+tq6sLW1tbWFtbS5iwZCyuMhUWFobWrVsXugqIpmjXrh0cHBzw3//+Fzo6rw+w5ObmYuTIkbh//z5Onz4tcUIqTX5+frh37x6OHz9eaCamrKwseHh4wN7eXradWVQlMzMTu3fvRlBQEM6fP4/u3btjxIgR6Ny5s9TR1CYuLg41a9YsczOzsbjKSGpqqjjE5F2XUSrPQ1EAwMDAAFeuXCl0gYLr16/DxcWlXA+gJ+Dhw4dwcXGBnp4e/P39Ua9ePQiCgBs3buDnn39GVlYWLl68CBsbG6mjqk1sbCxGjBiBsLAwPHv2rFxfKSkqKgoNGzaElpbWO6+Q1ahRIzWl+jA85yojFhYWYq+4gvMNb9OEzizA6y8P8fHxhYrr33//XahLPpU/NWrUQHh4OMaNG4dZs2aJnbsUCgU6d+6MVatWaUxhffjwIYKDgxEcHIyMjAxMmzat3H+5btKkiTgcrUmTJiV28JPrZyGLq4y8Ofzi5MmTEqeRVv/+/TFixAh8//33aN26NYDXF0meNm0aBg4cKHE6Ugc7Ozv8+eefePHiBe7cuQMAcHBwKNd7bAWys7Oxd+9ebNiwAWfOnIGnpyeWL18OT09PjbiQR2xsrNg7uKx28ONhYZKl7OxsTJs2DWvXrhXHsVWoUAFffPEFvv32W+jp6UmcsPS5ublhz549hWYiSk1NRc+ePREaGipNMCp1lSpVgomJCXx8fDB06NBCYzwLlPc92LKMxVWmjhw5AmNjY7G35OrVq/Hf//4XTk5OWL16tcb0GszIyMC9e/cAALVr1y40Y1V59vZMTQWePn2K6tWri3OvUvlT3AxlBTTl9BDwegRF5cqV4e3tDQCYPn061q1bBycnJ2zfvh22trYSJywai6tMOTs7Y8mSJfDy8sK1a9fg4uKCKVOm4OTJk6hXrx6CgoKkjliqUlJSkJeXV+gQYFJSEnR0dMr1N/aCDhxNmjRROlUAvB7rfOTIEfzyyy/ldgIFevcMZQXK80xlBerWrYs1a9bAzc0N4eHhcHd3x/Lly3Hw4EHo6Ohgz549UkcsEourTBkbGyM6Ohq1atXCV199hejoaOzevRuXL1+Gl5dXuR5ADwCenp7o3r07xo0bp7R87dq12L9/Pw4fPixRstJXMEMTUPTVbwwMDLBy5Ur4+fmpOxqR2hkaGuLmzZuoWbMmZsyYgSdPnmDz5s2IiYlBx44dZTtbnda7m5AUdHV1xeEmJ06cQJcuXQAAFStWfOcwnfLgwoUL+PTTTwst79ixIy5cuCBBIvWJjY3FvXv3IAgCIiIiEBsbK94ePXqE1NRUFlbSGMbGxnj+/DkA4NixY+IYX319fbx69UrKaCVib2GZatu2LQIDA9GmTRtERERg586dAIDbt2+LE7iXZ1lZWUVOyJ2TkyPr/1CqUHAOKT8/X+IkRNLr3LkzRo4ciaZNm+L27dvw8vICAMTExKBWrVrShisB91xlatWqVdDR0cHu3buxZs0aVK9eHQDw559/omvXrhKnK30tWrTAunXrCi1fu3YtmjdvLkEi6Vy/fh1HjhzB/v37lW5EmmD16tVwdXXFs2fP8Pvvv6NSpUoAgEuXLsl6WB7PuZIsnT17Fp06dcInn3wCd3d3AEBISAj++usvHDt2DO3atZM4Yem7f/8+evXqhWvXrikNoi84H6sJPUWJyioWVxnLz8/H3bt38fTp00KHCNu3by9RKvWJjIzEd999h8jISBgYGKBRo0aYNWsWHB0dpY6mFt27d4e2tjbWr18POzs7RERE4Pnz55gyZQq+//57jfiCQQS8vkJWREREoc9ChUKBoUOHSpiseCyuMnX+/HkMGjQIcXFxhXqMasr4Nk1XuXJlhIaGolGjRjAzM0NERATq1q2L0NBQTJkyBVeuXJE6IpWC3r17v3dbuQ5DUaUDBw5g8ODBSEtLg6mpqdK4X4VCgaSkJAnTFY8dmmRq7NixcHFxwaFDh1CtWrUyd0UIVdD0Pfe8vDxxHuXKlSvj8ePHqFu3LmxtbXHr1i2J01FpKe/XK/5QU6ZMgZ+fHxYtWlSmJpFhcZWpO3fuYPfu3XBwcJA6iiS45/76guBXr16FnZ0dWrZsiaVLl0JXVxfr1q2Dvb291PGolJT3CWI+1KNHjzBhwoQyVVgB9haWrZYtW+Lu3btSx5BMwZ57dHQ0kpKS8OLFC/Em18NAqjZ79mxxj33BggWIjY1Fu3btcPjwYfz0008SpyNSDw8PD1y8eFHqGB+M51xlau/evZg9ezamTZsGZ2fnQhdNl+s1DFXFyMgIV69e1dg99+IkJSXBwsJCI08TaKrdu3dj165diI+PR3Z2ttK6y5cvS5RKfTZs2IAFCxbA19e3yM/CHj16SJSsZCyuMvXmxN0FCoZjaMJhUTc3N0yfPl0jxvQSFeenn37Cl19+ieHDh2PdunXw9fXFvXv38Ndff8Hf3x/ffPON1BFLXVGfhQXk/FnIc64yVVavYagq48ePx5QpU5CQkKCRe+4AkJmZiZUrV+LkyZNFdurShL0WTffzzz9j3bp1GDhwIIKDgzF9+nTY29tj7ty5GnN6pKzOVMY9V5IlTd9zB4DBgwfj2LFj6Nu3L6pWrVroUPC8efMkSkbqYmhoiBs3bsDW1haWlpY4fvw4GjdujDt37qBVq1binLuaIjMzE/r6+lLHeC/cc5WxLVu2YO3atYiNjUV4eDhsbW2xfPly2NnZ4bPPPpM6XqnS9D13ADh48CAOHz6MNm3aSB2FJGJlZYWkpCTY2tqiZs2aOH/+PBo3bozY2Ngir5hUHuXl5WHRokVYu3YtEhMTcfv2bdjb22POnDmoVasWRowYIXXEIrG3sEytWbMGgYGB8PLyQnJysrinZm5ujuXLl0sbTg1sbW1LvGmC6tWri+NcSTO5ubmJ80j7+vpi8uTJ6Ny5M/r3749evXpJnE49vvnmGwQHB4tD0Qo0bNgQ69evlzBZyXhYWKacnJywaNEi9OzZEyYmJrh69Srs7e0RHR2Njh074p9//pE6Yql43wnp5dpDUJX+/PNP/PTTT1i7dq3GfKEgZfn5+cjPz4eOzuuDjDt27MC5c+fg6OiIMWPGKBWb8srBwQG//PIL3N3dlT4Lb968CVdXV7x48ULqiEXiYWGZio2NRdOmTQst19PTQ3p6ugSJ1KNnz57vbKMp51xdXFyQmZkJe3t7GBoaFurUpSkdWjSZlpaWUv+DAQMGYMCAARImUr9Hjx4VOSQvPz8fOTk5EiR6PyyuMmVnZ4fIyMhCeyxHjhxB/fr1JUpV+spqz8DSMHDgQDx69AiLFi0qskMTlU9RUVFo2LAhtLS0EBUVVWJbTeg17+TkhDNnzhT6LNy9e3eROyByweIqU4GBgfD390dmZiYEQUBERAS2b9+OxYsXy/o8A6nOuXPnEB4ejsaNG0sdhdSoSZMmSEhIgKWlJZo0aaJ0ucE3acoRnLlz58LHxwePHj1Cfn4+9uzZg1u3bmHz5s04ePCg1PGKxeIqUyNHjoSBgQFmz56NjIwMDBo0CNbW1lixYoXGHRbSVPXq1cOrV6+kjkFqFhsbiypVqog/a7rPPvsMBw4cwIIFC2BkZIS5c+eiWbNmOHDgADp37ix1vGKxQ1MZkJGRgbS0NFhaWkodhdTo2LFjmD9/Pr755psiJ9IwNTWVKBmpy+nTp9G6dWuxQ1OB3NxcnDt3TiOuDlVWsbiWEWFhYcjIyECrVq1gYWEhdRxSg4KOLG+fa9WkiTQ0nba2Np48eVLoi/Xz589haWmpcX8DmZmZ2LlzJzIyMtCpUyc4OjpKHalYPCwsM0uWLEFaWhoWLlwI4PUHqaenJ44dOwYAsLS0REhICBo0aCBlzFKVl5eHs2fPolGjRjA3N5c6jmROnjwpdQSSWMEXqbc9f/4cRkZGEiRSn8DAQOTk5GDlypUAgOzsbLRq1QrXr1+HoaEhpk2bhuPHj8PV1VXipEVjcZWZnTt3YsaMGeL93bt34/Tp0zhz5gzq16+PYcOGYf78+di1a5eEKUuXtrY2unTpghs3bmhscc3JycGCBQuwdu1aWX87p9LRu3dvAK+PWgwfPhx6enriury8PERFRaF169ZSxVOLY8eOYdGiReL9rVu3Ij4+Hnfu3EHNmjXh5+eHr7/+GocOHZIwZfFYXGUmNjZWqXv94cOH0bdvX3EKvNmzZ+Pzzz+XKp7aNGzYEPfv34ednZ3UUSRRoUKFdw7DoPLLzMwMwOs9VxMTExgYGIjrdHV10apVK4waNUqqeGoRHx8PJycn8X7BPNsFQ3ImTpwILy8vqeK9E4urzOTm5ip9Sw0PD8ekSZPE+9bW1uV2dqY3ff3115g6dSoWLlyI5s2bFzoEpgmdeYYMGYINGzbg22+/lToKqVlQUJA4/GblypUwNjaWOJH6aWlpKQ1BOn/+PObMmSPeNzc3l+3sTACLq+zUrl0bp0+fhr29PeLj43H79m2lHoEPHz5EpUqVJEyoHgXfSHv06KF0zkmTOvPk5uZi48aNOHHiRJFfMJYtWyZRMlIHQRCwdetW/Oc//9HIUwP169fHgQMHEBgYiJiYGMTHx+PTTz8V18fFxaFq1aoSJiwZi6vM+Pv7IyAgAGfOnMH58+fh6uqqdGgkNDRU1rOSqAo78wDR0dFo1qwZAOD27dtK6zhbU/mnpaUFR0dHPH/+XCOL6/Tp0zFgwAAcOnQIMTEx8PLyUjpNdPjwYbRo0ULChCXjUBwZ2rhxIw4cOAArKyvMmzcPVlZW4rpx48ahc+fOGnNFDCJNduDAASxduhRr1qxBw4YNpY6jdiEhITh48CCsrKwwfvx4GBoaiuvmz5+PDh06oGPHjtIFLAGLK8nWmTNn8Msvv+D+/fv47bffUL16dWzZsgV2dnZo27at1PHU6uHDhwCAGjVqSJyE1MnCwgIZGRnIzc2Frq6uUscmgBdvkDMeFiZZ+v333zF06FAMHjwYly9fRlZWFgAgJSUFixYtwuHDhyVOWPry8/Px9ddf44cffkBaWhoAwMTEBFOmTMGXX36pdLUUKp804drN5RX3XEmWmjZtismTJ2PYsGFK13C8cuUKPD09kZCQIHXEUjdr1ixs2LAB8+fPF4di/e9//8NXX32FUaNG4ZtvvpE4IREVh8WVZMnQ0BDXr19HrVq1lIrr/fv34eTkhMzMTKkjljpra2usXbu20IXh//jjD4wbNw6PHj2SKBlJITMzE9nZ2UrLNGFIWlnF40okS1ZWVrh7926h5f/73/9gb28vQSL1S0pKQr169Qotr1evHs+1aYj09HQEBATA0tISRkZGsLCwULqRfLG4ytzdu3dx9OhR8dJjmnKgYdSoUZg4cSIuXLgAhUKBx48fY+vWrZg6dSq++OILqeOpRePGjbFq1apCy1etWsVrvGqI6dOnIzQ0FGvWrIGenh7Wr1+P+fPnw9raGps3b5Y6ntrk5ubixIkT+OWXX/Dy5UsAwOPHj8W+CLIkkCz9888/gru7u6BQKAQtLS3h3r17giAIgq+vrxAYGChxutKXn58vfP3114KRkZGgUCgEhUIh6OvrC7Nnz5Y6mtqcOnVKMDIyEurXry/4+fkJfn5+Qv369QVjY2Ph9OnTUscjNbCxsRFOnjwpCIIgmJiYCHfu3BEEQRA2b94seHp6SphMfR48eCDUq1dPMDQ0FLS1tcXPwgkTJghjxoyROF3xuOcqU5MnT4aOjg7i4+OVxnb1798fR44ckTCZeigUCnz55ZdISkpCdHQ0zp8/j2fPnolXC9IEHTp0wO3bt9GrVy8kJycjOTkZvXv3xq1bt9CuXTup45EaJCUliadBTE1NxdMBbdu2xenTp6WMpjYTJ06Ei4sLXrx4oTQUqVevXggJCZEwWck4FEemjh07hqNHjxYa1+jo6Ii4uDiJUqlPaGgoWrduDX19faUZqjRBwQULFAoFrK2t2StYg9nb2yM2NhY1a9ZEvXr1sGvXLrRo0QIHDhzQmCtGnTlzBufOnYOurq7S8lq1asm6Ux/3XGUqPT1daY+1QFJSktLE/uVVjx49YG5ujnbt2mHOnDk4ceKEeN65vHN0dMSzZ8/E+/3790diYqKEiUgqvr6+uHr1KgBg5syZWL16NfT19TF58mRMmzZN4nTqkZ+fX+Rc4g8fPoSJiYkEid4Ph+LIlJeXF5o3b46FCxfCxMQEUVFRsLW1xYABA5Cfn4/du3dLHbFU5eTkICIiAmFhYQgLC8O5c+eQnZ0NFxcXfPrpp/j666+ljlhqtLS0kJCQAEtLSwBQGopEmi0uLg6XLl2Cg4OD0qUpy7P+/fvDzMwM69atEz8Lq1Spgs8++ww1a9ZEUFCQ1BGLxOIqU9HR0XB3d0ezZs0QGhqKHj16ICYmBklJSTh79ixq164tdUS1iomJwXfffYetW7cW+022vGBxpfz8fHz33XfYv38/srOz4e7ujnnz5hWa/lATPHz4EB4eHhAEAXfu3IGLiwvu3LmDypUr4/Tp0+L/E7lhcZWxlJQUrFq1ClevXkVaWhqaNWsGf39/VKtWTepope727ds4deoUTp06hbCwMGRlZaFdu3bo2LEjOnbsWK6HomhrayMhIQFVqlQBAPHbuqZeOF4TLVy4EF999RU6deoEAwMDHD16FAMHDsTGjRuljiaJ3Nxc7Ny5U+mzcPDgwbL+ssHiSrKkpaWFKlWqYOLEiejWrRucnZ015jJrWlpa8PT0FM+tHzhwAG5uboWu57pnzx4p4pEaODo6YurUqRgzZgwA4MSJE/D29sarV684p3QZwd+STB05cgT/+9//xPurV69GkyZNMGjQILx48ULCZOoxYcIEVK9eHQsWLMDYsWPx5Zdf4tixY8jIyJA6Wqnz8fGBpaUlzMzMYGZmhiFDhsDa2lq8X3Cj8is+Ph5eXl7i/U6dOomTqWiaTZs24dChQ+L96dOnw9zcHK1bt5b1yAnuucqUs7MzlixZAi8vL1y7dg0uLi6YMmUKTp48iXr16sn2JL6qJScn48yZM2LHppiYGDRt2hRnz56VOhpRqXn71ACguacH6tatizVr1sDNzQ3h4eFwd3fH8uXLcfDgQejo6Mj2CA7HucpUbGysOL7z999/R/fu3bFo0SJcvnxZ6RtteZeXl4ecnBxkZWUhMzMTWVlZuHXrltSxiEqVIAgYPny40rC7zMxMjB07Vun0gFwLiyr9/fffcHBwAADs27cPffv2xejRo9GmTRvZXigdYHGVLV1dXfEQ6IkTJzBs2DAAQMWKFZGamiplNLWYMGECTp06hevXr8PCwgLt27fHqFGj0LFjRzg7O0sdj6hU+fj4FFo2ZMgQCZJIz9jYGM+fP0fNmjVx7NgxBAYGAgD09fVlPfadxVWm2rZti8DAQLRp0wYRERHYuXMngNe9aN+etak8evLkCUaPHo2OHTuiYcOGUschUitNOe3zPjp37oyRI0eiadOmuH37tnjkLiYmBrVq1ZI2XAnYoUmmVq1aBR0dHezevRtr1qxB9erVAQB//vknunbtKnG60vfbb78hICCAhZVIw61evRqurq549uwZfv/9d1SqVAkAcOnSJQwcOFDidMVjhyaSpU2bNqFy5crw9vYG8LqH4Lp16+Dk5ITt27fD1tZW4oRERMVjcS0DMjMzkZ2drbTM1NRUojTq8XYPwU6dOuHHH3+UfQ9BIiodGRkZiI+PL/RZKNdpIFlcZSo9PR0zZszArl278Pz580Lry/P0fwBgaGiImzdvombNmpgxYwaePHmCzZs3IyYmBh07dlSa2J6Iyq9nz55h+PDhxV5qU66fhTznKlPTp09HaGgo1qxZAz09Paxfvx7z58+HtbU1Nm/eLHW8UlfQQxB4ffm9zp07A5B/D0EiUq1JkyYhJSUFFy5cgIGBAY4cOYJNmzbB0dER+/fvlzpesdhbWKYOHDiAzZs3o2PHjvD19UW7du3g4OAAW1tbbN26FYMHD5Y6Yqkqqz0EiUi1QkND8ccff8DFxQVaWlqwtbVF586dYWpqisWLF4v9MuSGe64ylZSUJF4FxdTUFElJSQBeD9E5ffq0lNHUoqz2ECQi1UpPTxevfGNhYSGeEnJ2dsbly5eljFYi7rnKlL29PWJjY1GzZk3Uq1cPu3btQosWLXDgwAGYm5tLHa/UmZubY9WqVYWWz58/X4I0RCSVunXr4tatW6hVqxYaN26MX375BbVq1cLatWtlfYUwdmiSqR9//BHa2tqYMGECTpw4ge7du0MQBOTk5GDZsmWYOHGi1BFLXXJyMiIiIvD06VPk5+eLyxUKBYYOHSphMiJSl19//RW5ubkYPnw4Ll26hK5duyIpKQm6uroIDg5G//79pY5YJBbXMiIuLg6XLl2Cg4ODbLueq9KBAwcwePBgpKWlwdTUVOlycwqFQjxMTkSaJSMjQxxJULlyZanjFIvFlWSpTp068PLywqJFi2BoaCh1HCKiD8IOTTITGhoKJyenIifnT0lJQYMGDXDmzBkJkqnXo0ePMGHCBBZWIg3Xp08fLFmypNDypUuX4vPPP5cg0fthcZWZ5cuXY9SoUUXOwGRmZoYxY8Zg2bJlEiRTLw8PD1y8eFHqGEQksdOnTxd5mU1PT09Zj5xgb2GZuXr1apHf0gp06dIF33//vRoTScPb2xvTpk3D9evX4ezsjAoVKiit79Gjh0TJiEid0tLSoKurW2h5hQoVZH35TRZXmUlMTCxUSN6ko6OjEVP/jRo1CgCwYMGCQusUCoVspzwjItVydnbGzp07MXfuXKXlO3bsgJOTk0Sp3o3FVWaqV6+O6OhoODg4FLk+KipK1mO7VOXNoTdEpLnmzJmD3r174969e3BzcwMAhISEYPv27fjtt98kTlc8nnOVGS8vL8yZMweZmZmF1r169Qrz5s1Dt27dJEgmD8nJyUVOLkFE5VP37t2xb98+3L17F+PGjcOUKVPw8OFDnDhxAj179pQ6XrE4FEdmEhMT0axZM2hrayMgIAB169YFANy8eROrV69GXl4eLl++jKpVq0qcVL1CQkKwYcMG7N27F4aGhkVeKYiISC5YXGUoLi4OX3zxBY4ePYqCX49CoYCHhwdWr14NOzs7iROqx99//42goCAEBQUhPj4eAwYMwNChQ+Hu7l7ieWkiIqmxuMrYixcvcPfuXQiCAEdHR1hYWEgdqdTl5ORg3759WL9+Pc6cOYOuXbti0KBBGDhwIK5evSrrDgxERAVYXElWLC0tUa9ePQwZMgSff/65+IWiQoUKLK5EVGawQxPJSm5uLhQKBRQKBbS1taWOQ0T0UVhcSVYeP36M0aNHY/v27bCyskKfPn2wd+9epYn7iaj8a9euHb7//nvcvn1b6igfhcWVZEVfXx+DBw9GaGgorl27hvr162PChAnIzc3FN998g+PHj3MCCSINMGrUKISHh6N58+aoX78+ZsyYgbNnz6KsnMnkOVeSvfz8fBw9ehQbNmzAgQMHYGJign/++UfqWESkBllZWQgJCcEff/yBAwcOIC8vD97e3ujRowc8PDxgYGAgdcQisbhSmfLs2TNs2bIFgYGBUkchIglcuHAB+/fvx/79+8VZm2bNmoU2bdpIHU0JiysREZVJ9+7dw/79+2FjY4O+fftKHUcJiysREZGKsUMTERGRirG4EhERqRiLK8ladnY2bt26hdzcXKmjEBG9NxZXkqWMjAyMGDEChoaGaNCgAeLj4wEA48ePx7fffitxOiKikvFi6SRLs2bNwtWrV3Hq1Cl07dpVXN6pUyd89dVXmDlzpoTpiEhd8vLyEBwcjJCQEDx9+hT5+flK60NDQyVKVjIWV5Klffv2YefOnWjVqpXS1IcNGjTAvXv3JExGROo0ceJEBAcHw9vbGw0bNiwzU6GyuJIsPXv2DJaWloWWp6enl5n/XET07+3YsQO7du2Cl5eX1FE+CM+5kiy5uLjg0KFD4v2Cgrp+/Xq4urpKFYuI1ExXVxcODg5Sx/hg3HMlWVq0aBE8PT1x/fp15ObmYsWKFbh+/TrOnTuHsLAwqeMRkZpMmTIFK1aswKpVq8rUUSvO0ESydf/+fSxevBhXr15FWloamjVrhhkzZsDZ2VnqaERUinr37q10PzQ0FBUrVkSDBg1QoUIFpXV79uxRZ7T3xj1Xkp2cnByMGTMGc+bMwX//+1+p4xCRmpmZmSnd79Wrl0RJPh73XEmWzMzMEBkZCTs7O6mjEBF9MHZoIlnq2bMn9u3bJ3UMIpJYbGws7ty5U2j5nTt38ODBA/UHek88LEyy5OjoiAULFuDs2bNo3rw5jIyMlNZPmDBBomREpE7Dhw+Hn58fHB0dlZZfuHAB69evx6lTp6QJ9g48LEyyVNLhYIVCgfv376sxDRFJxdTUFJcvXy40HOfu3btwcXFBcnKyNMHegXuuJEuxsbFSRyAiGVAoFHj58mWh5SkpKcjLy5Mg0fvhnisREclW9+7dYWBggO3bt0NbWxvA6/mG+/fvj/T0dPz5558SJywaiyvJRmBgIBYuXAgjIyMEBgaW2HbZsmVqSkVEUoqJiUGHDh1gbm6Odu3aAQDOnDmD1NRUhIaGomHDhhInLBoPC5NsXLlyBTk5OeLPREQNGjRAVFQUVq1ahatXr8LAwADDhg1DQEAAKlasKHW8YnHPlYiIZCs+Ph42NjZFTn0YHx+PmjVrSpDq3TjOlWTJz8+vyE4M6enp8PPzkyAREUnBzs4Oz549K7T8+fPnsp5khsWVZGnTpk149epVoeWvXr3C5s2bJUhERFIQBKHIvda0tDTo6+tLkOj98JwryUpqaioEQYAgCHj58qXSf568vDwcPny4yOu8ElH5UtCpUaFQYM6cOTA0NBTX5eXl4cKFC2jSpIlE6d6NxZVkxdzcHAqFAgqFAnXq1Cm0XqFQYP78+RIkIyJ1KujUKAgCrl27Bl1dXXGdrq4uGjdujKlTp0oV753YoYlkJSwsDIIgwM3NDb///rtSb0BdXV3Y2trC2tpawoREpE6+vr5YsWIFTE1NpY7yQVhcSZbi4uJgY2MDLS12CyCisofFlWQrOTkZERERePr0KfLz85XWDRs2TKJURKRuFy9exK5duxAfH4/s7GyldbxYOtEHOHDgAAYPHoy0tDSYmpoq9RZUKBQsrkQaYseOHRg2bBg8PDxw7NgxdOnSBbdv30ZiYqKsL6LOPVeSpTp16sDLywuLFi1S6iVIRJqlUaNGGDNmDPz9/WFiYoKrV6/Czs4OY8aMQbVq1WTbwZHFlWTJyMgI165dg729vdRRiEhCRkZGiImJQa1atVCpUiWcOnUKzs7OuHHjBtzc3PDkyROpIxaJvUVIljw8PHDx4kWpYxCRxCwsLMTZ2qpXr47o6GgAr/tkZGRkSBmtRDznSrLk7e2NadOm4fr163B2dkaFChWU1vfo0UOiZESkTu3bt8fx48fh7OyMzz//HBMnTkRoaCiOHz8Od3d3qeMVi4eFSZZKGoKjUChkfZFkIlKdpKQkZGZmwtraGvn5+Vi6dCnOnTsHR0dHzJ49GxYWFlJHLBKLKxERkYrxnCsREZGKsbiSrHh5eSElJUW8/+233yI5OVm8//z5czg5OUmQjIjUSVtb+71ucsXDwiQr2traePLkiXjlG1NTU0RGRopDchITE2Ftbc1zrkTlnJaWFmxtbeHj44OmTZsW2+6zzz5TY6r3x97CJCtvf9fjdz8izRQREYENGzZgxYoVsLOzg5+fHwYPHizbDkxv42FhIiKSHRcXF6xZswZPnjxBYGAg9u7dixo1amDAgAE4fvy41PHeicWVZKXgWq5vLyMizaSvr48hQ4YgJCQE0dHRePr0Kbp27YqkpCSpo5WIh4VJVgRBwPDhw6GnpwcAyMzMxNixY2FkZAQAyMrKkjIeEUng4cOHCA4ORnBwMDIyMjBt2jTZX9+VHZpIVnx9fd+rXVBQUCknISIpZWdnY+/evdiwYQPOnDkDT09P+Pn5wdPTU9a9hAuwuBIRkexUqlQJJiYm8PHxwdChQ8URBG+T6x4siysREcnOm1OgFtXvQhAEWU+FynOuREQkOydPnpQ6wr/CPVciIiIV41AcIiIiFWNxJSIiUjEWVyIiIhVjcSUiIlIxFlciIiIV41AcIiKSld69e7932z179pRiko/H4kpERLJiZmYmdYR/jeNciYiIVIznXImIiFSMh4WJiEjWdu/ejV27diE+Ph7Z2dlK6y5fvixRqpJxz5WIiGTrp59+gq+vL6pWrYorV66gRYsWqFSpEu7fvw9PT0+p4xWL51yJiEi26tWrh3nz5mHgwIEwMTHB1atXYW9vj7lz5yIpKQmrVq2SOmKRuOdKRESyFR8fj9atWwMADAwM8PLlSwDA0KFDsX37dimjlYjFlYiIZMvKygpJSUkAgJo1a+L8+fMAgNjYWMj5wCuLKxERyZabmxv2798PAPD19cXkyZPRuXNn9O/fH7169ZI4XfF4zpWIiGQrPz8f+fn50NF5Pbhlx44dOHfuHBwdHTFmzBjo6upKnLBoLK5EREQqxnGuREQkK1FRUWjYsCG0tLQQFRVVYttGjRqpKdWH4Z4rERHJipaWFhISEmBpaQktLS0oFIoiOy8pFArk5eVJkPDduOdKRESyEhsbiypVqog/l0UsrkREJCu2trbiz3FxcWjdurXYoalAbm4uzp07p9RWTnhYmIiIZEtbWxtPnjyBpaWl0vLnz5/D0tJStoeFOc6ViIhkSxAEKBSKQsufP38OIyMjCRK9Hx4WJiIi2enduzeA152Whg8fDj09PXFdXl4eoqKixGkR5YjFlYiIZMfMzAzA6z1XExMTGBgYiOt0dXXRqlUrjBo1Sqp478TiSkREshMUFCQOv1m5ciWMjY0lTvRh2KGJiIhkKT8/H/r6+oiJiYGjo6PUcT4IOzQREZEsaWlpwdHREc+fP5c6ygdjcSUiItn69ttvMW3aNERHR0sd5YPwsDAREcmWhYUFMjIykJubC11dXaWOTQDEa73KDTs0ERGRbC1fvlzqCB+Fe65EREQqxj1XIiIqEzIzM5Gdna20zNTUVKI0JWOHJiIikq309HQEBATA0tISRkZGsLCwULrJFYsrERHJ1vTp0xEaGoo1a9ZAT08P69evx/z582FtbY3NmzdLHa9YPOdKRESyVbNmTWzevBkdO3aEqakpLl++DAcHB2zZsgXbt2/H4cOHpY5YJO65EhGRbCUlJcHe3h7A6/OrBUNv2rZti9OnT0sZrUQsrkREJFv29vaIjY0FANSrVw+7du0CABw4cADm5uYSJisZDwsTEZFs/fjjj9DW1saECRNw4sQJdO/eHYIgICcnB8uWLcPEiROljlgkFlciIioz4uLicOnSJTg4OKBRo0ZSxykWiysREclOfn4+vvvuO+zfvx/Z2dlwd3fHvHnzCk1/KFc850pERLLzzTff4D//+Q+MjY1RvXp1rFixAv7+/lLHem/ccyUiItlxdHTE1KlTMWbMGADAiRMn4O3tjVevXkFLS/77hSyuREQkO3p6erh79y5sbGzEZfr6+rh79y5q1KghYbL3I//yT0REGic3Nxf6+vpKyypUqICcnByJEn0YTtxPRESyIwgChg8fDj09PXFZZmYmxo4dCyMjI3HZnj17pIj3TiyuREQkOz4+PoWWDRkyRIIkH4fnXImIiFSM51yJiIhUjMWViIhIxVhciYiIVIzFlYiISMVYXImIiFSMxZWIiEjFWFyJiIhUjMWViIhIxf4f2Y5WNomNvCcAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the frequency of failures by the failure type\n", + "fig, ax = plt.subplots(1,1, figsize=(5,3))\n", + "df = medical_failure.copy()\n", + "failure_mode_counts = df.groupby(\"failure_modes\").size()\n", + "failure_mode_counts.plot.bar(ax=ax, title=f\"Failure mode frequency\", color=\"#c61a27\")\n", + "\n", + "y_hline = failure_mode_counts.max() / 2\n", + "ax.axhline(y=y_hline, linestyle=\"--\", color=\"black\")\n", + "ax.set_ylabel(\"Counts\")\n", + "ax.set_xlabel(\"\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "id": "4acda359", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0, '')" + ] + }, + "execution_count": 68, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the frequency of failures by the task type for the failure mode other\n", + "fig, ax = plt.subplots(1,1, figsize=(5,3))\n", + "question_type = medical_failure.copy()\n", + "question_type = question_type.query(\"failure_modes == 'Other'\")\n", + "question_type = question_type['subtask'].str.split(':').str[0]\n", + "subtask_counts = question_type.value_counts()\n", + "subtask_counts.plot.bar(ax=ax, title=f\"Task type failure frequency for Failure mode: Other\", color=\"#c61a27\")\n", + "y_hline = subtask_counts.max() / 2\n", + "ax.axhline(y=y_hline, linestyle=\"--\", color=\"black\")\n", + "ax.set_ylabel(\"Counts\")\n", + "ax.set_xlabel(\"\")" + ] + }, + { + "cell_type": "markdown", + "id": "9aaf7592", + "metadata": {}, + "source": [ + "# Sprache Analyse" + ] + }, + { + "cell_type": "code", + "execution_count": 139, + "id": "df7bbc3a", + "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", + "
model_nameiteration_indexscore_possiblescore_achieved_total
0chatglm3:6:ggmlv3:q4_01357.0155.0
1chatglm3:6:ggmlv3:q4_02357.0148.0
2chatglm3:6:ggmlv3:q4_03357.0154.0
3gpt-3.5-turbo-01251357.0237.0
4gpt-3.5-turbo-01252357.0241.0
...............
109openhermes-2.5:7:ggufv2:Q6_K2357.0205.0
110openhermes-2.5:7:ggufv2:Q6_K3357.0205.0
111openhermes-2.5:7:ggufv2:Q8_01357.0206.0
112openhermes-2.5:7:ggufv2:Q8_02357.0206.0
113openhermes-2.5:7:ggufv2:Q8_03357.0206.0
\n", + "

114 rows × 4 columns

\n", + "
" + ], + "text/plain": [ + " model_name iteration_index score_possible \\\n", + "0 chatglm3:6:ggmlv3:q4_0 1 357.0 \n", + "1 chatglm3:6:ggmlv3:q4_0 2 357.0 \n", + "2 chatglm3:6:ggmlv3:q4_0 3 357.0 \n", + "3 gpt-3.5-turbo-0125 1 357.0 \n", + "4 gpt-3.5-turbo-0125 2 357.0 \n", + ".. ... ... ... \n", + "109 openhermes-2.5:7:ggufv2:Q6_K 2 357.0 \n", + "110 openhermes-2.5:7:ggufv2:Q6_K 3 357.0 \n", + "111 openhermes-2.5:7:ggufv2:Q8_0 1 357.0 \n", + "112 openhermes-2.5:7:ggufv2:Q8_0 2 357.0 \n", + "113 openhermes-2.5:7:ggufv2:Q8_0 3 357.0 \n", + "\n", + " score_achieved_total \n", + "0 155.0 \n", + "1 148.0 \n", + "2 154.0 \n", + "3 237.0 \n", + "4 241.0 \n", + ".. ... \n", + "109 205.0 \n", + "110 205.0 \n", + "111 206.0 \n", + "112 206.0 \n", + "113 206.0 \n", + "\n", + "[114 rows x 4 columns]" + ] + }, + "execution_count": 139, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = agg[2].copy()\n", + "df" + ] + }, + { + "cell_type": "code", + "execution_count": 157, + "id": "14ee6db9", + "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", + "
langscategoryiteration_indexscore_possiblescore_achieved_totalaccuracy
0deanatomy138.020.00.526316
1deanatomy238.020.00.526316
2deanatomy338.020.00.526316
3debiochemistry1190.050.00.263158
4debiochemistry2190.049.00.257895
.....................
61enoncology2456.0263.00.576754
62enoncology3456.0263.00.576754
63enphysiology1190.060.00.315789
64enphysiology2190.061.00.321053
65enphysiology3190.061.00.321053
\n", + "

66 rows × 6 columns

\n", + "
" + ], + "text/plain": [ + " langs category iteration_index score_possible score_achieved_total \\\n", + "0 de anatomy 1 38.0 20.0 \n", + "1 de anatomy 2 38.0 20.0 \n", + "2 de anatomy 3 38.0 20.0 \n", + "3 de biochemistry 1 190.0 50.0 \n", + "4 de biochemistry 2 190.0 49.0 \n", + ".. ... ... ... ... ... \n", + "61 en oncology 2 456.0 263.0 \n", + "62 en oncology 3 456.0 263.0 \n", + "63 en physiology 1 190.0 60.0 \n", + "64 en physiology 2 190.0 61.0 \n", + "65 en physiology 3 190.0 61.0 \n", + "\n", + " accuracy \n", + "0 0.526316 \n", + "1 0.526316 \n", + "2 0.526316 \n", + "3 0.263158 \n", + "4 0.257895 \n", + ".. ... \n", + "61 0.576754 \n", + "62 0.576754 \n", + "63 0.315789 \n", + "64 0.321053 \n", + "65 0.321053 \n", + "\n", + "[66 rows x 6 columns]" + ] + }, + "execution_count": 157, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = agg[0].copy()\n", + "\n", + "langs = df['subtask'].str.split(':').str[2]\n", + "category = df['subtask'].str.split(':').str[1]\n", + "\n", + "df['langs'] = langs\n", + "df['category'] = category\n", + "\n", + "df[\"score_possible\"] = df[\"score\"].apply(\n", + " lambda x: float(x.split(\"/\")[1])\n", + " )\n", + "df[\"score_achieved_total\"] = df[\"scores\"].apply(\n", + " lambda x: np.sum([float(score) for score in x.split(\";\")])\n", + ")\n", + "df[\"iteration_scores\"] = df[\"scores\"].apply(\n", + " lambda x: [float(score) for score in x.split(\";\")]\n", + ")\n", + "df[\"iteration_index\"] = df[\"iteration_scores\"].apply(\n", + " lambda x: list(range(1, len(x) + 1))\n", + ")\n", + "\n", + "exploded_results = df.explode([\"iteration_scores\", \"iteration_index\"])\n", + "exploded_results[\"iteration_scores\"] = exploded_results[\"iteration_scores\"].astype(float)\n", + "exploded_results[\"iteration_index\"] = exploded_results[\"iteration_index\"].astype(int)\n", + " \n", + "\n", + "df = exploded_results.groupby([\"langs\", \"category\", \"iteration_index\"]).agg(\n", + " score_possible=(\"score_possible\", \"sum\"),\n", + " score_achieved_total=(\"iteration_scores\", \"sum\"),\n", + ").reset_index()\t\n", + "\n", + "\n", + "df[\"accuracy\"] = df[\"score_achieved_total\"] / (df[\"score_possible\"])\n", + "df\n" + ] + }, + { + "cell_type": "code", + "execution_count": 166, + "id": "3d87b2ae", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 166, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1,1, figsize=(7,2))\n", + "colors = [\"#c61a27\", \"#800080\"]\n", + "offset_value = 0.3\n", + "for i, lang in enumerate(df[\"langs\"].unique()):\n", + " temp_df = df.query(\"langs == @lang\")\n", + " temp_df = temp_df.groupby(\"category\").agg(\n", + " accuracy=(\"accuracy\", \"mean\"),\n", + " std=(\"accuracy\", \"std\"),\n", + " langs=(\"langs\", \"first\")\n", + " ).reset_index()\n", + "\n", + " # Calculate offset for this series\n", + " offset = (i - len(df[\"langs\"].unique())/2) * offset_value\n", + " x_values_with_offset = range(len(temp_df[\"category\"])) \n", + " x_values_with_offset = [x + offset for x in x_values_with_offset]\n", + " \n", + " ax.plot(x_values_with_offset, temp_df[\"accuracy\"], marker=\"o\", ls=\"\", color=colors[i], ms=8)\n", + " ax.set_xticks(range(len(temp_df[\"category\"]))) \n", + " ax.set_xticklabels(temp_df[\"category\"], rotation=90) \n", + " ax.errorbar(x_values_with_offset, temp_df[\"accuracy\"], yerr=temp_df[\"std\"], capsize=6, ls=\"\", color=colors[i], linewidth=3)\n", + " \n", + "ax.set_xticklabels(ax.get_xticklabels(), rotation=90)\n", + "ax.axhline(y=0.5, linestyle=\"--\", color=\"black\")\n", + "ax.set_xlabel(\"\")\n", + "ax.set_ylabel(\"Accuracy\")\n", + "ax.set_ylim(0, 1)\n", + "fig.suptitle('Comparison of Task Type', fontsize=16)\n", + "ax.legend(df[\"langs\"].unique(), title=\"Language\", bbox_to_anchor=(0.7, 1), loc='upper left', ncol=len(df[\"langs\"].unique()), borderaxespad=0.)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "371eadd9", + "metadata": {}, + "outputs": [], + "source": [ + "ax.legend(df[\"langs\"].unique(), title=\"Language\", bbox_to_anchor=(1.05, -0.15), loc='upper left', ncol=len(df[\"langs\"].unique()), borderaxespad=0.)" + ] + }, + { + "cell_type": "markdown", + "id": "8a8abcbe", + "metadata": {}, + "source": [ + "# Statistics " + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "b81fad6ffd406939", + "metadata": { + "collapsed": false + }, + "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", + "
Sourceddof1ddof2Fp-uncnp2
0model_name37768306.650151.041718e-1230.999753
\n", + "
" + ], + "text/plain": [ + " Source ddof1 ddof2 F p-unc np2\n", + "0 model_name 37 76 8306.65015 1.041718e-123 0.999753" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The models have significantly different accuracies\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: invalid value encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: invalid value encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: invalid value encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: invalid value encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: invalid value encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: invalid value encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: invalid value encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: invalid value encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\bayesian.py:151: IntegrationWarning: The integral is probably divergent, or slowly convergent.\n", + " integr = quad(fun, 0, np.inf, args=(t, n, r, df))[0]\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\bayesian.py:151: IntegrationWarning: The integral is probably divergent, or slowly convergent.\n", + " integr = quad(fun, 0, np.inf, args=(t, n, r, df))[0]\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\bayesian.py:151: IntegrationWarning: The integral is probably divergent, or slowly convergent.\n", + " integr = quad(fun, 0, np.inf, args=(t, n, r, df))[0]\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\bayesian.py:151: IntegrationWarning: The integral is probably divergent, or slowly convergent.\n", + " integr = quad(fun, 0, np.inf, args=(t, n, r, df))[0]\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\bayesian.py:151: IntegrationWarning: The integral is probably divergent, or slowly convergent.\n", + " integr = quad(fun, 0, np.inf, args=(t, n, r, df))[0]\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\bayesian.py:151: IntegrationWarning: The integral is probably divergent, or slowly convergent.\n", + " integr = quad(fun, 0, np.inf, args=(t, n, r, df))[0]\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\bayesian.py:151: IntegrationWarning: The integral is probably divergent, or slowly convergent.\n", + " integr = quad(fun, 0, np.inf, args=(t, n, r, df))[0]\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\bayesian.py:151: IntegrationWarning: The integral is probably divergent, or slowly convergent.\n", + " integr = quad(fun, 0, np.inf, args=(t, n, r, df))[0]\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\bayesian.py:151: IntegrationWarning: The integral is probably divergent, or slowly convergent.\n", + " integr = quad(fun, 0, np.inf, args=(t, n, r, df))[0]\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\bayesian.py:151: IntegrationWarning: The integral is probably divergent, or slowly convergent.\n", + " integr = quad(fun, 0, np.inf, args=(t, n, r, df))[0]\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\bayesian.py:151: IntegrationWarning: The integral is probably divergent, or slowly convergent.\n", + " integr = quad(fun, 0, np.inf, args=(t, n, r, df))[0]\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\bayesian.py:151: IntegrationWarning: The integral is probably divergent, or slowly convergent.\n", + " integr = quad(fun, 0, np.inf, args=(t, n, r, df))[0]\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\bayesian.py:151: IntegrationWarning: The integral is probably divergent, or slowly convergent.\n", + " integr = quad(fun, 0, np.inf, args=(t, n, r, df))[0]\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: invalid value encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: invalid value encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: invalid value encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: invalid value encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\scipy\\stats\\_axis_nan_policy.py:573: RuntimeWarning: Precision loss occurred in moment calculation due to catastrophic cancellation. This occurs when the data are nearly identical. Results may be unreliable.\n", + " res = hypotest_fun_out(*samples, **kwds)\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\parametric.py:280: RuntimeWarning: invalid value encountered in multiply\n", + " ci = np.array([tval - tcrit, tval + tcrit]) * se\n", + "c:\\Users\\Sturm\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\pingouin\\effsize.py:803: RuntimeWarning: divide by zero encountered in scalar divide\n", + " d = (x.mean() - y.mean()) / poolsd\n" + ] + }, + { + "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", + "
ContrastABPairedParametricTdofalternativep-uncp-corrp-adjustBF10hedges
0model_namechatglm3:6:ggmlv3:q4_0gpt-3.5-turbo-0125FalseTrue-34.8775924.0two-sided4.032635e-060.002811bonf1240.092-22.781948
1model_namechatglm3:6:ggmlv3:q4_0gpt-4-0125-previewFalseTrue-55.1432924.0two-sided6.474839e-070.000451bonf4856.787-36.019447
2model_namechatglm3:6:ggmlv3:q4_0gpt-4-0613FalseTrue-42.3113964.0two-sided1.865118e-060.001300bonf2203.377-27.637688
3model_namechatglm3:6:ggmlv3:q4_0gpt-4o-2024-05-13FalseTrue-50.9116884.0two-sided8.907689e-070.000621bonf3826.331-33.255376
4model_namechatglm3:6:ggmlv3:q4_0llama-2-chat:13:ggufv2:Q2_KFalseTrue1.9824814.0two-sided1.184648e-011.000000bonf1.2591.294951
..........................................
698model_nameopenhermes-2.5:7:ggufv2:Q4_K_Mopenhermes-2.5:7:ggufv2:Q6_KFalseTrue13.0000004.0two-sided2.020399e-040.140822bonf70.0448.491564
699model_nameopenhermes-2.5:7:ggufv2:Q4_K_Mopenhermes-2.5:7:ggufv2:Q8_0FalseTrue10.0000004.0two-sided5.620036e-040.391717bonf33.9536.531973
700model_nameopenhermes-2.5:7:ggufv2:Q5_K_Mopenhermes-2.5:7:ggufv2:Q6_KFalseTrue-inf4.0two-sided0.000000e+000.000000bonfnan-inf
701model_nameopenhermes-2.5:7:ggufv2:Q5_K_Mopenhermes-2.5:7:ggufv2:Q8_0FalseTrue-inf4.0two-sided0.000000e+000.000000bonfnan-inf
702model_nameopenhermes-2.5:7:ggufv2:Q6_Kopenhermes-2.5:7:ggufv2:Q8_0FalseTrue-inf4.0two-sided0.000000e+000.000000bonfnan-inf
\n", + "

703 rows × 13 columns

\n", + "
" + ], + "text/plain": [ + " Contrast A B \\\n", + "0 model_name chatglm3:6:ggmlv3:q4_0 gpt-3.5-turbo-0125 \n", + "1 model_name chatglm3:6:ggmlv3:q4_0 gpt-4-0125-preview \n", + "2 model_name chatglm3:6:ggmlv3:q4_0 gpt-4-0613 \n", + "3 model_name chatglm3:6:ggmlv3:q4_0 gpt-4o-2024-05-13 \n", + "4 model_name chatglm3:6:ggmlv3:q4_0 llama-2-chat:13:ggufv2:Q2_K \n", + ".. ... ... ... \n", + "698 model_name openhermes-2.5:7:ggufv2:Q4_K_M openhermes-2.5:7:ggufv2:Q6_K \n", + "699 model_name openhermes-2.5:7:ggufv2:Q4_K_M openhermes-2.5:7:ggufv2:Q8_0 \n", + "700 model_name openhermes-2.5:7:ggufv2:Q5_K_M openhermes-2.5:7:ggufv2:Q6_K \n", + "701 model_name openhermes-2.5:7:ggufv2:Q5_K_M openhermes-2.5:7:ggufv2:Q8_0 \n", + "702 model_name openhermes-2.5:7:ggufv2:Q6_K openhermes-2.5:7:ggufv2:Q8_0 \n", + "\n", + " Paired Parametric T dof alternative p-unc p-corr \\\n", + "0 False True -34.877592 4.0 two-sided 4.032635e-06 0.002811 \n", + "1 False True -55.143292 4.0 two-sided 6.474839e-07 0.000451 \n", + "2 False True -42.311396 4.0 two-sided 1.865118e-06 0.001300 \n", + "3 False True -50.911688 4.0 two-sided 8.907689e-07 0.000621 \n", + "4 False True 1.982481 4.0 two-sided 1.184648e-01 1.000000 \n", + ".. ... ... ... ... ... ... ... \n", + "698 False True 13.000000 4.0 two-sided 2.020399e-04 0.140822 \n", + "699 False True 10.000000 4.0 two-sided 5.620036e-04 0.391717 \n", + "700 False True -inf 4.0 two-sided 0.000000e+00 0.000000 \n", + "701 False True -inf 4.0 two-sided 0.000000e+00 0.000000 \n", + "702 False True -inf 4.0 two-sided 0.000000e+00 0.000000 \n", + "\n", + " p-adjust BF10 hedges \n", + "0 bonf 1240.092 -22.781948 \n", + "1 bonf 4856.787 -36.019447 \n", + "2 bonf 2203.377 -27.637688 \n", + "3 bonf 3826.331 -33.255376 \n", + "4 bonf 1.259 1.294951 \n", + ".. ... ... ... \n", + "698 bonf 70.044 8.491564 \n", + "699 bonf 33.953 6.531973 \n", + "700 bonf nan -inf \n", + "701 bonf nan -inf \n", + "702 bonf nan -inf \n", + "\n", + "[703 rows x 13 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the statistics \n", + "model_root_names = [\"chatglm\", \"gpt\", \"llama\", \"mixtral\", \"openhermes\"]\n", + "\n", + "df = agg[2].copy()\n", + "df['accuracy'] = df['score_achieved_total'] / df['score_possible']\n", + "results = pg.anova(data=df, dv='accuracy', between='model_name')\n", + "display(results)\n", + "if(results.iloc[0, 4] < 0.05):\n", + " print(\"The models have significantly different accuracies\")\n", + "\n", + "pos_hoc = pg.pairwise_tests(data=df, dv='accuracy', between='model_name', padjust='bonf')\n", + "display(pos_hoc)" + ] + }, + { + "cell_type": "markdown", + "id": "bf2f9a20", + "metadata": {}, + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1bd3b587", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/benchmark/benchmark_utils.py b/benchmark/benchmark_utils.py index ddb7ebef..e6ff4804 100644 --- a/benchmark/benchmark_utils.py +++ b/benchmark/benchmark_utils.py @@ -306,6 +306,10 @@ def categorize_failure_modes( def is_synonym(word1, word2): + """ + Tests, if the input arguments word1 and word2 are synonyms of each other. + If yes, the function returns True, False otherwise. + """ if word2 is "yes" or "no" or "ja" or "nein": return False diff --git a/benchmark/conftest.py b/benchmark/conftest.py index bb4732c9..9603799a 100644 --- a/benchmark/conftest.py +++ b/benchmark/conftest.py @@ -20,7 +20,6 @@ # which models should be benchmarked? OPENAI_MODEL_NAMES = [ - # "gpt-3.5-turbo-0613", "gpt-3.5-turbo-0125", # "gpt-4-0613", # "gpt-4-0125-preview", diff --git a/benchmark/test_user_interaction.py b/benchmark/test_user_interaction.py index 2afe1311..bcb6ed0e 100644 --- a/benchmark/test_user_interaction.py +++ b/benchmark/test_user_interaction.py @@ -22,6 +22,15 @@ def test_medical_exam( conversation, multiple_testing, ): + """Test medical exam data by the model. + The user input is a medical question with answer options. The system prompt + has the guidelines to answer the question, and the expected answer is the + information that the model should reply from the given question. If the case + contains the word 'regex', the test is successful if the extracted information + occures in the words in response. If it is a different question, the test is + successful if the extracted information matches the expected answer exactly. + For all false answers also calculate the failure mode of the answer. + """ # Downloads the naturale language synonym toolkit, just need to be done once per device # nltk.download() @@ -40,13 +49,15 @@ def run_test(): nonlocal expected_answer nonlocal failure_mode conversation.reset() # needs to be reset for each test + # Define the system prompt [ conversation.append_system_message(m) for m in yaml_data["input"]["system_messages"] ] + # Define the user prompt response, _, _ = conversation.query(yaml_data["input"]["prompt"]) - # lower case, remove punctuation + # Set response to lower case and remove punctuation response = ( response.lower().replace(".", "").replace("?", "").replace("!", "") ).strip() diff --git a/docs/scripts/hooks.py b/docs/scripts/hooks.py index f6f273f0..dca0e34f 100644 --- a/docs/scripts/hooks.py +++ b/docs/scripts/hooks.py @@ -17,6 +17,7 @@ def on_pre_build(config, **kwargs) -> None: result_files_path = "benchmark/results/" + result_file_names = [ f for f in os.listdir(result_files_path) @@ -52,23 +53,23 @@ def preprocess_results_for_frontend( path (str): The path to the result files. file_name (str): The file name of the result file. """ - raw_results["score_possible"] = raw_results["score"].apply( - lambda x: float(x.split("/")[1]) + raw_results["score_possible"] = raw_results.apply( + lambda x: float(x["score"].split("/")[1]) * x["iterations"], axis=1 ) raw_results["scores"] = raw_results["score"].apply( lambda x: x.split("/")[0] ) raw_results["score_achieved"] = raw_results["scores"].apply( - lambda x: np.mean(float(x.split(";")[0])) if ";" in x else float(x) + lambda x: np.sum([float(score) for score in x.split(";")]) if ";" in x else float(x) ) raw_results["score_sd"] = raw_results["scores"].apply( - lambda x: np.std(float(x.split(";")[0])) if ";" in x else 0 + lambda x: np.std([float(score) for score in x.split(";")], ddof=1) if ";" in x else 0 ) aggregated_scores = raw_results.groupby(["model_name"]).agg( { "score_possible": "sum", "score_achieved": "sum", - "score_sd": "first", + "score_sd": "sum", "iterations": "first", } ) @@ -116,23 +117,23 @@ def write_individual_extraction_task_results(raw_results: pd.DataFrame) -> None: raw_results["subtask"] = raw_results["subtask"].apply( lambda x: x.split(":")[1] ) - raw_results["score_possible"] = raw_results["score"].apply( - lambda x: float(x.split("/")[1]) + raw_results["score_possible"] = raw_results.apply( + lambda x: float(x["score"].split("/")[1]) * x["iterations"], axis=1 ) raw_results["scores"] = raw_results["score"].apply( lambda x: x.split("/")[0] ) raw_results["score_achieved"] = raw_results["scores"].apply( - lambda x: np.mean(float(x.split(";")[0])) if ";" in x else float(x) + lambda x: np.sum([float(score) for score in x.split(";")]) if ";" in x else float(x) ) raw_results["score_sd"] = raw_results["scores"].apply( - lambda x: np.std(float(x.split(";")[0])) if ";" in x else 0 + lambda x: np.std([float(score) for score in x.split(";")], ddof=1) if ";" in x else 0 ) aggregated_scores = raw_results.groupby(["model_name", "subtask"]).agg( { "score_possible": "sum", "score_achieved": "sum", - "score_sd": "first", + "score_sd": "mean", "iterations": "first", } ) @@ -662,6 +663,26 @@ def plot_extraction_tasks(): sourcedata_info_extraction["score_sd"] = sourcedata_info_extraction[ "scores" ].apply(lambda x: np.std(float(x.split(";")[0])) if ";" in x else 0) + raw_results["score_possible"] = raw_results.apply( + lambda x: float(x["score"].split("/")[1]) * x["iterations"], axis=1 + ) + raw_results["scores"] = raw_results["score"].apply( + lambda x: x.split("/")[0] + ) + raw_results["score_achieved"] = raw_results["scores"].apply( + lambda x: np.sum([float(score) for score in x.split(";")]) if ";" in x else float(x) + ) + raw_results["score_sd"] = raw_results["scores"].apply( + lambda x: np.std([float(score) for score in x.split(";")], ddof=1) if ";" in x else 0 + ) + aggregated_scores = raw_results.groupby(["model_name"]).agg( + { + "score_possible": "sum", + "score_achieved": "sum", + "score_sd": "mean", + "iterations": "first", + } + ) aggregated_scores = sourcedata_info_extraction.groupby( ["model_name", "subtask"] ).agg(