nbs/API/effsize_objects.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Effectsize objects\n",
    "\n",
    "> The auxiliary classes involved in the computations of bootstrapped effect sizes.\n",
    "\n",
    "- order: 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| default_exp _effsize_objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| hide\n",
    "from __future__ import annotations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| hide\n",
    "from nbdev.showdoc import *\n",
    "import nbdev\n",
    "nbdev.nbdev_export()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| hide\n",
    "import dabest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "import pandas as pd\n",
    "import lqrt\n",
    "from scipy.stats import norm\n",
    "from numpy import array, isnan, isinf, repeat, random, isin, abs, var\n",
    "from numpy import sort as npsort\n",
    "from numpy import nan as npnan\n",
    "from numpy.random import PCG64, RandomState\n",
    "from statsmodels.stats.contingency_tables import mcnemar\n",
    "import warnings\n",
    "from string import Template\n",
    "import scipy.stats as spstats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "class TwoGroupsEffectSize(object):\n",
    "\n",
    "    \"\"\"\n",
    "    A class to compute and store the results of bootstrapped\n",
    "    mean differences between two groups.\n",
    "\n",
    "    Compute the effect size between two groups.\n",
    "\n",
    "        Parameters\n",
    "        ----------\n",
    "        control : array-like\n",
    "        test : array-like\n",
    "            These should be numerical iterables.\n",
    "        effect_size : string.\n",
    "            Any one of the following are accepted inputs:\n",
    "            'mean_diff', 'median_diff', 'cohens_d', 'hedges_g', or 'cliffs_delta'\n",
    "        is_paired : string, default None\n",
    "        resamples : int, default 5000\n",
    "            The number of bootstrap resamples to be taken for the calculation\n",
    "            of the confidence interval limits.\n",
    "        permutation_count : int, default 5000\n",
    "            The number of permutations (reshuffles) to perform for the\n",
    "            computation of the permutation p-value\n",
    "        ci : float, default 95\n",
    "            The confidence interval width. The default of 95 produces 95%\n",
    "            confidence intervals.\n",
    "        random_seed : int, default 12345\n",
    "            `random_seed` is used to seed the random number generator during\n",
    "            bootstrap resampling. This ensures that the confidence intervals\n",
    "            reported are replicable.\n",
    "\n",
    "        Returns\n",
    "        -------\n",
    "        A :py:class:`TwoGroupEffectSize` object:\n",
    "            `difference` : float\n",
    "                The effect size of the difference between the control and the test.\n",
    "            `effect_size` : string\n",
    "                The type of effect size reported.\n",
    "            `is_paired` : string\n",
    "                The type of repeated-measures experiment.\n",
    "            `ci` : float\n",
    "                Returns the width of the confidence interval, in percent.\n",
    "            `alpha` : float\n",
    "                Returns the significance level of the statistical test as a float between 0 and 1.\n",
    "            `resamples` : int\n",
    "                The number of resamples performed during the bootstrap procedure.\n",
    "            `bootstraps` : numpy ndarray\n",
    "                The generated bootstraps of the effect size.\n",
    "            `random_seed` : int\n",
    "                The number used to initialise the numpy random seed generator, ie.`seed_value` from `numpy.random.seed(seed_value)` is returned.\n",
    "            `bca_low, bca_high` : float\n",
    "                The bias-corrected and accelerated confidence interval lower limit and upper limits, respectively.\n",
    "            `pct_low, pct_high` : float\n",
    "                The percentile confidence interval lower limit and upper limits, respectively.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self,\n",
    "        control,\n",
    "        test,\n",
    "        effect_size,\n",
    "        proportional=False,\n",
    "        is_paired=None,\n",
    "        ci=95,\n",
    "        resamples=5000,\n",
    "        permutation_count=5000,\n",
    "        random_seed=12345,\n",
    "    ):\n",
    "        from ._stats_tools import confint_2group_diff as ci2g\n",
    "        from ._stats_tools import effsize as es\n",
    "\n",
    "        self.__EFFECT_SIZE_DICT = {\n",
    "            \"mean_diff\": \"mean difference\",\n",
    "            \"median_diff\": \"median difference\",\n",
    "            \"cohens_d\": \"Cohen's d\",\n",
    "            \"cohens_h\": \"Cohen's h\",\n",
    "            \"hedges_g\": \"Hedges' g\",\n",
    "            \"cliffs_delta\": \"Cliff's delta\",\n",
    "            \"delta_g\": \"deltas' g\",\n",
    "        }\n",
    "\n",
    "        self.__is_paired = is_paired\n",
    "        self.__resamples = resamples\n",
    "        self.__effect_size = effect_size\n",
    "        self.__random_seed = random_seed\n",
    "        self.__ci = ci\n",
    "        self.__proportional = proportional\n",
    "        self._check_errors(control, test)\n",
    "\n",
    "        # Convert to numpy arrays for speed.\n",
    "        # NaNs are automatically dropped.\n",
    "        control = array(control)\n",
    "        test = array(test)\n",
    "        self.__control = control[~isnan(control)]\n",
    "        self.__test = test[~isnan(test)]\n",
    "        self.__permutation_count = permutation_count\n",
    "\n",
    "        self.__alpha = ci2g._compute_alpha_from_ci(self.__ci)\n",
    "\n",
    "        self.__difference = es.two_group_difference(\n",
    "            self.__control, self.__test, self.__is_paired, self.__effect_size\n",
    "        )\n",
    "\n",
    "        self.__jackknives = ci2g.compute_meandiff_jackknife(\n",
    "            self.__control, self.__test, self.__is_paired, self.__effect_size\n",
    "        )\n",
    "\n",
    "        self.__acceleration_value = ci2g._calc_accel(self.__jackknives)\n",
    "\n",
    "        bootstraps = ci2g.compute_bootstrapped_diff(\n",
    "            self.__control,\n",
    "            self.__test,\n",
    "            self.__is_paired,\n",
    "            self.__effect_size,\n",
    "            self.__resamples,\n",
    "            self.__random_seed,\n",
    "        )\n",
    "        self.__bootstraps = bootstraps\n",
    "\n",
    "        sorted_bootstraps = npsort(self.__bootstraps)\n",
    "        # Added in v0.2.6.\n",
    "        # Raises a UserWarning if there are any infiinities in the bootstraps.\n",
    "        num_infinities = len(self.__bootstraps[isinf(self.__bootstraps)])\n",
    "\n",
    "        if num_infinities > 0:\n",
    "            warn_msg = (\n",
    "                \"There are {} bootstrap(s) that are not defined. \"\n",
    "                \"This is likely due to smaple sample sizes. \"\n",
    "                \"The values in a bootstrap for a group will be more likely \"\n",
    "                \"to be all equal, with a resulting variance of zero. \"\n",
    "                \"The computation of Cohen's d and Hedges' g thus \"\n",
    "                \"involved a division by zero. \"\n",
    "            )\n",
    "            warnings.warn(warn_msg.format(num_infinities), category=UserWarning)\n",
    "\n",
    "        self.__bias_correction = ci2g.compute_meandiff_bias_correction(\n",
    "            self.__bootstraps, self.__difference\n",
    "        )\n",
    "\n",
    "        self._compute_bca_intervals(sorted_bootstraps)\n",
    "\n",
    "        # Compute percentile intervals.\n",
    "        pct_idx_low = int((self.__alpha / 2) * self.__resamples)\n",
    "        pct_idx_high = int((1 - (self.__alpha / 2)) * self.__resamples)\n",
    "\n",
    "        self.__pct_interval_idx = (pct_idx_low, pct_idx_high)\n",
    "        self.__pct_low = sorted_bootstraps[pct_idx_low]\n",
    "        self.__pct_high = sorted_bootstraps[pct_idx_high]\n",
    "\n",
    "        self._perform_statistical_test()\n",
    "\n",
    "    def __repr__(self, show_resample_count=True, define_pval=True, sigfig=3):\n",
    "        RM_STATUS = {\n",
    "            \"baseline\": \"for repeated measures against baseline \\n\",\n",
    "            \"sequential\": \"for the sequential design of repeated-measures experiment \\n\",\n",
    "            \"None\": \"\",\n",
    "        }\n",
    "\n",
    "        PAIRED_STATUS = {\n",
    "            \"baseline\": \"paired\",\n",
    "            \"sequential\": \"paired\",\n",
    "            \"None\": \"unpaired\",\n",
    "        }\n",
    "\n",
    "        first_line = {\n",
    "            \"rm_status\": RM_STATUS[str(self.__is_paired)],\n",
    "            \"es\": self.__EFFECT_SIZE_DICT[self.__effect_size],\n",
    "            \"paired_status\": PAIRED_STATUS[str(self.__is_paired)],\n",
    "        }\n",
    "\n",
    "        out1 = \"The {paired_status} {es} {rm_status}\".format(**first_line)\n",
    "\n",
    "        base_string_fmt = \"{:.\" + str(sigfig) + \"}\"\n",
    "        if \".\" in str(self.__ci):\n",
    "            ci_width = base_string_fmt.format(self.__ci)\n",
    "        else:\n",
    "            ci_width = str(self.__ci)\n",
    "\n",
    "        ci_out = {\n",
    "            \"es\": base_string_fmt.format(self.__difference),\n",
    "            \"ci\": ci_width,\n",
    "            \"bca_low\": base_string_fmt.format(self.__bca_low),\n",
    "            \"bca_high\": base_string_fmt.format(self.__bca_high),\n",
    "        }\n",
    "\n",
    "        out2 = \"is {es} [{ci}%CI {bca_low}, {bca_high}].\".format(**ci_out)\n",
    "        out = out1 + out2\n",
    "\n",
    "        pval_rounded = base_string_fmt.format(self.pvalue_permutation)\n",
    "\n",
    "        p1 = \"The p-value of the two-sided permutation t-test is {}, \".format(\n",
    "            pval_rounded\n",
    "        )\n",
    "        p2 = \"calculated for legacy purposes only. \"\n",
    "        pvalue = p1 + p2\n",
    "\n",
    "        bs1 = \"{} bootstrap samples were taken; \".format(self.__resamples)\n",
    "        bs2 = \"the confidence interval is bias-corrected and accelerated.\"\n",
    "        bs = bs1 + bs2\n",
    "\n",
    "        pval_def1 = (\n",
    "            \"Any p-value reported is the probability of observing the\"\n",
    "            + \"effect size (or greater),\\nassuming the null hypothesis of \"\n",
    "            + \"zero difference is true.\"\n",
    "        )\n",
    "        pval_def2 = (\n",
    "            \"\\nFor each p-value, 5000 reshuffles of the \"\n",
    "            + \"control and test labels were performed.\"\n",
    "        )\n",
    "        pval_def = pval_def1 + pval_def2\n",
    "\n",
    "        if show_resample_count and define_pval:\n",
    "            return \"{}\\n{}\\n\\n{}\\n{}\".format(out, pvalue, bs, pval_def)\n",
    "        elif not show_resample_count and define_pval:\n",
    "            return \"{}\\n{}\\n\\n{}\".format(out, pvalue, pval_def)\n",
    "        elif show_resample_count and ~define_pval:\n",
    "            return \"{}\\n{}\\n\\n{}\".format(out, pvalue, bs)\n",
    "        else:\n",
    "            return \"{}\\n{}\".format(out, pvalue)\n",
    "\n",
    "    def _check_errors(self, control, test):\n",
    "        '''\n",
    "        Function to check configuration errors for the given control and test data.\n",
    "        '''\n",
    "        kosher_es = [a for a in self.__EFFECT_SIZE_DICT.keys()]\n",
    "        if self.__effect_size not in kosher_es:\n",
    "            err1 = \"The effect size '{}'\".format(self.__effect_size)\n",
    "            err2 = \"is not one of {}\".format(kosher_es)\n",
    "            raise ValueError(\" \".join([err1, err2]))\n",
    "\n",
    "        if self.__effect_size == \"cliffs_delta\" and self.__is_paired:\n",
    "            err1 = \"`paired` is not None; therefore Cliff's delta is not defined.\"\n",
    "            raise ValueError(err1)\n",
    "\n",
    "        if self.__proportional and self.__effect_size not in [\"mean_diff\", \"cohens_h\"]:\n",
    "            err1 = \"`proportional` is True; therefore effect size other than mean_diff and cohens_h is not defined.\"\n",
    "            raise ValueError(err1)\n",
    "\n",
    "        if self.__proportional and (\n",
    "            isin(control, [0, 1]).all() == False or isin(test, [0, 1]).all() == False\n",
    "        ):\n",
    "            err1 = (\n",
    "                \"`proportional` is True; Only accept binary data consisting of 0 and 1.\"\n",
    "            )\n",
    "            raise ValueError(err1)\n",
    "\n",
    "    def _compute_bca_intervals(self, sorted_bootstraps):\n",
    "        '''\n",
    "        Function to compute the bca intervals given the sorted bootstraps.\n",
    "        '''\n",
    "        from ._stats_tools import confint_2group_diff as ci2g\n",
    "\n",
    "        # Compute BCa intervals.\n",
    "        bca_idx_low, bca_idx_high = ci2g.compute_interval_limits(\n",
    "            self.__bias_correction,\n",
    "            self.__acceleration_value,\n",
    "            self.__resamples,\n",
    "            self.__ci,\n",
    "        )\n",
    "\n",
    "        self.__bca_interval_idx = (bca_idx_low, bca_idx_high)\n",
    "\n",
    "        if ~isnan(bca_idx_low) and ~isnan(bca_idx_high):\n",
    "            self.__bca_low = sorted_bootstraps[bca_idx_low]\n",
    "            self.__bca_high = sorted_bootstraps[bca_idx_high]\n",
    "\n",
    "            err1 = \"The $lim_type limit of the interval\"\n",
    "            err2 = \"was in the $loc 10 values.\"\n",
    "            err3 = \"The result should be considered unstable.\"\n",
    "            err_temp = Template(\" \".join([err1, err2, err3]))\n",
    "\n",
    "            if bca_idx_low <= 10:\n",
    "                warnings.warn(\n",
    "                    err_temp.substitute(lim_type=\"lower\", loc=\"bottom\"), stacklevel=1\n",
    "                )\n",
    "\n",
    "            if bca_idx_high >= self.__resamples - 9:\n",
    "                warnings.warn(\n",
    "                    err_temp.substitute(lim_type=\"upper\", loc=\"top\"), stacklevel=1\n",
    "                )\n",
    "\n",
    "        else:\n",
    "            err1 = \"The $lim_type limit of the BCa interval cannot be computed.\"\n",
    "            err2 = \"It is set to the effect size itself.\"\n",
    "            err3 = \"All bootstrap values were likely all the same.\"\n",
    "            err_temp = Template(\" \".join([err1, err2, err3]))\n",
    "\n",
    "            if isnan(bca_idx_low):\n",
    "                self.__bca_low = self.__difference\n",
    "                warnings.warn(err_temp.substitute(lim_type=\"lower\"), stacklevel=0)\n",
    "\n",
    "            if isnan(bca_idx_high):\n",
    "                self.__bca_high = self.__difference\n",
    "                warnings.warn(err_temp.substitute(lim_type=\"upper\"), stacklevel=0)\n",
    "\n",
    "    def _perform_statistical_test(self):\n",
    "        '''\n",
    "        Function to complete the statistical tests\n",
    "        '''\n",
    "        from ._stats_tools import effsize as es\n",
    "\n",
    "        # Perform statistical tests.\n",
    "        self.__PermutationTest_result = PermutationTest(\n",
    "            self.__control,\n",
    "            self.__test,\n",
    "            self.__effect_size,\n",
    "            self.__is_paired,\n",
    "            self.__permutation_count,\n",
    "        )\n",
    "\n",
    "        if self.__is_paired and not self.__proportional:\n",
    "            # Wilcoxon, a non-parametric version of the paired T-test.\n",
    "            try:\n",
    "                wilcoxon = spstats.wilcoxon(self.__control, self.__test)\n",
    "                self.__pvalue_wilcoxon = wilcoxon.pvalue\n",
    "                self.__statistic_wilcoxon = wilcoxon.statistic\n",
    "            except ValueError as e:\n",
    "                warnings.warn(\"Wilcoxon test could not be performed. This might be due \"\n",
    "                    \"to no variability in the difference of the paired groups. \\n\"\n",
    "                    \"Error: {}\\n\"\n",
    "                    \"For detailed information, please refer to https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.wilcoxon.html \"\n",
    "                    .format(e))\n",
    "\n",
    "            if self.__effect_size != \"median_diff\":\n",
    "                # Paired Student's t-test.\n",
    "                paired_t = spstats.ttest_rel(\n",
    "                    self.__control, self.__test, nan_policy=\"omit\"\n",
    "                )\n",
    "                self.__pvalue_paired_students_t = paired_t.pvalue\n",
    "                self.__statistic_paired_students_t = paired_t.statistic\n",
    "\n",
    "        elif self.__is_paired and self.__proportional:\n",
    "            # for binary paired data, use McNemar's test\n",
    "            # References:\n",
    "            # https://en.wikipedia.org/wiki/McNemar%27s_test\n",
    "\n",
    "            df_temp = pd.DataFrame({\"control\": self.__control, \"test\": self.__test})\n",
    "            x1 = len(df_temp[(df_temp[\"control\"] == 0) & (df_temp[\"test\"] == 0)])\n",
    "            x2 = len(df_temp[(df_temp[\"control\"] == 0) & (df_temp[\"test\"] == 1)])\n",
    "            x3 = len(df_temp[(df_temp[\"control\"] == 1) & (df_temp[\"test\"] == 0)])\n",
    "            x4 = len(df_temp[(df_temp[\"control\"] == 1) & (df_temp[\"test\"] == 1)])\n",
    "            table = [[x1, x2], [x3, x4]]\n",
    "            _mcnemar = mcnemar(table, exact=True, correction=True)\n",
    "            self.__pvalue_mcnemar = _mcnemar.pvalue\n",
    "            self.__statistic_mcnemar = _mcnemar.statistic\n",
    "\n",
    "        elif self.__proportional:\n",
    "            # The Cohen's h calculation is for binary categorical data\n",
    "            try:\n",
    "                self.__proportional_difference = es.cohens_h(\n",
    "                    self.__control, self.__test\n",
    "                )\n",
    "            except ValueError as e:\n",
    "                warnings.warn(f\"Calculation of Cohen's h failed. This method is applicable \"\n",
    "                  f\"only for binary data (0's and 1's). Details: {e}\")\n",
    "\n",
    "        elif self.__effect_size == \"cliffs_delta\":\n",
    "            # Let's go with Brunner-Munzel!\n",
    "            brunner_munzel = spstats.brunnermunzel(\n",
    "                self.__control, self.__test, nan_policy=\"omit\"\n",
    "            )\n",
    "            self.__pvalue_brunner_munzel = brunner_munzel.pvalue\n",
    "            self.__statistic_brunner_munzel = brunner_munzel.statistic\n",
    "\n",
    "        elif self.__effect_size == \"median_diff\":\n",
    "            # According to scipy's documentation of the function,\n",
    "            # \"The Kruskal-Wallis H-test tests the null hypothesis\n",
    "            # that the population median of all of the groups are equal.\"\n",
    "            kruskal = spstats.kruskal(self.__control, self.__test, nan_policy=\"omit\")\n",
    "            self.__pvalue_kruskal = kruskal.pvalue\n",
    "            self.__statistic_kruskal = kruskal.statistic\n",
    "\n",
    "        else:  # for mean difference, Cohen's d, and Hedges' g.\n",
    "            # Welch's t-test, assumes normality of distributions,\n",
    "            # but does not assume equal variances.\n",
    "            welch = spstats.ttest_ind(\n",
    "                self.__control, self.__test, equal_var=False, nan_policy=\"omit\"\n",
    "            )\n",
    "            self.__pvalue_welch = welch.pvalue\n",
    "            self.__statistic_welch = welch.statistic\n",
    "\n",
    "            # Student's t-test, assumes normality of distributions,\n",
    "            # as well as assumption of equal variances.\n",
    "            students_t = spstats.ttest_ind(\n",
    "                self.__control, self.__test, equal_var=True, nan_policy=\"omit\"\n",
    "            )\n",
    "            self.__pvalue_students_t = students_t.pvalue\n",
    "            self.__statistic_students_t = students_t.statistic\n",
    "\n",
    "            # Mann-Whitney test: Non parametric,\n",
    "            # does not assume normality of distributions\n",
    "            try:\n",
    "                mann_whitney = spstats.mannwhitneyu(\n",
    "                    self.__control, self.__test, alternative=\"two-sided\"\n",
    "                )\n",
    "                self.__pvalue_mann_whitney = mann_whitney.pvalue\n",
    "                self.__statistic_mann_whitney = mann_whitney.statistic\n",
    "            except ValueError as e:\n",
    "                warnings.warn(\"Mann-Whitney test could not be performed. This might be due \"\n",
    "                  \"to identical rank values in both control and test groups. \"\n",
    "                  \"Details: {}\".format(e))\n",
    "\n",
    "            standardized_es = es.cohens_d(self.__control, self.__test, is_paired=None)\n",
    "\n",
    "\n",
    "    def to_dict(self):\n",
    "        \"\"\"\n",
    "        Returns the attributes of the `dabest.TwoGroupEffectSize` object as a\n",
    "        dictionary.\n",
    "        \"\"\"\n",
    "        # Only get public (user-facing) attributes.\n",
    "        attrs = [a for a in dir(self) if not a.startswith((\"_\", \"to_dict\"))]\n",
    "        out = {}\n",
    "        for a in attrs:\n",
    "            out[a] = getattr(self, a)\n",
    "        return out\n",
    "\n",
    "    @property\n",
    "    def difference(self):\n",
    "        \"\"\"\n",
    "        Returns the difference between the control and the test.\n",
    "        \"\"\"\n",
    "        return self.__difference\n",
    "\n",
    "    @property\n",
    "    def effect_size(self):\n",
    "        \"\"\"\n",
    "        Returns the type of effect size reported.\n",
    "        \"\"\"\n",
    "        return self.__EFFECT_SIZE_DICT[self.__effect_size]\n",
    "\n",
    "    @property\n",
    "    def is_paired(self):\n",
    "        return self.__is_paired\n",
    "\n",
    "    @property\n",
    "    def proportional(self):\n",
    "        return self.__proportional\n",
    "\n",
    "    @property\n",
    "    def ci(self):\n",
    "        \"\"\"\n",
    "        Returns the width of the confidence interval, in percent.\n",
    "        \"\"\"\n",
    "        return self.__ci\n",
    "\n",
    "    @property\n",
    "    def alpha(self):\n",
    "        \"\"\"\n",
    "        Returns the significance level of the statistical test as a float\n",
    "        between 0 and 1.\n",
    "        \"\"\"\n",
    "        return self.__alpha\n",
    "\n",
    "    @property\n",
    "    def resamples(self):\n",
    "        \"\"\"\n",
    "        The number of resamples performed during the bootstrap procedure.\n",
    "        \"\"\"\n",
    "        return self.__resamples\n",
    "\n",
    "    @property\n",
    "    def bootstraps(self):\n",
    "        \"\"\"\n",
    "        The generated bootstraps of the effect size.\n",
    "        \"\"\"\n",
    "        return self.__bootstraps\n",
    "\n",
    "    @property\n",
    "    def random_seed(self):\n",
    "        \"\"\"\n",
    "        The number used to initialise the numpy random seed generator, ie.\n",
    "        `seed_value` from `numpy.random.seed(seed_value)` is returned.\n",
    "        \"\"\"\n",
    "        return self.__random_seed\n",
    "\n",
    "    @property\n",
    "    def bca_interval_idx(self):\n",
    "        return self.__bca_interval_idx\n",
    "\n",
    "    @property\n",
    "    def bca_low(self):\n",
    "        \"\"\"\n",
    "        The bias-corrected and accelerated confidence interval lower limit.\n",
    "        \"\"\"\n",
    "        return self.__bca_low\n",
    "\n",
    "    @property\n",
    "    def bca_high(self):\n",
    "        \"\"\"\n",
    "        The bias-corrected and accelerated confidence interval upper limit.\n",
    "        \"\"\"\n",
    "        return self.__bca_high\n",
    "\n",
    "    @property\n",
    "    def pct_interval_idx(self):\n",
    "        return self.__pct_interval_idx\n",
    "\n",
    "    @property\n",
    "    def pct_low(self):\n",
    "        \"\"\"\n",
    "        The percentile confidence interval lower limit.\n",
    "        \"\"\"\n",
    "        return self.__pct_low\n",
    "\n",
    "    @property\n",
    "    def pct_high(self):\n",
    "        \"\"\"\n",
    "        The percentile confidence interval lower limit.\n",
    "        \"\"\"\n",
    "        return self.__pct_high\n",
    "\n",
    "    @property\n",
    "    def pvalue_brunner_munzel(self):\n",
    "        try:\n",
    "            return self.__pvalue_brunner_munzel\n",
    "        except AttributeError:\n",
    "            return npnan\n",
    "\n",
    "    @property\n",
    "    def statistic_brunner_munzel(self):\n",
    "        try:\n",
    "            return self.__statistic_brunner_munzel\n",
    "        except AttributeError:\n",
    "            return npnan\n",
    "\n",
    "    @property\n",
    "    def pvalue_wilcoxon(self):\n",
    "        try:\n",
    "            return self.__pvalue_wilcoxon\n",
    "        except AttributeError:\n",
    "            return npnan\n",
    "\n",
    "    @property\n",
    "    def statistic_wilcoxon(self):\n",
    "        try:\n",
    "            return self.__statistic_wilcoxon\n",
    "        except AttributeError:\n",
    "            return npnan\n",
    "\n",
    "    @property\n",
    "    def pvalue_mcnemar(self):\n",
    "        try:\n",
    "            return self.__pvalue_mcnemar\n",
    "        except AttributeError:\n",
    "            return npnan\n",
    "\n",
    "    @property\n",
    "    def statistic_mcnemar(self):\n",
    "        try:\n",
    "            return self.__statistic_mcnemar\n",
    "        except AttributeError:\n",
    "            return npnan\n",
    "\n",
    "    @property\n",
    "    def pvalue_paired_students_t(self):\n",
    "        try:\n",
    "            return self.__pvalue_paired_students_t\n",
    "        except AttributeError:\n",
    "            return npnan\n",
    "\n",
    "    @property\n",
    "    def statistic_paired_students_t(self):\n",
    "        try:\n",
    "            return self.__statistic_paired_students_t\n",
    "        except AttributeError:\n",
    "            return npnan\n",
    "\n",
    "    @property\n",
    "    def pvalue_kruskal(self):\n",
    "        try:\n",
    "            return self.__pvalue_kruskal\n",
    "        except AttributeError:\n",
    "            return npnan\n",
    "\n",
    "    @property\n",
    "    def statistic_kruskal(self):\n",
    "        try:\n",
    "            return self.__statistic_kruskal\n",
    "        except AttributeError:\n",
    "            return npnan\n",
    "\n",
    "    @property\n",
    "    def pvalue_welch(self):\n",
    "        try:\n",
    "            return self.__pvalue_welch\n",
    "        except AttributeError:\n",
    "            return npnan\n",
    "\n",
    "    @property\n",
    "    def statistic_welch(self):\n",
    "        try:\n",
    "            return self.__statistic_welch\n",
    "        except AttributeError:\n",
    "            return npnan\n",
    "\n",
    "    @property\n",
    "    def pvalue_students_t(self):\n",
    "        try:\n",
    "            return self.__pvalue_students_t\n",
    "        except AttributeError:\n",
    "            return npnan\n",
    "\n",
    "    @property\n",
    "    def statistic_students_t(self):\n",
    "        try:\n",
    "            return self.__statistic_students_t\n",
    "        except AttributeError:\n",
    "            return npnan\n",
    "\n",
    "    @property\n",
    "    def pvalue_mann_whitney(self):\n",
    "        try:\n",
    "            return self.__pvalue_mann_whitney\n",
    "        except AttributeError:\n",
    "            return npnan\n",
    "\n",
    "    @property\n",
    "    def statistic_mann_whitney(self):\n",
    "        try:\n",
    "            return self.__statistic_mann_whitney\n",
    "        except AttributeError:\n",
    "            return npnan\n",
    "\n",
    "    @property\n",
    "    def pvalue_permutation(self):\n",
    "        \"\"\"\n",
    "        p value of permutation test\n",
    "        \"\"\"\n",
    "        return self.__PermutationTest_result.pvalue\n",
    "\n",
    "    @property\n",
    "    def permutation_count(self):\n",
    "        \"\"\"\n",
    "        The number of permutations taken.\n",
    "        \"\"\"\n",
    "        return self.__PermutationTest_result.permutation_count\n",
    "\n",
    "    @property\n",
    "    def permutations(self):\n",
    "        return self.__PermutationTest_result.permutations\n",
    "\n",
    "    @property\n",
    "    def permutations_var(self):\n",
    "        return self.__PermutationTest_result.permutations_var\n",
    "\n",
    "    @property\n",
    "    def proportional_difference(self):\n",
    "        try:\n",
    "            return self.__proportional_difference\n",
    "        except AttributeError:\n",
    "            return npnan"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "The unpaired mean difference is -0.253 [95%CI -0.78, 0.25].\n",
       "The p-value of the two-sided permutation t-test is 0.348, calculated for legacy purposes only. \n",
       "\n",
       "5000 bootstrap samples were taken; the confidence interval is bias-corrected and accelerated.\n",
       "Any p-value reported is the probability of observing theeffect size (or greater),\n",
       "assuming the null hypothesis ofzero difference is true.\n",
       "For each p-value, 5000 reshuffles of the control and test labels were performed."
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "random.seed(12345)\n",
    "control = norm.rvs(loc=0, size=30)\n",
    "test = norm.rvs(loc=0.5, size=30)\n",
    "effsize = dabest.TwoGroupsEffectSize(control, test, \"mean_diff\")\n",
    "effsize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'alpha': 0.05,\n",
       " 'bca_high': 0.24951887238295106,\n",
       " 'bca_interval_idx': (125, 4875),\n",
       " 'bca_low': -0.7801782111071534,\n",
       " 'bootstraps': array([-0.3649424 , -0.45018155, -0.56034412, ..., -0.49805581,\n",
       "        -0.25334475, -0.55206229]),\n",
       " 'ci': 95,\n",
       " 'difference': -0.25315417702752846,\n",
       " 'effect_size': 'mean difference',\n",
       " 'is_paired': None,\n",
       " 'pct_high': 0.24951887238295106,\n",
       " 'pct_interval_idx': (125, 4875),\n",
       " 'pct_low': -0.7801782111071534,\n",
       " 'permutation_count': 5000,\n",
       " 'permutations': array([ 0.17221029,  0.03112419, -0.13911387, ..., -0.38007941,\n",
       "         0.30261507, -0.09073054]),\n",
       " 'permutations_var': array([0.07201642, 0.07251104, 0.07219407, ..., 0.07003705, 0.07094885,\n",
       "        0.07238581]),\n",
       " 'proportional_difference': nan,\n",
       " 'pvalue_brunner_munzel': nan,\n",
       " 'pvalue_kruskal': nan,\n",
       " 'pvalue_mann_whitney': 0.5201446121616038,\n",
       " 'pvalue_mcnemar': nan,\n",
       " 'pvalue_paired_students_t': nan,\n",
       " 'pvalue_permutation': 0.3484,\n",
       " 'pvalue_students_t': 0.34743913903372836,\n",
       " 'pvalue_welch': 0.3474493875548964,\n",
       " 'pvalue_wilcoxon': nan,\n",
       " 'random_seed': 12345,\n",
       " 'resamples': 5000,\n",
       " 'statistic_brunner_munzel': nan,\n",
       " 'statistic_kruskal': nan,\n",
       " 'statistic_mann_whitney': 494.0,\n",
       " 'statistic_mcnemar': nan,\n",
       " 'statistic_paired_students_t': nan,\n",
       " 'statistic_students_t': 0.9472545159069105,\n",
       " 'statistic_welch': 0.9472545159069105,\n",
       " 'statistic_wilcoxon': nan}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "effsize.to_dict() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# | export\n",
    "class EffectSizeDataFrame(object):\n",
    "    \"\"\"A class that generates and stores the results of bootstrapped effect\n",
    "    sizes for several comparisons.\"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self,\n",
    "        dabest,\n",
    "        effect_size,\n",
    "        is_paired,\n",
    "        ci=95,\n",
    "        proportional=False,\n",
    "        resamples=5000,\n",
    "        permutation_count=5000,\n",
    "        random_seed=12345,\n",
    "        x1_level=None,\n",
    "        x2=None,\n",
    "        delta2=False,\n",
    "        experiment_label=None,\n",
    "        mini_meta=False,\n",
    "    ):\n",
    "        \"\"\"\n",
    "        Parses the data from a Dabest object, enabling plotting and printing\n",
    "        capability for the effect size of interest.\n",
    "        \"\"\"\n",
    "\n",
    "        self.__dabest_obj = dabest\n",
    "        self.__effect_size = effect_size\n",
    "        self.__is_paired = is_paired\n",
    "        self.__ci = ci\n",
    "        self.__resamples = resamples\n",
    "        self.__permutation_count = permutation_count\n",
    "        self.__random_seed = random_seed\n",
    "        self.__proportional = proportional\n",
    "        self.__x1_level = x1_level\n",
    "        self.__experiment_label = experiment_label\n",
    "        self.__x2 = x2\n",
    "        self.__delta2 = delta2\n",
    "        self.__mini_meta = mini_meta\n",
    "\n",
    "    def __pre_calc(self):\n",
    "        from .misc_tools import print_greeting, get_varname\n",
    "        from ._stats_tools import confint_2group_diff as ci2g\n",
    "        from ._delta_objects import MiniMetaDelta, DeltaDelta\n",
    "\n",
    "        idx = self.__dabest_obj.idx\n",
    "        dat = self.__dabest_obj._plot_data\n",
    "        xvar = self.__dabest_obj._xvar\n",
    "        yvar = self.__dabest_obj._yvar\n",
    "\n",
    "        out = []\n",
    "        reprs = []\n",
    "\n",
    "        if self.__delta2:\n",
    "            mixed_data = []\n",
    "            for j, current_tuple in enumerate(idx):\n",
    "                if self.__is_paired != \"sequential\":\n",
    "                    cname = current_tuple[0]\n",
    "                    control = dat[dat[xvar] == cname][yvar].copy()\n",
    "\n",
    "                for ix, tname in enumerate(current_tuple[1:]):\n",
    "                    if self.__is_paired == \"sequential\":\n",
    "                        cname = current_tuple[ix]\n",
    "                        control = dat[dat[xvar] == cname][yvar].copy()\n",
    "                    test = dat[dat[xvar] == tname][yvar].copy()\n",
    "                    mixed_data.append(control)\n",
    "                    mixed_data.append(test)\n",
    "            bootstraps_delta_delta = ci2g.compute_delta2_bootstrapped_diff(\n",
    "                mixed_data[0],\n",
    "                mixed_data[1],\n",
    "                mixed_data[2],\n",
    "                mixed_data[3],\n",
    "                self.__is_paired,\n",
    "                self.__resamples,\n",
    "                self.__random_seed,\n",
    "            )\n",
    "\n",
    "        for j, current_tuple in enumerate(idx):\n",
    "            if self.__is_paired != \"sequential\":\n",
    "                cname = current_tuple[0]\n",
    "                control = dat[dat[xvar] == cname][yvar].copy()\n",
    "\n",
    "            for ix, tname in enumerate(current_tuple[1:]):\n",
    "                if self.__is_paired == \"sequential\":\n",
    "                    cname = current_tuple[ix]\n",
    "                    control = dat[dat[xvar] == cname][yvar].copy()\n",
    "                test = dat[dat[xvar] == tname][yvar].copy()\n",
    "\n",
    "                result = TwoGroupsEffectSize(\n",
    "                    control,\n",
    "                    test,\n",
    "                    self.__effect_size,\n",
    "                    self.__proportional,\n",
    "                    self.__is_paired,\n",
    "                    self.__ci,\n",
    "                    self.__resamples,\n",
    "                    self.__permutation_count,\n",
    "                    self.__random_seed,\n",
    "                )\n",
    "                r_dict = result.to_dict()\n",
    "                r_dict[\"control\"] = cname\n",
    "                r_dict[\"test\"] = tname\n",
    "                r_dict[\"control_N\"] = int(len(control))\n",
    "                r_dict[\"test_N\"] = int(len(test))\n",
    "                out.append(r_dict)\n",
    "                if j == len(idx) - 1 and ix == len(current_tuple) - 2:\n",
    "                    if self.__delta2 and self.__effect_size in [\"mean_diff\", \"delta_g\"]:\n",
    "                        resamp_count = False\n",
    "                        def_pval = False\n",
    "                    elif self.__mini_meta and self.__effect_size == \"mean_diff\":\n",
    "                        resamp_count = False\n",
    "                        def_pval = False\n",
    "                    else:\n",
    "                        resamp_count = True\n",
    "                        def_pval = True\n",
    "                else:\n",
    "                    resamp_count = False\n",
    "                    def_pval = False\n",
    "\n",
    "                text_repr = result.__repr__(\n",
    "                    show_resample_count=resamp_count, define_pval=def_pval\n",
    "                )\n",
    "\n",
    "                to_replace = \"between {} and {} is\".format(cname, tname)\n",
    "                text_repr = text_repr.replace(\"is\", to_replace, 1)\n",
    "\n",
    "                reprs.append(text_repr)\n",
    "\n",
    "        self.__for_print = \"\\n\\n\".join(reprs)\n",
    "\n",
    "        out_ = pd.DataFrame(out)\n",
    "\n",
    "        columns_in_order = [\n",
    "            \"control\",\n",
    "            \"test\",\n",
    "            \"control_N\",\n",
    "            \"test_N\",\n",
    "            \"effect_size\",\n",
    "            \"is_paired\",\n",
    "            \"difference\",\n",
    "            \"ci\",\n",
    "            \"bca_low\",\n",
    "            \"bca_high\",\n",
    "            \"bca_interval_idx\",\n",
    "            \"pct_low\",\n",
    "            \"pct_high\",\n",
    "            \"pct_interval_idx\",\n",
    "            \"bootstraps\",\n",
    "            \"resamples\",\n",
    "            \"random_seed\",\n",
    "            \"permutations\",\n",
    "            \"pvalue_permutation\",\n",
    "            \"permutation_count\",\n",
    "            \"permutations_var\",\n",
    "            \"pvalue_welch\",\n",
    "            \"statistic_welch\",\n",
    "            \"pvalue_students_t\",\n",
    "            \"statistic_students_t\",\n",
    "            \"pvalue_mann_whitney\",\n",
    "            \"statistic_mann_whitney\",\n",
    "            \"pvalue_brunner_munzel\",\n",
    "            \"statistic_brunner_munzel\",\n",
    "            \"pvalue_wilcoxon\",\n",
    "            \"statistic_wilcoxon\",\n",
    "            \"pvalue_mcnemar\",\n",
    "            \"statistic_mcnemar\",\n",
    "            \"pvalue_paired_students_t\",\n",
    "            \"statistic_paired_students_t\",\n",
    "            \"pvalue_kruskal\",\n",
    "            \"statistic_kruskal\",\n",
    "            \"proportional_difference\",\n",
    "        ]\n",
    "        self.__results = out_.reindex(columns=columns_in_order)\n",
    "        self.__results.dropna(axis=\"columns\", how=\"all\", inplace=True)\n",
    "\n",
    "        # Add the is_paired column back when is_paired is None\n",
    "        if self.is_paired is None:\n",
    "            self.__results.insert(\n",
    "                5, \"is_paired\", self.__results.apply(lambda _: None, axis=1)\n",
    "            )\n",
    "\n",
    "        # Create and compute the delta-delta statistics\n",
    "        if self.__delta2:\n",
    "            self.__delta_delta = DeltaDelta(\n",
    "                self, self.__permutation_count, bootstraps_delta_delta, self.__ci\n",
    "            )\n",
    "            reprs.append(self.__delta_delta.__repr__(header=False))\n",
    "        elif self.__delta2 and self.__effect_size not in [\"mean_diff\", \"delta_g\"]:\n",
    "            self.__delta_delta = \"Delta-delta is not supported for {}.\".format(\n",
    "                self.__effect_size\n",
    "            )\n",
    "        else:\n",
    "            self.__delta_delta = (\n",
    "                \"`delta2` is False; delta-delta is therefore not calculated.\"\n",
    "            )\n",
    "\n",
    "        # Create and compute the weighted average statistics\n",
    "        if self.__mini_meta and self.__effect_size == \"mean_diff\":\n",
    "            self.__mini_meta_delta = MiniMetaDelta(\n",
    "                self, self.__permutation_count, self.__ci\n",
    "            )\n",
    "            reprs.append(self.__mini_meta_delta.__repr__(header=False))\n",
    "        elif self.__mini_meta and self.__effect_size != \"mean_diff\":\n",
    "            self.__mini_meta_delta = \"Weighted delta is not supported for {}.\".format(\n",
    "                self.__effect_size\n",
    "            )\n",
    "        else:\n",
    "            self.__mini_meta_delta = (\n",
    "                \"`mini_meta` is False; weighted delta is therefore not calculated.\"\n",
    "            )\n",
    "\n",
    "        varname = get_varname(self.__dabest_obj)\n",
    "        lastline = (\n",
    "            \"To get the results of all valid statistical tests, \"\n",
    "            + \"use `{}.{}.statistical_tests`\".format(varname, self.__effect_size)\n",
    "        )\n",
    "        reprs.append(lastline)\n",
    "\n",
    "        reprs.insert(0, print_greeting())\n",
    "\n",
    "        self.__for_print = \"\\n\\n\".join(reprs)\n",
    "\n",
    "    def __repr__(self):\n",
    "        try:\n",
    "            return self.__for_print\n",
    "        except AttributeError:\n",
    "            self.__pre_calc()\n",
    "            return self.__for_print\n",
    "\n",
    "    def __calc_lqrt(self):\n",
    "        rnd_seed = self.__random_seed\n",
    "        db_obj = self.__dabest_obj\n",
    "        dat = db_obj._plot_data\n",
    "        xvar = db_obj._xvar\n",
    "        yvar = db_obj._yvar\n",
    "        delta2 = self.__delta2\n",
    "\n",
    "        out = []\n",
    "\n",
    "        for j, current_tuple in enumerate(db_obj.idx):\n",
    "            if self.__is_paired != \"sequential\":\n",
    "                cname = current_tuple[0]\n",
    "                control = dat[dat[xvar] == cname][yvar].copy()\n",
    "\n",
    "            for ix, tname in enumerate(current_tuple[1:]):\n",
    "                if self.__is_paired == \"sequential\":\n",
    "                    cname = current_tuple[ix]\n",
    "                    control = dat[dat[xvar] == cname][yvar].copy()\n",
    "                test = dat[dat[xvar] == tname][yvar].copy()\n",
    "\n",
    "                if self.__is_paired:\n",
    "                    # Refactored here in v0.3.0 for performance issues.\n",
    "                    lqrt_result = lqrt.lqrtest_rel(control, test, random_state=rnd_seed)\n",
    "\n",
    "                    out.append(\n",
    "                        {\n",
    "                            \"control\": cname,\n",
    "                            \"test\": tname,\n",
    "                            \"control_N\": int(len(control)),\n",
    "                            \"test_N\": int(len(test)),\n",
    "                            \"pvalue_paired_lqrt\": lqrt_result.pvalue,\n",
    "                            \"statistic_paired_lqrt\": lqrt_result.statistic,\n",
    "                        }\n",
    "                    )\n",
    "\n",
    "                else:\n",
    "                    # Likelihood Q-Ratio test:\n",
    "                    lqrt_equal_var_result = lqrt.lqrtest_ind(\n",
    "                        control, test, random_state=rnd_seed, equal_var=True\n",
    "                    )\n",
    "\n",
    "                    lqrt_unequal_var_result = lqrt.lqrtest_ind(\n",
    "                        control, test, random_state=rnd_seed, equal_var=False\n",
    "                    )\n",
    "\n",
    "                    out.append(\n",
    "                        {\n",
    "                            \"control\": cname,\n",
    "                            \"test\": tname,\n",
    "                            \"control_N\": int(len(control)),\n",
    "                            \"test_N\": int(len(test)),\n",
    "                            \"pvalue_lqrt_equal_var\": lqrt_equal_var_result.pvalue,\n",
    "                            \"statistic_lqrt_equal_var\": lqrt_equal_var_result.statistic,\n",
    "                            \"pvalue_lqrt_unequal_var\": lqrt_unequal_var_result.pvalue,\n",
    "                            \"statistic_lqrt_unequal_var\": lqrt_unequal_var_result.statistic,\n",
    "                        }\n",
    "                    )\n",
    "        self.__lqrt_results = pd.DataFrame(out)\n",
    "\n",
    "    def plot(\n",
    "        self,\n",
    "        color_col=None,\n",
    "        raw_marker_size=6,\n",
    "        es_marker_size=9,\n",
    "        swarm_label=None,\n",
    "        contrast_label=None,\n",
    "        delta2_label=None,\n",
    "        swarm_ylim=None,\n",
    "        contrast_ylim=None,\n",
    "        delta2_ylim=None,\n",
    "        swarm_side=None,\n",
    "        custom_palette=None,\n",
    "        swarm_desat=0.5,\n",
    "        halfviolin_desat=1,\n",
    "        halfviolin_alpha=0.8,\n",
    "        face_color=None,\n",
    "        # bar plot\n",
    "        bar_label=None,\n",
    "        bar_desat=0.5,\n",
    "        bar_width=0.5,\n",
    "        bar_ylim=None,\n",
    "        # error bar of proportion plot\n",
    "        ci=None,\n",
    "        ci_type=\"bca\",\n",
    "        err_color=None,\n",
    "        float_contrast=True,\n",
    "        show_pairs=True,\n",
    "        show_delta2=True,\n",
    "        show_mini_meta=True,\n",
    "        group_summaries=None,\n",
    "        group_summaries_offset=0.1,\n",
    "        fig_size=None,\n",
    "        dpi=100,\n",
    "        ax=None,\n",
    "        contrast_show_es=False,\n",
    "        es_sf=2,\n",
    "        es_fontsize=10,\n",
    "        contrast_show_deltas=True,\n",
    "        gridkey_rows=None,\n",
    "        gridkey_merge_pairs=False,\n",
    "        gridkey_show_Ns=True,\n",
    "        gridkey_show_es=True,\n",
    "        swarmplot_kwargs=None,\n",
    "        barplot_kwargs=None,\n",
    "        violinplot_kwargs=None,\n",
    "        slopegraph_kwargs=None,\n",
    "        sankey_kwargs=None,\n",
    "        reflines_kwargs=None,\n",
    "        group_summary_kwargs=None,\n",
    "        legend_kwargs=None,\n",
    "        title=None,\n",
    "        fontsize_title=16,\n",
    "        fontsize_rawxlabel=12,\n",
    "        fontsize_rawylabel=12,\n",
    "        fontsize_contrastxlabel=12,\n",
    "        fontsize_contrastylabel=12,\n",
    "        fontsize_delta2label=12,\n",
    "        #### Contrast bars WIP  ####\n",
    "        contrast_bars=True,\n",
    "        swarm_bars=True,\n",
    "        contrast_bars_kwargs=None,\n",
    "        swarm_bars_kwargs=None,\n",
    "        summary_bars=None,\n",
    "        summary_bars_kwargs=None,\n",
    "    ):\n",
    "        \"\"\"\n",
    "        Creates an estimation plot for the effect size of interest.\n",
    "\n",
    "\n",
    "        Parameters\n",
    "        ----------\n",
    "        color_col : string, default None\n",
    "            Column to be used for colors.\n",
    "        raw_marker_size : float, default 6\n",
    "            The diameter (in points) of the marker dots plotted in the\n",
    "            swarmplot.\n",
    "        es_marker_size : float, default 9\n",
    "            The size (in points) of the effect size points on the difference\n",
    "            axes.\n",
    "        swarm_label, contrast_label, delta2_label : strings, default None\n",
    "            Set labels for the y-axis of the swarmplot and the contrast plot,\n",
    "            respectively. If `swarm_label` is not specified, it defaults to\n",
    "            \"value\", unless a column name was passed to `y`. If\n",
    "            `contrast_label` is not specified, it defaults to the effect size\n",
    "            being plotted. If `delta2_label` is not specifed, it defaults to\n",
    "            \"delta - delta\"\n",
    "        swarm_ylim, contrast_ylim, delta2_ylim : tuples, default None\n",
    "            The desired y-limits of the raw data (swarmplot) axes, the\n",
    "            difference axes and the delta-delta axes respectively, as a tuple.\n",
    "            These will be autoscaled to sensible values if they are not\n",
    "            specified. The delta2 axes and contrast axes should have the same\n",
    "            limits for y. When `show_delta2` is True, if both of the `contrast_ylim`\n",
    "            and `delta2_ylim` are not None, then they must be specified with the\n",
    "            same values; when `show_delta2` is True and only one of them is specified,\n",
    "            then the other will automatically be assigned with the same value.\n",
    "            Specifying `delta2_ylim` does not have any effect when `show_delta2` is\n",
    "            False.\n",
    "        custom_palette : dict, list, or matplotlib color palette, default None\n",
    "            This keyword accepts a dictionary with {'group':'color'} pairings,\n",
    "            a list of RGB colors, or a specified matplotlib palette. This\n",
    "            palette will be used to color the swarmplot. If `color_col` is not\n",
    "            specified, then each group will be colored in sequence according\n",
    "            to the default palette currently used by matplotlib.\n",
    "            Please take a look at the seaborn commands `color_palette`\n",
    "            and `cubehelix_palette` to generate a custom palette. Both\n",
    "            these functions generate a list of RGB colors.\n",
    "            See:\n",
    "            https://seaborn.pydata.org/generated/seaborn.color_palette.html\n",
    "            https://seaborn.pydata.org/generated/seaborn.cubehelix_palette.html\n",
    "            The named colors of matplotlib can be found here:\n",
    "            https://matplotlib.org/examples/color/named_colors.html\n",
    "        swarm_desat : float, default 1\n",
    "            Decreases the saturation of the colors in the swarmplot by the\n",
    "            desired proportion. Uses `seaborn.desaturate()` to acheive this.\n",
    "        halfviolin_desat : float, default 0.5\n",
    "            Decreases the saturation of the colors of the half-violin bootstrap\n",
    "            curves by the desired proportion. Uses `seaborn.desaturate()` to\n",
    "            acheive this.\n",
    "        halfviolin_alpha : float, default 0.8\n",
    "            The alpha (transparency) level of the half-violin bootstrap curves.\n",
    "        float_contrast : boolean, default True\n",
    "            Whether or not to display the halfviolin bootstrapped difference\n",
    "            distribution alongside the raw data.\n",
    "        show_pairs : boolean, default True\n",
    "            If the data is paired, whether or not to show the raw data as a\n",
    "            swarmplot, or as slopegraph, with a line joining each pair of\n",
    "            observations.\n",
    "        show_delta2, show_mini_meta : boolean, default True\n",
    "            If delta-delta or mini-meta delta is calculated, whether or not to\n",
    "            show the delta-delta plot or mini-meta plot.\n",
    "        group_summaries : ['mean_sd', 'median_quartiles', 'None'], default None.\n",
    "            Plots the summary statistics for each group. If 'mean_sd', then\n",
    "            the mean and standard deviation of each group is plotted as a\n",
    "            notched line beside each group. If 'median_quantiles', then the\n",
    "            median and 25th and 75th percentiles of each group is plotted\n",
    "            instead. If 'None', the summaries are not shown.\n",
    "        group_summaries_offset : float, default 0.1\n",
    "            If group summaries are displayed, they will be offset from the raw\n",
    "            data swarmplot groups by this value.\n",
    "        fig_size : tuple, default None\n",
    "            The desired dimensions of the figure as a (length, width) tuple.\n",
    "        dpi : int, default 100\n",
    "            The dots per inch of the resulting figure.\n",
    "        ax : matplotlib.Axes, default None\n",
    "            Provide an existing Axes for the plots to be created. If no Axes is\n",
    "            specified, a new matplotlib Figure will be created.\n",
    "        gridkey_rows : list, default None\n",
    "            Provide a list of row labels for the gridkey. The supplied idx is\n",
    "            checked against the row labels to determine whether the corresponding\n",
    "            cell should be populated or not.\n",
    "        swarmplot_kwargs : dict, default None\n",
    "            Pass any keyword arguments accepted by the seaborn `swarmplot`\n",
    "            command here, as a dict. If None, the following keywords are\n",
    "            passed to sns.swarmplot : {'size':`raw_marker_size`}.\n",
    "        violinplot_kwargs : dict, default None\n",
    "            Pass any keyword arguments accepted by the matplotlib `\n",
    "            pyplot.violinplot` command here, as a dict. If None, the following\n",
    "            keywords are passed to violinplot : {'widths':0.5, 'vert':True,\n",
    "            'showextrema':False, 'showmedians':False}.\n",
    "        slopegraph_kwargs : dict, default None\n",
    "            This will change the appearance of the lines used to join each pair\n",
    "            of observations when `show_pairs=True`. Pass any keyword arguments\n",
    "            accepted by matplotlib `plot()` function here, as a dict.\n",
    "            If None, the following keywords are\n",
    "            passed to plot() : {'linewidth':1, 'alpha':0.5}.\n",
    "        sankey_kwargs: dict, default None\n",
    "            Whis will change the appearance of the sankey diagram used to depict\n",
    "            paired proportional data when `show_pairs=True` and `proportional=True`.\n",
    "            Pass any keyword arguments accepted by plot_tools.sankeydiag() function\n",
    "            here, as a dict. If None, the following keywords are passed to sankey diagram:\n",
    "            {\"width\": 0.5, \"align\": \"center\", \"alpha\": 0.4, \"bar_width\": 0.1, \"rightColor\": False}\n",
    "        reflines_kwargs : dict, default None\n",
    "            This will change the appearance of the zero reference lines. Pass\n",
    "            any keyword arguments accepted by the matplotlib Axes `hlines`\n",
    "            command here, as a dict. If None, the following keywords are\n",
    "            passed to Axes.hlines : {'linestyle':'solid', 'linewidth':0.75,\n",
    "            'zorder':2, 'color' : default y-tick color}.\n",
    "        group_summary_kwargs : dict, default None\n",
    "            Pass any keyword arguments accepted by the matplotlib.lines.Line2D\n",
    "            command here, as a dict. This will change the appearance of the\n",
    "            vertical summary lines for each group, if `group_summaries` is not\n",
    "            'None'. If None, the following keywords are passed to\n",
    "            matplotlib.lines.Line2D : {'lw':2, 'alpha':1, 'zorder':3}.\n",
    "        legend_kwargs : dict, default None\n",
    "            Pass any keyword arguments accepted by the matplotlib Axes\n",
    "            `legend` command here, as a dict. If None, the following keywords\n",
    "            are passed to matplotlib.Axes.legend : {'loc':'upper left',\n",
    "            'frameon':False}.\n",
    "        title : string, default None\n",
    "            Title for the plot. If None, no title will be displayed. Pass any\n",
    "            keyword arguments accepted by the matplotlib.pyplot.suptitle `t` command here,\n",
    "            as a string.\n",
    "        fontsize_title : float or {'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large', 'xx-large'}, default 'large'\n",
    "            Font size for the plot title. If a float, the fontsize in points. The\n",
    "            string values denote sizes relative to the default font size. Pass any keyword arguments accepted\n",
    "            by the matplotlib.pyplot.suptitle `fontsize` command here, as a string.\n",
    "        fontsize_rawxlabel : float, default 12\n",
    "            Font size for the raw axes xlabel.\n",
    "        fontsize_rawylabel : float, default 12\n",
    "            Font size for the raw axes ylabel.\n",
    "        fontsize_contrastxlabel : float, default 12\n",
    "            Font size for the contrast axes xlabel.\n",
    "        fontsize_contrastylabel : float, default 12\n",
    "            Font size for the contrast axes ylabel.\n",
    "        fontsize_delta2label : float, default 12\n",
    "            Font size for the delta-delta axes ylabel.\n",
    "            \n",
    "            \n",
    "        contrast_bars : boolean, default True\n",
    "            Whether or not to display the contrast bars.\n",
    "        swarm_bars : boolean, default True\n",
    "            Whether or not to display the swarm bars.\n",
    "        contrast_bars_kwargs : dict, default None\n",
    "            Pass relevant keyword arguments to the contrast bars. Pass any keyword arguments accepted by \n",
    "            matplotlib.patches.Rectangle here, as a string. If None, the following keywords are passed:\n",
    "            {\"color\": None, \"alpha\": 0.15}\n",
    "        swarm_bars_kwargs : dict, default None\n",
    "            Pass relevant keyword arguments to the swarm bars. Pass any keyword arguments accepted by \n",
    "            matplotlib.patches.Rectangle here, as a string. If None, the following keywords are passed:\n",
    "            {\"color\": None, \"alpha\": 0.1}\n",
    "\n",
    "        summary_bars : list, default None\n",
    "            Pass a list of indices of the contrast objects to have summary bars displayed on the plot.\n",
    "            For example, [0,1] will show summary bars for the first two contrast objects.\n",
    "        summary_bars_kwargs: dict, default None\n",
    "            If None, the following keywords are passed: {\"color\": None, \"alpha\": 0.15}\n",
    "\n",
    "        Returns\n",
    "        -------\n",
    "        A :class:`matplotlib.figure.Figure` with 2 Axes, if ``ax = None``.\n",
    "\n",
    "        The first axes (accessible with ``FigName.axes[0]``) contains the rawdata swarmplot; the second axes (accessible with ``FigName.axes[1]``) has the bootstrap distributions and effect sizes (with confidence intervals) plotted on it.\n",
    "\n",
    "        If ``ax`` is specified, the rawdata swarmplot is accessed at ``ax``\n",
    "        itself, while the effect size axes is accessed at ``ax.contrast_axes``.\n",
    "        See the last example below.\n",
    "\n",
    "\n",
    "\n",
    "        \"\"\"\n",
    "\n",
    "        from .plotter import effectsize_df_plotter\n",
    "\n",
    "        if hasattr(self, \"results\") is False:\n",
    "            self.__pre_calc()\n",
    "\n",
    "        if self.__delta2:\n",
    "            color_col = self.__x2\n",
    "\n",
    "        # if self.__proportional:\n",
    "        #     raw_marker_size = 0.01\n",
    "\n",
    "        # Modification incurred due to update of Seaborn\n",
    "        ci = (\"ci\", ci) if ci is not None else None\n",
    "\n",
    "        all_kwargs = locals()\n",
    "        del all_kwargs[\"self\"]\n",
    "\n",
    "        out = effectsize_df_plotter(self, **all_kwargs)\n",
    "\n",
    "        return out\n",
    "\n",
    "    @property\n",
    "    def proportional(self):\n",
    "        \"\"\"\n",
    "        Returns the proportional parameter\n",
    "        class.\n",
    "        \"\"\"\n",
    "        return self.__proportional\n",
    "\n",
    "    @property\n",
    "    def results(self):\n",
    "        \"\"\"Prints all pairwise comparisons nicely.\"\"\"\n",
    "        try:\n",
    "            return self.__results\n",
    "        except AttributeError:\n",
    "            self.__pre_calc()\n",
    "            return self.__results\n",
    "\n",
    "    @property\n",
    "    def statistical_tests(self):\n",
    "        results_df = self.results\n",
    "\n",
    "        # Select only the statistics and p-values.\n",
    "        stats_columns = [\n",
    "            c\n",
    "            for c in results_df.columns\n",
    "            if c.startswith(\"statistic\") or c.startswith(\"pvalue\")\n",
    "        ]\n",
    "\n",
    "        default_cols = [\n",
    "            \"control\",\n",
    "            \"test\",\n",
    "            \"control_N\",\n",
    "            \"test_N\",\n",
    "            \"effect_size\",\n",
    "            \"is_paired\",\n",
    "            \"difference\",\n",
    "            \"ci\",\n",
    "            \"bca_low\",\n",
    "            \"bca_high\",\n",
    "        ]\n",
    "\n",
    "        cols_of_interest = default_cols + stats_columns\n",
    "\n",
    "        return results_df[cols_of_interest]\n",
    "\n",
    "    @property\n",
    "    def _for_print(self):\n",
    "        return self.__for_print\n",
    "\n",
    "    @property\n",
    "    def _plot_data(self):\n",
    "        return self.__dabest_obj._plot_data\n",
    "\n",
    "    @property\n",
    "    def idx(self):\n",
    "        return self.__dabest_obj.idx\n",
    "\n",
    "    @property\n",
    "    def xvar(self):\n",
    "        return self.__dabest_obj._xvar\n",
    "\n",
    "    @property\n",
    "    def yvar(self):\n",
    "        return self.__dabest_obj._yvar\n",
    "\n",
    "    @property\n",
    "    def is_paired(self):\n",
    "        return self.__is_paired\n",
    "\n",
    "    @property\n",
    "    def ci(self):\n",
    "        \"\"\"\n",
    "        The width of the confidence interval being produced, in percent.\n",
    "        \"\"\"\n",
    "        return self.__ci\n",
    "\n",
    "    @property\n",
    "    def x1_level(self):\n",
    "        return self.__x1_level\n",
    "\n",
    "    @property\n",
    "    def x2(self):\n",
    "        return self.__x2\n",
    "\n",
    "    @property\n",
    "    def experiment_label(self):\n",
    "        return self.__experiment_label\n",
    "\n",
    "    @property\n",
    "    def delta2(self):\n",
    "        return self.__delta2\n",
    "\n",
    "    @property\n",
    "    def resamples(self):\n",
    "        \"\"\"\n",
    "        The number of resamples (with replacement) during bootstrap resampling.\"\n",
    "        \"\"\"\n",
    "        return self.__resamples\n",
    "\n",
    "    @property\n",
    "    def random_seed(self):\n",
    "        \"\"\"\n",
    "        The seed used by `numpy.seed()` for bootstrap resampling.\n",
    "        \"\"\"\n",
    "        return self.__random_seed\n",
    "\n",
    "    @property\n",
    "    def effect_size(self):\n",
    "        \"\"\"The type of effect size being computed.\"\"\"\n",
    "        return self.__effect_size\n",
    "\n",
    "    @property\n",
    "    def dabest_obj(self):\n",
    "        \"\"\"\n",
    "        Returns the `dabest` object that invoked the current EffectSizeDataFrame\n",
    "        class.\n",
    "        \"\"\"\n",
    "        return self.__dabest_obj\n",
    "\n",
    "    @property\n",
    "    def proportional(self):\n",
    "        \"\"\"\n",
    "        Returns the proportional parameter\n",
    "        class.\n",
    "        \"\"\"\n",
    "        return self.__proportional\n",
    "\n",
    "    @property\n",
    "    def lqrt(self):\n",
    "        \"\"\"Returns all pairwise Lq-Likelihood Ratio Type test results\n",
    "        as a pandas DataFrame.\n",
    "\n",
    "        For more information on LqRT tests, see https://arxiv.org/abs/1911.11922\n",
    "        \"\"\"\n",
    "        try:\n",
    "            return self.__lqrt_results\n",
    "        except AttributeError:\n",
    "            self.__calc_lqrt()\n",
    "            return self.__lqrt_results\n",
    "\n",
    "    @property\n",
    "    def mini_meta(self):\n",
    "        \"\"\"\n",
    "        Returns the mini_meta boolean parameter.\n",
    "        \"\"\"\n",
    "        return self.__mini_meta\n",
    "\n",
    "    @property\n",
    "    def mini_meta_delta(self):\n",
    "        \"\"\"\n",
    "        Returns the mini_meta results.\n",
    "        \"\"\"\n",
    "        try:\n",
    "            return self.__mini_meta_delta\n",
    "        except AttributeError:\n",
    "            self.__pre_calc()\n",
    "            return self.__mini_meta_delta\n",
    "\n",
    "    @property\n",
    "    def delta_delta(self):\n",
    "        \"\"\"\n",
    "        Returns the mini_meta results.\n",
    "        \"\"\"\n",
    "        try:\n",
    "            return self.__delta_delta\n",
    "        except AttributeError:\n",
    "            self.__pre_calc()\n",
    "            return self.__delta_delta"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Example: plot\n",
    "\n",
    "Create a Gardner-Altman estimation plot for the mean difference."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "random.seed(9999) # Fix the seed so the results are replicable.\n",
    "# pop_size = 10000 # Size of each population.\n",
    "Ns = 20 # The number of samples taken from each population\n",
    "\n",
    "# Create samples\n",
    "c1 = norm.rvs(loc=3, scale=0.4, size=Ns)\n",
    "c2 = norm.rvs(loc=3.5, scale=0.75, size=Ns)\n",
    "c3 = norm.rvs(loc=3.25, scale=0.4, size=Ns)\n",
    "\n",
    "t1 = norm.rvs(loc=3.5, scale=0.5, size=Ns)\n",
    "t2 = norm.rvs(loc=2.5, scale=0.6, size=Ns)\n",
    "t3 = norm.rvs(loc=3, scale=0.75, size=Ns)\n",
    "t4 = norm.rvs(loc=3.5, scale=0.75, size=Ns)\n",
    "t5 = norm.rvs(loc=3.25, scale=0.4, size=Ns)\n",
    "t6 = norm.rvs(loc=3.25, scale=0.4, size=Ns)\n",
    "\n",
    "\n",
    "# Add a `gender` column for coloring the data.\n",
    "females = repeat('Female', Ns/2).tolist()\n",
    "males = repeat('Male', Ns/2).tolist()\n",
    "gender = females + males\n",
    "\n",
    "# Add an `id` column for paired data plotting.\n",
    "id_col = pd.Series(range(1, Ns+1))\n",
    "\n",
    "# Combine samples and gender into a DataFrame.\n",
    "df = pd.DataFrame({'Control 1' : c1,     'Test 1' : t1,\n",
    "                 'Control 2' : c2,     'Test 2' : t2,\n",
    "                 'Control 3' : c3,     'Test 3' : t3,\n",
    "                 'Test 4'    : t4,     'Test 5' : t5, 'Test 6' : t6,\n",
    "                 'Gender'    : gender, 'ID'  : id_col\n",
    "                })\n",
    "my_data = dabest.load(df, idx=(\"Control 1\", \"Test 1\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig1 = my_data.mean_diff.plot();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " Create a Gardner-Altman plot for the Hedges' g effect size."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig2 = my_data.hedges_g.plot();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a Cumming estimation plot for the mean difference."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig3 = my_data.mean_diff.plot(float_contrast=True);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " Create a paired Gardner-Altman plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_data_paired = dabest.load(df, idx=(\"Control 1\", \"Test 1\"),\n",
    "                       id_col = \"ID\", paired='baseline')\n",
    "fig4 = my_data_paired.mean_diff.plot();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a multi-group Cumming plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_multi_groups = dabest.load(df, id_col = \"ID\", \n",
    "                             idx=((\"Control 1\", \"Test 1\"),\n",
    "                                 (\"Control 2\", \"Test 2\")))\n",
    "fig5 = my_multi_groups.mean_diff.plot();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a shared control Cumming plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_shared_control = dabest.load(df, id_col = \"ID\",\n",
    "                                 idx=(\"Control 1\", \"Test 1\",\n",
    "                                          \"Test 2\", \"Test 3\"))\n",
    "fig6 = my_shared_control.mean_diff.plot();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a repeated meausures (against baseline) Slopeplot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_rm_baseline = dabest.load(df, id_col = \"ID\", paired = \"baseline\",\n",
    "                                 idx=(\"Control 1\", \"Test 1\",\n",
    "                                          \"Test 2\", \"Test 3\"))\n",
    "fig7 = my_rm_baseline.mean_diff.plot();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a repeated meausures (sequential) Slopeplot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_rm_sequential = dabest.load(df, id_col = \"ID\", paired = \"sequential\",\n",
    "                                 idx=(\"Control 1\", \"Test 1\",\n",
    "                                          \"Test 2\", \"Test 3\"))\n",
    "fig8 = my_rm_sequential.mean_diff.plot();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "class PermutationTest:\n",
    "    \"\"\"\n",
    "    A class to compute and report permutation tests.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    control : array-like\n",
    "    test : array-like\n",
    "        These should be numerical iterables.\n",
    "    effect_size : string.\n",
    "        Any one of the following are accepted inputs:\n",
    "        'mean_diff', 'median_diff', 'cohens_d', 'hedges_g', 'delta_g\" or 'cliffs_delta'\n",
    "    is_paired : string, default None\n",
    "    permutation_count : int, default 10000\n",
    "        The number of permutations (reshuffles) to perform.\n",
    "    random_seed : int, default 12345\n",
    "        `random_seed` is used to seed the random number generator during\n",
    "        bootstrap resampling. This ensures that the generated permutations\n",
    "        are replicable.\n",
    "        \n",
    "    Returns\n",
    "    -------\n",
    "    A :py:class:`PermutationTest` object:\n",
    "        `difference`:float\n",
    "            The effect size of the difference between the control and the test.\n",
    "        `effect_size`:string\n",
    "            The type of effect size reported.\n",
    "    \n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, control: array,\n",
    "                 test: array, # These should be numerical iterables.\n",
    "                 effect_size:str, # Any one of the following are accepted inputs: 'mean_diff', 'median_diff', 'cohens_d', 'hedges_g', or 'cliffs_delta'\n",
    "                 is_paired:str=None,\n",
    "                 permutation_count:int=5000, # The number of permutations (reshuffles) to perform.\n",
    "                 random_seed:int=12345,#`random_seed` is used to seed the random number generator during bootstrap resampling. This ensures that the generated permutations are replicable.\n",
    "                 **kwargs):\n",
    "        from ._stats_tools.effsize import two_group_difference\n",
    "        from ._stats_tools.confint_2group_diff import calculate_group_var\n",
    "        \n",
    "\n",
    "        self.__permutation_count = permutation_count\n",
    "\n",
    "        # Run Sanity Check.\n",
    "        if is_paired and len(control) != len(test):\n",
    "            raise ValueError(\"The two arrays do not have the same length.\")\n",
    "\n",
    "        # Initialise random number generator.\n",
    "        # rng = random.default_rng(seed=random_seed)\n",
    "        rng = RandomState(PCG64(random_seed))\n",
    "\n",
    "        # Set required constants and variables\n",
    "        control = array(control)\n",
    "        test = array(test)\n",
    "\n",
    "        control_sample = control.copy()\n",
    "        test_sample    = test.copy()\n",
    "\n",
    "        BAG = array([*control, *test])\n",
    "        CONTROL_LEN = int(len(control))\n",
    "        EXTREME_COUNT = 0.\n",
    "        THRESHOLD = abs(two_group_difference(control, test, \n",
    "                                                is_paired, effect_size))\n",
    "        self.__permutations = []\n",
    "        self.__permutations_var = []\n",
    "\n",
    "        for i in range(int(self.__permutation_count)):\n",
    "            if is_paired:\n",
    "                # Select which control-test pairs to swap.\n",
    "                random_idx = rng.choice(CONTROL_LEN,\n",
    "                                rng.randint(0, CONTROL_LEN+1),\n",
    "                                replace=False)\n",
    "\n",
    "                # Perform swap.\n",
    "                for i in random_idx:\n",
    "                    _placeholder      = control_sample[i]\n",
    "                    control_sample[i] = test_sample[i]\n",
    "                    test_sample[i]    = _placeholder\n",
    "                \n",
    "            else:\n",
    "                # Shuffle the bag and assign to control and test groups.\n",
    "                # NB. rng.shuffle didn't produce replicable results...\n",
    "                shuffled = rng.permutation(BAG) \n",
    "                control_sample = shuffled[:CONTROL_LEN]\n",
    "                test_sample    = shuffled[CONTROL_LEN:]\n",
    "\n",
    "\n",
    "            es = two_group_difference(control_sample, test_sample, \n",
    "                                    False, effect_size)\n",
    "            \n",
    "            group_var = calculate_group_var(var(control_sample, ddof=1), \n",
    "                                      CONTROL_LEN, \n",
    "                                      var(test_sample, ddof=1), \n",
    "                                      len(test_sample))\n",
    "            self.__permutations.append(es)\n",
    "            self.__permutations_var.append(group_var)\n",
    "\n",
    "            if abs(es) > THRESHOLD:\n",
    "                EXTREME_COUNT += 1.\n",
    "\n",
    "        self.__permutations = array(self.__permutations)\n",
    "        self.__permutations_var = array(self.__permutations_var)\n",
    "\n",
    "        self.pvalue = EXTREME_COUNT / self.__permutation_count\n",
    "\n",
    "\n",
    "    def __repr__(self):\n",
    "        return(\"{} permutations were taken. The p-value is {}.\".format(self.__permutation_count, \n",
    "                                                                      self.pvalue))\n",
    "\n",
    "\n",
    "    @property\n",
    "    def permutation_count(self):\n",
    "        \"\"\"\n",
    "        The number of permuations taken.\n",
    "        \"\"\"\n",
    "        return self.__permutation_count\n",
    "\n",
    "\n",
    "    @property\n",
    "    def permutations(self):\n",
    "        \"\"\"\n",
    "        The effect sizes of all the permutations in a list.\n",
    "        \"\"\"\n",
    "        return self.__permutations\n",
    "\n",
    "    \n",
    "    @property\n",
    "    def permutations_var(self):\n",
    "        \"\"\"\n",
    "        The experiment group variance of all the permutations in a list.\n",
    "        \"\"\"\n",
    "        return self.__permutations_var\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Notes**:\n",
    "    \n",
    "The basic concept of permutation tests is the same as that behind bootstrapping.\n",
    "In an \"exact\" permutation test, all possible resuffles of the control and test \n",
    "labels are performed, and the proportion of effect sizes that equal or exceed \n",
    "the observed effect size is computed. This is the probability, under the null \n",
    "hypothesis of zero difference between test and control groups, of observing the\n",
    "effect size: the p-value of the Student's t-test.\n",
    "\n",
    "Exact permutation tests are impractical: computing the effect sizes for all reshuffles quickly exceeds trivial computational loads. A control group and a test group both with 10 observations each would have a total of  $20!$ or $2.43 \\times {10}^{18}$ reshuffles.\n",
    "Therefore, in practice, \"approximate\" permutation tests are performed, where a sufficient number of reshuffles are performed (5,000 or 10,000), from which the p-value is computed.\n",
    "\n",
    "More information can be found [here](https://en.wikipedia.org/wiki/Resampling_(statistics)#Permutation_tests).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Example: permutation test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "control = norm.rvs(loc=0, size=30, random_state=12345)\n",
    "test = norm.rvs(loc=0.5, size=30, random_state=12345)\n",
    "perm_test = dabest.PermutationTest(control, test, \n",
    "                                   effect_size=\"mean_diff\", \n",
    "                                   is_paired=None)\n",
    "perm_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "DABESTDEV",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python",
   "version": "3.11.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}