diff --git a/CompStats/__init__.py b/CompStats/__init__.py
index 8c23749..304ae65 100644
--- a/CompStats/__init__.py
+++ b/CompStats/__init__.py
@@ -11,7 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-__version__ = '0.1.10'
+__version__ = '0.1.11'
 from CompStats.bootstrap import StatisticSamples
 from CompStats.measurements import CI, SE, difference_p_value
 from CompStats.performance import performance, difference, all_differences, plot_performance, plot_difference
diff --git a/CompStats/interface.py b/CompStats/interface.py
index f1143a3..a4262fb 100644
--- a/CompStats/interface.py
+++ b/CompStats/interface.py
@@ -20,7 +20,6 @@
 from CompStats.utils import progress_bar
 from CompStats import measurements
 from CompStats.measurements import SE
-from CompStats.performance import plot_performance, plot_difference
 from CompStats.utils import dataframe
 
 
@@ -248,7 +247,7 @@ def best(self):
             else:
                 self._best = np.array([key] * value.shape[1])
             return self._best
-        BiB = True if self.statistic_samples.BiB else False
+        BiB = bool(self.statistic_samples.BiB)
         keys = np.array(list(self.statistic.keys()))
         data = np.asanyarray([self.statistic[k]
                               for k in keys])        
@@ -338,6 +337,12 @@ def plot(self, value_name:str=None,
              CI:float=0.05,
              kind:str='point', linestyle:str='none',
              col_wrap:int=3, capsize:float=0.2,
+             comparison:bool=True,
+             right:bool=True,
+             comp_legend:str='Comparison',
+             winner_legend:str='Best',
+             tie_legend:str='Equivalent',
+             loser_legend:str='Different',
              **kwargs):
         """plot with seaborn
 
@@ -363,32 +368,79 @@ def plot(self, value_name:str=None,
                 value_name = 'Score'
             else:
                 value_name = 'Error'
+        if not isinstance(self.statistic, dict):
+            comparison = False
+        best = self.best
+        if isinstance(best, np.ndarray):
+            if best.shape[0] < col_wrap:
+                col_wrap = best.shape[0]
         df = self.dataframe(value_name=value_name, var_name=var_name,
-                            alg_legend=alg_legend, perf_names=perf_names)
+                            alg_legend=alg_legend, perf_names=perf_names,
+                            comparison=comparison, alpha=CI, right=right,
+                            comp_legend=comp_legend, 
+                            winner_legend=winner_legend,
+                            tie_legend=tie_legend,
+                            loser_legend=loser_legend)
         if var_name not in df.columns:
             var_name = None
             col_wrap = None
         ci = lambda x: measurements.CI(x, alpha=CI)
+        if comparison:
+            kwargs.update(dict(hue=comp_legend))
         f_grid = sns.catplot(df, x=value_name, errorbar=ci,
                              y=alg_legend, col=var_name,
                              kind=kind, linestyle=linestyle,
                              col_wrap=col_wrap, capsize=capsize, **kwargs)
         return f_grid
 
-    
-    def dataframe(self, value_name:str='Score',
+    def dataframe(self, comparison:bool=False,
+                  right:bool=True,
+                  alpha:float=0.05,
+                  value_name:str='Score',
                   var_name:str='Performance',
                   alg_legend:str='Algorithm',
+                  comp_legend:str='Comparison',
+                  winner_legend:str='Best',
+                  tie_legend:str='Equivalent',
+                  loser_legend:str='Different',
                   perf_names:str=None):
         """Dataframe"""
         if perf_names is None and isinstance(self.best, np.ndarray):
             func_name = self.statistic_func.__name__
             perf_names = [f'{func_name}({i})'
                           for i, k in enumerate(self.best)]
-        return dataframe(self, value_name=value_name,
-                         var_name=var_name,
-                         alg_legend=alg_legend,
-                         perf_names=perf_names)
+        df = dataframe(self, value_name=value_name,
+                       var_name=var_name,
+                       alg_legend=alg_legend,
+                       perf_names=perf_names)
+        if not comparison:
+            return df
+        df[comp_legend] = tie_legend
+        diff = self.difference()
+        best = self.best
+        if isinstance(best, str):
+            for name, p in diff.p_value(right=right).items():
+                if p >= alpha:
+                    continue
+                df.loc[df[alg_legend] == name, comp_legend] = loser_legend
+            df.loc[df[alg_legend] == best, comp_legend] = winner_legend
+        else:
+            p_values = diff.p_value(right=right)
+            systems = list(p_values.keys())
+            p_values = np.array([p_values[k] for k in systems])
+            for name, p_value, winner in zip(perf_names,
+                                             p_values.T,
+                                             best):
+                mask = df[var_name] == name
+                for alg, p in zip(systems, p_value):
+                    if p >= alpha and winner != alg:
+                        continue
+                    _ = mask & (df[alg_legend] == alg)
+                    if winner == alg:
+                        df.loc[_, comp_legend] = winner_legend
+                    else:
+                        df.loc[_, comp_legend] = loser_legend
+        return df
 
     @property
     def n_jobs(self):
diff --git a/CompStats/tests/test_interface.py b/CompStats/tests/test_interface.py
index feebee9..f2d02c4 100644
--- a/CompStats/tests/test_interface.py
+++ b/CompStats/tests/test_interface.py
@@ -17,12 +17,30 @@
 from sklearn.svm import LinearSVC
 from sklearn.ensemble import RandomForestClassifier
 from sklearn.naive_bayes import GaussianNB
-from sklearn.datasets import load_iris, load_digits
+from sklearn.datasets import load_iris, load_digits, load_breast_cancer
 from sklearn.model_selection import train_test_split
 import pandas as pd
 from CompStats.tests.test_performance import DATA
 
 
+def test_Perf_plot_col_wrap():
+    """Test plot when 2 classes"""
+    from CompStats.metrics import f1_score
+
+    X, y = load_breast_cancer(return_X_y=True)
+    _ = train_test_split(X, y, test_size=0.3)
+    X_train, X_val, y_train, y_val = _
+    ens = RandomForestClassifier().fit(X_train, y_train)
+    nb = GaussianNB().fit(X_train, y_train)
+    svm = LinearSVC().fit(X_train, y_train)
+    score = f1_score(y_val, ens.predict(X_val),
+                     average=None,
+                     num_samples=50)
+    score(nb.predict(X_val))
+    score(svm.predict(X_val))
+    score.plot()
+
+
 def test_Difference_dataframe():
     """Test Difference dataframe"""
     from CompStats.metrics import f1_score
diff --git a/README.rst b/README.rst
index 7e124c8..4ac5f92 100644
--- a/README.rst
+++ b/README.rst
@@ -27,7 +27,7 @@ CompStats
 
 Collaborative competitions have gained popularity in the scientific and technological fields. These competitions involve defining tasks, selecting evaluation scores, and devising result verification methods. In the standard scenario, participants receive a training set and are expected to provide a solution for a held-out dataset kept by organizers. An essential challenge for organizers arises when comparing algorithms' performance, assessing multiple participants, and ranking them. Statistical tools are often used for this purpose; however, traditional statistical methods often fail to capture decisive differences between systems' performance. CompStats implements an evaluation methodology for statistically analyzing competition results and competition. CompStats offers several advantages, including off-the-shell comparisons with correction mechanisms and the inclusion of confidence intervals. 
 
-To illustrate the use of `CompStats`, the following snippets show an example. The instructions load the necessary libraries, including the one to obtain the problem (e.g., digits), three different classifiers, and the last line is the score used to measure the performance and compare the algorithm. 
+To illustrate the use of `CompStats`, the following snippets show an example. The instructions load the necessary libraries, including the one to obtain the problem (e.g., digits), four different classifiers, and the last line is the score used to measure the performance and compare the algorithm. 
 
 >>> from sklearn.svm import LinearSVC
 >>> from sklearn.naive_bayes import GaussianNB
@@ -51,10 +51,10 @@ Once the predictions are available, it is time to measure the algorithm's perfor
 >>> score
 <Perf(score_func=f1_score, statistic=0.9435, se=0.0099)>
 
-The previous code shows the macro-f1 score and, in parenthesis, its standard error. The actual performance value is stored in the `statistic` function.
+The previous code shows the macro-f1 score and its standard error. The actual performance value is stored in the attributes `statistic` function, and `se`
 
->>> score.statistic
-0.9434834454375508
+>>> score.statistic, score.se
+(0.9521479775366307, 0.009717884979482313)
 
 Continuing with the example, let us assume that one wants to test another classifier on the same problem, in this case, a random forest, as can be seen in the following two lines. The second line predicts the validation set and sets it to the analysis. 
 
@@ -63,28 +63,36 @@ Continuing with the example, let us assume that one wants to test another classi
 <Perf(score_func=f1_score)>
 Statistic with its standard error (se)
 statistic (se)
-0.9655 (0.0077) <= Random Forest
-0.9435 (0.0099) <= alg-1
+0.9720 (0.0076) <= Random Forest
+0.9521 (0.0097) <= alg-1
 
-Let us incorporate another prediction, now with the Naive Bayes classifier, as seen below.
+Let us incorporate another predictions, now with Naive Bayes classifier, and Histogram Gradient Boosting as seen below.
 
 >>> nb = GaussianNB().fit(X_train, y_train)
 >>> score(nb.predict(X_val), name='Naive Bayes')
 <Perf(score_func=f1_score)>
 Statistic with its standard error (se)
 statistic (se)
-0.9655 (0.0077) <= Random Forest
-0.9435 (0.0099) <= alg-1
-0.8549 (0.0153) <= Naive Bayes
+0.9759 (0.0068) <= Hist. Grad. Boost. Tree
+0.9720 (0.0076) <= Random Forest
+0.9521 (0.0097) <= alg-1
+0.8266 (0.0159) <= Naive Bayes
 
-The final step is to compare the performance of the three classifiers, which can be done with the `difference` method, as seen next.  
+The performance, its confidence interval (5%), and a statistical comparison (5%) between the best performing system with the rest of the algorithms is depicted in the following figure.
+
+>>> score.plot()
+
+.. image:: https://github.com/INGEOTEC/CompStats/raw/docs/docs/source/digits_perf.png
+
+The final step is to compare the performance of the four classifiers, which can be done with the `difference` method, as seen next.  
 
 >>> diff = score.difference()
 >>> diff
 <Difference>
-difference p-values  w.r.t Random Forest
+difference p-values  w.r.t Hist. Grad. Boost. Tree
 0.0000 <= Naive Bayes
-0.0120 <= alg-1
+0.0100 <= alg-1
+0.3240 <= Random Forest
 
 The class `Difference` has the `plot` method that can be used to depict the difference with respect to the best. 
 
diff --git a/docs/CompStats_metrics.ipynb b/docs/CompStats_metrics.ipynb
index 2527d84..28c8838 100644
--- a/docs/CompStats_metrics.ipynb
+++ b/docs/CompStats_metrics.ipynb
@@ -48,58 +48,11 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 1,
+      "execution_count": null,
       "metadata": {
-        "id": "I1B4Ktin2VfE",
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "outputId": "b37f28d5-90d9-4d94-c28c-27f9054f1a23"
+        "id": "I1B4Ktin2VfE"
       },
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Collecting git+https://github.com/INGEOTEC/CompStats@develop\n",
-            "  Cloning https://github.com/INGEOTEC/CompStats (to revision develop) to /tmp/pip-req-build-yb73d9s4\n",
-            "  Running command git clone --filter=blob:none --quiet https://github.com/INGEOTEC/CompStats /tmp/pip-req-build-yb73d9s4\n",
-            "  Running command git checkout -b develop --track origin/develop\n",
-            "  Switched to a new branch 'develop'\n",
-            "  Branch 'develop' set up to track remote branch 'develop' from 'origin'.\n",
-            "  Resolved https://github.com/INGEOTEC/CompStats to commit 438a8055b71bba437bad7bd1ef5427b29e0ed245\n",
-            "  Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n",
-            "  Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n",
-            "  Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n",
-            "Requirement already satisfied: numpy in /usr/local/lib/python3.11/dist-packages (from CompStats==0.1.7) (1.26.4)\n",
-            "Requirement already satisfied: scikit-learn>=1.3.0 in /usr/local/lib/python3.11/dist-packages (from CompStats==0.1.7) (1.6.1)\n",
-            "Requirement already satisfied: pandas in /usr/local/lib/python3.11/dist-packages (from CompStats==0.1.7) (2.2.2)\n",
-            "Requirement already satisfied: seaborn>=0.13.0 in /usr/local/lib/python3.11/dist-packages (from CompStats==0.1.7) (0.13.2)\n",
-            "Requirement already satisfied: scipy>=1.6.0 in /usr/local/lib/python3.11/dist-packages (from scikit-learn>=1.3.0->CompStats==0.1.7) (1.13.1)\n",
-            "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.11/dist-packages (from scikit-learn>=1.3.0->CompStats==0.1.7) (1.4.2)\n",
-            "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.11/dist-packages (from scikit-learn>=1.3.0->CompStats==0.1.7) (3.5.0)\n",
-            "Requirement already satisfied: matplotlib!=3.6.1,>=3.4 in /usr/local/lib/python3.11/dist-packages (from seaborn>=0.13.0->CompStats==0.1.7) (3.10.0)\n",
-            "Requirement already satisfied: python-dateutil>=2.8.2 in /usr/local/lib/python3.11/dist-packages (from pandas->CompStats==0.1.7) (2.8.2)\n",
-            "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.11/dist-packages (from pandas->CompStats==0.1.7) (2025.1)\n",
-            "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.11/dist-packages (from pandas->CompStats==0.1.7) (2025.1)\n",
-            "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib!=3.6.1,>=3.4->seaborn>=0.13.0->CompStats==0.1.7) (1.3.1)\n",
-            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.11/dist-packages (from matplotlib!=3.6.1,>=3.4->seaborn>=0.13.0->CompStats==0.1.7) (0.12.1)\n",
-            "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.11/dist-packages (from matplotlib!=3.6.1,>=3.4->seaborn>=0.13.0->CompStats==0.1.7) (4.56.0)\n",
-            "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib!=3.6.1,>=3.4->seaborn>=0.13.0->CompStats==0.1.7) (1.4.8)\n",
-            "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.11/dist-packages (from matplotlib!=3.6.1,>=3.4->seaborn>=0.13.0->CompStats==0.1.7) (24.2)\n",
-            "Requirement already satisfied: pillow>=8 in /usr/local/lib/python3.11/dist-packages (from matplotlib!=3.6.1,>=3.4->seaborn>=0.13.0->CompStats==0.1.7) (11.1.0)\n",
-            "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib!=3.6.1,>=3.4->seaborn>=0.13.0->CompStats==0.1.7) (3.2.1)\n",
-            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.11/dist-packages (from python-dateutil>=2.8.2->pandas->CompStats==0.1.7) (1.17.0)\n",
-            "Building wheels for collected packages: CompStats\n",
-            "  Building wheel for CompStats (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n",
-            "  Created wheel for CompStats: filename=CompStats-0.1.7-py3-none-any.whl size=41028 sha256=e70584ada7f0c49c8768febba12e978c4e122d93bf8452e2d42ea190cc5b1ece\n",
-            "  Stored in directory: /tmp/pip-ephem-wheel-cache-sgv6titu/wheels/4f/d2/a1/8d1d30289bd99417ea947fc1e1f4587404d4e3a043b41f0289\n",
-            "Successfully built CompStats\n",
-            "Installing collected packages: CompStats\n",
-            "Successfully installed CompStats-0.1.7\n"
-          ]
-        }
-      ],
+      "outputs": [],
       "source": [
         "try:\n",
         "  import CompStats\n",
@@ -122,7 +75,7 @@
       "source": [
         "`CompStats.metrics` aims to facilitate performance measurement (with standard errors and confidence intervals) and statistical comparisons between algorithms on a single problem, wrapping the different scores and loss functions found on `metrics`.\n",
         "\n",
-        "To illustrate the use of `CompStats.metrics`, the following snippets show an example. The instructions load the necessary libraries, including the one to obtain the problem (e.g., digits), three different classifiers, and the last line is the score used to measure the performance and compare the algorithm."
+        "To illustrate the use of `CompStats.metrics`, the following snippets show an example. The instructions load the necessary libraries, including the one to obtain the problem (e.g., digits), four different classifiers, and the last line is the score used to measure the performance and compare the algorithm."
       ],
       "metadata": {
         "id": "ZyRCAFoJ3LzP"
@@ -133,7 +86,7 @@
       "source": [
         "from sklearn.svm import LinearSVC\n",
         "from sklearn.naive_bayes import GaussianNB\n",
-        "from sklearn.ensemble import RandomForestClassifier\n",
+        "from sklearn.ensemble import RandomForestClassifier, HistGradientBoostingClassifier\n",
         "from sklearn.datasets import load_digits\n",
         "from sklearn.model_selection import train_test_split\n",
         "from sklearn.base import clone\n",
@@ -142,7 +95,7 @@
       "metadata": {
         "id": "jEpd52Kq214r"
       },
-      "execution_count": 2,
+      "execution_count": 12,
       "outputs": []
     },
     {
@@ -166,7 +119,7 @@
       "metadata": {
         "id": "JGJczaOW3WeK"
       },
-      "execution_count": 3,
+      "execution_count": 13,
       "outputs": []
     },
     {
@@ -189,33 +142,33 @@
           "base_uri": "https://localhost:8080/"
         },
         "id": "Al0u9ZPB3cSj",
-        "outputId": "33d3dc5e-d7c7-4a2e-a3af-284a99935733"
+        "outputId": "6eb7e800-b835-46af-84d8-16c3ad214d58"
       },
-      "execution_count": 4,
+      "execution_count": 14,
       "outputs": [
         {
           "output_type": "stream",
           "name": "stderr",
           "text": [
-            "100%|██████████| 1/1 [00:05<00:00,  5.46s/it]\n"
+            "100%|██████████| 1/1 [00:00<00:00,  1.03it/s]\n"
           ]
         },
         {
           "output_type": "execute_result",
           "data": {
             "text/plain": [
-              "<Perf(score_func=f1_score, statistic=0.9435, se=0.0099)>"
+              "<Perf(score_func=f1_score, statistic=0.9521, se=0.0097)>"
             ]
           },
           "metadata": {},
-          "execution_count": 4
+          "execution_count": 14
         }
       ]
     },
     {
       "cell_type": "markdown",
       "source": [
-        "The previous code shows the macro-f1 score and, in parenthesis, its standard error. The actual performance value is stored in the `Perf.statistic` function."
+        "The previous code shows the macro-f1 score and, in parenthesis, its standard error. The actual performance value is stored in the attributes `statistic` function, and `se`."
       ],
       "metadata": {
         "id": "OV5-SrTh3loq"
@@ -224,26 +177,26 @@
     {
       "cell_type": "code",
       "source": [
-        "score.statistic"
+        "score.statistic, score.se"
       ],
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/"
         },
         "id": "Ye1HH4pn3jde",
-        "outputId": "a0f19b8f-eeb4-46ba-d0a1-8f3d59b67527"
+        "outputId": "3c7c9e30-06fa-4e62-b0ea-6eb53012af01"
       },
-      "execution_count": 5,
+      "execution_count": 15,
       "outputs": [
         {
           "output_type": "execute_result",
           "data": {
             "text/plain": [
-              "0.9434834454375508"
+              "(0.9521479775366307, 0.009717884979482313)"
             ]
           },
           "metadata": {},
-          "execution_count": 5
+          "execution_count": 15
         }
       ]
     },
@@ -267,15 +220,15 @@
           "base_uri": "https://localhost:8080/"
         },
         "id": "vboh7N9B3pDr",
-        "outputId": "980e3a62-1577-425d-ed59-69fbb93c4945"
+        "outputId": "73b9de04-f3b7-4a17-d2a7-09dc453c8f4e"
       },
-      "execution_count": 6,
+      "execution_count": 16,
       "outputs": [
         {
           "output_type": "stream",
           "name": "stderr",
           "text": [
-            "100%|██████████| 1/1 [00:01<00:00,  1.04s/it]\n"
+            "100%|██████████| 1/1 [00:00<00:00,  1.03it/s]\n"
           ]
         },
         {
@@ -285,19 +238,19 @@
               "<Perf(score_func=f1_score)>\n",
               "Statistic with its standard error (se)\n",
               "statistic (se)\n",
-              "0.9655 (0.0077) <= Random Forest\n",
-              "0.9435 (0.0099) <= alg-1"
+              "0.9720 (0.0076) <= Random Forest\n",
+              "0.9521 (0.0097) <= alg-1"
             ]
           },
           "metadata": {},
-          "execution_count": 6
+          "execution_count": 16
         }
       ]
     },
     {
       "cell_type": "markdown",
       "source": [
-        "Let us incorporate another prediction, now with the Naive Bayes classifier, as seen below."
+        "Let us incorporate another predictions, now with Naive Bayes classifier, and Histogram Gradient Boosting as seen below."
       ],
       "metadata": {
         "id": "v2R8F5H73vuc"
@@ -307,22 +260,24 @@
       "cell_type": "code",
       "source": [
         "nb = GaussianNB().fit(X_train, y_train)\n",
-        "score(nb.predict(X_val), name='Naive Bayes')"
+        "score(nb.predict(X_val), name='Naive Bayes')\n",
+        "hist = HistGradientBoostingClassifier().fit(X_train, y_train)\n",
+        "score(hist.predict(X_val), name='Hist. Grad. Boost. Tree')"
       ],
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/"
         },
         "id": "pVOaQb0T3tyN",
-        "outputId": "258373fc-4afb-4442-9e5f-e9fb75d743ef"
+        "outputId": "a38ce6fe-cadd-4f85-d127-423d66c2947b"
       },
-      "execution_count": 7,
+      "execution_count": 17,
       "outputs": [
         {
           "output_type": "stream",
           "name": "stderr",
           "text": [
-            "100%|██████████| 1/1 [00:01<00:00,  1.48s/it]\n"
+            "100%|██████████| 2/2 [00:02<00:00,  1.00s/it]\n"
           ]
         },
         {
@@ -332,20 +287,67 @@
               "<Perf(score_func=f1_score)>\n",
               "Statistic with its standard error (se)\n",
               "statistic (se)\n",
-              "0.9655 (0.0077) <= Random Forest\n",
-              "0.9435 (0.0099) <= alg-1\n",
-              "0.8549 (0.0153) <= Naive Bayes"
+              "0.9759 (0.0068) <= Hist. Grad. Boost. Tree\n",
+              "0.9720 (0.0076) <= Random Forest\n",
+              "0.9521 (0.0097) <= alg-1\n",
+              "0.8266 (0.0159) <= Naive Bayes"
             ]
           },
           "metadata": {},
-          "execution_count": 7
+          "execution_count": 17
         }
       ]
     },
     {
       "cell_type": "markdown",
       "source": [
-        "The final step is to compare the performance of the three classifiers, which can be done with the `Perf.difference` method, as seen next.  "
+        "The performance, its confidence interval (5\\%), and a statistical comparison (5\\%) between the best performing system with the rest of the algorithms is depicted in the following figure."
+      ],
+      "metadata": {
+        "id": "EY2NX9twUWjQ"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "score.plot()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 523
+        },
+        "id": "5hxPgZY-UXCc",
+        "outputId": "068f61bb-e52a-48b3-a0bb-d37eab65b299"
+      },
+      "execution_count": 18,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<seaborn.axisgrid.FacetGrid at 0x7e3d79665250>"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 18
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 623.75x500 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "The final step is to compare the performance of the four classifiers, which can be done with the `Perf.difference` method, as seen next.  "
       ],
       "metadata": {
         "id": "VRqHiUXN32ZX"
@@ -362,22 +364,23 @@
           "base_uri": "https://localhost:8080/"
         },
         "id": "XWAqUpYE3za2",
-        "outputId": "3f108864-6a1f-41bf-dda3-ccab294444e5"
+        "outputId": "2804fcd4-d766-4de5-ee27-276d4d7f3324"
       },
-      "execution_count": 8,
+      "execution_count": 22,
       "outputs": [
         {
           "output_type": "execute_result",
           "data": {
             "text/plain": [
               "<Difference>\n",
-              "difference p-values  w.r.t Random Forest\n",
+              "difference p-values  w.r.t Hist. Grad. Boost. Tree\n",
               "0.0000 <= Naive Bayes\n",
-              "0.0120 <= alg-1"
+              "0.0100 <= alg-1\n",
+              "0.3240 <= Random Forest"
             ]
           },
           "metadata": {},
-          "execution_count": 8
+          "execution_count": 22
         }
       ]
     },
@@ -398,34 +401,33 @@
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/",
-          "height": 546
+          "height": 529
         },
         "id": "Fai01O3q3-SN",
-        "outputId": "eae94c83-bac5-473d-b708-23f549b27b07"
+        "outputId": "a5aaacce-74fc-42dc-86dc-09512421ffbe"
       },
-      "execution_count": 9,
+      "execution_count": 23,
       "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "<seaborn.axisgrid.FacetGrid at 0x7e20698a4d90>"
-            ]
-          },
-          "metadata": {},
-          "execution_count": 9
-        },
         {
           "output_type": "display_data",
           "data": {
             "text/plain": [
-              "<Figure size 584.611x500 with 1 Axes>"
+              "<Figure size 584.875x500 with 1 Axes>"
             ],
-            "image/png": "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\n"
+            "image/png": "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\n"
           },
           "metadata": {}
         }
       ]
+    },
+    {
+      "cell_type": "code",
+      "source": [],
+      "metadata": {
+        "id": "VI3JFKudVYNI"
+      },
+      "execution_count": null,
+      "outputs": []
     }
   ]
 }
\ No newline at end of file
diff --git a/docs/source/digits_difference.png b/docs/source/digits_difference.png
index 608e0b6..74cee9d 100644
Binary files a/docs/source/digits_difference.png and b/docs/source/digits_difference.png differ
diff --git a/docs/source/digits_perf.png b/docs/source/digits_perf.png
new file mode 100644
index 0000000..08ce001
Binary files /dev/null and b/docs/source/digits_perf.png differ
diff --git a/docs/source/metrics_api.rst b/docs/source/metrics_api.rst
index f6f376b..4a600a6 100644
--- a/docs/source/metrics_api.rst
+++ b/docs/source/metrics_api.rst
@@ -27,7 +27,7 @@
 
 :py:mod:`CompStats.metrics` aims to facilitate performance measurement (with standard errors and confidence intervals) and statistical comparisons between algorithms on a single problem, wrapping the different scores and loss functions found on :py:mod:`~sklearn.metrics`.
 
-To illustrate the use of :py:mod:`CompStats.metrics`, the following snippets show an example. The instructions load the necessary libraries, including the one to obtain the problem (e.g., digits), three different classifiers, and the last line is the score used to measure the performance and compare the algorithm. 
+To illustrate the use of :py:mod:`CompStats.metrics`, the following snippets show an example. The instructions load the necessary libraries, including the one to obtain the problem (e.g., digits), four different classifiers, and the last line is the score used to measure the performance and compare the algorithm. 
 
 >>> from sklearn.svm import LinearSVC
 >>> from sklearn.naive_bayes import GaussianNB
@@ -49,45 +49,52 @@ Once the predictions are available, it is time to measure the algorithm's perfor
 
 >>> score = f1_score(y_val, hy, average='macro')
 >>> score
-<Perf>
-Statistic with its standard error (se)
-statistic (se)
-0.9332 (0.0113) <= alg-1
+<Perf(score_func=f1_score, statistic=0.9521, se=0.0097)>
 
-The previous code shows the macro-f1 score and, in parenthesis, its standard error. The actual performance value is stored in the :py:func:`~CompStats.interface.Perf.statistic` function.
+The previous code shows the macro-f1 score and, in parenthesis, its standard error. The actual performance value is stored in the attributes :py:func:`~CompStats.interface.Perf.statistic` and :py:func:`~CompStats.interface.Perf.se`
 
->>> score.statistic
-{'alg-1': 0.9332035615949114}
+>>> score.statistic, score.se
+(0.9521479775366307, 0.009717884979482313)
 
 Continuing with the example, let us assume that one wants to test another classifier on the same problem, in this case, a random forest, as can be seen in the following two lines. The second line predicts the validation set and sets it to the analysis. 
 
 >>> ens = RandomForestClassifier().fit(X_train, y_train)
 >>> score(ens.predict(X_val), name='Random Forest')
-<Perf>
+<Perf(score_func=f1_score)>
 Statistic with its standard error (se)
 statistic (se)
-0.9756 (0.0061) <= Random Forest
-0.9332 (0.0113) <= alg-1
+0.9720 (0.0076) <= Random Forest
+0.9521 (0.0097) <= alg-1
 
-Let us incorporate another prediction, now with the Naive Bayes classifier, as seen below.
+Let us incorporate another predictions, now with Naive Bayes classifier, and Histogram Gradient Boosting as seen below.
 
 >>> nb = GaussianNB().fit(X_train, y_train)
 >>> score(nb.predict(X_val), name='Naive Bayes')
-<Perf>
+>>> hist = HistGradientBoostingClassifier().fit(X_train, y_train)
+>>> score(hist.predict(X_val), name='Hist. Grad. Boost. Tree')
+<Perf(score_func=f1_score)>
 Statistic with its standard error (se)
 statistic (se)
-0.9756 (0.0061) <= Random Forest
-0.9332 (0.0113) <= alg-1
-0.8198 (0.0144) <= Naive Bayes
+0.9759 (0.0068) <= Hist. Grad. Boost. Tree
+0.9720 (0.0076) <= Random Forest
+0.9521 (0.0097) <= alg-1
+0.8266 (0.0159) <= Naive Bayes
+
+The performance, its confidence interval (5%), and a statistical comparison (5%) between the best performing system with the rest of the algorithms is depicted in the following figure.
+
+>>> score.plot()
+
+.. image:: digits_perf.png
 
-The final step is to compare the performance of the three classifiers, which can be done with the :py:func:`~CompStats.interface.Perf.difference` method, as seen next.  
+The final step is to compare the performance of the four classifiers, which can be done with the :py:func:`~CompStats.interface.Perf.difference` method, as seen next.  
 
 >>> diff = score.difference()
 >>> diff
 <Difference>
-difference p-values w.r.t Random Forest
-0.0000 <= alg-1
+difference p-values  w.r.t Hist. Grad. Boost. Tree
 0.0000 <= Naive Bayes
+0.0100 <= alg-1
+0.3240 <= Random Forest
 
 The class :py:class:`~CompStats.Difference` has the :py:class:`~CompStats.Difference.plot` method that can be used to depict the difference with respectto the best.