diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index a65b55e..d38444a 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1,6 +1,9 @@
 name: CI
 
-on: [push, pull_request]
+on:
+  push:
+  pull_request:
+  workflow_dispatch:
 
 jobs:
   build:
@@ -14,27 +17,28 @@ jobs:
     steps:
     - name: Check out repository
       uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
 
     - name: Set up Python ${{ matrix.python-version }}
       uses: actions/setup-python@v5
       with:
         python-version: ${{ matrix.python-version }}
+        cache: pip
 
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        pip install .
-        pip install ruff mypy pytest
+        python -m pip install ".[test]"
 
     - name: Lint with ruff
       run: |
-        ruff .
-      continue-on-error: true
+        python -m ruff check remode tests
 
     - name: Check types with mypy
       run: |
-        mypy remode/remode.py 
+        python -m mypy remode/remode.py
 
     - name: Run tests with pytest
       run: |
-        pytest
+        python -m pytest -q
diff --git a/.github/workflows/python-publish.yml b/.github/workflows/python-publish.yml
index 2a00b6f..58dcf2d 100644
--- a/.github/workflows/python-publish.yml
+++ b/.github/workflows/python-publish.yml
@@ -3,6 +3,7 @@ name: Upload Python Package
 on:
   release:
     types: [published]
+  workflow_dispatch:
 
 permissions:
   contents: read
@@ -17,15 +18,19 @@ jobs:
         uses: actions/setup-python@v5
         with:
           python-version: '3.x'
+          cache: pip
 
       - name: Install build tools
         run: |
           python -m pip install --upgrade pip
-          pip install build
+          python -m pip install build twine
 
       - name: Build package
         run: python -m build
 
+      - name: Validate package metadata
+        run: python -m twine check dist/*
+
       - name: Publish package
         uses: pypa/gh-action-pypi-publish@db8f07d3871a0a180efa06b95d467625c19d5d5f
         with:
diff --git a/.gitignore b/.gitignore
index 68bc17f..044ba5f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -158,3 +158,6 @@ cython_debug/
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
 #.idea/
+
+# macOS
+.DS_Store
diff --git a/README.md b/README.md
index a3aed6a..949cc53 100644
--- a/README.md
+++ b/README.md
@@ -5,6 +5,7 @@
 ### Features
 - Mode Detection: Identifies all potential local maxima in the dataset.
 - Statistical Tests: Implements Fisher's exact test and binomial tests to validate modes.
+- Mode Statistics: Returns per-mode p-values and approximate Bayes factors.
 - Data Formatting: Converts raw data into histogram format for analysis.
 - Stability Analysis: Includes functionality to assess the stability of detected modes using jackknife resampling.
 - Visualization: Provides methods to plot the histogram of data along with identified modes.
@@ -26,21 +27,28 @@ from remode import ReMoDe
 xt_count = [8, 20, 5, 2, 6, 2, 30]
 
 # Create an instance of ReMoDe
-detector = ReMoDe()
+detector = ReMoDe(alpha_correction="descriptive_peaks")  # default
 
 # Fit model
 results = detector.fit(xt_count)
+# results contains:
+# - nr_of_modes
+# - modes
+# - p_values
+# - approx_bayes_factors
 
 # Plot the results
 detector.plot_maxima()
 
 # Perform stability analysis
-stability_info = detector.evaluate_stability(percentage_steps=50)
+stability_info = detector.remode_stability(percentage_steps=50)
 
 ```
 
+
 See also the tutorial [here](https://github.com/sodascience/remode/blob/main/tutorial.ipynb).
 
+
 ### Citation
 
 Please cite the following paper:
diff --git a/pyproject.toml b/pyproject.toml
index 66ba8a7..1897f51 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,9 +1,5 @@
 [build-system]
-requires = [
-  "setuptools>=42",
-  "wheel",
-  "setuptools_scm[toml]>=6.0"
-]
+requires = ["setuptools>=61", "setuptools-scm>=8", "wheel"]
 build-backend = "setuptools.build_meta"
 
 [project]
@@ -31,7 +27,6 @@ dynamic = ["version"]
 
 
 classifiers = [
-    "License :: OSI Approved :: MIT License",
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.8",
     "Programming Language :: Python :: 3.9",
@@ -41,16 +36,19 @@ classifiers = [
     "Operating System :: OS Independent",
 ]
 
-
-[tool.setuptools_scm]
-write_to = "remode/_version.py"
-
-
 [project.optional-dependencies]
 test = [
     "ruff", "pytest", "mypy"
 ]
 
+[tool.setuptools_scm]
+write_to = "remode/_version.py"
+tag_regex = "^(?:v)?(?P<version>\\d+\\.\\d+(?:\\.\\d+)?)$"
+local_scheme = "no-local-version"
+
+[tool.setuptools.packages.find]
+include = ["remode*"]
+
 [project.urls]
 homepage = "https://github.com/sodascience/remode"
 repository = "https://github.com/sodascience/remode"
diff --git a/remode/__init__.py b/remode/__init__.py
index bd1b1b0..564f9db 100644
--- a/remode/__init__.py
+++ b/remode/__init__.py
@@ -1,5 +1,15 @@
 """Import ReMoDe class and statistical tests."""
 
-__all__ = ['ReMoDe', 'perform_fisher_test', 'perform_binomial_test']
+from importlib.metadata import PackageNotFoundError, version
+
+__all__ = ['ReMoDe', 'perform_fisher_test', 'perform_binomial_test', '__version__']
 
 from .remode import ReMoDe, perform_fisher_test, perform_binomial_test
+
+try:
+    __version__ = version('ReMoDe')
+except PackageNotFoundError:
+    try:
+        from ._version import version as __version__
+    except ImportError:
+        __version__ = '0+unknown'
diff --git a/remode/remode.py b/remode/remode.py
index 4a58a56..5bc9bc4 100644
--- a/remode/remode.py
+++ b/remode/remode.py
@@ -1,5 +1,6 @@
 """Recursive Mode Detection (ReMoDe) for ordinal data."""
 
+import warnings
 from collections import Counter
 from typing import Any, Callable, Dict, Literal, Optional, Tuple, Union
 
@@ -11,6 +12,57 @@
 from scipy.stats import binomtest, fisher_exact
 
 
+def count_descriptive_peaks(x: np.ndarray) -> int:
+    """
+    Count descriptive peaks in a histogram-like vector, matching the R implementation.
+
+    Parameters
+    ----------
+    x : np.ndarray
+        Histogram counts.
+
+    Returns
+    -------
+    int
+        Number of descriptive peaks.
+    """
+    if len(x) < 2:
+        return 0
+
+    signs = np.concatenate((np.array([-1]), np.sign(np.diff(x))))
+    x_filtered = x[signs != 0]
+
+    if len(x_filtered) < 2:
+        return 0
+
+    signs = np.concatenate((np.array([-1]), np.sign(np.diff(x_filtered))))
+    return int(np.sum(np.diff(signs) < 0))
+
+
+def approximate_bayes_factor(p_value: float) -> float:
+    """
+    Approximate BF_10 from a p-value using Sellke, Bayarri, and Berger (2001).
+
+    Parameters
+    ----------
+    p_value : float
+        P-value for a detected mode.
+
+    Returns
+    -------
+    float
+        Approximate Bayes factor in favor of the alternative hypothesis.
+    """
+    if p_value == 0:
+        return np.inf
+
+    if p_value <= 1 / np.e:
+        bf_01 = (-np.e * p_value * np.log(p_value)) / (1 - p_value)
+        return 1 / bf_01
+
+    return np.nan
+
+
 def perform_fisher_test(
     x: np.ndarray, candidate: int, left_min: int, right_min: int
 ) -> Tuple[float, float]:
@@ -91,7 +143,9 @@ class ReMoDe:
     alpha : float
         The significance level for the statistical tests. Default is 0.05.
     alpha_correction : str or function
-        The method for correcting the significance level for multiple comparisons. Options are "max_modes" and "none". Default is "none".
+        The method for correcting the significance level for multiple comparisons.
+        Options are "descriptive_peaks", "max_modes", and "none".
+        Default is "descriptive_peaks".
     statistical_test : function
         The statistical test to use for identifying local maxima. Options are `perform_fisher_test` and `perform_binomial_test`. Default is `perform_fisher_test`.
 
@@ -101,40 +155,66 @@ class ReMoDe:
         Formats the input data for mode detection.
     fit(xt: np.ndarray) -> Dict[str, Union[int, np.ndarray]]:
         Fits the model to the input data and returns the detected modes.
-    evaluate_stability(iterations: int, percentage_steps: int) -> Dict[str, Any]:
+    remode_stability(iterations: int, percentage_steps: int) -> Dict[str, Any]:
         Evaluates the stability of the detected modes using the jackknife resampling method.
     """
 
     def __init__(
         self,
         alpha: float = 0.05,
-        alpha_correction: Union[Literal["max_modes", "none"], Callable] = "none",
+        alpha_correction: Union[
+            Literal["descriptive_peaks", "max_modes", "none"], Callable
+        ] = "descriptive_peaks",
         statistical_test: Callable = perform_fisher_test,
     ):
         self.alpha = alpha
 
+        def _segment_length(segment: Union[np.ndarray, int]) -> int:
+            if isinstance(segment, np.ndarray):
+                return len(segment)
+            return int(segment)
+
         if isinstance(alpha_correction, str):
-            if alpha_correction.lower() == "none":
-                self._create_alpha_correction = lambda length, alpha: alpha
-            elif alpha_correction.lower() == "max_modes":
-                self._create_alpha_correction = lambda length, alpha: alpha / (
-                    np.floor((length + 1) / 2)
+            correction_name = alpha_correction.lower()
+            if correction_name == "none":
+                self._create_alpha_correction = lambda segment, alpha: alpha
+            elif correction_name == "max_modes":
+                self._create_alpha_correction = (
+                    lambda segment, alpha: alpha
+                    / np.floor((_segment_length(segment) + 1) / 2)
                 )
-        else:
-            # Test if the provided function is valid (has one argument)
-            if not callable(alpha_correction):
+            elif correction_name == "descriptive_peaks":
+                self._create_alpha_correction = (
+                    lambda segment, alpha: alpha
+                    / max(1, count_descriptive_peaks(np.asarray(segment)))
+                )
+            else:
                 raise ValueError(
-                    "The alpha_correction argument must be a function or one of 'max_modes' or 'none'."
+                    "The alpha_correction argument must be a function or one of "
+                    "'descriptive_peaks', 'max_modes', or 'none'."
                 )
-            elif len(alpha_correction.__code__.co_varnames) != 2:
+        else:
+            if not callable(alpha_correction):
                 raise ValueError(
-                    "The alpha_correction function must take two arguments (the legnth of the bins and the alpha level)."
+                    "The alpha_correction argument must be a function or one of "
+                    "'descriptive_peaks', 'max_modes', or 'none'."
                 )
-            self._create_alpha_correction = alpha_correction
+
+            def _create_alpha_correction(
+                segment: Union[np.ndarray, int], alpha_level: float
+            ) -> float:
+                try:
+                    return alpha_correction(segment, alpha_level)
+                except TypeError:
+                    return alpha_correction(_segment_length(segment), alpha_level)
+
+            self._create_alpha_correction = _create_alpha_correction
 
         self.alpha_cor: Optional[float] = None
         self.statistical_test = statistical_test
         self.modes: np.ndarray = np.array([])
+        self.p_values: np.ndarray = np.array([])
+        self.approx_bayes_factors: np.ndarray = np.array([])
         self.xt: np.ndarray = np.array([])
         self.levels: np.ndarray = np.array([])
 
@@ -164,7 +244,7 @@ def format_data(
 
         return np.histogram(xt, bins=levels_h)[0]
 
-    def _find_maxima(self, xt: np.ndarray) -> np.ndarray:
+    def _find_maxima(self, xt: np.ndarray) -> list:
         """
         Finds the local maxima in the input data.
 
@@ -175,23 +255,32 @@ def _find_maxima(self, xt: np.ndarray) -> np.ndarray:
 
         Returns
         -------
-        np.ndarray
-            The indices of the local maxima in the input data.
+        list
+            Pairs of local mode indices and p-values.
         """
         if len(xt) < 3:
-            return np.array([], dtype=int)
+            return []
 
         result = []
+        alpha_cor = self._create_alpha_correction(xt, self.alpha)
         candidate = np.argmax(xt)
         if candidate != 0 and candidate != len(xt) - 1:
             left_min = np.argmin(xt[:candidate])
             right_min = np.argmin(xt[candidate:]) + candidate
             p_left, p_right = self.statistical_test(xt, candidate, left_min, right_min)
-            if p_left < self.alpha_cor and p_right < self.alpha_cor:
-                result.append(candidate)
-        result.extend(self._find_maxima(xt[:candidate]))
-        result.extend(self._find_maxima(xt[candidate + 1 :]) + candidate + 1)
-        return np.unique(result)
+            if self.statistical_test is perform_fisher_test:
+                p_value = 1 - (1 - p_left) * (1 - p_right)
+                if p_value < alpha_cor:
+                    result.append((candidate, p_value))
+            elif p_left < alpha_cor and p_right < alpha_cor:
+                result.append((candidate, max(p_left, p_right)))
+
+        left = self._find_maxima(xt[:candidate])
+        right = [
+            (idx + candidate + 1, p_value)
+            for idx, p_value in self._find_maxima(xt[candidate + 1 :])
+        ]
+        return result + left + right
 
     def fit(
         self, xt: np.ndarray, set_data: bool = True, levels: np.ndarray = np.array([])
@@ -217,10 +306,24 @@ def fit(
         Dict[str, Any]
             A dictionary containing the detected modes and their properties. The keys of the dictionary are the indices of the modes, and the values are the properties of the modes.
         """
-        self.alpha_cor = self._create_alpha_correction(len(xt), self.alpha)
+        xt = np.asarray(xt)
         xt_padded: np.ndarray = np.concatenate((np.array([0]), xt, np.array([0])))
-        modes = self._find_maxima(xt_padded)
-        modes -= 1
+        self.alpha_cor = self._create_alpha_correction(xt_padded, self.alpha)
+        mode_details = self._find_maxima(xt_padded)
+        if len(mode_details) == 0:
+            modes = np.array([], dtype=int)
+            p_values = np.array([], dtype=float)
+            approx_bayes_factors = np.array([], dtype=float)
+        else:
+            modes = np.array([mode_index - 1 for mode_index, _ in mode_details], dtype=int)
+            p_values = np.array([p_value for _, p_value in mode_details], dtype=float)
+
+            sort_order = np.argsort(modes)
+            modes = modes[sort_order]
+            p_values = p_values[sort_order]
+            approx_bayes_factors = np.array(
+                [approximate_bayes_factor(p_value) for p_value in p_values], dtype=float
+            )
 
         if len(levels) == 0:
             self.levels = np.arange(len(xt))
@@ -230,10 +333,14 @@ def fit(
         if set_data:
             self.xt = xt
             self.modes = modes
+            self.p_values = p_values
+            self.approx_bayes_factors = approx_bayes_factors
 
         return {
             "nr_of_modes": len(modes),
             "modes": modes,
+            "p_values": p_values,
+            "approx_bayes_factors": approx_bayes_factors,
             "xt": xt,
             "alpha_after_correction": self.alpha_cor,
         }
@@ -345,9 +452,9 @@ def _jackknife(self, percentage: float) -> np.ndarray:
 
         return np.bincount(x, minlength=len(self.xt))
 
-    def evaluate_stability(
-            self, iterations: int = 100, percentage_steps: int = 10, plot: bool = True
-        ) -> Dict[str, Any]:
+    def remode_stability(
+        self, iterations: int = 100, percentage_steps: int = 10, plot: bool = True
+    ) -> Dict[str, Any]:
         """
         Evaluates the stability of the detected modes using the jackknife resampling method.
 
@@ -370,8 +477,7 @@ def evaluate_stability(
                 "It appears that either you did not yet apply ReMoDe or that no modes were found. Stability analyses can only be performed on modes detected by ReMoDe."
             )
 
-
-        perc_range = np.linspace(0, 100, percentage_steps)
+        perc_range = np.linspace(0, 100, percentage_steps + 1)
         modes = pd.DataFrame(
             {
                 "perc": perc_range,
@@ -386,10 +492,10 @@ def evaluate_stability(
         modes.at[0, "majority_result"] = True
 
         # Initialize matrix to store data counts of mode locations
-        modes_locations = np.zeros((percentage_steps + 1, len(self.xt)))
+        modes_locations = np.zeros((len(perc_range), len(self.xt)))
         modes_locations[0, self.modes] = iterations
 
-        for i in range(1, len(perc_range)):
+        for i in range(1, len(perc_range) - 1):
             m = np.zeros(iterations)
             for j in range(iterations):
                 xt_jackknifed = self._jackknife(modes.at[i, "perc"])
@@ -402,30 +508,37 @@ def evaluate_stability(
             modes.at[i, "mean_modality"] = np.mean(m)
             modes.at[i, "most_freq_modality"] = Counter(m).most_common(1)[0][0]
             modes.at[i, "majority_result"] = (
-                np.mean(m == modes.at[i, "most_freq_modality"]) >= 0.5
+                np.mean(m == len(self.modes)) >= 0.5
             )
 
-
         modes.loc[len(perc_range) - 1, ["mean_modality", "most_freq_modality", "majority_result"]] = [0, 0, False]
         modes_locations[len(perc_range) - 1, :] = 0
 
-        stable_until = modes.loc[
-            (modes["majority_result"] == 1) & (modes["most_freq_modality"] == modes.at[0, "most_freq_modality"]),
-            "perc"
-        ].max()
+        false_indices = np.where(~modes["majority_result"].astype(bool).to_numpy())[0]
+        if len(false_indices) == 0:
+            stable_until = float(modes["perc"].max())
+        elif false_indices[0] == 0:
+            stable_until = 0.0
+        else:
+            stable_until = float(modes["perc"].iloc[false_indices[0] - 1])
 
         # Calculate the stability of the location of detected modes
-        stability_location = np.apply_along_axis(
-            lambda x: (np.argmax(x > (iterations / 2)) - 1) / len(perc_range),
-            axis=0,
-            arr=modes_locations
-        )
-
-        stability_location = stability_location[stability_location > 0]
-        # Ensure compatibility in dimensions
-        if len(stability_location) > 0:
-            stability_location = np.column_stack((sorted(self.modes), stability_location))
-            stability_location_df = pd.DataFrame(stability_location, columns=["Mode location", "Stability estimate"])
+        if len(self.modes) > 0:
+            sorted_modes = np.sort(self.modes.astype(int))
+            stability_estimates = np.apply_along_axis(
+                lambda x: np.argmin(x > (iterations / 2)) / modes_locations.shape[0],
+                axis=0,
+                arr=modes_locations[:, sorted_modes],
+            )
+            stability_location_df = pd.DataFrame(
+                {
+                    "Mode location": sorted_modes,
+                    "Stability estimate": stability_estimates,
+                }
+            )
+            stability_location_df = stability_location_df[
+                stability_location_df["Stability estimate"] > 0
+            ].reset_index(drop=True)
         else:
             stability_location_df = pd.DataFrame(columns=["Mode location", "Stability estimate"])
 
@@ -466,3 +579,19 @@ def evaluate_stability(
             "stable_until": stable_until,
             "location_stability": stability_location_df
         }
+
+    def evaluate_stability(
+        self, iterations: int = 100, percentage_steps: int = 10, plot: bool = True
+    ) -> Dict[str, Any]:
+        """
+        Deprecated alias for ``remode_stability``.
+        """
+        warnings.warn(
+            "'evaluate_stability' is deprecated and will be removed in a future release; "
+            "use 'remode_stability' instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.remode_stability(
+            iterations=iterations, percentage_steps=percentage_steps, plot=plot
+        )
diff --git a/tests/test_remode.py b/tests/test_remode.py
index 8088096..175f43e 100644
--- a/tests/test_remode.py
+++ b/tests/test_remode.py
@@ -1,6 +1,8 @@
 """Tests for the ReMoDe class."""
 import numpy as np
+import pytest
 from remode import ReMoDe, perform_fisher_test, perform_binomial_test
+from remode.remode import count_descriptive_peaks
 
 
 def test_perform_fisher_test():
@@ -37,15 +39,24 @@ def test_remode_initialization():
         alpha=0.05, alpha_correction="none", statistical_test=perform_fisher_test
     )
     assert remode.alpha == 0.05
-    assert remode._create_alpha_correction(10, 0.05) == 0.05
+    assert remode._create_alpha_correction(np.arange(10), 0.05) == 0.05
     assert remode.statistical_test == perform_fisher_test
 
     remode = ReMoDe(
         alpha=0.05, alpha_correction="max_modes", statistical_test=perform_fisher_test
     )
-    assert remode._create_alpha_correction(10, 0.05) == 0.01
+    assert remode._create_alpha_correction(np.arange(10), 0.05) == 0.01
     assert remode.statistical_test == perform_fisher_test
 
+    remode = ReMoDe(alpha=0.05, statistical_test=perform_fisher_test)
+    assert remode._create_alpha_correction(np.array([0, 2, 0, 3, 0]), 0.05) == 0.025
+    assert remode.statistical_test == perform_fisher_test
+
+
+def test_count_descriptive_peaks():
+    assert count_descriptive_peaks(np.array([0, 2, 0, 3, 0])) == 2
+    assert count_descriptive_peaks(np.array([1, 1, 1, 1])) == 0
+
 
 def test_format_data():
     remode = ReMoDe()
@@ -59,14 +70,48 @@ def test_fit():
     x = np.array([1, 2, 30, 2, 1])
     maxima = remode.fit(x)
     assert np.array_equal(maxima["modes"], np.array([2]))
+    assert len(maxima["p_values"]) == 1
+    assert len(maxima["approx_bayes_factors"]) == 1
+    assert maxima["p_values"][0] < 0.05
+    assert maxima["approx_bayes_factors"][0] > 1
 
     x = np.array([30, 2, 1, 2, 1])
     maxima = remode.fit(x)
     assert np.array_equal(maxima["modes"], np.array([0]))
+    assert len(maxima["p_values"]) == 1
+    assert len(maxima["approx_bayes_factors"]) == 1
 
     x = np.array([30, 2, 1, 2, 30])
     maxima = remode.fit(x)
     assert np.array_equal(maxima["modes"], np.array([0, 4]))
+    assert len(maxima["p_values"]) == 2
+    assert len(maxima["approx_bayes_factors"]) == 2
+
+
+def test_fit_returns_r_parity_statistics_fisher():
+    remode = ReMoDe(statistical_test=perform_fisher_test)
+    x = np.array([70, 80, 110, 30, 70, 100, 90, 120])
+
+    result = remode.fit(x)
+
+    assert np.array_equal(result["modes"], np.array([2, 7]))
+    assert np.isclose(result["p_values"][0], 1.129097e-13, rtol=1e-5)
+    assert np.isclose(result["approx_bayes_factors"][0], 1.0929e11, rtol=1e-5)
+    assert result["p_values"][1] == 0
+    assert np.isinf(result["approx_bayes_factors"][1])
+
+
+def test_fit_returns_r_parity_statistics_binomial():
+    remode = ReMoDe(statistical_test=perform_binomial_test)
+    x = np.array([70, 80, 110, 30, 70, 100, 90, 120])
+
+    result = remode.fit(x)
+
+    assert np.array_equal(result["modes"], np.array([2, 7]))
+    assert np.isclose(result["p_values"][0], 3.12457e-12, rtol=1e-5)
+    assert np.isclose(result["p_values"][1], 7.52316e-37, rtol=1e-5)
+    assert np.isclose(result["approx_bayes_factors"][0], 4.44432e9, rtol=1e-5)
+    assert np.isclose(result["approx_bayes_factors"][1], 5.87893e33, rtol=1e-5)
 
 
 def test_jackknife():
@@ -76,12 +121,22 @@ def test_jackknife():
     assert len(resampled_data) == 5
 
 
-def test_evaluate_stability():
+def test_remode_stability():
     remode = ReMoDe()
     remode.xt = np.array([1, 2, 20, 2, 1])
     remode.modes = np.array([2])
-    result = remode.evaluate_stability(iterations=100, percentage_steps=5)
-    print(result["stable_until"])
+
+    np.random.seed(123)
+    result = remode.remode_stability(iterations=100, percentage_steps=5, plot=False)
+
     assert "location_stability" in result
     assert "stable_until" in result
-    assert result["stable_until"] == 75
+    assert 0 <= result["stable_until"] <= 100
+
+    np.random.seed(123)
+    with pytest.warns(DeprecationWarning):
+        alias_result = remode.evaluate_stability(
+            iterations=100, percentage_steps=5, plot=False
+        )
+
+    assert alias_result["stable_until"] == result["stable_until"]
diff --git a/tutorial.ipynb b/tutorial.ipynb
index f4a8a48..5423a3a 100644
--- a/tutorial.ipynb
+++ b/tutorial.ipynb
@@ -2,12 +2,13 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 1,
    "id": "79d69429-7819-43fe-9c67-4fde9fba4657",
    "metadata": {},
    "outputs": [],
    "source": [
-    "from remode import *\n",
+    "#pip install remode\n",
+    "from remode import ReMoDe, perform_fisher_test, perform_binomial_test\n",
     "import numpy as np\n",
     "import matplotlib.pyplot as plt"
    ]
@@ -22,7 +23,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 2,
    "id": "22d965f2",
    "metadata": {},
    "outputs": [
@@ -30,12 +31,14 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'nr_of_modes': 2, 'modes': array([1, 6]), 'xt': [8, 20, 5, 2, 6, 2, 30], 'alpha_after_correction': 0.05}\n"
+      "{'nr_of_modes': 2, 'modes': array([1, 6]), 'p_values': array([5.43120690e-06, 4.27329283e-11]), 'approx_bayes_factors': array([5.58707110e+03, 3.60562337e+08]), 'xt': array([ 8, 20,  5,  2,  6,  2, 30]), 'alpha_after_correction': 0.016666666666666666}\n",
+      "mode p-values: [5.43120690e-06 4.27329283e-11]\n",
+      "approx Bayes factors: [5.58707110e+03 3.60562337e+08]\n"
      ]
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -48,19 +51,21 @@
     "## Histogram counts\n",
     "xt_count = [8, 20, 5, 2, 6, 2, 30]\n",
     "\n",
-    "# Start ReMoDe\n",
+    "# Start ReMoDe (default uses descriptive-peaks alpha correction)\n",
     "remode = ReMoDe()\n",
     "\n",
-    "# Fit the data and plot maxima\n",
+    "# Fit the data and inspect mode statistics\n",
     "result = remode.fit(xt_count)\n",
     "print(result)\n",
+    "print('mode p-values:', result['p_values'])\n",
+    "print('approx Bayes factors:', result['approx_bayes_factors'])\n",
     "\n",
-    "remode.plot_maxima()"
+    "remode.plot_maxima()\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 3,
    "id": "455b36c0",
    "metadata": {},
    "outputs": [
@@ -68,12 +73,12 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "81.63265306122449\n"
+      "72.0\n"
      ]
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1200x400 with 2 Axes>"
       ]
@@ -84,13 +89,13 @@
    ],
    "source": [
     "# Test robustness using jackknife\n",
-    "robustness = remode.evaluate_stability(percentage_steps=50)\n",
-    "print(robustness[\"stable_until\"])"
+    "robustness = remode.remode_stability(percentage_steps=50)\n",
+    "print(robustness['stable_until'])\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 4,
    "id": "8ae0fc0a",
    "metadata": {},
    "outputs": [
@@ -98,12 +103,14 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'nr_of_modes': 1, 'modes': array([2]), 'xt': array([41, 34, 71, 36, 18]), 'alpha_after_correction': 0.05}\n"
+      "{'nr_of_modes': 1, 'modes': array([2]), 'p_values': array([0.]), 'approx_bayes_factors': array([inf]), 'xt': array([41, 34, 71, 36, 18]), 'alpha_after_correction': 0.025}\n",
+      "mode p-values: [0.]\n",
+      "approx Bayes factors: [inf]\n"
      ]
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -124,9 +131,11 @@
     "# Create count data\n",
     "xt_count = remode.format_data(data)\n",
     "\n",
-    "# Fit the data and plot maxima\n",
+    "# Fit the data and inspect mode statistics\n",
     "result = remode.fit(xt_count, levels=np.arange(3, 8))\n",
     "print(result)\n",
+    "print('mode p-values:', result['p_values'])\n",
+    "print('approx Bayes factors:', result['approx_bayes_factors'])\n",
     "\n",
     "remode.plot_maxima()\n"
    ]
@@ -143,36 +152,35 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 5,
    "id": "65305726-763b-421c-ae8e-74640127cf47",
    "metadata": {},
    "outputs": [],
    "source": [
     "remode = ReMoDe(\n",
-    "    alpha=0.05, # alpha level desired (to be adjusted later for multiple testing)\n",
-    "    alpha_correction=\"max_modes\", # or \"none\" (for no adjustment), or custom function\n",
-    "    statistical_test=perform_fisher_test, # or perform_binomial_test, or custom function\n",
-    ")"
+    "    alpha=0.05,  # alpha level desired (adjusted recursively for multiple testing)\n",
+    "    alpha_correction='descriptive_peaks',  # or 'max_modes', 'none', or custom function\n",
+    "    statistical_test=perform_fisher_test,  # or perform_binomial_test, or custom function\n",
+    ")\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 6,
    "id": "d74cd67c-f4ab-420d-919d-f5dd3f663175",
    "metadata": {},
    "outputs": [],
    "source": [
-    "\n",
     "remode = ReMoDe(\n",
-    "    alpha=0.05, # alpha level desired (to be adjusted later for multiple testing)\n",
-    "    alpha_correction=\"max_modes\", # or \"none\" (for no adjustment), or custom function\n",
-    "    statistical_test=perform_fisher_test, # or perform_binomial_test, or custom function\n",
+    "    alpha=0.05,\n",
+    "    alpha_correction='max_modes',  # example of the alternative built-in correction\n",
+    "    statistical_test=perform_fisher_test,\n",
     ")\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 7,
    "id": "a9f09ad5",
    "metadata": {},
    "outputs": [],
@@ -181,62 +189,43 @@
     "from scipy.stats import binomtest\n",
     "\n",
     "def custom_test(x, candidate, left_min, right_min):\n",
-    "    \"\"\"\n",
-    "    Perform a custom statistical test on the candidate maximum.\n",
-    "\n",
-    "    Parameters\n",
-    "    ----------\n",
-    "    x : np.ndarray\n",
-    "        The input data array.\n",
-    "    candidate : int\n",
-    "        The index of the candidate maximum.\n",
-    "    left_min : int\n",
-    "        The index of the minimum value on the left side of the candidate maximum.\n",
-    "    right_min : int\n",
-    "        The index of the minimum value on the right side of the candidate maximum.\n",
-    "\n",
-    "    Returns\n",
-    "    -------\n",
-    "    Tuple[float, float]\n",
-    "        The p-values of the binomial tests for the left and right sides of the candidate maximum.\n",
-    "    \"\"\"\n",
+    "    \"\"\"Return left/right p-values for a candidate maximum.\"\"\"\n",
     "    n_left = x[candidate] + x[left_min]\n",
     "    n_right = x[candidate] + x[right_min]\n",
-    "    p_left = binomtest(x[candidate], n_left, alternative=\"greater\").pvalue\n",
-    "    p_right = binomtest(x[candidate], n_right, alternative=\"greater\").pvalue\n",
+    "    p_left = binomtest(x[candidate], n_left, alternative='greater').pvalue\n",
+    "    p_right = binomtest(x[candidate], n_right, alternative='greater').pvalue\n",
     "    return p_left, p_right\n",
     "\n",
-    "# Example of custom adjustment\n",
-    "def custom_adjustment(len_x, alpha):\n",
-    "    \"\"\"\n",
-    "    Perform a custom adjustment of p-values.\n",
-    "\n",
-    "    Parameters\n",
-    "    ----------\n",
-    "    len_x : int\n",
-    "        The length of the input data array.\n",
-    "    alpha : float\n",
-    "        The desired alpha level.\n",
     "\n",
-    "    Returns\n",
-    "    -------\n",
-    "    float\n",
-    "        The adjusted alpha level\n",
-    "    \"\"\"\n",
-    "    return alpha / len_x\n",
+    "# Example of custom alpha adjustment\n",
+    "def custom_adjustment(segment_or_length, alpha):\n",
+    "    \"\"\"Adjust alpha as a function of segment size.\"\"\"\n",
+    "    if hasattr(segment_or_length, '__len__'):\n",
+    "        length = len(segment_or_length)\n",
+    "    else:\n",
+    "        length = int(segment_or_length)\n",
+    "    return alpha / max(1, length)\n",
     "\n",
     "\n",
     "remode = ReMoDe(\n",
-    "    alpha=0.05, # alpha level desired (to be adjusted later for multiple testing)\n",
-    "    statistical_test=perform_fisher_test, # or perform_binomial_test, or custom function\n",
+    "    alpha=0.05,\n",
+    "    statistical_test=custom_test,\n",
     "    alpha_correction=custom_adjustment,\n",
-    ")"
+    ")\n"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9f5e5d0e-bf54-47d6-931e-d2bfda79894a",
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "st",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -250,7 +239,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.12"
+   "version": "3.9.15"
   }
  },
  "nbformat": 4,