IntervalArray

class pandas::IntervalArray

Extension array type for specialized data storage.

Example

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

// Use IntervalArray
IntervalArray obj;
// ... operations ...

Constructors

Signature	Location	Example
IntervalArray(const numpy::NDArray<T>& left, const numpy::NDArray<T>& right, const numpy::NDArray<numpy::bool_>& mask, IntervalClosed closed = IntervalClosed::Right, bool copy = false)	pd_interval_array.h:124
IntervalArray(const numpy::NDArray<T>& left, const numpy::NDArray<T>& right, IntervalClosed closed = IntervalClosed::Right)	pd_interval_array.h:144
explicit IntervalArray(const std::vector<std::optional<std::pair<T, T>>>& values, IntervalClosed closed = IntervalClosed::Right)	pd_interval_array.h:161

Construction

Signature	Return Type	Location	Example
static IntervalArray from_arrays(const std::vector<T>& left, const std::vector<T>& right, IntervalClosed closed = IntervalClosed::Right)	static IntervalArray	pd_interval_array.h:269	View
static IntervalArray from_arrays(const numpy::NDArray<T>& left, const numpy::NDArray<T>& right, IntervalClosed closed = IntervalClosed::Right)	static IntervalArray	pd_interval_array.h:290	View
static IntervalArray from_breaks(const std::vector<T>& breaks, IntervalClosed closed = IntervalClosed::Right)	static IntervalArray	pd_interval_array.h:230	View
static IntervalArray from_breaks(const numpy::NDArray<T>& breaks, IntervalClosed closed = IntervalClosed::Right)	static IntervalArray	pd_interval_array.h:251	View
static IntervalArray from_tuples(const std::vector<std::pair<T, T>>& tuples, IntervalClosed closed = IntervalClosed::Right)	static IntervalArray	pd_interval_array.h:303	View

Indexing / Selection

Signature	Return Type	Location	Example
const numpy::NDArray<numpy::bool_>& mask() const	const numpy::NDArray<numpy::bool_>&	pd_interval_array.h:558	View
IntervalArray take(const numpy::NDArray<numpy::int64>& indices) const	IntervalArray	pd_interval_array.h:1298	View

Data Manipulation

Signature	Return Type	Location	Example
IntervalArray dropna() const	IntervalArray	pd_interval_array.h:639	View

Missing Data

Signature	Return Type	Location	Example
IntervalArray fillna(const std::pair<T, T>& fill_value) const	IntervalArray	pd_interval_array.h:620	View
BooleanArray isna() const	BooleanArray	pd_interval_array.h:593	View
BooleanArray notna() const	BooleanArray	pd_interval_array.h:606	View

Statistics

Signature	Return Type	Location	Example
size_t count() const	size_t	pd_interval_array.h:661	View

Arithmetic

Signature	Return Type	Location	Example
const std::string& subtype_override() const	const std::string&	pd_interval_array.h:393	View

Comparison

Signature	Return Type	Location	Example
numpy::NDArray<T> left() const	numpy::NDArray<T>	pd_interval_array.h:418	View
size_t len() const	size_t	pd_interval_array.h:365	View
numpy::NDArray<T> length() const	numpy::NDArray<T>	pd_interval_array.h:454	View

Sorting

Signature	Return Type	Location	Example
numpy::NDArray<numpy::int64> argsort() const	numpy::NDArray<numpy::int64>	pd_interval_array.h:985	View

Combining

Signature	Return Type	Location	Example
static IntervalArray concat(const std::vector<IntervalArray>& arrays)	static IntervalArray	pd_interval_array.h:1362	View

I/O

Signature	Return Type	Location	Example
std::string to_string() const	std::string	pd_interval_array.h:1265	View
std::vector<std::optional<std::pair<T, T>>> to_tuples() const	std::vector<std::optional<std::pair<T, T>>>	pd_interval_array.h:858	View

Conversion

Signature	Return Type	Location	Example
IntervalArray copy() const	IntervalArray	pd_interval_array.h:1400	View

Set Operations

Signature	Return Type	Location	Example
IntervalArray unique() const	IntervalArray	pd_interval_array.h:1070	View

Type Checking

Signature	Return Type	Location	Example
BooleanArray is_empty() const	BooleanArray	pd_interval_array.h:478	View
bool is_left_closed() const	bool	pd_interval_array.h:400	View
bool is_na(size_t index) const	bool	pd_interval_array.h:578	View
bool is_non_overlapping_monotonic() const	bool	pd_interval_array.h:505	View
bool is_right_closed() const	bool	pd_interval_array.h:407	View

Other Methods

Signature	Return Type	Location	Example
numpy::int64 argmax() const	numpy::int64	pd_interval_array.h:1042	View
numpy::int64 argmin() const	numpy::int64	pd_interval_array.h:1018	View
IntervalClosed closed() const	IntervalClosed	pd_interval_array.h:372	View
std::string closed_string() const	std::string	pd_interval_array.h:379	View
BooleanArray contains(T value) const	BooleanArray	pd_interval_array.h:696	View
BooleanArray contains(const numpy::NDArray<T>& values) const	BooleanArray	pd_interval_array.h:734	View
const numpy::NDArray<T>& data_left() const	const numpy::NDArray<T>&	pd_interval_array.h:544
const numpy::NDArray<T>& data_right() const	const numpy::NDArray<T>&	pd_interval_array.h:551
dtype_type dtype() const	dtype_type	pd_interval_array.h:323	View
bool empty() const	bool	pd_interval_array.h:358	View
std::pair<IntegerArray<numpy::int64>, IntervalArray> factorize() const	std::pair<IntegerArray<numpy::int64>, IntervalArray>	pd_interval_array.h:1124	View
fmt_bound(oss, l)		pd_interval_array.h:1254
fmt_bound(oss, r)		pd_interval_array.h:1256
fmt_float(oss, l)		pd_interval_array.h:1204
fmt_float(oss, r)		pd_interval_array.h:1206
bool has_na() const	bool	pd_interval_array.h:674	View
std::string interval_to_string(size_t index) const	std::string	pd_interval_array.h:1176
oss << interval_to_string(i)	oss <<	pd_interval_array.h:1274
FloatingArray<numpy::float64> mid() const	FloatingArray<numpy::float64>	pd_interval_array.h:433	View
size_t nbytes() const	size_t	pd_interval_array.h:337	View
constexpr int ndim() const	constexpr int	pd_interval_array.h:344	View
BooleanArray overlaps(T other_left, T other_right, IntervalClosed other_closed) const	BooleanArray	pd_interval_array.h:781	View
BooleanArray overlaps(T other_left, T other_right) const	BooleanArray	pd_interval_array.h:829	View
numpy::NDArray<T> right() const	numpy::NDArray<T>	pd_interval_array.h:425	View
IntervalArray set_closed(IntervalClosed new_closed) const	IntervalArray	pd_interval_array.h:843	View
IntervalArray set_closed(const std::string& new_closed) const	IntervalArray	pd_interval_array.h:850	View
void set_subtype_override(const std::string& override)	void	pd_interval_array.h:386	View
std::vector<size_t> shape() const	std::vector<size_t>	pd_interval_array.h:351	View
size_t size() const	size_t	pd_interval_array.h:330	View
IntervalArray slice(size_t start, size_t stop, size_t step = 1) const	IntervalArray	pd_interval_array.h:1325	View
void validate_arrays()	void	pd_interval_array.h:57
void validate_bounds()	void	pd_interval_array.h:84

Internal Methods

1 internal methods (prefixed with underscore)

Code Examples

The following examples are extracted from the test suite.

from_arrays (pd_test_1_all.cpp:1994)

// ============================================================================
// Test: from_arrays factory method
// ============================================================================
void test_from_arrays() {
    std::cout << "========= IntervalArray: from_arrays ======================= ";

    std::vector<numpy::int64> left_vec = {0, 10, 20};
    std::vector<numpy::int64> right_vec = {5, 15, 25};

    auto arr = pandas::IntervalArrayInt64::from_arrays(left_vec, right_vec);

    if (arr.size() != 3) {
        std::cout << "[FAIL] : in test_from_arrays() : size" << std::endl;
        return;
    }

    auto interval1 = arr[1];
    if (!interval1.has_value() || interval1->first != 10 || interval1->second != 15) {
        std::cout << "[FAIL] : in test_from_arrays() : interval values" << std::endl;
        return;

from_arrays (pd_test_1_all.cpp:1994)

// ============================================================================
// Test: from_arrays factory method
// ============================================================================
void test_from_arrays() {
    std::cout << "========= IntervalArray: from_arrays ======================= ";

    std::vector<numpy::int64> left_vec = {0, 10, 20};
    std::vector<numpy::int64> right_vec = {5, 15, 25};

    auto arr = pandas::IntervalArrayInt64::from_arrays(left_vec, right_vec);

    if (arr.size() != 3) {
        std::cout << "[FAIL] : in test_from_arrays() : size" << std::endl;
        return;
    }

    auto interval1 = arr[1];
    if (!interval1.has_value() || interval1->first != 10 || interval1->second != 15) {
        std::cout << "[FAIL] : in test_from_arrays() : interval values" << std::endl;
        return;

from_breaks (pd_test_1_all.cpp:1955)

}

// ============================================================================
// Test: from_breaks factory method
// ============================================================================
void test_from_breaks() {
    std::cout << "========= IntervalArray: from_breaks ======================= ";

    // Create from breaks
    std::vector<numpy::float64> breaks = {0.0, 1.0, 2.0, 3.0, 4.0};
    auto arr = pandas::IntervalArrayFloat64::from_breaks(breaks);

    if (arr.size() != 4) {
        std::cout << "[FAIL] : in test_from_breaks() : size should be n-1" << std::endl;
        return;
    }

    // Check intervals
    auto interval0 = arr[0];
    if (!interval0.has_value() || interval0->first != 0.0 || interval0->second != 1.0) {
        std::cout << "[FAIL] : in test_from_breaks() : first interval" << std::endl;

from_breaks (pd_test_1_all.cpp:1955)

}

// ============================================================================
// Test: from_breaks factory method
// ============================================================================
void test_from_breaks() {
    std::cout << "========= IntervalArray: from_breaks ======================= ";

    // Create from breaks
    std::vector<numpy::float64> breaks = {0.0, 1.0, 2.0, 3.0, 4.0};
    auto arr = pandas::IntervalArrayFloat64::from_breaks(breaks);

    if (arr.size() != 4) {
        std::cout << "[FAIL] : in test_from_breaks() : size should be n-1" << std::endl;
        return;
    }

    // Check intervals
    auto interval0 = arr[0];
    if (!interval0.has_value() || interval0->first != 0.0 || interval0->second != 1.0) {
        std::cout << "[FAIL] : in test_from_breaks() : first interval" << std::endl;

from_tuples (pd_test_1_all.cpp:2022)

// ============================================================================
void test_from_tuples() {
    std::cout << "========= IntervalArray: from_tuples ======================= ";

    std::vector<std::pair<numpy::float64, numpy::float64>> tuples = {
        {0.0, 1.5},
        {1.5, 3.0},
        {3.0, 4.5}
    };

    auto arr = pandas::IntervalArrayFloat64::from_tuples(tuples);

    if (arr.size() != 3) {
        std::cout << "[FAIL] : in test_from_tuples() : size" << std::endl;
        return;
    }

    auto interval2 = arr[2];
    if (!interval2.has_value() || interval2->first != 3.0 || interval2->second != 4.5) {
        std::cout << "[FAIL] : in test_from_tuples() : interval values" << std::endl;
        return;

mask (pd_test_1_all.cpp:9119)

void pd_test_datetime_mixin_array_constructor() {
    std::cout << "========= DatetimeTDMixin array constructor =========================";

    // Create DatetimeArray with some values
    numpy::NDArray<numpy::datetime64> data(std::vector<size_t>{3});
    data.setElementAt({0}, numpy::datetime64(1000000000000000000LL, numpy::DateTimeUnit::Nanosecond));  // ~2001
    data.setElementAt({1}, numpy::datetime64(1500000000000000000LL, numpy::DateTimeUnit::Nanosecond));  // ~2017
    data.setElementAt({2}, numpy::datetime64(1600000000000000000LL, numpy::DateTimeUnit::Nanosecond));  // ~2020

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

    pandas::DatetimeArray arr(data, mask);
    pandas::DatetimeTDMixin idx(arr, "timestamps");

    bool passed = (idx.size() == 3 && !idx.empty() &&
                   idx.name().has_value() && *idx.name() == "timestamps" &&
                   idx.inferred_type() == "datetime");

take (pd_test_1_all.cpp:5903)

// Inherited Operations Tests
// ============================================================================

void pd_test_categorical_index_take() {
    std::cout << "========= inherited take ==============================";

    pandas::CategoricalArray arr({"a", "b", "c", "d"});
    pandas::CategoricalIndex idx(arr);

    std::vector<size_t> indices = {0, 2, 3};
    pandas::ExtensionIndex<pandas::CategoricalArray> taken = idx.take(indices);

    bool passed = (taken.size() == 3);
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_categorical_index_take()" << std::endl;
        throw std::runtime_error("pd_test_categorical_index_take failed");
    }

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

dropna (pd_test_1_all.cpp:531)

        }

        // Test isna array
        numpy::NDArray<numpy::bool_> na_mask = arr.isna();
        if (na_mask.getSize() != 4) {
            std::cout << "  [FAIL] : in pd_test_categorical_array_na_handling() : isna size != 4" << std::endl;
            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");

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

isna (pd_test_1_all.cpp:524)

            throw std::runtime_error("pd_test_categorical_array_na_handling failed: has_na() should be true");
        }

        // Test count (non-NA)
        if (arr.count() != 2) {
            std::cout << "  [FAIL] : in pd_test_categorical_array_na_handling() : count() != 2" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_na_handling failed: count() != 2");
        }

        // Test isna array
        numpy::NDArray<numpy::bool_> na_mask = arr.isna();
        if (na_mask.getSize() != 4) {
            std::cout << "  [FAIL] : in pd_test_categorical_array_na_handling() : isna size != 4" << std::endl;
            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");

notna (pd_test_1_all.cpp:6595)

                if (!na_mask.getElementAt({2, 1})) {
                    std::cout << "  [FAIL] : in pd_test_dataframe_manipulation() : isna at (2,1) should be true" << std::endl;
                    throw std::runtime_error("pd_test_dataframe_manipulation failed: isna at (2,1)");
                }
                // Row 0, col 0 should NOT be NA
                if (na_mask.getElementAt({0, 0})) {
                    std::cout << "  [FAIL] : in pd_test_dataframe_manipulation() : isna at (0,0) should be false" << std::endl;
                    throw std::runtime_error("pd_test_dataframe_manipulation failed: isna at (0,0)");
                }

                auto notna_mask = df_na.notna();
                if (notna_mask.getElementAt({1, 0})) {
                    std::cout << "  [FAIL] : in pd_test_dataframe_manipulation() : notna at (1,0) should be false" << std::endl;
                    throw std::runtime_error("pd_test_dataframe_manipulation failed: notna at (1,0)");
                }
            }

            // Test fillna
            {
                std::map<std::string, std::vector<numpy::float64>> float_data;
                float_data["X"] = {1.0, std::nan(""), 3.0};

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 ======================= ";

subtype_override (pd_test_3_all.cpp:24889)

    return dataframe_tests_bdate_timedelta_range::pd_test_bdate_timedelta_range_main();
}
// ------------------- pd_test_bdate_timedelta_range (end) ---------------------------

// ------------------- pd_test_interval_type_inference (begin) ---------------------------
namespace dataframe_tests_interval_type_inference {

void pd_test_interval_type_inference_breaks_int() {
    std::cout << "========= interval_type_inference_breaks_int ======================= ";
    auto idx = pandas::IntervalIndex<double>::from_breaks({0.0, 1.0, 2.0, 3.0});
    if (idx.subtype_override() != "int64")
        throw std::runtime_error("expected subtype_override 'int64', got '" + idx.subtype_override() + "'");
    std::string dtype = idx.dtype_name();
    if (dtype.find("int64") == std::string::npos)
        throw std::runtime_error("expected dtype containing 'int64', got '" + dtype + "'");
    std::string fmt = idx.format_interval(0);
    if (fmt.find('.') != std::string::npos)
        throw std::runtime_error("expected integer format without decimal, got '" + fmt + "'");
    std::cout << " -> tests passed" << std::endl;
}

left (pd_test_1_all.cpp:1909)

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

    pandas::IntervalArrayFloat64 arr1(left, right);
    if (arr1.size() != 3) {
        std::cout << "[FAIL] : in test_constructors() : array size" << std::endl;
        return;
    }

len (pd_test_3_all.cpp:20867)

    auto title_result = s.str().title();
    if (title_result[0] != "Hello World" || title_result[1] != "Hello World" || title_result[2] != "Hello World") {
        std::cout << "  [FAIL] : title() failed" << std::endl;
        throw std::runtime_error("pd_test_str_capitalize_title: title() failed");
    }

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

// ============================================================================
// Test str().len()
// ============================================================================

void pd_test_str_len() {
    std::cout << "========= Series.str().len() ============================";

    pandas::Series<std::string> s({"a", "bb", "ccc", ""});

    auto lens = s.str().len();
    if (lens[0] != 1 || lens[1] != 2 || lens[2] != 3 || lens[3] != 0) {
        std::cout << "  [FAIL] : len() failed" << std::endl;

length (pd_test_1_all.cpp:2137)

    auto mid0 = mid_arr[0];
    auto mid1 = mid_arr[1];
    auto mid2 = mid_arr[2];
    if (!mid0.has_value() || std::abs(mid0.value() - 1.0) > 1e-10 ||
        !mid1.has_value() || std::abs(mid1.value() - 3.5) > 1e-10 ||
        !mid2.has_value() || std::abs(mid2.value() - 7.5) > 1e-10) {
        std::cout << "[FAIL] : in test_left_right_mid_length() : mid()" << std::endl;
        return;
    }

    // Test length()
    auto len_arr = arr.length();
    if (len_arr.getElementAt({0}) != 2.0 ||
        len_arr.getElementAt({1}) != 3.0 ||
        len_arr.getElementAt({2}) != 5.0) {
        std::cout << "[FAIL] : in test_left_right_mid_length() : length()" << std::endl;
        return;
    }

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

argsort (pd_test_1_all.cpp:1304)

        std::cout << "========= DatetimeArray: sorting ======================= ";

        pandas::DatetimeArray arr(std::vector<std::string>{
            "2023-06-15",
            "NaT",
            "2023-01-01",
            "2023-12-31"
        });

        // argsort ascending
        auto indices = arr.argsort(true, "last");
        // Expected order: 2023-01-01(2), 2023-06-15(0), 2023-12-31(3), NaT(1)
        if (indices.getElementAt({0}) != 2) {
            std::cout << "  [FAIL] : argsort: first should be index 2 (2023-01-01)" << std::endl;
            throw std::runtime_error("pd_test_datetime_array_sorting failed: argsort first");
        }
        if (indices.getElementAt({3}) != 1) {
            std::cout << "  [FAIL] : argsort: last should be index 1 (NaT)" << std::endl;
            throw std::runtime_error("pd_test_datetime_array_sorting failed: NaT position");
        }

concat (pd_test_1_all.cpp:17717)

}

void pd_test_period_index_concat() {
    std::cout << "========= concat factory ==============================";

    std::vector<int64_t> ordinals1 = {0, 1};
    std::vector<int64_t> ordinals2 = {2, 3};
    pandas::PeriodIndex idx1(ordinals1, "D");
    pandas::PeriodIndex idx2(ordinals2, "D");

    pandas::PeriodIndex concatenated = pandas::PeriodIndex::concat({idx1, idx2});

    bool passed = (concatenated.size() == 4);
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_period_index_concat()" << std::endl;
        throw std::runtime_error("pd_test_period_index_concat failed");
    }

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

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];

to_tuples (pd_test_1_all.cpp:13037)

    }

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

void pd_test_interval_index_to_tuples() {
    std::cout << "========= to_tuples =========================";

    auto idx = pandas::IntervalIndex64::from_breaks({0, 1, 2, 3});

    auto tuples = idx.to_tuples();

    bool passed = (tuples.size() == 3 &&
                   tuples[0].has_value() && tuples[0]->first == 0 && tuples[0]->second == 1 &&
                   tuples[1].has_value() && tuples[1]->first == 1 && tuples[1]->second == 2 &&
                   tuples[2].has_value() && tuples[2]->first == 2 && tuples[2]->second == 3);
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_interval_index_to_tuples() : check failed" << std::endl;
        throw std::runtime_error("pd_test_interval_index_to_tuples failed");
    }

copy (pd_test_1_all.cpp:5798)

// ============================================================================
// Copy/Rename Tests
// ============================================================================

void pd_test_categorical_index_copy() {
    std::cout << "========= copy ========================================";

    pandas::CategoricalArray arr({"a", "b", "c"});
    pandas::CategoricalIndex idx(arr, "original");

    pandas::CategoricalIndex copied = idx.copy();

    bool passed = (copied.size() == idx.size() && copied.name() == idx.name() &&
                   copied.categories() == idx.categories() && copied.ordered() == idx.ordered());
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_categorical_index_copy()" << std::endl;
        throw std::runtime_error("pd_test_categorical_index_copy failed");
    }

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

unique (pd_test_1_all.cpp:1345)

        pandas::DatetimeArray arr(std::vector<std::string>{
            "2023-01-01",
            "2023-06-15",
            "2023-01-01",
            "NaT",
            "2023-06-15",
            "NaT"
        });

        // unique
        auto uniq = arr.unique();
        // Should have: NaT, 2023-01-01, 2023-06-15 (3 unique values)
        if (uniq.size() != 3) {
            std::cout << "  [FAIL] : unique size should be 3, got " << uniq.size() << std::endl;
            throw std::runtime_error("pd_test_datetime_array_unique failed: size");
        }

        // factorize
        auto [codes, uniques] = arr.factorize();
        // Codes for NaT should be -1
        if (codes.getElementAt({3}) != -1) {

is_empty (pd_test_1_all.cpp:2164)

    // Test with right-closed intervals (a, b]
    std::vector<std::pair<numpy::float64, numpy::float64>> tuples = {
        {0.0, 1.0},   // Not empty
        {1.0, 1.0},   // Empty (1, 1] has no points
        {2.0, 2.0},   // Empty
        {2.0, 3.0}    // Not empty
    };

    auto arr_right = pandas::IntervalArrayFloat64::from_tuples(tuples, pandas::IntervalClosed::Right);
    auto empty_right = arr_right.is_empty();

    if (empty_right[0].value_or(true) != false ||
        empty_right[1].value_or(false) != true ||
        empty_right[2].value_or(false) != true ||
        empty_right[3].value_or(true) != false) {
        std::cout << "[FAIL] : in test_is_empty() : right-closed" << std::endl;
        return;
    }

    // Test with both-closed intervals [a, b] - [1, 1] is NOT empty

is_left_closed (pd_test_1_all.cpp:12830)

}

void pd_test_interval_index_is_left_right_closed() {
    std::cout << "========= is_left_closed/is_right_closed =========================";

    auto idx_right = pandas::IntervalIndex64::from_breaks({0, 1, 2}, pandas::IntervalClosed::Right);
    auto idx_left = pandas::IntervalIndex64::from_breaks({0, 1, 2}, pandas::IntervalClosed::Left);
    auto idx_both = pandas::IntervalIndex64::from_breaks({0, 1, 2}, pandas::IntervalClosed::Both);
    auto idx_neither = pandas::IntervalIndex64::from_breaks({0, 1, 2}, pandas::IntervalClosed::Neither);

    bool passed = (!idx_right.is_left_closed() && idx_right.is_right_closed() &&
                   idx_left.is_left_closed() && !idx_left.is_right_closed() &&
                   idx_both.is_left_closed() && idx_both.is_right_closed() &&
                   !idx_neither.is_left_closed() && !idx_neither.is_right_closed());
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_interval_index_is_left_right_closed() : check failed" << std::endl;
        throw std::runtime_error("pd_test_interval_index_is_left_right_closed failed");
    }

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

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

is_non_overlapping_monotonic (pd_test_1_all.cpp:2457)

// ============================================================================
// Test: is_non_overlapping_monotonic
// ============================================================================
void test_is_non_overlapping_monotonic() {
    std::cout << "========= IntervalArray: is_non_overlapping_monotonic ======================= ";

    // Monotonic, non-overlapping
    std::vector<numpy::float64> breaks1 = {0.0, 1.0, 2.0, 3.0};
    auto arr1 = pandas::IntervalArrayFloat64::from_breaks(breaks1, pandas::IntervalClosed::Right);
    if (!arr1.is_non_overlapping_monotonic()) {
        std::cout << "[FAIL] : in test_is_non_overlapping_monotonic() : should be true for breaks" << std::endl;
        return;
    }

    // Non-monotonic (out of order)
    std::vector<std::pair<numpy::float64, numpy::float64>> tuples2 = {
        {2.0, 3.0}, {0.0, 1.0}, {1.0, 2.0}
    };
    auto arr2 = pandas::IntervalArrayFloat64::from_tuples(tuples2);
    if (arr2.is_non_overlapping_monotonic()) {

is_right_closed (pd_test_1_all.cpp:12830)

}

void pd_test_interval_index_is_left_right_closed() {
    std::cout << "========= is_left_closed/is_right_closed =========================";

    auto idx_right = pandas::IntervalIndex64::from_breaks({0, 1, 2}, pandas::IntervalClosed::Right);
    auto idx_left = pandas::IntervalIndex64::from_breaks({0, 1, 2}, pandas::IntervalClosed::Left);
    auto idx_both = pandas::IntervalIndex64::from_breaks({0, 1, 2}, pandas::IntervalClosed::Both);
    auto idx_neither = pandas::IntervalIndex64::from_breaks({0, 1, 2}, pandas::IntervalClosed::Neither);

    bool passed = (!idx_right.is_left_closed() && idx_right.is_right_closed() &&
                   idx_left.is_left_closed() && !idx_left.is_right_closed() &&
                   idx_both.is_left_closed() && idx_both.is_right_closed() &&
                   !idx_neither.is_left_closed() && !idx_neither.is_right_closed());
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_interval_index_is_left_right_closed() : check failed" << std::endl;
        throw std::runtime_error("pd_test_interval_index_is_left_right_closed failed");
    }

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

argmax (pd_test_1_all.cpp:1323)

        }

        // argmin
        auto min_idx = arr.argmin();
        if (!min_idx.has_value() || min_idx.value() != 2) {
            std::cout << "  [FAIL] : argmin should be 2 (2023-01-01)" << std::endl;
            throw std::runtime_error("pd_test_datetime_array_sorting failed: argmin");
        }

        // argmax
        auto max_idx = arr.argmax();
        if (!max_idx.has_value() || max_idx.value() != 3) {
            std::cout << "  [FAIL] : argmax should be 3 (2023-12-31)" << std::endl;
            throw std::runtime_error("pd_test_datetime_array_sorting failed: argmax");
        }

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

    void pd_test_datetime_array_unique() {
        std::cout << "========= DatetimeArray: unique/factorize ======================= ";

argmin (pd_test_1_all.cpp:1316)

        if (indices.getElementAt({0}) != 2) {
            std::cout << "  [FAIL] : argsort: first should be index 2 (2023-01-01)" << std::endl;
            throw std::runtime_error("pd_test_datetime_array_sorting failed: argsort first");
        }
        if (indices.getElementAt({3}) != 1) {
            std::cout << "  [FAIL] : argsort: last should be index 1 (NaT)" << std::endl;
            throw std::runtime_error("pd_test_datetime_array_sorting failed: NaT position");
        }

        // argmin
        auto min_idx = arr.argmin();
        if (!min_idx.has_value() || min_idx.value() != 2) {
            std::cout << "  [FAIL] : argmin should be 2 (2023-01-01)" << std::endl;
            throw std::runtime_error("pd_test_datetime_array_sorting failed: argmin");
        }

        // argmax
        auto max_idx = arr.argmax();
        if (!max_idx.has_value() || max_idx.value() != 3) {
            std::cout << "  [FAIL] : argmax should be 3 (2023-12-31)" << std::endl;
            throw std::runtime_error("pd_test_datetime_array_sorting failed: argmax");

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

closed_string (pd_test_1_all.cpp:12813)

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

void pd_test_interval_index_closed_string() {
    std::cout << "========= closed_string =========================";

    auto idx_right = pandas::IntervalIndex64::from_breaks({0, 1, 2}, pandas::IntervalClosed::Right);
    auto idx_left = pandas::IntervalIndex64::from_breaks({0, 1, 2}, pandas::IntervalClosed::Left);

    bool passed = (idx_right.closed_string() == "right" && idx_left.closed_string() == "left");
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_interval_index_closed_string() : closed_string check failed" << std::endl;
        throw std::runtime_error("pd_test_interval_index_closed_string failed");
    }

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

void pd_test_interval_index_is_left_right_closed() {
    std::cout << "========= is_left_closed/is_right_closed =========================";

contains (pd_test_1_all.cpp:2200)

// Test: contains method
// ============================================================================
void test_contains() {
    std::cout << "========= IntervalArray: contains ======================= ";

    std::vector<numpy::float64> breaks = {0.0, 1.0, 2.0, 3.0};

    // Right-closed intervals: (0, 1], (1, 2], (2, 3]
    auto arr_right = pandas::IntervalArrayFloat64::from_breaks(breaks, pandas::IntervalClosed::Right);

    // Test contains(1.0) - should be in interval 0 but not 1 (since 1 is exclusive on left of interval 1)
    auto contains_1 = arr_right.contains(1.0);
    // (0, 1] contains 1: yes, (1, 2] contains 1: no (open on left), (2, 3] contains 1: no
    if (contains_1[0].value_or(false) != true ||
        contains_1[1].value_or(true) != false ||
        contains_1[2].value_or(true) != false) {
        std::cout << "[FAIL] : in test_contains() : right-closed contains 1.0" << std::endl;
        return;
    }

    // Left-closed intervals: [0, 1), [1, 2), [2, 3)

contains (pd_test_1_all.cpp:2200)

// Test: contains method
// ============================================================================
void test_contains() {
    std::cout << "========= IntervalArray: contains ======================= ";

    std::vector<numpy::float64> breaks = {0.0, 1.0, 2.0, 3.0};

    // Right-closed intervals: (0, 1], (1, 2], (2, 3]
    auto arr_right = pandas::IntervalArrayFloat64::from_breaks(breaks, pandas::IntervalClosed::Right);

    // Test contains(1.0) - should be in interval 0 but not 1 (since 1 is exclusive on left of interval 1)
    auto contains_1 = arr_right.contains(1.0);
    // (0, 1] contains 1: yes, (1, 2] contains 1: no (open on left), (2, 3] contains 1: no
    if (contains_1[0].value_or(false) != true ||
        contains_1[1].value_or(true) != false ||
        contains_1[2].value_or(true) != false) {
        std::cout << "[FAIL] : in test_contains() : right-closed contains 1.0" << std::endl;
        return;
    }

    // Left-closed intervals: [0, 1), [1, 2), [2, 3)

dtype (pd_test_1_all.cpp:295)

            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 ======================= ";

        pandas::BooleanArray arr;
        if (arr.dtype().name() != "boolean") {
            std::cout << "  [FAIL] : in pd_test_boolean_array_dtype() : dtype name should be 'boolean'" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_dtype failed: dtype name");
        }

        if (arr.dtype().kind() != "b") {
            std::cout << "  [FAIL] : in pd_test_boolean_array_dtype() : dtype kind should be 'b'" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_dtype failed: dtype kind");
        }

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

empty (pd_test_1_all.cpp:941)

#include "../pandas/pd_config.h"

namespace dataframe_tests {

namespace dataframe_tests_config {

    void pd_test_config_version() {
        std::cout << "========= df_config: version info ======================= ";
        const char* version = pandas::DataFrameInfo::version();
        if (version == nullptr || std::string(version).empty()) {
            std::cout << "[FAIL] : in pd_test_config_version() : version is null or empty" << std::endl;
            throw std::runtime_error("pd_test_config_version failed: version is null or empty");
        }
        std::cout << "-> tests passed" << std::endl;
    }

    void pd_test_config_na_repr() {
        std::cout << "========= df_config: NA representation ======================= ";
        const char* na_repr = pandas::DataFrameConfig::get_na_repr();
        if (na_repr == nullptr) {

factorize (pd_test_1_all.cpp:1353)

        // unique
        auto uniq = arr.unique();
        // Should have: NaT, 2023-01-01, 2023-06-15 (3 unique values)
        if (uniq.size() != 3) {
            std::cout << "  [FAIL] : unique size should be 3, got " << uniq.size() << std::endl;
            throw std::runtime_error("pd_test_datetime_array_unique failed: size");
        }

        // factorize
        auto [codes, uniques] = arr.factorize();
        // Codes for NaT should be -1
        if (codes.getElementAt({3}) != -1) {
            std::cout << "  [FAIL] : factorize: NaT code should be -1" << std::endl;
            throw std::runtime_error("pd_test_datetime_array_unique failed: NaT code");
        }
        // Same values should have same codes
        if (codes.getElementAt({0}) != codes.getElementAt({2})) {
            std::cout << "  [FAIL] : factorize: 2023-01-01 values should have same code" << std::endl;
            throw std::runtime_error("pd_test_datetime_array_unique failed: same code");
        }

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;

mid (pd_test_1_all.cpp:2124)

    // Test right()
    auto right_arr = arr.right();
    if (right_arr.getElementAt({0}) != 2.0 ||
        right_arr.getElementAt({1}) != 5.0 ||
        right_arr.getElementAt({2}) != 10.0) {
        std::cout << "[FAIL] : in test_left_right_mid_length() : right()" << std::endl;
        return;
    }

    // Test mid()
    auto mid_arr = arr.mid();
    // (0+2)/2=1, (2+5)/2=3.5, (5+10)/2=7.5
    auto mid0 = mid_arr[0];
    auto mid1 = mid_arr[1];
    auto mid2 = mid_arr[2];
    if (!mid0.has_value() || std::abs(mid0.value() - 1.0) > 1e-10 ||
        !mid1.has_value() || std::abs(mid1.value() - 3.5) > 1e-10 ||
        !mid2.has_value() || std::abs(mid2.value() - 7.5) > 1e-10) {
        std::cout << "[FAIL] : in test_left_right_mid_length() : mid()" << std::endl;
        return;

nbytes (pd_test_1_all.cpp:6214)

            }

            // Test empty DataFrame
            pandas::DataFrame empty_df;
            if (!empty_df.empty()) {
                std::cout << "  [FAIL] : in pd_test_dataframe_properties() : should be empty" << std::endl;
                throw std::runtime_error("pd_test_dataframe_properties failed: should be empty");
            }

            // Test nbytes > 0 for non-empty
            if (df.nbytes() == 0) {
                std::cout << "  [FAIL] : in pd_test_dataframe_properties() : nbytes should be > 0" << std::endl;
                throw std::runtime_error("pd_test_dataframe_properties failed: nbytes should be > 0");
            }

            // Test columns index
            if (df.columns().size() != 3) {
                std::cout << "  [FAIL] : in pd_test_dataframe_properties() : columns size != 3" << std::endl;
                throw std::runtime_error("pd_test_dataframe_properties failed: columns size != 3");
            }

ndim (pd_test_1_all.cpp:6195)

            pandas::DataFrame df(data);

            // Test shape
            auto shape = df.shape();
            if (shape.size() != 2 || shape[0] != 4 || shape[1] != 3) {
                std::cout << "  [FAIL] : in pd_test_dataframe_properties() : shape mismatch" << std::endl;
                throw std::runtime_error("pd_test_dataframe_properties failed: shape mismatch");
            }

            // Test ndim
            if (df.ndim() != 2) {
                std::cout << "  [FAIL] : in pd_test_dataframe_properties() : ndim != 2" << std::endl;
                throw std::runtime_error("pd_test_dataframe_properties failed: ndim != 2");
            }

            // Test empty
            if (df.empty()) {
                std::cout << "  [FAIL] : in pd_test_dataframe_properties() : should not be empty" << std::endl;
                throw std::runtime_error("pd_test_dataframe_properties failed: should not be empty");
            }

overlaps (pd_test_1_all.cpp:2244)

// Test: overlaps method
// ============================================================================
void test_overlaps() {
    std::cout << "========= IntervalArray: overlaps ======================= ";

    std::vector<numpy::float64> breaks = {0.0, 2.0, 4.0, 6.0};
    // Right-closed: (0, 2], (2, 4], (4, 6]
    auto arr = pandas::IntervalArrayFloat64::from_breaks(breaks, pandas::IntervalClosed::Right);

    // Check overlap with (1, 3]
    auto overlap_1_3 = arr.overlaps(1.0, 3.0);
    // (0, 2] overlaps (1, 3]? Yes (share 1-2)
    // (2, 4] overlaps (1, 3]? Yes (share 2-3)
    // (4, 6] overlaps (1, 3]? No
    if (overlap_1_3[0].value_or(false) != true ||
        overlap_1_3[1].value_or(false) != true ||
        overlap_1_3[2].value_or(true) != false) {
        std::cout << "[FAIL] : in test_overlaps() : overlaps (1, 3]" << std::endl;
        return;
    }

overlaps (pd_test_1_all.cpp:2244)

// Test: overlaps method
// ============================================================================
void test_overlaps() {
    std::cout << "========= IntervalArray: overlaps ======================= ";

    std::vector<numpy::float64> breaks = {0.0, 2.0, 4.0, 6.0};
    // Right-closed: (0, 2], (2, 4], (4, 6]
    auto arr = pandas::IntervalArrayFloat64::from_breaks(breaks, pandas::IntervalClosed::Right);

    // Check overlap with (1, 3]
    auto overlap_1_3 = arr.overlaps(1.0, 3.0);
    // (0, 2] overlaps (1, 3]? Yes (share 1-2)
    // (2, 4] overlaps (1, 3]? Yes (share 2-3)
    // (4, 6] overlaps (1, 3]? No
    if (overlap_1_3[0].value_or(false) != true ||
        overlap_1_3[1].value_or(false) != true ||
        overlap_1_3[2].value_or(true) != false) {
        std::cout << "[FAIL] : in test_overlaps() : overlaps (1, 3]" << std::endl;
        return;
    }

right (pd_test_1_all.cpp:1910)

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

    pandas::IntervalArrayFloat64 arr1(left, right);
    if (arr1.size() != 3) {
        std::cout << "[FAIL] : in test_constructors() : array size" << std::endl;
        return;
    }

set_closed (pd_test_1_all.cpp:2285)

    std::vector<numpy::float64> breaks = {0.0, 1.0, 2.0};
    auto arr = pandas::IntervalArrayFloat64::from_breaks(breaks, pandas::IntervalClosed::Right);

    if (arr.closed() != pandas::IntervalClosed::Right) {
        std::cout << "[FAIL] : in test_set_closed() : initial closure" << std::endl;
        return;
    }

    // Change to left-closed
    auto arr_left = arr.set_closed(pandas::IntervalClosed::Left);
    if (arr_left.closed() != pandas::IntervalClosed::Left) {
        std::cout << "[FAIL] : in test_set_closed() : set to Left" << std::endl;
        return;
    }

    // Original should be unchanged
    if (arr.closed() != pandas::IntervalClosed::Right) {
        std::cout << "[FAIL] : in test_set_closed() : original changed" << std::endl;
        return;
    }

set_closed (pd_test_1_all.cpp:2285)

    std::vector<numpy::float64> breaks = {0.0, 1.0, 2.0};
    auto arr = pandas::IntervalArrayFloat64::from_breaks(breaks, pandas::IntervalClosed::Right);

    if (arr.closed() != pandas::IntervalClosed::Right) {
        std::cout << "[FAIL] : in test_set_closed() : initial closure" << std::endl;
        return;
    }

    // Change to left-closed
    auto arr_left = arr.set_closed(pandas::IntervalClosed::Left);
    if (arr_left.closed() != pandas::IntervalClosed::Left) {
        std::cout << "[FAIL] : in test_set_closed() : set to Left" << std::endl;
        return;
    }

    // Original should be unchanged
    if (arr.closed() != pandas::IntervalClosed::Right) {
        std::cout << "[FAIL] : in test_set_closed() : original changed" << std::endl;
        return;
    }

set_subtype_override (pd_test_3_all.cpp:24977)

    std::cout << "========= Interval repr float bounds ====================";
    pandas::Interval<double> iv(0.0, 1.5);
    if (iv.repr() != "Interval(0.0, 1.5, closed='right')")
        throw std::runtime_error("repr mismatch: " + iv.repr());
    std::cout << " -> tests passed" << std::endl;
}

void pd_test_interval_repr_timedelta() {
    std::cout << "========= Interval repr timedelta subtype ===============";
    pandas::Interval<double> iv(0.0, 86400000000000.0);  // 1 day in nanos
    iv.set_subtype_override("timedelta64[ns]");
    std::string r = iv.repr();
    if (r.find("Timedelta") == std::string::npos)
        throw std::runtime_error("expected Timedelta in repr: " + r);
    if (r.find("1 days") == std::string::npos)
        throw std::runtime_error("expected '1 days' in repr: " + r);
    std::cout << " -> tests passed" << std::endl;
}

void pd_test_interval_str_integer() {
    std::cout << "========= Interval to_string integer bounds =============";

shape (pd_test_1_all.cpp:6188)

            std::cout << "========= properties =======================";

            std::map<std::string, std::vector<numpy::float64>> data;
            data["A"] = {1.0, 2.0, 3.0, 4.0};
            data["B"] = {5.0, 6.0, 7.0, 8.0};
            data["C"] = {9.0, 10.0, 11.0, 12.0};

            pandas::DataFrame df(data);

            // Test shape
            auto shape = df.shape();
            if (shape.size() != 2 || shape[0] != 4 || shape[1] != 3) {
                std::cout << "  [FAIL] : in pd_test_dataframe_properties() : shape mismatch" << std::endl;
                throw std::runtime_error("pd_test_dataframe_properties failed: shape mismatch");
            }

            // Test ndim
            if (df.ndim() != 2) {
                std::cout << "  [FAIL] : in pd_test_dataframe_properties() : ndim != 2" << std::endl;
                throw std::runtime_error("pd_test_dataframe_properties failed: ndim != 2");
            }

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)

slice (pd_test_1_all.cpp:17546)

// ============================================================================
// Slicing / Indexing Tests
// ============================================================================

void pd_test_period_index_slice() {
    std::cout << "========= slice method ================================";

    std::vector<int64_t> ordinals = {0, 1, 2, 3, 4};
    pandas::PeriodIndex idx(ordinals, "D");

    pandas::PeriodIndex sliced = idx.slice(1, 4);

    bool passed = (sliced.size() == 3 &&
                   sliced[0].has_value() && *sliced[0] == 1);
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_period_index_slice()" << std::endl;
        throw std::runtime_error("pd_test_period_index_slice failed");
    }

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