From ccb88c6830acfd812cacfaae0d9f2fef5ed66540 Mon Sep 17 00:00:00 2001
From: Hossein Moein <myseajune@aol.com>
Date: Mon, 1 Jan 2024 12:04:29 -0500
Subject: [PATCH 1/5] Streamlined paralle computing logic in code

---
 docs/HTML/DataFrame.html                      |   5 +-
 examples/hello_world.cc                       |   2 +-
 include/DataFrame/Internals/DataFrame.tcc     | 124 +++++++++++-------
 include/DataFrame/Internals/DataFrame_get.tcc |  85 +++++++++---
 4 files changed, 147 insertions(+), 69 deletions(-)

diff --git a/docs/HTML/DataFrame.html b/docs/HTML/DataFrame.html
index f788782f..b0546aef 100644
--- a/docs/HTML/DataFrame.html
+++ b/docs/HTML/DataFrame.html
@@ -1440,7 +1440,7 @@ <H2><font color="blue">API Reference with code samples</font></H2>
 <BR><HR COLOR="Orange" SIZE="5">
 
   <H2><font color="blue">Multithreading</font></H2>
-    In general, multithreading could be very tricky. A lot of times you think by using multithreading you enhance the performance of your program. But in fact, you are hindering it. It requires measuring and careful adjustments. It is recommended to start with a single-threaded version and when that is <I>working correctly</I>, take measurements and adjust to move to multithreading version.<BR>
+    In general, multithreading could be very unintuitive. Often you think by using multithreading you enhance the performance of your program. But in fact, you are hindering it. It requires measuring and careful adjustments. It is recommended to start with a single-threaded version and when that is <I>working correctly</I>, take measurements and adjust to move to multithreading version.<BR>
 DataFrame uses multithreading extensively and provides granular tools to adjust your environment. Let’s divide the multithreading subject in DataFrame into two categories:<BR>
 
   <H4>1. User Multithreading</H4>
@@ -1450,7 +1450,8 @@ <H4>1. User Multithreading</H4>
       <LI>In addition, instances of DataFrame are not multithreaded safe either. In other words, a single instance of DataFrame must not be used in multiple threads without protection, unless it is used as read-only.</LI>
     </UL>
   <H4>2. DataFrame Internal Multithreading</H4>
-  Whether or not you, as the user, use multithreading, DataFrame utilizes a versatile thread-pool to employ parallel computing extensively in almost all its functionalities. By default, there is no multithreading. All algorithms execute their single-threaded version. To enable multithreading, call either <I>ThreadGranularity::set_optimum_thread_level()</I> (recommended) or <I>ThreadGranularity::set_thread_level(n)</I>. When Multithreading is enabled, most parallel algorithms trigger when number of data points exceeds 250k and number of threads exceeds 2.<BR>
+  Whether or not you, as the user, use multithreading, DataFrame utilizes a versatile thread-pool to employ parallel computing extensively in almost all its API's. By default, there is no multithreading. All algorithms execute their single-threaded version. To enable multithreading, call either <I>ThreadGranularity::set_optimum_thread_level()</I> (recommended) or <I>ThreadGranularity::set_thread_level(n)</I>.<BR>
+  When Multithreading is enabled, most parallel algorithms trigger when number of data points exceeds 250k and number of threads exceeds 2. Therefore, if your process deals with datasets smaller than this, it doesn't make sense to populate the thread-pool with threads as they will be waste of resources.<BR>
   You do not need to worry about synchronization for DataFrame internal multithreading. It is done behind the scenes and unbeknown to you.<BR>
   <UL>
     <LI> There are asynchronous versions of some methods. For example, you have sort()/sort_async(), visit()/visit_async(), ... The latter versions return a std::future and would execute in parallel.<BR>If you chose to use DataFrame async interfaces, it is highly recommended to call <I>ThreadGranularity::set_optimum_thread_level()</I>, So your thread-pool is populated with optimal number of threads. Otherwise, if thread-pool is empty, async interfaces will add one thread to it. Having only one thread in thread-pool could be suboptimal and hinder performance.</LI>
diff --git a/examples/hello_world.cc b/examples/hello_world.cc
index 3a9b8fc8..ecba3111 100644
--- a/examples/hello_world.cc
+++ b/examples/hello_world.cc
@@ -73,7 +73,7 @@ int main(int, char *[])  {
     // it is recommended to call the following at the beginning of your program.
     //
     // NOTE: make sure you read and understand the Multithreading section
-    //       in the documentations.
+    //       in the documentations (threads could potentially hinder performance).
     //
     ThreadGranularity::set_optimum_thread_level();
 
diff --git a/include/DataFrame/Internals/DataFrame.tcc b/include/DataFrame/Internals/DataFrame.tcc
index f8b1a364..f89f1c06 100644
--- a/include/DataFrame/Internals/DataFrame.tcc
+++ b/include/DataFrame/Internals/DataFrame.tcc
@@ -129,9 +129,12 @@ DataFrame<I, H>::shuffle(const StlVecType<const char *> &col_names,
     std::random_device  rd;
     std::mt19937        g ((seed != seed_t(-1)) ? seed : rd());
     std::future<void>   idx_future;
+    const auto          thread_level =
+        (indices_.size() < ThreadPool::MUL_THR_THHOLD)
+            ? 0L : get_thread_level();
 
     if (also_shuffle_index)  {
-        if (get_thread_level() > 2)  {
+        if (thread_level > 2)  {
             auto    lbd = [&g, this] () -> void  {
                 std::shuffle(this->indices_.begin(), this->indices_.end(), g);
             };
@@ -160,7 +163,7 @@ DataFrame<I, H>::shuffle(const StlVecType<const char *> &col_names,
         };
     const SpinGuard             guard (lock_);
 
-    if (get_thread_level() > 2)  {
+    if (thread_level > 2)  {
         std::vector<std::future<void>>  futures;
 
         futures.reserve(col_names.size());
@@ -412,16 +415,18 @@ fill_missing(const StlVecType<const char *> &col_names,
         throw NotImplemented(buffer);
     }
 
-    const size_type                     count = col_names.size();
-    const ThreadGranularity::size_type  thread_count = get_thread_level();
-    StlVecType<std::future<void>>       futures;
+    const size_type                 count = col_names.size();
+    const auto                      thread_level =
+        (indices_.size() < ThreadPool::MUL_THR_THHOLD)
+            ? 0L : get_thread_level();
+    StlVecType<std::future<void>>   futures;
 
-    if (thread_count > 1)
+    if (thread_level > 2)
         futures.reserve(count);
     for (size_type i = 0; i < count; ++i)  {
         ColumnVecType<T>    &vec = get_column<T>(col_names[i]);
 
-        if (thread_count == 0)  {
+        if (thread_level <= 2)  {
             if (fp == fill_policy::value)
                 fill_missing_value_(vec, values[i], limit, indices_.size());
             else if (fp == fill_policy::fill_forward)
@@ -539,10 +544,12 @@ drop_missing(drop_policy policy, size_type threshold)  {
 
     DropRowMap                      missing_row_map;
     const size_type                 num_cols = data_.size();
-    const size_type                 thread_level = get_thread_level();
+    const auto                      thread_level =
+        (indices_.size() < ThreadPool::MUL_THR_THHOLD)
+            ? 0L : get_thread_level();
     std::vector<std::future<void>>  futures;
 
-    if (thread_level > 1)  futures.reserve(num_cols + 1);
+    if (thread_level > 2)  futures.reserve(num_cols + 1);
 
     map_missing_rows_functor_<Ts ...>   functor (
         indices_.size(), missing_row_map);
@@ -551,7 +558,7 @@ drop_missing(drop_policy policy, size_type threshold)  {
     for (size_type idx = 0; idx < num_cols; ++idx)
         data_[idx].change(functor);
 
-    if (thread_level > 1)
+    if (thread_level > 2)
         futures.emplace_back(
             thr_pool_.dispatch(
                 false,
@@ -688,9 +695,12 @@ void DataFrame<I, H>::shrink_to_fit ()  {
     indices_.shrink_to_fit();
 
     shrink_to_fit_functor_<Ts ...>  functor;
+    const auto                      thread_level =
+        (indices_.size() < ThreadPool::MUL_THR_THHOLD)
+            ? 0L : get_thread_level();
     const SpinGuard                 guard(lock_);
 
-    if (get_thread_level() > 2)  {
+    if (thread_level > 2)  {
         auto    lbd =
             [&functor](const auto &begin, const auto &end) -> void  {
                 for (auto citer = begin; citer < end; ++citer)
@@ -745,11 +755,13 @@ sort(const char *name, sort_spec dir, bool ignore_index)  {
 
     std::iota(sorting_idxs.begin(), sorting_idxs.end(), 0);
 
-    auto    zip = std::ranges::views::zip(*vec, sorting_idxs);
-    auto    zip_idx = std::ranges::views::zip(*vec, indices_, sorting_idxs);
+    auto        zip = std::ranges::views::zip(*vec, sorting_idxs);
+    auto        zip_idx = std::ranges::views::zip(*vec, indices_, sorting_idxs);
+    const auto  thread_level =
+        (idx_s < ThreadPool::MUL_THR_THHOLD) ? 0L : get_thread_level();
 
     if (dir == sort_spec::ascen)  {
-        if (get_thread_level() > 1 && idx_s > ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             if (! ignore_index)
                 thr_pool_.parallel_sort(zip_idx.begin(), zip_idx.end(), a);
             else
@@ -763,7 +775,7 @@ sort(const char *name, sort_spec dir, bool ignore_index)  {
         }
     }
     else if (dir == sort_spec::desce)  {
-        if (get_thread_level() > 1 && idx_s > ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             if (! ignore_index)
                 thr_pool_.parallel_sort(zip_idx.begin(), zip_idx.end(), d);
             else
@@ -777,7 +789,7 @@ sort(const char *name, sort_spec dir, bool ignore_index)  {
         }
     }
     else if (dir == sort_spec::abs_ascen)  {
-        if (get_thread_level() > 1 && idx_s > ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             if (! ignore_index)
                 thr_pool_.parallel_sort(zip_idx.begin(), zip_idx.end(), aa);
             else
@@ -791,7 +803,7 @@ sort(const char *name, sort_spec dir, bool ignore_index)  {
         }
     }
     else if (dir == sort_spec::abs_desce)  {
-        if (get_thread_level() > 1 && idx_s > ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             if (! ignore_index)
                 thr_pool_.parallel_sort(zip_idx.begin(), zip_idx.end(), ad);
             else
@@ -805,7 +817,7 @@ sort(const char *name, sort_spec dir, bool ignore_index)  {
         }
     }
 
-    if (get_thread_level() > 1 && ((column_list_.size() - 1) > 1))  {
+    if (((column_list_.size() - 1) > 1) && get_thread_level() > 2)  {
         auto    lbd = [name,
                        &sorting_idxs = std::as_const(sorting_idxs),
                        idx_s, this]
@@ -995,12 +1007,14 @@ sort(const char *name1, sort_spec dir1,
 
     std::iota(sorting_idxs.begin(), sorting_idxs.end(), 0);
 
-    auto    zip = std::ranges::views::zip(*vec1, *vec2, sorting_idxs);
-    auto    zip_idx =
+    auto        zip = std::ranges::views::zip(*vec1, *vec2, sorting_idxs);
+    auto        zip_idx =
         std::ranges::views::zip(*vec1, *vec2, indices_, sorting_idxs);
+    const auto  thread_level =
+        (idx_s < ThreadPool::MUL_THR_THHOLD) ? 0L : get_thread_level();
 
     if (dir1 == sort_spec::ascen && dir2 == sort_spec::ascen)  {
-        if (get_thread_level() > 1 && idx_s > ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             if (! ignore_index)
                 thr_pool_.parallel_sort(zip_idx.begin(), zip_idx.end(), a_a);
             else
@@ -1014,7 +1028,7 @@ sort(const char *name1, sort_spec dir1,
         }
     }
     else if (dir1 == sort_spec::desce && dir2 == sort_spec::desce)  {
-        if (get_thread_level() > 1 && idx_s > ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             if (! ignore_index)
                 thr_pool_.parallel_sort(zip_idx.begin(), zip_idx.end(), d_d);
             else
@@ -1028,7 +1042,7 @@ sort(const char *name1, sort_spec dir1,
         }
     }
     else if (dir1 == sort_spec::ascen && dir2 == sort_spec::desce)  {
-        if (get_thread_level() > 1 && idx_s > ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             if (! ignore_index)
                 thr_pool_.parallel_sort(zip_idx.begin(), zip_idx.end(), a_d);
             else
@@ -1042,7 +1056,7 @@ sort(const char *name1, sort_spec dir1,
         }
     }
     else if (dir1 == sort_spec::desce && dir2 == sort_spec::ascen)  {
-        if (get_thread_level() > 1 && idx_s > ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             if (! ignore_index)
                 thr_pool_.parallel_sort(zip_idx.begin(), zip_idx.end(), d_a);
             else
@@ -1056,7 +1070,7 @@ sort(const char *name1, sort_spec dir1,
         }
     }
     else if (dir1 == sort_spec::abs_ascen && dir2 == sort_spec::abs_ascen)  {
-        if (get_thread_level() > 1 && idx_s > ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             if (! ignore_index)
                 thr_pool_.parallel_sort(zip_idx.begin(), zip_idx.end(), aa_aa);
             else
@@ -1070,7 +1084,7 @@ sort(const char *name1, sort_spec dir1,
         }
     }
     else if (dir1 == sort_spec::abs_desce && dir2 == sort_spec::abs_desce)  {
-        if (get_thread_level() > 1 && idx_s > ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             if (! ignore_index)
                 thr_pool_.parallel_sort(zip_idx.begin(), zip_idx.end(), ad_ad);
             else
@@ -1084,7 +1098,7 @@ sort(const char *name1, sort_spec dir1,
         }
     }
     else if (dir1 == sort_spec::abs_ascen && dir2 == sort_spec::abs_desce)  {
-        if (get_thread_level() > 1 && idx_s > ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             if (! ignore_index)
                 thr_pool_.parallel_sort(zip_idx.begin(), zip_idx.end(), aa_ad);
             else
@@ -1098,7 +1112,7 @@ sort(const char *name1, sort_spec dir1,
         }
     }
     else if (dir1 == sort_spec::abs_desce && dir2 == sort_spec::abs_ascen)  {
-        if (get_thread_level() > 1 && idx_s > ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             if (! ignore_index)
                 thr_pool_.parallel_sort(zip_idx.begin(), zip_idx.end(), ad_aa);
             else
@@ -1112,7 +1126,7 @@ sort(const char *name1, sort_spec dir1,
         }
     }
     else if (dir1 == sort_spec::ascen && dir2 == sort_spec::abs_ascen)  {
-        if (get_thread_level() > 1 && idx_s > ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             if (! ignore_index)
                 thr_pool_.parallel_sort(zip_idx.begin(), zip_idx.end(), a_aa);
             else
@@ -1126,7 +1140,7 @@ sort(const char *name1, sort_spec dir1,
         }
     }
     else if (dir1 == sort_spec::ascen && dir2 == sort_spec::abs_desce)  {
-        if (get_thread_level() > 1 && idx_s > ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             if (! ignore_index)
                 thr_pool_.parallel_sort(zip_idx.begin(), zip_idx.end(), a_ad);
             else
@@ -1140,7 +1154,7 @@ sort(const char *name1, sort_spec dir1,
         }
     }
     else if (dir1 == sort_spec::desce && dir2 == sort_spec::abs_ascen)  {
-        if (get_thread_level() > 1 && idx_s > ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             if (! ignore_index)
                 thr_pool_.parallel_sort(zip_idx.begin(), zip_idx.end(), d_aa);
             else
@@ -1154,7 +1168,7 @@ sort(const char *name1, sort_spec dir1,
         }
     }
     else if (dir1 == sort_spec::desce && dir2 == sort_spec::abs_desce)  {
-        if (get_thread_level() > 1 && idx_s > ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             if (! ignore_index)
                 thr_pool_.parallel_sort(zip_idx.begin(), zip_idx.end(), d_ad);
             else
@@ -1168,7 +1182,7 @@ sort(const char *name1, sort_spec dir1,
         }
     }
     else if (dir1 == sort_spec::abs_ascen && dir2 == sort_spec::ascen)  {
-        if (get_thread_level() > 1 && idx_s > ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             if (! ignore_index)
                 thr_pool_.parallel_sort(zip_idx.begin(), zip_idx.end(), aa_a);
             else
@@ -1182,7 +1196,7 @@ sort(const char *name1, sort_spec dir1,
         }
     }
     else if (dir1 == sort_spec::abs_desce && dir2 == sort_spec::ascen)  {
-        if (get_thread_level() > 1 && idx_s > ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             if (! ignore_index)
                 thr_pool_.parallel_sort(zip_idx.begin(), zip_idx.end(), ad_a);
             else
@@ -1196,7 +1210,7 @@ sort(const char *name1, sort_spec dir1,
         }
     }
     else if (dir1 == sort_spec::abs_ascen && dir2 == sort_spec::desce)  {
-        if (get_thread_level() > 1 && idx_s > ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             if (! ignore_index)
                 thr_pool_.parallel_sort(zip_idx.begin(), zip_idx.end(), aa_d);
             else
@@ -1210,7 +1224,7 @@ sort(const char *name1, sort_spec dir1,
         }
     }
     else  {   // dir1 == sort_spec::abs_desce && dir2 == sort_spec::desce
-        if (get_thread_level() > 1 && idx_s > ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             if (! ignore_index)
                 thr_pool_.parallel_sort(zip_idx.begin(), zip_idx.end(), ad_d);
             else
@@ -1224,7 +1238,7 @@ sort(const char *name1, sort_spec dir1,
         }
     }
 
-    if (get_thread_level() > 1 && ((column_list_.size() - 2) > 1))  {
+    if (((column_list_.size() - 2) > 1) && get_thread_level() > 2)  {
         auto    lbd = [name1, name2,
                        &sorting_idxs = std::as_const(sorting_idxs),
                        idx_s, this]
@@ -1356,11 +1370,14 @@ sort(const char *name1, sort_spec dir1,
 
     std::iota(sorting_idxs.begin(), sorting_idxs.end(), 0);
 
-    auto    zip = std::ranges::views::zip(*vec1, *vec2, *vec3, sorting_idxs);
-    auto    zip_idx =
+    auto        zip =
+        std::ranges::views::zip(*vec1, *vec2, *vec3, sorting_idxs);
+    auto        zip_idx =
         std::ranges::views::zip(*vec1, *vec2, *vec3, indices_, sorting_idxs);
+    const auto  thread_level =
+        (idx_s < ThreadPool::MUL_THR_THHOLD) ? 0L : get_thread_level();
 
-    if (get_thread_level() > 1 && idx_s > ThreadPool::MUL_THR_THHOLD)  {
+    if (thread_level > 2)  {
         if (! ignore_index)
             thr_pool_.parallel_sort(zip_idx.begin(), zip_idx.end(), cf);
         else
@@ -1373,7 +1390,7 @@ sort(const char *name1, sort_spec dir1,
             std::ranges::sort(zip, cf);
     }
 
-    if (get_thread_level() > 1 && ((column_list_.size() - 3) > 1))  {
+    if (((column_list_.size() - 3) > 1) && get_thread_level() > 2)  {
         auto    lbd = [name1, name2, name3,
                        &sorting_idxs = std::as_const(sorting_idxs),
                        idx_s, this]
@@ -1543,13 +1560,15 @@ sort(const char *name1, sort_spec dir1,
 
     std::iota(sorting_idxs.begin(), sorting_idxs.end(), 0);
 
-    auto    zip =
+    auto         zip =
         std::ranges::views::zip(*vec1, *vec2, *vec3, *vec4, sorting_idxs);
-    auto    zip_idx =
+    auto         zip_idx =
         std::ranges::views::zip(*vec1, *vec2, *vec3, *vec4,
                                 indices_, sorting_idxs);
+    const auto  thread_level =
+        (idx_s < ThreadPool::MUL_THR_THHOLD) ? 0L : get_thread_level();
 
-    if (get_thread_level() > 1 && idx_s > ThreadPool::MUL_THR_THHOLD)  {
+    if (thread_level > 2)  {
         if (! ignore_index)
             thr_pool_.parallel_sort(zip_idx.begin(), zip_idx.end(), cf);
         else
@@ -1562,7 +1581,7 @@ sort(const char *name1, sort_spec dir1,
             std::ranges::sort(zip, cf);
     }
 
-    if (get_thread_level() > 1 && ((column_list_.size() - 4) > 1))  {
+    if (((column_list_.size() - 4) > 1) && get_thread_level() > 2)  {
         auto    lbd = [name1, name2, name3, name4,
                        &sorting_idxs = std::as_const(sorting_idxs),
                        idx_s, this]
@@ -1770,14 +1789,16 @@ sort(const char *name1, sort_spec dir1,
 
     std::iota(sorting_idxs.begin(), sorting_idxs.end(), 0);
 
-    auto    zip =
+    auto        zip =
         std::ranges::views::zip(*vec1, *vec2, *vec3, *vec4, *vec5,
                                 sorting_idxs);
-    auto    zip_idx =
+    auto        zip_idx =
         std::ranges::views::zip(*vec1, *vec2, *vec3, *vec4, *vec5,
                                 indices_, sorting_idxs);
+    const auto  thread_level =
+        (idx_s < ThreadPool::MUL_THR_THHOLD) ? 0L : get_thread_level();
 
-    if (get_thread_level() > 1 && idx_s > ThreadPool::MUL_THR_THHOLD)  {
+    if (thread_level > 2)  {
         if (! ignore_index)
             thr_pool_.parallel_sort(zip_idx.begin(), zip_idx.end(), cf);
         else
@@ -1790,7 +1811,7 @@ sort(const char *name1, sort_spec dir1,
             std::ranges::sort(zip, cf);
     }
 
-    if (get_thread_level() > 1 && ((column_list_.size() - 5) > 1))  {
+    if (((column_list_.size() - 5) > 1) && get_thread_level() > 2)  {
         auto    lbd = [name1, name2, name3, name4, name5,
                        &sorting_idxs = std::as_const(sorting_idxs),
                        idx_s, this]
@@ -2306,8 +2327,11 @@ bucketize(bucket_type bt,
     _bucketize_core_(dst_idx, src_idx, src_idx, value, idx_visitor, idx_s, bt);
 
     std::vector<std::future<void>>  futures;
+    const auto                      thread_level =
+        (indices_.size() < ThreadPool::MUL_THR_THHOLD)
+            ? 0L : get_thread_level();
 
-    if (get_thread_level() > 1)  futures.reserve(column_list_.size());
+    if (thread_level > 2)  futures.reserve(column_list_.size());
 
     auto    args_tuple = std::tuple<Ts ...>(args ...);
     auto    func =
diff --git a/include/DataFrame/Internals/DataFrame_get.tcc b/include/DataFrame/Internals/DataFrame_get.tcc
index 1a4540e1..d87250f7 100644
--- a/include/DataFrame/Internals/DataFrame_get.tcc
+++ b/include/DataFrame/Internals/DataFrame_get.tcc
@@ -367,7 +367,11 @@ DataFrame<I, H>::get_data_by_idx (Index2D<IndexType> range) const  {
             data_[citer.second].change(functor);
         }
 
-        if (get_thread_level() > 1)  {
+        const auto  thread_level =
+            (indices_.size() < ThreadPool::MUL_THR_THHOLD)
+                ? 0L : get_thread_level();
+
+        if (thread_level > 2)  {
             auto    lbd =
                 [b_dist, e_dist, &df, this]
                 (const auto &begin, const auto &end) -> void  {
@@ -434,7 +438,10 @@ get_data_by_idx(const StlVecType<IndexType> &values) const  {
         data_[citer.second].change(functor);
     }
 
-    if (get_thread_level() > 1)  {
+    const auto  thread_level =
+        (idx_s < ThreadPool::MUL_THR_THHOLD) ? 0L : get_thread_level();
+
+    if (thread_level > 2)  {
         auto    lbd =
             [&locations = std::as_const(locations), idx_s, &df, this]
             (const auto &begin, const auto &end) -> void  {
@@ -679,7 +686,11 @@ DataFrame<I, H>::get_data_by_loc (Index2D<long> range) const  {
             data_[citer.second].change(functor);
         }
 
-        if (get_thread_level() > 1)  {
+        const auto  thread_level =
+            (indices_.size() < ThreadPool::MUL_THR_THHOLD)
+            ? 0L : get_thread_level();
+
+        if (thread_level > 2)  {
             auto    lbd =
                 [&range = std::as_const(range), &df, this]
                 (const auto &begin, const auto &end) -> void  {
@@ -753,7 +764,10 @@ get_data_by_loc (const StlVecType<long> &locations) const  {
         data_[citer.second].change(functor);
     }
 
-    if (get_thread_level() > 1)  {
+    const auto  thread_level =
+        (idx_s < ThreadPool::MUL_THR_THHOLD) ? 0L : get_thread_level();
+
+    if (thread_level > 2)  {
         auto    lbd =
             [&locations = std::as_const(locations), idx_s, &df, this]
             (const auto &begin, const auto &end) -> void  {
@@ -1004,7 +1018,10 @@ get_data_by_sel (const char *name, F &sel_functor) const  {
         data_[citer.second].change(functor);
     }
 
-    if (get_thread_level() > 1)  {
+    const auto  thread_level =
+        (idx_s < ThreadPool::MUL_THR_THHOLD) ? 0L : get_thread_level();
+
+    if (thread_level > 2)  {
         auto    lbd =
             [&col_indices = std::as_const(col_indices), idx_s, &df, this]
             (const auto &begin, const auto &end) -> void  {
@@ -1172,7 +1189,10 @@ get_data_by_sel (const char *name1, const char *name2, F &sel_functor) const  {
         data_[citer.second].change(functor);
     }
 
-    if (get_thread_level() > 1)  {
+    const auto  thread_level =
+        (idx_s < ThreadPool::MUL_THR_THHOLD) ? 0L : get_thread_level();
+
+    if (thread_level > 2)  {
         auto    lbd =
             [&col_indices = std::as_const(col_indices), idx_s, &df, this]
             (const auto &begin, const auto &end) -> void  {
@@ -1360,7 +1380,10 @@ get_data_by_sel (const char *name1,
         data_[citer.second].change(functor);
     }
 
-    if (get_thread_level() > 1)  {
+    const auto  thread_level =
+        (idx_s < ThreadPool::MUL_THR_THHOLD) ? 0L : get_thread_level();
+
+    if (thread_level > 2)  {
         auto    lbd =
             [&col_indices = std::as_const(col_indices), idx_s, &df, this]
             (const auto &begin, const auto &end) -> void  {
@@ -1453,7 +1476,11 @@ get_data_by_sel (F &sel_functor) const  {
         data_[citer.second].change(functor);
     }
 
-    if (get_thread_level() > 1)  {
+    const auto  thread_level =
+        (indices_.size() < ThreadPool::MUL_THR_THHOLD)
+            ? 0L : get_thread_level();
+
+    if (thread_level > 2)  {
         auto    lbd =
             [&col_indices = std::as_const(col_indices), idx_s, &df, this]
             (const auto &begin, const auto &end) -> void  {
@@ -1546,7 +1573,11 @@ get_data_by_sel (F &sel_functor, FilterCols && ... filter_cols) const  {
         data_[citer.second].change(functor);
     }
 
-    if (get_thread_level() > 1)  {
+    const auto  thread_level =
+        (indices_.size() < ThreadPool::MUL_THR_THHOLD)
+            ? 0L : get_thread_level();
+
+    if (thread_level > 2)  {
         auto    lbd =
             [&col_indices = std::as_const(col_indices), idx_s, &df, this]
             (const auto &begin, const auto &end) -> void  {
@@ -1753,7 +1784,10 @@ get_data_by_sel(const char *name1,
         data_[citer.second].change(functor);
     }
 
-    if (get_thread_level() > 1)  {
+    const auto  thread_level =
+        (idx_s < ThreadPool::MUL_THR_THHOLD) ? 0L : get_thread_level();
+
+    if (thread_level > 2)  {
         auto    lbd =
             [&col_indices = std::as_const(col_indices), idx_s, &df, this]
             (const auto &begin, const auto &end) -> void  {
@@ -1979,7 +2013,10 @@ get_data_by_sel(const char *name1,
         data_[citer.second].change(functor);
     }
 
-    if (get_thread_level() > 1)  {
+    const auto  thread_level =
+        (idx_s < ThreadPool::MUL_THR_THHOLD) ? 0L : get_thread_level();
+
+    if (thread_level > 2)  {
         auto    lbd =
             [&col_indices = std::as_const(col_indices), idx_s, &df, this]
             (const auto &begin, const auto &end) -> void  {
@@ -2103,7 +2140,10 @@ get_data_by_sel(const char *name1,
         data_[citer.second].change(functor);
     }
 
-    if (get_thread_level() > 1)  {
+    const auto  thread_level =
+        (idx_s < ThreadPool::MUL_THR_THHOLD) ? 0L : get_thread_level();
+
+    if (thread_level > 2)  {
         auto    lbd =
             [&col_indices = std::as_const(col_indices), idx_s, &df, this]
             (const auto &begin, const auto &end) -> void  {
@@ -2231,7 +2271,10 @@ get_data_by_sel(const char *name1,
         data_[citer.second].change(functor);
     }
 
-    if (get_thread_level() > 1)  {
+    const auto  thread_level =
+        (idx_s < ThreadPool::MUL_THR_THHOLD) ? 0L : get_thread_level();
+
+    if (thread_level > 2)  {
         auto    lbd =
             [&col_indices = std::as_const(col_indices), idx_s, &df, this]
             (const auto &begin, const auto &end) -> void  {
@@ -2363,7 +2406,10 @@ get_data_by_sel(const char *name1,
         data_[citer.second].change(functor);
     }
 
-    if (get_thread_level() > 1)  {
+    const auto  thread_level =
+        (idx_s < ThreadPool::MUL_THR_THHOLD) ? 0L : get_thread_level();
+
+    if (thread_level > 2)  {
         auto    lbd =
             [&col_indices = std::as_const(col_indices), idx_s, &df, this]
             (const auto &begin, const auto &end) -> void  {
@@ -2594,7 +2640,11 @@ get_data_by_rand(random_policy spec, double n, seed_t seed) const  {
             data_[citer.second].change(functor);
         }
 
-        if (get_thread_level() > 1)  {
+        const auto  thread_level =
+            (indices_.size() < ThreadPool::MUL_THR_THHOLD)
+                ? 0L : get_thread_level();
+
+        if (thread_level > 2)  {
             auto    lbd =
                 [&rand_indices = std::as_const(rand_indices), &df, this]
                 (const auto &begin, const auto &end) -> void  {
@@ -2938,7 +2988,10 @@ get_reindexed(const char *col_to_be_index, const char *old_index_name) const  {
         data_[citer.second].change(functor);
     }
 
-    if (get_thread_level() > 1)  {
+    const auto  thread_level =
+        (new_idx_s < ThreadPool::MUL_THR_THHOLD) ? 0L : get_thread_level();
+
+    if (thread_level > 2)  {
         auto    lbd =
             [col_to_be_index = std::as_const(col_to_be_index),
              new_idx_s, &df, this]

From 3391002661b9cfe3d5fbfc8c9b96eeca61939ee3 Mon Sep 17 00:00:00 2001
From: Hossein Moein <myseajune@aol.com>
Date: Mon, 1 Jan 2024 12:36:46 -0500
Subject: [PATCH 2/5] Streamlined paralle computing logic in code 2

---
 docs/HTML/DataFrame.html                      |  2 +-
 include/DataFrame/Internals/DataFrame.tcc     |  8 +-
 .../DataFrame/Internals/DataFrame_functors.h  |  3 +
 .../DataFrame/Internals/DataFrame_join.tcc    | 74 ++++++-------------
 .../DataFrame/Internals/DataFrame_misc.tcc    |  2 +-
 5 files changed, 35 insertions(+), 54 deletions(-)

diff --git a/docs/HTML/DataFrame.html b/docs/HTML/DataFrame.html
index b0546aef..cf9c5152 100644
--- a/docs/HTML/DataFrame.html
+++ b/docs/HTML/DataFrame.html
@@ -1440,7 +1440,7 @@ <H2><font color="blue">API Reference with code samples</font></H2>
 <BR><HR COLOR="Orange" SIZE="5">
 
   <H2><font color="blue">Multithreading</font></H2>
-    In general, multithreading could be very unintuitive. Often you think by using multithreading you enhance the performance of your program. But in fact, you are hindering it. It requires measuring and careful adjustments. It is recommended to start with a single-threaded version and when that is <I>working correctly</I>, take measurements and adjust to move to multithreading version.<BR>
+    In general, multithreading could be very unintuitive. Often you think by using multithreading you enhance the performance of your program. But in fact, you are hindering it. To do effective multithreading, you must do two things repeatedly; measure and adjust. It is recommended to start with a single-threaded version and when that is <I>working correctly</I>, take measurements and adjust to move to multithreading version.<BR>
 DataFrame uses multithreading extensively and provides granular tools to adjust your environment. Let’s divide the multithreading subject in DataFrame into two categories:<BR>
 
   <H4>1. User Multithreading</H4>
diff --git a/include/DataFrame/Internals/DataFrame.tcc b/include/DataFrame/Internals/DataFrame.tcc
index f89f1c06..16680517 100644
--- a/include/DataFrame/Internals/DataFrame.tcc
+++ b/include/DataFrame/Internals/DataFrame.tcc
@@ -575,8 +575,12 @@ drop_missing(drop_policy policy, size_type threshold)  {
                            threshold,
                            num_cols);
 
-    drop_missing_rows_functor_<Ts ...>  functor2 (
-        missing_row_map, policy, threshold, data_.size(), futures);
+    drop_missing_rows_functor_<Ts ...>  functor2 (missing_row_map,
+                                                  policy,
+                                                  threshold,
+                                                  data_.size(),
+                                                  thread_level,
+                                                  futures);
 
     for (size_type idx = 0; idx < num_cols; ++idx)
         data_[idx].change(functor2);
diff --git a/include/DataFrame/Internals/DataFrame_functors.h b/include/DataFrame/Internals/DataFrame_functors.h
index d4678070..53488d77 100644
--- a/include/DataFrame/Internals/DataFrame_functors.h
+++ b/include/DataFrame/Internals/DataFrame_functors.h
@@ -453,17 +453,20 @@ struct drop_missing_rows_functor_ :
                                        drop_policy p,
                                        size_type th,
                                        size_type cn,
+                                       long tl,
                                        std::vector<std::future<void>> &futs)
         : missing_row_map(mrm),
           policy(p),
           threshold(th),
           col_num(cn),
+          thread_level(tl),
           futures(futs)  {   }
 
     const DropRowMap                &missing_row_map;
     const drop_policy               policy;
     const size_type                 threshold;
     const size_type                 col_num;
+    const long                      thread_level;
     std::vector<std::future<void>>  &futures;
 
     template<typename T>
diff --git a/include/DataFrame/Internals/DataFrame_join.tcc b/include/DataFrame/Internals/DataFrame_join.tcc
index 0b670ad7..42b6a20b 100644
--- a/include/DataFrame/Internals/DataFrame_join.tcc
+++ b/include/DataFrame/Internals/DataFrame_join.tcc
@@ -62,12 +62,14 @@ join_by_index (const RHS_T &rhs, join_policy mp) const  {
     for (size_type i = 0; i < rhs_idx_s; ++i) [[likely]]
         idx_vec_rhs.push_back(std::make_pair(&(rhs_idx[i]), i));
 
-    auto    cf = [] (const JoinSortingPair<IndexType> &l,
-                     const JoinSortingPair<IndexType> &r) -> bool  {
-                     return (*(l.first) < *(r.first));
-                 };
-
-    if (get_thread_level() > 3 && lhs_idx_s > ThreadPool::MUL_THR_THHOLD)  {
+    auto        cf = [] (const JoinSortingPair<IndexType> &l,
+                         const JoinSortingPair<IndexType> &r) -> bool  {
+                         return (*(l.first) < *(r.first));
+                     };
+    const auto  thread_level =
+        (lhs_idx_s < ThreadPool::MUL_THR_THHOLD) ? 0L : get_thread_level();
+
+    if (thread_level > 3)  {
         std::future<void>   futures[2];
 
         futures[0] = thr_pool_.dispatch(
@@ -87,22 +89,6 @@ join_by_index (const RHS_T &rhs, join_policy mp) const  {
         futures[0].get();
         futures[1].get();
     }
-    else if (get_thread_level() > 1)  {
-        std::future<void>   futures[2];
-
-        futures[0] = thr_pool_.dispatch(false,
-                                        &std::sort<pair_vec_iter, decltype(cf)>,
-                                            idx_vec_lhs.begin(),
-                                            idx_vec_lhs.end(),
-                                            std::move(cf));
-        futures[1] = thr_pool_.dispatch(false,
-                                        &std::sort<pair_vec_iter, decltype(cf)>,
-                                            idx_vec_rhs.begin(),
-                                            idx_vec_rhs.end(),
-                                            std::move(cf));
-        futures[0].get();
-        futures[1].get();
-    }
     else  {
         std::sort(idx_vec_lhs.begin(), idx_vec_lhs.end(), cf);
         std::sort(idx_vec_rhs.begin(), idx_vec_rhs.end(), cf);
@@ -154,12 +140,14 @@ join_by_column (const RHS_T &rhs, const char *name, join_policy mp) const  {
     for (size_type i = 0; i < rhs_vec_s; ++i) [[likely]]
         col_vec_rhs.push_back(std::make_pair(&(rhs_vec[i]), i));
 
-    auto    cf = [] (const JoinSortingPair<T> &l,
-                     const JoinSortingPair<T> &r) -> bool  {
-                     return (*(l.first) < *(r.first));
-                 };
+    auto        cf = [] (const JoinSortingPair<T> &l,
+                         const JoinSortingPair<T> &r) -> bool  {
+                         return (*(l.first) < *(r.first));
+                     };
+    const auto  thread_level =
+        (lhs_vec_s < ThreadPool::MUL_THR_THHOLD) ? 0L : get_thread_level();
 
-    if (get_thread_level() > 3 && lhs_vec_s > ThreadPool::MUL_THR_THHOLD)  {
+    if (thread_level > 3)  {
         std::future<void>   futures[2];
 
         futures[0] = thr_pool_.dispatch(
@@ -179,22 +167,6 @@ join_by_column (const RHS_T &rhs, const char *name, join_policy mp) const  {
         futures[0].get();
         futures[1].get();
     }
-    else if (get_thread_level() > 1)  {
-        std::future<void>   futures[2];
-
-        futures[0] = thr_pool_.dispatch(false,
-                                        &std::sort<pair_vec_iter, decltype(cf)>,
-                                            col_vec_lhs.begin(),
-                                            col_vec_lhs.end(),
-                                            std::move(cf));
-        futures[1] = thr_pool_.dispatch(false,
-                                        &std::sort<pair_vec_iter, decltype(cf)>,
-                                            col_vec_rhs.begin(),
-                                            col_vec_rhs.end(),
-                                            std::move(cf));
-        futures[0].get();
-        futures[1].get();
-    }
     else  {
         std::sort(col_vec_lhs.begin(), col_vec_lhs.end(), cf);
         std::sort(col_vec_rhs.begin(), col_vec_rhs.end(), cf);
@@ -236,10 +208,12 @@ join_helper_common_(
     using res_t = decltype(result);
 
     std::vector<std::future<void>>  futures;
-    const auto                      thread_level = get_thread_level();
+    const auto                      thread_level =
+        (lhs.indices_.size() < ThreadPool::MUL_THR_THHOLD)
+            ? 0L : get_thread_level();
 
 
-    if (thread_level > 1)
+    if (thread_level > 2)
         futures.reserve(lhs.column_list_.size() + rhs.column_list_.size());
 
     const SpinGuard guard(lock_);
@@ -287,7 +261,7 @@ join_helper_common_(
                     lhs.data_[citer.second].change(functor);
                 };
 
-            if (thread_level > 1)
+            if (thread_level > 2)
                 futures.emplace_back(thr_pool_.dispatch(false, jcomm_lbd));
             else
                 jcomm_lbd();
@@ -307,7 +281,7 @@ join_helper_common_(
                     lhs.data_[citer.second].change(functor);
                 };
 
-            if (thread_level > 1)
+            if (thread_level > 2)
                 futures.emplace_back(thr_pool_.dispatch(false, jlhs_lbd));
             else
                 jlhs_lbd();
@@ -343,7 +317,7 @@ join_helper_common_(
                     rhs.data_[citer.second].change(functor);
                 };
 
-            if (thread_level > 1)
+            if (thread_level > 2)
                 futures.emplace_back(thr_pool_.dispatch(false, jrhs_lbd));
             else
                 jrhs_lbd();
@@ -384,7 +358,7 @@ index_join_helper_(const LHS_T &lhs,
         };
 
     // Load the index
-    if (get_thread_level() > 0 && len >= ThreadPool::MUL_THR_THHOLD)  {
+    if (len >= ThreadPool::MUL_THR_THHOLD && get_thread_level() > 2)  {
         auto    futures =
             thr_pool_.parallel_loop(size_type(0), len, std::move(lbd));
 
@@ -459,7 +433,7 @@ column_join_helper_(const LHS_T &lhs,
             }
         };
 
-    if (get_thread_level() > 0 && len >= ThreadPool::MUL_THR_THHOLD)  {
+    if (len >= ThreadPool::MUL_THR_THHOLD && get_thread_level() > 2)  {
         auto    futures =
             thr_pool_.parallel_loop(size_type(0), len, std::move(lbd));
 
diff --git a/include/DataFrame/Internals/DataFrame_misc.tcc b/include/DataFrame/Internals/DataFrame_misc.tcc
index 7fec997e..4b7b8a10 100644
--- a/include/DataFrame/Internals/DataFrame_misc.tcc
+++ b/include/DataFrame/Internals/DataFrame_misc.tcc
@@ -556,7 +556,7 @@ DataFrame<I, H>::
 drop_missing_rows_functor_<Ts ...>::
 operator()(T &vec)  {
 
-    if (get_thread_level()  > 0)
+    if (thread_level  > 2)
         futures.emplace_back(
             thr_pool_.dispatch(false,
                                &DataFrame::drop_missing_rows_<T>,

From ebc1bb717088b6205b896a61792beb090ad88d39 Mon Sep 17 00:00:00 2001
From: Hossein Moein <myseajune@aol.com>
Date: Tue, 2 Jan 2024 08:11:37 -0500
Subject: [PATCH 3/5] Streamlined paralle computing logic in code 3

---
 README.md                                     |  1 +
 include/DataFrame/Internals/DataFrame_set.tcc | 21 +++++++++++++++----
 .../DataFrame/Internals/DataFrame_shift.tcc   |  7 +++++--
 .../Internals/DataFrame_standalone.tcc        |  5 ++++-
 4 files changed, 27 insertions(+), 7 deletions(-)

diff --git a/README.md b/README.md
index c16a5610..f84d7332 100644
--- a/README.md
+++ b/README.md
@@ -40,6 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 This is a C++ analytical library designed for data analysis similar to libraries in Python and R. For example, you would compare this to Pandas or R data.frame.<BR>
 You can slice the data in many different ways. You can join, merge, group-by the data. You can run various statistical, summarization, financial, and ML algorithms on the data. You can add your custom algorithms easily. You can multi-column sort, custom pick and delete the data. And more …<BR>
 DataFrame also includes a large collection of analytical algorithms in form of visitors. These are from basic stats such as <I>Mean</I>, <I>Std Deviation</I>, <I>Return</I>, … to more involved analysis such as <I>Affinity Propagation</I>, <I>Polynomial Fit</I>, <I>Fast Fourier transform of arbitrary length</I> … including a good collection of trading indicators. You can also easily add your own algorithms.<BR>
+DataFrame also employs extensive multithreading in almost all its API’s, for large datasets.<BR>
 For basic operations to start you off, see [Hello World](examples/hello_world.cc). For a complete list of features with code samples, see [documentation](https://htmlpreview.github.io/?https://github.com/hosseinmoein/DataFrame/blob/master/docs/HTML/DataFrame.html).
 
 I have followed a few <B>principles in this library</B>:<BR>
diff --git a/include/DataFrame/Internals/DataFrame_set.tcc b/include/DataFrame/Internals/DataFrame_set.tcc
index adcdd7ab..7b95aa50 100644
--- a/include/DataFrame/Internals/DataFrame_set.tcc
+++ b/include/DataFrame/Internals/DataFrame_set.tcc
@@ -930,9 +930,12 @@ void DataFrame<I, H>::remove_data_by_idx (Index2D<IndexType> range)  {
         make_consistent<Ts ...>();
         indices_.erase(lower, upper);
 
+        const auto      thread_level =
+            (indices_.size() < ThreadPool::MUL_THR_THHOLD)
+                ? 0L : get_thread_level();
         const SpinGuard guard(lock_);
 
-        if (get_thread_level() > 2)  {
+        if (thread_level > 2)  {
             auto    lbd =
                 [b_dist, e_dist, this]
                 (const auto &begin, const auto &end) -> void  {
@@ -979,9 +982,12 @@ void DataFrame<I, H>::remove_data_by_loc (Index2D<long> range)  {
         indices_.erase(indices_.begin() + range.begin,
                        indices_.begin() + range.end);
 
+        const auto      thread_level =
+            (indices_.size() < ThreadPool::MUL_THR_THHOLD)
+                ? 0L : get_thread_level();
         const SpinGuard guard(lock_);
 
-        if (get_thread_level() > 2)  {
+        if (thread_level > 2)  {
             auto    lbd =
                 [&range = std::as_const(range), this]
                 (const auto &begin, const auto &end) -> void  {
@@ -1025,9 +1031,12 @@ template<typename ... Ts>
 void DataFrame<I, H>::
 remove_data_by_sel_common_(const StlVecType<size_type> &col_indices)  {
 
+    const auto  thread_level =
+        (indices_.size() < ThreadPool::MUL_THR_THHOLD)
+            ? 0L : get_thread_level();
     SpinGuard   guard (lock_);
 
-    if (get_thread_level() > 2)  {
+    if (thread_level > 2)  {
         auto    lbd =
             [&col_indices = std::as_const(col_indices), this]
             (const auto &begin, const auto &end) -> void  {
@@ -1223,7 +1232,11 @@ remove_dups_common_(const DataFrame &s_df,
         s_df.data_[citer.second].change(functor);
     }
 
-    if (get_thread_level() > 2)  {
+    const auto  thread_level =
+        (new_df.get_index().size() < ThreadPool::MUL_THR_THHOLD)
+            ? 0L : get_thread_level();
+
+    if (thread_level > 2)  {
         auto    lbd =
             [&rows_to_del = std::as_const(rows_to_del),
              &s_df = std::as_const(s_df),
diff --git a/include/DataFrame/Internals/DataFrame_shift.tcc b/include/DataFrame/Internals/DataFrame_shift.tcc
index c9c46b93..7cf308b9 100644
--- a/include/DataFrame/Internals/DataFrame_shift.tcc
+++ b/include/DataFrame/Internals/DataFrame_shift.tcc
@@ -48,9 +48,12 @@ void DataFrame<I, H>::self_shift(size_type periods, shift_policy sp)  {
         if (sp == shift_policy::down || sp == shift_policy::up) [[likely]]  {
             vertical_shift_functor_<Ts ...> functor(periods, sp);
             const size_type                 num_cols = data_.size();
-            const                           SpinGuard guard(lock_);
+            const auto                      thread_level =
+                (indices_.size() < ThreadPool::MUL_THR_THHOLD)
+                    ? 0L : get_thread_level();
+            const SpinGuard                 guard(lock_);
 
-            if (get_thread_level() > 2)  {
+            if (thread_level > 2)  {
                 auto    lbd =
                     [&functor, this](auto begin, auto end) -> void  {
                         for (size_type idx = begin; idx < end; ++idx)
diff --git a/include/DataFrame/Internals/DataFrame_standalone.tcc b/include/DataFrame/Internals/DataFrame_standalone.tcc
index 8547c56e..ed164f4f 100644
--- a/include/DataFrame/Internals/DataFrame_standalone.tcc
+++ b/include/DataFrame/Internals/DataFrame_standalone.tcc
@@ -527,8 +527,11 @@ _load_bucket_data_(const DF &source,
     auto                &dst_vec = _create_column_from_triple_(dest, triple);
     const std::size_t   src_s = std::min(src_vec.size(), src_idx.size());
     auto                &visitor = std::get<2>(triple);
+    const auto          thread_level =
+        (src_idx.size() < ThreadPool::MUL_THR_THHOLD)
+            ? 0L : ThreadGranularity::get_thread_level();
 
-    if (ThreadGranularity::get_thread_level() > 3)
+    if (thread_level > 3)
         futures.emplace_back(
             ThreadGranularity::thr_pool_.dispatch(
                 false,

From 120bbd0378a2ad4dc52c7a6a0426930fda210621 Mon Sep 17 00:00:00 2001
From: Hossein Moein <myseajune@aol.com>
Date: Tue, 2 Jan 2024 14:49:58 -0500
Subject: [PATCH 4/5] Streamlined paralle computing logic in code visitors

---
 .../DataFrame/DataFrameFinancialVisitors.h    | 165 +++++-----
 include/DataFrame/DataFrameMLVisitors.h       |  39 +--
 include/DataFrame/DataFrameStatsVisitors.h    | 303 ++++++++----------
 3 files changed, 235 insertions(+), 272 deletions(-)

diff --git a/include/DataFrame/DataFrameFinancialVisitors.h b/include/DataFrame/DataFrameFinancialVisitors.h
index 3d09097e..85b55f51 100644
--- a/include/DataFrame/DataFrameFinancialVisitors.h
+++ b/include/DataFrame/DataFrameFinancialVisitors.h
@@ -87,12 +87,10 @@ struct  ReturnVisitor  {
                        return ((diff > 0) ? 1 : ((diff < 0) ? -1 : 0));
                    };
 
-        result_type result;
-
-        if (ThreadGranularity::get_thread_level() > 2 &&
-            col_s >= ThreadPool::MUL_THR_THHOLD)  {
-            result.resize(col_s);
+        result_type result(col_s);
 
+        if (col_s >= ThreadPool::MUL_THR_THHOLD &&
+            ThreadGranularity::get_thread_level() > 2)  {
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
                     size_type(1),
@@ -107,9 +105,8 @@ struct  ReturnVisitor  {
             for (auto &fut : futures)  fut.get();
         }
         else  {
-            result.reserve(col_s);
             std::adjacent_difference (column_begin, column_end,
-                                      std::back_inserter (result),
+                                      result.begin(),
                                       func);
         }
         result[0] = std::numeric_limits<T>::quiet_NaN();
@@ -165,9 +162,8 @@ struct  DoubleCrossOver  {
                   size_t(std::distance(prices_begin, prices_end)),
                   result.size() });
 
+        col_to_short_term_.resize(col_s);
         if (thread_level_ > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
-            col_to_short_term_.resize(col_s);
-
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
                     size_type(0),
@@ -182,10 +178,9 @@ struct  DoubleCrossOver  {
             for (auto &fut : futures)  fut.get();
         }
         else  {
-            col_to_short_term_.reserve(col_s);
             std::transform(prices_begin, prices_begin + col_s,
                            result.begin(),
-                           std::back_inserter(col_to_short_term_),
+                           col_to_short_term_.begin(),
                            [](auto p, auto r) -> value_type  {
                                return (p - r);
                            });
@@ -208,9 +203,8 @@ struct  DoubleCrossOver  {
                   size_t(std::distance(prices_begin, prices_end)),
                   result.size() });
 
+        col_to_long_term_.resize(col_s);
         if (thread_level_ > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
-            col_to_long_term_.resize(col_s);
-
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
                     size_type(0),
@@ -225,10 +219,9 @@ struct  DoubleCrossOver  {
             for (auto &fut : futures)  fut.get();
         }
         else  {
-            col_to_long_term_.reserve(col_s);
             std::transform(prices_begin, prices_begin + col_s,
                            result.begin(),
-                           std::back_inserter(col_to_long_term_),
+                           col_to_long_term_.begin(),
                            [](auto p, auto r) -> value_type  {
                                return (p - r);
                            });
@@ -283,9 +276,8 @@ struct  DoubleCrossOver  {
 
         const size_type col_s = std::min<size_type>(re_count1, re_count2);
 
+        short_term_to_long_term_.resize(col_s);
         if (thread_level_ > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
-            short_term_to_long_term_.resize(col_s);
-
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
                     size_type(0),
@@ -301,11 +293,10 @@ struct  DoubleCrossOver  {
             for (auto &fut : futures)  fut.get();
         }
         else  {
-            short_term_to_long_term_.reserve(col_s);
             std::transform(short_roller_.get_result().begin(),
                            short_roller_.get_result().begin() + col_s,
                            long_roller_.get_result().begin(),
-                           std::back_inserter(short_term_to_long_term_),
+                           short_term_to_long_term_.begin(),
                            [](auto s, auto l) -> value_type  {
                                return (s - l);
                            });
@@ -402,11 +393,12 @@ struct  BollingerBand {
     operator() (const K &idx_begin, const K &idx_end,
                 const H &prices_begin, const H &prices_end)  {
 
-        const auto  thread_level = ThreadGranularity::get_thread_level();
+        const auto  thread_level =
+            (std::distance(prices_begin, prices_end) <
+                 ThreadPool::MUL_THR_THHOLD)
+                     ? 0L : ThreadGranularity::get_thread_level();
 
-        if (thread_level > 2 &&
-            std::distance(prices_begin, prices_end) >=
-                ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             std::future<void>   fut1 =
                 ThreadGranularity::thr_pool_.dispatch(
                     false,
@@ -443,7 +435,7 @@ struct  BollingerBand {
                   std_result.size(),
                   mean_result.size() });
 
-        if (thread_level > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             upper_band_to_raw_.resize(col_s);
             raw_to_lower_band_.resize(col_s);
 
@@ -533,11 +525,16 @@ struct  MACDVisitor  {
     operator() (const K &idx_begin, const K &idx_end,
                 const H &column_begin, const H &column_end)  {
 
-        const auto      thread_level = ThreadGranularity::get_thread_level();
-        macd_roller_t   short_roller (exponential_decay_spec::span,
-                                      short_mean_period_);
-        macd_roller_t   long_roller (exponential_decay_spec::span,
-                                     long_mean_period_);
+        macd_roller_t   short_roller(exponential_decay_spec::span,
+                                     short_mean_period_);
+        macd_roller_t   long_roller(exponential_decay_spec::span,
+                                    long_mean_period_);
+        const size_type col_s =
+            std::min<size_type>(
+                { size_t(std::distance(idx_begin, idx_end)),
+                  size_t(std::distance(column_begin, column_end)) });
+        const auto      thread_level = (col_s < ThreadPool::MUL_THR_THHOLD)
+            ? 0L : ThreadGranularity::get_thread_level();
 
         short_roller.pre();
         long_roller.pre();
@@ -571,18 +568,11 @@ struct  MACDVisitor  {
         long_roller.post();
         short_roller.post();
 
-        const auto      &short_result = short_roller.get_result();
-        const auto      &long_result = long_roller.get_result();
-        const size_type col_s =
-            std::min<size_type>(
-                { size_t(std::distance(idx_begin, idx_end)),
-                  size_t(std::distance(column_begin, column_end)),
-                  short_result.size(),
-                  long_result.size() });
-
-        if (thread_level > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
-            macd_line_.resize(col_s);
+        const auto  &short_result = short_roller.get_result();
+        const auto  &long_result = long_roller.get_result();
 
+        macd_line_.resize(col_s);
+        if (thread_level > 2)  {
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
                     size_type(0),
@@ -599,10 +589,9 @@ struct  MACDVisitor  {
             for (auto &fut : futures)  fut.get();
         }
         else  {
-            macd_line_.reserve(col_s);
             std::transform(short_result.begin(), short_result.begin() + col_s,
                            long_result.begin(),
-                           std::back_inserter(macd_line_),
+                           macd_line_.begin(),
                            [](auto s, auto l) -> value_type  {
                                return (s - l);
                            });
@@ -615,9 +604,8 @@ struct  MACDVisitor  {
 
         const auto  &signal_line_result { signal_line_roller_.get_result() };
 
-        if (thread_level > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
-            macd_histogram_.resize(col_s);
-
+        macd_histogram_.resize(col_s);
+        if (thread_level > 2)  {
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
                     size_type(0),
@@ -633,10 +621,9 @@ struct  MACDVisitor  {
             for (auto &fut : futures)  fut.get();
         }
         else  {
-            macd_histogram_.reserve(col_s);
             std::transform(macd_line_.begin(), macd_line_.begin() + col_s,
                            signal_line_result.begin(),
-                           std::back_inserter(macd_histogram_),
+                           macd_histogram_.begin(),
                            [](const auto &ml, const auto &sl) -> value_type  {
                                return (ml - sl);
                            });
@@ -1466,11 +1453,12 @@ struct  RVIVisitor  {
          const H &ts_begin, const H &ts_end,
          result_type &result, size_type col_s)  {
 
-        const auto  thread_level = ThreadGranularity::get_thread_level();
+        const auto  thread_level = (col_s < ThreadPool::MUL_THR_THHOLD)
+            ? 0L : ThreadGranularity::get_thread_level();
 
         stdev_.pre();
         ret_v_.pre();
-        if (thread_level > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             auto    fut1 =
                 ThreadGranularity::thr_pool_.dispatch(
                     false,
@@ -1502,7 +1490,7 @@ struct  RVIVisitor  {
         std::copy(ret_v_.get_result().begin(), ret_v_.get_result().end(),
                   neg_.begin());
 
-        if (thread_level > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
                     size_type(0),
@@ -1553,7 +1541,7 @@ struct  RVIVisitor  {
         ewm_neg_ (idx_begin, idx_end, neg_.begin(), neg_.end());
         ewm_neg_.post();
 
-        if (thread_level > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             result.resize(col_s);
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
@@ -1808,8 +1796,8 @@ struct  MassIndexVisitor  {
             else [[likely]]  break;
         }
 
-        if (ThreadGranularity::get_thread_level() > 2 &&
-            col_s >= ThreadPool::MUL_THR_THHOLD)  {
+        if (col_s >= ThreadPool::MUL_THR_THHOLD &&
+            ThreadGranularity::get_thread_level() > 2)  {
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
                     size_type(0),
@@ -1881,14 +1869,15 @@ struct  HullRollingMeanVisitor  {
 
         GET_COL_SIZE
 
-        const auto  thread_level = ThreadGranularity::get_thread_level();
+        const auto  thread_level = (col_s < ThreadPool::MUL_THR_THHOLD)
+            ? 0L : ThreadGranularity::get_thread_level();
 
         wma_t   wma_half { WeightedMeanVisitor<T, I>(), roll_count_ / 2 };
         wma_t   wma_full { WeightedMeanVisitor<T, I>(), roll_count_ };
 
         wma_half.pre();
         wma_full.pre();
-        if (thread_level > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             auto    fut1 =
                 ThreadGranularity::thr_pool_.dispatch(
                     false,
@@ -1918,7 +1907,7 @@ struct  HullRollingMeanVisitor  {
 
         result_type result { std::move(wma_half.get_result()) };
 
-        if (thread_level > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
                     size_type(0),
@@ -2069,8 +2058,8 @@ struct  DrawdownVisitor  {
         const auto              &cm_result { cm_v.get_result() };
         constexpr value_type    one { 1 };
 
-        if (ThreadGranularity::get_thread_level() > 2 &&
-            col_s >= ThreadPool::MUL_THR_THHOLD)  {
+        if (col_s >= ThreadPool::MUL_THR_THHOLD &&
+            ThreadGranularity::get_thread_level() > 2)  {
             drawdown_.resize(col_s);
             pct_drawdown_.resize(col_s);
             log_drawdown_.resize(col_s);
@@ -2152,7 +2141,8 @@ struct  WilliamPrcRVisitor  {
         if (roll_count_ == 0)  return;
 
         const size_type col_s = std::distance(close_begin, close_end);
-        const auto      thread_level = ThreadGranularity::get_thread_level();
+        const auto      thread_level = (col_s < ThreadPool::MUL_THR_THHOLD)
+            ? 0L : ThreadGranularity::get_thread_level();
 
         assert((col_s == size_type(std::distance(low_begin, low_end))));
         assert((col_s == size_type(std::distance(high_begin, high_end))));
@@ -2164,7 +2154,7 @@ struct  WilliamPrcRVisitor  {
 
         min_v.pre();
         max_v.pre();
-        if (thread_level > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             auto    fut1 =
                 ThreadGranularity::thr_pool_.dispatch(
                     false,
@@ -2194,7 +2184,7 @@ struct  WilliamPrcRVisitor  {
 
         result_type result { std::move(max_v.get_result()) };
 
-        if (thread_level > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
                     size_type(0),
@@ -2303,9 +2293,8 @@ struct  PSLVisitor  {
 
         assert((col_s == size_type(std::distance(open_begin, open_end))));
 
+        result_.resize(col_s);
         if (thread_level_ > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
-            result_.resize(col_s);
-
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
                     size_type(0),
@@ -2323,10 +2312,9 @@ struct  PSLVisitor  {
             for (auto &fut : futures)  fut.get();
         }
         else  {
-            result_.reserve(col_s);
             std::transform(close_begin, close_begin + col_s,
                            open_begin,
-                           std::back_inserter(result_),
+                           result_.begin(),
                            [](const auto &c, const auto &o) -> value_type  {
                                return (((c - o) > 0) ? 1 : 0);
                            });
@@ -2404,14 +2392,15 @@ struct  CCIVisitor  {
         if (roll_count_ == 0)  return;
 
         const size_type col_s = std::distance(close_begin, close_end);
-        const auto      thread_level = ThreadGranularity::get_thread_level();
+        const auto      thread_level = (col_s < ThreadPool::MUL_THR_THHOLD)
+            ? 0L : ThreadGranularity::get_thread_level();
 
         assert((col_s == size_type(std::distance(low_begin, low_end))));
         assert((col_s == size_type(std::distance(high_begin, high_end))));
 
         result_type result;
 
-        if (thread_level > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             result.resize(col_s);
 
             auto    futures =
@@ -2454,7 +2443,7 @@ struct  CCIVisitor  {
         mad_v (idx_begin, idx_end, result.begin(), result.end());
         mad_v.post();
 
-        if (thread_level > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
                     size_type(0),
@@ -2527,8 +2516,8 @@ struct  GarmanKlassVolVisitor  {
         result_type             result(
             col_s, std::numeric_limits<T>::quiet_NaN());
 
-        if (ThreadGranularity::get_thread_level() > 2 &&
-            col_s >= ThreadPool::MUL_THR_THHOLD)  {
+        if (col_s >= ThreadPool::MUL_THR_THHOLD &&
+            ThreadGranularity::get_thread_level() > 2)  {
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
                     roll_count_,
@@ -2628,8 +2617,8 @@ struct  YangZhangVolVisitor  {
         const value_type    norm { T(1) / T(roll_count_ - 1) };
         result_type         result(col_s, std::numeric_limits<T>::quiet_NaN());
 
-        if (ThreadGranularity::get_thread_level() > 2 &&
-            col_s >= (ThreadPool::MUL_THR_THHOLD / 2))  {
+        if (col_s >= (ThreadPool::MUL_THR_THHOLD / 2) &&
+            ThreadGranularity::get_thread_level() > 2)  {
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
                     roll_count_,
@@ -2766,8 +2755,8 @@ struct  KamaVisitor  {
 
         result_type peer_diff (col_s, std::numeric_limits<T>::quiet_NaN());
 
-        if (ThreadGranularity::get_thread_level() > 2 &&
-            col_s >= ThreadPool::MUL_THR_THHOLD)  {
+        if (col_s >= ThreadPool::MUL_THR_THHOLD &&
+            ThreadGranularity::get_thread_level() > 2)  {
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
                     size_type(1),
@@ -2854,14 +2843,15 @@ struct  FisherTransVisitor  {
                 const H &high_begin, const H &high_end)  {
 
         const size_type col_s = std::distance(low_begin, low_end);
-        const auto      thread_level = ThreadGranularity::get_thread_level();
+        const auto      thread_level = (col_s < ThreadPool::MUL_THR_THHOLD)
+            ? 0L : ThreadGranularity::get_thread_level();
 
         assert((col_s == size_type(std::distance(high_begin, high_end))));
         assert((roll_count_ < (col_s - 1)));
 
         result_type mid_hl(col_s);
 
-        if (col_s >= ThreadPool::MUL_THR_THHOLD && thread_level > 2)  {
+        if (thread_level > 2)  {
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
                     size_type(0),
@@ -2894,7 +2884,7 @@ struct  FisherTransVisitor  {
 
         result_type result(col_s);
 
-        if (thread_level > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
                     size_type(0),
@@ -3174,7 +3164,8 @@ struct  UltimateOSCIVisitor  {
                 const H &close_begin, const H &close_end)  {
 
         const size_type col_s = std::distance(close_begin, close_end);
-        const auto      thread_level = ThreadGranularity::get_thread_level();
+        const auto      thread_level = (col_s < ThreadPool::MUL_THR_THHOLD)
+            ? 0L : ThreadGranularity::get_thread_level();
 
         assert((col_s == size_type(std::distance(low_begin, low_end))));
         assert((col_s == size_type(std::distance(high_begin, high_end))));
@@ -3182,7 +3173,7 @@ struct  UltimateOSCIVisitor  {
         result_type max_high(col_s, std::numeric_limits<T>::quiet_NaN());
         result_type min_low(col_s, std::numeric_limits<T>::quiet_NaN());
 
-        if (col_s >= ThreadPool::MUL_THR_THHOLD && thread_level > 2)  {
+        if (thread_level > 2)  {
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
                     size_type(1),
@@ -3213,7 +3204,7 @@ struct  UltimateOSCIVisitor  {
         result_type buying_pressure(col_s);
         result_type true_range(col_s);
 
-        if (col_s >= ThreadPool::MUL_THR_THHOLD && thread_level > 2)  {
+        if (thread_level > 2)  {
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
                     size_type(0),
@@ -3276,7 +3267,7 @@ struct  UltimateOSCIVisitor  {
         const value_type    total_weights { slow_w_ + fast_w_ + medium_w_ };
         result_type         result(col_s);
 
-        if (col_s >= ThreadPool::MUL_THR_THHOLD && thread_level > 2)  {
+        if (thread_level > 2)  {
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
                     size_type(0),
@@ -3374,8 +3365,8 @@ struct  UlcerIndexVisitor  {
 
         GET_COL_SIZE2
 
-        const auto  thread_level = (col_s >= ThreadPool::MUL_THR_THHOLD)
-            ? ThreadGranularity::get_thread_level() : 0L;
+        const auto  thread_level = (col_s < ThreadPool::MUL_THR_THHOLD)
+            ? 0L : ThreadGranularity::get_thread_level();
 
         SimpleRollAdopter<MaxVisitor<T, I>, T, I, A>    high {
             MaxVisitor<T, I>(), periods_ };
@@ -3511,8 +3502,8 @@ struct  TTMTrendVisitor  {
         assert((col_s == size_type(std::distance(high_begin, high_end))));
         assert(((bar_periods_ + 1) < col_s));
 
-        const auto  thread_level = (col_s >= ThreadPool::MUL_THR_THHOLD)
-            ? ThreadGranularity::get_thread_level() : 0L;
+        const auto  thread_level = (col_s < ThreadPool::MUL_THR_THHOLD)
+            ? 0L : ThreadGranularity::get_thread_level();
         avg_vec_t   trend_avg(col_s, std::numeric_limits<T>::quiet_NaN());
 
         if (thread_level > 2)  {
@@ -3971,8 +3962,8 @@ struct  VarIdxDynAvgVisitor  {
         diff (idx_begin, idx_end, column_begin, column_end);
         diff.post();
 
-        const auto  thread_level = (col_s >= ThreadPool::MUL_THR_THHOLD)
-            ? ThreadGranularity::get_thread_level() : 0L;
+        const auto  thread_level = (col_s < ThreadPool::MUL_THR_THHOLD)
+            ? 0L : ThreadGranularity::get_thread_level();
         result_type positive { std::move(diff.get_result()) };
 
         positive[0] = 0;
diff --git a/include/DataFrame/DataFrameMLVisitors.h b/include/DataFrame/DataFrameMLVisitors.h
index 7f080352..3e4dbc3d 100644
--- a/include/DataFrame/DataFrameMLVisitors.h
+++ b/include/DataFrame/DataFrameMLVisitors.h
@@ -1034,8 +1034,8 @@ struct  EntropyVisitor  {
 
         result_type result = std::move(sum_v.get_result());
 
-        if (ThreadGranularity::get_thread_level() > 2 &&
-            result.size() >= ThreadPool::MUL_THR_THHOLD)  {
+        if (result.size() >= ThreadPool::MUL_THR_THHOLD &&
+            ThreadGranularity::get_thread_level() > 2)  {
                 auto    futures =
                     ThreadGranularity::thr_pool_.parallel_loop(
                         size_type(0),
@@ -1230,7 +1230,7 @@ struct  SigmoidVisitor  {
     inline void logistic_(const H &column_begin, const H &column_end,
                           size_type col_s, long thread_level)  {
 
-        if (thread_level > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
                     size_type(0),
@@ -1256,7 +1256,7 @@ struct  SigmoidVisitor  {
     inline void algebraic_(const H &column_begin, const H &column_end,
                            size_type col_s, long thread_level)  {
 
-        if (thread_level > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
                     size_type(0),
@@ -1285,7 +1285,7 @@ struct  SigmoidVisitor  {
     inline void hyperbolic_tan_(const H &column_begin, const H &column_end,
                                 size_type col_s, long thread_level)  {
 
-        if (thread_level > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
                     size_type(0),
@@ -1310,7 +1310,7 @@ struct  SigmoidVisitor  {
     inline void arc_tan_(const H &column_begin, const H &column_end,
                          size_type col_s, long thread_level)  {
 
-        if (thread_level > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
                     size_type(0),
@@ -1335,7 +1335,7 @@ struct  SigmoidVisitor  {
     inline void error_function_(const H &column_begin, const H &column_end,
                                 size_type col_s, long thread_level)  {
 
-        if (thread_level > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
                     size_type(0),
@@ -1360,7 +1360,7 @@ struct  SigmoidVisitor  {
     inline void gudermannian_(const H &column_begin, const H &column_end,
                               size_type col_s, long thread_level)  {
 
-        if (thread_level > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
                     size_type(0),
@@ -1386,7 +1386,7 @@ struct  SigmoidVisitor  {
     inline void smoothstep_(const H &column_begin, const H &column_end,
                             size_type col_s, long thread_level)  {
 
-        if (thread_level > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
                     size_type(0),
@@ -1431,7 +1431,8 @@ struct  SigmoidVisitor  {
 
         GET_COL_SIZE2
 
-        const auto  thread_level = ThreadGranularity::get_thread_level();
+        const auto  thread_level = (col_s < ThreadPool::MUL_THR_THHOLD)
+            ? 0L : ThreadGranularity::get_thread_level();
 
         result_.resize(std::distance(column_begin, column_end));
         if (sigmoid_type_ == sigmoid_type::logistic)
@@ -1490,8 +1491,8 @@ struct  RectifyVisitor  {
 
         GET_COL_SIZE2
 
-        if (ThreadGranularity::get_thread_level() > 2 &&
-            col_s >= ThreadPool::MUL_THR_THHOLD)  {
+        if (col_s >= ThreadPool::MUL_THR_THHOLD &&
+            ThreadGranularity::get_thread_level() > 2)  {
             std::vector<std::future<void>>  futures;
 
             result_.resize(col_s);
@@ -1752,9 +1753,9 @@ struct  PolicyLearningLossVisitor  {
 
         // Negative Log Likelihood
         //
-        if (ThreadGranularity::get_thread_level() > 2 &&
-            col_s >= ThreadPool::MUL_THR_THHOLD)  {
-            result_.resize(col_s);
+        result_.resize(col_s);
+        if (col_s >= ThreadPool::MUL_THR_THHOLD &&
+            ThreadGranularity::get_thread_level() > 2)  {
 
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
@@ -1773,10 +1774,9 @@ struct  PolicyLearningLossVisitor  {
             for (auto &fut : futures)  fut.get();
         }
         else  {
-            result_.reserve(col_s);
             std::transform(action_prob_begin, action_prob_end,
                            reward_begin,
-                           std::back_inserter(result_),
+                           result_.begin(),
                            [](const T &ap, const T &r) -> T  {
                                return (-std::log(ap) * r);
                            });
@@ -1846,9 +1846,10 @@ struct  LossFunctionVisitor  {
             return;
         }
 
-        if (ThreadGranularity::get_thread_level() > 2 &&
-            col_s >= ThreadPool::MUL_THR_THHOLD)  {
+        if (col_s >= ThreadPool::MUL_THR_THHOLD &&
+            ThreadGranularity::get_thread_level() > 2)  {
             std::vector<std::future<void>>  futures;
+
             if (lft_ == loss_function_type::kullback_leibler)  {
                 auto    futures =
                     ThreadGranularity::thr_pool_.parallel_loop(
diff --git a/include/DataFrame/DataFrameStatsVisitors.h b/include/DataFrame/DataFrameStatsVisitors.h
index e927cd76..7de2864a 100644
--- a/include/DataFrame/DataFrameStatsVisitors.h
+++ b/include/DataFrame/DataFrameStatsVisitors.h
@@ -277,9 +277,9 @@ struct  SumVisitor  {
     inline void
     operator() (K /*idx_begin*/, K /*idx_end*/, H column_begin, H column_end) {
 
-        if (ThreadGranularity::get_thread_level() > 2 &&
-            std::distance(column_begin, column_end) >=
-                ThreadPool::MUL_THR_THHOLD)  {
+        if (std::distance(column_begin, column_end) >=
+                ThreadPool::MUL_THR_THHOLD &&
+            ThreadGranularity::get_thread_level() > 2)  {
             auto    lbd =
                 [this] (const auto &begin, const auto &end) -> value_type  {
                     value_type  sum { };
@@ -531,9 +531,9 @@ struct  ProdVisitor  {
     inline void
     operator() (K /*idx_begin*/, K /*idx_end*/, H column_begin, H column_end) {
 
-        if (ThreadGranularity::get_thread_level() > 2 &&
-            std::distance(column_begin, column_end) >=
-                ThreadPool::MUL_THR_THHOLD)  {
+        if (std::distance(column_begin, column_end) >=
+                ThreadPool::MUL_THR_THHOLD &&
+            ThreadGranularity::get_thread_level() > 2)  {
             auto    lbd =
                 [this] (const auto &begin, const auto &end) -> value_type  {
                     value_type  prod { 1 };
@@ -617,9 +617,9 @@ struct  ExtremumVisitor  {
 
         // NOTE: Currently in multi-threading mode, pos_ and index_ are not
         //       updated.
-        if (ThreadGranularity::get_thread_level() > 2 &&
-            std::distance(column_begin, column_end) >=
-                ThreadPool::MUL_THR_THHOLD)  {
+        if (std::distance(column_begin, column_end) >=
+                ThreadPool::MUL_THR_THHOLD &&
+            ThreadGranularity::get_thread_level() > 2)  {
             auto    lbd =
                 [this] (const auto &begin, const auto &end) -> value_type  {
                     value_type  extremum { *begin };
@@ -812,9 +812,9 @@ struct  CovVisitor  {
                 H column_begin1, H column_end1,
                 H column_begin2, H column_end2)  {
 
-        if (ThreadGranularity::get_thread_level() > 2 &&
-            std::distance(column_begin1, column_end1) >=
-                ThreadPool::MUL_THR_THHOLD)  {
+        if (std::distance(column_begin1, column_end1) >=
+                ThreadPool::MUL_THR_THHOLD &&
+            ThreadGranularity::get_thread_level() > 2)  {
             auto    lbd =
                 [this]
                 (const auto &begin1, const auto &end1,
@@ -1245,8 +1245,8 @@ struct  CorrVisitor  {
                                  (value_type(col_s * (col_s * col_s - 1))));
             };
 
-            if (ThreadGranularity::get_thread_level() > 2 &&
-                col_s >= ThreadPool::MUL_THR_THHOLD)  {
+            if (col_s >= ThreadPool::MUL_THR_THHOLD &&
+                ThreadGranularity::get_thread_level() > 2)  {
                 auto        lbd =
                     [](const K &ib, const K &ie,
                        const H &cb, const H &ce) -> RankVisitor<T, I>  {
@@ -1333,9 +1333,9 @@ struct  DotProdVisitor  {
                 H column_begin1, H column_end1,
                 H column_begin2, H column_end2)  {
 
-        if (ThreadGranularity::get_thread_level() > 2 &&
-            std::distance(column_begin1, column_end1) >=
-                ThreadPool::MUL_THR_THHOLD)  {
+        if (std::distance(column_begin1, column_end1) >=
+                ThreadPool::MUL_THR_THHOLD &&
+            ThreadGranularity::get_thread_level() > 2)  {
             auto    lbd =
                 []
                 (const auto &begin1, const auto &end1,
@@ -1815,8 +1815,8 @@ struct  TTestVisitor  {
                         std::distance(x_begin, x_end),
                         std::distance(y_begin, y_end) });
 
-        if (ThreadGranularity::get_thread_level() > 2 &&
-            col_s >= ThreadPool::MUL_THR_THHOLD)  {
+        if (col_s >= ThreadPool::MUL_THR_THHOLD &&
+            ThreadGranularity::get_thread_level() > 2)  {
             std::vector<std::future<void>>  futures;
 
             if (! related_ts_)  {
@@ -2208,8 +2208,8 @@ struct  FactorizeVisitor  {
         const size_type col_s = std::distance(column_begin, column_end);
         result_type     result;
 
-        if (ThreadGranularity::get_thread_level() > 2 &&
-            col_s >= ThreadPool::MUL_THR_THHOLD)  {
+        if (col_s >= ThreadPool::MUL_THR_THHOLD &&
+            ThreadGranularity::get_thread_level() > 2)  {
             result.resize(col_s);
 
             auto    lbd =
@@ -2270,8 +2270,8 @@ struct  AutoCorrVisitor  {
         size_type               lag = 1;
 
         tmp_result[0] = 1.0;
-        if (ThreadGranularity::get_thread_level() > 2 &&
-            col_s >= ThreadPool::MUL_THR_THHOLD)  {
+        if (col_s >= ThreadPool::MUL_THR_THHOLD &&
+            ThreadGranularity::get_thread_level() > 2)  {
             vec_type<std::future<CorrResult>>   futures;
 
             futures.reserve((col_s - 4) - lag);
@@ -2827,8 +2827,8 @@ struct  ZeroLagMovingMeanVisitor  {
 
         const size_type lag = size_type (0.5 * double(roll_period_ - 1));
 
-        if (ThreadGranularity::get_thread_level() > 2 &&
-            col_s >= ThreadPool::MUL_THR_THHOLD)  {
+        if (col_s >= ThreadPool::MUL_THR_THHOLD &&
+            ThreadGranularity::get_thread_level() > 2)  {
             auto    lbd =
                 [lag, &column_begin, this]
                 (auto begin, auto end) mutable -> void  {
@@ -2901,10 +2901,10 @@ struct  LinregMovingMeanVisitor  {
         const value_type    divisor = T(roll_period_) * sum_x2 - sum_x * sum_x;
         result_type         result (col_s,
                                     std::numeric_limits<T>::quiet_NaN());
-        const auto          thread_level =
-            ThreadGranularity::get_thread_level();
+        const auto          thread_level = (col_s < ThreadPool::MUL_THR_THHOLD)
+            ? 0L : ThreadGranularity::get_thread_level();
 
-        if (thread_level > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             auto    lbd =
                 [&column_begin, &result, sum_x, sum_x2, divisor, this]
                 (auto begin, auto end) mutable -> void  {
@@ -2953,8 +2953,8 @@ struct  LinregMovingMeanVisitor  {
         value_type      sum_y { 0 };
         value_type      sum_xy { 0 };
 
-        if (ThreadGranularity::get_thread_level() > 2 &&
-            col_s >= ThreadPool::MUL_THR_THHOLD)  {
+        if (col_s >= ThreadPool::MUL_THR_THHOLD &&
+            ThreadGranularity::get_thread_level() > 2)  {
             auto    lbd =
                 [&column_begin]
                 (auto begin, auto end) mutable -> std::pair<T, T>  {
@@ -3430,8 +3430,8 @@ struct  ModeVisitor  {
                           val_vec.push_back(map_pair.second);
                       });
 
-        if (ThreadGranularity::get_thread_level() > 2 &&
-            val_vec.size() >= ThreadPool::MUL_THR_THHOLD)  {
+        if (val_vec.size() >= ThreadPool::MUL_THR_THHOLD &&
+            ThreadGranularity::get_thread_level() > 2)  {
             ThreadGranularity::thr_pool_.parallel_sort(
                 val_vec.begin(), val_vec.end(),
                 [](const DataItem &lhs, const DataItem &rhs) -> bool  {
@@ -3463,8 +3463,8 @@ struct  ModeVisitor  {
 
     inline void sort_by_repeat_count()  {
 
-        if (ThreadGranularity::get_thread_level() > 2 &&
-            result_.size() >= ThreadPool::MUL_THR_THHOLD)
+        if (result_.size() >= ThreadPool::MUL_THR_THHOLD &&
+            ThreadGranularity::get_thread_level() > 2)
             ThreadGranularity::thr_pool_.parallel_sort(
                 result_.begin(), result_.end(),
                 [](const DataItem &lhs, const DataItem &rhs) -> bool  {
@@ -3478,8 +3478,8 @@ struct  ModeVisitor  {
     }
     inline void sort_by_value()  {
 
-        if (ThreadGranularity::get_thread_level() > 2 &&
-            result_.size() >= ThreadPool::MUL_THR_THHOLD)
+        if (result_.size() >= ThreadPool::MUL_THR_THHOLD &&
+            ThreadGranularity::get_thread_level() > 2)
             ThreadGranularity::thr_pool_.parallel_sort(
                 result_.begin(), result_.end(),
                 [](const DataItem &lhs, const DataItem &rhs) -> bool  {
@@ -3822,12 +3822,12 @@ struct  ZScoreVisitor  {
 
         MeanVisitor<T, I>   mvisit { skip_nan_ };
         StdVisitor<T, I>    svisit;
-        const auto          thread_level {
-            ThreadGranularity::get_thread_level() };
+        const auto          thread_level = (col_s < ThreadPool::MUL_THR_THHOLD)
+            ? 0L : ThreadGranularity::get_thread_level();
 
         mvisit.pre();
         svisit.pre();
-        if (thread_level > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             auto    fut1 =
                 ThreadGranularity::thr_pool_.dispatch(
                       false,
@@ -3859,9 +3859,8 @@ struct  ZScoreVisitor  {
         const value_type    s = svisit.get_result();
         result_type         result;
 
-        if (thread_level > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
-            result.resize(col_s);
-
+        result.resize(col_s);
+        if (thread_level > 2)  {
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
                     size_type(0),
@@ -3875,9 +3874,8 @@ struct  ZScoreVisitor  {
             for (auto &fut : futures)  fut.get();
         }
         else  {
-            result.reserve(col_s);
             std::transform(column_begin, column_end,
-                           std::back_inserter(result),
+                           result.begin(),
                            [m, s](const auto &val) -> value_type  {
                                return ((val - m) / s);
                            });
@@ -3922,6 +3920,8 @@ struct  SampleZScoreVisitor  {
                 const H &population_begin, const H &population_end,
                 const H &sample_begin, const H &sample_end)  {
 
+        const size_type s_col_s = std::distance(sample_begin, sample_end);
+
         MeanVisitor<T, I>   p_mvisit { skip_nan_ };
         StdVisitor<T, I>    p_svisit;
         MeanVisitor<T, I>   s_mvisit { skip_nan_ };
@@ -3929,7 +3929,8 @@ struct  SampleZScoreVisitor  {
         p_mvisit.pre();
         p_svisit.pre();
         s_mvisit.pre();
-        if (ThreadGranularity::get_thread_level() > 3)  {
+        if (s_col_s >= ThreadPool::MUL_THR_THHOLD &&
+            ThreadGranularity::get_thread_level() > 3)  {
             auto    fut1 =
                 ThreadGranularity::thr_pool_.dispatch(
                       false,
@@ -3971,8 +3972,6 @@ struct  SampleZScoreVisitor  {
         p_svisit.post();
         s_mvisit.post();
 
-        const size_type s_col_s = std::distance(sample_begin, sample_end);
-
         result_ = (s_mvisit.get_result() - p_mvisit.get_result()) /
                   (p_svisit.get_result() / ::sqrt(s_col_s));
     }
@@ -4005,9 +4004,9 @@ struct  BoxCoxVisitor  {
     inline void modulus_(const H &column_begin, const H &column_end,
                          size_type col_s, size_type thread_level)  {
 
+        result_.resize(col_s);
         if (lambda_ != 0)  {
-            if (thread_level > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
-                result_.resize(col_s);
+            if (thread_level > 2)  {
                 auto    futures =
                     ThreadGranularity::thr_pool_.parallel_loop(
                         size_type(0),
@@ -4030,10 +4029,9 @@ struct  BoxCoxVisitor  {
                 for (auto &fut : futures)  fut.get();
             }
             else  {
-                result_.reserve(col_s);
                 std::transform(
                     column_begin, column_end,
-                    std::back_inserter(result_),
+                    result_.begin(),
                     [this](const auto &val) -> value_type  {
                         const value_type    sign = std::signbit(val) ? -1 : 1;
                         const value_type    v =
@@ -4045,8 +4043,7 @@ struct  BoxCoxVisitor  {
             }
         }
         else  {
-            if (thread_level > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
-                result_.resize(col_s);
+            if (thread_level > 2)  {
                 auto    futures =
                     ThreadGranularity::thr_pool_.parallel_loop(
                         size_type(0),
@@ -4066,10 +4063,9 @@ struct  BoxCoxVisitor  {
                 for (auto &fut : futures)  fut.get();
             }
             else  {
-                result_.reserve(col_s);
                 std::transform(
                     column_begin, column_end,
-                    std::back_inserter(result_),
+                    result_.begin(),
                     [](const auto &val) -> value_type  {
                         const value_type    sign = std::signbit(val) ? -1 : 1;
 
@@ -4083,9 +4079,9 @@ struct  BoxCoxVisitor  {
     inline void exponential_(const H &column_begin, const H &column_end,
                              size_type col_s, size_type thread_level)  {
 
+        result_.resize(col_s);
         if (lambda_ != 0)  {
-            if (thread_level > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
-                result_.resize(col_s);
+            if (thread_level > 2)  {
                 auto    futures =
                     ThreadGranularity::thr_pool_.parallel_loop(
                         size_type(0),
@@ -4104,10 +4100,9 @@ struct  BoxCoxVisitor  {
                 for (auto &fut : futures)  fut.get();
             }
             else  {
-                result_.reserve(col_s);
                 std::transform(
                     column_begin, column_end,
-                    std::back_inserter(result_),
+                    result_.begin(),
                     [this](const auto &val) -> value_type  {
                         return ((std::exp(this->lambda_ * val) - T(1)) /
                                 this->lambda_);
@@ -4115,8 +4110,7 @@ struct  BoxCoxVisitor  {
             }
         }
         else  {
-            if (thread_level > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
-                result_.resize(col_s);
+            if (thread_level > 2)  {
                 auto    futures =
                     ThreadGranularity::thr_pool_.parallel_loop(
                         size_type(0),
@@ -4131,9 +4125,8 @@ struct  BoxCoxVisitor  {
                 for (auto &fut : futures)  fut.get();
             }
             else  {
-                result_.reserve(col_s);
                 std::transform(column_begin, column_end,
-                               std::back_inserter(result_),
+                               result_.begin(),
                                [](const auto &val) -> value_type  {
                                    return (val);
                                });
@@ -4148,9 +4141,9 @@ struct  BoxCoxVisitor  {
                           size_type col_s,
                           size_type thread_level)  {
 
+        result_.resize(col_s);
         if (lambda_ != 0)  {
-            if (thread_level > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
-                result_.resize(col_s);
+            if (thread_level > 2)  {
                 auto    futures =
                     ThreadGranularity::thr_pool_.parallel_loop(
                         size_type(0),
@@ -4169,10 +4162,9 @@ struct  BoxCoxVisitor  {
                 for (auto &fut : futures)  fut.get();
             }
             else  {
-                result_.reserve(col_s);
                 std::transform(
                     column_begin, column_end,
-                    std::back_inserter(result_),
+                    result_.begin(),
                     [this, shift](const auto &val) -> value_type  {
                         return ((std::pow(val + shift, this->lambda_) -
                                  T(1)) / this->lambda_);
@@ -4180,8 +4172,7 @@ struct  BoxCoxVisitor  {
             }
         }
         else  {
-            if (thread_level > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
-                result_.resize(col_s);
+            if (thread_level > 2)  {
                 auto    futures =
                     ThreadGranularity::thr_pool_.parallel_loop(
                         size_type(0),
@@ -4198,9 +4189,8 @@ struct  BoxCoxVisitor  {
                 for (auto &fut : futures)  fut.get();
             }
             else  {
-                result_.reserve(col_s);
                 std::transform(column_begin, column_end,
-                               std::back_inserter(result_),
+                               result_.begin(),
                                [shift](const auto &val) -> value_type  {
                                    return (std::log(val + shift));
                                });
@@ -4218,14 +4208,14 @@ struct  BoxCoxVisitor  {
         H                           citer = column_begin;
         GeometricMeanVisitor<T, I>  gm;
 
+        result_.resize(col_s);
         gm.pre();
         if (lambda_ != 0)  {
             while (citer < column_end) [[likely]]
                 gm(dummy, *citer++ + shift);
             gm.post();
 
-            if (thread_level > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
-                result_.resize(col_s);
+            if (thread_level > 2)  {
                 auto    futures =
                     ThreadGranularity::thr_pool_.parallel_loop(
                         size_type(0),
@@ -4247,10 +4237,9 @@ struct  BoxCoxVisitor  {
                 for (auto &fut : futures)  fut.get();
             }
             else  {
-                result_.reserve(col_s);
                 std::transform(
                     column_begin, column_end,
-                    std::back_inserter(result_),
+                    result_.begin(),
                     [this, shift, gm = gm.get_result()]
                     (const auto &val) -> value_type  {
                         const value_type    raw_v = val + shift;
@@ -4266,8 +4255,7 @@ struct  BoxCoxVisitor  {
                 gm(dummy, std::log(*citer++ + shift));
             gm.post();
 
-            if (thread_level > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
-                result_.resize(col_s);
+            if (thread_level > 2)  {
                 auto    futures =
                     ThreadGranularity::thr_pool_.parallel_loop(
                         size_type(0),
@@ -4284,9 +4272,8 @@ struct  BoxCoxVisitor  {
                 for (auto &fut : futures)  fut.get();
             }
             else  {
-                result_.reserve(col_s);
                 std::transform(column_begin, column_end,
-                               std::back_inserter(result_),
+                               result_.begin(),
                                [shift, gm = gm.get_result()]
                                (const auto &val) -> value_type  {
                                    return ((val + shift) * gm);
@@ -4317,7 +4304,8 @@ struct  BoxCoxVisitor  {
         }
 
         const size_type col_s = std::distance(column_begin, column_end);
-        const size_type thread_level = ThreadGranularity::get_thread_level();
+        const auto      thread_level = (col_s < ThreadPool::MUL_THR_THHOLD)
+            ? 0L : ThreadGranularity::get_thread_level();
 
         if (box_cox_type_ == box_cox_type::original)
             original_(column_begin, column_end, shift, col_s, thread_level);
@@ -4366,9 +4354,9 @@ struct  ProbabilityDistVisitor  {
         result_type result;
         value_type  sum { 0 };
 
-        if (ThreadGranularity::get_thread_level() > 2 &&
-            std::distance(column_begin, column_end) >=
-                ThreadPool::MUL_THR_THHOLD)  {
+        if (std::distance(column_begin, column_end) >=
+                ThreadPool::MUL_THR_THHOLD &&
+            ThreadGranularity::get_thread_level() > 2)  {
             result.resize(col_s);
             if (pdtype_ == prob_dist_type::arithmetic)  {
                 auto    futures =
@@ -4637,10 +4625,9 @@ struct  NormalizeVisitor  {
         const value_type    diff = maxv.get_result() - minv.get_result();
         const size_type     col_s = std::distance(column_begin, column_end);
 
-        if (ThreadGranularity::get_thread_level() > 2 &&
-            col_s >= ThreadPool::MUL_THR_THHOLD)  {
-            result_.resize(col_s);
-
+        result_.resize(col_s);
+        if (col_s >= ThreadPool::MUL_THR_THHOLD &&
+            ThreadGranularity::get_thread_level() > 2)  {
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
                     size_type(0),
@@ -4655,9 +4642,8 @@ struct  NormalizeVisitor  {
             for (auto &fut : futures)  fut.get();
         }
         else  {
-            result_.reserve(col_s);
             std::transform(column_begin, column_end,
-                           std::back_inserter(result_),
+                           result_.begin(),
                            [minv = minv.get_result(), diff]
                            (const auto &val) -> value_type  {
                                return ((val - minv) / diff);
@@ -4677,10 +4663,9 @@ struct  NormalizeVisitor  {
 
         const size_type col_s = std::distance(column_begin, column_end);
 
-        if (ThreadGranularity::get_thread_level() > 2 &&
-            col_s >= ThreadPool::MUL_THR_THHOLD)  {
-            result_.resize(col_s);
-
+        result_.resize(col_s);
+        if (col_s >= ThreadPool::MUL_THR_THHOLD &&
+            ThreadGranularity::get_thread_level() > 2)  {
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
                     size_type(0),
@@ -4694,9 +4679,8 @@ struct  NormalizeVisitor  {
             for (auto &fut : futures)  fut.get();
         }
         else  {
-            result_.reserve(col_s);
             std::transform(column_begin, column_end,
-                           std::back_inserter(result_),
+                           result_.begin(),
                            [sumv = sumv.get_result()]
                            (const auto &val) -> value_type  {
                                return (val / sumv);
@@ -4716,10 +4700,9 @@ struct  NormalizeVisitor  {
 
         const size_type col_s = std::distance(column_begin, column_end);
 
-        if (ThreadGranularity::get_thread_level() > 2 &&
-            col_s >= ThreadPool::MUL_THR_THHOLD)  {
-            result_.resize(col_s);
-
+        result_.resize(col_s);
+        if (col_s >= ThreadPool::MUL_THR_THHOLD &&
+            ThreadGranularity::get_thread_level() > 2)  {
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
                     size_type(0),
@@ -4733,9 +4716,8 @@ struct  NormalizeVisitor  {
             for (auto &fut : futures)  fut.get();
         }
         else  {
-            result_.reserve(col_s);
             std::transform(column_begin, column_end,
-                           std::back_inserter(result_),
+                           result_.begin(),
                            [eucli = eucliv.get_euclidean_norm()]
                            (const auto &val) -> value_type  {
                                return (val / eucli);
@@ -4755,10 +4737,9 @@ struct  NormalizeVisitor  {
 
         const size_type col_s = std::distance(column_begin, column_end);
 
-        if (ThreadGranularity::get_thread_level() > 2 &&
-            col_s >= ThreadPool::MUL_THR_THHOLD)  {
-            result_.resize(col_s);
-
+        result_.resize(col_s);
+        if (col_s >= ThreadPool::MUL_THR_THHOLD &&
+            ThreadGranularity::get_thread_level() > 2)  {
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
                     size_type(0),
@@ -4772,9 +4753,8 @@ struct  NormalizeVisitor  {
             for (auto &fut : futures)  fut.get();
         }
         else  {
-            result_.reserve(col_s);
             std::transform(column_begin, column_end,
-                           std::back_inserter(result_),
+                           result_.begin(),
                            [maxv = maxv.get_result()]
                            (const auto &val) -> value_type  {
                                return (val / maxv);
@@ -4798,10 +4778,9 @@ struct  NormalizeVisitor  {
 
         const size_type col_s = std::distance(column_begin, column_end);
 
-        if (ThreadGranularity::get_thread_level() > 2 &&
-            col_s >= ThreadPool::MUL_THR_THHOLD)  {
-            result_.resize(col_s);
-
+        result_.resize(col_s);
+        if (col_s >= ThreadPool::MUL_THR_THHOLD &&
+            ThreadGranularity::get_thread_level() > 2)  {
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
                     size_type(0),
@@ -4817,9 +4796,8 @@ struct  NormalizeVisitor  {
             for (auto &fut : futures)  fut.get();
         }
         else  {
-            result_.reserve(col_s);
             std::transform(column_begin, column_end,
-                           std::back_inserter(result_),
+                           result_.begin(),
                            [meanv = meanv.get_result(),
                             stdv = stdv.get_result()]
                            (const auto &val) -> value_type  {
@@ -4844,10 +4822,9 @@ struct  NormalizeVisitor  {
             std::pow(10, std::log10(maxv.get_result()) + 1);
         const size_type     col_s = std::distance(column_begin, column_end);
 
-        if (ThreadGranularity::get_thread_level() > 2 &&
-            col_s >= ThreadPool::MUL_THR_THHOLD)  {
-            result_.resize(col_s);
-
+        result_.resize(col_s);
+        if (col_s >= ThreadPool::MUL_THR_THHOLD &&
+            ThreadGranularity::get_thread_level() > 2)  {
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
                     size_type(0),
@@ -4861,9 +4838,8 @@ struct  NormalizeVisitor  {
             for (auto &fut : futures)  fut.get();
         }
         else  {
-            result_.reserve(col_s);
             std::transform(column_begin, column_end,
-                           std::back_inserter(result_),
+                           result_.begin(),
                            [scale](const auto &val) -> value_type  {
                                return (val / scale);
                            });
@@ -4875,10 +4851,9 @@ struct  NormalizeVisitor  {
 
         const size_type col_s = std::distance(column_begin, column_end);
 
-        if (ThreadGranularity::get_thread_level() > 2 &&
-            col_s >= ThreadPool::MUL_THR_THHOLD)  {
-            result_.resize(col_s);
-
+        result_.resize(col_s);
+        if (col_s >= ThreadPool::MUL_THR_THHOLD &&
+            ThreadGranularity::get_thread_level() > 2)  {
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
                     size_type(0),
@@ -4891,9 +4866,8 @@ struct  NormalizeVisitor  {
             for (auto &fut : futures)  fut.get();
         }
         else  {
-            result_.reserve(std::distance(column_begin, column_end));
             std::transform(column_begin, column_end,
-                           std::back_inserter(result_),
+                           result_.begin(),
                            [](const auto &val) -> value_type  {
                                return (std::log(val));
                            });
@@ -4905,10 +4879,9 @@ struct  NormalizeVisitor  {
 
         const size_type col_s = std::distance(column_begin, column_end);
 
-        if (ThreadGranularity::get_thread_level() > 2 &&
-            col_s >= ThreadPool::MUL_THR_THHOLD)  {
-            result_.resize(col_s);
-
+        result_.resize(col_s);
+        if (col_s >= ThreadPool::MUL_THR_THHOLD &&
+            ThreadGranularity::get_thread_level() > 2)  {
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
                     size_type(0),
@@ -4921,9 +4894,8 @@ struct  NormalizeVisitor  {
             for (auto &fut : futures)  fut.get();
         }
         else  {
-            result_.reserve(col_s);
             std::transform(column_begin, column_end,
-                           std::back_inserter(result_),
+                           result_.begin(),
                            [](const auto &val) -> value_type  {
                                return (std::sqrt(val));
                            });
@@ -4961,10 +4933,9 @@ struct  StandardizeVisitor  {
 
         const size_type col_s = std::distance(column_begin, column_end);
 
-        if (ThreadGranularity::get_thread_level() > 2 &&
-            col_s >= ThreadPool::MUL_THR_THHOLD)  {
-            result_.resize(col_s);
-
+        result_.resize(col_s);
+        if (col_s >= ThreadPool::MUL_THR_THHOLD &&
+            ThreadGranularity::get_thread_level() > 2)  {
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
                     size_type(0),
@@ -4979,9 +4950,8 @@ struct  StandardizeVisitor  {
             for (auto &fut : futures)  fut.get();
         }
         else  {
-            result_.reserve(col_s);
             std::transform(column_begin, column_end,
-                           std::back_inserter(result_),
+                           result_.begin(),
                            [mv = mv.get_result(), sv = sv.get_result()]
                            (const auto &val) -> value_type  {
                                return ((val - mv) / sv);
@@ -5027,7 +4997,8 @@ struct  PolyFitVisitor  {
                 const Hy &y_begin, const Hy &y_end)  {
 
         const size_type col_s = std::distance(x_begin, x_end);
-        const size_type thread_level = ThreadGranularity::get_thread_level();
+        const auto      thread_level = (col_s < ThreadPool::MUL_THR_THHOLD)
+            ? 0L : ThreadGranularity::get_thread_level();
 
         assert((col_s == size_type(std::distance(y_begin, y_end))));
 
@@ -5045,7 +5016,7 @@ struct  PolyFitVisitor  {
             // consecutive positions of the array will store
             // col_s, sigma(xi), sigma(xi^2), sigma(xi^3) ... sigma(xi^2n)
             //
-            if (thread_level > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
+            if (thread_level > 2)  {
                 auto    futures =
                     ThreadGranularity::thr_pool_.parallel_loop(
                         size_type(0),
@@ -5097,7 +5068,7 @@ struct  PolyFitVisitor  {
             // consecutive positions will store
             // sigma(yi), sigma(xi * yi), sigma(xi^2 * yi) ... sigma(xi^n * yi)
             //
-            if (thread_level > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
+            if (thread_level > 2)  {
                 auto    futures =
                     ThreadGranularity::thr_pool_.parallel_loop(
                         size_type(0),
@@ -5255,11 +5226,12 @@ struct  LogFitVisitor  {
                 const H &y_begin, const H &y_end)  {
 
         const size_type col_s = std::distance(x_begin, x_end);
-        const size_type thread_level = ThreadGranularity::get_thread_level();
+        const auto      thread_level = (col_s < ThreadPool::MUL_THR_THHOLD)
+            ? 0L : ThreadGranularity::get_thread_level();
 
         result_type logx (x_begin, x_end);
 
-        if (thread_level > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
                     size_type(0),
@@ -5281,7 +5253,7 @@ struct  LogFitVisitor  {
                   y_begin, y_end);
 
         y_fits_.resize(col_s);
-        if (thread_level > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
                     size_type(0),
@@ -5365,7 +5337,8 @@ struct  ExponentialFitVisitor  {
                 const H &y_begin, const H &y_end)  {
 
         const size_type col_s = std::distance(x_begin, x_end);
-        const size_type thread_level = ThreadGranularity::get_thread_level();
+        const auto      thread_level = (col_s < ThreadPool::MUL_THR_THHOLD)
+            ? 0L : ThreadGranularity::get_thread_level();
 
         assert((col_s == size_type(std::distance(y_begin, y_end))));
 
@@ -5374,7 +5347,7 @@ struct  ExponentialFitVisitor  {
         value_type  sum_x2 { 0 };  // Sum of all observed x squared
         value_type  sum_xy { 0 };  // Sum of all x times sum of all observed y
 
-        if (thread_level > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             using sum_t =
                 std::tuple<value_type, value_type, value_type, value_type>;
 
@@ -5434,7 +5407,7 @@ struct  ExponentialFitVisitor  {
         const value_type    prefactor = std::exp(intercept_);
 
         y_fits_.resize(col_s);
-        if (thread_level > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
                     size_type(0),
@@ -5518,7 +5491,8 @@ struct  LinearFitVisitor  {
                 const H &y_begin, const H &y_end)  {
 
         const size_type col_s = std::distance(x_begin, x_end);
-        const size_type thread_level = ThreadGranularity::get_thread_level();
+        const auto      thread_level = (col_s < ThreadPool::MUL_THR_THHOLD)
+            ? 0L : ThreadGranularity::get_thread_level();
 
         assert((col_s == size_type(std::distance(y_begin, y_end))));
 
@@ -5527,7 +5501,7 @@ struct  LinearFitVisitor  {
         value_type  sum_x2 { 0 };  // Sum of all observed x squared
         value_type  sum_xy { 0 };  // Sum of all x times sum of all observed y
 
-        if (thread_level > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             using sum_t =
                 std::tuple<value_type, value_type, value_type, value_type>;
 
@@ -5584,9 +5558,8 @@ struct  LinearFitVisitor  {
         //
         intercept_ = (sum_x2 * sum_y - sum_x * sum_xy) / divisor;
 
-        if (thread_level > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
-            y_fits_.resize(col_s);
-
+        y_fits_.resize(col_s);
+        if (thread_level > 2)  {
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop(
                     size_type(0),
@@ -5613,10 +5586,9 @@ struct  LinearFitVisitor  {
              for (auto &fut : futures)  residual_ += fut.get();
         }
         else  {
-            y_fits_.reserve(col_s);
             std::transform(x_begin, x_end,
                            y_begin,
-                           std::back_inserter(y_fits_),
+                           y_fits_.begin(),
                            [this]
                            (const auto &x, const auto &y) -> value_type  {
                                const value_type    pred =
@@ -5675,14 +5647,15 @@ struct  CubicSplineFitVisitor  {
                 const H &y_begin, const H &y_end)  {
 
         const size_type col_s = std::distance(x_begin, x_end);
-        const size_type thread_level = ThreadGranularity::get_thread_level();
+        const auto      thread_level = (col_s < ThreadPool::MUL_THR_THHOLD)
+            ? 0L : ThreadGranularity::get_thread_level();
 
         assert(col_s > 3);
         assert((col_s == size_type(std::distance(y_begin, y_end))));
 
         result_type h;
 
-        if (thread_level > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
+        if (thread_level > 2)  {
             h.resize(col_s - 1);
 
             auto    futures =
@@ -6473,8 +6446,8 @@ struct  DecomposeVisitor  {
         // What is left is residual
         //
         residual_.resize(col_s, 0);
-        if (thread_level_ > 2 &&
-            detrended.size() >= ThreadPool::MUL_THR_THHOLD)  {
+        if (detrended.size() >= ThreadPool::MUL_THR_THHOLD &&
+            ThreadGranularity::get_thread_level() > 2)  {
             std::vector<std::future<void>>  futures;
 
             if (type_ == decompose_type::additive)
@@ -6542,7 +6515,8 @@ struct  DecomposeVisitor  {
 
         // Remove trend from observations in y
         //
-        if (thread_level_ > 2 && col_s >= ThreadPool::MUL_THR_THHOLD)  {
+        if (col_s >= ThreadPool::MUL_THR_THHOLD &&
+            ThreadGranularity::get_thread_level() > 2)  {
             std::vector<std::future<void>>  futures;
 
             if (type_ == decompose_type::additive)
@@ -6620,8 +6594,7 @@ struct  DecomposeVisitor  {
         : frac_(frac),
           s_period_(s_period),
           delta_(delta),
-          type_(t),
-          thread_level_(ThreadGranularity::get_thread_level())  {   }
+          type_(t)  {   }
 
 private:
 
@@ -6639,8 +6612,6 @@ struct  DecomposeVisitor  {
     const value_type        delta_;
     const decompose_type    type_;
 
-    const long              thread_level_;
-
     result_type             trend_ {  };
     result_type             seasonal_ {  };
     result_type             residual_ {  };
@@ -6794,8 +6765,8 @@ struct  BiasVisitor  {
         avger.post();
 
         result_ = std::move(avger.get_result());
-        if (ThreadGranularity::get_thread_level() > 2 &&
-            col_s >= ThreadPool::MUL_THR_THHOLD)  {
+        if (col_s >= ThreadPool::MUL_THR_THHOLD &&
+            ThreadGranularity::get_thread_level() > 2)  {
             auto    futures =
                 ThreadGranularity::thr_pool_.parallel_loop2(
                     roll_period_ - 1,
@@ -6862,8 +6833,8 @@ struct  NonZeroRangeVisitor  {
         bool        there_is_zero = false;
         result_type result;
 
-        if (ThreadGranularity::get_thread_level() > 2 &&
-            col_s >= ThreadPool::MUL_THR_THHOLD)  {
+        if (col_s >= ThreadPool::MUL_THR_THHOLD &&
+            ThreadGranularity::get_thread_level() > 2)  {
             result.resize(col_s);
 
             auto    futures =

From 46c4429fed17c7e14efbf4c4f3385c969320545c Mon Sep 17 00:00:00 2001
From: Hossein Moein <myseajune@aol.com>
Date: Wed, 3 Jan 2024 12:34:38 -0500
Subject: [PATCH 5/5] Added parallel computing logic to the following visitors:
 Clip, Abs, HampelFilter

---
 README.md                                     |   2 +-
 .../DataFrame/DataFrameTransformVisitors.h    | 175 ++++++++++++++++--
 2 files changed, 156 insertions(+), 21 deletions(-)

diff --git a/README.md b/README.md
index f84d7332..f98e33ab 100644
--- a/README.md
+++ b/README.md
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 This is a C++ analytical library designed for data analysis similar to libraries in Python and R. For example, you would compare this to Pandas or R data.frame.<BR>
 You can slice the data in many different ways. You can join, merge, group-by the data. You can run various statistical, summarization, financial, and ML algorithms on the data. You can add your custom algorithms easily. You can multi-column sort, custom pick and delete the data. And more …<BR>
 DataFrame also includes a large collection of analytical algorithms in form of visitors. These are from basic stats such as <I>Mean</I>, <I>Std Deviation</I>, <I>Return</I>, … to more involved analysis such as <I>Affinity Propagation</I>, <I>Polynomial Fit</I>, <I>Fast Fourier transform of arbitrary length</I> … including a good collection of trading indicators. You can also easily add your own algorithms.<BR>
-DataFrame also employs extensive multithreading in almost all its API’s, for large datasets.<BR>
+DataFrame also employs extensive multithreading in almost all its API’s, for large datasets. That makes DataFrame especially suitable for analyzing large datasets.<BR>
 For basic operations to start you off, see [Hello World](examples/hello_world.cc). For a complete list of features with code samples, see [documentation](https://htmlpreview.github.io/?https://github.com/hosseinmoein/DataFrame/blob/master/docs/HTML/DataFrame.html).
 
 I have followed a few <B>principles in this library</B>:<BR>
diff --git a/include/DataFrame/DataFrameTransformVisitors.h b/include/DataFrame/DataFrameTransformVisitors.h
index cd408ccd..9a2e78f4 100644
--- a/include/DataFrame/DataFrameTransformVisitors.h
+++ b/include/DataFrame/DataFrameTransformVisitors.h
@@ -30,7 +30,6 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #pragma once
 
 #include <DataFrame/DataFrameStatsVisitors.h>
-#include <DataFrame/DataFrameTypes.h>
 
 #include <algorithm>
 #include <cassert>
@@ -72,7 +71,54 @@ struct  ClipVisitor  {
             count_ += 1;
         }
     }
-    PASS_DATA_ONE_BY_ONE
+    template <forward_iterator K, forward_iterator H>
+    inline void
+    operator() (K idx_begin, K idx_end, H column_begin, H column_end) {
+
+        GET_COL_SIZE
+
+        if (col_s >= ThreadPool::MUL_THR_THHOLD &&
+            ThreadGranularity::get_thread_level() > 2)  {
+            auto    futures =
+                ThreadGranularity::thr_pool_.parallel_loop(
+                    size_type(0),
+                    col_s,
+                    [&column_begin, this]
+                    (auto begin, auto end) -> result_type  {
+                        result_type count { 0 };
+
+                        for (size_type i = begin; i < end; ++i)  {
+                            value_type  &val = *(column_begin + i);
+
+                            if (val > this->upper_)  {
+                                val = this->upper_;
+                                count += 1;
+                            }
+                            else if (val < this->lower_)  {
+                                val = this->lower_;
+                                count += 1;
+                            }
+                        }
+                        return (count);
+                    });
+
+            for (auto &fut : futures)  count_ += fut.get();
+        }
+        else  {
+            for (size_type i = 0; i < col_s; ++i)  {
+                value_type  &val = *(column_begin + i);
+
+                if (val > upper_)  {
+                    val = upper_;
+                    count_ += 1;
+                }
+                else if (val < lower_)  {
+                    val = lower_;
+                    count_ += 1;
+                }
+            }
+        }
+    }
 
     DEFINE_PRE_POST_2
 
@@ -104,6 +150,52 @@ struct  AbsVisitor  {
         }
     }
     PASS_DATA_ONE_BY_ONE
+    template <forward_iterator K, forward_iterator H>
+    inline void
+    operator() (K idx_begin, K idx_end, H column_begin, H column_end) {
+
+        GET_COL_SIZE
+
+        if (col_s >= ThreadPool::MUL_THR_THHOLD &&
+            ThreadGranularity::get_thread_level() > 2)  {
+            auto    futures =
+                ThreadGranularity::thr_pool_.parallel_loop(
+                    size_type(0),
+                    col_s,
+                    [&column_begin]
+                    (auto begin, auto end) -> result_type  {
+                        result_type count { 0 };
+
+                        for (size_type i = begin; i < end; ++i)  {
+                            value_type  &val = *(column_begin + i);
+
+                            if (val < T(0))  {
+                                if constexpr (std::is_floating_point<T>::value)
+                                    val = std::fabs(val);
+                                else
+                                    val = std::abs(val);
+                                count += 1;
+                            }
+                        }
+                        return (count);
+                    });
+
+            for (auto &fut : futures)  count_ += fut.get();
+        }
+        else  {
+            for (size_type i = 0; i < col_s; ++i)  {
+                value_type  &val = *(column_begin + i);
+
+                if (val < T(0))  {
+                    if constexpr (std::is_floating_point<T>::value)
+                        val = std::fabs(val);
+                    else
+                        val = std::abs(val);
+                    count_ += 1;
+                }
+            }
+        }
+    }
 
     DEFINE_PRE_POST_2
 
@@ -134,33 +226,73 @@ struct  HampelFilterVisitor {
         aggr.post();
 
         GET_COL_SIZE
-        std::vector<T, typename allocator_declare<T, A>::type>  diff;
 
-        diff.reserve(col_s);
-        std::transform(aggr.get_result().begin(), aggr.get_result().end(),
-                       column_begin,
-                       std::back_inserter(diff),
-                       [](const T &lhs, const T &rhs) -> T  {
-                           return (std::fabs(lhs - rhs));
-                       });
+        const auto  thread_level = (col_s < ThreadPool::MUL_THR_THHOLD)
+            ? 0L : ThreadGranularity::get_thread_level();
+        vec_t       diff(col_s);
+
+        if (thread_level > 2)  {
+            auto    futures =
+                ThreadGranularity::thr_pool_.parallel_loop(
+                    size_type(0),
+                    col_s,
+                    [&aggr = std::as_const(aggr.get_result()), &diff,
+                     &column_begin]
+                    (auto begin, auto end) -> void  {
+                        for (size_type i = begin; i < end; ++i)
+                            diff[i] = aggr[i] - *(column_begin + i);
+                    });
+
+            for (auto &fut : futures)  fut.get();
+        }
+        else  {
+            std::transform(aggr.get_result().begin(), aggr.get_result().end(),
+                           column_begin,
+                           diff.begin(),
+                           [](const T &agr, const T &col) -> T  {
+                               return (std::fabs(agr - col));
+                           });
+        }
 
         // Calculate median absolute deviation
+        //
         aggr.pre();
         aggr(idx_begin, idx_end, diff.begin(), diff.end());
         aggr.post();
 
         const value_type    factor = num_of_std_ * unbiased_factor_;
 
-        std::transform(aggr.get_result().begin(), aggr.get_result().end(),
-                       aggr.get_result().begin(),
-                       [factor](const T &v) -> T { return (factor * v); });
-
-        for (size_type i = 0; i < col_s; ++i)
-            if (diff[i] > aggr.get_result()[i])  {
-                *(column_begin + i) =
-                    std::numeric_limits<value_type>::quiet_NaN();
-                count_ += 1;
+        if (col_s >= ThreadPool::MUL_THR_THHOLD &&
+            ThreadGranularity::get_thread_level() > 2)  {
+            auto    futures =
+                ThreadGranularity::thr_pool_.parallel_loop(
+                    size_type(0),
+                    col_s,
+                    [&column_begin, &diff = std::as_const(diff), factor,
+                     &aggr = std::as_const(aggr.get_result())]
+                    (auto begin, auto end) -> result_type  {
+                        result_type count { 0 };
+
+                        for (size_type i = begin; i < end; ++i)  {
+                            if (diff[i] > (aggr[i] * factor))  {
+                                *(column_begin + i) =
+                                    std::numeric_limits<T>::quiet_NaN();
+                                count += 1;
+                            }
+                        }
+                        return (count);
+                    });
+
+            for (auto &fut : futures)  count_ += fut.get();
+        }
+        else  {
+            for (size_type i = 0; i < col_s; ++i)  {
+                if (diff[i] > (aggr.get_result()[i] * factor))  {
+                    *(column_begin + i) = std::numeric_limits<T>::quiet_NaN();
+                    count_ += 1;
+                }
             }
+        }
     }
 
 public:
@@ -194,6 +326,8 @@ struct  HampelFilterVisitor {
 
 private:
 
+    using vec_t = std::vector<T, typename allocator_declare<T, A>::type>;
+
     static constexpr value_type unbiased_factor_ { value_type(1.4826) };
     const size_type             window_size_;
     const hampel_type           type_;
@@ -260,7 +394,8 @@ struct  HWExpoSmootherVisitor {
 
     template<typename K, typename H>
     inline void
-    operator() (K /*idx_begin*/, K /*idx_end*/, H column_begin, H column_end)  {
+    operator() (K /*idx_begin*/, K /*idx_end*/,
+                H column_begin, H column_end)  {
 
         count_ = std::distance(column_begin, column_end);