DatetimeIndex
=============

.. cpp:class:: pandas::DatetimeIndex

   Index class for axis labels in pandas data structures.

Example
-------

.. code-block:: cpp

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

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

Constructors
------------

.. list-table::
   :widths: 55 25 20
   :header-rows: 1

   * - Signature
     - Location
     - Example
   * - ``explicit DatetimeIndex(const DatetimeArray& arr, const std::optional<std::string>& name = std::nullopt)``
     - pd_datetime_index.h:126
     - :ref:`View <example-datetimeindex-datetimeindex-0>`
   * - ``explicit DatetimeIndex(DatetimeArray&& arr, const std::optional<std::string>& name = std::nullopt)``
     - pd_datetime_index.h:136
     - :ref:`View <example-datetimeindex-datetimeindex-1>`
   * - ``explicit DatetimeIndex(const std::vector<numpy::datetime64>& values, const std::optional<std::string>& name = std::nullopt)``
     - pd_datetime_index.h:146
     - :ref:`View <example-datetimeindex-datetimeindex-2>`
   * - ``explicit DatetimeIndex(const std::vector<std::optional<numpy::datetime64>>& values, const std::optional<std::string>& name = std::nullopt)``
     - pd_datetime_index.h:164
     - :ref:`View <example-datetimeindex-datetimeindex-3>`
   * - ``DatetimeIndex(const std::string& start, int periods, const std::string& freq)``
     - pd_datetime_index.h:175
     - :ref:`View <example-datetimeindex-datetimeindex-4>`
   * - ``DatetimeIndex(const DatetimeIndex& other)``
     - pd_datetime_index.h:180
     - :ref:`View <example-datetimeindex-datetimeindex-5>`
   * - ``DatetimeIndex(DatetimeIndex&& other) noexcept``
     - pd_datetime_index.h:187
     - :ref:`View <example-datetimeindex-datetimeindex-6>`

Indexing / Selection
--------------------

.. list-table::
   :widths: 40 20 15 25
   :header-rows: 1

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``std::optional<std::pair<int64_t, std::string>> get_datetime_ns_at(size_t pos) const override``
     - std::optional<std::pair<int64_t, std::string>>
     - pd_datetime_index.h:334
     - :ref:`View <example-datetimeindex-get_datetime_ns_at-7>`
   * - ``numpy::NDArray<numpy::int64> get_indexer(const DatetimeIndex& target, const std::string& method = "", std::optional<int> limit = std::nullopt, std::optional<int64_t> tolerance = std::nullopt) const``
     - numpy::NDArray<numpy::int64>
     - pd_datetime_index.h:1590
     - :ref:`View <example-datetimeindex-get_indexer-8>`
   * - ``numpy::NDArray<numpy::int64> get_indexer_for(const std::vector<numpy::datetime64>& target) const``
     - numpy::NDArray<numpy::int64>
     - pd_datetime_index.h:1639
     - :ref:`View <example-datetimeindex-get_indexer_for-9>`
   * - ``get_indexer_non_unique(const DatetimeIndex& target) const``
     - 
     - pd_datetime_index.h:1671
     - :ref:`View <example-datetimeindex-get_indexer_non_unique-10>`
   * - ``DatetimeIndex get_level_values(int level) const``
     - DatetimeIndex
     - pd_datetime_index.h:2866
     - :ref:`View <example-datetimeindex-get_level_values-11>`
   * - ``DatetimeIndex get_level_values(const std::string& level_name) const``
     - DatetimeIndex
     - pd_datetime_index.h:2882
     - :ref:`View <example-datetimeindex-get_level_values-12>`
   * - ``int64_t get_loc(const numpy::datetime64& key) const``
     - int64_t
     - pd_datetime_index.h:1729
     - :ref:`View <example-datetimeindex-get_loc-13>`
   * - ``std::optional<size_t> get_loc_string(const std::string& key) const override``
     - std::optional<size_t>
     - pd_datetime_index.h:3671
     - :ref:`View <example-datetimeindex-get_loc_string-14>`
   * - ``int64_t get_loc_string_legacy_int64(const std::string& key) const``
     - int64_t
     - pd_datetime_index.h:3634
     - 
   * - ``std::vector<std::optional<std::string>> get_names() const``
     - std::vector<std::optional<std::string>>
     - pd_datetime_index.h:3474
     - 
   * - ``std::vector<size_t> get_partial_date_indices(const std::string& key) const``
     - std::vector<size_t>
     - pd_datetime_index.h:3605
     - 
   * - ``size_t get_slice_bound(const numpy::datetime64& label, const std::string& side = "left") const``
     - size_t
     - pd_datetime_index.h:1750
     - :ref:`View <example-datetimeindex-get_slice_bound-15>`
   * - ``std::string get_string(size_t i) const``
     - std::string
     - pd_datetime_index.h:930
     - :ref:`View <example-datetimeindex-get_string-16>`
   * - ``std::string get_value_str(size_t index) const override``
     - std::string
     - pd_datetime_index.h:806
     - :ref:`View <example-datetimeindex-get_value_str-17>`
   * - ``DatetimeIndex take(const numpy::NDArray<numpy::int64>& indices, int axis = 0, bool allow_fill = true, std::optional<numpy::datetime64> fill_value = std::nullopt) const``
     - DatetimeIndex
     - pd_datetime_index.h:2472
     - :ref:`View <example-datetimeindex-take-18>`
   * - ``DatetimeIndex where(const numpy::NDArray<numpy::bool_>& cond, const numpy::datetime64& other) const``
     - DatetimeIndex
     - pd_datetime_index.h:2807
     - :ref:`View <example-datetimeindex-where-19>`

Data Manipulation
-----------------

.. list-table::
   :widths: 40 20 15 25
   :header-rows: 1

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``DatetimeIndex drop(const std::vector<numpy::datetime64>& labels, const std::string& errors = "raise") const``
     - DatetimeIndex
     - pd_datetime_index.h:1255
     - :ref:`View <example-datetimeindex-drop-20>`
   * - ``DatetimeIndex drop_duplicates(const std::string& keep = "first") const``
     - DatetimeIndex
     - pd_datetime_index.h:1305
     - :ref:`View <example-datetimeindex-drop_duplicates-21>`
   * - ``DatetimeIndex droplevel(int level = 0) const``
     - DatetimeIndex
     - pd_datetime_index.h:2849
     - :ref:`View <example-datetimeindex-droplevel-22>`
   * - ``DatetimeIndex dropna() const``
     - DatetimeIndex
     - pd_datetime_index.h:1361
     - :ref:`View <example-datetimeindex-dropna-23>`
   * - ``DatetimeIndex insert(size_t loc, const numpy::datetime64& item) const``
     - DatetimeIndex
     - pd_datetime_index.h:1898
     - :ref:`View <example-datetimeindex-insert-24>`
   * - ``std::pair<DatetimeIndex, numpy::NDArray<numpy::int64>> reindex( const DatetimeIndex& target, const std::string& method = "", std::optional<int> level = std::nullopt, std::optional<int> limit = std::nullopt, std::optional<int64_t> tolerance = std::nullopt) const``
     - std::pair<DatetimeIndex, numpy::NDArray<numpy::int64>>
     - pd_datetime_index.h:3147
     - :ref:`View <example-datetimeindex-reindex-25>`
   * - ``DatetimeIndex rename(const std::optional<std::string>& new_name, bool inplace = false, std::optional<std::string> name = std::nullopt) const``
     - DatetimeIndex
     - pd_datetime_index.h:597
     - :ref:`View <example-datetimeindex-rename-26>`
   * - ``DatetimeIndex set_names(const std::optional<std::string>& names, std::optional<int> level = std::nullopt, bool inplace = false) const``
     - DatetimeIndex
     - pd_datetime_index.h:2295
     - :ref:`View <example-datetimeindex-set_names-27>`

Missing Data
------------

.. list-table::
   :widths: 40 20 15 25
   :header-rows: 1

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``DatetimeIndex fillna(const numpy::datetime64& value, const std::string& downcast = "") const``
     - DatetimeIndex
     - pd_datetime_index.h:1548
     - :ref:`View <example-datetimeindex-fillna-28>`
   * - ``numpy::NDArray<numpy::bool_> isna() const``
     - numpy::NDArray<numpy::bool_>
     - pd_datetime_index.h:2057
     - :ref:`View <example-datetimeindex-isna-29>`
   * - ``numpy::NDArray<numpy::bool_> isnull() const``
     - numpy::NDArray<numpy::bool_>
     - pd_datetime_index.h:2070
     - :ref:`View <example-datetimeindex-isnull-30>`
   * - ``numpy::NDArray<numpy::bool_> notna() const``
     - numpy::NDArray<numpy::bool_>
     - pd_datetime_index.h:2143
     - :ref:`View <example-datetimeindex-notna-31>`
   * - ``numpy::NDArray<numpy::bool_> notnull() const``
     - numpy::NDArray<numpy::bool_>
     - pd_datetime_index.h:2156
     - :ref:`View <example-datetimeindex-notnull-32>`

Statistics
----------

.. list-table::
   :widths: 40 20 15 25
   :header-rows: 1

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``std::optional<numpy::datetime64> max(bool skipna = true, std::optional<int> axis = std::nullopt) const``
     - std::optional<numpy::datetime64>
     - pd_datetime_index.h:441
     - :ref:`View <example-datetimeindex-max-33>`
   * - ``std::optional<numpy::datetime64> min(bool skipna = true, std::optional<int> axis = std::nullopt) const``
     - std::optional<numpy::datetime64>
     - pd_datetime_index.h:407
     - :ref:`View <example-datetimeindex-min-34>`
   * - ``size_t nunique(bool dropna = true) const``
     - size_t
     - pd_datetime_index.h:2165
     - :ref:`View <example-datetimeindex-nunique-35>`
   * - ``std::optional<numpy::timedelta64> std(bool skipna = true) const``
     - std::optional<numpy::timedelta64>
     - pd_datetime_index.h:522
     - :ref:`View <example-datetimeindex-std-36>`
   * - ``std::unordered_map<int64_t, size_t> value_counts(bool normalize = false, bool ascending = false, bool dropna = true, std::optional<int> bins = std::nullopt, bool sort = true) const``
     - std::unordered_map<int64_t, size_t>
     - pd_datetime_index.h:2764
     - :ref:`View <example-datetimeindex-value_counts-37>`

Aggregation
-----------

.. list-table::
   :widths: 40 20 15 25
   :header-rows: 1

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``std::unordered_map<GroupT, std::vector<size_t>> groupby( const std::vector<GroupT>& values) const``
     - std::unordered_map<GroupT, std::vector<size_t>>
     - pd_datetime_index.h:2913
     - :ref:`View <example-datetimeindex-groupby-38>`
   * - ``DatetimeIndex map(F&& mapper, const std::string& na_action = "") const``
     - DatetimeIndex
     - pd_datetime_index.h:2096
     - :ref:`View <example-datetimeindex-map-39>`

Comparison
----------

.. list-table::
   :widths: 40 20 15 25
   :header-rows: 1

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``bool equals(const DatetimeIndex& other) const``
     - bool
     - pd_datetime_index.h:1479
     - :ref:`View <example-datetimeindex-equals-40>`
   * - ``DatetimeArray new_arr(combined)``
     - DatetimeArray
     - pd_datetime_index.h:997
     - 
   * - ``DatetimeArray new_arr(values)``
     - DatetimeArray
     - pd_datetime_index.h:1146
     - 
   * - ``DatetimeArray new_arr(values)``
     - DatetimeArray
     - pd_datetime_index.h:1166
     - 
   * - ``DatetimeArray new_arr(result)``
     - DatetimeArray
     - pd_datetime_index.h:1245
     - 
   * - ``DatetimeArray new_arr(result)``
     - DatetimeArray
     - pd_datetime_index.h:1296
     - 
   * - ``DatetimeArray new_arr(result)``
     - DatetimeArray
     - pd_datetime_index.h:1353
     - 
   * - ``DatetimeArray new_arr(result)``
     - DatetimeArray
     - pd_datetime_index.h:1374
     - 
   * - ``DatetimeArray new_arr(result)``
     - DatetimeArray
     - pd_datetime_index.h:1562
     - 
   * - ``DatetimeArray new_arr(values)``
     - DatetimeArray
     - pd_datetime_index.h:1917
     - 
   * - ``DatetimeArray new_arr(result)``
     - DatetimeArray
     - pd_datetime_index.h:1955
     - 
   * - ``DatetimeArray new_arr(result)``
     - DatetimeArray
     - pd_datetime_index.h:2117
     - 
   * - ``DatetimeArray new_arr(result)``
     - DatetimeArray
     - pd_datetime_index.h:2207
     - 
   * - ``DatetimeArray new_arr(result)``
     - DatetimeArray
     - pd_datetime_index.h:2249
     - 
   * - ``DatetimeArray new_arr(result)``
     - DatetimeArray
     - pd_datetime_index.h:2458
     - 
   * - ``DatetimeArray new_arr(result)``
     - DatetimeArray
     - pd_datetime_index.h:2494
     - 
   * - ``DatetimeArray new_arr(result)``
     - DatetimeArray
     - pd_datetime_index.h:2739
     - 
   * - ``DatetimeArray new_arr(result)``
     - DatetimeArray
     - pd_datetime_index.h:2820
     - 

Sorting
-------

.. list-table::
   :widths: 40 20 15 25
   :header-rows: 1

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``numpy::NDArray<numpy::int64> argsort() const``
     - numpy::NDArray<numpy::int64>
     - pd_datetime_index.h:1005
     - :ref:`View <example-datetimeindex-argsort-41>`
   * - ``size_t searchsorted(const numpy::datetime64& value, const std::string& side = "left", std::optional<numpy::NDArray<numpy::int64>> sorter = std::nullopt) const``
     - size_t
     - pd_datetime_index.h:2260
     - :ref:`View <example-datetimeindex-searchsorted-42>`
   * - ``DatetimeIndex sort_values(bool ascending = true, const std::string& na_position = "last", bool return_indexer = false, std::nullptr_t key = nullptr) const``
     - DatetimeIndex
     - pd_datetime_index.h:2389
     - :ref:`View <example-datetimeindex-sort_values-43>`

Reshaping
---------

.. list-table::
   :widths: 40 20 15 25
   :header-rows: 1

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``FrameData to_frame(bool index = true, const std::optional<std::string>& name = std::nullopt) const``
     - FrameData
     - pd_datetime_index.h:2542
     - :ref:`View <example-datetimeindex-to_frame-44>`
   * - ``DatetimeIndex transpose() const``
     - DatetimeIndex
     - pd_datetime_index.h:2686
     - :ref:`View <example-datetimeindex-transpose-45>`

Combining
---------

.. list-table::
   :widths: 40 20 15 25
   :header-rows: 1

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``DatetimeIndex append(const DatetimeIndex& other) const``
     - DatetimeIndex
     - pd_datetime_index.h:983
     - :ref:`View <example-datetimeindex-append-46>`
   * - ``join(const DatetimeIndex& other, const std::string& how = "left", std::optional<int> level = std::nullopt, bool return_indexers = true, bool sort = false) const``
     - 
     - pd_datetime_index.h:2960
     - :ref:`View <example-datetimeindex-join-47>`
   * - ``DatetimeArray joined_arr(joined_values)``
     - DatetimeArray
     - pd_datetime_index.h:3108
     - 

Time Series
-----------

.. list-table::
   :widths: 40 20 15 25
   :header-rows: 1

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``std::optional<numpy::datetime64> asof(const numpy::datetime64& where, std::optional<numpy::datetime64> label = std::nullopt) const``
     - std::optional<numpy::datetime64>
     - pd_datetime_index.h:1037
     - :ref:`View <example-datetimeindex-asof-48>`
   * - ``numpy::NDArray<numpy::int64> asof_locs(const std::vector<numpy::datetime64>& where, std::optional<numpy::NDArray<numpy::bool_>> mask = std::nullopt) const``
     - numpy::NDArray<numpy::int64>
     - pd_datetime_index.h:1072
     - :ref:`View <example-datetimeindex-asof_locs-49>`
   * - ``TimedeltaArray diff(int64_t periods = 1) const``
     - TimedeltaArray
     - pd_datetime_index.h:1175
     - :ref:`View <example-datetimeindex-diff-50>`
   * - ``DatetimeIndex difference(const DatetimeIndex& other, bool sort = true) const``
     - DatetimeIndex
     - pd_datetime_index.h:1222
     - :ref:`View <example-datetimeindex-difference-51>`
   * - ``DatetimeIndex shift(int64_t periods, const std::optional<std::string>& freq = std::nullopt) const``
     - DatetimeIndex
     - pd_datetime_index.h:350
     - :ref:`View <example-datetimeindex-shift-52>`
   * - ``DatetimeIndex tz_convert(const std::string& tz, const std::string& tz_display = "") const``
     - DatetimeIndex
     - pd_datetime_index.h:390
     - :ref:`View <example-datetimeindex-tz_convert-53>`
   * - ``DatetimeIndex tz_localize(const std::string& tz, const std::string& ambiguous = "raise", const std::string& nonexistent = "raise", const std::string& tz_display = "") const``
     - DatetimeIndex
     - pd_datetime_index.h:372
     - :ref:`View <example-datetimeindex-tz_localize-54>`

I/O
---

.. list-table::
   :widths: 40 20 15 25
   :header-rows: 1

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``std::vector<std::optional<EpochComponents>> to_epoch_components() const``
     - std::vector<std::optional<EpochComponents>>
     - pd_datetime_index.h:2620
     - :ref:`View <example-datetimeindex-to_epoch_components-55>`
   * - ``DatetimeIndex to_flat_index() const``
     - DatetimeIndex
     - pd_datetime_index.h:2502
     - :ref:`View <example-datetimeindex-to_flat_index-56>`
   * - ``FloatingArray<double> to_julian_date() const``
     - FloatingArray<double>
     - pd_datetime_index.h:3426
     - :ref:`View <example-datetimeindex-to_julian_date-57>`
   * - ``std::vector<std::optional<numpy::datetime64>> to_list() const``
     - std::vector<std::optional<numpy::datetime64>>
     - pd_datetime_index.h:2571
     - :ref:`View <example-datetimeindex-to_list-58>`
   * - ``std::string to_string() const override``
     - std::string
     - pd_datetime_index.h:614
     - :ref:`View <example-datetimeindex-to_string-59>`
   * - ``std::vector<pandas::Timestamp> to_vector() const``
     - std::vector<pandas::Timestamp>
     - pd_datetime_index.h:2666
     - :ref:`View <example-datetimeindex-to_vector-60>`
   * - ``std::vector<std::optional<numpy::datetime64>> tolist() const``
     - std::vector<std::optional<numpy::datetime64>>
     - pd_datetime_index.h:2585
     - :ref:`View <example-datetimeindex-tolist-61>`

Conversion
----------

.. list-table::
   :widths: 40 20 15 25
   :header-rows: 1

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``numpy::NDArray<numpy::int64> astype(const std::string& dtype = "int64", bool copy = true) const``
     - numpy::NDArray<numpy::int64>
     - pd_datetime_index.h:1108
     - :ref:`View <example-datetimeindex-astype-62>`
   * - ``DatetimeIndex copy(const std::optional<std::string>& name = std::nullopt, bool deep = true) const``
     - DatetimeIndex
     - pd_datetime_index.h:581
     - :ref:`View <example-datetimeindex-copy-63>`
   * - ``DatetimeIndex infer_objects(bool copy = true) const``
     - DatetimeIndex
     - pd_datetime_index.h:2936
     - :ref:`View <example-datetimeindex-infer_objects-64>`
   * - ``numpy::NDArray<numpy::datetime64> view() const``
     - numpy::NDArray<numpy::datetime64>
     - pd_datetime_index.h:2797
     - :ref:`View <example-datetimeindex-view-65>`

Set Operations
--------------

.. list-table::
   :widths: 40 20 15 25
   :header-rows: 1

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``BooleanArray duplicated(const std::string& keep = "first") const``
     - BooleanArray
     - pd_datetime_index.h:1383
     - :ref:`View <example-datetimeindex-duplicated-66>`
   * - ``DatetimeIndex intersection(const DatetimeIndex& other, bool sort = false) const``
     - DatetimeIndex
     - pd_datetime_index.h:1927
     - :ref:`View <example-datetimeindex-intersection-67>`
   * - ``BooleanArray isin(const std::vector<numpy::datetime64>& values, std::optional<int> level = std::nullopt) const``
     - BooleanArray
     - pd_datetime_index.h:2030
     - :ref:`View <example-datetimeindex-isin-68>`
   * - ``DatetimeIndex symmetric_difference(const DatetimeIndex& other, std::optional<std::string> result_name = std::nullopt, bool sort = false) const``
     - DatetimeIndex
     - pd_datetime_index.h:2420
     - :ref:`View <example-datetimeindex-symmetric_difference-69>`
   * - ``DatetimeIndex union_(const DatetimeIndex& other, bool sort = true) const``
     - DatetimeIndex
     - pd_datetime_index.h:2696
     - :ref:`View <example-datetimeindex-union_-70>`
   * - ``DatetimeIndex unique(std::optional<int> level = std::nullopt) const``
     - DatetimeIndex
     - pd_datetime_index.h:2748
     - :ref:`View <example-datetimeindex-unique-71>`
   * - ``DatetimeArray unique_arr(uniques)``
     - DatetimeArray
     - pd_datetime_index.h:1538
     - 

Type Checking
-------------

.. list-table::
   :widths: 40 20 15 25
   :header-rows: 1

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``bool is_(const DatetimeIndex& other) const``
     - bool
     - pd_datetime_index.h:1964
     - :ref:`View <example-datetimeindex-is_-72>`
   * - ``bool is_boolean() const``
     - bool
     - pd_datetime_index.h:1972
     - :ref:`View <example-datetimeindex-is_boolean-73>`
   * - ``bool is_categorical() const``
     - bool
     - pd_datetime_index.h:1980
     - :ref:`View <example-datetimeindex-is_categorical-74>`
   * - ``bool is_floating() const``
     - bool
     - pd_datetime_index.h:1988
     - :ref:`View <example-datetimeindex-is_floating-75>`
   * - ``bool is_integer() const``
     - bool
     - pd_datetime_index.h:1996
     - :ref:`View <example-datetimeindex-is_integer-76>`
   * - ``bool is_interval() const``
     - bool
     - pd_datetime_index.h:2004
     - :ref:`View <example-datetimeindex-is_interval-77>`
   * - ``bool is_numeric() const``
     - bool
     - pd_datetime_index.h:2012
     - :ref:`View <example-datetimeindex-is_numeric-78>`
   * - ``bool is_object() const``
     - bool
     - pd_datetime_index.h:2020
     - :ref:`View <example-datetimeindex-is_object-79>`

Other Methods
-------------

.. list-table::
   :widths: 40 20 15 25
   :header-rows: 1

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``bool all() const``
     - bool
     - pd_datetime_index.h:950
     - :ref:`View <example-datetimeindex-all-80>`
   * - ``bool any() const``
     - bool
     - pd_datetime_index.h:964
     - :ref:`View <example-datetimeindex-any-81>`
   * - ``int64_t argmax() const``
     - int64_t
     - pd_datetime_index.h:497
     - :ref:`View <example-datetimeindex-argmax-82>`
   * - ``int64_t argmin() const``
     - int64_t
     - pd_datetime_index.h:473
     - :ref:`View <example-datetimeindex-argmin-83>`
   * - ``DatetimeArray arr(opt_values)``
     - DatetimeArray
     - pd_datetime_index.h:155
     - :ref:`View <example-datetimeindex-arr-84>`
   * - ``DatetimeArray arr(values)``
     - DatetimeArray
     - pd_datetime_index.h:168
     - :ref:`View <example-datetimeindex-arr-85>`
   * - ``DatetimeIndex as_unit(const std::string& target_unit, bool round_ok = true) const``
     - DatetimeIndex
     - pd_datetime_index.h:328
     - :ref:`View <example-datetimeindex-as_unit-86>`
   * - ``DatetimeIndex ceil(const std::string& freq, const std::string& ambiguous = "raise", const std::string& nonexistent = "raise") const``
     - DatetimeIndex
     - pd_datetime_index.h:304
     - :ref:`View <example-datetimeindex-ceil-87>`
   * - ``static int classify_partial_date(const std::string& s)``
     - static int
     - pd_datetime_index.h:3486
     - 
   * - ``std::unique_ptr<IndexBase> clone() const override``
     - std::unique_ptr<IndexBase>
     - pd_datetime_index.h:567
     - :ref:`View <example-datetimeindex-clone-88>`
   * - ``DatetimeIndex delete_(size_t loc) const``
     - DatetimeIndex
     - pd_datetime_index.h:1131
     - :ref:`View <example-datetimeindex-delete_-89>`
   * - ``DatetimeIndex delete_(const std::vector<size_t>& locs) const``
     - DatetimeIndex
     - pd_datetime_index.h:1155
     - :ref:`View <example-datetimeindex-delete_-90>`
   * - ``std::string dtype_str() const``
     - std::string
     - pd_datetime_index.h:227
     - :ref:`View <example-datetimeindex-dtype_str-91>`
   * - ``std::pair<numpy::NDArray<numpy::int64>, DatetimeIndex> factorize() const``
     - std::pair<numpy::NDArray<numpy::int64>, DatetimeIndex>
     - pd_datetime_index.h:1503
     - :ref:`View <example-datetimeindex-factorize-92>`
   * - ``DatetimeIndex floor(const std::string& freq, const std::string& ambiguous = "raise", const std::string& nonexistent = "raise") const``
     - DatetimeIndex
     - pd_datetime_index.h:288
     - :ref:`View <example-datetimeindex-floor-93>`
   * - ``std::vector<std::string> format( const std::string& formatter = "%Y-%m-%d", [[maybe_unused]] const std::string& date_format = "", [[maybe_unused]] const std::string& na_rep = "NaT", [[maybe_unused]] bool name = false) const``
     - std::vector<std::string>
     - pd_datetime_index.h:1574
     - :ref:`View <example-datetimeindex-format-94>`
   * - ``std::unique_ptr<DateOffset> freq_offset() const``
     - std::unique_ptr<DateOffset>
     - pd_datetime_index.h:252
     - :ref:`View <example-datetimeindex-freq_offset-95>`
   * - ``bool holds_integer() const``
     - bool
     - pd_datetime_index.h:1779
     - :ref:`View <example-datetimeindex-holds_integer-96>`
   * - ``bool identical(const DatetimeIndex& other) const``
     - bool
     - pd_datetime_index.h:1788
     - :ref:`View <example-datetimeindex-identical-97>`
   * - ``numpy::NDArray<numpy::int64> indexer_at_time(const std::string& time, bool asof = false) const``
     - numpy::NDArray<numpy::int64>
     - pd_datetime_index.h:1799
     - :ref:`View <example-datetimeindex-indexer_at_time-98>`
   * - ``numpy::NDArray<numpy::int64> indexer_between_time( const std::string& start_time, const std::string& end_time, bool include_start = true, bool include_end = true) const``
     - numpy::NDArray<numpy::int64>
     - pd_datetime_index.h:1841
     - :ref:`View <example-datetimeindex-indexer_between_time-99>`
   * - ``std::string infer_freq_from_data() const``
     - std::string
     - pd_datetime_index.h:751
     - 
   * - ``std::string inferred_type() const override``
     - std::string
     - pd_datetime_index.h:219
     - :ref:`View <example-datetimeindex-inferred_type-100>`
   * - ``numpy::datetime64 item() const``
     - numpy::datetime64
     - pd_datetime_index.h:2078
     - :ref:`View <example-datetimeindex-item-101>`
   * - ``size_t memory_usage(bool deep = false) const``
     - size_t
     - pd_datetime_index.h:2126
     - :ref:`View <example-datetimeindex-memory_usage-102>`
   * - ``size_t nbytes() const override``
     - size_t
     - pd_datetime_index.h:2135
     - :ref:`View <example-datetimeindex-nbytes-103>`
   * - ``size_t nlevels() const``
     - size_t
     - pd_datetime_index.h:3466
     - :ref:`View <example-datetimeindex-nlevels-104>`
   * - ``DatetimeIndex normalize() const``
     - DatetimeIndex
     - pd_datetime_index.h:360
     - :ref:`View <example-datetimeindex-normalize-105>`
   * - ``static bool partial_date_to_ns_range(const std::string& s, int64_t& start_ns, int64_t& end_ns)``
     - static bool
     - pd_datetime_index.h:3519
     - 
   * - ``DatetimeIndex putmask(const numpy::NDArray<numpy::bool_>& mask, const numpy::datetime64& value) const``
     - DatetimeIndex
     - pd_datetime_index.h:2194
     - :ref:`View <example-datetimeindex-putmask-106>`
   * - ``numpy::NDArray<numpy::datetime64> ravel() const``
     - numpy::NDArray<numpy::datetime64>
     - pd_datetime_index.h:2215
     - :ref:`View <example-datetimeindex-ravel-107>`
   * - ``DatetimeIndex repeat(size_t repeats, std::optional<int> axis = std::nullopt) const``
     - DatetimeIndex
     - pd_datetime_index.h:2237
     - :ref:`View <example-datetimeindex-repeat-108>`
   * - ``std::string repr() const override``
     - std::string
     - pd_datetime_index.h:796
     - :ref:`View <example-datetimeindex-repr-109>`
   * - ``static int64_t resolve_datetime_endpoint(const std::string& s, const std::string& side)``
     - static int64_t
     - pd_datetime_index.h:3561
     - 
   * - ``DatetimeIndex result(base_result.array(), base_result.name())``
     - DatetimeIndex
     - pd_datetime_index.h:377
     - :ref:`View <example-datetimeindex-result-110>`
   * - ``DatetimeIndex result(base_result.array(), base_result.name())``
     - DatetimeIndex
     - pd_datetime_index.h:392
     - :ref:`View <example-datetimeindex-result-111>`
   * - ``DatetimeIndex result(DatetimeArray(values), this->name())``
     - DatetimeIndex
     - pd_datetime_index.h:2365
     - :ref:`View <example-datetimeindex-result-112>`
   * - ``DatetimeIndex round(const std::string& freq, const std::string& ambiguous = "raise", const std::string& nonexistent = "raise") const``
     - DatetimeIndex
     - pd_datetime_index.h:272
     - :ref:`View <example-datetimeindex-round-113>`
   * - ``DatetimeIndex slice(size_t start, size_t stop, size_t step = 1) const``
     - DatetimeIndex
     - pd_datetime_index.h:2357
     - :ref:`View <example-datetimeindex-slice-114>`
   * - ``std::pair<size_t, size_t> slice_indexer(const std::optional<numpy::datetime64>& start, const std::optional<numpy::datetime64>& stop, const std::optional<numpy::datetime64>& end = std::nullopt, size_t step = 1) const``
     - std::pair<size_t, size_t>
     - pd_datetime_index.h:2315
     - :ref:`View <example-datetimeindex-slice_indexer-115>`
   * - ``std::pair<size_t, size_t> slice_locs(const std::optional<numpy::datetime64>& start = std::nullopt, const std::optional<numpy::datetime64>& stop = std::nullopt, const std::optional<numpy::datetime64>& end = std::nullopt, size_t step = 1) const``
     - std::pair<size_t, size_t>
     - pd_datetime_index.h:2343
     - :ref:`View <example-datetimeindex-slice_locs-116>`
   * - ``std::pair<size_t, size_t> slice_locs_string( const std::string& start, const std::string& stop) const``
     - std::pair<size_t, size_t>
     - pd_datetime_index.h:3575
     - 
   * - ``DatetimeIndex snap(const std::string& freq = "S") const``
     - DatetimeIndex
     - pd_datetime_index.h:316
     - :ref:`View <example-datetimeindex-snap-117>`
   * - ``DatetimeIndex sort(bool ascending = true) const``
     - DatetimeIndex
     - pd_datetime_index.h:2377
     - :ref:`View <example-datetimeindex-sort-118>`
   * - ``DatetimeArray sorted_arr(sorted_values)``
     - DatetimeArray
     - pd_datetime_index.h:3338
     - 
   * - ``std::pair<DatetimeIndex, numpy::NDArray<numpy::int64>> sortlevel( int level = 0, bool ascending = true, bool sort_remaining = true, const std::string& na_position = "last") const``
     - std::pair<DatetimeIndex, numpy::NDArray<numpy::int64>>
     - pd_datetime_index.h:3272
     - :ref:`View <example-datetimeindex-sortlevel-119>`
   * - ``StringMethods<DatetimeIndex> str() const``
     - StringMethods<DatetimeIndex>
     - pd_datetime_index.h:938
     - :ref:`View <example-datetimeindex-str-120>`
   * - ``pandas::Timestamp ts(s)``
     - pandas::Timestamp
     - pd_datetime_index.h:3567
     - :ref:`View <example-datetimeindex-ts-121>`
   * - ``pandas::Timestamp ts(key)``
     - pandas::Timestamp
     - pd_datetime_index.h:3640
     - :ref:`View <example-datetimeindex-ts-122>`
   * - ``pandas::Timestamp ts(key)``
     - pandas::Timestamp
     - pd_datetime_index.h:3681
     - :ref:`View <example-datetimeindex-ts-123>`
   * - ``IndexTypeId type_id() const override``
     - IndexTypeId
     - pd_datetime_index.h:571
     - :ref:`View <example-datetimeindex-type_id-124>`
   * - ``DatetimeIndex upsample(const DateOffset& freq) const``
     - DatetimeIndex
     - pd_datetime_index.h:3713
     - :ref:`View <example-datetimeindex-upsample-125>`
   * - ``DatetimeIndex upsample(const std::string& freq_str) const``
     - DatetimeIndex
     - pd_datetime_index.h:3719
     - :ref:`View <example-datetimeindex-upsample-126>`


Code Examples
-------------

The following examples are extracted from the test suite.

.. _example-datetimeindex-datetimeindex-0:

.. dropdown:: DatetimeIndex (pd_test_2_all.cpp:386)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 376
      :emphasize-lines: 11

      namespace dataframe_tests {
          namespace dataframe_tests_asof {
      
              void pd_test_asof_scalar_basic() {
                  std::cout << "========= asof scalar basic ===========================";
      
                  // Create DataFrame with DatetimeIndex and some NaN values
                  // Similar to pandas example:
                  //   df = pd.DataFrame({'a': [10., 20., 30., 40., 50.],
                  //                      'b': [None, None, None, None, 500]},
                  //                     index=pd.DatetimeIndex(['2018-02-27 09:01:00', ...]))
      
                  std::map<std::string, std::vector<double>> data;
                  data["a"] = {10.0, 20.0, 30.0, 40.0, 50.0};
                  data["b"] = {std::numeric_limits<double>::quiet_NaN(),
                               std::numeric_limits<double>::quiet_NaN(),
                               std::numeric_limits<double>::quiet_NaN(),
                               std::numeric_limits<double>::quiet_NaN(),
                               500.0};
      
                  pandas::DataFrame df(data);

.. _example-datetimeindex-datetimeindex-1:

.. dropdown:: DatetimeIndex (pd_test_2_all.cpp:386)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 376
      :emphasize-lines: 11

      namespace dataframe_tests {
          namespace dataframe_tests_asof {
      
              void pd_test_asof_scalar_basic() {
                  std::cout << "========= asof scalar basic ===========================";
      
                  // Create DataFrame with DatetimeIndex and some NaN values
                  // Similar to pandas example:
                  //   df = pd.DataFrame({'a': [10., 20., 30., 40., 50.],
                  //                      'b': [None, None, None, None, 500]},
                  //                     index=pd.DatetimeIndex(['2018-02-27 09:01:00', ...]))
      
                  std::map<std::string, std::vector<double>> data;
                  data["a"] = {10.0, 20.0, 30.0, 40.0, 50.0};
                  data["b"] = {std::numeric_limits<double>::quiet_NaN(),
                               std::numeric_limits<double>::quiet_NaN(),
                               std::numeric_limits<double>::quiet_NaN(),
                               std::numeric_limits<double>::quiet_NaN(),
                               500.0};
      
                  pandas::DataFrame df(data);

.. _example-datetimeindex-datetimeindex-2:

.. dropdown:: DatetimeIndex (pd_test_2_all.cpp:386)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 376
      :emphasize-lines: 11

      namespace dataframe_tests {
          namespace dataframe_tests_asof {
      
              void pd_test_asof_scalar_basic() {
                  std::cout << "========= asof scalar basic ===========================";
      
                  // Create DataFrame with DatetimeIndex and some NaN values
                  // Similar to pandas example:
                  //   df = pd.DataFrame({'a': [10., 20., 30., 40., 50.],
                  //                      'b': [None, None, None, None, 500]},
                  //                     index=pd.DatetimeIndex(['2018-02-27 09:01:00', ...]))
      
                  std::map<std::string, std::vector<double>> data;
                  data["a"] = {10.0, 20.0, 30.0, 40.0, 50.0};
                  data["b"] = {std::numeric_limits<double>::quiet_NaN(),
                               std::numeric_limits<double>::quiet_NaN(),
                               std::numeric_limits<double>::quiet_NaN(),
                               std::numeric_limits<double>::quiet_NaN(),
                               500.0};
      
                  pandas::DataFrame df(data);

.. _example-datetimeindex-datetimeindex-3:

.. dropdown:: DatetimeIndex (pd_test_2_all.cpp:386)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 376
      :emphasize-lines: 11

      namespace dataframe_tests {
          namespace dataframe_tests_asof {
      
              void pd_test_asof_scalar_basic() {
                  std::cout << "========= asof scalar basic ===========================";
      
                  // Create DataFrame with DatetimeIndex and some NaN values
                  // Similar to pandas example:
                  //   df = pd.DataFrame({'a': [10., 20., 30., 40., 50.],
                  //                      'b': [None, None, None, None, 500]},
                  //                     index=pd.DatetimeIndex(['2018-02-27 09:01:00', ...]))
      
                  std::map<std::string, std::vector<double>> data;
                  data["a"] = {10.0, 20.0, 30.0, 40.0, 50.0};
                  data["b"] = {std::numeric_limits<double>::quiet_NaN(),
                               std::numeric_limits<double>::quiet_NaN(),
                               std::numeric_limits<double>::quiet_NaN(),
                               std::numeric_limits<double>::quiet_NaN(),
                               500.0};
      
                  pandas::DataFrame df(data);

.. _example-datetimeindex-datetimeindex-4:

.. dropdown:: DatetimeIndex (pd_test_2_all.cpp:386)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 376
      :emphasize-lines: 11

      namespace dataframe_tests {
          namespace dataframe_tests_asof {
      
              void pd_test_asof_scalar_basic() {
                  std::cout << "========= asof scalar basic ===========================";
      
                  // Create DataFrame with DatetimeIndex and some NaN values
                  // Similar to pandas example:
                  //   df = pd.DataFrame({'a': [10., 20., 30., 40., 50.],
                  //                      'b': [None, None, None, None, 500]},
                  //                     index=pd.DatetimeIndex(['2018-02-27 09:01:00', ...]))
      
                  std::map<std::string, std::vector<double>> data;
                  data["a"] = {10.0, 20.0, 30.0, 40.0, 50.0};
                  data["b"] = {std::numeric_limits<double>::quiet_NaN(),
                               std::numeric_limits<double>::quiet_NaN(),
                               std::numeric_limits<double>::quiet_NaN(),
                               std::numeric_limits<double>::quiet_NaN(),
                               500.0};
      
                  pandas::DataFrame df(data);

.. _example-datetimeindex-datetimeindex-5:

.. dropdown:: DatetimeIndex (pd_test_2_all.cpp:386)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 376
      :emphasize-lines: 11

      namespace dataframe_tests {
          namespace dataframe_tests_asof {
      
              void pd_test_asof_scalar_basic() {
                  std::cout << "========= asof scalar basic ===========================";
      
                  // Create DataFrame with DatetimeIndex and some NaN values
                  // Similar to pandas example:
                  //   df = pd.DataFrame({'a': [10., 20., 30., 40., 50.],
                  //                      'b': [None, None, None, None, 500]},
                  //                     index=pd.DatetimeIndex(['2018-02-27 09:01:00', ...]))
      
                  std::map<std::string, std::vector<double>> data;
                  data["a"] = {10.0, 20.0, 30.0, 40.0, 50.0};
                  data["b"] = {std::numeric_limits<double>::quiet_NaN(),
                               std::numeric_limits<double>::quiet_NaN(),
                               std::numeric_limits<double>::quiet_NaN(),
                               std::numeric_limits<double>::quiet_NaN(),
                               500.0};
      
                  pandas::DataFrame df(data);

.. _example-datetimeindex-datetimeindex-6:

.. dropdown:: DatetimeIndex (pd_test_2_all.cpp:386)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 376
      :emphasize-lines: 11

      namespace dataframe_tests {
          namespace dataframe_tests_asof {
      
              void pd_test_asof_scalar_basic() {
                  std::cout << "========= asof scalar basic ===========================";
      
                  // Create DataFrame with DatetimeIndex and some NaN values
                  // Similar to pandas example:
                  //   df = pd.DataFrame({'a': [10., 20., 30., 40., 50.],
                  //                      'b': [None, None, None, None, 500]},
                  //                     index=pd.DatetimeIndex(['2018-02-27 09:01:00', ...]))
      
                  std::map<std::string, std::vector<double>> data;
                  data["a"] = {10.0, 20.0, 30.0, 40.0, 50.0};
                  data["b"] = {std::numeric_limits<double>::quiet_NaN(),
                               std::numeric_limits<double>::quiet_NaN(),
                               std::numeric_limits<double>::quiet_NaN(),
                               std::numeric_limits<double>::quiet_NaN(),
                               500.0};
      
                  pandas::DataFrame df(data);

.. _example-datetimeindex-get_datetime_ns_at-7:

.. dropdown:: get_datetime_ns_at (pd_test_3_all.cpp:26202)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 26192
      :emphasize-lines: 11

          auto [is_dt, data] = s.idxmin_typed();
          if (!is_dt) throw std::runtime_error("Expected datetime result");
          if (data.first != 2000000000LL) throw std::runtime_error("Expected 2000000000 ns, got " + std::to_string(data.first));
          std::cout << "PASSED" << std::endl;
      }
      
      void pd_test_idxmax_min_typed_non_datetime_ns() {
          std::cout << "  pd_test_idxmax_min_typed_non_datetime_ns: ";
          // RangeIndex's get_datetime_ns_at should return nullopt
          ::pandas::Series<::numpy::float64> s({1.0, 2.0, 3.0});
          auto result = s.index().get_datetime_ns_at(0);
          if (result.has_value()) throw std::runtime_error("Expected nullopt for non-datetime index");
          std::cout << "PASSED" << std::endl;
      }
      
      void pd_test_idxmax_min_typed_string_fallback() {
          std::cout << "  pd_test_idxmax_min_typed_string_fallback: ";
          // Verify that existing idxmax() string method still works
          ::pandas::Series<::numpy::float64> s({1.0, 3.0, 2.0});
          std::string result = s.idxmax();
          if (result != "1") throw std::runtime_error("Expected '1', got '" + result + "'");

.. _example-datetimeindex-get_indexer-8:

.. dropdown:: get_indexer (pd_test_1_all.cpp:10332)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 10322
      :emphasize-lines: 11

      
      void pd_test_extension_index_get_indexer() {
          std::cout << "========= get_indexer =========================";
      
          pandas::CategoricalArray arr1({"a", "b", "c", "d"});
          pandas::CategoricalIndex idx1(arr1);
      
          pandas::CategoricalArray arr2({"b", "d", "x"});
          pandas::CategoricalIndex idx2(arr2);
      
          auto indexer = idx1.get_indexer(idx2);
      
          bool passed = (indexer.getSize() == 3 &&
                         indexer.getElementAt({0}) == 1 &&
                         indexer.getElementAt({1}) == 3 &&
                         indexer.getElementAt({2}) == -1);
          if (!passed) {
              std::cout << "  [FAIL] : in pd_test_extension_index_get_indexer() : get_indexer check failed" << std::endl;
              throw std::runtime_error("pd_test_extension_index_get_indexer failed");
          }
      

.. _example-datetimeindex-get_indexer_for-9:

.. dropdown:: get_indexer_for (pd_test_3_all.cpp:716)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 706
      :emphasize-lines: 11

      // ============================================================================
      // Category 6: Index Indexer Methods
      // ============================================================================
      
      void pd_test_3_all_index_indexers() {
          std::cout << "========= Index.get_indexer_for/non_unique/slice_indexer() ";
      
          std::vector<std::string> vals = {"a", "b", "c", "d", "e"};
          pandas::Index<std::string> idx(vals);
      
          // Test get_indexer_for()
          std::vector<std::string> target = {"b", "d", "f"};  // "f" doesn't exist
          numpy::NDArray<numpy::int64> indexer = idx.get_indexer_for(target);
          if (indexer.getSize() != 3) {
              std::cout << "  [FAIL] : in pd_test_3_all_index_indexers() : get_indexer_for size mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_index_indexers failed: get_indexer_for size");
          }
          // "b" is at index 1
          if (indexer.getElementAt({0}) != 1) {
              std::cout << "  [FAIL] : in pd_test_3_all_index_indexers() : 'b' should be at index 1" << std::endl;
              throw std::runtime_error("pd_test_3_all_index_indexers failed: 'b' index");

.. _example-datetimeindex-get_indexer_non_unique-10:

.. dropdown:: get_indexer_non_unique (pd_test_3_all.cpp:739)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 729
      :emphasize-lines: 11

          if (indexer.getElementAt({1}) != 3) {
              std::cout << "  [FAIL] : in pd_test_3_all_index_indexers() : 'd' should be at index 3" << std::endl;
              throw std::runtime_error("pd_test_3_all_index_indexers failed: 'd' index");
          }
          // "f" doesn't exist -> -1
          if (indexer.getElementAt({2}) != -1) {
              std::cout << "  [FAIL] : in pd_test_3_all_index_indexers() : 'f' should be -1" << std::endl;
              throw std::runtime_error("pd_test_3_all_index_indexers failed: 'f' index");
          }
      
          // Test get_indexer_non_unique()
          std::vector<std::string> target2 = {"a", "c", "z"};  // "z" doesn't exist
          pandas::Index<std::string> target_idx(target2);
          auto [indexer2, missing] = idx.get_indexer_non_unique(target_idx);
      
          if (indexer2.getSize() < 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_index_indexers() : get_indexer_non_unique size too small" << std::endl;
              throw std::runtime_error("pd_test_3_all_index_indexers failed: get_indexer_non_unique size");
          }
      
          // Test slice_indexer()

.. _example-datetimeindex-get_level_values-11:

.. dropdown:: get_level_values (pd_test_3_all.cpp:4524)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 4514
      :emphasize-lines: 11

          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_interval_index_get_level_values_droplevel() {
          std::cout << "========= IntervalIndex.get_level_values/droplevel() ";
      
          pandas::IntervalIndex64 idx = pandas::IntervalIndex64::from_breaks({0, 10, 20, 30});
      
          // get_level_values(0) should work
          pandas::IntervalIndex64 level_vals = idx.get_level_values(0);
          if (level_vals.size() != idx.size()) {
              throw std::runtime_error("get_level_values(0) size mismatch");
          }
      
          // get_level_values(1) should throw
          bool threw = false;
          try {
              idx.get_level_values(1);
          } catch (const std::out_of_range&) {

.. _example-datetimeindex-get_level_values-12:

.. dropdown:: get_level_values (pd_test_3_all.cpp:4524)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 4514
      :emphasize-lines: 11

          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_interval_index_get_level_values_droplevel() {
          std::cout << "========= IntervalIndex.get_level_values/droplevel() ";
      
          pandas::IntervalIndex64 idx = pandas::IntervalIndex64::from_breaks({0, 10, 20, 30});
      
          // get_level_values(0) should work
          pandas::IntervalIndex64 level_vals = idx.get_level_values(0);
          if (level_vals.size() != idx.size()) {
              throw std::runtime_error("get_level_values(0) size mismatch");
          }
      
          // get_level_values(1) should throw
          bool threw = false;
          try {
              idx.get_level_values(1);
          } catch (const std::out_of_range&) {

.. _example-datetimeindex-get_loc-13:

.. dropdown:: get_loc (pd_test_1_all.cpp:10281)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 10271
      :emphasize-lines: 11

          bool passed = (idx.contains("apple") && idx.contains("banana") && !idx.contains("grape"));
          if (!passed) {
              std::cout << "  [FAIL] : in pd_test_extension_index_contains() : contains check failed" << std::endl;
              throw std::runtime_error("pd_test_extension_index_contains failed");
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_extension_index_get_loc_unique() {
          std::cout << "========= get_loc (unique) =========================";
      
          pandas::CategoricalArray arr({"apple", "banana", "cherry"});
          pandas::CategoricalIndex idx(arr);
      
          auto loc_apple = idx.get_loc("apple");
          auto loc_banana = idx.get_loc("banana");
          auto loc_cherry = idx.get_loc("cherry");
      
          bool passed = (std::holds_alternative<size_t>(loc_apple) && std::get<size_t>(loc_apple) == 0 &&
                         std::get<size_t>(loc_banana) == 1 &&

.. _example-datetimeindex-get_loc_string-14:

.. dropdown:: get_loc_string (pd_test_3_all.cpp:28108)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 28098
      :emphasize-lines: 11

              vals.push_back(numpy::timedelta64(ns, numpy::DateTimeUnit::Nanosecond));
          }
          return pandas::TimedeltaArray(vals);
      }
      
      void pd_test_getitem_timedelta_str_lookup() {
          std::cout << "  -- pd_test_getitem_timedelta_str_lookup --" << std::endl;
          int fail = 0;
          auto tda = ge_make_tda({1 * GE_NS_PER_DAY, 2 * GE_NS_PER_DAY, 3 * GE_NS_PER_DAY});
          pandas::TimedeltaIndex tdi(tda);
          auto pos = tdi.get_loc_string("2 days");
          if (!pos.has_value()) { std::cout << "    FAIL: '2 days' not found" << std::endl; fail++; }
          else if (*pos != 1) { std::cout << "    FAIL: expected pos=1, got " << *pos << std::endl; fail++; }
          if (fail == 0) std::cout << "    OK" << std::endl;
          if (fail) throw std::runtime_error("pd_test_getitem_timedelta_str_lookup failed");
      }
      
      void pd_test_getitem_timedelta_str_not_found() {
          std::cout << "  -- pd_test_getitem_timedelta_str_not_found --" << std::endl;
          int fail = 0;
          auto tda = ge_make_tda({1 * GE_NS_PER_DAY});

.. _example-datetimeindex-get_slice_bound-15:

.. dropdown:: get_slice_bound (pd_test_3_all.cpp:3644)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 3634
      :emphasize-lines: 11

          formatted = idx.format(custom_formatter);
      
          if (formatted[0] != "val:1") {
              throw std::runtime_error("custom formatter failed");
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_index_get_slice_bound() {
          std::cout << "========= Index.get_slice_bound() ==================";
      
          pandas::Index<numpy::int64> idx({10, 20, 30, 40, 50});
      
          // Exact match, left side
          size_t bound = idx.get_slice_bound(30, "left");
          if (bound != 2) {
              throw std::runtime_error("left bound for 30 should be 2");
          }
      
          // Exact match, right side

.. _example-datetimeindex-get_string-16:

.. dropdown:: get_string (pd_test_3_all.cpp:27746)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 27736
      :emphasize-lines: 11

              }
          }
      
          pandas::Series<numpy::int64> si({10, 20, 30}, "ints");
          auto result2 = si.astype("str");
          auto* str_s2 = dynamic_cast<pandas::Series<std::string>*>(result2.get());
          if (!str_s2) {
              std::cout << "    FAIL: expected Series<string> from int" << std::endl;
              fail++;
          } else {
              if (str_s2->get_string(0) != "10") {
                  std::cout << "    FAIL: expected '10', got '" << str_s2->get_string(0) << "'" << std::endl;
                  fail++;
              }
          }
      
          if (fail == 0) std::cout << "    OK" << std::endl;
      }
      
      void pd_test_astype_datetime_to_string() {
          std::cout << "  -- pd_test_astype_datetime_to_string --" << std::endl;

.. _example-datetimeindex-get_value_str-17:

.. dropdown:: get_value_str (pd_test_1_all.cpp:4665)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 4655
      :emphasize-lines: 11

                  auto corr_df = df.corr();
      
                  // Check dimensions
                  bool passed = corr_df.nrows() == 2 && corr_df.ncols() == 2;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_aggregation_dataframe_corr() : corr should be 2x2" << std::endl;
                      throw std::runtime_error("pd_test_aggregation_dataframe_corr failed: corr should be 2x2");
                  }
      
                  // Diagonal should be 1.0
                  std::string aa = corr_df["A"].get_value_str(0);
                  passed = std::abs(std::stod(aa) - 1.0) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_aggregation_dataframe_corr() : diagonal should be 1.0" << std::endl;
                      throw std::runtime_error("pd_test_aggregation_dataframe_corr failed: diagonal should be 1.0");
                  }
      
                  // A-B correlation should be 1.0 (perfect correlation)
                  std::string ab = corr_df["B"].get_value_str(0);
                  passed = std::abs(std::stod(ab) - 1.0) < 0.001;
                  if (!passed) {

.. _example-datetimeindex-take-18:

.. dropdown:: take (pd_test_1_all.cpp:5903)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 5893
      :emphasize-lines: 11

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

.. _example-datetimeindex-where-19:

.. dropdown:: where (pd_test_1_all.cpp:22018)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 22008
      :emphasize-lines: 11

                  data["B"] = {5.0, 6.0, 7.0, 8.0};
                  pandas::DataFrame df(data);
      
                  // Create condition DataFrame (values > 2)
                  std::map<std::string, std::vector<numpy::bool_>> cond_data;
                  cond_data["A"] = {false, false, true, true};   // 1<=2, 2<=2, 3>2, 4>2
                  cond_data["B"] = {true, true, true, true};     // all >2
                  pandas::DataFrame cond(cond_data);
      
                  // Apply where with replacement value -1
                  pandas::DataFrame result = df.where(cond, -1.0);
      
                  // Get column index for A - it's sorted alphabetically in std::map
                  size_t col_a_idx = df.get_column_index("A");
                  size_t col_b_idx = df.get_column_index("B");
      
                  bool passed = true;
                  std::string error_msg;
      
                  // Check A column values
                  std::string a0 = result.iat<double>(0, col_a_idx) == -1.0 ? "ok" : "fail";

.. _example-datetimeindex-drop-20:

.. dropdown:: drop (pd_test_1_all.cpp:6558)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 6548
      :emphasize-lines: 11

                  if (df.ncols() != 2) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_manipulation() : pop ncols != 2" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_manipulation failed: pop ncols != 2");
                  }
                  if (!popped) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_manipulation() : popped is null" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_manipulation failed: popped is null");
                  }
      
                  // Test drop columns
                  auto dropped = df.drop(std::vector<std::string>{"B"}, 1);
                  if (dropped.ncols() != 1) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_manipulation() : drop ncols != 1" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_manipulation failed: drop ncols != 1");
                  }
      
                  // Test rename
                  auto renamed = df.rename_columns(std::map<std::string, std::string>{{"A", "X"}});
                  if (!renamed.has_column("X")) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_manipulation() : rename failed" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_manipulation failed: rename failed");

.. _example-datetimeindex-drop_duplicates-21:

.. dropdown:: drop_duplicates (pd_test_1_all.cpp:6639)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 6629
      :emphasize-lines: 11

                      }
                  }
      
                  // Test drop_duplicates
                  {
                      std::map<std::string, std::vector<numpy::int64>> dup_data;
                      dup_data["A"] = {1, 1, 2, 2};
                      dup_data["B"] = {1, 1, 2, 3};
                      pandas::DataFrame df_dup(dup_data);
      
                      auto deduped = df_dup.drop_duplicates();
                      // Rows 0 and 1 are duplicates (A=1, B=1), so should have 3 rows
                      if (deduped.nrows() != 3) {
                          std::cout << "  [FAIL] : in pd_test_dataframe_manipulation() : drop_duplicates nrows != 3, got " << deduped.nrows() << std::endl;
                          throw std::runtime_error("pd_test_dataframe_manipulation failed: drop_duplicates");
                      }
                  }
      
                  // Test assign
                  {
                      std::map<std::string, std::vector<numpy::int64>> assign_data;

.. _example-datetimeindex-droplevel-22:

.. dropdown:: droplevel (pd_test_1_all.cpp:14428)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 14418
      :emphasize-lines: 11

              void pd_test_multiindex_droplevel() {
                  std::cout << "========= droplevel =================================== ";
      
                  std::vector<std::vector<std::string>> arrays = {
                      {"a", "a", "b"},
                      {"x", "y", "z"},
                      {"1", "2", "3"}
                  };
      
                  pandas::MultiIndex mi = pandas::MultiIndex::from_arrays<std::string>(arrays);
                  pandas::MultiIndex dropped = mi.droplevel(1);
      
                  bool passed = true;
      
                  if (dropped.nlevels() != 2) {
                      std::cout << "  [FAIL] : nlevels should be 2 after drop" << std::endl;
                      passed = false;
                  }
      
                  // Check remaining levels
                  auto tup = dropped[0];

.. _example-datetimeindex-dropna-23:

.. dropdown:: dropna (pd_test_1_all.cpp:531)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 521
      :emphasize-lines: 11

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

.. _example-datetimeindex-insert-24:

.. dropdown:: insert (pd_test_1_all.cpp:12028)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 12018
      :emphasize-lines: 11

                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_index_insert_delete() {
                  std::cout << "========= insert and delete ===========================";
      
                  pandas::Index<numpy::int64> idx{1, 2, 4, 5};
      
                  auto inserted = idx.insert(2, 3);
                  bool passed = (inserted.size() == 5);
                  passed = passed && (inserted[2] == 3);
      
                  auto deleted = inserted.delete_(2);
                  passed = passed && (deleted.size() == 4);
                  passed = passed && deleted.equals(idx);
      
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_index_insert_delete() : insert/delete failed" << std::endl;
                      throw std::runtime_error("pd_test_index_insert_delete failed");

.. _example-datetimeindex-reindex-25:

.. dropdown:: reindex (pd_test_1_all.cpp:6708)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 6698
      :emphasize-lines: 11

                      }
                  }
      
                  // Test reindex rows
                  {
                      std::map<std::string, std::vector<double>> data;
                      data["A"] = {1.0, 2.0, 3.0};
                      pandas::DataFrame df(data);
                      df = df.set_axis({"x", "y", "z"}, 0);
      
                      auto reindexed = df.reindex({"x", "z", "w"}, 0);
                      if (reindexed.nrows() != 3) {
                          std::cout << "  [FAIL] : in pd_test_dataframe_index_ops() : reindex wrong nrows" << std::endl;
                          throw std::runtime_error("pd_test_dataframe_index_ops failed: reindex nrows");
                      }
                      // 'w' should have NaN
                      std::string val = reindexed["A"].get_value_str(2);
                      if (!std::isnan(std::stod(val))) {
                          std::cout << "  [FAIL] : in pd_test_dataframe_index_ops() : missing label should be NaN" << std::endl;
                          throw std::runtime_error("pd_test_dataframe_index_ops failed: reindex NaN");
                      }

.. _example-datetimeindex-rename-26:

.. dropdown:: rename (pd_test_1_all.cpp:5816)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 5806
      :emphasize-lines: 11

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

.. _example-datetimeindex-set_names-27:

.. dropdown:: set_names (pd_test_1_all.cpp:14519)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 14509
      :emphasize-lines: 11

                  std::cout << "-> tests passed" << std::endl;
              }
      
              void pd_test_multiindex_set_names() {
                  std::cout << "========= set_names =================================== ";
      
                  std::vector<std::vector<std::string>> arrays = {{"a", "b"}, {"x", "y"}};
                  pandas::MultiIndex mi = pandas::MultiIndex::from_arrays<std::string>(arrays);
      
                  std::vector<std::optional<std::string>> new_names = {"level_a", "level_b"};
                  pandas::MultiIndex named = mi.set_names(new_names);
      
                  bool passed = (named.names()[0] == "level_a" && named.names()[1] == "level_b");
      
                  if (!passed) {
                      std::cout << "  [FAIL] : names not set correctly" << std::endl;
                      throw std::runtime_error("pd_test_multiindex_set_names failed");
                  }
      
                  std::cout << "-> tests passed" << std::endl;
              }

.. _example-datetimeindex-fillna-28:

.. dropdown:: fillna (pd_test_1_all.cpp:537)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 527
      :emphasize-lines: 11

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

.. _example-datetimeindex-isna-29:

.. dropdown:: isna (pd_test_1_all.cpp:524)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 514
      :emphasize-lines: 11

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

.. _example-datetimeindex-isnull-30:

.. dropdown:: isnull (pd_test_3_all.cpp:671)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 661
      :emphasize-lines: 11

      // Category 5: Index Null Detection
      // ============================================================================
      
      void pd_test_3_all_index_null_detection() {
          std::cout << "========= Index.isnull/notnull() =====================";
      
          // Test with float index (can have NaN)
          std::vector<double> vals = {1.0, std::nan(""), 3.0, std::nan("")};
          pandas::Index<double> idx(vals);
      
          numpy::NDArray<numpy::bool_> isnull_result = idx.isnull();
          if (isnull_result.getSize() != 4) {
              std::cout << "  [FAIL] : in pd_test_3_all_index_null_detection() : isnull() size mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_index_null_detection failed: isnull() size");
          }
          // Index 0: 1.0 -> not null
          if (isnull_result.getElementAt({0})) {
              std::cout << "  [FAIL] : in pd_test_3_all_index_null_detection() : index 0 should not be null" << std::endl;
              throw std::runtime_error("pd_test_3_all_index_null_detection failed: index 0");
          }
          // Index 1: NaN -> null

.. _example-datetimeindex-notna-31:

.. dropdown:: notna (pd_test_1_all.cpp:6595)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 6585
      :emphasize-lines: 11

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

.. _example-datetimeindex-notnull-32:

.. dropdown:: notnull (pd_test_3_all.cpp:665)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 655
      :emphasize-lines: 11

          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      // ============================================================================
      // Category 5: Index Null Detection
      // ============================================================================
      
      void pd_test_3_all_index_null_detection() {
          std::cout << "========= Index.isnull/notnull() =====================";
      
          // Test with float index (can have NaN)
          std::vector<double> vals = {1.0, std::nan(""), 3.0, std::nan("")};
          pandas::Index<double> idx(vals);
      
          numpy::NDArray<numpy::bool_> isnull_result = idx.isnull();
          if (isnull_result.getSize() != 4) {
              std::cout << "  [FAIL] : in pd_test_3_all_index_null_detection() : isnull() size mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_index_null_detection failed: isnull() size");
          }

.. _example-datetimeindex-max-33:

.. dropdown:: max (pd_test_1_all.cpp:771)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 761
      :emphasize-lines: 11

              pandas::CategoricalArray arr = pandas::CategoricalArray::from_codes(codes, cats, true);  // ordered
      
              // Test min
              std::optional<std::string> min_val = arr.min();
              if (!min_val.has_value() || *min_val != "low") {
                  std::cout << "  [FAIL] : in pd_test_categorical_array_ordered_operations() : min != 'low'" << std::endl;
                  throw std::runtime_error("pd_test_categorical_array_ordered_operations failed: min != 'low'");
              }
      
              // Test max
              std::optional<std::string> max_val = arr.max();
              if (!max_val.has_value() || *max_val != "high") {
                  std::cout << "  [FAIL] : in pd_test_categorical_array_ordered_operations() : max != 'high'" << std::endl;
                  throw std::runtime_error("pd_test_categorical_array_ordered_operations failed: max != 'high'");
              }
      
              // Test unordered throws for min/max
              pandas::CategoricalArray unordered = arr.as_unordered();
              bool threw = false;
              try {
                  unordered.min();

.. _example-datetimeindex-min-34:

.. dropdown:: min (pd_test_1_all.cpp:764)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 754
      :emphasize-lines: 11

          }
      
          void pd_test_categorical_array_ordered_operations() {
              std::cout << "========= CategoricalArray: ordered operations (min/max) ======================= ";
      
              std::vector<std::string> cats = {"low", "medium", "high"};
              std::vector<numpy::int32> codes = {0, 2, 1, 0, -1};  // low, high, medium, low, NA
              pandas::CategoricalArray arr = pandas::CategoricalArray::from_codes(codes, cats, true);  // ordered
      
              // Test min
              std::optional<std::string> min_val = arr.min();
              if (!min_val.has_value() || *min_val != "low") {
                  std::cout << "  [FAIL] : in pd_test_categorical_array_ordered_operations() : min != 'low'" << std::endl;
                  throw std::runtime_error("pd_test_categorical_array_ordered_operations failed: min != 'low'");
              }
      
              // Test max
              std::optional<std::string> max_val = arr.max();
              if (!max_val.has_value() || *max_val != "high") {
                  std::cout << "  [FAIL] : in pd_test_categorical_array_ordered_operations() : max != 'high'" << std::endl;
                  throw std::runtime_error("pd_test_categorical_array_ordered_operations failed: max != 'high'");

.. _example-datetimeindex-nunique-35:

.. dropdown:: nunique (pd_test_1_all.cpp:10604)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 10594
      :emphasize-lines: 11

      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_extension_index_nunique() {
          std::cout << "========= nunique =========================";
      
          pandas::CategoricalArray arr({"a", "b", "a", "c", "b", std::nullopt});
          pandas::CategoricalIndex idx(arr);
      
          bool passed = (idx.nunique(true) == 3 && idx.nunique(false) == 4);
          if (!passed) {
              std::cout << "  [FAIL] : in pd_test_extension_index_nunique() : nunique check failed" << std::endl;
              throw std::runtime_error("pd_test_extension_index_nunique failed");
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_extension_index_factorize() {
          std::cout << "========= factorize =========================";

.. _example-datetimeindex-std-36:

.. dropdown:: std (pd_test_1_all.cpp:4526)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 4516
      :emphasize-lines: 11

      #include "../pandas/pd_series.h"
      
      namespace dataframe_tests {
          namespace dataframe_tests_aggregation {
      
              void pd_test_aggregation_series_sem() {
                  std::cout << "========= Series sem ============================";
      
                  pandas::Series<double> s({1.0, 2.0, 3.0, 4.0, 5.0});
                  auto sem_val = s.sem();
                  // std(ddof=1) = sqrt(2.5), sem = sqrt(2.5)/sqrt(5) ≈ 0.707
                  bool passed = sem_val.has_value() && std::abs(*sem_val - 0.707) < 0.01;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_aggregation_series_sem() : sem value incorrect" << std::endl;
                      throw std::runtime_error("pd_test_aggregation_series_sem failed: sem value incorrect");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_aggregation_series_quantile() {

.. _example-datetimeindex-value_counts-37:

.. dropdown:: value_counts (pd_test_1_all.cpp:865)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 855
      :emphasize-lines: 11

              std::vector<std::optional<std::string>> values = {
                  std::optional<std::string>("a"),
                  std::optional<std::string>("b"),
                  std::optional<std::string>("a"),
                  std::optional<std::string>("a"),
                  std::optional<std::string>("b"),
                  std::nullopt  // NA not counted
              };
              pandas::CategoricalArray arr(values);
      
              auto [cats, counts] = arr.value_counts();
      
              // Should have 2 categories
              if (cats.size() != 2 || counts.size() != 2) {
                  std::cout << "  [FAIL] : in pd_test_categorical_array_value_counts() : wrong size" << std::endl;
                  throw std::runtime_error("pd_test_categorical_array_value_counts failed: wrong size");
              }
      
              // Find 'a' count
              int64_t a_count = 0, b_count = 0;
              for (size_t i = 0; i < cats.size(); ++i) {

.. _example-datetimeindex-groupby-38:

.. dropdown:: groupby (pd_test_1_all.cpp:11495)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 11485
      :emphasize-lines: 11

                  std::cout << "========= GroupBy basic =========================";
      
                  // Create DataFrame with category column
                  std::map<std::string, std::vector<double>> data = {
                      {"category", {1.0, 1.0, 2.0, 2.0, 2.0}},
                      {"value", {10.0, 20.0, 30.0, 40.0, 50.0}}
                  };
                  pandas::DataFrame df(data);
      
                  // Test groupby
                  auto grouped = df.groupby("category");
      
                  bool passed = grouped.ngroups() == 2;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_groupby_basic() : ngroups should be 2" << std::endl;
                      throw std::runtime_error("pd_test_groupby_basic failed: ngroups should be 2");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      

.. _example-datetimeindex-map-39:

.. dropdown:: map (pd_test_1_all.cpp:5839)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 5829
      :emphasize-lines: 11

      // Map Tests
      // ============================================================================
      
      void pd_test_categorical_index_map() {
          std::cout << "========= map =========================================";
      
          pandas::CategoricalArray arr({"yes", "no", "yes"});
          pandas::CategoricalIndex idx(arr);
      
          std::unordered_map<std::string, std::string> mapping = {{"yes", "1"}, {"no", "0"}};
          pandas::CategoricalIndex mapped = idx.map(mapping);
      
          bool passed = (mapped.has_category("1") && mapped.has_category("0") &&
                         !mapped.has_category("yes") && !mapped.has_category("no"));
          if (!passed) {
              std::cout << "  [FAIL] : in pd_test_categorical_index_map()" << std::endl;
              throw std::runtime_error("pd_test_categorical_index_map failed");
          }
      
          std::cout << " -> tests passed" << std::endl;
      }

.. _example-datetimeindex-equals-40:

.. dropdown:: equals (pd_test_1_all.cpp:5866)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 5856
      :emphasize-lines: 11

          std::cout << "========= equals ======================================";
      
          pandas::CategoricalArray arr1({"a", "b", "a"});
          pandas::CategoricalArray arr2({"a", "b", "a"});
          pandas::CategoricalArray arr3({"a", "b", "c"});
      
          pandas::CategoricalIndex idx1(arr1);
          pandas::CategoricalIndex idx2(arr2);
          pandas::CategoricalIndex idx3(arr3);
      
          bool passed = (idx1.equals(idx2) && !idx1.equals(idx3));
          if (!passed) {
              std::cout << "  [FAIL] : in pd_test_categorical_index_equals()" << std::endl;
              throw std::runtime_error("pd_test_categorical_index_equals failed");
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_categorical_index_identical() {
          std::cout << "========= identical ===================================";

.. _example-datetimeindex-argsort-41:

.. dropdown:: argsort (pd_test_1_all.cpp:1304)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 1294
      :emphasize-lines: 11

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

.. _example-datetimeindex-searchsorted-42:

.. dropdown:: searchsorted (pd_test_1_all.cpp:18958)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 18948
      :emphasize-lines: 11

      
          // =========================================================================
          // Search Tests
          // =========================================================================
      
          void pd_test_range_index_searchsorted() {
              std::cout << "========= searchsorted ================================ ";
      
              pandas::RangeIndex ri(0, 10, 2);  // [0, 2, 4, 6, 8]
      
              bool passed = (ri.searchsorted(4, "left") == 2 &&
                            ri.searchsorted(4, "right") == 3 &&
                            ri.searchsorted(3, "left") == 2 &&   // 3 would go between 2 and 4
                            ri.searchsorted(-1, "left") == 0 &&  // Before all
                            ri.searchsorted(10, "left") == 5);   // After all
      
              if (!passed) {
                  std::cout << "  [FAIL] : searchsorted" << std::endl;
                  throw std::runtime_error("pd_test_range_index_searchsorted failed");
              }
      

.. _example-datetimeindex-sort_values-43:

.. dropdown:: sort_values (pd_test_1_all.cpp:6408)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 6398
      :emphasize-lines: 11

              void pd_test_dataframe_sorting() {
                  std::cout << "========= sorting ==========================";
      
                  std::map<std::string, std::vector<numpy::float64>> data;
                  data["A"] = {3.0, 1.0, 4.0, 1.0, 5.0};
                  data["B"] = {9.0, 2.0, 6.0, 5.0, 3.0};
      
                  pandas::DataFrame df(data);
      
                  // Test sort_values ascending
                  auto sorted_asc = df.sort_values("A", true);
                  // First value should be smallest (1.0)
                  std::string first_val = sorted_asc["A"].get_value_str(0);
                  if (std::stod(first_val) != 1.0) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_sorting() : sort_values asc first != 1" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_sorting failed: sort_values asc first != 1");
                  }
      
                  // Test sort_values descending
                  auto sorted_desc = df.sort_values("A", false);
                  first_val = sorted_desc["A"].get_value_str(0);

.. _example-datetimeindex-to_frame-44:

.. dropdown:: to_frame (pd_test_3_all.cpp:4931)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 4921
      :emphasize-lines: 11

      
          size_t usage = mi.memory_usage(true);
          if (usage == 0) {
              throw std::runtime_error("memory_usage() should return > 0");
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_multiindex_to_frame() {
          std::cout << "========= MultiIndex.to_frame() =======================";
      
          std::vector<std::vector<std::string>> arrays = {{"a", "b"}, {"x", "y"}};
          std::vector<std::optional<std::string>> names = {"first", "second"};
          pandas::MultiIndex mi = pandas::MultiIndex::from_arrays<std::string>(arrays, names);
      
          auto frame = mi.to_frame();
          if (frame.find("first") == frame.end() || frame.find("second") == frame.end()) {
              throw std::runtime_error("to_frame() missing columns");
          }
      

.. _example-datetimeindex-transpose-45:

.. dropdown:: transpose (pd_test_1_all.cpp:16648)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 16638
      :emphasize-lines: 11

                      std::cout << "  [FAIL] : in pd_test_ndframe_transpose() : T_() size" << std::endl;
                      throw std::runtime_error("pd_test_ndframe_transpose failed: T_() size");
                  }
      
                  passed = transposed[0] == 1 && transposed[1] == 2 && transposed[2] == 3;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_ndframe_transpose() : T_() values" << std::endl;
                      throw std::runtime_error("pd_test_ndframe_transpose failed: T_() values");
                  }
      
                  // Test transpose() alias
                  auto transposed2 = s.transpose();
                  passed = transposed2.size() == s.size();
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_ndframe_transpose() : transpose() size" << std::endl;
                      throw std::runtime_error("pd_test_ndframe_transpose failed: transpose() size");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      

.. _example-datetimeindex-append-46:

.. dropdown:: append (pd_test_1_all.cpp:10650)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 10640
      :emphasize-lines: 11

          std::cout << "========= append =========================";
      
          // Use same categories for both arrays (required by CategoricalArray::concat)
          std::vector<std::string> cats = {"a", "b", "c", "d"};
          pandas::CategoricalArray arr1({"a", "b"}, cats);
          pandas::CategoricalIndex idx1(arr1);
      
          pandas::CategoricalArray arr2({"c", "d"}, cats);
          pandas::CategoricalIndex idx2(arr2);
      
          auto appended = idx1.append(idx2);
      
          bool passed = (appended.size() == 4);
          if (!passed) {
              std::cout << "  [FAIL] : in pd_test_extension_index_append() : append check failed" << std::endl;
              throw std::runtime_error("pd_test_extension_index_append failed");
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      

.. _example-datetimeindex-join-47:

.. dropdown:: join (pd_test_1_all.cpp:12353)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 12343
      :emphasize-lines: 11

      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_index_join() {
                  std::cout << "========= join ========================================";
      
                  pandas::Index<numpy::int64> idx1{1, 2, 3};
                  pandas::Index<numpy::int64> idx2{2, 3, 4};
      
                  auto [inner_joined, left_idx, right_idx] = idx1.join(idx2, "inner");
                  bool passed = (inner_joined.size() == 2);  // {2, 3}
      
                  auto [outer_joined, ol_idx, or_idx] = idx1.join(idx2, "outer");
                  passed = passed && (outer_joined.size() == 4);  // {1, 2, 3, 4}
      
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_index_join() : join failed" << std::endl;
                      throw std::runtime_error("pd_test_index_join failed");
                  }
      

.. _example-datetimeindex-asof-48:

.. dropdown:: asof (pd_test_2_all.cpp:366)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 356
      :emphasize-lines: 11

      
              std::cout << "====================================== [OK] pd_test_add_prefix test suite ========================== " << std::endl;
              return 0;
          }
      
      } // namespace dataframe_tests
      // ------------------- pd_test_add_prefix.cpp (end) -----------------------------
      
      // ------------------- pd_test_asof.cpp (start) -----------------------------
      // dataframe_tests/pd_test_asof.cpp
      // Test for DataFrame.asof() method
      
      #include <iostream>
      #include <cmath>
      #include <stdexcept>
      #include <limits>
      #include "../pandas/pd_dataframe.h"
      
      // CRITICAL: No using namespace directives
      
      namespace dataframe_tests {

.. _example-datetimeindex-asof_locs-49:

.. dropdown:: asof_locs (pd_test_3_all.cpp:3557)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 3547
      :emphasize-lines: 11

              throw std::runtime_error("all() should be true for empty index");
          }
          if (empty_idx.any()) {
              throw std::runtime_error("any() should be false for empty index");
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_index_asof() {
          std::cout << "========= Index.asof()/asof_locs() =================";
      
          // Test with monotonically increasing index
          pandas::Index<numpy::int64> idx({10, 20, 30, 40, 50});
      
          // Exact match
          auto result = idx.asof(30);
          if (!result.has_value() || result.value() != 30) {
              throw std::runtime_error("asof() exact match should return 30");
          }
      

.. _example-datetimeindex-diff-50:

.. dropdown:: diff (pd_test_1_all.cpp:5171)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 5161
      :emphasize-lines: 11

              }
      
              void pd_test_arithmetic_dataframe_diff_shift() {
                  std::cout << "========= DataFrame diff/shift ==================";
      
                  std::map<std::string, std::vector<double>> data;
                  data["A"] = {1.0, 3.0, 6.0, 10.0};
                  pandas::DataFrame df(data);
      
                  // diff: [NaN, 2, 3, 4]
                  auto d = df.diff();
                  std::string val = d["A"].get_value_str(1);
                  bool passed = std::abs(std::stod(val) - 2.0) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_dataframe_diff_shift() : diff failed" << std::endl;
                      throw std::runtime_error("pd_test_arithmetic_dataframe_diff_shift failed: diff failed");
                  }
      
                  // First element should be NaN
                  val = d["A"].get_value_str(0);
                  passed = std::isnan(std::stod(val));

.. _example-datetimeindex-difference-51:

.. dropdown:: difference (pd_test_1_all.cpp:10718)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 10708
      :emphasize-lines: 11

          std::cout << "========= difference =========================";
      
          // Use same categories for both arrays
          std::vector<std::string> cats = {"a", "b", "c", "d"};
          pandas::CategoricalArray arr1({"a", "b", "c", "d"}, cats);
          pandas::CategoricalIndex idx1(arr1);
      
          pandas::CategoricalArray arr2({"b", "d"}, cats);
          pandas::CategoricalIndex idx2(arr2);
      
          auto diff = idx1.difference(idx2);
      
          bool passed = (diff.size() == 2 &&
                         diff.contains("a") && diff.contains("c") &&
                         !diff.contains("b") && !diff.contains("d"));
          if (!passed) {
              std::cout << "  [FAIL] : in pd_test_extension_index_difference() : difference check failed" << std::endl;
              throw std::runtime_error("pd_test_extension_index_difference failed");
          }
      
          std::cout << " -> tests passed" << std::endl;

.. _example-datetimeindex-shift-52:

.. dropdown:: shift (pd_test_1_all.cpp:5188)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 5178
      :emphasize-lines: 11

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

.. _example-datetimeindex-tz_convert-53:

.. dropdown:: tz_convert (pd_test_2_all.cpp:17874)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 17864
      :emphasize-lines: 11

      
              std::cout << "====================================== [OK] pd_test_transform test suite ========================== " << std::endl;
              return 0;
          }
      
      } // namespace dataframe_tests
      // ------------------- pd_test_transform.cpp (end) -----------------------------
      
      // ------------------- pd_test_tz_convert.cpp (start) -----------------------------
      // dataframe_tests/pd_test_tz_convert.cpp
      // Test for DataFrame.tz_convert() method
      
      #include <iostream>
      #include <stdexcept>
      #include <cmath>
      #include "../pandas/pd_dataframe.h"
      
      namespace dataframe_tests {
          namespace dataframe_tests_tz_convert {
      
              void pd_test_tz_convert_basic() {

.. _example-datetimeindex-tz_localize-54:

.. dropdown:: tz_localize (pd_test_1_all.cpp:1431)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 1421
      :emphasize-lines: 11

                  "2023-06-15"
              });
      
              // Initially should be timezone-naive
              if (arr.is_tz_aware()) {
                  std::cout << "  [FAIL] : array should be timezone-naive initially" << std::endl;
                  throw std::runtime_error("pd_test_datetime_array_timezone failed: naive");
              }
      
              // Localize to UTC
              auto localized = arr.tz_localize("UTC");
              if (!localized.is_tz_aware()) {
                  std::cout << "  [FAIL] : localized array should be timezone-aware" << std::endl;
                  throw std::runtime_error("pd_test_datetime_array_timezone failed: localize");
              }
      
              // Verify timezone name in dtype
              auto dt = localized.dtype();
              if (!dt.is_tz_aware()) {
                  std::cout << "  [FAIL] : dtype should be timezone-aware" << std::endl;
                  throw std::runtime_error("pd_test_datetime_array_timezone failed: dtype tz");

.. _example-datetimeindex-to_epoch_components-55:

.. dropdown:: to_epoch_components (pd_test_5_all.cpp:46367)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 46357
      :emphasize-lines: 11

                  numpy::datetime64(NS_2020,     numpy::DateTimeUnit::Nanosecond)},
          };
      }
      
      void f_d5_case_1_nat_propagation(int& local_fail) {
          std::cout << "-- case_1_nat_propagation\n";
          auto values = make_edge_case_values();
          pandas::DatetimeArray arr(values);
          pandas::DatetimeIndex idx(arr, std::optional<std::string>{"t"});
      
          auto comps = idx.to_epoch_components();
          pandas_tests::check(comps.size() == 5, "d5_case_1.size_eq_5", local_fail);
          pandas_tests::check(!comps[0].has_value(), "d5_case_1.slot0_is_nullopt_NaT", local_fail);
      }
      
      void f_d5_case_2_pre_1970_floor_div(int& local_fail) {
          std::cout << "-- case_2_pre_1970_floor_div\n";
          auto values = make_edge_case_values();
          pandas::DatetimeArray arr(values);
          pandas::DatetimeIndex idx(arr);
      

.. _example-datetimeindex-to_flat_index-56:

.. dropdown:: to_flat_index (pd_test_1_all.cpp:14733)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 14723
      :emphasize-lines: 11

      
              void pd_test_multiindex_to_flat_index() {
                  std::cout << "========= to_flat_index =============================== ";
      
                  std::vector<std::vector<std::string>> arrays = {
                      {"a", "b"},
                      {"x", "y"}
                  };
      
                  pandas::MultiIndex mi = pandas::MultiIndex::from_arrays<std::string>(arrays);
                  auto flat = mi.to_flat_index();
      
                  bool passed = (flat.size() == 2 &&
                                flat[0][0] == "a" && flat[0][1] == "x" &&
                                flat[1][0] == "b" && flat[1][1] == "y");
      
                  if (!passed) {
                      std::cout << "  [FAIL] : to_flat_index incorrect" << std::endl;
                      throw std::runtime_error("pd_test_multiindex_to_flat_index failed");
                  }
      

.. _example-datetimeindex-to_julian_date-57:

.. dropdown:: to_julian_date (pd_test_3_all.cpp:20400)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 20390
      :emphasize-lines: 11

      // CRITICAL: No using namespace directives
      
      namespace dataframe_tests {
      namespace dataframe_tests_misc {
      
      // ============================================================================
      // Test DatetimeIndex.to_julian_date
      // ============================================================================
      
      void pd_test_to_julian_date() {
          std::cout << "========= DatetimeIndex.to_julian_date() ==================";
      
          // Create DatetimeIndex with known dates
          std::vector<std::optional<numpy::datetime64>> dates = {
              numpy::datetime64("2000-01-01"),
              numpy::datetime64("2000-01-02"),
              numpy::datetime64("2000-01-03")
          };
          pandas::DatetimeArray arr(dates);
          pandas::DatetimeIndex idx(arr, "test_dates");
      

.. _example-datetimeindex-to_list-58:

.. dropdown:: to_list (pd_test_1_all.cpp:10247)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 10237
      :emphasize-lines: 11

      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_extension_index_to_list() {
          std::cout << "========= to_list =========================";
      
          pandas::CategoricalArray arr({"x", "y", "z"});
          pandas::CategoricalIndex idx(arr);
      
          auto list = idx.to_list();
      
          bool passed = (list.size() == 3 &&
                         list[0].has_value() && *list[0] == "x" &&
                         list[1].has_value() && *list[1] == "y" &&
                         list[2].has_value() && *list[2] == "z");
          if (!passed) {
              std::cout << "  [FAIL] : in pd_test_extension_index_to_list() : to_list check failed" << std::endl;
              throw std::runtime_error("pd_test_extension_index_to_list failed");
          }
      

.. _example-datetimeindex-to_string-59:

.. dropdown:: to_string (pd_test_1_all.cpp:2693)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 2683
      :emphasize-lines: 11

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

.. _example-datetimeindex-to_vector-60:

.. dropdown:: to_vector (pd_test_3_all.cpp:10723)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 10713
      :emphasize-lines: 11

      // ============================================================================
      
      void pd_test_3_all_niche_residual_fixes() {
          std::cout << "========= niche residual fixes ============";
      
          // --- Case 1: DatetimeIndex::to_vector ---
          {
              pandas::DatetimeIndex dt_idx("2023-01-01", 3, "D");
              pandas::DataFrame df;
              df.add_column<int64_t>("id", {1, 2, 3});
              df.add_column<pandas::Timestamp>("Date", dt_idx.to_vector());
              if (df.nrows() != 3) {
                  std::cout << "  [FAIL] : in pd_test_3_all_niche_residual_fixes() : Case 1 nrows" << std::endl;
                  throw std::runtime_error("pd_test_3_all_niche_residual_fixes failed: Case 1 nrows");
              }
              if (df.ncols() != 2) {
                  std::cout << "  [FAIL] : in pd_test_3_all_niche_residual_fixes() : Case 1 ncols" << std::endl;
                  throw std::runtime_error("pd_test_3_all_niche_residual_fixes failed: Case 1 ncols");
              }
          }
      

.. _example-datetimeindex-tolist-61:

.. dropdown:: tolist (pd_test_3_all.cpp:2300)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 2290
      :emphasize-lines: 11

              threw = true;
          }
          if (!threw) {
              throw std::runtime_error("swapaxes should throw for invalid axes");
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_categorical_to_list() {
          std::cout << "========= CategoricalArray.to_list()/tolist() =========";
      
          std::vector<std::optional<std::string>> values = {"a", "b", std::nullopt, "c"};
          pandas::CategoricalArray arr(values);
      
          auto list = arr.to_list();
          if (list.size() != 4 || *list[0] != "a" || *list[1] != "b" ||
              list[2].has_value() || *list[3] != "c") {
              throw std::runtime_error("to_list failed");
          }
      

.. _example-datetimeindex-astype-62:

.. dropdown:: astype (pd_test_1_all.cpp:21292)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 21282
      :emphasize-lines: 11

                  std::cout << "========= astype all columns to float64 =============";
      
                  // Create DataFrame with int64 columns
                  std::map<std::string, std::vector<numpy::int64>> data;
                  data["A"] = {1, 2, 3, 4, 5};
                  data["B"] = {10, 20, 30, 40, 50};
      
                  pandas::DataFrame df(data);
      
                  // Convert all columns to float64
                  pandas::DataFrame df_float = df.astype("float64");
      
                  // Verify dtype changed
                  pandas::Series<std::string> dtypes = df_float.dtypes();
      
                  bool passed = true;
                  if (dtypes[static_cast<size_t>(0)] != "float64") {
                      std::cout << "  [FAIL] : in pd_test_astype_all_columns_to_float64() : column A dtype is " << dtypes[static_cast<size_t>(0)] << ", expected float64" << std::endl;
                      passed = false;
                  }
                  if (dtypes[static_cast<size_t>(1)] != "float64") {

.. _example-datetimeindex-copy-63:

.. dropdown:: copy (pd_test_1_all.cpp:5798)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 5788
      :emphasize-lines: 11

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

.. _example-datetimeindex-infer_objects-64:

.. dropdown:: infer_objects (pd_test_1_all.cpp:27595)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 27585
      :emphasize-lines: 11

                  // Create DataFrame with string column containing integers
                  std::map<std::string, std::vector<std::string>> data;
                  data["A"] = {"1", "2", "3", "4", "5"};
      
                  pandas::DataFrame df(data);
      
                  // Before inference, dtype should be string/object
                  std::string before_dtype = df["A"].dtype_name();
      
                  // Apply infer_objects
                  pandas::DataFrame result = df.infer_objects();
      
                  // After inference, dtype should be int64
                  std::string after_dtype = result["A"].dtype_name();
      
                  bool passed = (after_dtype == "int64");
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_infer_objects_integer_column() : expected int64, got " << after_dtype << std::endl;
                      throw std::runtime_error("pd_test_infer_objects_integer_column failed");
                  }
      

.. _example-datetimeindex-view-65:

.. dropdown:: view (pd_test_3_all.cpp:2147)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 2137
      :emphasize-lines: 11

              throw std::runtime_error("memory_usage shallow too small");
          }
          if (deep < shallow) {
              throw std::runtime_error("memory_usage deep should be >= shallow");
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_categorical_ravel_view() {
          std::cout << "========= CategoricalArray.ravel()/view() =============";
      
          std::vector<std::optional<std::string>> values = {"a", "b", "c"};
          pandas::CategoricalArray arr(values);
      
          auto raveled = arr.ravel();
          if (raveled.size() != 3 || !raveled.equals(arr)) {
              throw std::runtime_error("ravel failed");
          }
      
          auto viewed = arr.view();

.. _example-datetimeindex-duplicated-66:

.. dropdown:: duplicated (pd_test_1_all.cpp:10583)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 10573
      :emphasize-lines: 11

      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_extension_index_duplicated() {
          std::cout << "========= duplicated =========================";
      
          pandas::CategoricalArray arr({"a", "b", "a", "c", "a"});
          pandas::CategoricalIndex idx(arr);
      
          auto dup_mask = idx.duplicated("first");
      
          bool passed = (dup_mask.getElementAt({0}) == false &&
                         dup_mask.getElementAt({1}) == false &&
                         dup_mask.getElementAt({2}) == true &&
                         dup_mask.getElementAt({3}) == false &&
                         dup_mask.getElementAt({4}) == true);
          if (!passed) {
              std::cout << "  [FAIL] : in pd_test_extension_index_duplicated() : duplicated check failed" << std::endl;
              throw std::runtime_error("pd_test_extension_index_duplicated failed");
          }

.. _example-datetimeindex-intersection-67:

.. dropdown:: intersection (pd_test_1_all.cpp:10672)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 10662
      :emphasize-lines: 11

          std::cout << "========= intersection =========================";
      
          // Use same categories for both arrays
          std::vector<std::string> cats = {"a", "b", "c", "d", "e", "f"};
          pandas::CategoricalArray arr1({"a", "b", "c", "d"}, cats);
          pandas::CategoricalIndex idx1(arr1);
      
          pandas::CategoricalArray arr2({"b", "c", "e", "f"}, cats);
          pandas::CategoricalIndex idx2(arr2);
      
          auto inter = idx1.intersection(idx2);
      
          bool passed = (inter.size() == 2 && inter.contains("b") && inter.contains("c"));
          if (!passed) {
              std::cout << "  [FAIL] : in pd_test_extension_index_intersection() : intersection check failed" << std::endl;
              throw std::runtime_error("pd_test_extension_index_intersection failed");
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      

.. _example-datetimeindex-isin-68:

.. dropdown:: isin (pd_test_1_all.cpp:5938)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 5928
      :emphasize-lines: 11

          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_categorical_index_isin() {
          std::cout << "========= inherited isin ==============================";
      
          pandas::CategoricalArray arr({"a", "b", "c", "d"});
          pandas::CategoricalIndex idx(arr);
      
          std::vector<std::string> values = {"a", "c"};
          numpy::NDArray<numpy::bool_> mask = idx.isin(values);
      
          bool passed = (mask.getSize() == 4 &&
                         mask.getElementAt({0}) == true &&   // a
                         mask.getElementAt({1}) == false &&  // b
                         mask.getElementAt({2}) == true &&   // c
                         mask.getElementAt({3}) == false);   // d
          if (!passed) {
              std::cout << "  [FAIL] : in pd_test_categorical_index_isin()" << std::endl;
              throw std::runtime_error("pd_test_categorical_index_isin failed");
          }

.. _example-datetimeindex-symmetric_difference-69:

.. dropdown:: symmetric_difference (pd_test_1_all.cpp:10742)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 10732
      :emphasize-lines: 11

          std::cout << "========= symmetric_difference =========================";
      
          // Use same categories for both arrays
          std::vector<std::string> cats = {"a", "b", "c", "d"};
          pandas::CategoricalArray arr1({"a", "b", "c"}, cats);
          pandas::CategoricalIndex idx1(arr1);
      
          pandas::CategoricalArray arr2({"b", "c", "d"}, cats);
          pandas::CategoricalIndex idx2(arr2);
      
          auto sym_diff = idx1.symmetric_difference(idx2);
      
          bool passed = (sym_diff.size() == 2 &&
                         sym_diff.contains("a") && sym_diff.contains("d") &&
                         !sym_diff.contains("b") && !sym_diff.contains("c"));
          if (!passed) {
              std::cout << "  [FAIL] : in pd_test_extension_index_symmetric_difference() : symmetric_difference check failed" << std::endl;
              throw std::runtime_error("pd_test_extension_index_symmetric_difference failed");
          }
      
          std::cout << " -> tests passed" << std::endl;

.. _example-datetimeindex-union_-70:

.. dropdown:: union_ (pd_test_1_all.cpp:10694)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 10684
      :emphasize-lines: 11

          std::cout << "========= union =========================";
      
          // Use same categories for both arrays
          std::vector<std::string> cats = {"a", "b", "c", "d", "e"};
          pandas::CategoricalArray arr1({"a", "b", "c"}, cats);
          pandas::CategoricalIndex idx1(arr1);
      
          pandas::CategoricalArray arr2({"b", "c", "d", "e"}, cats);
          pandas::CategoricalIndex idx2(arr2);
      
          auto uni = idx1.union_(idx2);
      
          bool passed = (uni.size() == 5 &&
                         uni.contains("a") && uni.contains("b") && uni.contains("c") &&
                         uni.contains("d") && uni.contains("e"));
          if (!passed) {
              std::cout << "  [FAIL] : in pd_test_extension_index_union() : union check failed" << std::endl;
              throw std::runtime_error("pd_test_extension_index_union failed");
          }
      
          std::cout << " -> tests passed" << std::endl;

.. _example-datetimeindex-unique-71:

.. dropdown:: unique (pd_test_1_all.cpp:1345)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 1335
      :emphasize-lines: 11

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

.. _example-datetimeindex-is_-72:

.. dropdown:: is_ (pd_test_3_all.cpp:3972)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 3962
      :emphasize-lines: 11

      
          // For typed Index, this is a no-op
          if (result.size() != 5) {
              throw std::runtime_error("infer_objects size should be 5");
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_index_is_() {
          std::cout << "========= Index.is_() ==============================";
      
          pandas::Index<numpy::int64> idx1({1, 2, 3, 4, 5});
          pandas::Index<numpy::int64> idx2({1, 2, 3, 4, 5});  // Different object
      
          // Different objects should not be the same
          if (idx1.is_(idx2)) {
              throw std::runtime_error("different objects should not be is_() equal");
          }
      
          // Same object should be the same

.. _example-datetimeindex-is_boolean-73:

.. dropdown:: is_boolean (pd_test_3_all.cpp:3290)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 3280
      :emphasize-lines: 11

      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_datetime_index_type_checks() {
          std::cout << "========= DatetimeIndex type checks ======================";
      
          pandas::DatetimeIndex idx = pandas::date_range("2024-01-01", "2024-01-05", std::nullopt, "D");
      
          // Type check methods
          if (idx.is_boolean()) {
              throw std::runtime_error("is_boolean() should be false");
          }
          if (idx.is_categorical()) {
              throw std::runtime_error("is_categorical() should be false");
          }
          if (idx.is_floating()) {
              throw std::runtime_error("is_floating() should be false");
          }
          if (idx.is_integer()) {
              throw std::runtime_error("is_integer() should be false");

.. _example-datetimeindex-is_categorical-74:

.. dropdown:: is_categorical (pd_test_3_all.cpp:3293)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 3283
      :emphasize-lines: 11

      
      void pd_test_3_all_datetime_index_type_checks() {
          std::cout << "========= DatetimeIndex type checks ======================";
      
          pandas::DatetimeIndex idx = pandas::date_range("2024-01-01", "2024-01-05", std::nullopt, "D");
      
          // Type check methods
          if (idx.is_boolean()) {
              throw std::runtime_error("is_boolean() should be false");
          }
          if (idx.is_categorical()) {
              throw std::runtime_error("is_categorical() should be false");
          }
          if (idx.is_floating()) {
              throw std::runtime_error("is_floating() should be false");
          }
          if (idx.is_integer()) {
              throw std::runtime_error("is_integer() should be false");
          }
          if (idx.is_interval()) {
              throw std::runtime_error("is_interval() should be false");

.. _example-datetimeindex-is_floating-75:

.. dropdown:: is_floating (pd_test_3_all.cpp:622)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 612
      :emphasize-lines: 11

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

.. _example-datetimeindex-is_integer-76:

.. dropdown:: is_integer (pd_test_3_all.cpp:618)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 608
      :emphasize-lines: 11

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

.. _example-datetimeindex-is_interval-77:

.. dropdown:: is_interval (pd_test_3_all.cpp:3302)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 3292
      :emphasize-lines: 11

          }
          if (idx.is_categorical()) {
              throw std::runtime_error("is_categorical() should be false");
          }
          if (idx.is_floating()) {
              throw std::runtime_error("is_floating() should be false");
          }
          if (idx.is_integer()) {
              throw std::runtime_error("is_integer() should be false");
          }
          if (idx.is_interval()) {
              throw std::runtime_error("is_interval() should be false");
          }
          if (idx.is_numeric()) {
              throw std::runtime_error("is_numeric() should be false");
          }
          if (idx.is_object()) {
              throw std::runtime_error("is_object() should be false");
          }
          if (idx.holds_integer()) {
              throw std::runtime_error("holds_integer() should be false");

.. _example-datetimeindex-is_numeric-78:

.. dropdown:: is_numeric (pd_test_3_all.cpp:614)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 604
      :emphasize-lines: 11

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

.. _example-datetimeindex-is_object-79:

.. dropdown:: is_object (pd_test_3_all.cpp:626)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 616
      :emphasize-lines: 11

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

.. _example-datetimeindex-all-80:

.. dropdown:: all (pd_test_1_all.cpp:247)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 237
      :emphasize-lines: 11

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

.. _example-datetimeindex-any-81:

.. dropdown:: any (pd_test_1_all.cpp:226)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 216
      :emphasize-lines: 11

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

.. _example-datetimeindex-argmax-82:

.. dropdown:: argmax (pd_test_1_all.cpp:1323)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 1313
      :emphasize-lines: 11

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

.. _example-datetimeindex-argmin-83:

.. dropdown:: argmin (pd_test_1_all.cpp:1316)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 1306
      :emphasize-lines: 11

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

.. _example-datetimeindex-arr-84:

.. dropdown:: arr (pd_test_1_all.cpp:45)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 35
      :emphasize-lines: 11

                  std::cout << "  [FAIL] : in pd_test_boolean_array_constructors() : initializer_list size != 4" << std::endl;
                  throw std::runtime_error("pd_test_boolean_array_constructors failed: initializer_list size != 4");
              }
      
              std::cout << " -> tests passed" << std::endl;
          }
      
          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");
              }
      

.. _example-datetimeindex-arr-85:

.. dropdown:: arr (pd_test_1_all.cpp:45)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 35
      :emphasize-lines: 11

                  std::cout << "  [FAIL] : in pd_test_boolean_array_constructors() : initializer_list size != 4" << std::endl;
                  throw std::runtime_error("pd_test_boolean_array_constructors failed: initializer_list size != 4");
              }
      
              std::cout << " -> tests passed" << std::endl;
          }
      
          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");
              }
      

.. _example-datetimeindex-as_unit-86:

.. dropdown:: as_unit (pd_test_1_all.cpp:9361)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 9351
      :emphasize-lines: 11

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

.. _example-datetimeindex-ceil-87:

.. dropdown:: ceil (pd_test_1_all.cpp:4949)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 4939
      :emphasize-lines: 11

                      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;

.. _example-datetimeindex-clone-88:

.. dropdown:: clone (pd_test_1_all.cpp:5776)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 5766
      :emphasize-lines: 11

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

.. _example-datetimeindex-delete_-89:

.. dropdown:: delete_ (pd_test_1_all.cpp:10501)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 10491
      :emphasize-lines: 11

      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_extension_index_delete() {
          std::cout << "========= delete_ =========================";
      
          pandas::CategoricalArray arr({"a", "b", "c", "d"});
          pandas::CategoricalIndex idx(arr);
      
          auto deleted = idx.delete_(1);
          auto v0 = deleted[0];
          auto v1 = deleted[1];
          auto v2 = deleted[2];
      
          bool passed = (deleted.size() == 3 &&
                         v0.has_value() && *v0 == "a" &&
                         v1.has_value() && *v1 == "c" &&
                         v2.has_value() && *v2 == "d");
          if (!passed) {
              std::cout << "  [FAIL] : in pd_test_extension_index_delete() : delete_ check failed" << std::endl;

.. _example-datetimeindex-delete_-90:

.. dropdown:: delete_ (pd_test_1_all.cpp:10501)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 10491
      :emphasize-lines: 11

      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_extension_index_delete() {
          std::cout << "========= delete_ =========================";
      
          pandas::CategoricalArray arr({"a", "b", "c", "d"});
          pandas::CategoricalIndex idx(arr);
      
          auto deleted = idx.delete_(1);
          auto v0 = deleted[0];
          auto v1 = deleted[1];
          auto v2 = deleted[2];
      
          bool passed = (deleted.size() == 3 &&
                         v0.has_value() && *v0 == "a" &&
                         v1.has_value() && *v1 == "c" &&
                         v2.has_value() && *v2 == "d");
          if (!passed) {
              std::cout << "  [FAIL] : in pd_test_extension_index_delete() : delete_ check failed" << std::endl;

.. _example-datetimeindex-dtype_str-91:

.. dropdown:: dtype_str (pd_test_1_all.cpp:17251)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 17241
      :emphasize-lines: 11

      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_period_index_dtype_str() {
          std::cout << "========= dtype_str property ==========================";
      
          std::vector<int64_t> ordinals = {0, 1};
          pandas::PeriodIndex idx = pandas::PeriodIndex::from_ordinals(ordinals, "M");
      
          std::string dt_str = idx.dtype_str();
      
          bool passed = (dt_str.find("period[") != std::string::npos);
          if (!passed) {
              std::cout << "  [FAIL] : in pd_test_period_index_dtype_str() got: " << dt_str << std::endl;
              throw std::runtime_error("pd_test_period_index_dtype_str failed");
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      

.. _example-datetimeindex-factorize-92:

.. dropdown:: factorize (pd_test_1_all.cpp:1353)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 1343
      :emphasize-lines: 11

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

.. _example-datetimeindex-floor-93:

.. dropdown:: floor (pd_test_1_all.cpp:4942)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 4932
      :emphasize-lines: 11

      
                  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;

.. _example-datetimeindex-format-94:

.. dropdown:: format (main.cpp:20)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 10
      :emphasize-lines: 11

      int main() {
        // Automatically log all output to temp/pd_test_output.log
        numpy::TestLogger logger("temp/pd_test_output.log");
      
        int res = 0;
        int res1 = 0;
        std::string resS = "";
      
        // call all the tests
        res1 = dataframe_tests::pd_test_main();
        resS += std::format("             pd_test_main: {}  errors\n", res1);
        res += res1;
      
        std::cout << "\n------------------------- main --------------------------------------------\n";
        std::cout << std::endl << "All tests completed. Nb errors = " << res << std::endl;
        std::cout << "Details: \n" << resS;
        std::cout << "\n---------------------------------------------------------------------------\n";
        return res;
      }

.. _example-datetimeindex-freq_offset-95:

.. dropdown:: freq_offset (pd_test_5_all.cpp:89280)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 89270
      :emphasize-lines: 11

          }
          out_msg = "<no throw>";
          return false;
      }
      
      template <class Concrete>
      static void check_offset_typed(const std::string& label,
                                     const pandas::DatetimeIndex& idx,
                                     int expected_n,
                                     int& local_fail) {
          std::unique_ptr<pandas::DateOffset> off = idx.freq_offset();
          pandas_tests::check(off != nullptr, label + ".not_null", local_fail);
          if (!off) return;
          const Concrete* cast = dynamic_cast<const Concrete*>(off.get());
          pandas_tests::check(cast != nullptr, label + ".dynamic_cast", local_fail);
          if (!cast) {
              std::cout << "  got name=\"" << off->name() << "\"\n";
              return;
          }
          pandas_tests::check(cast->n() == expected_n, label + ".n_matches", local_fail);
          if (cast->n() != expected_n) {

.. _example-datetimeindex-holds_integer-96:

.. dropdown:: holds_integer (pd_test_3_all.cpp:3311)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 3301
      :emphasize-lines: 11

          }
          if (idx.is_interval()) {
              throw std::runtime_error("is_interval() should be false");
          }
          if (idx.is_numeric()) {
              throw std::runtime_error("is_numeric() should be false");
          }
          if (idx.is_object()) {
              throw std::runtime_error("is_object() should be false");
          }
          if (idx.holds_integer()) {
              throw std::runtime_error("holds_integer() should be false");
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_datetime_index_sort() {
          std::cout << "========= DatetimeIndex.sort_values() ====================";
      
          pandas::DatetimeIndex idx = pandas::date_range("2024-01-01", "2024-01-05", std::nullopt, "D");

.. _example-datetimeindex-identical-97:

.. dropdown:: identical (pd_test_1_all.cpp:5883)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 5873
      :emphasize-lines: 11

      }
      
      void pd_test_categorical_index_identical() {
          std::cout << "========= identical ===================================";
      
          pandas::CategoricalArray arr({"a", "b"});
          pandas::CategoricalIndex idx1(arr, "same_name");
          pandas::CategoricalIndex idx2(arr, "same_name");
          pandas::CategoricalIndex idx3(arr, "diff_name");
      
          bool passed = (idx1.identical(idx2) && !idx1.identical(idx3));
          if (!passed) {
              std::cout << "  [FAIL] : in pd_test_categorical_index_identical()" << std::endl;
              throw std::runtime_error("pd_test_categorical_index_identical failed");
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      // ============================================================================
      // Inherited Operations Tests

.. _example-datetimeindex-indexer_at_time-98:

.. dropdown:: indexer_at_time (pd_test_3_all.cpp:3274)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 3264
      :emphasize-lines: 11

          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_datetime_index_time_operations() {
          std::cout << "========= DatetimeIndex time operations ==================";
      
          // Create datetime index with specific times (using hourly freq)
          pandas::DatetimeIndex idx = pandas::date_range("2024-01-01 09:00:00", "2024-01-01 17:00:00", std::nullopt, "H");
      
          // Test indexer_at_time
          numpy::NDArray<numpy::int64> at_time = idx.indexer_at_time("12:00:00");
          // Should find the 12:00 entry
      
          // Test indexer_between_time
          numpy::NDArray<numpy::int64> between_time = idx.indexer_between_time("10:00:00", "14:00:00");
          // Should find entries between 10:00 and 14:00
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_datetime_index_type_checks() {

.. _example-datetimeindex-indexer_between_time-99:

.. dropdown:: indexer_between_time (pd_test_3_all.cpp:3278)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 3268
      :emphasize-lines: 11

          std::cout << "========= DatetimeIndex time operations ==================";
      
          // Create datetime index with specific times (using hourly freq)
          pandas::DatetimeIndex idx = pandas::date_range("2024-01-01 09:00:00", "2024-01-01 17:00:00", std::nullopt, "H");
      
          // Test indexer_at_time
          numpy::NDArray<numpy::int64> at_time = idx.indexer_at_time("12:00:00");
          // Should find the 12:00 entry
      
          // Test indexer_between_time
          numpy::NDArray<numpy::int64> between_time = idx.indexer_between_time("10:00:00", "14:00:00");
          // Should find entries between 10:00 and 14:00
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_datetime_index_type_checks() {
          std::cout << "========= DatetimeIndex type checks ======================";
      
          pandas::DatetimeIndex idx = pandas::date_range("2024-01-01", "2024-01-05", std::nullopt, "D");
      

.. _example-datetimeindex-inferred_type-100:

.. dropdown:: inferred_type (pd_test_1_all.cpp:5270)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 5260
      :emphasize-lines: 11

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

.. _example-datetimeindex-item-101:

.. dropdown:: item (pd_test_3_all.cpp:3712)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 3702
      :emphasize-lines: 11

      
          // Test is_interval (always false for base Index)
          if (int_idx.is_interval()) {
              throw std::runtime_error("base Index should not be interval");
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_index_item() {
          std::cout << "========= Index.item() =============================";
      
          pandas::Index<numpy::int64> idx1({42});
          numpy::int64 val = idx1.item();
      
          if (val != 42) {
              throw std::runtime_error("item() should return 42");
          }
      
          // Test error for size != 1
          pandas::Index<numpy::int64> idx2({1, 2, 3});

.. _example-datetimeindex-memory_usage-102:

.. dropdown:: memory_usage (pd_test_1_all.cpp:27063)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 27053
      :emphasize-lines: 11

              }
      
              std::cout << "====================================== [OK] pd_test_value_counts test suite ========================== " << std::endl;
              return 0;
          }
      
      } // namespace dataframe_tests
      // ------------------- pd_test_value_counts.cpp (end) -----------------------------
      
      // ------------------- pd_test_memory_usage.cpp (start) -----------------------------
      // Tests for DataFrame.memory_usage() - pandas-compatible memory usage reporting
      
      namespace dataframe_tests {
          namespace dataframe_tests_memory_usage {
      
              void pd_test_memory_usage_basic() {
                  std::cout << "========= basic memory_usage =======================";
      
                  // Create a simple DataFrame with multiple columns
                  std::map<std::string, std::vector<double>> data;
                  data["A"] = {1.0, 2.0, 3.0, 4.0, 5.0};

.. _example-datetimeindex-nbytes-103:

.. dropdown:: nbytes (pd_test_1_all.cpp:6214)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 6204
      :emphasize-lines: 11

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

.. _example-datetimeindex-nlevels-104:

.. dropdown:: nlevels (pd_test_1_all.cpp:14138)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 14128
      :emphasize-lines: 11

      
              // =====================================================================
              // Constructor Tests
              // =====================================================================
      
              void pd_test_multiindex_default_constructor() {
                  std::cout << "========= default constructor ========================= ";
      
                  pandas::MultiIndex mi;
      
                  bool passed = (mi.nlevels() == 0) && (mi.size() == 0) && mi.empty();
      
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_multiindex_default_constructor()" << std::endl;
                      throw std::runtime_error("pd_test_multiindex_default_constructor failed");
                  }
      
                  std::cout << "-> tests passed" << std::endl;
              }
      
              void pd_test_multiindex_from_arrays() {

.. _example-datetimeindex-normalize-105:

.. dropdown:: normalize (pd_test_1_all.cpp:8723)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 8713
      :emphasize-lines: 11

      void pd_test_datetime_mixin_normalize() {
          std::cout << "========= normalize ===================================";
      
          // Create datetime with time component
          std::vector<std::optional<numpy::datetime64>> values = {
              numpy::datetime64(86400000000000LL + 3600000000000LL, numpy::DateTimeUnit::Nanosecond)  // 1 day + 1 hour
          };
          pandas::DatetimeArray arr(values);
          pandas::DatetimeMixinIndex idx(arr);
      
          pandas::DatetimeMixinIndex normalized = idx.normalize();
      
          bool passed = (normalized.size() == 1);
          if (!passed) {
              std::cout << "  [FAIL] : in pd_test_datetime_mixin_normalize()" << std::endl;
              throw std::runtime_error("pd_test_datetime_mixin_normalize failed");
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      

.. _example-datetimeindex-putmask-106:

.. dropdown:: putmask (pd_test_3_all.cpp:3752)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 3742
      :emphasize-lines: 11

      
          // Should be at least sizeof index + 5 * sizeof(int64)
          if (usage < 5 * sizeof(numpy::int64)) {
              throw std::runtime_error("memory_usage too small");
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_index_putmask() {
          std::cout << "========= Index.putmask() ==========================";
      
          pandas::Index<numpy::int64> idx({1, 2, 3, 4, 5});
          numpy::NDArray<numpy::bool_> mask(std::vector<size_t>{5});
          mask.setElementAt({0}, numpy::bool_(true));
          mask.setElementAt({1}, numpy::bool_(false));
          mask.setElementAt({2}, numpy::bool_(true));
          mask.setElementAt({3}, numpy::bool_(false));
          mask.setElementAt({4}, numpy::bool_(true));
      
          auto result = idx.putmask(mask, numpy::int64(99));

.. _example-datetimeindex-ravel-107:

.. dropdown:: ravel (pd_test_3_all.cpp:2147)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 2137
      :emphasize-lines: 11

              throw std::runtime_error("memory_usage shallow too small");
          }
          if (deep < shallow) {
              throw std::runtime_error("memory_usage deep should be >= shallow");
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_categorical_ravel_view() {
          std::cout << "========= CategoricalArray.ravel()/view() =============";
      
          std::vector<std::optional<std::string>> values = {"a", "b", "c"};
          pandas::CategoricalArray arr(values);
      
          auto raveled = arr.ravel();
          if (raveled.size() != 3 || !raveled.equals(arr)) {
              throw std::runtime_error("ravel failed");
          }
      
          auto viewed = arr.view();

.. _example-datetimeindex-repeat-108:

.. dropdown:: repeat (pd_test_3_all.cpp:2166)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 2156
      :emphasize-lines: 11

      
          auto viewed = arr.view();
          if (viewed.size() != 3 || !viewed.equals(arr)) {
              throw std::runtime_error("view failed");
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_categorical_repeat() {
          std::cout << "========= CategoricalArray.repeat() ===================";
      
          std::vector<std::optional<std::string>> values = {"a", "b"};
          pandas::CategoricalArray arr(values);
      
          auto result = arr.repeat(3);
          if (result.size() != 6 || *result[0] != "a" || *result[2] != "a" ||
              *result[3] != "b" || *result[5] != "b") {
              throw std::runtime_error("repeat scalar failed");
          }
      

.. _example-datetimeindex-repr-109:

.. dropdown:: repr (pd_test_1_all.cpp:10906)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 10896
      :emphasize-lines: 11

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

.. _example-datetimeindex-result-110:

.. dropdown:: result (pd_test_1_all.cpp:15406)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 15396
      :emphasize-lines: 11

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

.. _example-datetimeindex-result-111:

.. dropdown:: result (pd_test_1_all.cpp:15406)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 15396
      :emphasize-lines: 11

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

.. _example-datetimeindex-result-112:

.. dropdown:: result (pd_test_1_all.cpp:15406)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 15396
      :emphasize-lines: 11

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

.. _example-datetimeindex-round-113:

.. dropdown:: round (pd_test_1_all.cpp:1688)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 1678
      :emphasize-lines: 11

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

.. _example-datetimeindex-slice-114:

.. dropdown:: slice (pd_test_1_all.cpp:17546)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 17536
      :emphasize-lines: 11

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

.. _example-datetimeindex-slice_indexer-115:

.. dropdown:: slice_indexer (pd_test_3_all.cpp:711)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 701
      :emphasize-lines: 11

          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      // ============================================================================
      // Category 6: Index Indexer Methods
      // ============================================================================
      
      void pd_test_3_all_index_indexers() {
          std::cout << "========= Index.get_indexer_for/non_unique/slice_indexer() ";
      
          std::vector<std::string> vals = {"a", "b", "c", "d", "e"};
          pandas::Index<std::string> idx(vals);
      
          // Test get_indexer_for()
          std::vector<std::string> target = {"b", "d", "f"};  // "f" doesn't exist
          numpy::NDArray<numpy::int64> indexer = idx.get_indexer_for(target);
          if (indexer.getSize() != 3) {
              std::cout << "  [FAIL] : in pd_test_3_all_index_indexers() : get_indexer_for size mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_index_indexers failed: get_indexer_for size");

.. _example-datetimeindex-slice_locs-116:

.. dropdown:: slice_locs (pd_test_1_all.cpp:18275)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 18265
      :emphasize-lines: 11

              }
      
              std::cout << "-> tests passed" << std::endl;
          }
      
          void pd_test_range_index_slice_locs() {
              std::cout << "========= slice_locs ================================== ";
      
              pandas::RangeIndex ri(0, 10);  // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
      
              auto [start_idx, stop_idx] = ri.slice_locs(3, 7);
      
              bool passed = (start_idx == 3 && stop_idx == 8);
      
              if (!passed) {
                  std::cout << "  [FAIL] : slice_locs" << std::endl;
                  throw std::runtime_error("pd_test_range_index_slice_locs failed");
              }
      
              std::cout << "-> tests passed" << std::endl;
          }

.. _example-datetimeindex-snap-117:

.. dropdown:: snap (pd_test_1_all.cpp:8364)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 8354
      :emphasize-lines: 11

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

.. _example-datetimeindex-sort-118:

.. dropdown:: sort (pd_test_3_all.cpp:3869)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 3859
      :emphasize-lines: 11

              throw std::runtime_error("last 2 positions should be NaN");
          }
          if (std::abs(result[0] - 3.0) > 0.001) {
              throw std::runtime_error("shift(-2) [0] should be 3.0");
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_index_sort() {
          std::cout << "========= Index.sort() =============================";
      
          pandas::Index<numpy::int64> idx({3, 1, 4, 1, 5, 9, 2, 6});
          auto result = idx.sort();
      
          if (result[0] != 1 || result[1] != 1 || result[7] != 9) {
              throw std::runtime_error("sort() not working correctly");
          }
      
          // Test descending
          result = idx.sort(false);

.. _example-datetimeindex-sortlevel-119:

.. dropdown:: sortlevel (pd_test_1_all.cpp:14676)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 14666
      :emphasize-lines: 11

      
              void pd_test_multiindex_sortlevel() {
                  std::cout << "========= sortlevel =================================== ";
      
                  std::vector<std::vector<std::string>> arrays = {
                      {"b", "a", "c"},
                      {"2", "1", "3"}
                  };
      
                  pandas::MultiIndex mi = pandas::MultiIndex::from_arrays<std::string>(arrays);
                  auto [sorted, indices] = mi.sortlevel(0);
      
                  bool passed = true;
      
                  // After sorting by level 0: a, b, c
                  if (sorted[0][0] != "a" || sorted[1][0] != "b" || sorted[2][0] != "c") {
                      std::cout << "  [FAIL] : not sorted correctly by level 0" << std::endl;
                      passed = false;
                  }
      
                  if (!passed) {

.. _example-datetimeindex-str-120:

.. dropdown:: str (pd_test_1_all.cpp:7137)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 7127
      :emphasize-lines: 11

                  // Test basic info() with stringstream
                  std::map<std::string, std::vector<int>> data = {
                      {"A", {1, 2, 3, 4, 5}},
                      {"B", {10, 20, 30, 40, 50}},
                      {"C", {100, 200, 300, 400, 500}}
                  };
                  pandas::DataFrame df(data);
      
                  std::ostringstream oss;
                  df.info(oss);
                  std::string output = oss.str();
      
                  // Verify key components
                  if (output.find("<class 'pandas.core.frame.DataFrame'>") == std::string::npos) {
                      std::cout << "  [FAIL] : info missing class name" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_info failed: missing class name");
                  }
                  if (output.find("RangeIndex:") == std::string::npos) {
                      std::cout << "  [FAIL] : info missing RangeIndex" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_info failed: missing RangeIndex");
                  }

.. _example-datetimeindex-ts-121:

.. dropdown:: ts (pd_test_2_all.cpp:22590)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 22580
      :emphasize-lines: 11

      
      void test_to_datetime_numeric_seconds() {
          std::cout << "  -- test_to_datetime_numeric_seconds --" << std::endl;
          // 1490195805 seconds = 2017-03-22 15:16:45 UTC
          std::vector<double> vals = {1490195805.0};
          auto arr = pandas::to_datetime_numeric(vals, "s");
          check(arr.size() == 1, "size==1");
          auto v = arr[0];
          check(v.has_value(), "has_value");
          if (v.has_value()) {
              pandas::Timestamp ts(v->getValue());
              check(ts.year() == 2017, "year==2017");
              check(ts.month() == 3, "month==3");
              check(ts.day() == 22, "day==22");
              check(ts.hour() == 15, "hour==15");
              check(ts.minute() == 16, "min==16");
              check(ts.second() == 45, "sec==45");
          }
      }
      
      void test_to_datetime_numeric_millis() {

.. _example-datetimeindex-ts-122:

.. dropdown:: ts (pd_test_2_all.cpp:22590)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 22580
      :emphasize-lines: 11

      
      void test_to_datetime_numeric_seconds() {
          std::cout << "  -- test_to_datetime_numeric_seconds --" << std::endl;
          // 1490195805 seconds = 2017-03-22 15:16:45 UTC
          std::vector<double> vals = {1490195805.0};
          auto arr = pandas::to_datetime_numeric(vals, "s");
          check(arr.size() == 1, "size==1");
          auto v = arr[0];
          check(v.has_value(), "has_value");
          if (v.has_value()) {
              pandas::Timestamp ts(v->getValue());
              check(ts.year() == 2017, "year==2017");
              check(ts.month() == 3, "month==3");
              check(ts.day() == 22, "day==22");
              check(ts.hour() == 15, "hour==15");
              check(ts.minute() == 16, "min==16");
              check(ts.second() == 45, "sec==45");
          }
      }
      
      void test_to_datetime_numeric_millis() {

.. _example-datetimeindex-ts-123:

.. dropdown:: ts (pd_test_2_all.cpp:22590)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 22580
      :emphasize-lines: 11

      
      void test_to_datetime_numeric_seconds() {
          std::cout << "  -- test_to_datetime_numeric_seconds --" << std::endl;
          // 1490195805 seconds = 2017-03-22 15:16:45 UTC
          std::vector<double> vals = {1490195805.0};
          auto arr = pandas::to_datetime_numeric(vals, "s");
          check(arr.size() == 1, "size==1");
          auto v = arr[0];
          check(v.has_value(), "has_value");
          if (v.has_value()) {
              pandas::Timestamp ts(v->getValue());
              check(ts.year() == 2017, "year==2017");
              check(ts.month() == 3, "month==3");
              check(ts.day() == 22, "day==22");
              check(ts.hour() == 15, "hour==15");
              check(ts.minute() == 16, "min==16");
              check(ts.second() == 45, "sec==45");
          }
      }
      
      void test_to_datetime_numeric_millis() {

.. _example-datetimeindex-type_id-124:

.. dropdown:: type_id (pd_test_3_all.cpp:25592)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 25582
      :emphasize-lines: 11

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

.. _example-datetimeindex-upsample-125:

.. dropdown:: upsample (pd_test_5_all.cpp:87061)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 87051
      :emphasize-lines: 11

          pandas::DataFrame df;
          std::vector<int64_t> v(idx.size(), 0);
          df.add_column<int64_t>("v", v);
          df.set_index(std::make_unique<pandas::DatetimeIndex>(idx));
          return df;
      }
      
      void f_core_05_upsample_05f4ab_case_1_hourly_of_daily(int& local_fail) {
          std::cout << "-- case_1_hourly_of_daily\n";
          auto idx = mk_idx({"2020-01-01", "2020-01-02", "2020-01-03"});
          auto up = idx.upsample(pandas::Hour(1));
          pandas_tests::check(up.size() == 49,
                              "case_1.hourly_of_daily.size==49", local_fail);
      }
      
      void f_core_05_upsample_05f4ab_case_2_minute_of_hourly(int& local_fail) {
          std::cout << "-- case_2_minute_of_hourly\n";
          auto idx = mk_idx({"2020-01-01T00:00:00", "2020-01-01T02:00:00"});
          auto up = idx.upsample(pandas::Minute(1));
          pandas_tests::check(up.size() == 121,
                              "case_2.minute_of_hourly.size==121", local_fail);

.. _example-datetimeindex-upsample-126:

.. dropdown:: upsample (pd_test_5_all.cpp:87061)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 87051
      :emphasize-lines: 11

          pandas::DataFrame df;
          std::vector<int64_t> v(idx.size(), 0);
          df.add_column<int64_t>("v", v);
          df.set_index(std::make_unique<pandas::DatetimeIndex>(idx));
          return df;
      }
      
      void f_core_05_upsample_05f4ab_case_1_hourly_of_daily(int& local_fail) {
          std::cout << "-- case_1_hourly_of_daily\n";
          auto idx = mk_idx({"2020-01-01", "2020-01-02", "2020-01-03"});
          auto up = idx.upsample(pandas::Hour(1));
          pandas_tests::check(up.size() == 49,
                              "case_1.hourly_of_daily.size==49", local_fail);
      }
      
      void f_core_05_upsample_05f4ab_case_2_minute_of_hourly(int& local_fail) {
          std::cout << "-- case_2_minute_of_hourly\n";
          auto idx = mk_idx({"2020-01-01T00:00:00", "2020-01-01T02:00:00"});
          auto up = idx.upsample(pandas::Minute(1));
          pandas_tests::check(up.size() == 121,
                              "case_2.minute_of_hourly.size==121", local_fail);