Added option to HampelFilterVisitor to populate indices to datapoints affected

Author: hosseinmoein

docs/HTML/HampelFilterVisitor.html

@@ -68,7 +68,8 @@
       <td bgcolor="blue"> <font color="white">
         <PRE><B>#include &lt;DataFrame/DataFrameTransformVisitors.h&gt;
 
-template&lt;typename T, typename I = unsigned long&gt;
+template&lt;typename T, typename I = unsigned long
+         std::size_t A = 0&gt;
 struct HampelFilterVisitor;
 
 // -------------------------------------
@@ -85,13 +86,18 @@
     explicit
     HampelFilterVisitor(std::size_t window_size,
                         hampel_type ht = hampel_type::median,
-                        T num_of_std = 3);
+                        T num_of_std = 3,
+                        bool populate_idxs = false);
         </PRE>
 		</I>
+        If <I>populate_idxs</I> is true, the input data column will be unchanged. Instead, a vector of indices to datapoints affected will be populated and can be accessed by calling <I>get_idxs()</I>.<BR><BR>
+        <I>get_result()</I> returns number of data points affected<BR>
+		<I>get_idxs()</I> returns a std::vector of indices of datapoints affected<BR>
       </td>
       <td width="30%">
         <B>T</B>: Column data type.<BR>
-        <B>I</B>: Index type.
+        <B>I</B>: Index type.<BR>
+        <B>A</B>: Memory alignment boundary for vectors. Default is system default alignment<BR>
       </td>
     </tr>
 

include/DataFrame/DataFrameTransformVisitors.h

@@ -367,33 +367,43 @@ struct  HampelFilterVisitor {
 
         const value_type    factor = num_of_std_ * unbiased_factor_;
 
-        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;
-                            }
+        if (! populate_idxs_)  {
+            auto    lbd =
+                [&column_begin, &diff = std::as_const(diff), factor,
+                 &aggr = std::as_const(aggr.get_result())]
+                (size_type begin, size_type 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();
+                    }
+                    return (count);
+                };
+
+            if (col_s >= ThreadPool::MUL_THR_THHOLD &&
+                ThreadGranularity::get_thread_level() > 2)  {
+                auto    futures =
+                    ThreadGranularity::thr_pool_.parallel_loop(size_type(0),
+                                                               col_s,
+                                                               lbd);
+
+                for (auto &fut : futures)  count_ += fut.get();
+            }
+            else  {
+                count_ = lbd(0, col_s);
+            }
         }
         else  {
+            const auto  &aggr_res = aggr.get_result();
+
+            idxs_.reserve(col_s / 20);
             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();
+                if (diff[i] > (aggr_res[i] * factor))  {
+                    idxs_.push_back(i);
                     count_ += 1;
                 }
             }
@@ -402,6 +412,9 @@ struct  HampelFilterVisitor {
 
 public:
 
+    using idxs_vec_t =
+        std::vector<size_type, typename allocator_declare<size_type, A>::type>;
+
     template<typename K, typename H>
     inline void
     operator() (K idx_begin, K idx_end, H column_begin, H column_end)  {
@@ -416,15 +429,20 @@ struct  HampelFilterVisitor {
                         (MeanVisitor<T, I> { true }, window_size_));
     }
 
-    DEFINE_PRE_POST_2
+    inline void pre ()  { count_ = 0; idxs_.clear(); }
+    inline void post ()  {  }
+    inline result_type get_result () const  { return (count_); }
+    inline const idxs_vec_t &get_idxs () const  { return (idxs_); }
 
     explicit
     HampelFilterVisitor(size_type window_size,
                         hampel_type ht = hampel_type::median,
-                        value_type num_of_std = 3)
+                        value_type num_of_std = 3,
+                        bool populate_idxs = false)
         : window_size_(window_size),
           type_(ht),
-          num_of_std_(num_of_std)  {   }
+          num_of_std_(num_of_std),
+          populate_idxs_(populate_idxs)  {   }
 
 private:
 
@@ -434,7 +452,9 @@ struct  HampelFilterVisitor {
     const size_type             window_size_;
     const hampel_type           type_;
     const value_type            num_of_std_;
+    const bool                  populate_idxs_;
     result_type                 count_ { 0 };
+    idxs_vec_t                  idxs_;
 };
 
 template<typename T, typename I = unsigned long, std::size_t A = 0>