DataFrameResampler

class pandas::DataFrameResampler

Window operation class for rolling/expanding calculations.

Example

#include <pandas/pandas.h>
using namespace pandas;

// Use DataFrameResampler
DataFrameResampler obj;
// ... operations ...

Constructors

Signature	Location	Example
DataFrameResampler(const DataFrame& df, const std::string& freq, const std::string& closed = "", const std::string& label = "", const std::string& origin = "epoch", int64_t offset_nanos = 0)	pd_resampler.h:308

Indexing / Selection

Signature	Return Type	Location	Example
DataFrame first() const	DataFrame	pd_resampler.h:361	View
std::vector<std::string> get_numeric_columns() const	std::vector<std::string>	pd_resampler.h:424
int64_t get_period_key(int64_t epoch_ns) const	int64_t	pd_resampler.h:422
DataFrame last() const	DataFrame	pd_resampler.h:364	View

Missing Data

Signature	Return Type	Location	Example
DataFrame bfill() const	DataFrame	pd_resampler.h:387	View
DataFrame ffill() const	DataFrame	pd_resampler.h:377	View

Statistics

Signature	Return Type	Location	Example
DataFrame count() const	DataFrame	pd_resampler.h:335	View
DataFrame max() const	DataFrame	pd_resampler.h:332	View
DataFrame mean() const	DataFrame	pd_resampler.h:330	View
DataFrame median() const	DataFrame	pd_resampler.h:336	View
DataFrame min() const	DataFrame	pd_resampler.h:331	View
DataFrame std_(int ddof = 1) const	DataFrame	pd_resampler.h:333	View
DataFrame sum() const	DataFrame	pd_resampler.h:329	View
DataFrame var(int ddof = 1) const	DataFrame	pd_resampler.h:334	View

Aggregation

Signature	Return Type	Location	Example
DataFrame agg(const std::string& func_name) const	DataFrame	pd_resampler.h:342	View
DataFrame agg(const std::vector<std::string>& funcs) const	DataFrame	pd_resampler.h:348	View
DataFrame agg(const std::vector<std::pair<std::string, std::vector<std::string>>>& col_funcs) const	DataFrame	pd_resampler.h:354	View
std::vector<double> aggregate_column(size_t col_idx, const std::string& func) const	std::vector<double>	pd_resampler.h:427
DataFrame transform(const std::string& func_name) const	DataFrame	pd_resampler.h:384	View

Other Methods

Signature	Return Type	Location	Example
void build_groups()	void	pd_resampler.h:421
const std::string& closed() const	const std::string&	pd_resampler.h:406	View
static double compute_agg(const std::vector<double>& values, const std::string& func, int ddof = 1)	static double	pd_resampler.h:430	View
const DataFrame& dataframe() const	const DataFrame&	pd_resampler.h:403	View
const std::string& freq() const	const std::string&	pd_resampler.h:400	View
const std::vector<int64_t>& group_keys() const	const std::vector<int64_t>&	pd_resampler.h:415
const std::unordered_map<int64_t, std::vector<size_t>>& groups() const	const std::unordered_map<int64_t, std::vector<size_t>>&	pd_resampler.h:412	View
const std::string& label() const	const std::string&	pd_resampler.h:409	View
size_t ngroups() const { return group_keys_order_.size()	size_t	pd_resampler.h:397	View
DataFrame ohlc() const	DataFrame	pd_resampler.h:370	View
int64_t period_key_to_timestamp(int64_t key) const	int64_t	pd_resampler.h:423
const std::vector<int64_t>& period_timestamps() const	const std::vector<int64_t>&	pd_resampler.h:418
DataFrame size() const	DataFrame	pd_resampler.h:394	View

Code Examples

The following examples are extracted from the test suite.

first (pd_test_1_all.cpp:11616)

        void pd_test_groupby_first_last() {
            std::cout << "========= GroupBy first/last ====================";

            std::map<std::string, std::vector<double>> data = {
                {"category", {1.0, 1.0, 2.0, 2.0}},
                {"value", {10.0, 20.0, 30.0, 40.0}}
            };
            pandas::DataFrame df(data);

            auto first_result = df.groupby("category").first();
            auto last_result = df.groupby("category").last();

            // First for group 1: 10, group 2: 30
            // Last for group 1: 20, group 2: 40
            double first1 = std::stod(first_result["value"].get_value_str(0));
            double first2 = std::stod(first_result["value"].get_value_str(1));

            bool passed = ((std::abs(first1 - 10.0) < 0.001 && std::abs(first2 - 30.0) < 0.001) ||
                          (std::abs(first1 - 30.0) < 0.001 && std::abs(first2 - 10.0) < 0.001));
            if (!passed) {

last (pd_test_1_all.cpp:11617)

        void pd_test_groupby_first_last() {
            std::cout << "========= GroupBy first/last ====================";

            std::map<std::string, std::vector<double>> data = {
                {"category", {1.0, 1.0, 2.0, 2.0}},
                {"value", {10.0, 20.0, 30.0, 40.0}}
            };
            pandas::DataFrame df(data);

            auto first_result = df.groupby("category").first();
            auto last_result = df.groupby("category").last();

            // First for group 1: 10, group 2: 30
            // Last for group 1: 20, group 2: 40
            double first1 = std::stod(first_result["value"].get_value_str(0));
            double first2 = std::stod(first_result["value"].get_value_str(1));

            bool passed = ((std::abs(first1 - 10.0) < 0.001 && std::abs(first2 - 30.0) < 0.001) ||
                          (std::abs(first1 - 30.0) < 0.001 && std::abs(first2 - 10.0) < 0.001));
            if (!passed) {
                std::cout << "  [FAIL] : in pd_test_groupby_first_last() : first values incorrect" << std::endl;

bfill (pd_test_1_all.cpp:23603)

        std::cout << "====================================== [OK] pd_test_equals test suite ========================== " << std::endl;
        return 0;
    }

} // namespace dataframe_tests
// ------------------- pd_test_equals.cpp (end) -----------------------------

// ------------------- pd_test_ffill_bfill.cpp (start) -----------------------------
// dataframe_tests/pd_test_ffill_bfill.cpp
// Test file for DataFrame.ffill() and DataFrame.bfill() methods

#include <iostream>
#include <stdexcept>
#include <cmath>
#include <limits>
#include <map>
#include "../pandas/pd_dataframe.h"

// CRITICAL: No using namespace directives

ffill (pd_test_1_all.cpp:23603)

        std::cout << "====================================== [OK] pd_test_equals test suite ========================== " << std::endl;
        return 0;
    }

} // namespace dataframe_tests
// ------------------- pd_test_equals.cpp (end) -----------------------------

// ------------------- pd_test_ffill_bfill.cpp (start) -----------------------------
// dataframe_tests/pd_test_ffill_bfill.cpp
// Test file for DataFrame.ffill() and DataFrame.bfill() methods

#include <iostream>
#include <stdexcept>
#include <cmath>
#include <limits>
#include <map>
#include "../pandas/pd_dataframe.h"

// CRITICAL: No using namespace directives

count (pd_test_1_all.cpp:66)

        if (arr.is_na(0)) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_na_handling() : is_na(0) should be false" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_na_handling failed: is_na(0) should be false");
        }

        if (!arr.has_na()) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_na_handling() : has_na() should be true" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_na_handling failed: has_na() should be true");
        }

        if (arr.count() != 2) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_na_handling() : count() should be 2" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_na_handling failed: count() should be 2");
        }

        std::cout << " -> tests passed" << std::endl;
    }

    void pd_test_boolean_array_kleene_and() {
        std::cout << "========= BooleanArray: Kleene AND ======================= ";

max (pd_test_1_all.cpp:771)

        pandas::CategoricalArray arr = pandas::CategoricalArray::from_codes(codes, cats, true);  // ordered

        // Test min
        std::optional<std::string> min_val = arr.min();
        if (!min_val.has_value() || *min_val != "low") {
            std::cout << "  [FAIL] : in pd_test_categorical_array_ordered_operations() : min != 'low'" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_ordered_operations failed: min != 'low'");
        }

        // Test max
        std::optional<std::string> max_val = arr.max();
        if (!max_val.has_value() || *max_val != "high") {
            std::cout << "  [FAIL] : in pd_test_categorical_array_ordered_operations() : max != 'high'" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_ordered_operations failed: max != 'high'");
        }

        // Test unordered throws for min/max
        pandas::CategoricalArray unordered = arr.as_unordered();
        bool threw = false;
        try {
            unordered.min();

mean (pd_test_1_all.cpp:282)

            std::optional<bool>(true),
            std::optional<bool>(true)
        });

        auto s = arr.sum();
        if (!s.has_value() || s.value() != 3) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_reductions() : sum should be 3" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_reductions failed: sum");
        }

        auto m = arr.mean();
        if (!m.has_value() || std::abs(m.value() - 0.75) > 0.001) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_reductions() : mean should be 0.75" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_reductions failed: mean");
        }

        std::cout << " -> tests passed" << std::endl;
    }

    void pd_test_boolean_array_dtype() {
        std::cout << "========= BooleanArray: dtype ======================= ";

median (pd_test_1_all.cpp:20910)

                throw std::runtime_error("pd_test_expanding_var failed: expanding var values incorrect");
            }

            std::cout << " -> tests passed" << std::endl;
        }

        void pd_test_expanding_median() {
            std::cout << "========= Expanding median ======================";

            pandas::Series<double> s({1.0, 2.0, 3.0, 4.0, 5.0});
            auto result = s.expanding().median();

            // Expanding median: 1, 1.5, 2, 2.5, 3
            bool passed = std::abs(result[0] - 1.0) < 0.001 &&
                          std::abs(result[1] - 1.5) < 0.001 &&
                          std::abs(result[2] - 2.0) < 0.001 &&
                          std::abs(result[3] - 2.5) < 0.001 &&
                          std::abs(result[4] - 3.0) < 0.001;
            if (!passed) {
                std::cout << "  [FAIL] : in pd_test_expanding_median() : expanding median values incorrect" << std::endl;
                throw std::runtime_error("pd_test_expanding_median failed: expanding median values incorrect");

min (pd_test_1_all.cpp:764)

    }

    void pd_test_categorical_array_ordered_operations() {
        std::cout << "========= CategoricalArray: ordered operations (min/max) ======================= ";

        std::vector<std::string> cats = {"low", "medium", "high"};
        std::vector<numpy::int32> codes = {0, 2, 1, 0, -1};  // low, high, medium, low, NA
        pandas::CategoricalArray arr = pandas::CategoricalArray::from_codes(codes, cats, true);  // ordered

        // Test min
        std::optional<std::string> min_val = arr.min();
        if (!min_val.has_value() || *min_val != "low") {
            std::cout << "  [FAIL] : in pd_test_categorical_array_ordered_operations() : min != 'low'" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_ordered_operations failed: min != 'low'");
        }

        // Test max
        std::optional<std::string> max_val = arr.max();
        if (!max_val.has_value() || *max_val != "high") {
            std::cout << "  [FAIL] : in pd_test_categorical_array_ordered_operations() : max != 'high'" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_ordered_operations failed: max != 'high'");

std_ (pd_test_1_all.cpp:20752)

                throw std::runtime_error("pd_test_rolling_min_periods failed: with min_periods=1, idx 1 should be 3.0");
            }

            std::cout << " -> tests passed" << std::endl;
        }

        void pd_test_rolling_std() {
            std::cout << "========= Rolling std ===========================";

            pandas::Series<double> s({1.0, 2.0, 3.0, 4.0, 5.0});
            auto result = s.rolling(3).std_();

            // std([1,2,3]) = 1.0 (ddof=1)
            // std([2,3,4]) = 1.0
            // std([3,4,5]) = 1.0
            bool passed = std::abs(result[2] - 1.0) < 0.001;
            if (!passed) {
                std::cout << "  [FAIL] : in pd_test_rolling_std() : rolling std should be 1.0" << std::endl;
                throw std::runtime_error("pd_test_rolling_std failed: rolling std should be 1.0");
            }

sum (pd_test_1_all.cpp:276)

        }

        // Test sum/mean
        pandas::BooleanArray arr({
            std::optional<bool>(true),
            std::optional<bool>(false),
            std::optional<bool>(true),
            std::optional<bool>(true)
        });

        auto s = arr.sum();
        if (!s.has_value() || s.value() != 3) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_reductions() : sum should be 3" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_reductions failed: sum");
        }

        auto m = arr.mean();
        if (!m.has_value() || std::abs(m.value() - 0.75) > 0.001) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_reductions() : mean should be 0.75" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_reductions failed: mean");
        }

var (pd_test_1_all.cpp:20890)

                throw std::runtime_error("pd_test_expanding_std failed: expanding std values incorrect");
            }

            std::cout << " -> tests passed" << std::endl;
        }

        void pd_test_expanding_var() {
            std::cout << "========= Expanding var =========================";

            pandas::Series<double> s({1.0, 2.0, 3.0, 4.0, 5.0});
            auto result = s.expanding().var();

            // Expanding var (ddof=1): NaN, 0.5, 1.0, 1.6667, 2.5
            bool passed = std::isnan(result[0]) &&
                          std::abs(result[1] - 0.5) < 0.001 &&
                          std::abs(result[2] - 1.0) < 0.001 &&
                          std::abs(result[3] - 1.6667) < 0.001 &&
                          std::abs(result[4] - 2.5) < 0.001;
            if (!passed) {
                std::cout << "  [FAIL] : in pd_test_expanding_var() : expanding var values incorrect" << std::endl;
                throw std::runtime_error("pd_test_expanding_var failed: expanding var values incorrect");

agg (pd_test_1_all.cpp:11100)

        }

        void pd_test_func_apply_series_agg() {
            std::cout << "========= Series agg ==================================";

            pandas::Series<double> s({1.0, 2.0, 3.0, 4.0, 5.0}, "values");

            bool passed = true;

            // Test string-based aggregation
            auto sum_result = s.agg("sum");
            if (!sum_result.has_value() || !approx_equal(sum_result.value(), 15.0)) {
                passed = false;
                std::cout << "  [FAIL] : in pd_test_func_apply_series_agg() : sum failed" << std::endl;
                throw std::runtime_error("pd_test_func_apply_series_agg failed: sum failed");
            }

            auto mean_result = s.agg("mean");
            if (!mean_result.has_value() || !approx_equal(mean_result.value(), 3.0)) {
                passed = false;
                std::cout << "  [FAIL] : in pd_test_func_apply_series_agg() : mean failed" << std::endl;

agg (pd_test_1_all.cpp:11100)

        }

        void pd_test_func_apply_series_agg() {
            std::cout << "========= Series agg ==================================";

            pandas::Series<double> s({1.0, 2.0, 3.0, 4.0, 5.0}, "values");

            bool passed = true;

            // Test string-based aggregation
            auto sum_result = s.agg("sum");
            if (!sum_result.has_value() || !approx_equal(sum_result.value(), 15.0)) {
                passed = false;
                std::cout << "  [FAIL] : in pd_test_func_apply_series_agg() : sum failed" << std::endl;
                throw std::runtime_error("pd_test_func_apply_series_agg failed: sum failed");
            }

            auto mean_result = s.agg("mean");
            if (!mean_result.has_value() || !approx_equal(mean_result.value(), 3.0)) {
                passed = false;
                std::cout << "  [FAIL] : in pd_test_func_apply_series_agg() : mean failed" << std::endl;

agg (pd_test_1_all.cpp:11100)

        }

        void pd_test_func_apply_series_agg() {
            std::cout << "========= Series agg ==================================";

            pandas::Series<double> s({1.0, 2.0, 3.0, 4.0, 5.0}, "values");

            bool passed = true;

            // Test string-based aggregation
            auto sum_result = s.agg("sum");
            if (!sum_result.has_value() || !approx_equal(sum_result.value(), 15.0)) {
                passed = false;
                std::cout << "  [FAIL] : in pd_test_func_apply_series_agg() : sum failed" << std::endl;
                throw std::runtime_error("pd_test_func_apply_series_agg failed: sum failed");
            }

            auto mean_result = s.agg("mean");
            if (!mean_result.has_value() || !approx_equal(mean_result.value(), 3.0)) {
                passed = false;
                std::cout << "  [FAIL] : in pd_test_func_apply_series_agg() : mean failed" << std::endl;

transform (pd_test_1_all.cpp:11071)

            std::cout << " -> tests passed" << std::endl;
        }

        void pd_test_func_apply_series_transform() {
            std::cout << "========= Series transform ============================";

            pandas::Series<double> s({1.0, 2.0, 3.0, 4.0}, "values");

            // Transform must return same shape
            auto result = s.transform([](double x) { return x * 2 + 1; });

            bool passed = true;
            if (result.size() != s.size()) {
                passed = false;
                std::cout << "  [FAIL] : in pd_test_func_apply_series_transform() : size changed" << std::endl;
                throw std::runtime_error("pd_test_func_apply_series_transform failed: size changed");
            }

            std::vector<double> expected = {3.0, 5.0, 7.0, 9.0};
            for (size_t i = 0; i < result.size(); ++i) {

closed (pd_test_1_all.cpp:1903)

// ============================================================================
void test_constructors() {
    std::cout << "========= IntervalArray: constructors ======================= ";

    // Default constructor
    pandas::IntervalArrayFloat64 empty;
    if (empty.size() != 0) {
        std::cout << "[FAIL] : in test_constructors() : default constructor size" << std::endl;
        return;
    }
    if (empty.closed() != pandas::IntervalClosed::Right) {
        std::cout << "[FAIL] : in test_constructors() : default closure" << std::endl;
        return;
    }

    // Constructor from left/right arrays
    numpy::NDArray<numpy::float64> left(std::vector<size_t>{3});
    numpy::NDArray<numpy::float64> right(std::vector<size_t>{3});
    left.setElementAt({0}, 0.0);  right.setElementAt({0}, 1.0);
    left.setElementAt({1}, 1.0);  right.setElementAt({1}, 2.0);
    left.setElementAt({2}, 2.0);  right.setElementAt({2}, 3.0);

compute_agg (pd_test_5_all.cpp:112204)

    // Default signature is groupby(by, axis, level, as_index, sort, group_keys, observed, dropna).
    auto gb = df_in.groupby("k", 0, std::nullopt, /*as_index=*/true,
                            /*sort=*/true, /*group_keys=*/true,
                            /*observed=*/false, /*dropna=*/true);
    pandas::DataFrame df = gb.agg("sum");
    std::string actual = df.to_string();

    // Pandas oracle (verified by analysis1 H3 logic + compute_agg empty=0.0):
    // - "a" observed, sum=10
    // - "b" observed, sum=20
    // - "c" unobserved -> compute_agg(empty, "sum") -> 0
    // Plan 12 (Logic-C int widening) has landed: aggregate_column now
    // preserves int64 for integer inputs, so the oracle is int64 with
    // integer literal display (no .0 suffix).
    std::string expected =
        "    v\n"
        "k    \n"
        "a  10\n"
        "b  20\n"
        "c   0";
    check_case("groupby_agg_dispatch_7c3a91_case_41",

dataframe (pd_test_2_all.cpp:11742)

                std::cout << "  [FAIL] : wrong dimensions" << std::endl;
                std::remove(temp_path.c_str());
                throw std::runtime_error("pd_test_to_hdf_mixed_types failed");
            }

            std::remove(temp_path.c_str());
            std::cout << " -> tests passed" << std::endl;
        }

        void pd_test_to_hdf_empty_dataframe() {
            std::cout << "========= to_hdf empty dataframe (real HDF5) ===================";

            pandas::DataFrame df;
            std::string temp_path = "temp/test_hdf5_empty.h5";
            df.to_hdf(temp_path, "df", "w");

            // Just verify file was created
            std::ifstream file(temp_path);
            if (!file.is_open()) {
                std::cout << "  [FAIL] : file not created" << std::endl;
                throw std::runtime_error("pd_test_to_hdf_empty_dataframe failed");

freq (pd_test_1_all.cpp:8233)

    std::cout << "========= freq property ===============================";

    std::vector<std::optional<numpy::datetime64>> values = {
        numpy::datetime64(0LL, numpy::DateTimeUnit::Nanosecond),
        numpy::datetime64(86400000000000LL, numpy::DateTimeUnit::Nanosecond)  // 1 day
    };
    pandas::DatetimeArray arr(values);
    pandas::DatetimeMixinIndex idx(arr);

    // Default freq is nullopt or inferred
    auto f = idx.freq();
    std::string fs = idx.freqstr();

    bool passed = true;  // freq may or may not be set
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_datetime_mixin_freq()" << std::endl;
        throw std::runtime_error("pd_test_datetime_mixin_freq failed");
    }

    std::cout << " -> tests passed" << std::endl;
}

groups (pd_test_2_all.cpp:20864)

// =====================================================================
// Per-group expanding tests
// =====================================================================

void test_series_groupby_expanding_sum() {
    std::cout << "  -- test_series_groupby_expanding_sum --" << std::endl;

    // Two groups: A=[1,2,3], B=[10,20]
    std::vector<numpy::float64> vals = {1.0, 10.0, 2.0, 20.0, 3.0};
    pandas::Series<numpy::float64> data(vals);
    pandas::Series<std::string> groups({"A", "B", "A", "B", "A"});

    auto sgb = data.groupby(groups);
    pandas::SeriesGroupByExpandingWindow ew(sgb, 1);
    auto result = ew.sum();

    check(result.size() == 5, "size_5");
    // A group: expanding sum = 1, 3, 6
    // B group: expanding sum = 10, 30
    // Original order: [A:1, B:10, A:3, B:30, A:6]
    check(approx_eq(result[0], 1.0), "A_exp_sum_0");

label (pd_test_4_all.cpp:4935)

// Helper: compare and report
// ----------------------------------------------------------------------------
static void check_str(const std::string& label,
                      const std::string& expected,
                      const std::string& actual) {
    int _f = 0;
    pandas_tests::check_str_ws(label, expected, actual, _f);
    if (_f > 0) throw std::runtime_error(label + ": str mismatch");
}

// Slugify a python compare-test label ("a.b.c" → "a_b_c") matching the
// scheme in scripts/gen_repr_mismatch_fixtures.py.
static std::string slugify_label(const std::string& label) {
    std::string out = label;
    for (char& ch : out) {
        if (ch == '.') ch = '_';
    }
    return out;
}

// Load a captured pandas-generated expected output file. The file is written

ngroups (pd_test_1_all.cpp:11497)

            // Create DataFrame with category column
            std::map<std::string, std::vector<double>> data = {
                {"category", {1.0, 1.0, 2.0, 2.0, 2.0}},
                {"value", {10.0, 20.0, 30.0, 40.0, 50.0}}
            };
            pandas::DataFrame df(data);

            // Test groupby
            auto grouped = df.groupby("category");

            bool passed = grouped.ngroups() == 2;
            if (!passed) {
                std::cout << "  [FAIL] : in pd_test_groupby_basic() : ngroups should be 2" << std::endl;
                throw std::runtime_error("pd_test_groupby_basic failed: ngroups should be 2");
            }

            std::cout << " -> tests passed" << std::endl;
        }

        void pd_test_groupby_multiple_columns() {
            std::cout << "========= GroupBy multiple columns ==============";

ohlc (pd_test_1_all.cpp:20388)

                "2020-01-01 11:00:00",
                "2020-01-01 12:00:00",
                "2020-01-02 09:00:00",
                "2020-01-02 10:00:00",
                "2020-01-02 11:00:00",
                "2020-01-02 12:00:00"
            };
            df.set_index(std::make_unique<pandas::Index<std::string>>(dates));

            auto resampler = df.resample("D");
            pandas::DataFrame result = resampler.ohlc();

            // Should have open, high, low, close columns
            const auto& cols = result.columns();
            bool has_open = false, has_high = false, has_low = false, has_close = false;
            for (size_t i = 0; i < cols.size(); ++i) {
                std::string c = cols[i];
                if (c.find("open") != std::string::npos) has_open = true;
                if (c.find("high") != std::string::npos) has_high = true;
                if (c.find("low") != std::string::npos) has_low = true;
                if (c.find("close") != std::string::npos) has_close = true;

size (pd_test_1_all.cpp:22)

#include "../pandas/pd_boolean_array.h"

namespace dataframe_tests {

namespace dataframe_tests_boolean_array {
    void pd_test_boolean_array_constructors() {
        std::cout << "========= BooleanArray: constructors ======================= ";

        // Default constructor
        pandas::BooleanArray arr1;
        if (arr1.size() != 0) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_constructors() : default constructor size != 0" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_constructors failed: default constructor size != 0");
        }

        // Initializer list constructor
        pandas::BooleanArray arr2({
            std::optional<bool>(true),
            std::optional<bool>(false),
            std::nullopt,
            std::optional<bool>(true)