bool operator() (const unsigned int &idx, double &value) {

if (idx == 20180103) {

value *= 1000.0;

count += 1;

}

else if (idx == 20180115) {

value *= 1000.0;

count += 1;

}

else if (idx == 20180121) {

value *= 1000.0;

count += 1;

}

return (true);

}

size_t count { 0 };

MyDataFrame::set_thread_level(10);

std::cout << "\nTesting load_data ..." << std::endl;

MyDataFrame df;

df.create_column<int>(static_cast<const char *>("col_name"));

std::vector<int> intvec = { 1, 2, 3, 4, 5 };

std::vector<double> dblvec =

{ 1.2345, 2.2345, 3.2345, 4.2345, 5.2345 };

std::vector<double> dblvec2 =

{ 0.998, 0.3456, 0.056, 0.15678, 0.00345, 0.923, 0.06743, 0.1 };

std::vector<std::string> strvec =

{ "Col_name", "Col_name", "Col_name", "Col_name", "Col_name" };

std::vector<unsigned long> ulgvec =

{ 1UL, 2UL, 3UL, 4UL, 5UL, 8UL, 7UL, 6UL };

std::vector<unsigned long> xulgvec = ulgvec;

MyDataFrame::size_type rc =

df.load_data(std::move(ulgvec),

std::make_pair("int_col", intvec),

std::make_pair("dbl_col", dblvec),

std::make_pair("dbl_col_2", dblvec2),

std::make_pair("str_col", strvec),

std::make_pair("ul_col", xulgvec));

assert(rc == 48);

df.load_index(ulgvec.begin(), ulgvec.end());

df.load_column<int>("int_col", { intvec.begin(), intvec.end() },

nan_policy::pad_with_nans);

df.load_column<std::string>("str_col", { strvec.begin(), strvec.end() },

nan_policy::pad_with_nans);

df.load_column<double>("dbl_col", { dblvec.begin(), dblvec.end() },

nan_policy::pad_with_nans);

df.load_column<double>("dbl_col_2", { dblvec2.begin(), dblvec2.end() },

nan_policy::dont_pad_with_nans);

df.append_column<std::string>("str_col", "Additional column");

df.append_column("dbl_col", 10.56);

std::vector<int> ivec = df.get_column<int> ("int_col");

std::cout << std::endl;

assert(df.get_column<int>("int_col") == df.get_column<int>(std::size_t(1)));

assert(df.get_column<double> ("dbl_col")[2] == 3.2345);

std::cout << "\nTesting Visitors 1 ..." << std::endl;

MyDataFrame df_dup = df;

MyDataFrame df_dup2(std::move(df));

df = std::move(df_dup);

MeanVisitor<int> ivisitor;

MeanVisitor<double> dvisitor;

MeanVisitor<double> rev_dvisitor;

WeightedMeanVisitor<double> wm_dvisitor;

QuadraticMeanVisitor<double> quad_dvisitor;

const MyDataFrame const_df = df;

auto const_fut =

const_df.visit_async<int>("int_col", ivisitor);

assert(const_fut.get().get_result() == 1);

auto fut = df.visit_async<double>("dbl_col", dvisitor);

// auto rev_fut = df.visit_async<double>("dbl_col", rev_dvisitor);

// auto wm_fut = df.visit_async<double>("dbl_col", wm_dvisitor);

// auto quad_fut = df.visit_async<double>("dbl_col", quad_dvisitor);

assert(abs(fut.get().get_result() - 3.2345) < 0.00001);

df.get_column<double>("dbl_col")[5] = 6.5;

df.get_column<double>("dbl_col")[6] = 7.5;

df.get_column<double>("dbl_col")[7] = 8.5;

assert(::abs(df.visit<double>("dbl_col", dvisitor).get_result() -

4.83406) < 0.0001);

assert(::abs(df.visit<double>("dbl_col", rev_dvisitor, true).get_result() -

4.83406) < 0.0001);

assert(::abs(df.visit<double>("dbl_col", wm_dvisitor).get_result() -

6.05604) < 0.0001);

assert(::abs(df.visit<double>("dbl_col", quad_dvisitor).get_result() -

5.39745) < 0.0001);

std::vector<double> dvec = df.get_column<double> ("dbl_col");

std::vector<double> dvec2 = df.get_column<double> ("dbl_col_2");

assert(dvec.size() == 9);

assert(dvec[0] == 1.2345);

assert(dvec[1] == 2.2345);

assert(dvec[3] == 4.2345);

assert(dvec[8] == 10.56);

assert(dvec2.size() == 8);

assert(dvec2[0] == 0.998);

assert(dvec2[1] == 0.3456);

assert(dvec2[4] == 0.00345);

assert(dvec2[7] == 0.1);

std::cout << "\nTesting make_consistent ..." << std::endl;

df.make_consistent<int, double, std::string>();

df.shrink_to_fit<int, double, std::string>();

dvec = df.get_column<double> ("dbl_col");

dvec2 = df.get_column<double> ("dbl_col_2");

assert(dvec.size() == 8);

assert(dvec[0] == 1.2345);

assert(dvec[1] == 2.2345);

assert(dvec[3] == 4.2345);

assert(dvec[7] == 8.5);

assert(dvec2.size() == 8);

assert(dvec2[0] == 0.998);

assert(dvec2[1] == 0.3456);

assert(dvec2[4] == 0.00345);

assert(dvec2[7] == 0.1);

std::cout << "\nTesting sort 1 ..." << std::endl;

df.sort<MyDataFrame::IndexType, int, double, std::string>

(DF_INDEX_COL_NAME, sort_spec::ascen);

dvec = df.get_column<double> ("dbl_col");

dvec2 = df.get_column<double> ("dbl_col_2");

assert(dvec.size() == 8);

assert(dvec[0] == 1.2345);

assert(dvec[1] == 2.2345);

assert(dvec[3] == 4.2345);

assert(dvec[5] == 8.5);

assert(dvec[7] == 6.5);

assert(dvec2.size() == 8);

assert(dvec2[0] == 0.998);

assert(dvec2[1] == 0.3456);

assert(dvec2[4] == 0.00345);

assert(dvec2[5] == 0.1);

assert(dvec2[7] == 0.923);

std::cout << "\nTesting sort 2 ..." << std::endl;

df.sort<double, int, double, std::string>("dbl_col_2", sort_spec::desce);

dvec = df.get_column<double> ("dbl_col");

dvec2 = df.get_column<double> ("dbl_col_2");

assert(dvec[0] == 1.2345);

assert(dvec[7] == 5.2345);

assert(dvec2[0] == 0.998);

assert(dvec2[7] == 0.00345);

std::cout << "\nTesting sort 3 ..." << std::endl;

df.sort<double, int, double, std::string>("dbl_col_2", sort_spec::ascen);

dvec = df.get_column<double> ("dbl_col");

dvec2 = df.get_column<double> ("dbl_col_2");

assert(dvec.size() == 8);

assert(dvec[0] == 5.2345);

assert(dvec[1] == 3.2345);

assert(dvec[3] == 8.5);

assert(dvec[5] == 2.2345);

assert(dvec[7] == 1.2345);

assert(dvec2.size() == 8);

assert(dvec2[0] == 0.00345);

assert(dvec2[1] == 0.056);

assert(dvec2[4] == 0.15678);

assert(dvec2[5] == 0.3456);

assert(dvec2[7] == 0.998);

std::cout << "\nTesting get_data_by_idx() ..." << std::endl;

df.sort<MyDataFrame::IndexType, int, double, std::string>

(DF_INDEX_COL_NAME, sort_spec::ascen);

MyDataFrame df2 =

df.get_data_by_idx<int, double, std::string>(

Index2D<MyDataFrame::IndexType> { 3, 5 });

dvec = df2.get_column<double> ("dbl_col");

dvec2 = df2.get_column<double> ("dbl_col_2");

assert(dvec.size() == 3);

assert(dvec[0] == 3.2345);

assert(dvec[1] == 4.2345);

assert(dvec2.size() == 3);

assert(dvec2[0] == 0.056);

assert(dvec2[1] == 0.15678);

std::cout << "\nTesting get_data_by_loc() ..." << std::endl;

df.sort<double, int, double, std::string>("dbl_col_2", sort_spec::ascen);

MyDataFrame df3 = df.get_data_by_loc<int, double, std::string>

(Index2D<long> { 1, 2 });

assert(df3.get_index().size() == 1);

assert(df3.get_column<int>("int_col").size() == 1);

assert(df3.get_column<double>("dbl_col").size() == 1);

assert(df3.get_column<double>("dbl_col_2").size() == 1);

assert(df3.get_column<std::string>("str_col").size() == 1);

assert(df3.get_index()[0] == 3);

assert(df3.get_column<double>("dbl_col")[0] == 3.2345);

assert(df3.get_column<int>("col_name")[0] == 0);

assert(df3.get_column<std::string>("str_col")[0] == "Col_name");

// Printing the second df after get_data_by_loc() ...

dvec = df3.get_column<double> ("dbl_col");

dvec2 = df3.get_column<double> ("dbl_col_2");

assert(dvec.size() == 1);

assert(dvec[0] == 3.2345);

assert(dvec2.size() == 1);

assert(dvec2[0] == 0.056);

std::cout << "\nTesting Correlation Visitor ..." << std::endl;

CorrVisitor<double> corr_visitor;

CorrVisitor<double> rev_corr_visitor;

auto fut10 =

df.visit_async<double, double>("dbl_col", "dbl_col_2", corr_visitor);

auto rev_fut10 =

df.visit_async<double, double>("dbl_col", "dbl_col_2",

rev_corr_visitor, true);

const double corr = fut10.get().get_result();

const double rev_corr = rev_fut10.get().get_result();

assert(fabs(corr - -0.358381) < 0.000001);

assert(fabs(rev_corr - -0.358381) < 0.000001);

std::cout << "\nTesting Stats Visitor ..." << std::endl;

StatsVisitor<double> stats_visitor;

df.visit<double>("dbl_col", stats_visitor);

dvec = df.get_column<double> ("dbl_col");

assert(fabs(stats_visitor.get_skew() - 0.0396307) < 0.0001);

assert(fabs(stats_visitor.get_kurtosis() - -1.273) < 0.0001);

assert(fabs(stats_visitor.get_mean() - 4.83406) < 0.0001);

assert(fabs(stats_visitor.get_variance() - 6.58781) < 0.0001);

std::cout << "\nTesting SLRegression Visitor ..." << std::endl;

SLRegressionVisitor<double> slr_visitor;

df.visit<double, double>("dbl_col", "dbl_col_2", slr_visitor);

assert(slr_visitor.get_count() == 8);

assert(fabs(slr_visitor.get_slope() - -0.0561415) < 0.00001);

assert(fabs(slr_visitor.get_intercept() - 0.602674) < 0.00001);

assert(fabs(slr_visitor.get_corr() - -0.358381) < 0.00001);

assert(fabs(df.visit<double, double>("dbl_col", "dbl_col_2",

corr_visitor).get_result() -

-0.358381) < 0.00001);

std::cout << "\nTesting GROUPBY ..." << std::endl;

std::vector<unsigned long> ulgvec2 =

{ 123450, 123451, 123452, 123450, 123455, 123450, 123449,

123448, 123451, 123452, 123452, 123450, 123455, 123450,

123454, 123453, 123456, 123457, 123458, 123459, 123460,

123441, 123442, 123432, 123433, 123434, 123435, 123436 };

std::vector<unsigned long> xulgvec2 = ulgvec2;

std::vector<int> intvec2 =

{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,

15, 20, 22, 23, 24, 25, 30, 33, 34, 35, 36, 40, 45, 46 };

std::vector<double> xdblvec2 =

{ 1.2345, 2.2345, 3.2345, 4.2345, 5.2345, 3.0, 0.9999,

10.0, 4.25, 0.009, 1.111, 8.0, 2.2222, 3.3333,

11.0, 5.25, 1.009, 2.111, 9.0, 3.2222, 4.3333,

12.0, 6.25, 2.009, 3.111, 10.0, 4.2222, 5.3333 };

std::vector<double> dblvec22 =

{ 0.998, 0.3456, 0.056, 0.15678, 0.00345, 0.923, 0.06743,

0.1, 0.0056, 0.07865, -0.9999, 0.0111, 0.1002, -0.8888,

0.14, 0.0456, 0.078654, -0.8999, 0.01119, 0.8002, -0.9888,

0.2, 0.1056, 0.87865, -0.6999, 0.4111, 0.1902, -0.4888 };

std::vector<std::string> strvec2 =

{ "4% of something", "Description 4/5", "This is bad",

"3.4% of GDP", "Market drops", "Market pulls back",

"$15 increase", "Running fast", "C++14 development",

"Some explanation", "More strings", "Bonds vs. Equities",

"Almost done", "Here comes the sun", "XXXX1", "XXXX04",

"XXXX2", "XXXX3", "XXXX4", "XXXX4", "XXXX5", "XXXX6",

"XXXX7", "XXXX10", "XXXX11", "XXXX01", "XXXX02", "XXXX03" };

MyDataFrame dfx;

dfx.load_data(std::move(ulgvec2),

std::make_pair("xint_col", intvec2),

std::make_pair("dbl_col", xdblvec2),

std::make_pair("dbl_col_2", dblvec22),

std::make_pair("str_col", strvec2),

std::make_pair("ul_col", xulgvec2));

dfx.write<std::ostream,

int,

unsigned long,

double,

std::string>(std::cout);

std::cout << "\nTesting Async write ..." << std::endl;

std::future<bool> fut2 =

dfx.write_async<std::ostream,

int,

unsigned long,

double,

std::string>(std::cout);

fut2.get();

std::cout << "\nTesting Async sort ..." << std::endl;

auto sf = dfx.sort_async<MyDataFrame::IndexType, std::string,

int, double, std::string, unsigned int>

(DF_INDEX_COL_NAME, sort_spec::ascen,

"str_col", sort_spec::desce);

sf.get();

std::cout << "\nTesting Async sort 2 ..." << std::endl;

std::future<void> sort_fut =

dfx.sort_async<MyDataFrame::IndexType,

int, double, std::string, unsigned int>

(DF_INDEX_COL_NAME, sort_spec::ascen);

sort_fut.get();

dfx.write<std::ostream,

int,

unsigned long,

double,

std::string>(std::cout);

std::cout << "\nTesting multi_visit() ..." << std::endl;

MeanVisitor<int> ivisitor2;

MeanVisitor<unsigned long> ulvisitor;

MeanVisitor<double> dvisitor2;

MeanVisitor<double> dvisitor22;

dfx.multi_visit(std::make_pair("xint_col", &ivisitor2),

std::make_pair("dbl_col", &dvisitor2),

std::make_pair("dbl_col_2", &dvisitor22),

std::make_pair("ul_col", &ulvisitor));

assert(ivisitor2.get_result() == 19);

assert(fabs(dvisitor2.get_result() - 4.5696) < 0.0001);

assert(fabs(dvisitor22.get_result() - 0.0264609) < 0.00001);

assert(ulvisitor.get_result() == 123448);

const MyDataFrame dfx_c = dfx;

dfx_c.multi_visit(std::make_pair("xint_col", &ivisitor2),

std::make_pair("dbl_col", &dvisitor2),

std::make_pair("dbl_col_2", &dvisitor22),

std::make_pair("ul_col", &ulvisitor));

assert(ivisitor2.get_result() == 19);

assert(fabs(dvisitor2.get_result() - 4.5696) < 0.0001);

assert(fabs(dvisitor22.get_result() - 0.0264609) < 0.00001);

assert(ulvisitor.get_result() == 123448);

MyDataFrame df_copy_con = dfx;

assert((df_copy_con.is_equal<int,

unsigned long,

double,

std::string>(dfx)));

df_copy_con.get_column<double>("dbl_col")[7] = 88.888888;

assert(dfx.get_column<double>("dbl_col")[7] == 10.0);

assert(

fabs(df_copy_con.get_column<double>("dbl_col")[7] - 88.888888) <

0.00001);

assert(! (df_copy_con.is_equal<int,

unsigned long,

double,

std::string>(dfx)));

std::cout << "dfx before modify_by_idx()" << std::endl;

dfx.write<std::ostream,

int,

unsigned long,

double,

std::string>(std::cout);

dfx.modify_by_idx<int, unsigned long, double, std::string>(df_copy_con);

std::cout << "dfx after modify_by_idx()" << std::endl;

dfx.write<std::ostream,

int,

unsigned long,

double,

std::string>(std::cout);

dfx.modify_by_idx<int, unsigned long, double, std::string>(df);

std::cout << "dfx after modify_by_idx()" << std::endl;

dfx.write<std::ostream,

int,

unsigned long,

double,

std::string>(std::cout);

MyDataFrame::set_thread_level(5);

assert(MyDataFrame::get_thread_level() == 5);

MyDataFrame::set_thread_level(0);

assert(MyDataFrame::get_thread_level() == 0);

MyDataFrame::set_thread_level(10);

std::cout << "\nTesting read() ..." << std::endl;

MyDataFrame df_read;

try {

std::future<bool> fut2 = df_read.read_async("data/sample_data.csv");

fut2.get();

}

catch (const DataFrameError &ex) {

std::cout << ex.what() << std::endl;

}

df_read.write<std::ostream,

int,

unsigned long,

double,

std::string,

bool>(std::cout);

StdDataFrame<std::string> df_read_str;

try {

df_read_str.read("data/sample_data_string_index.csv");

}

catch (const DataFrameError &ex) {

std::cout << ex.what() << std::endl;

}

df_read_str.write<std::ostream,

int,

unsigned long,

double,

std::string,

bool>(std::cout);

StdDataFrame<DateTime> df_read_dt;

try {

df_read_dt.read("data/sample_data_dt_index.csv");

}

catch (const DataFrameError &ex) {

std::cout << ex.what() << std::endl;

}

df_read_dt.write<std::ostream,

int,

unsigned long,

double,

std::string,

bool>(std::cout);

std::cout << "\nTesting transpose() ..." << std::endl;

std::vector<unsigned long> idx =

{ 123450, 123451, 123452, 123450, 123455, 123450, 123449 };

std::vector<double> d1 = { 1, 2, 3, 4, 5, 6, 7 };

std::vector<double> d2 = { 8, 9, 10, 11, 12, 13, 14 };

std::vector<double> d3 = { 15, 16, 17, 18, 19, 20, 21 };

std::vector<double> d4 = { 22, 23, 24, 25 };

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_4", d4));

std::vector<unsigned long> tidx = { 100, 101, 102, 104 };

std::vector<const char *> tcol_names =

{ "tcol_1", "tcol_2", "tcol_3",

"tcol_4", "tcol_5", "tcol_6", "tcol_7" };

MyDataFrame tdf =

df.transpose<double>(std::move(tidx), tcol_names);

std::cout << "Original DataFrame:" << std::endl;

df.write<std::ostream, unsigned long, double>(std::cout);

std::cout << "Transposed DataFrame:" << std::endl;

tdf.write<std::ostream, unsigned long, double>(std::cout);

std::cout << "\nTesting get_data_by_loc()/slicing ..." << std::endl;

std::vector<unsigned long> idx =

{ 123450, 123451, 123452, 123450, 123455, 123450, 123449 };

std::vector<double> d1 = { 1, 2, 3, 4, 5, 6, 7 };

std::vector<double> d2 = { 8, 9, 10, 11, 12, 13, 14 };

std::vector<double> d3 = { 15, 16, 17, 18, 19, 20, 21 };

std::vector<double> d4 = { 22, 23, 24, 25 };

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_4", d4));

MyDataFrame df2 = df.get_data_by_loc<double>(Index2D<long> { 3, 6 });

MyDataFrame df3 = df.get_data_by_loc<double>(Index2D<long> { 0, 7 });

MyDataFrame df4 = df.get_data_by_loc<double>(Index2D<long> { -4, -1 });

MyDataFrame df5 = df.get_data_by_loc<double>(Index2D<long> { -4, 6 });

df.write<std::ostream, double>(std::cout);

df2.write<std::ostream, double>(std::cout);

df3.write<std::ostream, double>(std::cout);

df4.write<std::ostream, double>(std::cout);

df5.write<std::ostream, double>(std::cout);

try {

MyDataFrame df2 = df.get_data_by_loc<double>(Index2D<long> { 3, 8 });

}

catch (const BadRange &ex) {

std::cout << "Caught: " << ex.what() << std::endl;

}

try {

MyDataFrame df2 = df.get_data_by_loc<double>(Index2D<long> { -8, -1 });

}

catch (const BadRange &ex) {

std::cout << "Caught: " << ex.what() << std::endl;

}

std::cout << "\nTesting get_view_by_loc() ..." << std::endl;

std::vector<unsigned long> idx =

{ 123450, 123451, 123452, 123450, 123455, 123450, 123449 };

std::vector<double> d1 = { 1, 2, 3, 4, 5, 6, 7 };

std::vector<double> d2 = { 8, 9, 10, 11, 12, 13, 14 };

std::vector<double> d3 = { 15, 16, 17, 18, 19, 20, 21 };

std::vector<double> d4 = { 22, 23, 24, 25 };

std::vector<std::string> s1 =

{ "11", "22", "33", "xx", "yy", "gg", "string" };

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_4", d4),

std::make_pair("col_str", s1));

auto memory_use1 = df.get_memory_usage<double>("col_3");

std::cout << "DataFrame Memory Usage:\n" << memory_use1 << std::endl;

typedef DataFrameView<unsigned long> MyDataFrameView;

MyDataFrameView dfv =

df.get_view_by_loc<double, std::string>(Index2D<long> { 3, 6 });

dfv.shrink_to_fit<double, std::string>();

dfv.write<std::ostream, double, std::string>(std::cout);

dfv.get_column<double>("col_3")[0] = 88.0;

assert(dfv.get_column<double>("col_3")[0] ==

df.get_column<double>("col_3")[3]);

assert(dfv.get_column<double>("col_3")[0] == 88.0);

auto memory_use2 = dfv.get_memory_usage<double>("col_3");

std::cout << "View Memory Usage:\n" << memory_use2 << std::endl;

std::cout << "\nTesting remove_column() ..." << std::endl;

std::vector<unsigned long> idx =

{ 123450, 123451, 123452, 123450, 123455, 123450, 123449 };

std::vector<double> d1 = { 1, 2, 3, 4, 5, 6, 7 };

std::vector<double> d2 = { 8, 9, 10, 11, 12, 13, 14 };

std::vector<double> d3 = { 15, 16, 17, 18, 19, 20, 21 };

std::vector<int> i1 = { 22, 23, 24, 25 };

std::vector<std::string> s1 =

{ "11", "22", "33", "xx", "yy", "gg", "string" };

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_int", i1),

std::make_pair("col_str", s1));

df.write<std::ostream, double, int, std::string>(std::cout);

df.remove_column("col_2");

std::cout << "After removing column `col_2`" << std::endl;

df.write<std::ostream, double, int, std::string>(std::cout);

df.remove_column("col_str");

std::cout << "After removing column `col_str`" << std::endl;

df.write<std::ostream, double, int, std::string>(std::cout);

std::vector<double> d22 = { 8, 9, 10, 11, 12, 13, 14 };

df.load_column("col_2", std::move(d22));

std::cout << "After adding back column `col_2`" << std::endl;

df.write<std::ostream, double, int, std::string>(std::cout);

std::cout << "\nTesting get_view_by_idx()/slicing ..." << std::endl;

std::vector<unsigned long> idx =

{ 123450, 123451, 123452, 123453, 123454, 123455, 123456,

123457, 123458, 123459, 123460, 123461, 123462, 123466 };

std::vector<double> d1 = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 };

std::vector<double> d2 = { 8, 9, 10, 11, 12, 13, 14, 20, 22, 23,

30, 31, 32, 1.89 };

std::vector<double> d3 = { 15, 16, 17, 18, 19, 20, 21,

0.34, 1.56, 0.34, 2.3, 0.1, 0.89, 0.45 };

std::vector<int> i1 = { 22, 23, 24, 25, 99, 100, 101, 3, 2 };

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_4", i1));

typedef DataFrameView<unsigned long> MyDataFrameView;

MyDataFrame df2 =

df.get_data_by_idx<double, int>(

Index2D<MyDataFrame::IndexType> { 123452, 123460 });

MyDataFrameView dfv =

df.get_view_by_idx<double, int>(

Index2D<MyDataFrame::IndexType> { 123452, 123460 });

df.write<std::ostream, double, int>(std::cout);

df2.write<std::ostream, double, int>(std::cout);

dfv.write<std::ostream, double, int>(std::cout);

dfv.get_column<double>("col_3")[0] = 88.0;

assert(dfv.get_column<double>("col_3")[0] ==

df.get_column<double>("col_3")[2]);

assert(dfv.get_column<double>("col_3")[0] == 88.0);

std::cout << "\nTesting rename_column() ..." << std::endl;

std::vector<unsigned long> idx =

{ 123450, 123451, 123452, 123453, 123454, 123455, 123456,

123457, 123458, 123459, 123460, 123461, 123462, 123466 };

std::vector<double> d1 = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 };

std::vector<double> d2 =

{ 8, 9, 10, 11, 12, 13, 14, 20, 22, 23, 30, 31, 32, 1.89 };

std::vector<double> d3 =

{ 15, 16, 17, 18, 19, 20, 21, 0.34, 1.56, 0.34, 2.3, 0.1, 0.89, 0.45 };

std::vector<int> i1 = { 22, 23, 24, 25, 99, 100, 101, 3, 2 };

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_4", i1));

std::cout << "Before rename" << std::endl;

df.write<std::ostream, double, int>(std::cout);

df.rename_column("col_2", "renamed_column");

std::cout << "After rename" << std::endl;

df.write<std::ostream, double, int>(std::cout);

std::cout << "\nTesting get_col_unique_values() ..." << std::endl;

std::vector<unsigned long> idx =

{ 123450, 123451, 123452, 123453, 123454, 123455, 123456,

123457, 123458, 123459, 123460, 123461, 123462, 123466 };

std::vector<double> d1 = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 };

std::vector<double> d2 =

{ 8, 9, 10, 11, 12, 13, 14, 20, 22, 23, 30, 31, 32, 1.89 };

std::vector<double> d3 =

{ 15, 16, 15, 18, 19, 16, 21, 0.34, 1.56, 0.34, 2.3, 0.34, 0.89, 19.0 };

std::vector<int> i1 = { 22, 23, 24, 25, 99, 100, 101, 3, 2 };

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_4", i1));

df.write<std::ostream, double, int>(std::cout);

std::cout << "Getting unique values in column col_3" << std::endl;

const std::vector<double> result =

df.get_col_unique_values<double>("col_3");

for (auto &iter : result)

std::cout << iter << ",";

std::cout << std::endl;

std::cout << "\nTesting remove_data_by_idx() ..." << std::endl;

std::vector<unsigned long> idx =

{ 123450, 123451, 123452, 123453, 123454, 123455, 123456,

123457, 123458, 123459, 123460, 123461, 123462, 123466 };

std::vector<double> d1 = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 };

std::vector<double> d2 =

{ 8, 9, 10, 11, 12, 13, 14, 20, 22, 23, 30, 31, 32, 1.89 };

std::vector<double> d3 =

{ 15, 16, 17, 18, 19, 20, 21, 0.34, 1.56, 0.34, 2.3, 0.1, 0.89, 0.45 };

std::vector<int> i1 = { 22, 23, 24, 25, 99, 100, 101, 3, 2 };

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_4", i1));

df.write<std::ostream, double, int>(std::cout);

std::cout << "After removing by ibdex { 123452, 123460 }" << std::endl;

df.remove_data_by_idx<double, int>({ 123452, 123460 });

df.write<std::ostream, double, int>(std::cout);

std::cout << "\nTesting remove_data_by_loc() ..." << std::endl;

std::vector<unsigned long> idx =

{ 123450, 123451, 123452, 123453, 123454, 123455, 123456,

123457, 123458, 123459, 123460, 123461, 123462, 123466 };

std::vector<double> d1 = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 };

std::vector<double> d2 =

{ 8, 9, 10, 11, 12, 13, 14, 20, 22, 23, 30, 31, 32, 1.89 };

std::vector<double> d3 =

{ 15, 16, 17, 18, 19, 20, 21, 0.34, 1.56, 0.34, 2.3, 0.1, 0.89, 0.45 };

std::vector<int> i1 = { 22, 23, 24, 25, 99 };

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_4", i1));

df.write<std::ostream, double, int>(std::cout);

std::cout << "After removing by ibdex { 3, -3 }" << std::endl;

df.remove_data_by_loc<double, int>({ 3, -3 });

df.write<std::ostream, double, int>(std::cout);

std::cout << "\nTesting value_counts() ..." << std::endl;

const double my_nan = sqrt(-1);

std::vector<unsigned long> idx =

{ 123450, 123451, 123452, 123453, 123454, 123455, 123456,

123457, 123458, 123459, 123460, 123461, 123462, 123466 };

std::vector<double> d1 = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 };

std::vector<double> d2 =

{ 8, 9, 10, 11, 12, 13, 14, 20, 22, 23, 30, 31, 32, 1.89 };

std::vector<double> d3 =

{ 15, 16, 15, 18, 19, 16, 21, my_nan, 0.34, 1.56, 0.34, 2.3, 0.34,

19.0 };

std::vector<int> i1 = { 22, 23, 24, 25, 99 };

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_4", i1));

df.write<std::ostream, double, int>(std::cout);

auto result = df.value_counts<double>("col_3");

auto result2 = df.value_counts<int>("col_4");

auto result3 = df.value_counts<int>(3);

assert((result2.is_equal<double, int>(result3)));

std::cout << "After calling value_counts(cols_3)" << std::endl;

result.write<std::ostream, size_t>(std::cout);

std::cout << "\nTesting Index Inner Join ..." << std::endl;

std::vector<unsigned long> idx =

{ 123456, 123451, 123452, 123453, 123454, 123455, 123450,

123457, 123458, 123459, 123460, 123461, 123462, 123466 };

std::vector<double> d1 = { 7, 2, 3, 4, 5, 6, 1, 8, 9, 10, 11, 12, 13, 14 };

std::vector<double> d2 =

{ 14, 9, 10, 11, 12, 13, 8, 20, 22, 23, 30, 31, 32, 1.89 };

std::vector<double> d3 =

{ 21, 16, 15, 18, 19, 16, 15, 0.34, 1.56, 0.34, 2.3, 0.34, 19.0 };

std::vector<int> i1 = { 22, 23, 24, 25, 99 };

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_4", i1));

std::vector<unsigned long> idx2 =

{ 123452, 123453, 123455, 123458, 123466, 223450, 223451,

223454, 223456, 223457, 223459, 223460, 223462, 223461 };

std::vector<double> d12 =

{ 11, 12, 13, 14, 15, 16, 17, 18, 19, 110, 111, 112, 114, 113 };

std::vector<double> d22 =

{ 18, 19, 110, 111, 112, 113, 114, 120, 122, 123,

130, 131, 11.89, 132 };

std::vector<double> d32 =

{ 115, 116, 115, 118, 119, 116, 121,

10.34, 11.56, 10.34, 12.3, 119.0, 10.34 };

std::vector<int> i12 = { 122, 123, 124, 125, 199 };

MyDataFrame df2;

df2.load_data(std::move(idx2),

std::make_pair("xcol_1", d12),

std::make_pair("col_2", d22),

std::make_pair("xcol_3", d32),

std::make_pair("col_4", i12));

std::cout << "First DF:" << std::endl;

df.write<std::ostream, double, int>(std::cout);

std::cout << "Second DF2:" << std::endl;

df2.write<std::ostream, double, int>(std::cout);

MyDataFrame join_df =

df.join_by_index<decltype(df2), double, int>

(df2, join_policy::inner_join);

std::cout << "Now The joined DF:" << std::endl;

join_df.write<std::ostream, double, int>(std::cout);

std::cout << "\nTesting Index Left Join ..." << std::endl;

std::vector<unsigned long> idx =

{ 123450, 123451, 123452, 123453, 123454, 123455, 123456,

123457, 123458, 123459, 123460, 123461, 123462, 123466 };

std::vector<double> d1 = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 };

std::vector<double> d2 =

{ 8, 9, 10, 11, 12, 13, 14, 20, 22, 23, 30, 31, 32, 1.89 };

std::vector<double> d3 =

{ 15, 16, 15, 18, 19, 16, 21, 0.34, 1.56, 0.34, 2.3, 0.34, 19.0 };

std::vector<int> i1 = { 22, 23, 24, 25, 99 };

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_4", i1));

std::vector<unsigned long> idx2 =

{ 123452, 123453, 123455, 123458, 123466, 223450, 223451,

223454, 223456, 223457, 223459, 223460, 223461, 223462 };

std::vector<double> d12 =

{ 11, 12, 13, 14, 15, 16, 17, 18, 19, 110, 111, 112, 113, 114 };

std::vector<double> d22 =

{ 18, 19, 110, 111, 112, 113, 114, 120, 122, 123,

130, 131, 132, 11.89 };

std::vector<double> d32 =

{ 115, 116, 115, 118, 119, 116, 121,

10.34, 11.56, 10.34, 12.3, 10.34, 119.0 };

std::vector<int> i12 = { 122, 123, 124, 125, 199 };

MyDataFrame df2;

df2.load_data(std::move(idx2),

std::make_pair("xcol_1", d12),

std::make_pair("col_2", d22),

std::make_pair("xcol_3", d32),

std::make_pair("col_4", i12));

std::cout << "First DF:" << std::endl;