Signature Description Parameters
#include <DataFrame/DataFrameStatsVisitors.h>

template<typename F, typename T, typename I = unsigned long>
struct SimpleRollAdopter;
        
This functor applies functor F to the data in a rolling progression. The roll count is given to the constructor of SimpleRollAdoptor.
The result is a vector of values with same number of items as the given column. The first roll_count items, in the result, will be NAN.
    SimpleRollAdopter(F &&functor, size_t roll_count);
        
F: Functor type
T: Column data type
I: Index type
static void test_SimpleRollAdopter()  {

    std::cout << "\nTesting SimpleRollAdopter{ } ..." << std::endl;

    std::vector<unsigned long>  idx =
        { 123450, 123451, 123452, 123453, 123454, 123455, 123456, 123457, 123458, 123459, 123460 };
    std::vector<double> d1 = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
    std::vector<double> d2 = { 8, 9, 10, 11,
                               std::numeric_limits<double>::quiet_NaN(),
                               13, 14,
                               std::numeric_limits<double>::quiet_NaN(),
                               16, 17, 18 };
    std::vector<double> d3 = { 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25 };
    std::vector<double> d4 = { 22, 23, 24, 25, 26, 27 };
    std::vector<std::string> s1 = { "11", "22", "33", "aa", "bb", "cc", "dd" "tt", "uu", "ii", "88" };
    MyDataFrame         df;

    df.load_data(std::move(idx),
                 std::make_pair("col_1", d1),
                 std::make_pair("col_2", d2),
                 std::make_pair("col_3", d3),
                 std::make_pair("col_str", s1));
    df.load_column("col_4", std::move(d4), nan_policy::dont_pad_with_nans);

    SimpleRollAdopter<MinVisitor<double>, double>   min_roller(MinVisitor<double>(), 3);
    const auto                                      &result = df.single_act_visit<double>("col_1", min_roller).get_result();

    assert(result.size() == 11);
    assert(std::isnan(result[0]));
    assert(std::isnan(result[1]));
    assert(result[2] == 1.0);
    assert(result[5] == 4.0);
    assert(result[8] == 7.0);

    SimpleRollAdopter<MeanVisitor<double>, double>  mean_roller(MeanVisitor<double>(), 3);
    const auto                                      &result2 = df.single_act_visit<double>("col_3", mean_roller).get_result();

    assert(result2.size() == 11);
    assert(std::isnan(result2[0]));
    assert(std::isnan(result2[1]));
    assert(result2[2] == 16.0);
    assert(result2[5] == 19.0);
    assert(result2[8] == 22.0);

    SimpleRollAdopter<MaxVisitor<double>, double>   max_roller(MaxVisitor<double>(), 3);
    const auto                                      &result3 = df.single_act_visit<double>("col_4", max_roller).get_result();

    assert(result3.size() == 6);
    assert(std::isnan(result3[0]));
    assert(std::isnan(result3[1]));
    assert(result3[2] == 24.0);
    assert(result3[4] == 26.0);
    assert(result3[5] == 27.0);

    SimpleRollAdopter<MaxVisitor<double>, double>   max2_roller(MaxVisitor<double>(false), 3);
    const auto                                      &result4 = df.single_act_visit<double>("col_2", max2_roller).get_result();

    assert(result4.size() == 11);
    assert(std::isnan(result4[0]));
    assert(std::isnan(result4[1]));
    assert(result4[2] == 10.0);
    assert(result4[3] == 11.0);
    assert(std::isnan(result4[4]));
    assert(std::isnan(result4[8]));
    assert(std::isnan(result4[9]));
    assert(result4[10] == 18.0);
}
C++ DataFrame