Merge branch 'db/update_selection' into 'master'

        See :meth:`BayesResults.compute_best_params` for arguments.

        """

        if superset:

            pr_in_target = self.rank_df[n_best_params:].sum(axis=0)

            fp_proba = self.rank_df[:n_best_params].sum(axis=0)

        else:

            pr_in_target = self.rank_df[:n_best_params].sum(axis=0)

            fp_proba = self.rank_df[n_best_params:].sum(axis=0)

        fp_rate, selected = 0, []

        while fp_rate < alpha and len(selected) < self.model.n_params:

            selected.append(pr_in_target.argmax())

            fp_rate = (

                (len(selected) - 1) * fp_rate + 1 - pr_in_target[selected[-1]]

            ) / len(selected)

            pr_in_target[selected[-1]] = 0

        selected.pop()

        argsort = fp_proba.argsort()

        for i in range(self.model.n_params):

            fp_rate = (len(selected) * fp_rate + fp_proba[argsort[i]]) / (

                len(selected) + 1

            )

            if fp_rate <= alpha:

                selected.append(argsort[i])

            else:

                break

        selected_mask = np.full(self.model.n_params, False)

        selected_mask[selected] = True

        return ~selected_mask if superset else selected_mask

        See :meth:`BayesResults.compute_best_params` for arguments.

        """

        mask = (-self._posterior_rvs).argsort().argsort() >= n_best_params

        target_n_selected = self.model.n_params - n_best_params

        if superset:

            mask, target_n_selected = ~mask, self.model.n_params - target_n_selected

        selected = []  # selected parameters

        # n_selected is a (n samples,) array where n_selected[i] is the number of

        # selected parameters in the top `n_best_params` for sample i

        n_selected = np.zeros(len(mask))

        # max_n_selected is the maximum number of selected parameters in the top

        # `n_best_params` across samples from the posterior distribution

        max_n_selected = 0

        while (n_selected >= target_n_selected).mean() < 1 - alpha:

            arr = mask[n_selected == min(target_n_selected - 1, max_n_selected)].sum(

                axis=0

            )

            if (arr == 0).all():

                arr = mask[n_selected < target_n_selected].sum(axis=0)

            selected.append(arr.argmax())

            n_selected += mask[:, selected[-1]]

            mask[:, selected[-1]] = False

            max_n_selected += 1

        selected_mask = np.full(self.model.n_params, True)

        selected_mask[selected] = False

            n_best_params = self.model.n_params - n_best_params

            ranks = self._posterior_rvs.argsort().argsort() + 1

        else:

            ranks = (-self._posterior_rvs).argsort().argsort() + 1

        # (n_samples, n_params) array where mask[i, k] indicates that k was not one of

        # the best parameters in draw i

        mask = ranks > n_best_params

        selected = []

        unselected = list(range(self.model.n_params))

        n_uncovered_rvs = 0

        while n_uncovered_rvs / self._posterior_rvs.shape[0] <= alpha:

            # (n_params,) array of the number of rows that wouldn't be covered if parameter k

            # were selected

            uncovered = mask[:, unselected].sum(axis=0)

            index = np.argmin(uncovered)

            n_uncovered_rvs += uncovered[index]

            k = unselected[index]

            if n_uncovered_rvs / self._posterior_rvs.shape[0] <= alpha:

                selected.append(k)

                unselected.remove(k)

                # remove rows no longer covered after selecting parameter k

                mask = mask[~mask[:, k]]

        selected_mask = np.full(self.model.n_params, False)

        selected_mask[selected] = True

        return ~selected_mask if superset else selected_mask

    def rank_conf_int(