DatetimeTimedeltaMixin

class pandas::DatetimeTimedeltaMixin

Mixin class providing shared functionality.

Example

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

// Use DatetimeTimedeltaMixin
DatetimeTimedeltaMixin obj;
// ... operations ...

Constructors

Signature	Location	Example
explicit DatetimeTimedeltaMixin(const ArrayType& array, const std::optional<std::string>& name = std::nullopt)	pd_datetime_timedelta_mixin.h:105
explicit DatetimeTimedeltaMixin(ArrayType&& array, const std::optional<std::string>& name = std::nullopt)	pd_datetime_timedelta_mixin.h:113
DatetimeTimedeltaMixin(const DatetimeTimedeltaMixin& other)	pd_datetime_timedelta_mixin.h:121
DatetimeTimedeltaMixin(DatetimeTimedeltaMixin&& other) noexcept	pd_datetime_timedelta_mixin.h:128

Indexing / Selection

Signature	Return Type	Location	Example
static int64_t get_unit_conversion_factor(numpy::DateTimeUnit from, numpy::DateTimeUnit to)	static int64_t	pd_datetime_timedelta_mixin.h:676

Data Manipulation

Signature	Return Type	Location	Example
DatetimeTimedeltaMixin rename(const std::optional<std::string>& new_name) const	DatetimeTimedeltaMixin	pd_datetime_timedelta_mixin.h:581	View

Statistics

Signature	Return Type	Location	Example
std::optional<value_type> mean(bool skipna = true, std::optional<int> axis = std::nullopt) const	std::optional<value_type>	pd_datetime_timedelta_mixin.h:447	View

Time Series

Signature	Return Type	Location	Example
DatetimeTimedeltaMixin shift(int64_t periods, const std::optional<std::string>& freq = std::nullopt) const	DatetimeTimedeltaMixin	pd_datetime_timedelta_mixin.h:508	View

I/O

Signature	Return Type	Location	Example
std::string to_string() const override	std::string	pd_datetime_timedelta_mixin.h:589	View

Conversion

Signature	Return Type	Location	Example
DatetimeTimedeltaMixin copy(const std::optional<std::string>& name = std::nullopt) const	DatetimeTimedeltaMixin	pd_datetime_timedelta_mixin.h:571	View

Other Methods

Signature	Return Type	Location	Example
DatetimeTimedeltaMixin as_unit(const std::string& target_unit, bool round_ok = true) const	DatetimeTimedeltaMixin	pd_datetime_timedelta_mixin.h:224	View
DatetimeTimedeltaMixin ceil(const std::string& freq, const std::string& ambiguous = "raise", const std::string& nonexistent = "raise") const	DatetimeTimedeltaMixin	pd_datetime_timedelta_mixin.h:372	View
std::unique_ptr<IndexBase> clone() const override	std::unique_ptr<IndexBase>	pd_datetime_timedelta_mixin.h:558	View
static ArrayType convert_array_unit(const ArrayType& arr, numpy::DateTimeUnit new_unit, int64_t factor, bool divide)	static ArrayType	pd_datetime_timedelta_mixin.h:706
DatetimeTimedeltaMixin floor(const std::string& freq, const std::string& ambiguous = "raise", const std::string& nonexistent = "raise") const	DatetimeTimedeltaMixin	pd_datetime_timedelta_mixin.h:342	View
static int64_t freq_to_nanoseconds(const std::string& freq)	static int64_t	pd_datetime_timedelta_mixin.h:743
std::string inferred_type() const override	std::string	pd_datetime_timedelta_mixin.h:634	View
static numpy::DateTimeUnit parse_unit(const std::string& unit_str)	static numpy::DateTimeUnit	pd_datetime_timedelta_mixin.h:660
std::string repr() const	std::string	pd_datetime_timedelta_mixin.h:626	View
DatetimeTimedeltaMixin result(this->array().copy(), name.has_value() ? name : this->name())	DatetimeTimedeltaMixin	pd_datetime_timedelta_mixin.h:572	View
DatetimeTimedeltaMixin round(const std::string& freq, const std::string& ambiguous = "raise", const std::string& nonexistent = "raise") const	DatetimeTimedeltaMixin	pd_datetime_timedelta_mixin.h:312	View
static ArrayType round_array(const ArrayType& arr, int64_t freq_ns, RoundMode mode)	static ArrayType	pd_datetime_timedelta_mixin.h:763
DatetimeTimedeltaMixin snap(const std::string& freq = "S") const	DatetimeTimedeltaMixin	pd_datetime_timedelta_mixin.h:392	View
IndexTypeId type_id() const override	IndexTypeId	pd_datetime_timedelta_mixin.h:562	View
std::string unit() const	std::string	pd_datetime_timedelta_mixin.h:197	View

Internal Methods

2 internal methods (prefixed with underscore)

Code Examples

The following examples are extracted from the test suite.

rename (pd_test_1_all.cpp:5816)

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

void pd_test_categorical_index_rename() {
    std::cout << "========= rename ======================================";

    pandas::CategoricalArray arr({"x", "y"});
    pandas::CategoricalIndex idx(arr, "old_name");

    pandas::CategoricalIndex renamed = idx.rename("new_name");

    bool passed = (renamed.name().has_value() && *renamed.name() == "new_name" &&
                   renamed.size() == idx.size() && renamed.categories() == idx.categories());
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_categorical_index_rename()" << std::endl;
        throw std::runtime_error("pd_test_categorical_index_rename failed");
    }

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

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

shift (pd_test_1_all.cpp:5188)

            // First element should be NaN
            val = d["A"].get_value_str(0);
            passed = std::isnan(std::stod(val));
            if (!passed) {
                std::cout << "  [FAIL] : in pd_test_arithmetic_dataframe_diff_shift() : diff NaN failed" << std::endl;
                throw std::runtime_error("pd_test_arithmetic_dataframe_diff_shift failed: diff NaN failed");
            }

            // shift: [NaN, 1, 3, 6]
            auto s = df.shift();
            val = s["A"].get_value_str(1);
            passed = std::abs(std::stod(val) - 1.0) < 0.001;
            if (!passed) {
                std::cout << "  [FAIL] : in pd_test_arithmetic_dataframe_diff_shift() : shift failed" << std::endl;
                throw std::runtime_error("pd_test_arithmetic_dataframe_diff_shift failed: shift 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];

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

as_unit (pd_test_1_all.cpp:9361)

    data.setElementAt({1}, numpy::datetime64(2000000000LL, numpy::DateTimeUnit::Nanosecond));  // 2 seconds in ns

    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::DatetimeTDMixin idx(arr, "test");

    // Convert to microseconds
    pandas::DatetimeTDMixin us_idx = idx.as_unit("us");

    // Convert to same unit (should return identical)
    pandas::DatetimeTDMixin same_idx = idx.as_unit("ns");

    bool passed = (us_idx.size() == 2 && same_idx.size() == 2 &&
                   us_idx.name().has_value() && *us_idx.name() == "test");
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_datetime_as_unit() : as_unit check failed" << std::endl;
        throw std::runtime_error("pd_test_datetime_as_unit failed");
    }

ceil (pd_test_1_all.cpp:4949)

                throw std::runtime_error("pd_test_arithmetic_series_round failed: round failed");
            }

            auto f = a.floor();
            passed = std::abs(f[0] - 1.0) < 0.001 && std::abs(f[2] - 3.0) < 0.001 && std::abs(f[3] - (-2.0)) < 0.001;
            if (!passed) {
                std::cout << "  [FAIL] : in pd_test_arithmetic_series_round() : floor failed" << std::endl;
                throw std::runtime_error("pd_test_arithmetic_series_round failed: floor failed");
            }

            auto c = a.ceil();
            passed = std::abs(c[0] - 2.0) < 0.001 && std::abs(c[2] - 4.0) < 0.001 && std::abs(c[3] - (-1.0)) < 0.001;
            if (!passed) {
                std::cout << "  [FAIL] : in pd_test_arithmetic_series_round() : ceil failed" << std::endl;
                throw std::runtime_error("pd_test_arithmetic_series_round failed: ceil failed");
            }

            // Round with decimals
            pandas::Series<double> b({1.234, 2.567, 3.891});
            auto r2 = b.round(2);
            passed = std::abs(r2[0] - 1.23) < 0.001 && std::abs(r2[1] - 2.57) < 0.001;

clone (pd_test_1_all.cpp:5776)

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

void pd_test_categorical_index_clone() {
    std::cout << "========= clone =======================================";

    pandas::CategoricalArray arr({"p", "q", "r"});
    pandas::CategoricalIndex idx(arr, "original");

    std::unique_ptr<pandas::IndexBase> cloned = idx.clone();

    bool passed = (cloned != nullptr && cloned->size() == idx.size() &&
                   cloned->name() == idx.name());
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_categorical_index_clone()" << std::endl;
        throw std::runtime_error("pd_test_categorical_index_clone failed");
    }

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

floor (pd_test_1_all.cpp:4942)

            pandas::Series<double> a({1.4, 2.5, 3.6, -1.4, -2.5});

            auto r = a.round();
            bool passed = std::abs(r[0] - 1.0) < 0.001 && std::abs(r[2] - 4.0) < 0.001;
            if (!passed) {
                std::cout << "  [FAIL] : in pd_test_arithmetic_series_round() : round failed" << std::endl;
                throw std::runtime_error("pd_test_arithmetic_series_round failed: round failed");
            }

            auto f = a.floor();
            passed = std::abs(f[0] - 1.0) < 0.001 && std::abs(f[2] - 3.0) < 0.001 && std::abs(f[3] - (-2.0)) < 0.001;
            if (!passed) {
                std::cout << "  [FAIL] : in pd_test_arithmetic_series_round() : floor failed" << std::endl;
                throw std::runtime_error("pd_test_arithmetic_series_round failed: floor failed");
            }

            auto c = a.ceil();
            passed = std::abs(c[0] - 2.0) < 0.001 && std::abs(c[2] - 4.0) < 0.001 && std::abs(c[3] - (-1.0)) < 0.001;
            if (!passed) {
                std::cout << "  [FAIL] : in pd_test_arithmetic_series_round() : ceil failed" << std::endl;

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

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

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

round (pd_test_1_all.cpp:1688)

    void pd_test_floating_array_rounding() {
        std::cout << "========= FloatingArray: rounding ======================= ";

        pandas::FloatingArray<double> arr({
            std::optional<double>(1.234),
            std::optional<double>(2.567),
            std::nullopt
        });

        auto rounded = arr.round(2);
        if (std::abs(rounded[0].value() - 1.23) > 0.001 ||
            std::abs(rounded[1].value() - 2.57) > 0.001) {
            std::cout << "  [FAIL] : in pd_test_floating_array_rounding() : round(2)" << std::endl;
            throw std::runtime_error("pd_test_floating_array_rounding failed: round(2)");
        }

        if (!rounded.is_na(2)) {
            std::cout << "  [FAIL] : in pd_test_floating_array_rounding() : round should preserve NA" << std::endl;
            throw std::runtime_error("pd_test_floating_array_rounding failed: NA preservation");
        }

snap (pd_test_1_all.cpp:8364)

void pd_test_datetime_mixin_snap() {
    std::cout << "========= snap ========================================";

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

    pandas::DatetimeMixinIndex snapped = idx.snap("s");

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

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

type_id (pd_test_3_all.cpp:25592)

// ------------------- pd_test_value_classify (end) ------------------

// ------------------- pd_test_index_type_id (start) ------------------
namespace dataframe_tests_index_type_id {

void pd_test_index_type_id_dispatch() {
    std::cout << "========= IndexTypeId dispatch =======================";

    // RangeIndex
    ::pandas::RangeIndex ri(0, 5);
    if (ri.type_id() != ::pandas::IndexTypeId::RangeIndex)
        throw std::runtime_error("RangeIndex type_id failed");

    // Index<string>
    ::pandas::Index<std::string> si(std::vector<std::string>{"a", "b", "c"});
    if (si.type_id() != ::pandas::IndexTypeId::IndexString)
        throw std::runtime_error("Index<string> type_id failed");

    // Index<int64>
    ::pandas::Index<numpy::int64> ii(std::vector<numpy::int64>{1, 2, 3});
    if (ii.type_id() != ::pandas::IndexTypeId::IndexInt64)

unit (pd_test_1_all.cpp:9284)

    data.setElementAt({0}, numpy::datetime64(1000LL, numpy::DateTimeUnit::Nanosecond));
    data.setElementAt({1}, numpy::datetime64(2000LL, 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::DatetimeTDMixin idx(arr);

    std::string unit = idx.unit();

    bool passed = (unit == "ns");  // nanosecond
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_datetime_unit_property() : unit property check failed, got '" << unit << "'" << std::endl;
        throw std::runtime_error("pd_test_datetime_unit_property failed");
    }

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