BooleanMask

class pandas::BooleanMask

pandas C++ class.

Example

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

// Use BooleanMask
BooleanMask obj;
// ... operations ...

Constructors

Signature	Location	Example
BooleanMask() = default	pd_boolean_mask.h:32	View
explicit BooleanMask(std::vector<bool> d)	pd_boolean_mask.h:34	View
BooleanMask(std::vector<bool> d, std::vector<bool> na)	pd_boolean_mask.h:50	View
explicit BooleanMask(const BooleanArray& ba)	pd_boolean_mask.h:57	View

Missing Data

Signature	Return Type	Location	Example
BooleanMask fillna(bool value) const	BooleanMask	pd_boolean_mask.h:141	View

Statistics

Signature	Return Type	Location	Example
int64_t sum() const	int64_t	pd_boolean_mask.h:151	View

I/O

Signature	Return Type	Location	Example
std::string to_string() const	std::string	pd_boolean_mask.h:196	View

Type Checking

Signature	Return Type	Location	Example
bool is_na(size_t i) const { return boolean_data.is_na(i)	bool	pd_boolean_mask.h:67	View

Other Methods

Signature	Return Type	Location	Example
bool all() const	bool	pd_boolean_mask.h:156	View
bool any() const	bool	pd_boolean_mask.h:161	View
bool data_at(size_t i) const	bool	pd_boolean_mask.h:170	View
std::vector<bool> data_vector() const	std::vector<bool>	pd_boolean_mask.h:175	View
bool has_na() const { return boolean_data.has_na()	bool	pd_boolean_mask.h:66	View
std::vector<bool> na_mask_vector() const	std::vector<bool>	pd_boolean_mask.h:184	View
BooleanMask result(boolean_data & other.boolean_data)	BooleanMask	pd_boolean_mask.h:74	View
BooleanMask result(boolean_data \| other.boolean_data)	BooleanMask	pd_boolean_mask.h:84	View
BooleanMask result(~boolean_data)	BooleanMask	pd_boolean_mask.h:94	View
BooleanMask result(boolean_data ^ other.boolean_data)	BooleanMask	pd_boolean_mask.h:104	View
BooleanMask result(boolean_data & scalar)	BooleanMask	pd_boolean_mask.h:118	View
BooleanMask result(boolean_data \| scalar)	BooleanMask	pd_boolean_mask.h:128	View
BooleanMask result(boolean_data.fillna(value))	BooleanMask	pd_boolean_mask.h:142	View
size_t size() const { return boolean_data.size()	size_t	pd_boolean_mask.h:65	View
std::vector<std::optional<bool>> vals(d.size())	std::vector<std::optional<bool>>	pd_boolean_mask.h:35	View
std::vector<std::optional<bool>> vals(d.size())	std::vector<std::optional<bool>>	pd_boolean_mask.h:44	View
std::vector<std::optional<bool>> vals(d.size())	std::vector<std::optional<bool>>	pd_boolean_mask.h:51	View

Code Examples

The following examples are extracted from the test suite.

BooleanMask (pd_test_5_all.cpp:92531)

    return pandas::Series<std::int64_t>({10, 20, 30, 40, 50},
                                        std::string("i5"));
}

static pandas::Series<std::string> make_str_series_5() {
    return pandas::Series<std::string>({"a", "b", "c", "d", "e"},
                                       std::string("s5"));
}

static pandas::BooleanMask make_mask_TFTFT() {
    return pandas::BooleanMask(std::vector<bool>{true, false, true, false,
                                                 true});
}

static pandas::BooleanMask make_mask_all_false() {
    return pandas::BooleanMask(std::vector<bool>{false, false, false, false,
                                                 false});
}

static pandas::BooleanMask make_mask_all_true() {
    return pandas::BooleanMask(std::vector<bool>{true, true, true, true,

BooleanMask (pd_test_5_all.cpp:92531)

    return pandas::Series<std::int64_t>({10, 20, 30, 40, 50},
                                        std::string("i5"));
}

static pandas::Series<std::string> make_str_series_5() {
    return pandas::Series<std::string>({"a", "b", "c", "d", "e"},
                                       std::string("s5"));
}

static pandas::BooleanMask make_mask_TFTFT() {
    return pandas::BooleanMask(std::vector<bool>{true, false, true, false,
                                                 true});
}

static pandas::BooleanMask make_mask_all_false() {
    return pandas::BooleanMask(std::vector<bool>{false, false, false, false,
                                                 false});
}

static pandas::BooleanMask make_mask_all_true() {
    return pandas::BooleanMask(std::vector<bool>{true, true, true, true,

BooleanMask (pd_test_5_all.cpp:92531)

    return pandas::Series<std::int64_t>({10, 20, 30, 40, 50},
                                        std::string("i5"));
}

static pandas::Series<std::string> make_str_series_5() {
    return pandas::Series<std::string>({"a", "b", "c", "d", "e"},
                                       std::string("s5"));
}

static pandas::BooleanMask make_mask_TFTFT() {
    return pandas::BooleanMask(std::vector<bool>{true, false, true, false,
                                                 true});
}

static pandas::BooleanMask make_mask_all_false() {
    return pandas::BooleanMask(std::vector<bool>{false, false, false, false,
                                                 false});
}

static pandas::BooleanMask make_mask_all_true() {
    return pandas::BooleanMask(std::vector<bool>{true, true, true, true,

BooleanMask (pd_test_5_all.cpp:92531)

    return pandas::Series<std::int64_t>({10, 20, 30, 40, 50},
                                        std::string("i5"));
}

static pandas::Series<std::string> make_str_series_5() {
    return pandas::Series<std::string>({"a", "b", "c", "d", "e"},
                                       std::string("s5"));
}

static pandas::BooleanMask make_mask_TFTFT() {
    return pandas::BooleanMask(std::vector<bool>{true, false, true, false,
                                                 true});
}

static pandas::BooleanMask make_mask_all_false() {
    return pandas::BooleanMask(std::vector<bool>{false, false, false, false,
                                                 false});
}

static pandas::BooleanMask make_mask_all_true() {
    return pandas::BooleanMask(std::vector<bool>{true, true, true, true,

fillna (pd_test_1_all.cpp:537)

            throw std::runtime_error("pd_test_categorical_array_na_handling failed: isna size != 4");
        }

        // Test dropna
        pandas::CategoricalArray dropped = arr.dropna();
        if (dropped.size() != 2) {
            std::cout << "  [FAIL] : in pd_test_categorical_array_na_handling() : dropna size != 2" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_na_handling failed: dropna size != 2");
        }

        // Test fillna (fill with existing category)
        pandas::CategoricalArray filled = arr.fillna("a");  // 'a' is in categories
        if (filled.has_na()) {
            std::cout << "  [FAIL] : in pd_test_categorical_array_na_handling() : fillna should have no NA" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_na_handling failed: fillna should have no NA");
        }

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

    void pd_test_categorical_array_add_categories() {

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");
        }

to_string (pd_test_1_all.cpp:2693)

        pandas::PeriodArray arr_m(std::vector<std::string>{
            "2020-01",
            "NaT",
            "2025-06"
        }, "M");

        // Year
        auto years = arr_m.year();
        auto y0 = years[0];
        if (!y0.has_value() || y0.value() != 2020) {
            std::cout << "  [FAIL] : year[0] should be 2020, got " << (y0.has_value() ? std::to_string(y0.value()) : "NA") << std::endl;
            throw std::runtime_error("pd_test_period_array_year_month_quarter failed: year[0]");
        }

        auto y1 = years[1];
        if (y1.has_value()) {
            std::cout << "  [FAIL] : year[1] should be NA (NaT)" << std::endl;
            throw std::runtime_error("pd_test_period_array_year_month_quarter failed: year[1] should be NA");
        }

        auto y2 = years[2];

is_na (pd_test_1_all.cpp:51)

    void pd_test_boolean_array_na_handling() {
        std::cout << "========= BooleanArray: NA handling ======================= ";

        pandas::BooleanArray arr({
            std::optional<bool>(true),
            std::nullopt,  // NA at index 1
            std::optional<bool>(false)
        });

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

        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()) {

all (pd_test_1_all.cpp:247)

        pandas::BooleanArray has_true({
            std::optional<bool>(false),
            std::optional<bool>(true)
        });
        any_result = has_true.any();
        if (!any_result.has_value() || !any_result.value()) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_reductions() : any() with True" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_reductions failed: any() with True");
        }

        // Test all()
        pandas::BooleanArray all_true({
            std::optional<bool>(true),
            std::optional<bool>(true)
        });
        auto all_result = all_true.all();
        if (!all_result.has_value() || !all_result.value()) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_reductions() : all() of all True" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_reductions failed: all() all True");
        }

any (pd_test_1_all.cpp:226)

            std::cout << "  [FAIL] : in pd_test_boolean_array_kleene_not() : ~NA should be NA" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_kleene_not failed: ~NA");
        }

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

    void pd_test_boolean_array_reductions() {
        std::cout << "========= BooleanArray: reductions ======================= ";

        // Test any()
        pandas::BooleanArray all_false({
            std::optional<bool>(false),
            std::optional<bool>(false)
        });
        auto any_result = all_false.any();
        if (!any_result.has_value() || any_result.value()) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_reductions() : any() of all False" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_reductions failed: any() all False");
        }

data_at (pd_test_3_all.cpp:24087)

// ------------------- pd_test_agg_to_series.cpp (end) ---------------------------

// ------------------- pd_test_df_boolean_mask_core.cpp (begin) --------------------
namespace dataframe_tests_df_boolean_mask_core {

void test_boolean_mask_construct_data() {
    std::cout << "========= BooleanMask construct from vector<bool> ====== ";
    std::vector<bool> d1 = {true, false, true};
    pandas::BooleanMask m(d1);
    assert(m.size() == 3);
    assert(m.data_at(0) == true);
    assert(m.data_at(1) == false);
    assert(m.data_at(2) == true);
    auto dv = m.data_vector();
    assert(dv.size() == 3);
    assert(dv[0] == true);
    assert(dv[1] == false);
    assert(dv[2] == true);
    std::cout << " -> tests passed" << std::endl;
}

data_vector (pd_test_3_all.cpp:24090)

namespace dataframe_tests_df_boolean_mask_core {

void test_boolean_mask_construct_data() {
    std::cout << "========= BooleanMask construct from vector<bool> ====== ";
    std::vector<bool> d1 = {true, false, true};
    pandas::BooleanMask m(d1);
    assert(m.size() == 3);
    assert(m.data_at(0) == true);
    assert(m.data_at(1) == false);
    assert(m.data_at(2) == true);
    auto dv = m.data_vector();
    assert(dv.size() == 3);
    assert(dv[0] == true);
    assert(dv[1] == false);
    assert(dv[2] == true);
    std::cout << " -> tests passed" << std::endl;
}

void test_boolean_mask_construct_na() {
    std::cout << "========= BooleanMask construct with NA mask ====== ";
    std::vector<bool> d1 = {true, false, true};

has_na (pd_test_1_all.cpp:61)

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

        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;

na_mask_vector (pd_test_3_all.cpp:24108)

void test_boolean_mask_construct_na() {
    std::cout << "========= BooleanMask construct with NA mask ====== ";
    std::vector<bool> d1 = {true, false, true};
    std::vector<bool> na1 = {false, true, false};
    pandas::BooleanMask m(d1, na1);
    assert(m.size() == 3);
    assert(m.has_na());
    assert(!m.is_na(0));
    assert(m.is_na(1));
    assert(!m.is_na(2));
    auto nav = m.na_mask_vector();
    assert(nav.size() == 3);
    assert(nav[0] == false);
    assert(nav[1] == true);
    assert(nav[2] == false);
    std::cout << " -> tests passed" << std::endl;
}

void test_boolean_mask_construct_index() {
    std::cout << "========= BooleanMask construct with index labels ====== ";
    std::vector<bool> d1 = {true, false};

result (pd_test_1_all.cpp:15406)

    data.setElementAt({0}, numpy::datetime64(100LL, numpy::DateTimeUnit::Nanosecond));
    data.setElementAt({1}, numpy::datetime64(200LL, numpy::DateTimeUnit::Nanosecond));

    numpy::NDArray<numpy::bool_> mask(std::vector<size_t>{2});
    mask.setElementAt({0}, numpy::bool_(false));
    mask.setElementAt({1}, numpy::bool_(false));

    pandas::DatetimeArray arr(data, mask);
    pandas::DatetimeIndexBase idx(arr, "original");

    // Create join result (int64 values)
    numpy::NDArray<numpy::int64> join_result(std::vector<size_t>{3});
    join_result.setElementAt({0}, numpy::int64(500LL));
    join_result.setElementAt({1}, numpy::int64(600LL));
    join_result.setElementAt({2}, numpy::int64(700LL));

    auto new_idx = idx._from_join_target(join_result);

    bool passed = (new_idx.size() == 3 &&
                   new_idx.name().has_value() && *new_idx.name() == "original");
    if (!passed) {

result (pd_test_1_all.cpp:15406)

    data.setElementAt({0}, numpy::datetime64(100LL, numpy::DateTimeUnit::Nanosecond));
    data.setElementAt({1}, numpy::datetime64(200LL, numpy::DateTimeUnit::Nanosecond));

    numpy::NDArray<numpy::bool_> mask(std::vector<size_t>{2});
    mask.setElementAt({0}, numpy::bool_(false));
    mask.setElementAt({1}, numpy::bool_(false));

    pandas::DatetimeArray arr(data, mask);
    pandas::DatetimeIndexBase idx(arr, "original");

    // Create join result (int64 values)
    numpy::NDArray<numpy::int64> join_result(std::vector<size_t>{3});
    join_result.setElementAt({0}, numpy::int64(500LL));
    join_result.setElementAt({1}, numpy::int64(600LL));
    join_result.setElementAt({2}, numpy::int64(700LL));

    auto new_idx = idx._from_join_target(join_result);

    bool passed = (new_idx.size() == 3 &&
                   new_idx.name().has_value() && *new_idx.name() == "original");
    if (!passed) {

result (pd_test_1_all.cpp:15406)

    data.setElementAt({0}, numpy::datetime64(100LL, numpy::DateTimeUnit::Nanosecond));
    data.setElementAt({1}, numpy::datetime64(200LL, numpy::DateTimeUnit::Nanosecond));

    numpy::NDArray<numpy::bool_> mask(std::vector<size_t>{2});
    mask.setElementAt({0}, numpy::bool_(false));
    mask.setElementAt({1}, numpy::bool_(false));

    pandas::DatetimeArray arr(data, mask);
    pandas::DatetimeIndexBase idx(arr, "original");

    // Create join result (int64 values)
    numpy::NDArray<numpy::int64> join_result(std::vector<size_t>{3});
    join_result.setElementAt({0}, numpy::int64(500LL));
    join_result.setElementAt({1}, numpy::int64(600LL));
    join_result.setElementAt({2}, numpy::int64(700LL));

    auto new_idx = idx._from_join_target(join_result);

    bool passed = (new_idx.size() == 3 &&
                   new_idx.name().has_value() && *new_idx.name() == "original");
    if (!passed) {

result (pd_test_1_all.cpp:15406)

    data.setElementAt({0}, numpy::datetime64(100LL, numpy::DateTimeUnit::Nanosecond));
    data.setElementAt({1}, numpy::datetime64(200LL, numpy::DateTimeUnit::Nanosecond));

    numpy::NDArray<numpy::bool_> mask(std::vector<size_t>{2});
    mask.setElementAt({0}, numpy::bool_(false));
    mask.setElementAt({1}, numpy::bool_(false));

    pandas::DatetimeArray arr(data, mask);
    pandas::DatetimeIndexBase idx(arr, "original");

    // Create join result (int64 values)
    numpy::NDArray<numpy::int64> join_result(std::vector<size_t>{3});
    join_result.setElementAt({0}, numpy::int64(500LL));
    join_result.setElementAt({1}, numpy::int64(600LL));
    join_result.setElementAt({2}, numpy::int64(700LL));

    auto new_idx = idx._from_join_target(join_result);

    bool passed = (new_idx.size() == 3 &&
                   new_idx.name().has_value() && *new_idx.name() == "original");
    if (!passed) {

result (pd_test_1_all.cpp:15406)

    data.setElementAt({0}, numpy::datetime64(100LL, numpy::DateTimeUnit::Nanosecond));
    data.setElementAt({1}, numpy::datetime64(200LL, numpy::DateTimeUnit::Nanosecond));

    numpy::NDArray<numpy::bool_> mask(std::vector<size_t>{2});
    mask.setElementAt({0}, numpy::bool_(false));
    mask.setElementAt({1}, numpy::bool_(false));

    pandas::DatetimeArray arr(data, mask);
    pandas::DatetimeIndexBase idx(arr, "original");

    // Create join result (int64 values)
    numpy::NDArray<numpy::int64> join_result(std::vector<size_t>{3});
    join_result.setElementAt({0}, numpy::int64(500LL));
    join_result.setElementAt({1}, numpy::int64(600LL));
    join_result.setElementAt({2}, numpy::int64(700LL));

    auto new_idx = idx._from_join_target(join_result);

    bool passed = (new_idx.size() == 3 &&
                   new_idx.name().has_value() && *new_idx.name() == "original");
    if (!passed) {

result (pd_test_1_all.cpp:15406)

    data.setElementAt({0}, numpy::datetime64(100LL, numpy::DateTimeUnit::Nanosecond));
    data.setElementAt({1}, numpy::datetime64(200LL, numpy::DateTimeUnit::Nanosecond));

    numpy::NDArray<numpy::bool_> mask(std::vector<size_t>{2});
    mask.setElementAt({0}, numpy::bool_(false));
    mask.setElementAt({1}, numpy::bool_(false));

    pandas::DatetimeArray arr(data, mask);
    pandas::DatetimeIndexBase idx(arr, "original");

    // Create join result (int64 values)
    numpy::NDArray<numpy::int64> join_result(std::vector<size_t>{3});
    join_result.setElementAt({0}, numpy::int64(500LL));
    join_result.setElementAt({1}, numpy::int64(600LL));
    join_result.setElementAt({2}, numpy::int64(700LL));

    auto new_idx = idx._from_join_target(join_result);

    bool passed = (new_idx.size() == 3 &&
                   new_idx.name().has_value() && *new_idx.name() == "original");
    if (!passed) {

result (pd_test_1_all.cpp:15406)

    data.setElementAt({0}, numpy::datetime64(100LL, numpy::DateTimeUnit::Nanosecond));
    data.setElementAt({1}, numpy::datetime64(200LL, numpy::DateTimeUnit::Nanosecond));

    numpy::NDArray<numpy::bool_> mask(std::vector<size_t>{2});
    mask.setElementAt({0}, numpy::bool_(false));
    mask.setElementAt({1}, numpy::bool_(false));

    pandas::DatetimeArray arr(data, mask);
    pandas::DatetimeIndexBase idx(arr, "original");

    // Create join result (int64 values)
    numpy::NDArray<numpy::int64> join_result(std::vector<size_t>{3});
    join_result.setElementAt({0}, numpy::int64(500LL));
    join_result.setElementAt({1}, numpy::int64(600LL));
    join_result.setElementAt({2}, numpy::int64(700LL));

    auto new_idx = idx._from_join_target(join_result);

    bool passed = (new_idx.size() == 3 &&
                   new_idx.name().has_value() && *new_idx.name() == "original");
    if (!passed) {

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)

vals (pd_test_3_all.cpp:12418)

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

// ============================================================================
// Test 22: memory_usage()
// ============================================================================
void pd_test_series_memory_usage() {
    std::cout << "========= Series.memory_usage() ====================";

    std::vector<double> vals(1000);
    pandas::Series<double> s(vals, "test");

    size_t mem = s.memory_usage();
    // Should be at least 1000 * sizeof(double)
    if (mem < 1000 * sizeof(double)) {
        std::cout << "  [FAIL] : memory_usage too small" << std::endl;
        throw std::runtime_error("pd_test_series_memory_usage failed");
    }

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

vals (pd_test_3_all.cpp:12418)

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

// ============================================================================
// Test 22: memory_usage()
// ============================================================================
void pd_test_series_memory_usage() {
    std::cout << "========= Series.memory_usage() ====================";

    std::vector<double> vals(1000);
    pandas::Series<double> s(vals, "test");

    size_t mem = s.memory_usage();
    // Should be at least 1000 * sizeof(double)
    if (mem < 1000 * sizeof(double)) {
        std::cout << "  [FAIL] : memory_usage too small" << std::endl;
        throw std::runtime_error("pd_test_series_memory_usage failed");
    }

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

vals (pd_test_3_all.cpp:12418)

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

// ============================================================================
// Test 22: memory_usage()
// ============================================================================
void pd_test_series_memory_usage() {
    std::cout << "========= Series.memory_usage() ====================";

    std::vector<double> vals(1000);
    pandas::Series<double> s(vals, "test");

    size_t mem = s.memory_usage();
    // Should be at least 1000 * sizeof(double)
    if (mem < 1000 * sizeof(double)) {
        std::cout << "  [FAIL] : memory_usage too small" << std::endl;
        throw std::runtime_error("pd_test_series_memory_usage failed");
    }

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