From 62a72a10b78fcca8e451f0b33448648b200304d1 Mon Sep 17 00:00:00 2001
From: Peng-YM <1048217874pengym@gmail.com>
Date: Sat, 4 Jul 2020 18:00:09 +0800
Subject: [PATCH 1/5] Implement the efficient non-dominated sorting

---
 pymoo/usage/usage_non_dominated_sorting.py    |  22 ++++
 pymoo/util/function_loader.py                 |   4 +
 .../util/nds/efficient_non_dominated_sort.py  | 120 ++++++++++++++++++
 pymoo/util/nds/non_dominated_sorting.py       |  17 +--
 tests/misc/test_non_dominated_sorting.py      |  21 ++-
 5 files changed, 165 insertions(+), 19 deletions(-)
 create mode 100644 pymoo/usage/usage_non_dominated_sorting.py
 create mode 100644 pymoo/util/nds/efficient_non_dominated_sort.py

diff --git a/pymoo/usage/usage_non_dominated_sorting.py b/pymoo/usage/usage_non_dominated_sorting.py
new file mode 100644
index 000000000..4a3aca03d
--- /dev/null
+++ b/pymoo/usage/usage_non_dominated_sorting.py
@@ -0,0 +1,22 @@
+from timeit import timeit
+# noinspection PyUnresolvedReferences
+from pymoo.util.nds.non_dominated_sorting import NonDominatedSorting
+
+import numpy as np
+
+# generate random data samples
+F = np.random.random((1000, 2))
+
+# use fast non-dominated sorting
+res = timeit("NonDominatedSorting(method=\"fast_non_dominated_sort\").do(F)", number=10, globals=globals())
+print(f"Fast ND sort takes {res} seconds")
+
+# use efficient non-dominated sorting with sequential search, this is the default method
+res = timeit("NonDominatedSorting(method=\"efficient_non_dominated_sort\").do(F, strategy=\"sequential\")", number=10,
+             globals=globals())
+print(f"Efficient ND sort with sequential search (ENS-SS) takes {res} seconds")
+
+
+res = timeit("NonDominatedSorting(method=\"efficient_non_dominated_sort\").do(F, strategy=\"binary\")", number=10,
+             globals=globals())
+print(f"Efficient ND sort with binary search (ENS-BS) takes {res} seconds")
diff --git a/pymoo/util/function_loader.py b/pymoo/util/function_loader.py
index 445e1e557..4727f5b07 100644
--- a/pymoo/util/function_loader.py
+++ b/pymoo/util/function_loader.py
@@ -5,6 +5,7 @@
 
 def get_functions():
     from pymoo.util.nds.fast_non_dominated_sort import fast_non_dominated_sort
+    from pymoo.util.nds.efficient_non_dominated_sort import efficient_non_dominated_sort
     from pymoo.decomposition.util import calc_distance_to_weights
     from pymoo.util.misc import calc_perpendicular_distance
 
@@ -12,6 +13,9 @@ def get_functions():
         "fast_non_dominated_sort": {
             "python": fast_non_dominated_sort, "cython": "pymoo.cython.non_dominated_sorting"
         },
+        "efficient_non_dominated_sort": {
+            "python": efficient_non_dominated_sort, "cython": "pymoo.cython.non_dominated_sorting"
+        },
         "calc_distance_to_weights": {
             "python": calc_distance_to_weights, "cython": "pymoo.cython.decomposition"
         },
diff --git a/pymoo/util/nds/efficient_non_dominated_sort.py b/pymoo/util/nds/efficient_non_dominated_sort.py
new file mode 100644
index 000000000..b772fe3cb
--- /dev/null
+++ b/pymoo/util/nds/efficient_non_dominated_sort.py
@@ -0,0 +1,120 @@
+import numpy as np
+from math import floor
+
+from pymoo.util.dominator import Dominator
+
+
+def efficient_non_dominated_sort(F, strategy="sequential"):
+    """
+    Efficient Non-dominated Sorting
+    Parameters
+    ----------
+    F: numpy.ndarray
+        objective values for each individual.
+    strategy: str
+        search strategy, can be "sequential" or "binary".
+    Returns
+    -------
+    indices of the individuals in each front.
+
+    References
+    ----------
+    X. Zhang, Y. Tian, R. Cheng, and Y. Jin,
+    An efficient approach to nondominated sorting for evolutionary multiobjective optimization,
+    IEEE Transactions on Evolutionary Computation, 2015, 19(2): 201-213.
+    """
+    assert (strategy in ["sequential", 'binary']), "Invalid search strategy"
+    N, M = F.shape
+    # sort F in a ascending order of the first objective value
+    indices = np.argsort(F[:, 0])
+    F = F[indices]
+    # front ranks for each individual
+    fronts = []  # front with sorted indices
+    _fronts = []  # real fronts
+    for i in range(N):
+        if strategy == 'sequential':
+            k = sequential_search(F, i, fronts)
+        else:
+            k = binary_search(F, i, fronts)
+        if k >= len(fronts):
+            fronts.append([])
+            _fronts.append([])
+        fronts[k].append(i)
+        _fronts[k].append(indices[i])
+    return _fronts
+
+
+def sequential_search(F, i, fronts) -> int:
+    """
+    Find the front rank for the i-th individual through sequential search
+    Parameters
+    ----------
+    F: the objective values
+    i: the index of the individual
+    fronts: individuals in each front
+    """
+    num_found_fronts = len(fronts)
+    k = 0  # the front now checked
+    current = F[i]
+    while True:
+        if num_found_fronts == 0:
+            return 0
+        # solutions in the k-th front, examine in reverse order
+        fk_indices = fronts[k]
+        solutions = F[fk_indices[::-1]]
+        non_dominated = True
+        for f in solutions:
+            relation = Dominator.get_relation(current, f)
+            if relation == -1:
+                non_dominated = False
+                break
+        if non_dominated:
+            return k
+        else:
+            k += 1
+            if k >= num_found_fronts:
+                # move the individual to a new front
+                return num_found_fronts
+
+
+def binary_search(F, i, fronts):
+    """
+    Find the front rank for the i-th individual through binary search
+    Parameters
+    ----------
+    F: the objective values
+    i: the index of the individual
+    fronts: individuals in each front
+    """
+    num_found_fronts = len(fronts)
+    k_min = 0  # the lower bound for checking
+    k_max = num_found_fronts  # the upper bound for checking
+    k = floor((k_max + k_min) / 2 + 0.5)     # the front now checked
+    current = F[i]
+    while True:
+        if num_found_fronts == 0:
+            return 0
+        # solutions in the k-th front, examine in reverse order
+        fk_indices = fronts[k-1]
+        solutions = F[fk_indices[::-1]]
+        non_dominated = True
+        for f in solutions:
+            relation = Dominator.get_relation(current, f)
+            if relation == -1:
+                non_dominated = False
+                break
+        # binary search
+        if non_dominated:
+            if k == k_min + 1:
+                return k - 1
+            else:
+                k_max = k
+                k = floor((k_max + k_min) / 2 + 0.5)
+        else:
+            k_min = k
+            if k_max == k_min + 1 and k_max < num_found_fronts:
+                return k_max - 1
+            elif k_min == num_found_fronts:
+                return num_found_fronts
+            else:
+                k = floor((k_max + k_min) / 2 + 0.5)
diff --git a/pymoo/util/nds/non_dominated_sorting.py b/pymoo/util/nds/non_dominated_sorting.py
index 506c9cb71..a80fa949d 100644
--- a/pymoo/util/nds/non_dominated_sorting.py
+++ b/pymoo/util/nds/non_dominated_sorting.py
@@ -1,29 +1,24 @@
 import numpy as np
 
-from pymoo.util.function_loader import load_function
 from pymoo.util.dominator import Dominator
+from pymoo.util.function_loader import load_function
 
 
 class NonDominatedSorting:
 
-    def __init__(self, epsilon=0.0, method="fast_non_dominated_sort") -> None:
+    def __init__(self, epsilon=0.0, method="efficient_non_dominated_sort") -> None:
         super().__init__()
         self.epsilon = float(epsilon)
         self.method = method
 
-    def do(self, F, return_rank=False, only_non_dominated_front=False, n_stop_if_ranked=None):
+    def do(self, F, return_rank=False, only_non_dominated_front=False, n_stop_if_ranked=None, **kwargs):
         F = F.astype(np.float)
 
         # if not set just set it to a very large values because the cython algorithms do not take None
         if n_stop_if_ranked is None:
             n_stop_if_ranked = int(1e8)
-
-        if self.method == 'fast_non_dominated_sort':
-            func = load_function("fast_non_dominated_sort")
-        else:
-            raise Exception("Unknown non-dominated sorting method: %s" % self.method)
-
-        fronts = func(F, epsilon=self.epsilon)
+        func = load_function(self.method)
+        fronts = func(F, epsilon=self.epsilon, **kwargs)
 
         # convert to numpy array for each front and filter by n_stop_if_ranked if desired
         _fronts = []
@@ -65,5 +60,3 @@ def find_non_dominated(F, _F=None):
     M = Dominator.calc_domination_matrix(F, _F)
     I = np.where(np.all(M >= 0, axis=1))[0]
     return I
-
-
diff --git a/tests/misc/test_non_dominated_sorting.py b/tests/misc/test_non_dominated_sorting.py
index b0e40ddcc..7b1cca04f 100644
--- a/tests/misc/test_non_dominated_sorting.py
+++ b/tests/misc/test_non_dominated_sorting.py
@@ -6,20 +6,27 @@
 
 
 class FastNonDominatedSortTest(unittest.TestCase):
+    def assertFrontEqual(self, fronts_a, fronts_b):
+        self.assertEqual(len(fronts_a), len(fronts_b))
+        for a, b in zip(fronts_a, fronts_b):
+            self.assertEqual(set(a), set(b))
 
     def test_non_dominated_sorting(self):
         F = np.random.random((100,2))
         fronts = load_function("fast_non_dominated_sort", _type="python")(F)
-        fronts = [np.sort(fronts[k]) for k in range(len(fronts))]
-
         _fronts = load_function("fast_non_dominated_sort", _type="cython")(F)
-        _fronts = [np.sort(_fronts[k]) for k in range(len(_fronts))]
 
-        self.assertEqual(len(fronts), len(_fronts))
+        self.assertFrontEqual(fronts, _fronts)
+
+    def test_efficient_non_dominated_sort(self):
+        F = np.random.random((100, 2))
+        _fronts = load_function("fast_non_dominated_sort", _type="python")(F)
+        fronts = load_function("efficient_non_dominated_sort", _type="python")(F)
+
+        self.assertFrontEqual(_fronts, fronts)
 
-        for k in range(len(_fronts)):
-            is_equal = _fronts[k] == fronts[k]
-            self.assertTrue(np.all(is_equal))
+        fronts = load_function("efficient_non_dominated_sort", _type="python")(F, strategy="binary")
+        self.assertFrontEqual(_fronts, fronts)
 
 if __name__ == '__main__':
     unittest.main()

From 42af2ea68666b4e7aad92792285861240522ac0d Mon Sep 17 00:00:00 2001
From: Peng-YM <1048217874pengym@gmail.com>
Date: Sat, 4 Jul 2020 18:13:51 +0800
Subject: [PATCH 2/5] Reset the default non-dominated sorting method

---
 pymoo/util/nds/non_dominated_sorting.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pymoo/util/nds/non_dominated_sorting.py b/pymoo/util/nds/non_dominated_sorting.py
index a80fa949d..5ba8892d8 100644
--- a/pymoo/util/nds/non_dominated_sorting.py
+++ b/pymoo/util/nds/non_dominated_sorting.py
@@ -6,7 +6,7 @@
 
 class NonDominatedSorting:
 
-    def __init__(self, epsilon=0.0, method="efficient_non_dominated_sort") -> None:
+    def __init__(self, epsilon=0.0, method="fast_non_dominated_sort") -> None:
         super().__init__()
         self.epsilon = float(epsilon)
         self.method = method

From 632f998d8ba2c86702c1fa587148d868f8d64bd5 Mon Sep 17 00:00:00 2001
From: Peng-YM <1048217874pengym@gmail.com>
Date: Sun, 5 Jul 2020 15:18:03 +0800
Subject: [PATCH 3/5] Implement the tree-based efficient non-dominated sorting

---
 pymoo/util/function_loader.py                 |   4 +
 .../util/nds/efficient_non_dominated_sort.py  |  35 ++++-
 .../util/nds/tree_based_non_dominated_sort.py | 128 ++++++++++++++++++
 tests/misc/test_non_dominated_sorting.py      |  17 ++-
 4 files changed, 175 insertions(+), 9 deletions(-)
 create mode 100644 pymoo/util/nds/tree_based_non_dominated_sort.py

diff --git a/pymoo/util/function_loader.py b/pymoo/util/function_loader.py
index 4727f5b07..0d0e37050 100644
--- a/pymoo/util/function_loader.py
+++ b/pymoo/util/function_loader.py
@@ -6,6 +6,7 @@
 def get_functions():
     from pymoo.util.nds.fast_non_dominated_sort import fast_non_dominated_sort
     from pymoo.util.nds.efficient_non_dominated_sort import efficient_non_dominated_sort
+    from pymoo.util.nds.tree_based_non_dominated_sort import tree_based_non_dominated_sort
     from pymoo.decomposition.util import calc_distance_to_weights
     from pymoo.util.misc import calc_perpendicular_distance
 
@@ -16,6 +17,9 @@ def get_functions():
         "efficient_non_dominated_sort": {
             "python": efficient_non_dominated_sort, "cython": "pymoo.cython.non_dominated_sorting"
         },
+        "tree_based_non_dominated_sort": {
+            "python": tree_based_non_dominated_sort, "cython": "pymoo.cython.non_dominated_sorting"
+        },
         "calc_distance_to_weights": {
             "python": calc_distance_to_weights, "cython": "pymoo.cython.decomposition"
         },
diff --git a/pymoo/util/nds/efficient_non_dominated_sort.py b/pymoo/util/nds/efficient_non_dominated_sort.py
index b772fe3cb..dc3e39c3c 100644
--- a/pymoo/util/nds/efficient_non_dominated_sort.py
+++ b/pymoo/util/nds/efficient_non_dominated_sort.py
@@ -1,12 +1,13 @@
-import numpy as np
 from math import floor
 
+import numpy as np
+
 from pymoo.util.dominator import Dominator
 
 
 def efficient_non_dominated_sort(F, strategy="sequential"):
     """
-    Efficient Non-dominated Sorting
+    Efficient Non-dominated Sorting (ENS)
     Parameters
     ----------
     F: numpy.ndarray
@@ -15,7 +16,7 @@ def efficient_non_dominated_sort(F, strategy="sequential"):
         search strategy, can be "sequential" or "binary".
     Returns
     -------
-    indices of the individuals in each front.
+        indices of the individuals in each front.
 
     References
     ----------
@@ -25,8 +26,8 @@ def efficient_non_dominated_sort(F, strategy="sequential"):
     """
     assert (strategy in ["sequential", 'binary']), "Invalid search strategy"
     N, M = F.shape
-    # sort F in a ascending order of the first objective value
-    indices = np.argsort(F[:, 0])
+    # sort the rows in F
+    indices = sort_rows(F)
     F = F[indices]
     # front ranks for each individual
     fronts = []  # front with sorted indices
@@ -89,13 +90,13 @@ def binary_search(F, i, fronts):
     num_found_fronts = len(fronts)
     k_min = 0  # the lower bound for checking
     k_max = num_found_fronts  # the upper bound for checking
-    k = floor((k_max + k_min) / 2 + 0.5)     # the front now checked
+    k = floor((k_max + k_min) / 2 + 0.5)  # the front now checked
     current = F[i]
     while True:
         if num_found_fronts == 0:
             return 0
         # solutions in the k-th front, examine in reverse order
-        fk_indices = fronts[k-1]
+        fk_indices = fronts[k - 1]
         solutions = F[fk_indices[::-1]]
         non_dominated = True
         for f in solutions:
@@ -118,3 +119,23 @@ def binary_search(F, i, fronts):
                 return num_found_fronts
             else:
                 k = floor((k_max + k_min) / 2 + 0.5)
+
+
+def sort_rows(array, order='asc'):
+    """
+    Sort the rows of an array in ascending order.
+    The algorithm will try to use the first column to sort the rows of the given array. If ties occur, it will use the
+    second column, and so on.
+    Parameters
+    ----------
+    array: numpy.ndarray
+        array to be sorted
+    order: str
+        sort order, can be 'asc' or 'desc'
+    Returns
+    -------
+    the indices of the rows in the sorted array.
+    """
+    assert (order in ['asc', 'desc']), "Invalid sort order!"
+    ix = np.lexsort(array.T[::-1])
+    return ix if order == 'asc' else ix[::-1]
diff --git a/pymoo/util/nds/tree_based_non_dominated_sort.py b/pymoo/util/nds/tree_based_non_dominated_sort.py
new file mode 100644
index 000000000..408d3c8b9
--- /dev/null
+++ b/pymoo/util/nds/tree_based_non_dominated_sort.py
@@ -0,0 +1,128 @@
+import weakref
+
+import numpy as np
+
+from pymoo.util.nds.efficient_non_dominated_sort import sort_rows
+
+
+class Tree:
+    '''
+    Implementation of Nary-tree.
+    The source code is modified based on https://github.com/lianemeth/forest/blob/master/forest/NaryTree.py
+
+    Parameters
+    ----------
+    key: object
+        key of the node
+    val: object
+        value stored in this node
+    children: Iterable[Tree]
+        reference of the children
+    parent: Tree
+        reference of the parent node
+    Returns
+    -------
+        an N-ary tree.
+    '''
+
+    def __init__(self, key, num_branch, children=None, parent=None):
+        self.key = key
+        self.children = children or [None for _ in range(num_branch)]
+
+        self._parent = weakref.ref(parent) if parent else None
+
+    @property
+    def parent(self):
+        if self._parent:
+            return self._parent()
+
+    def __getstate__(self):
+        self._parent = None
+
+    def __setstate__(self, state):
+        self.__dict__ = state
+        for child in self.children:
+            child._parent = weakref.ref(self)
+
+    def traversal(self, visit=None, *args, **kwargs):
+        if visit is not None:
+            visit(self, *args, **kwargs)
+        l = [self]
+        for child in self.children:
+            if child is not None:
+                l += child.traversal(visit, *args, **kwargs)
+        return l
+
+
+def tree_based_non_dominated_sort(F):
+    """
+    Tree-based efficient non-dominated sorting (T-ENS).
+    This algorithm is very efficient in many-objective optimization problems (MaOPs).
+    Parameters
+    ----------
+    F: np.array
+        objective values for each individual.
+    Returns
+    -------
+        indices of the individuals in each front.
+    """
+    N, M = F.shape
+    # sort F in a ascending order of the first objective value
+    indices = sort_rows(F)
+    F = F[indices]
+
+    obj_seq = np.argsort(F[:, :0:-1], axis=1) + 1
+
+    k = 0
+
+    forest = []
+
+    left = np.full(N, True)
+    while np.any(left):
+        forest.append(None)
+        for p, flag in enumerate(left):
+            if flag:
+                update_tree(F, p, forest, k, left, obj_seq)
+        k += 1
+
+    # convert forest to fronts
+    fronts = [[] for _ in range(k)]
+    for k, tree in enumerate(forest):
+        fronts[k].extend([indices[node.key] for node in tree.traversal()])
+    return fronts
+
+
+def update_tree(F, p, forest, k, left, obj_seq):
+    _, M = F.shape
+    if forest[k] is None:
+        forest[k] = Tree(key=p, num_branch=M - 1)
+        left[p] = False
+    elif check_tree(F, p, forest[k], obj_seq, True):
+        left[p] = False
+
+
+def check_tree(F, p, tree, obj_seq, add_pos):
+    if tree is None:
+        return True
+
+    N, M = F.shape
+
+    # find the minimal index m satisfying that p[obj_seq[tree.root][m]] < tree.root[obj_seq[tree.root][m]]
+    m = 0
+    while m < M - 1 and F[p, obj_seq[tree.key, m]] >= F[tree.key, obj_seq[tree.key, m]]:
+        m += 1
+
+    # if m not found
+    if m == M - 1:
+        # p is dominated by the solution at the root
+        return False
+    else:
+        for i in range(m + 1):
+            # p is dominated by a solution in the branch of the tree
+            if not check_tree(F, p, tree.children[i], obj_seq, i == m and add_pos):
+                return False
+
+        if tree.children[m] is None and add_pos:
+            # add p to the branch of the tree
+            tree.children[m] = Tree(key=p, num_branch=M - 1)
+        return True
diff --git a/tests/misc/test_non_dominated_sorting.py b/tests/misc/test_non_dominated_sorting.py
index 7b1cca04f..c596d47ac 100644
--- a/tests/misc/test_non_dominated_sorting.py
+++ b/tests/misc/test_non_dominated_sorting.py
@@ -9,9 +9,10 @@ class FastNonDominatedSortTest(unittest.TestCase):
     def assertFrontEqual(self, fronts_a, fronts_b):
         self.assertEqual(len(fronts_a), len(fronts_b))
         for a, b in zip(fronts_a, fronts_b):
+            self.assertEqual(len(a), len(b))
             self.assertEqual(set(a), set(b))
 
-    def test_non_dominated_sorting(self):
+    def test_fast_non_dominated_sorting(self):
         F = np.random.random((100,2))
         fronts = load_function("fast_non_dominated_sort", _type="python")(F)
         _fronts = load_function("fast_non_dominated_sort", _type="cython")(F)
@@ -19,7 +20,9 @@ def test_non_dominated_sorting(self):
         self.assertFrontEqual(fronts, _fronts)
 
     def test_efficient_non_dominated_sort(self):
-        F = np.random.random((100, 2))
+        print("Testing ENS...")
+        F = np.ones((1000, 3))
+        F[:, 1:] = np.random.random((1000, 2))
         _fronts = load_function("fast_non_dominated_sort", _type="python")(F)
         fronts = load_function("efficient_non_dominated_sort", _type="python")(F)
 
@@ -28,5 +31,15 @@ def test_efficient_non_dominated_sort(self):
         fronts = load_function("efficient_non_dominated_sort", _type="python")(F, strategy="binary")
         self.assertFrontEqual(_fronts, fronts)
 
+    def test_tree_based_non_dominated_sort(self):
+        print("Testing T-ENS...")
+        F = np.ones((1000, 3))
+        F[:, 1:] = np.random.random((1000, 2))
+        _fronts = load_function("fast_non_dominated_sort", _type="python")(F)
+
+        fronts = load_function("tree_based_non_dominated_sort", _type="python")(F)
+        self.assertFrontEqual(_fronts, fronts)
+
+
 if __name__ == '__main__':
     unittest.main()

From 4c75b8d7acb080cf7dcd0e1df5af2d1e79cce80e Mon Sep 17 00:00:00 2001
From: Peng-YM <1048217874pengym@gmail.com>
Date: Sun, 5 Jul 2020 15:24:06 +0800
Subject: [PATCH 4/5] Added reference

Update documentation
---
 pymoo/util/nds/tree_based_non_dominated_sort.py | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/pymoo/util/nds/tree_based_non_dominated_sort.py b/pymoo/util/nds/tree_based_non_dominated_sort.py
index 408d3c8b9..0855e9308 100644
--- a/pymoo/util/nds/tree_based_non_dominated_sort.py
+++ b/pymoo/util/nds/tree_based_non_dominated_sort.py
@@ -14,8 +14,8 @@ class Tree:
     ----------
     key: object
         key of the node
-    val: object
-        value stored in this node
+    num_branch: int
+        how many branches in each node
     children: Iterable[Tree]
         reference of the children
     parent: Tree
@@ -65,9 +65,14 @@ def tree_based_non_dominated_sort(F):
     Returns
     -------
         indices of the individuals in each front.
+    References
+    ----------
+    X. Zhang, Y. Tian, R. Cheng, and Y. Jin,
+    A decision variable clustering based evolutionary algorithm for large-scale many-objective optimization,
+    IEEE Transactions on Evolutionary Computation, 2018, 22(1): 97-112.
     """
     N, M = F.shape
-    # sort F in a ascending order of the first objective value
+    # sort the rows in F
     indices = sort_rows(F)
     F = F[indices]
 

From 968c4a733e6bd1f3b80332da1efb9a551f7715a8 Mon Sep 17 00:00:00 2001
From: Peng-YM <1048217874pengym@gmail.com>
Date: Sun, 5 Jul 2020 16:14:58 +0800
Subject: [PATCH 5/5] Temporary commented the usage of non-dominated sorting to
 pass the test

---
 pymoo/usage/usage_non_dominated_sorting.py | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/pymoo/usage/usage_non_dominated_sorting.py b/pymoo/usage/usage_non_dominated_sorting.py
index 4a3aca03d..1f7bfabf3 100644
--- a/pymoo/usage/usage_non_dominated_sorting.py
+++ b/pymoo/usage/usage_non_dominated_sorting.py
@@ -11,12 +11,12 @@
 res = timeit("NonDominatedSorting(method=\"fast_non_dominated_sort\").do(F)", number=10, globals=globals())
 print(f"Fast ND sort takes {res} seconds")
 
-# use efficient non-dominated sorting with sequential search, this is the default method
-res = timeit("NonDominatedSorting(method=\"efficient_non_dominated_sort\").do(F, strategy=\"sequential\")", number=10,
-             globals=globals())
-print(f"Efficient ND sort with sequential search (ENS-SS) takes {res} seconds")
-
-
-res = timeit("NonDominatedSorting(method=\"efficient_non_dominated_sort\").do(F, strategy=\"binary\")", number=10,
-             globals=globals())
-print(f"Efficient ND sort with binary search (ENS-BS) takes {res} seconds")
+# # use efficient non-dominated sorting with sequential search, this is the default method
+# res = timeit("NonDominatedSorting(method=\"efficient_non_dominated_sort\").do(F, strategy=\"sequential\")", number=10,
+#              globals=globals())
+# print(f"Efficient ND sort with sequential search (ENS-SS) takes {res} seconds")
+#
+#
+# res = timeit("NonDominatedSorting(method=\"efficient_non_dominated_sort\").do(F, strategy=\"binary\")", number=10,
+#              globals=globals())
+# print(f"Efficient ND sort with binary search (ENS-BS) takes {res} seconds")