Base LDS and LNDS on longest increasing subsequence

Author: Morwenn

include/cpp-sort/detail/longest_non_descending_subsequence.h renamed to include/cpp-sort/detail/longest_increasing_subsequence.h

@@ -2,8 +2,8 @@
  * Copyright (c) 2021-2025 Morwenn
  * SPDX-License-Identifier: MIT
  */
-#ifndef CPPSORT_DETAIL_LONGEST_NON_DESCENDING_SUBSEQUENCE_H_
-#define CPPSORT_DETAIL_LONGEST_NON_DESCENDING_SUBSEQUENCE_H_
+#ifndef CPPSORT_DETAIL_LONGEST_INCREASING_SUBSEQUENCE_H_
+#define CPPSORT_DETAIL_LONGEST_INCREASING_SUBSEQUENCE_H_
 
 ////////////////////////////////////////////////////////////
 // Headers
@@ -15,23 +15,23 @@
 #include <cpp-sort/utility/as_function.h>
 #include <cpp-sort/utility/functional.h>
 #include "iterator_traits.h"
-#include "upper_bound.h"
+#include "lower_bound.h"
 
 namespace cppsort::detail
 {
-    // Longest non-decreasing subsequence, computed with an altered
+    // Longest increasing subsequence, computed with an altered
     // patience sorting algorithm - returns a pair containing the
-    // size of the LNDS and the size of the collection
+    // size of the LIS and the size of the collection
 
     template<
         bool RecomputeSize,
         typename ForwardIterator,
         typename Compare,
         typename Projection
     >
-    auto longest_non_descending_subsequence(ForwardIterator first, ForwardIterator last,
-                                            difference_type_t<ForwardIterator> size,
-                                            Compare compare, Projection projection)
+    auto longest_increasing_subsequence(ForwardIterator first, ForwardIterator last,
+                                        difference_type_t<ForwardIterator> size,
+                                        Compare compare, Projection projection)
         -> std::pair<difference_type_t<ForwardIterator>, difference_type_t<ForwardIterator>>
     {
         constexpr bool is_random_access = std::is_base_of_v<
@@ -59,18 +59,18 @@ namespace cppsort::detail
         // Top (smaller) elements in patience sorting stacks
         std::vector<ForwardIterator> stack_tops;
 
-        while (first != last) {
-            auto it = detail::upper_bound(
+        do {
+            auto it = detail::lower_bound(
                 stack_tops.begin(), stack_tops.end(),
                 proj(*first), compare, utility::indirect{} | projection);
 
             if (it == stack_tops.end()) {
-                // The element is bigger than everything else,
+                // The element is strictly bigger than everything else,
                 // create a new "stack" to put it
                 stack_tops.emplace_back(first);
             } else {
-                // The element is strictly smaller than the top
-                // of a given stack, replace the stack top
+                // The element is strictly smaller than or equal to
+                // the top of a given stack, replace the stack top
                 *it = first;
             }
             ++first;
@@ -79,10 +79,10 @@ namespace cppsort::detail
                 // Compute the size as-we-go if iterators are not random-access
                 ++size;
             }
-        }
+        } while (first != last);
 
         return { stack_tops.size(), size };
     }
 }
 
-#endif // CPPSORT_DETAIL_LONGEST_NON_DESCENDING_SUBSEQUENCE_H_
+#endif // CPPSORT_DETAIL_LONGEST_INCREASING_SUBSEQUENCE_H_

include/cpp-sort/probes/rem.h

@@ -11,11 +11,13 @@
 #include <functional>
 #include <iterator>
 #include <utility>
+#include <cpp-sort/comparators/flip.h>
+#include <cpp-sort/comparators/not_fn.h>
 #include <cpp-sort/sorter_facade.h>
 #include <cpp-sort/sorter_traits.h>
 #include <cpp-sort/utility/functional.h>
 #include <cpp-sort/utility/size.h>
-#include "../detail/longest_non_descending_subsequence.h"
+#include "../detail/longest_increasing_subsequence.h"
 #include "../detail/type_traits.h"
 
 namespace cppsort::probe
@@ -49,10 +51,10 @@ namespace cppsort::probe
                 // with the assumption that it's better than O(n) - which is at least
                 // consistent as far as the standard library is concerned. We also
                 // handle C arrays whose size is known and part of the type.
-                auto res = cppsort::detail::longest_non_descending_subsequence<false>(
+                auto res = cppsort::detail::longest_increasing_subsequence<false>(
                     std::begin(range), std::end(range),
                     utility::size(range),
-                    std::move(compare), std::move(projection)
+                    cppsort::not_fn(cppsort::flip(compare)), std::move(projection)
                 );
                 auto lnds_size = res.second - res.first;
                 return lnds_size >= 0 ? lnds_size : 0;
@@ -73,8 +75,9 @@ namespace cppsort::probe
                 // We give 0 as a "dummy" value since it will be recomputed, but it
                 // is also used by the non-random-access iterators version as the
                 // initial value used for the size count
-                auto res = cppsort::detail::longest_non_descending_subsequence<true>(
-                    first, last, 0, std::move(compare), std::move(projection)
+                auto res = cppsort::detail::longest_increasing_subsequence<true>(
+                    first, last, 0,
+                    cppsort::not_fn(cppsort::flip(compare)), std::move(projection)
                 );
                 auto lnds_size = res.second - res.first;
                 return lnds_size >= 0 ? lnds_size : 0;

include/cpp-sort/probes/sus.h

@@ -10,11 +10,11 @@
 ////////////////////////////////////////////////////////////
 #include <functional>
 #include <utility>
-#include <cpp-sort/comparators/not_fn.h>
+#include <cpp-sort/comparators/flip.h>
 #include <cpp-sort/sorter_facade.h>
 #include <cpp-sort/sorter_traits.h>
 #include <cpp-sort/utility/functional.h>
-#include "../detail/longest_non_descending_subsequence.h"
+#include "../detail/longest_increasing_subsequence.h"
 #include "../detail/type_traits.h"
 
 namespace cppsort::probe
@@ -37,10 +37,10 @@ namespace cppsort::probe
             {
                 // We don't need the size information, so we can avoid
                 // computing it altogether
-                auto res = cppsort::detail::longest_non_descending_subsequence<false>(
+                auto res = cppsort::detail::longest_increasing_subsequence<false>(
                     first, last,
                     0, // Dummy value, not useful here
-                    cppsort::not_fn(compare), std::move(projection)
+                    cppsort::flip(compare), std::move(projection)
                 );
                 return res.first > 0 ? res.first - 1 : 0;
             }