IndexDtype

class pandas::IndexDtype

Data type class for pandas extension types.

Example

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

// Create IndexDtype
IndexDtype<int64_t> idx({1, 2, 3}, "my_index");
size_t len = idx.size();

Iteration

Signature	Return Type	Location	Example
size_t itemsize() const override	size_t	pd_index_dtype.h:109

Type Checking

Signature	Return Type	Location	Example
bool is_datetime() const	bool	pd_index_dtype.h:213
bool is_floating() const	bool	pd_index_dtype.h:199	View
bool is_integer() const	bool	pd_index_dtype.h:192	View
bool is_nullable() const override	bool	pd_index_dtype.h:138
bool is_numeric() const	bool	pd_index_dtype.h:185	View
bool is_object() const	bool	pd_index_dtype.h:206	View
bool is_timedelta() const	bool	pd_index_dtype.h:220

Other Methods

Signature	Return Type	Location	Example
std::string inferred_type() const	std::string	pd_index_dtype.h:166	View
std::string kind() const override	std::string	pd_index_dtype.h:118	View
std::string name() const override	std::string	pd_index_dtype.h:39	View
numpy::DType numpy_dtype() const override	numpy::DType	pd_index_dtype.h:75
std::string repr() const override	std::string	pd_index_dtype.h:154	View
const std::type_info& type() const override	const std::type_info&	pd_index_dtype.h:146	View

Code Examples

The following examples are extracted from the test suite.

is_floating (pd_test_3_all.cpp:622)

    // Test with integer index
    pandas::IndexDtype<numpy::int64> int_dtype;
    if (!int_dtype.is_numeric()) {
        std::cout << "  [FAIL] : in pd_test_3_all_index_dtype_checks() : int should be numeric" << std::endl;
        throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_numeric");
    }
    if (!int_dtype.is_integer()) {
        std::cout << "  [FAIL] : in pd_test_3_all_index_dtype_checks() : int should be integer" << std::endl;
        throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_integer");
    }
    if (int_dtype.is_floating()) {
        std::cout << "  [FAIL] : in pd_test_3_all_index_dtype_checks() : int should not be floating" << std::endl;
        throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_floating");
    }
    if (int_dtype.is_object()) {
        std::cout << "  [FAIL] : in pd_test_3_all_index_dtype_checks() : int should not be object" << std::endl;
        throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_object");
    }

    // Test with float index
    pandas::IndexDtype<double> float_dtype;

is_integer (pd_test_3_all.cpp:618)

void pd_test_3_all_index_dtype_checks() {
    std::cout << "========= IndexDtype.is_numeric/integer/floating/object() ";

    // Test with integer index
    pandas::IndexDtype<numpy::int64> int_dtype;
    if (!int_dtype.is_numeric()) {
        std::cout << "  [FAIL] : in pd_test_3_all_index_dtype_checks() : int should be numeric" << std::endl;
        throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_numeric");
    }
    if (!int_dtype.is_integer()) {
        std::cout << "  [FAIL] : in pd_test_3_all_index_dtype_checks() : int should be integer" << std::endl;
        throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_integer");
    }
    if (int_dtype.is_floating()) {
        std::cout << "  [FAIL] : in pd_test_3_all_index_dtype_checks() : int should not be floating" << std::endl;
        throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_floating");
    }
    if (int_dtype.is_object()) {
        std::cout << "  [FAIL] : in pd_test_3_all_index_dtype_checks() : int should not be object" << std::endl;
        throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_object");

is_numeric (pd_test_3_all.cpp:614)

// ============================================================================
// Category 4: Index Type Checking (IndexDtype)
// ============================================================================

void pd_test_3_all_index_dtype_checks() {
    std::cout << "========= IndexDtype.is_numeric/integer/floating/object() ";

    // Test with integer index
    pandas::IndexDtype<numpy::int64> int_dtype;
    if (!int_dtype.is_numeric()) {
        std::cout << "  [FAIL] : in pd_test_3_all_index_dtype_checks() : int should be numeric" << std::endl;
        throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_numeric");
    }
    if (!int_dtype.is_integer()) {
        std::cout << "  [FAIL] : in pd_test_3_all_index_dtype_checks() : int should be integer" << std::endl;
        throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_integer");
    }
    if (int_dtype.is_floating()) {
        std::cout << "  [FAIL] : in pd_test_3_all_index_dtype_checks() : int should not be floating" << std::endl;
        throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_floating");

is_object (pd_test_3_all.cpp:626)

        throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_numeric");
    }
    if (!int_dtype.is_integer()) {
        std::cout << "  [FAIL] : in pd_test_3_all_index_dtype_checks() : int should be integer" << std::endl;
        throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_integer");
    }
    if (int_dtype.is_floating()) {
        std::cout << "  [FAIL] : in pd_test_3_all_index_dtype_checks() : int should not be floating" << std::endl;
        throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_floating");
    }
    if (int_dtype.is_object()) {
        std::cout << "  [FAIL] : in pd_test_3_all_index_dtype_checks() : int should not be object" << std::endl;
        throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_object");
    }

    // Test with float index
    pandas::IndexDtype<double> float_dtype;
    if (!float_dtype.is_numeric()) {
        std::cout << "  [FAIL] : in pd_test_3_all_index_dtype_checks() : float should be numeric" << std::endl;
        throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: float is_numeric");
    }

inferred_type (pd_test_1_all.cpp:5270)

}

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

    pandas::CategoricalArray arr({"apple", "banana", "apple", "cherry"});
    pandas::CategoricalIndex idx(arr, "fruits");

    bool passed = (idx.size() == 4 && !idx.empty() &&
                   idx.name().has_value() && *idx.name() == "fruits" &&
                   idx.inferred_type() == "categorical");
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_categorical_index_array_constructor()" << std::endl;
        throw std::runtime_error("pd_test_categorical_index_array_constructor failed");
    }

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

void pd_test_categorical_index_values_constructor() {
    std::cout << "========= values constructor ==========================";

kind (pd_test_1_all.cpp:300)

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

int pd_test_boolean_array_main() {
    std::cout << "====================================== running pd_test_boolean_array ==================================== " << std::endl;

name (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;

repr (pd_test_1_all.cpp:10906)

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

void pd_test_extension_index_repr() {
    std::cout << "========= repr =========================";

    pandas::CategoricalArray arr({"a", "b", "c"});
    // Use ExtensionIndex<CategoricalArray> directly to test base class repr
    pandas::ExtensionIndex<pandas::CategoricalArray> idx(arr, "test");

    std::string repr_str = idx.repr();

    bool passed = (!repr_str.empty() && repr_str.find("ExtensionIndex") != std::string::npos);
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_extension_index_repr() : repr check failed" << std::endl;
        throw std::runtime_error("pd_test_extension_index_repr failed");
    }

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

type (pd_test_3_all.cpp:15450)

/**
 * Test Series.convert_dtypes() parameter flags
 */
void pd_test_series_convert_dtypes_flags() {
    std::cout << "========= Series.convert_dtypes() flags =================";

    // Test convert_integer=false - with floats disabled too, so it becomes string/object
    pandas::Series<std::string> s({"1", "2", "3"}, "numbers");
    auto converted = s.convert_dtypes(true, true, false, true, false);  // convert_integer=false, convert_floating=false

    // Should remain object type (Series<std::string> has dtype_name()="object")
    // When integer and floating are both disabled for integer-like strings, it falls back to string type
    if (converted->dtype_name() != "object") {
        std::cout << "  [FAIL] : dtype should be object when convert_integer=false and convert_floating=false, got " << converted->dtype_name() << std::endl;
        throw std::runtime_error("pd_test_series_convert_dtypes_flags failed: convert_integer");
    }

    // Test convert_boolean=false - strings stay as object/string type
    pandas::Series<std::string> s_bool({"true", "false"}, "bools");
    auto converted_bool = s_bool.convert_dtypes(true, true, true, false, true);  // convert_boolean=false