DataFrame
=========

.. cpp:class:: pandas::DataFrame

   Core data container class in the pandas namespace.

Example
-------

.. code-block:: cpp

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

   // Create DataFrame
   DataFrame df;
   df["A"] = {1, 2, 3};
   df["B"] = {4.0, 5.0, 6.0};

   // Access data
   auto shape = df.shape();
   auto columns = df.columns();

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

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

   * - Signature
     - Location
     - Example
   * - ``DataFrame(const std::map<std::string, std::vector<T>>& data, std::unique_ptr<IndexBase> index = nullptr, const std::string& dtype = "", bool copy = false)``
     - pd_dataframe.h:761
     - :ref:`View <example-dataframe-dataframe-0>`
   * - ``DataFrame(const std::vector<Series<T>>& columns, const std::vector<std::string>& column_names, std::unique_ptr<IndexBase> index = nullptr, const std::string& dtype = "", bool copy = false)``
     - pd_dataframe.h:819
     - :ref:`View <example-dataframe-dataframe-1>`
   * - ``DataFrame(const numpy::NDArray<T>& data, std::unique_ptr<IndexBase> index = nullptr, const std::vector<std::string>& columns = {}, const std::string& dtype = "", bool copy = false)``
     - pd_dataframe.h:884
     - :ref:`View <example-dataframe-dataframe-2>`
   * - ``DataFrame(const DataFrame& other)``
     - pd_dataframe.h:939
     - :ref:`View <example-dataframe-dataframe-3>`
   * - ``DataFrame(DataFrame&& other) noexcept``
     - pd_dataframe.h:964
     - :ref:`View <example-dataframe-dataframe-4>`
   * - ``DataFrame(const std::map<std::string, std::vector<std::complex<double>>>& cols)``
     - pd_dataframe.h:1078
     - :ref:`View <example-dataframe-dataframe-5>`
   * - ``DataFrame(const std::map<std::string, ColumnSource>& cols)``
     - pd_dataframe.h:1123
     - :ref:`View <example-dataframe-dataframe-6>`

Construction
------------

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

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``std::unique_ptr<NDFrameBase> create_nan_filled(size_t n) const override``
     - std::unique_ptr<NDFrameBase>
     - pd_dataframe.h:27133
     - 

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

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

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``T at(const std::string& row_label, const std::string& col_label) const``
     - T
     - pd_dataframe.h:3997
     - :ref:`View <example-dataframe-at-7>`
   * - ``DataFrame at_time(const std::string& time, bool asof = false, int axis = 0) const``
     - DataFrame
     - pd_dataframe.h:26966
     - :ref:`View <example-dataframe-at_time-8>`
   * - ``const Attrs& attrs() const override``
     - const Attrs&
     - pd_dataframe.h:1825
     - :ref:`View <example-dataframe-attrs-9>`
   * - ``Attrs& attrs() override``
     - Attrs&
     - pd_dataframe.h:1832
     - :ref:`View <example-dataframe-attrs-10>`
   * - ``DataFrame first(const std::string& offset) const``
     - DataFrame
     - pd_dataframe.h:27022
     - :ref:`View <example-dataframe-first-11>`
   * - ``std::optional<std::string> first_valid_index() const``
     - std::optional<std::string>
     - pd_dataframe.h:13168
     - :ref:`View <example-dataframe-first_valid_index-12>`
   * - ``std::optional<ReturnType> get(const std::string& key, std::optional<ReturnType> default_value = std::nullopt) const``
     - std::optional<ReturnType>
     - pd_dataframe.h:13303
     - :ref:`View <example-dataframe-get-13>`
   * - ``Series<numpy::bool_> get_column_as_bool_series(const std::string& key) const``
     - Series<numpy::bool_>
     - pd_dataframe.h:3379
     - 
   * - ``Series<numpy::int64> get_column_as_int64_series(const std::string& key) const``
     - Series<numpy::int64>
     - pd_dataframe.h:3458
     - 
   * - ``Series<T> get_column_as_series(size_t c, const MultiIndexColumnLabel\* label = nullptr) const``
     - Series<T>
     - pd_dataframe.h:3149
     - :ref:`View <example-dataframe-get_column_as_series-14>`
   * - ``Series<std::string> get_column_as_string_series(const std::string& key) const``
     - Series<std::string>
     - pd_dataframe.h:3422
     - :ref:`View <example-dataframe-get_column_as_string_series-15>`
   * - ``const Series<numpy::uint64>\* get_column_as_uint64_raw(const std::string& key) const``
     - const Series<numpy::uint64>\*
     - pd_dataframe.h:3510
     - 
   * - ``Series<numpy::float64> get_column_as_uint64_series(const std::string& key) const``
     - Series<numpy::float64>
     - pd_dataframe.h:3489
     - 
   * - ``size_t get_column_index(const std::string& name) const``
     - size_t
     - pd_dataframe.h:3282
     - :ref:`View <example-dataframe-get_column_index-16>`
   * - ``static std::pair<double, double> get_column_range(const NDFrameBase\* col)``
     - static std::pair<double, double>
     - pd_dataframe.h:22474
     - 
   * - ``std::vector<double> get_column_values_as_double_(size_t col_idx) const``
     - std::vector<double>
     - pd_dataframe.h:23099
     - 
   * - ``const std::vector<std::vector<std::string>>& get_columns_level_categories() const``
     - const std::vector<std::vector<std::string>>&
     - pd_dataframe.h:1537
     - 
   * - ``const std::vector<bool>& get_columns_level_ordered() const``
     - const std::vector<bool>&
     - pd_dataframe.h:1544
     - 
   * - ``DataFrame get_dummies( const std::vector<std::string>& columns_to_encode = {}, const std::string& prefix_str = "", const std::vector<std::string>& prefix_list = {}, const std::map<std::string, std::string>& prefix_dict = {}, bool prefix_is_list = false, bool prefix_is_dict = false, const std::string& prefix_sep = "_", bool dummy_na = false, bool drop_first = false, const std::string& dtype_str = "") const``
     - DataFrame
     - pd_dataframe.h:7226
     - :ref:`View <example-dataframe-get_dummies-17>`
   * - ``DataFrame get_duplicate_columns(const std::string& key) const``
     - DataFrame
     - pd_dataframe.h:3347
     - :ref:`View <example-dataframe-get_duplicate_columns-18>`
   * - ``DataFrame get_multiindex_column_group(const std::string& key) const``
     - DataFrame
     - pd_dataframe.h:3562
     - 
   * - ``size_t get_num_levels(int axis) const``
     - size_t
     - pd_dataframe.h:15914
     - 
   * - ``std::optional<const NDFrameBase\*> get_optional(const std::string& key) const``
     - std::optional<const NDFrameBase\*>
     - pd_dataframe.h:6753
     - :ref:`View <example-dataframe-get_optional-19>`
   * - ``Series<T> get_series(const std::string& col_name) const``
     - Series<T>
     - pd_dataframe.h:3630
     - :ref:`View <example-dataframe-get_series-20>`
   * - ``bool get_value_bool(size_t idx) const override``
     - bool
     - pd_dataframe.h:8435
     - :ref:`View <example-dataframe-get_value_bool-21>`
   * - ``DataFrame head(size_t n = 5) const``
     - DataFrame
     - pd_dataframe.h:4016
     - :ref:`View <example-dataframe-head-22>`
   * - ``T iat(size_t row, size_t col_idx) const``
     - T
     - pd_dataframe.h:4005
     - :ref:`View <example-dataframe-iat-23>`
   * - ``Series<std::string> idxmax(int axis = 0, bool skipna = true, bool numeric_only = false) const``
     - Series<std::string>
     - pd_dataframe.h:10501
     - :ref:`View <example-dataframe-idxmax-24>`
   * - ``Series<std::string> idxmin(int axis = 0, bool skipna = true, bool numeric_only = false) const``
     - Series<std::string>
     - pd_dataframe.h:10587
     - :ref:`View <example-dataframe-idxmin-25>`
   * - ``DataFrame iloc(size_t start, size_t stop) const``
     - DataFrame
     - pd_dataframe.h:3794
     - :ref:`View <example-dataframe-iloc-26>`
   * - ``T iloc(size_t row, size_t col_idx) const``
     - T
     - pd_dataframe.h:3802
     - :ref:`View <example-dataframe-iloc-27>`
   * - ``DataFrame iloc(const std::vector<size_t>& row_indices, const std::vector<size_t>& col_indices) const``
     - DataFrame
     - pd_dataframe.h:3983
     - :ref:`View <example-dataframe-iloc-28>`
   * - ``DataFrame iloc_cols(const std::vector<size_t>& col_indices) const``
     - DataFrame
     - pd_dataframe.h:3969
     - 
   * - ``DataFrame iloc_row(size_t row) const``
     - DataFrame
     - pd_dataframe.h:3820
     - 
   * - ``DataFrame iloc_rows(size_t start, size_t stop, size_t step = 1) const``
     - DataFrame
     - pd_dataframe.h:3830
     - :ref:`View <example-dataframe-iloc_rows-29>`
   * - ``DataFrame iloc_rows(const std::vector<size_t>& row_indices) const``
     - DataFrame
     - pd_dataframe.h:3865
     - :ref:`View <example-dataframe-iloc_rows-30>`
   * - ``DataFrame last(const std::string& offset) const``
     - DataFrame
     - pd_dataframe.h:27029
     - :ref:`View <example-dataframe-last-31>`
   * - ``std::optional<std::string> last_valid_index() const``
     - std::optional<std::string>
     - pd_dataframe.h:13188
     - :ref:`View <example-dataframe-last_valid_index-32>`
   * - ``T loc(const std::string& row_label, const std::string& col_label) const``
     - T
     - pd_dataframe.h:3709
     - :ref:`View <example-dataframe-loc-33>`
   * - ``DataFrame loc(const std::string& start_label, const std::string& end_label) const``
     - DataFrame
     - pd_dataframe.h:3718
     - :ref:`View <example-dataframe-loc-34>`
   * - ``LocProxy loc(const std::string& label1, const std::string& label2)``
     - LocProxy
     - pd_dataframe.h:3730
     - :ref:`View <example-dataframe-loc-35>`
   * - ``DataFrame loc(const std::string& first_level_label) const``
     - DataFrame
     - pd_dataframe.h:3737
     - :ref:`View <example-dataframe-loc-36>`
   * - ``DataFrame loc(const std::vector<std::string>& row_labels, const std::vector<std::string>& col_labels) const``
     - DataFrame
     - pd_dataframe.h:3781
     - :ref:`View <example-dataframe-loc-37>`
   * - ``DataFrame loc_row(const std::string& row_label) const``
     - DataFrame
     - pd_dataframe.h:3759
     - 
   * - ``DataFrame loc_rows(const std::vector<std::string>& row_labels) const``
     - DataFrame
     - pd_dataframe.h:3767
     - 
   * - ``DataFrame mask(const DataFrame& cond, double other = std::numeric_limits<double>::quiet_NaN(), bool inplace = false, int axis = 0, std::optional<int> level = std::nullopt) const``
     - DataFrame
     - pd_dataframe.h:9354
     - :ref:`View <example-dataframe-mask-38>`
   * - ``DataFrame nlargest(size_t n, const std::string& columns, const std::string& keep = "first") const``
     - DataFrame
     - pd_dataframe.h:15038
     - :ref:`View <example-dataframe-nlargest-39>`
   * - ``DataFrame nsmallest(size_t n, const std::string& columns, const std::string& keep = "first") const``
     - DataFrame
     - pd_dataframe.h:15051
     - :ref:`View <example-dataframe-nsmallest-40>`
   * - ``DataFrame query(const std::string& expr, bool inplace = false) const``
     - DataFrame
     - pd_dataframe.h:9486
     - :ref:`View <example-dataframe-query-41>`
   * - ``std::string query_get_value_str(const std::string& name, size_t row) const``
     - std::string
     - pd_dataframe.h:9539
     - 
   * - ``static double query_str_to_double(const std::string& s)``
     - static double
     - pd_dataframe.h:9617
     - 
   * - ``DataFrame sample(std::optional<size_t> n = std::nullopt, std::optional<double> frac = std::nullopt, bool replace = false, const std::vector<double>& weights = {}, unsigned int random_state = 0, bool ignore_index = false, std::optional<int> axis = std::nullopt) const``
     - DataFrame
     - pd_dataframe.h:4040
     - :ref:`View <example-dataframe-sample-42>`
   * - ``DataFrame sample(T n, unsigned int seed) const``
     - DataFrame
     - pd_dataframe.h:4141
     - :ref:`View <example-dataframe-sample-43>`
   * - ``DataFrame sample(T n, unsigned int seed) const``
     - DataFrame
     - pd_dataframe.h:4155
     - :ref:`View <example-dataframe-sample-44>`
   * - ``DataFrame sample(std::optional<size_t> n, std::optional<double> frac, bool replace, unsigned int random_state) const``
     - DataFrame
     - pd_dataframe.h:4176
     - :ref:`View <example-dataframe-sample-45>`
   * - ``DataFrame sample(std::optional<size_t> n, std::optional<double> frac, bool replace, unsigned int random_state, bool ignore_index) const``
     - DataFrame
     - pd_dataframe.h:4187
     - :ref:`View <example-dataframe-sample-46>`
   * - ``DataFrame sample_frac(double frac, unsigned int seed = 0) const``
     - DataFrame
     - pd_dataframe.h:4168
     - :ref:`View <example-dataframe-sample_frac-47>`
   * - ``void set_value_double(size_t idx, double value) override``
     - void
     - pd_dataframe.h:8465
     - 
   * - ``void set_value_nan(size_t idx) override``
     - void
     - pd_dataframe.h:8449
     - :ref:`View <example-dataframe-set_value_nan-48>`
   * - ``DataFrame tail(size_t n = 5) const``
     - DataFrame
     - pd_dataframe.h:4024
     - :ref:`View <example-dataframe-tail-49>`
   * - ``DataFrame take(const std::vector<size_t>& indices, int axis = 0) const``
     - DataFrame
     - pd_dataframe.h:4201
     - :ref:`View <example-dataframe-take-50>`
   * - ``std::unique_ptr<NDFrameBase> take_indices(const std::vector<size_t>& indices) const override``
     - std::unique_ptr<NDFrameBase>
     - pd_dataframe.h:27152
     - 
   * - ``DataFrame where(const DataFrame& cond, const Series<numpy::float64>& other, int axis) const``
     - DataFrame
     - pd_dataframe.h:8953
     - :ref:`View <example-dataframe-where-51>`
   * - ``DataFrame where(const DataFrame& cond, const DataFrame& other) const``
     - DataFrame
     - pd_dataframe.h:8993
     - :ref:`View <example-dataframe-where-52>`
   * - ``DataFrame where(const DataFrame& cond, double other = std::numeric_limits<double>::quiet_NaN(), bool inplace = false, int axis = 0, std::optional<int> level = std::nullopt) const``
     - DataFrame
     - pd_dataframe.h:9130
     - :ref:`View <example-dataframe-where-53>`
   * - ``DataFrame where_resolved(const WhereCondition& cond, const WhereOther& other, int axis) const``
     - DataFrame
     - pd_dataframe.h:9271
     - :ref:`View <example-dataframe-where_resolved-54>`
   * - ``DataFrame xs(const std::string& key, int axis = 0, std::optional<int> level = std::nullopt, bool drop_level = true) const``
     - DataFrame
     - pd_dataframe.h:4274
     - :ref:`View <example-dataframe-xs-55>`
   * - ``DataFrame xs(const std::string& key, const std::string& axis, std::optional<int> level = std::nullopt, bool drop_level = true) const``
     - DataFrame
     - pd_dataframe.h:4315
     - :ref:`View <example-dataframe-xs-56>`
   * - ``DataFrame xs(const std::vector<std::string>& keys, int axis = 0, const std::vector<size_t>& levels = {}, bool drop_level = true) const``
     - DataFrame
     - pd_dataframe.h:4347
     - :ref:`View <example-dataframe-xs-57>`
   * - ``DataFrame xs_col(const std::string& key, bool drop_level) const``
     - DataFrame
     - pd_dataframe.h:4444
     - 
   * - ``DataFrame xs_cols_multi(const std::vector<std::string>& keys, const std::vector<size_t>& levels, bool drop_level) const``
     - DataFrame
     - pd_dataframe.h:4550
     - 
   * - ``DataFrame xs_level(const std::string& key, const std::string& level_name, bool drop_level = true) const``
     - DataFrame
     - pd_dataframe.h:4367
     - :ref:`View <example-dataframe-xs_level-58>`
   * - ``DataFrame xs_row(const std::string& key, bool drop_level) const``
     - DataFrame
     - pd_dataframe.h:4392
     - 
   * - ``DataFrame xs_rows_multi(const std::vector<std::string>& keys, const std::vector<size_t>& levels, bool drop_level) const``
     - DataFrame
     - pd_dataframe.h:4492
     - 

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

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

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``DataFrame assign(const std::string& col_name, const std::vector<T>& data) const``
     - DataFrame
     - pd_dataframe.h:10259
     - :ref:`View <example-dataframe-assign-59>`
   * - ``DataFrame assign(const std::string& col_name, const Series<numpy::float64>& s) const``
     - DataFrame
     - pd_dataframe.h:10300
     - :ref:`View <example-dataframe-assign-60>`
   * - ``DataFrame assign(const std::string& col_name, const Series<std::string>& s) const``
     - DataFrame
     - pd_dataframe.h:10322
     - :ref:`View <example-dataframe-assign-61>`
   * - ``DataFrame drop(const std::vector<std::string>& labels, int axis = 0, const std::vector<std::string>& index = {}, const std::vector<std::string>& columns = {}, std::optional<int> level = std::nullopt, bool inplace = false, const std::string& errors = "raise") const``
     - DataFrame
     - pd_dataframe.h:7177
     - :ref:`View <example-dataframe-drop-62>`
   * - ``DataFrame drop_duplicates(const std::vector<std::string>& subset = {}, const std::string& keep = "first", bool inplace = false, bool ignore_index = false) const``
     - DataFrame
     - pd_dataframe.h:10113
     - :ref:`View <example-dataframe-drop_duplicates-63>`
   * - ``void drop_inplace(const std::vector<std::string>& labels, int axis = 0)``
     - void
     - pd_dataframe.h:7243
     - 
   * - ``static std::string drop_level_from_label(const std::string& label, size_t level)``
     - static std::string
     - pd_dataframe.h:15555
     - 
   * - ``static void drop_values_column_level(DataFrame& result, const std::vector<std::string>& columns)``
     - static void
     - pd_dataframe.h:16405
     - 
   * - ``drop_values_column_level(result, columns)``
     - 
     - pd_dataframe.h:16470
     - 
   * - ``drop_values_column_level(result, columns)``
     - 
     - pd_dataframe.h:16957
     - 
   * - ``drop_values_column_level(result, std::vector<std::string>{columns})``
     - 
     - pd_dataframe.h:17001
     - 
   * - ``DataFrame droplevel(int level, int axis = 0) const``
     - DataFrame
     - pd_dataframe.h:15296
     - :ref:`View <example-dataframe-droplevel-64>`
   * - ``DataFrame droplevel(int level, const std::string& axis) const``
     - DataFrame
     - pd_dataframe.h:15313
     - :ref:`View <example-dataframe-droplevel-65>`
   * - ``DataFrame droplevel(const std::string& level_name, int axis = 0) const``
     - DataFrame
     - pd_dataframe.h:15335
     - :ref:`View <example-dataframe-droplevel-66>`
   * - ``DataFrame droplevel(const std::vector<int>& levels, int axis = 0) const``
     - DataFrame
     - pd_dataframe.h:15365
     - :ref:`View <example-dataframe-droplevel-67>`
   * - ``DataFrame droplevel_columns(int level) const``
     - DataFrame
     - pd_dataframe.h:15499
     - 
   * - ``DataFrame droplevel_index(int level) const``
     - DataFrame
     - pd_dataframe.h:15388
     - 
   * - ``DataFrame dropna(const std::string& how, int axis = 0, const std::vector<std::string>& subset = {}, std::optional<int> thresh = std::nullopt, bool inplace = false, bool ignore_index = false) const``
     - DataFrame
     - pd_dataframe.h:7518
     - :ref:`View <example-dataframe-dropna-68>`
   * - ``DataFrame dropna(int axis = 0, const std::string& how = "any", std::optional<int> thresh = std::nullopt, const std::vector<std::string>& subset = {}, bool inplace = false, bool ignore_index = false) const``
     - DataFrame
     - pd_dataframe.h:7525
     - :ref:`View <example-dataframe-dropna-69>`
   * - ``void insert(size_t loc, const std::string& column, std::unique_ptr<NDFrameBase> value, bool allow_duplicates = false)``
     - void
     - pd_dataframe.h:6806
     - :ref:`View <example-dataframe-insert-70>`
   * - ``insert(ncols(), name, std::move(s))``
     - 
     - pd_dataframe.h:6874
     - :ref:`View <example-dataframe-insert-71>`
   * - ``insert(ncols(), name, std::make_unique<Series<T>>(data, name))``
     - 
     - pd_dataframe.h:6877
     - :ref:`View <example-dataframe-insert-72>`
   * - ``insert(ncols(), name, std::move(new_col))``
     - 
     - pd_dataframe.h:6906
     - :ref:`View <example-dataframe-insert-73>`
   * - ``insert(ncols(), name, std::move(new_col))``
     - 
     - pd_dataframe.h:6942
     - :ref:`View <example-dataframe-insert-74>`
   * - ``insert(ncols(), name, std::move(new_col))``
     - 
     - pd_dataframe.h:6965
     - :ref:`View <example-dataframe-insert-75>`
   * - ``insert(ncols(), name, std::move(s))``
     - 
     - pd_dataframe.h:7006
     - :ref:`View <example-dataframe-insert-76>`
   * - ``insert(ncols(), name, std::move(s))``
     - 
     - pd_dataframe.h:7026
     - :ref:`View <example-dataframe-insert-77>`
   * - ``insert(ncols(), name, std::move(s))``
     - 
     - pd_dataframe.h:7039
     - :ref:`View <example-dataframe-insert-78>`
   * - ``DataFrame reindex(const std::vector<std::string>& labels = {}, const std::vector<std::string>& index = {}, const std::vector<std::string>& columns = {}, int axis = 0, const std::string& method = "", bool copy = true, std::optional<int> level = std::nullopt, double fill_value = std::nan(""), std::optional<int> limit = std::nullopt, std::optional<double> tolerance = std::nullopt, const std::optional<std::string>& str_fill = std::nullopt) const``
     - DataFrame
     - pd_dataframe.h:5422
     - :ref:`View <example-dataframe-reindex-79>`
   * - ``DataFrame reindex(const std::vector<std::string>& labels, int axis, double fill_value = std::nan(""), const std::optional<std::string>& str_fill = std::nullopt) const``
     - DataFrame
     - pd_dataframe.h:6475
     - :ref:`View <example-dataframe-reindex-80>`
   * - ``DataFrame reindex(const std::vector<std::string>& new_labels, pandas::detail::FillKind fill_kind, double numeric_fill = std::numeric_limits<double>::quiet_NaN(), const std::string& string_fill = "") const``
     - DataFrame
     - pd_dataframe.h:6486
     - :ref:`View <example-dataframe-reindex-81>`
   * - ``DataFrame reindex(const std::vector<std::string>& labels, const std::vector<std::string>& index, int axis, double fill_value) const``
     - DataFrame
     - pd_dataframe.h:6503
     - :ref:`View <example-dataframe-reindex-82>`
   * - ``DataFrame reindex(const std::vector<std::int64_t>& int_labels, int axis = 0, double fill_value = std::nan("")) const``
     - DataFrame
     - pd_dataframe.h:6513
     - :ref:`View <example-dataframe-reindex-83>`
   * - ``DataFrame reindex_by_indexer( const numpy::NDArray<numpy::int64>& indexer, const Index<std::string>& new_index, double fill_value) const``
     - DataFrame
     - pd_dataframe.h:27072
     - 
   * - ``DataFrame reindex_impl(const std::vector<std::string>& labels, int axis, double fill_value, const std::optional<std::string>& str_fill = std::nullopt, const std::optional<FillSpec>& explicit_spec = std::nullopt, const std::string& method = "", std::optional<int> limit = std::nullopt, std::optional<double> tolerance = std::nullopt) const``
     - DataFrame
     - pd_dataframe.h:5480
     - 
   * - ``DataFrame reindex_like(const DataFrame& other, const std::string& method = "", bool copy = true, std::optional<int> limit = std::nullopt, std::optional<double> tolerance = std::nullopt) const``
     - DataFrame
     - pd_dataframe.h:6769
     - :ref:`View <example-dataframe-reindex_like-84>`
   * - ``std::unique_ptr<NDFrameBase> reindex_with_indexer(const numpy::NDArray<numpy::int64>& indexer) const override``
     - std::unique_ptr<NDFrameBase>
     - pd_dataframe.h:27156
     - :ref:`View <example-dataframe-reindex_with_indexer-85>`
   * - ``DataFrame reindex_with_spec(const std::vector<std::string>& labels, int axis, const FillSpec& spec, const std::string& method = "", std::optional<int> limit = std::nullopt, std::optional<double> tolerance = std::nullopt) const``
     - DataFrame
     - pd_dataframe.h:6531
     - :ref:`View <example-dataframe-reindex_with_spec-86>`
   * - ``DataFrame rename(const std::map<std::string, std::string>& mapper = {}, const std::map<std::string, std::string>& index = {}, const std::map<std::string, std::string>& columns = {}, int axis = 0, bool copy = true, bool inplace = false, std::optional<int> level = std::nullopt, const std::string& errors = "ignore") const``
     - DataFrame
     - pd_dataframe.h:5336
     - :ref:`View <example-dataframe-rename-87>`
   * - ``DataFrame rename(const std::map<std::string, std::string>& mapper, int axis) const``
     - DataFrame
     - pd_dataframe.h:5385
     - :ref:`View <example-dataframe-rename-88>`
   * - ``DataFrame rename_axis(const std::string& mapper = "", const std::string& index = "", const std::string& columns = "", int axis = 0, bool copy = true, bool inplace = false) const``
     - DataFrame
     - pd_dataframe.h:6604
     - :ref:`View <example-dataframe-rename_axis-89>`
   * - ``DataFrame rename_axis(const std::string& mapper, int axis) const``
     - DataFrame
     - pd_dataframe.h:6642
     - :ref:`View <example-dataframe-rename_axis-90>`
   * - ``DataFrame rename_columns(const std::map<std::string, std::string>& mapper) const``
     - DataFrame
     - pd_dataframe.h:5278
     - :ref:`View <example-dataframe-rename_columns-91>`
   * - ``Result rename_result(const RenameSpec& spec, int axis, bool inplace, bool errors_raise)``
     - Result
     - pd_dataframe.h:5403
     - :ref:`View <example-dataframe-rename_result-92>`
   * - ``DataFrame reorder_levels(const std::vector<int>& order, int axis = 0) const``
     - DataFrame
     - pd_dataframe.h:15657
     - :ref:`View <example-dataframe-reorder_levels-93>`
   * - ``DataFrame reorder_levels(const std::vector<int>& order, const std::string& axis) const``
     - DataFrame
     - pd_dataframe.h:15708
     - :ref:`View <example-dataframe-reorder_levels-94>`
   * - ``DataFrame reorder_levels(const std::vector<std::string>& order, int axis = 0) const``
     - DataFrame
     - pd_dataframe.h:15731
     - :ref:`View <example-dataframe-reorder_levels-95>`
   * - ``DataFrame reorder_levels(std::initializer_list<const char\*> order, int axis = 0) const``
     - DataFrame
     - pd_dataframe.h:15766
     - :ref:`View <example-dataframe-reorder_levels-96>`
   * - ``DataFrame reorder_levels_columns(const std::vector<size_t>& order) const``
     - DataFrame
     - pd_dataframe.h:15986
     - 
   * - ``static std::string reorder_levels_in_label(const std::string& label, const std::vector<size_t>& order)``
     - static std::string
     - pd_dataframe.h:15590
     - 
   * - ``DataFrame reorder_levels_index(const std::vector<size_t>& order) const``
     - DataFrame
     - pd_dataframe.h:15932
     - 
   * - ``DataFrame replace(double to_replace, double value, bool inplace = false, std::optional<int> limit = std::nullopt, bool regex = false, const std::string& method = "") const``
     - DataFrame
     - pd_dataframe.h:9027
     - :ref:`View <example-dataframe-replace-97>`
   * - ``DataFrame replace(const std::string& to_replace, const std::string& value, bool inplace = false, std::optional<int> limit = std::nullopt, bool regex = false, const std::string& method = "") const``
     - DataFrame
     - pd_dataframe.h:9050
     - :ref:`View <example-dataframe-replace-98>`
   * - ``DataFrame replace(const std::map<std::string,std::string>& mapping, bool inplace = false) const``
     - DataFrame
     - pd_dataframe.h:9075
     - :ref:`View <example-dataframe-replace-99>`
   * - ``DataFrame replace(std::int64_t to_replace, std::int64_t value) const``
     - DataFrame
     - pd_dataframe.h:9095
     - :ref:`View <example-dataframe-replace-100>`
   * - ``DataFrame replace(int old_val, int new_val) const``
     - DataFrame
     - pd_dataframe.h:9100
     - :ref:`View <example-dataframe-replace-101>`
   * - ``void replace_column_str(const std::string& name, const std::vector<std::string>& data)``
     - void
     - pd_dataframe.h:7092
     - 
   * - ``void replace_value(double to_replace, double value) override``
     - void
     - pd_dataframe.h:8423
     - 
   * - ``DataFrame& reset_index(bool drop = false, std::optional<int> level = std::nullopt, bool inplace = false, std::optional<int> col_level = std::nullopt, const std::string& col_fill = "", bool allow_duplicates = false, const std::optional<std::vector<std::string>>& names = std::nullopt)``
     - DataFrame&
     - pd_dataframe.h:5027
     - :ref:`View <example-dataframe-reset_index-102>`
   * - ``DataFrame set_axis(const std::vector<std::string>& labels, int axis = 0, bool copy = true) const``
     - DataFrame
     - pd_dataframe.h:6559
     - :ref:`View <example-dataframe-set_axis-103>`
   * - ``void set_index(std::unique_ptr<IndexBase> new_index) override``
     - void
     - pd_dataframe.h:4611
     - :ref:`View <example-dataframe-set_index-104>`
   * - ``void set_index(const std::shared_ptr<IdxT>& new_index)``
     - void
     - pd_dataframe.h:4630
     - :ref:`View <example-dataframe-set_index-105>`
   * - ``DataFrame set_index(std::initializer_list<const char\*> keys, bool drop = true, bool append = false, bool verify_integrity = false) const``
     - DataFrame
     - pd_dataframe.h:4640
     - :ref:`View <example-dataframe-set_index-106>`
   * - ``DataFrame set_index(const std::vector<std::string>& keys, bool drop = true, bool append = false, bool verify_integrity = false) const``
     - DataFrame
     - pd_dataframe.h:4652
     - :ref:`View <example-dataframe-set_index-107>`
   * - ``DataFrame set_index(const std::string& key, bool drop = true, bool append = false, bool verify_integrity = false) const``
     - DataFrame
     - pd_dataframe.h:4663
     - :ref:`View <example-dataframe-set_index-108>`
   * - ``void set_index(const IdxT& idx)``
     - void
     - pd_dataframe.h:4682
     - :ref:`View <example-dataframe-set_index-109>`
   * - ``set_index(idx.clone())``
     - 
     - pd_dataframe.h:4684
     - :ref:`View <example-dataframe-set_index-110>`
   * - ``void set_index(const MultiIndex& mi)``
     - void
     - pd_dataframe.h:4690
     - :ref:`View <example-dataframe-set_index-111>`
   * - ``void set_index(MultiIndex&& mi)``
     - void
     - pd_dataframe.h:4693
     - :ref:`View <example-dataframe-set_index-112>`
   * - ``void set_index(std::initializer_list<std::type_identity_t<T>> values)``
     - void
     - pd_dataframe.h:4713
     - :ref:`View <example-dataframe-set_index-113>`
   * - ``set_index(std::make_unique<Index<T>>(std::move(vec)))``
     - 
     - pd_dataframe.h:4715
     - :ref:`View <example-dataframe-set_index-114>`
   * - ``void set_index(const std::vector<std::type_identity_t<T>>& values)``
     - void
     - pd_dataframe.h:4720
     - :ref:`View <example-dataframe-set_index-115>`
   * - ``set_index(std::make_unique<Index<T>>(values))``
     - 
     - pd_dataframe.h:4721
     - :ref:`View <example-dataframe-set_index-116>`
   * - ``void set_index(std::vector<std::type_identity_t<T>>&& values)``
     - void
     - pd_dataframe.h:4726
     - :ref:`View <example-dataframe-set_index-117>`
   * - ``set_index(std::make_unique<Index<T>>(std::move(values)))``
     - 
     - pd_dataframe.h:4727
     - :ref:`View <example-dataframe-set_index-118>`
   * - ``set_index(std::make_unique<Index<std::string>>(vec))``
     - 
     - pd_dataframe.h:4740
     - :ref:`View <example-dataframe-set_index-119>`
   * - ``set_index(std::make_unique<Index<numpy::int64>>(vec))``
     - 
     - pd_dataframe.h:4745
     - :ref:`View <example-dataframe-set_index-120>`
   * - ``set_index(std::make_unique<Index<numpy::int64>>(vec))``
     - 
     - pd_dataframe.h:4752
     - :ref:`View <example-dataframe-set_index-121>`
   * - ``set_index(std::make_unique<Index<numpy::int64>>(vec))``
     - 
     - pd_dataframe.h:4762
     - :ref:`View <example-dataframe-set_index-122>`
   * - ``set_index(std::make_unique<Index<std::string>>(values))``
     - 
     - pd_dataframe.h:4766
     - :ref:`View <example-dataframe-set_index-123>`
   * - ``set_index(std::make_unique<DatetimeIndex>(std::move(dti)))``
     - 
     - pd_dataframe.h:4842
     - :ref:`View <example-dataframe-set_index-124>`
   * - ``set_index(std::move(idx))``
     - 
     - pd_dataframe.h:4890
     - :ref:`View <example-dataframe-set_index-125>`
   * - ``DataFrame set_index_col(const std::string& col_name, bool drop = true, bool append = false, bool verify_integrity = false) const``
     - DataFrame
     - pd_dataframe.h:4901
     - :ref:`View <example-dataframe-set_index_col-126>`
   * - ``DataFrame set_index_col(const std::vector<std::string>& keys, bool drop = true, bool append = false, bool verify_integrity = false) const``
     - DataFrame
     - pd_dataframe.h:4948
     - :ref:`View <example-dataframe-set_index_col-127>`
   * - ``DataFrame set_index_col(std::initializer_list<const char\*> keys, bool drop = true, bool append = false, bool verify_integrity = false) const``
     - DataFrame
     - pd_dataframe.h:5007
     - :ref:`View <example-dataframe-set_index_col-128>`
   * - ``void set_index_from_column(const std::string& name, std::initializer_list<T> values)``
     - void
     - pd_dataframe.h:4884
     - :ref:`View <example-dataframe-set_index_from_column-129>`
   * - ``void set_index_from_list(std::initializer_list<const char\*> values)``
     - void
     - pd_dataframe.h:4738
     - :ref:`View <example-dataframe-set_index_from_list-130>`
   * - ``void set_index_from_list(std::initializer_list<int64_t> values)``
     - void
     - pd_dataframe.h:4743
     - :ref:`View <example-dataframe-set_index_from_list-131>`
   * - ``void set_index_from_list(std::initializer_list<int> values)``
     - void
     - pd_dataframe.h:4748
     - :ref:`View <example-dataframe-set_index_from_list-132>`
   * - ``void set_index_from_list(std::initializer_list<long> values)``
     - void
     - pd_dataframe.h:4758
     - :ref:`View <example-dataframe-set_index_from_list-133>`
   * - ``void set_index_from_list(const std::vector<std::string>& values)``
     - void
     - pd_dataframe.h:4765
     - :ref:`View <example-dataframe-set_index_from_list-134>`
   * - ``set_index_from_list(values)``
     - 
     - pd_dataframe.h:4771
     - :ref:`View <example-dataframe-set_index_from_list-135>`
   * - ``set_index_from_list(values)``
     - 
     - pd_dataframe.h:4774
     - :ref:`View <example-dataframe-set_index_from_list-136>`
   * - ``set_index_from_list(values)``
     - 
     - pd_dataframe.h:4777
     - :ref:`View <example-dataframe-set_index_from_list-137>`
   * - ``set_index_from_list(values)``
     - 
     - pd_dataframe.h:4780
     - :ref:`View <example-dataframe-set_index_from_list-138>`
   * - ``set_index_from_list(values)``
     - 
     - pd_dataframe.h:4783
     - :ref:`View <example-dataframe-set_index_from_list-139>`
   * - ``void set_index_from_strings(std::initializer_list<const char\*> values)``
     - void
     - pd_dataframe.h:4779
     - :ref:`View <example-dataframe-set_index_from_strings-140>`
   * - ``void set_index_from_strings(const std::vector<std::string>& values)``
     - void
     - pd_dataframe.h:4782
     - :ref:`View <example-dataframe-set_index_from_strings-141>`
   * - ``void set_index_name(const std::string& name)``
     - void
     - pd_dataframe.h:4789
     - :ref:`View <example-dataframe-set_index_name-142>`
   * - ``set_index_name(name)``
     - 
     - pd_dataframe.h:4798
     - :ref:`View <example-dataframe-set_index_name-143>`
   * - ``DataFrame swaplevel(int i = -2, int j = -1, int axis = 0) const``
     - DataFrame
     - pd_dataframe.h:15815
     - :ref:`View <example-dataframe-swaplevel-144>`
   * - ``DataFrame swaplevel(int i, int j, const std::string& axis) const``
     - DataFrame
     - pd_dataframe.h:15863
     - :ref:`View <example-dataframe-swaplevel-145>`
   * - ``DataFrame swaplevel(const std::string& i, const std::string& j, int axis = 0) const``
     - DataFrame
     - pd_dataframe.h:15886
     - :ref:`View <example-dataframe-swaplevel-146>`
   * - ``void update(const DataFrame& other, bool overwrite = true, const std::string& filter_func = "", const std::string& join = "left", const std::string& errors = "raise")``
     - void
     - pd_dataframe.h:26357
     - :ref:`View <example-dataframe-update-147>`

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

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

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``DataFrame backfill(int axis = 0, std::optional<int> limit = std::nullopt, bool inplace = false, const std::string& downcast = "") const``
     - DataFrame
     - pd_dataframe.h:13146
     - :ref:`View <example-dataframe-backfill-148>`
   * - ``DataFrame bfill(int axis = 0, std::optional<int> limit = std::nullopt, bool inplace = false, const std::string& limit_area = "", const std::string& downcast = "") const``
     - DataFrame
     - pd_dataframe.h:7738
     - :ref:`View <example-dataframe-bfill-149>`
   * - ``DataFrame ffill(int axis = 0, std::optional<int> limit = std::nullopt, bool inplace = false, const std::string& limit_area = "", const std::string& downcast = "") const``
     - DataFrame
     - pd_dataframe.h:7644
     - :ref:`View <example-dataframe-ffill-150>`
   * - ``DataFrame fillna(double value, const std::string& method = "", int axis = 0, bool inplace = false, std::optional<int> limit = std::nullopt, const std::string& downcast = "") const``
     - DataFrame
     - pd_dataframe.h:8771
     - :ref:`View <example-dataframe-fillna-151>`
   * - ``DataFrame fillna(const std::string& value) const``
     - DataFrame
     - pd_dataframe.h:8819
     - :ref:`View <example-dataframe-fillna-152>`
   * - ``DataFrame fillna(const std::map<std::string, double>& values, const std::string& method = "", int axis = 0, bool inplace = false, std::optional<int> limit = std::nullopt, const std::string& downcast = "") const``
     - DataFrame
     - pd_dataframe.h:8828
     - :ref:`View <example-dataframe-fillna-153>`
   * - ``DataFrame fillna(const Series<numpy::float64>& values, const std::string& method = "", int axis = 0, bool inplace = false, std::optional<int> limit = std::nullopt, const std::string& downcast = "") const``
     - DataFrame
     - pd_dataframe.h:8857
     - :ref:`View <example-dataframe-fillna-154>`
   * - ``DataFrame fillna(const DataFrame& fill_df, int axis = 0, std::optional<int> limit = std::nullopt) const``
     - DataFrame
     - pd_dataframe.h:8877
     - :ref:`View <example-dataframe-fillna-155>`
   * - ``void fillna_double(double value) override``
     - void
     - pd_dataframe.h:8413
     - 
   * - ``DataFrame interpolate(const std::string& method = "linear", int axis = 0, std::optional<int> limit = std::nullopt, const std::string& limit_direction = "forward", bool inplace = false, const std::string& limit_area = "", const std::string& downcast = "") const``
     - DataFrame
     - pd_dataframe.h:7835
     - :ref:`View <example-dataframe-interpolate-156>`
   * - ``interpolate_column(result, c, method, limit, limit_direction, limit_area)``
     - 
     - pd_dataframe.h:7869
     - 
   * - ``void interpolate_column(DataFrame& result, size_t col_idx, const std::string& method, std::optional<int> limit, const std::string& limit_direction, const std::string& limit_area = "") const``
     - void
     - pd_dataframe.h:7886
     - 
   * - ``interpolate_row(result, r, method, limit, limit_direction)``
     - 
     - pd_dataframe.h:7874
     - 
   * - ``void interpolate_row(DataFrame& result, size_t row_idx, const std::string& method, std::optional<int> limit, const std::string& limit_direction) const``
     - void
     - pd_dataframe.h:8293
     - 
   * - ``numpy::NDArray<numpy::bool_> isna() const``
     - numpy::NDArray<numpy::bool_>
     - pd_dataframe.h:8508
     - :ref:`View <example-dataframe-isna-157>`
   * - ``DataFrame isna_frame() const``
     - DataFrame
     - pd_dataframe.h:8538
     - :ref:`View <example-dataframe-isna_frame-158>`
   * - ``numpy::NDArray<numpy::bool_> isnull() const``
     - numpy::NDArray<numpy::bool_>
     - pd_dataframe.h:13126
     - :ref:`View <example-dataframe-isnull-159>`
   * - ``DataFrame isnull_frame() const``
     - DataFrame
     - pd_dataframe.h:8591
     - :ref:`View <example-dataframe-isnull_frame-160>`
   * - ``numpy::NDArray<numpy::bool_> notna() const``
     - numpy::NDArray<numpy::bool_>
     - pd_dataframe.h:8523
     - :ref:`View <example-dataframe-notna-161>`
   * - ``DataFrame notna_frame() const``
     - DataFrame
     - pd_dataframe.h:8565
     - :ref:`View <example-dataframe-notna_frame-162>`
   * - ``numpy::NDArray<numpy::bool_> notnull() const``
     - numpy::NDArray<numpy::bool_>
     - pd_dataframe.h:13134
     - :ref:`View <example-dataframe-notnull-163>`
   * - ``DataFrame notnull_frame() const``
     - DataFrame
     - pd_dataframe.h:8598
     - :ref:`View <example-dataframe-notnull_frame-164>`
   * - ``DataFrame pad(int axis = 0, std::optional<int> limit = std::nullopt, bool inplace = false, const std::string& downcast = "") const``
     - DataFrame
     - pd_dataframe.h:13159
     - :ref:`View <example-dataframe-pad-165>`

Statistics
----------

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

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``size_t count() const override``
     - size_t
     - pd_dataframe.h:7458
     - :ref:`View <example-dataframe-count-166>`
   * - ``Series<numpy::int64> count(int axis, bool numeric_only = false) const``
     - Series<numpy::int64>
     - pd_dataframe.h:7472
     - :ref:`View <example-dataframe-count-167>`
   * - ``Series<numpy::int64> count_cols() const``
     - Series<numpy::int64>
     - pd_dataframe.h:10719
     - :ref:`View <example-dataframe-count_cols-168>`
   * - ``DataFrame cummax(int axis = 0, bool skipna = true) const``
     - DataFrame
     - pd_dataframe.h:20426
     - :ref:`View <example-dataframe-cummax-169>`
   * - ``DataFrame cummin(int axis = 0, bool skipna = true) const``
     - DataFrame
     - pd_dataframe.h:20311
     - :ref:`View <example-dataframe-cummin-170>`
   * - ``DataFrame cumprod(int axis = 0, bool skipna = true) const``
     - DataFrame
     - pd_dataframe.h:20214
     - :ref:`View <example-dataframe-cumprod-171>`
   * - ``DataFrame cumsum(int axis = 0, bool skipna = true) const``
     - DataFrame
     - pd_dataframe.h:20108
     - :ref:`View <example-dataframe-cumsum-172>`
   * - ``DataFrame describe(const std::vector<double>& percentiles = {0.25, 0.5, 0.75}) const``
     - DataFrame
     - pd_dataframe.h:11001
     - :ref:`View <example-dataframe-describe-173>`
   * - ``DataFrame describe_full(const std::vector<double>& percentiles = {0.25, 0.5, 0.75}, int include_mode = 0) const``
     - DataFrame
     - pd_dataframe.h:10868
     - :ref:`View <example-dataframe-describe_full-174>`
   * - ``Series<numpy::float64> kurt(int axis = 0, bool skipna = true, bool numeric_only = false) const``
     - Series<numpy::float64>
     - pd_dataframe.h:12411
     - :ref:`View <example-dataframe-kurt-175>`
   * - ``Series<numpy::float64> kurt_cols(bool skipna = true) const``
     - Series<numpy::float64>
     - pd_dataframe.h:11071
     - :ref:`View <example-dataframe-kurt_cols-176>`
   * - ``Series<numpy::float64> kurtosis(int axis = 0, bool skipna = true, bool numeric_only = false) const``
     - Series<numpy::float64>
     - pd_dataframe.h:12465
     - :ref:`View <example-dataframe-kurtosis-177>`
   * - ``Series<numpy::float64> max(int axis = 0, bool skipna = true, bool numeric_only = false) const``
     - Series<numpy::float64>
     - pd_dataframe.h:12250
     - :ref:`View <example-dataframe-max-178>`
   * - ``Series<numpy::float64> max_cols(bool skipna = true) const``
     - Series<numpy::float64>
     - pd_dataframe.h:10459
     - :ref:`View <example-dataframe-max_cols-179>`
   * - ``Series<numpy::float64> mean(int axis = 0, bool skipna = true, bool numeric_only = false) const``
     - Series<numpy::float64>
     - pd_dataframe.h:12011
     - :ref:`View <example-dataframe-mean-180>`
   * - ``Series<numpy::float64> mean_cols(bool skipna = true) const``
     - Series<numpy::float64>
     - pd_dataframe.h:10392
     - :ref:`View <example-dataframe-mean_cols-181>`
   * - ``Series<numpy::float64> median(int axis = 0, bool skipna = true, bool numeric_only = false) const``
     - Series<numpy::float64>
     - pd_dataframe.h:11174
     - :ref:`View <example-dataframe-median-182>`
   * - ``Series<numpy::float64> median_cols(bool skipna = true) const``
     - Series<numpy::float64>
     - pd_dataframe.h:11126
     - :ref:`View <example-dataframe-median_cols-183>`
   * - ``Series<numpy::float64> min(int axis = 0, bool skipna = true, bool numeric_only = false) const``
     - Series<numpy::float64>
     - pd_dataframe.h:12158
     - :ref:`View <example-dataframe-min-184>`
   * - ``Series<numpy::float64> min_cols(bool skipna = true) const``
     - Series<numpy::float64>
     - pd_dataframe.h:10430
     - :ref:`View <example-dataframe-min_cols-185>`
   * - ``DataFrame mode(int axis = 0, bool numeric_only = false, bool dropna = true) const``
     - DataFrame
     - pd_dataframe.h:11242
     - :ref:`View <example-dataframe-mode-186>`
   * - ``DataFrame mode_cols(bool numeric_only = false, bool dropna = true) const``
     - DataFrame
     - pd_dataframe.h:11261
     - 
   * - ``DataFrame mode_rows(bool numeric_only = false, bool dropna = true) const``
     - DataFrame
     - pd_dataframe.h:11406
     - 
   * - ``Series<numpy::int64> nunique(int axis = 0, bool dropna = true) const``
     - Series<numpy::int64>
     - pd_dataframe.h:13667
     - :ref:`View <example-dataframe-nunique-187>`
   * - ``Series<numpy::int64> nunique_cols(bool dropna = true) const``
     - Series<numpy::int64>
     - pd_dataframe.h:13622
     - :ref:`View <example-dataframe-nunique_cols-188>`
   * - ``Series<numpy::float64> prod(int axis = 0, bool skipna = true, bool numeric_only = false, int min_count = 0) const``
     - Series<numpy::float64>
     - pd_dataframe.h:11554
     - :ref:`View <example-dataframe-prod-189>`
   * - ``Series<numpy::float64> prod_cols(bool skipna = true) const``
     - Series<numpy::float64>
     - pd_dataframe.h:11507
     - :ref:`View <example-dataframe-prod_cols-190>`
   * - ``Series<numpy::float64> product(int axis = 0, bool skipna = true, bool numeric_only = false, int min_count = 0) const``
     - Series<numpy::float64>
     - pd_dataframe.h:12592
     - :ref:`View <example-dataframe-product-191>`
   * - ``Series<numpy::float64> quantile(double q = 0.5, int axis = 0, bool numeric_only = false, const std::string& interpolation = "linear", const std::string& method = "") const``
     - Series<numpy::float64>
     - pd_dataframe.h:12478
     - :ref:`View <example-dataframe-quantile-192>`
   * - ``Series<numpy::float64> quantile_cols(double q, const std::string& interpolation = "linear") const``
     - Series<numpy::float64>
     - pd_dataframe.h:13949
     - :ref:`View <example-dataframe-quantile_cols-193>`
   * - ``Series<numpy::float64> sem(int axis = 0, bool skipna = true, int ddof = 1, bool numeric_only = false) const``
     - Series<numpy::float64>
     - pd_dataframe.h:12312
     - :ref:`View <example-dataframe-sem-194>`
   * - ``Series<numpy::float64> sem_cols(bool skipna = true, int ddof = 1) const``
     - Series<numpy::float64>
     - pd_dataframe.h:11008
     - 
   * - ``Series<numpy::float64> skew(int axis = 0, bool skipna = true, bool numeric_only = false) const``
     - Series<numpy::float64>
     - pd_dataframe.h:12358
     - :ref:`View <example-dataframe-skew-195>`
   * - ``Series<numpy::float64> skew_cols(bool skipna = true) const``
     - Series<numpy::float64>
     - pd_dataframe.h:11024
     - :ref:`View <example-dataframe-skew_cols-196>`
   * - ``Series<numpy::float64> std(int axis = 0, bool skipna = true, int ddof = 1, bool numeric_only = false) const``
     - Series<numpy::float64>
     - pd_dataframe.h:12065
     - :ref:`View <example-dataframe-std-197>`
   * - ``pandas::Series<numpy::timedelta64> std_(td_vals)``
     - pandas::Series<numpy::timedelta64>
     - pd_dataframe.h:21232
     - :ref:`View <example-dataframe-std_-198>`
   * - ``pandas::Series<numpy::timedelta64> std_(td_vals)``
     - pandas::Series<numpy::timedelta64>
     - pd_dataframe.h:21597
     - :ref:`View <example-dataframe-std_-199>`
   * - ``Series<numpy::float64> std_cols(bool skipna = true, int ddof = 1) const``
     - Series<numpy::float64>
     - pd_dataframe.h:10660
     - :ref:`View <example-dataframe-std_cols-200>`
   * - ``Series<numpy::float64> sum(int axis = 0, bool skipna = true, bool numeric_only = false, int min_count = 0) const``
     - Series<numpy::float64>
     - pd_dataframe.h:11822
     - :ref:`View <example-dataframe-sum-201>`
   * - ``Series<numpy::float64> sum_cols(bool skipna = true) const``
     - Series<numpy::float64>
     - pd_dataframe.h:10341
     - :ref:`View <example-dataframe-sum_cols-202>`
   * - ``std::variant<Series<numpy::int64>, Series<numpy::float64>> value_counts( const std::vector<std::string>& subset = {}, bool normalize = false, bool sort = true, bool ascending = false, bool dropna = true) const``
     - std::variant<Series<numpy::int64>, Series<numpy::float64>>
     - pd_dataframe.h:13754
     - :ref:`View <example-dataframe-value_counts-203>`
   * - ``Series<numpy::float64> var(int axis = 0, bool skipna = true, int ddof = 1, bool numeric_only = false) const``
     - Series<numpy::float64>
     - pd_dataframe.h:12118
     - :ref:`View <example-dataframe-var-204>`
   * - ``Series<numpy::float64> var_cols(bool skipna = true, int ddof = 1) const``
     - Series<numpy::float64>
     - pd_dataframe.h:10703
     - 

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

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

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``DataFrame agg(const std::string& func, int axis = 0) const``
     - DataFrame
     - pd_dataframe.h:23703
     - :ref:`View <example-dataframe-agg-205>`
   * - ``DataFrame agg(const std::vector<std::string>& funcs, int axis = 0) const``
     - DataFrame
     - pd_dataframe.h:23742
     - :ref:`View <example-dataframe-agg-206>`
   * - ``DataFrame agg(const std::map<std::string, std::string>& col_func_map, int axis = 0) const``
     - DataFrame
     - pd_dataframe.h:23795
     - :ref:`View <example-dataframe-agg-207>`
   * - ``DataFrame agg(const std::map<std::string, std::vector<std::string>>& col_funcs_map, int axis = 0) const``
     - DataFrame
     - pd_dataframe.h:23820
     - :ref:`View <example-dataframe-agg-208>`
   * - ``Series<numpy::float64> agg_to_series(const std::map<std::string, std::string>& col_func_map, int axis = 0) const``
     - Series<numpy::float64>
     - pd_dataframe.h:23874
     - :ref:`View <example-dataframe-agg_to_series-209>`
   * - ``Series<numpy::float64> agg_to_series(const std::string& func, int axis = 0) const``
     - Series<numpy::float64>
     - pd_dataframe.h:23893
     - :ref:`View <example-dataframe-agg_to_series-210>`
   * - ``DataFrame aggregate(const std::string& func, int axis = 0) const``
     - DataFrame
     - pd_dataframe.h:23776
     - :ref:`View <example-dataframe-aggregate-211>`
   * - ``DataFrame aggregate(const std::vector<std::string>& funcs, int axis = 0) const``
     - DataFrame
     - pd_dataframe.h:23785
     - :ref:`View <example-dataframe-aggregate-212>`
   * - ``DataFrame aggregate(const std::map<std::string, std::string>& col_func_map, int axis = 0) const``
     - DataFrame
     - pd_dataframe.h:23861
     - :ref:`View <example-dataframe-aggregate-213>`
   * - ``DataFrame aggregate(const std::map<std::string, std::vector<std::string>>& col_funcs_map, int axis = 0) const``
     - DataFrame
     - pd_dataframe.h:23864
     - :ref:`View <example-dataframe-aggregate-214>`
   * - ``DataFrame apply(Func&& func, int axis = 0) const``
     - DataFrame
     - pd_dataframe.h:20839
     - :ref:`View <example-dataframe-apply-215>`
   * - ``DataFrame apply(Func&& func, int axis = 0, bool raw = false, const std::string& result_type = "", const std::string& by_row = "compat", const std::string& engine = "", const std::map<std::string, std::string>& engine_kwargs = {}) const``
     - DataFrame
     - pd_dataframe.h:20879
     - :ref:`View <example-dataframe-apply-216>`
   * - ``PANDASCORE_API Result apply( const FuncArg& func, int axis = 0, const std::function<ApplyCellResult(const ApplyRowInput&)>& row_cb = {}, const std::function<ApplyCellResult(const ApplyColInput&)>& col_cb = {} ) const``
     - PANDASCORE_API Result
     - pd_dataframe.h:21738
     - :ref:`View <example-dataframe-apply-217>`
   * - ``static std::string apply_bare_double_result_dtype_(const std::string& rolled)``
     - static std::string
     - pd_dataframe.h:20709
     - 
   * - ``PANDASCORE_API ApplyResult apply_callable( int axis, const std::function<ApplyCellResult(const ApplyRowInput&)>& row_cb, const std::function<ApplyCellResult(const ApplyColInput&)>& col_cb, const ApplyCallableOptions& opts = ApplyCallableOptions{} ) const``
     - PANDASCORE_API ApplyResult
     - pd_dataframe.h:21659
     - :ref:`View <example-dataframe-apply_callable-218>`
   * - ``apply_category_meta(result, col, spec)``
     - 
     - pd_dataframe.h:22263
     - 
   * - ``apply_category_meta(result, col, sub)``
     - 
     - pd_dataframe.h:22317
     - 
   * - ``std::vector<std::complex<double>> apply_column_as_complex_(size_t c) const``
     - std::vector<std::complex<double>>
     - pd_dataframe.h:20773
     - 
   * - ``std::vector<double> apply_column_as_doubles_(size_t c) const``
     - std::vector<double>
     - pd_dataframe.h:20744
     - 
   * - ``DataFrame apply_downcast(const std::string& downcast) const``
     - DataFrame
     - pd_dataframe.h:22510
     - 
   * - ``static std::string apply_family_target_dtype_(const std::string& src_dtype)``
     - static std::string
     - pd_dataframe.h:20657
     - 
   * - ``apply_family_target_dtype_(columns_[c]->dtype_name()))``
     - 
     - pd_dataframe.h:21029
     - 
   * - ``std::vector<double> apply_named_transform_(const std::string& func_name, const std::vector<double>& values) const``
     - std::vector<double>
     - pd_dataframe.h:23117
     - 
   * - ``PANDASCORE_API DataFrame apply_resolved_typed( const std::function<ApplyCellResult(const pandas::Series<numpy::float64>&)>& cb, pandas::ApplyResultInference::ScalarKindHistogram& hist, int axis = 0 ) const``
     - PANDASCORE_API DataFrame
     - pd_dataframe.h:21701
     - :ref:`View <example-dataframe-apply_resolved_typed-219>`
   * - ``DataFrame apply_with_args(Func&& func, int axis, bool raw, const std::string& result_type, std::tuple<Args...> args, const std::string& by_row = "compat") const``
     - DataFrame
     - pd_dataframe.h:21746
     - :ref:`View <example-dataframe-apply_with_args-220>`
   * - ``DataFrame applymap(Func&& func, const std::string& na_action = "") const``
     - DataFrame
     - pd_dataframe.h:21859
     - :ref:`View <example-dataframe-applymap-221>`
   * - ``DataFrameEWM ewm(std::optional<double> com = std::nullopt, std::optional<double> span = std::nullopt, std::optional<double> halflife = std::nullopt, std::optional<double> alpha = std::nullopt, int min_periods = 0, bool adjust = true, bool ignore_na = false, int axis = 0, const std::vector<double>& times = {}, const std::string& method = "single") const``
     - DataFrameEWM
     - pd_dataframe.h:13081
     - :ref:`View <example-dataframe-ewm-222>`
   * - ``DataFrameExpanding expanding(size_t min_periods = 1, int axis = 0, const std::string& method = "single") const``
     - DataFrameExpanding
     - pd_dataframe.h:13055
     - :ref:`View <example-dataframe-expanding-223>`
   * - ``DataFrameGroupBy groupby( std::initializer_list<const char\*> by_init, int axis = 0, std::optional<int> level = std::nullopt, bool as_index = true, bool sort = true, bool group_keys = true, bool observed = true, bool dropna = true) const``
     - DataFrameGroupBy
     - pd_dataframe.h:26598
     - :ref:`View <example-dataframe-groupby-224>`
   * - ``DataFrameGroupBy groupby(const std::string& by, int axis = 0, std::optional<int> level = std::nullopt, bool as_index = true, bool sort = true, bool group_keys = true, bool observed = true, bool dropna = true) const``
     - DataFrameGroupBy
     - pd_dataframe.h:26608
     - :ref:`View <example-dataframe-groupby-225>`
   * - ``DataFrameGroupBy groupby(const std::vector<std::string>& by, int axis = 0, std::optional<int> level = std::nullopt, bool as_index = true, bool sort = true, bool group_keys = true, bool observed = true, bool dropna = true) const``
     - DataFrameGroupBy
     - pd_dataframe.h:26629
     - :ref:`View <example-dataframe-groupby-226>`
   * - ``DataFrameGroupBy groupby( const Grouper& by, int axis = 0, bool as_index = true, bool sort = true, bool group_keys = true, std::optional<bool> observed = std::nullopt, bool dropna = true) const``
     - DataFrameGroupBy
     - pd_dataframe.h:26652
     - :ref:`View <example-dataframe-groupby-227>`
   * - ``DataFrameGroupBy groupby( const std::vector<Grouper>& by, int axis = 0, bool as_index = true, bool sort = true, bool group_keys = true, std::optional<bool> observed = std::nullopt, bool dropna = true) const``
     - DataFrameGroupBy
     - pd_dataframe.h:26672
     - :ref:`View <example-dataframe-groupby-228>`
   * - ``DataFrameGroupBy groupby( std::initializer_list<std::variant<Grouper, std::string>> by_init, int axis = 0, bool as_index = true, bool sort = true, bool group_keys = true, std::optional<bool> observed = std::nullopt, bool dropna = true) const``
     - DataFrameGroupBy
     - pd_dataframe.h:26685
     - :ref:`View <example-dataframe-groupby-229>`
   * - ``DataFrame map(Func&& func, const std::string& na_action = "") const``
     - DataFrame
     - pd_dataframe.h:21888
     - :ref:`View <example-dataframe-map-230>`
   * - ``PANDASCORE_API DataFrame map_callable( const std::function<ApplyCellResult(const MapCellInput&)>& cell_cb, const std::string& na_action = "" ) const``
     - PANDASCORE_API DataFrame
     - pd_dataframe.h:21666
     - 
   * - ``PANDASCORE_API DataFrame map_callable_resolved( const std::function<ApplyCellResult(const pandas::MapCellInput&)>& cb, pandas::ApplyResultInference::ScalarKindHistogram& hist ) const``
     - PANDASCORE_API DataFrame
     - pd_dataframe.h:21707
     - :ref:`View <example-dataframe-map_callable_resolved-231>`
   * - ``auto pipe(Func&& func, Args&&... args) const``
     - auto
     - pd_dataframe.h:23921
     - :ref:`View <example-dataframe-pipe-232>`
   * - ``auto pipe(Func&& func, Args&&... args)``
     - auto
     - pd_dataframe.h:23930
     - :ref:`View <example-dataframe-pipe-233>`
   * - ``DataFrameResampler resample(const std::string& rule, int axis = 0, const std::string& closed = "", const std::string& label = "", const std::string& convention = "start", const std::string& kind = "", const std::string& on = "", std::optional<int> level = std::nullopt, const std::string& origin = "start_day", const std::string& offset = "", bool group_keys = false) const``
     - DataFrameResampler
     - pd_dataframe.h:26725
     - :ref:`View <example-dataframe-resample-234>`
   * - ``DataFrameRolling rolling(size_t window, size_t min_periods = 1, bool center = false, const std::string& win_type = "", const std::string& on = "", int axis = 0, const std::string& closed = "right", std::optional<size_t> step = std::nullopt, const std::string& method = "single") const``
     - DataFrameRolling
     - pd_dataframe.h:13032
     - :ref:`View <example-dataframe-rolling-235>`
   * - ``DataFrame transform(Func&& func, int axis = 0) const``
     - DataFrame
     - pd_dataframe.h:23357
     - :ref:`View <example-dataframe-transform-236>`
   * - ``DataFrame transform(const std::string& func_name, int axis = 0) const``
     - DataFrame
     - pd_dataframe.h:23455
     - :ref:`View <example-dataframe-transform-237>`
   * - ``DataFrame transform(const std::vector<std::string>& func_names, int axis = 0) const``
     - DataFrame
     - pd_dataframe.h:23525
     - :ref:`View <example-dataframe-transform-238>`
   * - ``DataFrame transform(const std::map<std::string, std::string>& col_func_map, int axis = 0) const``
     - DataFrame
     - pd_dataframe.h:23565
     - :ref:`View <example-dataframe-transform-239>`
   * - ``DataFrame transform(const std::map<std::string, std::vector<std::string>>& col_funcs_map, int axis = 0) const``
     - DataFrame
     - pd_dataframe.h:23614
     - :ref:`View <example-dataframe-transform-240>`
   * - ``PANDASCORE_API DataFrame transform_callable_resolved( const std::function<ApplyCellResult(const pandas::Series<numpy::float64>&)>& cb, pandas::ApplyResultInference::ScalarKindHistogram& hist, int axis = 0 ) const``
     - PANDASCORE_API DataFrame
     - pd_dataframe.h:21712
     - :ref:`View <example-dataframe-transform_callable_resolved-241>`

Arithmetic
----------

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

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``DataFrame add(const DataFrame& other, int axis = 1, std::optional<int> level = std::nullopt, double fill_value = 0.0) const``
     - DataFrame
     - pd_dataframe.h:19521
     - :ref:`View <example-dataframe-add-242>`
   * - ``DataFrame add(double scalar) const``
     - DataFrame
     - pd_dataframe.h:19529
     - :ref:`View <example-dataframe-add-243>`
   * - ``DataFrame add(const Series<numpy::float64>& other, int axis = 1, std::optional<double> fill_value = std::nullopt, std::optional<int> level = std::nullopt) const``
     - DataFrame
     - pd_dataframe.h:19533
     - :ref:`View <example-dataframe-add-244>`
   * - ``void add_column(const std::string& name, const std::vector<T>& data)``
     - void
     - pd_dataframe.h:6854
     - :ref:`View <example-dataframe-add_column-245>`
   * - ``void add_column_nullable(const std::string& name, std::initializer_list<std::conditional_t< std::is_same_v<T, std::string>, NullableString, Nullable<T>>> data)``
     - void
     - pd_dataframe.h:6984
     - :ref:`View <example-dataframe-add_column_nullable-246>`
   * - ``void add_column_with_dtype_override(const std::string& name, const std::vector<T>& data, const std::string& dtype_str)``
     - void
     - pd_dataframe.h:7034
     - :ref:`View <example-dataframe-add_column_with_dtype_override-247>`
   * - ``DataFrame add_prefix(const std::string& prefix, int axis = -1) const``
     - DataFrame
     - pd_dataframe.h:6660
     - :ref:`View <example-dataframe-add_prefix-248>`
   * - ``DataFrame add_suffix(const std::string& suffix, int axis = -1) const``
     - DataFrame
     - pd_dataframe.h:6711
     - :ref:`View <example-dataframe-add_suffix-249>`
   * - ``DataFrame div(const DataFrame& other, int axis = 1, std::optional<int> level = std::nullopt, double fill_value = 1.0) const``
     - DataFrame
     - pd_dataframe.h:19623
     - :ref:`View <example-dataframe-div-250>`
   * - ``DataFrame div(double scalar) const``
     - DataFrame
     - pd_dataframe.h:19631
     - :ref:`View <example-dataframe-div-251>`
   * - ``DataFrame div(const Series<numpy::float64>& other, int axis = 1, std::optional<double> fill_value = std::nullopt, std::optional<int> level = std::nullopt) const``
     - DataFrame
     - pd_dataframe.h:19635
     - :ref:`View <example-dataframe-div-252>`
   * - ``DataFrame divide(const DataFrame& other, int axis = 1, std::optional<int> level = std::nullopt, double fill_value = 1.0) const``
     - DataFrame
     - pd_dataframe.h:19642
     - :ref:`View <example-dataframe-divide-253>`
   * - ``DataFrame divide(const Series<numpy::float64>& other, int axis = 1, std::optional<double> fill_value = std::nullopt, std::optional<int> level = std::nullopt) const``
     - DataFrame
     - pd_dataframe.h:19648
     - :ref:`View <example-dataframe-divide-254>`
   * - ``DataFrame dot(const DataFrame& other) const``
     - DataFrame
     - pd_dataframe.h:19264
     - :ref:`View <example-dataframe-dot-255>`
   * - ``Series<double> dot(const Series<T>& other) const``
     - Series<double>
     - pd_dataframe.h:19323
     - :ref:`View <example-dataframe-dot-256>`
   * - ``DataFrame floordiv(const DataFrame& other, int axis = 1, std::optional<int> level = std::nullopt, double fill_value = std::numeric_limits<double>::quiet_NaN()) const``
     - DataFrame
     - pd_dataframe.h:19678
     - :ref:`View <example-dataframe-floordiv-257>`
   * - ``DataFrame floordiv(double scalar) const``
     - DataFrame
     - pd_dataframe.h:19687
     - :ref:`View <example-dataframe-floordiv-258>`
   * - ``DataFrame mod(const DataFrame& other, int axis = 1, std::optional<int> level = std::nullopt, double fill_value = std::numeric_limits<double>::quiet_NaN()) const``
     - DataFrame
     - pd_dataframe.h:19698
     - :ref:`View <example-dataframe-mod-259>`
   * - ``DataFrame mod(double scalar) const``
     - DataFrame
     - pd_dataframe.h:19707
     - :ref:`View <example-dataframe-mod-260>`
   * - ``DataFrame mul(const numpy::NDArray<numpy::float64>& rhs) const``
     - DataFrame
     - pd_dataframe.h:3239
     - :ref:`View <example-dataframe-mul-261>`
   * - ``DataFrame mul(const DataFrame& other, int axis = 1, std::optional<int> level = std::nullopt, double fill_value = 1.0) const``
     - DataFrame
     - pd_dataframe.h:19585
     - :ref:`View <example-dataframe-mul-262>`
   * - ``DataFrame mul(double scalar) const``
     - DataFrame
     - pd_dataframe.h:19593
     - :ref:`View <example-dataframe-mul-263>`
   * - ``DataFrame mul(const Series<numpy::float64>& other, int axis = 1, std::optional<double> fill_value = std::nullopt, std::optional<int> level = std::nullopt) const``
     - DataFrame
     - pd_dataframe.h:19597
     - :ref:`View <example-dataframe-mul-264>`
   * - ``MultiIndex multi_idx(std::move(levels), std::move(codes), level_names)``
     - MultiIndex
     - pd_dataframe.h:13932
     - 
   * - ``const MultiIndex& multiindex() const``
     - const MultiIndex&
     - pd_dataframe.h:1351
     - :ref:`View <example-dataframe-multiindex-265>`
   * - ``DataFrame multiply(const DataFrame& other, int axis = 1, std::optional<int> level = std::nullopt, double fill_value = 1.0) const``
     - DataFrame
     - pd_dataframe.h:19604
     - :ref:`View <example-dataframe-multiply-266>`
   * - ``DataFrame multiply(const Series<numpy::float64>& other, int axis = 1, std::optional<double> fill_value = std::nullopt, std::optional<int> level = std::nullopt) const``
     - DataFrame
     - pd_dataframe.h:19610
     - :ref:`View <example-dataframe-multiply-267>`
   * - ``DataFrame pow(const DataFrame& other, int axis = 1, std::optional<int> level = std::nullopt, double fill_value = std::numeric_limits<double>::quiet_NaN()) const``
     - DataFrame
     - pd_dataframe.h:19718
     - :ref:`View <example-dataframe-pow-268>`
   * - ``DataFrame pow(double exponent) const``
     - DataFrame
     - pd_dataframe.h:19727
     - :ref:`View <example-dataframe-pow-269>`
   * - ``DataFrame radd(const DataFrame& other, int axis = 1, std::optional<int> level = std::nullopt, double fill_value = 0.0) const``
     - DataFrame
     - pd_dataframe.h:19747
     - :ref:`View <example-dataframe-radd-270>`
   * - ``DataFrame radd(double scalar, double fill_value = std::numeric_limits<double>::quiet_NaN()) const``
     - DataFrame
     - pd_dataframe.h:19756
     - :ref:`View <example-dataframe-radd-271>`
   * - ``DataFrame radd(const Series<numpy::float64>& other, int axis = 1, std::optional<double> fill_value = std::nullopt, std::optional<int> level = std::nullopt) const``
     - DataFrame
     - pd_dataframe.h:19765
     - :ref:`View <example-dataframe-radd-272>`
   * - ``DataFrame rdiv(const DataFrame& other, int axis = 1, std::optional<int> level = std::nullopt, double fill_value = 1.0) const``
     - DataFrame
     - pd_dataframe.h:19855
     - :ref:`View <example-dataframe-rdiv-273>`
   * - ``DataFrame rdiv(double scalar, double fill_value = std::numeric_limits<double>::quiet_NaN()) const``
     - DataFrame
     - pd_dataframe.h:19863
     - :ref:`View <example-dataframe-rdiv-274>`
   * - ``DataFrame rdiv(const Series<numpy::float64>& other, int axis = 1, std::optional<double> fill_value = std::nullopt, std::optional<int> level = std::nullopt) const``
     - DataFrame
     - pd_dataframe.h:19871
     - :ref:`View <example-dataframe-rdiv-275>`
   * - ``DataFrame rfloordiv(const DataFrame& other, int axis = 1, std::optional<int> level = std::nullopt, double fill_value = 1.0) const``
     - DataFrame
     - pd_dataframe.h:19907
     - :ref:`View <example-dataframe-rfloordiv-276>`
   * - ``DataFrame rfloordiv(double scalar, double fill_value = std::numeric_limits<double>::quiet_NaN()) const``
     - DataFrame
     - pd_dataframe.h:19915
     - :ref:`View <example-dataframe-rfloordiv-277>`
   * - ``DataFrame rmod(const DataFrame& other, int axis = 1, std::optional<int> level = std::nullopt, double fill_value = 1.0) const``
     - DataFrame
     - pd_dataframe.h:19935
     - :ref:`View <example-dataframe-rmod-278>`
   * - ``DataFrame rmod(double scalar, double fill_value = std::numeric_limits<double>::quiet_NaN()) const``
     - DataFrame
     - pd_dataframe.h:19943
     - :ref:`View <example-dataframe-rmod-279>`
   * - ``DataFrame rmul(const DataFrame& other, int axis = 1, std::optional<int> level = std::nullopt, double fill_value = 1.0) const``
     - DataFrame
     - pd_dataframe.h:19819
     - :ref:`View <example-dataframe-rmul-280>`
   * - ``DataFrame rmul(double scalar, double fill_value = std::numeric_limits<double>::quiet_NaN()) const``
     - DataFrame
     - pd_dataframe.h:19828
     - :ref:`View <example-dataframe-rmul-281>`
   * - ``DataFrame rmul(const Series<numpy::float64>& other, int axis = 1, std::optional<double> fill_value = std::nullopt, std::optional<int> level = std::nullopt) const``
     - DataFrame
     - pd_dataframe.h:19836
     - :ref:`View <example-dataframe-rmul-282>`
   * - ``DataFrame rpow(const DataFrame& other, int axis = 1, std::optional<int> level = std::nullopt, double fill_value = 1.0) const``
     - DataFrame
     - pd_dataframe.h:19963
     - :ref:`View <example-dataframe-rpow-283>`
   * - ``DataFrame rpow(double base, double fill_value = std::numeric_limits<double>::quiet_NaN()) const``
     - DataFrame
     - pd_dataframe.h:19971
     - :ref:`View <example-dataframe-rpow-284>`
   * - ``DataFrame rsub(const DataFrame& other, int axis = 1, std::optional<int> level = std::nullopt, double fill_value = 0.0) const``
     - DataFrame
     - pd_dataframe.h:19784
     - :ref:`View <example-dataframe-rsub-285>`
   * - ``DataFrame rsub(double scalar, double fill_value = std::numeric_limits<double>::quiet_NaN()) const``
     - DataFrame
     - pd_dataframe.h:19792
     - :ref:`View <example-dataframe-rsub-286>`
   * - ``DataFrame rsub(const Series<numpy::float64>& other, int axis = 1, std::optional<double> fill_value = std::nullopt, std::optional<int> level = std::nullopt) const``
     - DataFrame
     - pd_dataframe.h:19800
     - :ref:`View <example-dataframe-rsub-287>`
   * - ``DataFrame rtruediv(const DataFrame& other, int axis = 1, std::optional<int> level = std::nullopt, double fill_value = 1.0) const``
     - DataFrame
     - pd_dataframe.h:19885
     - :ref:`View <example-dataframe-rtruediv-288>`
   * - ``DataFrame rtruediv(double scalar, double fill_value = std::numeric_limits<double>::quiet_NaN()) const``
     - DataFrame
     - pd_dataframe.h:19891
     - :ref:`View <example-dataframe-rtruediv-289>`
   * - ``DataFrame sub(const DataFrame& other, int axis = 1, std::optional<int> level = std::nullopt, double fill_value = 0.0) const``
     - DataFrame
     - pd_dataframe.h:19547
     - :ref:`View <example-dataframe-sub-290>`
   * - ``DataFrame sub(double scalar) const``
     - DataFrame
     - pd_dataframe.h:19555
     - :ref:`View <example-dataframe-sub-291>`
   * - ``DataFrame sub(const Series<numpy::float64>& other, int axis = 1, std::optional<double> fill_value = std::nullopt, std::optional<int> level = std::nullopt) const``
     - DataFrame
     - pd_dataframe.h:19559
     - :ref:`View <example-dataframe-sub-292>`
   * - ``DataFrame subtract(const DataFrame& other, int axis = 1, std::optional<int> level = std::nullopt, double fill_value = 0.0) const``
     - DataFrame
     - pd_dataframe.h:19566
     - :ref:`View <example-dataframe-subtract-293>`
   * - ``DataFrame subtract(const Series<numpy::float64>& other, int axis = 1, std::optional<double> fill_value = std::nullopt, std::optional<int> level = std::nullopt) const``
     - DataFrame
     - pd_dataframe.h:19572
     - :ref:`View <example-dataframe-subtract-294>`
   * - ``DataFrame truediv(const DataFrame& other, int axis = 1, std::optional<int> level = std::nullopt, double fill_value = 1.0) const``
     - DataFrame
     - pd_dataframe.h:19661
     - :ref:`View <example-dataframe-truediv-295>`
   * - ``DataFrame truediv(double scalar) const``
     - DataFrame
     - pd_dataframe.h:19667
     - :ref:`View <example-dataframe-truediv-296>`

Comparison
----------

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

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``DataFrame compare( const DataFrame& other, bool keep_shape = false, bool keep_equal = false) const``
     - DataFrame
     - pd_dataframe.h:26425
     - :ref:`View <example-dataframe-compare-297>`
   * - ``DataFrame eq(const DataFrame& other, int axis = 1, std::optional<int> level = std::nullopt) const``
     - DataFrame
     - pd_dataframe.h:19373
     - :ref:`View <example-dataframe-eq-298>`
   * - ``DataFrame eq(const Series<numpy::float64>& other, int axis = 1) const``
     - DataFrame
     - pd_dataframe.h:19446
     - :ref:`View <example-dataframe-eq-299>`
   * - ``DataFrame eq(double scalar) const``
     - DataFrame
     - pd_dataframe.h:19466
     - :ref:`View <example-dataframe-eq-300>`
   * - ``bool equals(const DataFrame& other) const``
     - bool
     - pd_dataframe.h:10199
     - :ref:`View <example-dataframe-equals-301>`
   * - ``DataFrame ge(const DataFrame& other, int axis = 1, std::optional<int> level = std::nullopt) const``
     - DataFrame
     - pd_dataframe.h:19438
     - :ref:`View <example-dataframe-ge-302>`
   * - ``DataFrame ge(const Series<numpy::float64>& other, int axis = 1) const``
     - DataFrame
     - pd_dataframe.h:19461
     - :ref:`View <example-dataframe-ge-303>`
   * - ``DataFrame ge(double scalar) const``
     - DataFrame
     - pd_dataframe.h:19486
     - :ref:`View <example-dataframe-ge-304>`
   * - ``std::mt19937 gen(random_state == 0 ? std::random_device{}() : random_state)``
     - std::mt19937
     - pd_dataframe.h:4063
     - :ref:`View <example-dataframe-gen-305>`
   * - ``DataFrame gt(const DataFrame& other, int axis = 1, std::optional<int> level = std::nullopt) const``
     - DataFrame
     - pd_dataframe.h:19425
     - :ref:`View <example-dataframe-gt-306>`
   * - ``DataFrame gt(const Series<numpy::float64>& other, int axis = 1) const``
     - DataFrame
     - pd_dataframe.h:19458
     - :ref:`View <example-dataframe-gt-307>`
   * - ``DataFrame gt(double scalar) const``
     - DataFrame
     - pd_dataframe.h:19482
     - :ref:`View <example-dataframe-gt-308>`
   * - ``DataFrame le(const DataFrame& other, int axis = 1, std::optional<int> level = std::nullopt) const``
     - DataFrame
     - pd_dataframe.h:19412
     - :ref:`View <example-dataframe-le-309>`
   * - ``DataFrame le(const Series<numpy::float64>& other, int axis = 1) const``
     - DataFrame
     - pd_dataframe.h:19455
     - :ref:`View <example-dataframe-le-310>`
   * - ``DataFrame le(double scalar) const``
     - DataFrame
     - pd_dataframe.h:19478
     - :ref:`View <example-dataframe-le-311>`
   * - ``std::vector<std::vector<std::string>> level_arrays(keys.size())``
     - std::vector<std::vector<std::string>>
     - pd_dataframe.h:4967
     - 
   * - ``std::vector<std::vector<std::string>> level_arrays(col_names.size())``
     - std::vector<std::vector<std::string>>
     - pd_dataframe.h:13882
     - 
   * - ``std::vector<std::vector<std::string>> level_arrays(index.size())``
     - std::vector<std::vector<std::string>>
     - pd_dataframe.h:16563
     - 
   * - ``std::vector<std::vector<std::string>> level_arrays(n_result_levels)``
     - std::vector<std::vector<std::string>>
     - pd_dataframe.h:18130
     - 
   * - ``std::vector<std::vector<std::string>> level_values(nlvl)``
     - std::vector<std::vector<std::string>>
     - pd_dataframe.h:15002
     - 
   * - ``std::vector<std::vector<std::string>> level_values(n_levels)``
     - std::vector<std::vector<std::string>>
     - pd_dataframe.h:17926
     - 
   * - ``std::vector<std::vector<std::string>> levels(n_levels)``
     - std::vector<std::vector<std::string>>
     - pd_dataframe.h:16881
     - :ref:`View <example-dataframe-levels-312>`
   * - ``std::vector<std::vector<std::string>> levels(1 + n_inner)``
     - std::vector<std::vector<std::string>>
     - pd_dataframe.h:17300
     - :ref:`View <example-dataframe-levels-313>`
   * - ``DataFrame lt(const DataFrame& other, int axis = 1, std::optional<int> level = std::nullopt) const``
     - DataFrame
     - pd_dataframe.h:19399
     - :ref:`View <example-dataframe-lt-314>`
   * - ``DataFrame lt(const Series<numpy::float64>& other, int axis = 1) const``
     - DataFrame
     - pd_dataframe.h:19452
     - :ref:`View <example-dataframe-lt-315>`
   * - ``DataFrame lt(double scalar) const``
     - DataFrame
     - pd_dataframe.h:19474
     - :ref:`View <example-dataframe-lt-316>`
   * - ``DataFrame ne(const DataFrame& other, int axis = 1, std::optional<int> level = std::nullopt) const``
     - DataFrame
     - pd_dataframe.h:19386
     - :ref:`View <example-dataframe-ne-317>`
   * - ``DataFrame ne(const Series<numpy::float64>& other, int axis = 1) const``
     - DataFrame
     - pd_dataframe.h:19449
     - :ref:`View <example-dataframe-ne-318>`
   * - ``DataFrame ne(double scalar) const``
     - DataFrame
     - pd_dataframe.h:19470
     - :ref:`View <example-dataframe-ne-319>`
   * - ``DatetimeArray new_arr(new_dt_values)``
     - DatetimeArray
     - pd_dataframe.h:3880
     - 
   * - ``std::vector<std::vector<std::string>> new_levels(columns_levels_.size())``
     - std::vector<std::vector<std::string>>
     - pd_dataframe.h:2837
     - 
   * - ``std::vector<std::vector<std::string>> new_levels(levels.size())``
     - std::vector<std::vector<std::string>>
     - pd_dataframe.h:2886
     - 
   * - ``std::vector<std::vector<std::string>> new_stacked_indices(stack_lvls.size())``
     - std::vector<std::vector<std::string>>
     - pd_dataframe.h:18526
     - 

Sorting
-------

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

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``DataFrame rank(int axis = 0, const std::string& method = "average", bool ascending = true, const std::string& na_option = "keep", bool pct = false, bool numeric_only = false) const``
     - DataFrame
     - pd_dataframe.h:15068
     - :ref:`View <example-dataframe-rank-320>`
   * - ``DataFrame sort_index(bool ascending) const``
     - DataFrame
     - pd_dataframe.h:14908
     - :ref:`View <example-dataframe-sort_index-321>`
   * - ``DataFrame sort_index(int axis, bool ascending) const``
     - DataFrame
     - pd_dataframe.h:14911
     - :ref:`View <example-dataframe-sort_index-322>`
   * - ``DataFrame sort_index(int axis = 0, std::optional<int> level = std::nullopt, bool ascending = true, bool inplace = false, const std::string& kind = "quicksort", const std::string& na_position = "last", bool sort_remaining = true, bool ignore_index = false, std::function<std::string(const std::string&)> key = nullptr) const``
     - DataFrame
     - pd_dataframe.h:14914
     - :ref:`View <example-dataframe-sort_index-323>`
   * - ``DataFrame sort_values(const std::string& by, bool ascending, S&& na_position, int axis = 0, bool inplace = false, const std::string& kind = "quicksort", bool ignore_index = false, const std::string& key = "") const``
     - DataFrame
     - pd_dataframe.h:14619
     - :ref:`View <example-dataframe-sort_values-324>`
   * - ``DataFrame sort_values(const std::vector<std::string>& by, bool ascending, S&& na_position, int axis = 0, bool inplace = false, const std::string& kind = "quicksort", bool ignore_index = false, const std::string& key = "") const``
     - DataFrame
     - pd_dataframe.h:14631
     - :ref:`View <example-dataframe-sort_values-325>`
   * - ``DataFrame sort_values(std::initializer_list<const char\*> by_init, bool ascending = true) const``
     - DataFrame
     - pd_dataframe.h:14642
     - :ref:`View <example-dataframe-sort_values-326>`
   * - ``DataFrame sort_values(const std::string& by, bool ascending = true, int axis = 0, bool inplace = false, const std::string& kind = "quicksort", const std::string& na_position = "last", bool ignore_index = false, const std::string& key = "") const``
     - DataFrame
     - pd_dataframe.h:14648
     - :ref:`View <example-dataframe-sort_values-327>`
   * - ``DataFrame sort_values(const std::vector<std::string>& by, bool ascending, int axis = 0, bool inplace = false, const std::string& kind = "quicksort", const std::string& na_position = "last", bool ignore_index = false, const std::string& key = "") const``
     - DataFrame
     - pd_dataframe.h:14661
     - :ref:`View <example-dataframe-sort_values-328>`
   * - ``DataFrame sort_values(const std::vector<std::string>& by, const std::vector<bool>& ascending, int axis = 0, bool inplace = false, const std::string& kind = "quicksort", const std::string& na_position = "last", bool ignore_index = false, const std::string& key = "") const``
     - DataFrame
     - pd_dataframe.h:14683
     - :ref:`View <example-dataframe-sort_values-329>`
   * - ``DataFrame sort_values_by_transformed( const std::vector<std::vector<std::string>>& transformed_cols, const std::vector<bool>& ascending, const std::string& na_position = "last", bool ignore_index = false) const``
     - DataFrame
     - pd_dataframe.h:14843
     - :ref:`View <example-dataframe-sort_values_by_transformed-330>`

Reshaping
---------

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

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``DataFrame T() const``
     - DataFrame
     - pd_dataframe.h:1270
     - :ref:`View <example-dataframe-t-331>`
   * - ``DataFrame explode(const std::string& column, bool ignore_index = false) const``
     - DataFrame
     - pd_dataframe.h:17984
     - :ref:`View <example-dataframe-explode-332>`
   * - ``DataFrame melt(std::initializer_list<std::string> id_vars, std::initializer_list<std::string> value_vars, const std::string& var_name = "variable", const std::string& value_name = "value", std::optional<int> col_level = std::nullopt, bool ignore_index = true) const``
     - DataFrame
     - pd_dataframe.h:17667
     - :ref:`View <example-dataframe-melt-333>`
   * - ``DataFrame melt(const std::vector<std::string>& id_vars, const std::string& var_name, const std::string& value_name) const``
     - DataFrame
     - pd_dataframe.h:17679
     - :ref:`View <example-dataframe-melt-334>`
   * - ``DataFrame melt(const std::vector<std::string>& id_vars, const std::vector<std::string>& value_vars, const std::string& col_level_placeholder, const std::string& var_name, const std::string& value_name) const``
     - DataFrame
     - pd_dataframe.h:17686
     - :ref:`View <example-dataframe-melt-335>`
   * - ``DataFrame melt(const std::vector<std::string>& id_vars, const std::vector<std::string>& value_vars = {}, const std::string& var_name = "variable", const std::string& value_name = "value", std::optional<int> col_level = std::nullopt, bool ignore_index = true) const``
     - DataFrame
     - pd_dataframe.h:17695
     - :ref:`View <example-dataframe-melt-336>`
   * - ``DataFrame pivot(const std::string& columns, const std::string& index = "", const std::string& values = "") const``
     - DataFrame
     - pd_dataframe.h:16099
     - :ref:`View <example-dataframe-pivot-337>`
   * - ``static std::string pivot_result_dtype_for_agg(const std::string& aggfunc, const std::string& src_dt)``
     - static std::string
     - pd_dataframe.h:16032
     - 
   * - ``DataFrame pivot_table(const std::string& values, const std::string& index, const std::string& columns, const std::string& aggfunc, double fill_value = std::numeric_limits<double>::quiet_NaN()) const``
     - DataFrame
     - pd_dataframe.h:16285
     - :ref:`View <example-dataframe-pivot_table-338>`
   * - ``DataFrame pivot_table(const std::string& values, const std::string& index, const std::string& columns, const std::string& aggfunc, bool margins, const std::string& margins_name = "All", bool dropna = true, bool observed = false, bool sort = true) const``
     - DataFrame
     - pd_dataframe.h:16307
     - :ref:`View <example-dataframe-pivot_table-339>`
   * - ``DataFrame pivot_table(const std::vector<std::string>& values, const std::vector<std::string>& index, const std::string& columns, const std::string& aggfunc, double fill_value = std::numeric_limits<double>::quiet_NaN()) const``
     - DataFrame
     - pd_dataframe.h:16328
     - :ref:`View <example-dataframe-pivot_table-340>`
   * - ``DataFrame pivot_table(const std::vector<std::string>& index, const std::vector<std::string>& columns, const std::string& aggfunc) const``
     - DataFrame
     - pd_dataframe.h:16347
     - :ref:`View <example-dataframe-pivot_table-341>`
   * - ``DataFrame pivot_table(const std::vector<std::string>& values, const std::vector<std::string>& index, const std::vector<std::string>& columns, const std::string& aggfunc, double fill_value = std::numeric_limits<double>::quiet_NaN(), bool margins = false, const std::string& margins_name = "All", bool dropna = true, bool observed = false, bool sort = true, bool values_was_scalar = false) const``
     - DataFrame
     - pd_dataframe.h:16447
     - :ref:`View <example-dataframe-pivot_table-342>`
   * - ``DataFrame pivot_table_multi_agg( const std::vector<std::string>& values, const std::vector<std::string>& index, const std::vector<std::string>& columns, const std::vector<std::string>& aggfuncs, double fill_value = std::numeric_limits<double>::quiet_NaN(), bool margins = false, const std::string& margins_name = "All") const``
     - DataFrame
     - pd_dataframe.h:17456
     - :ref:`View <example-dataframe-pivot_table_multi_agg-343>`
   * - ``DataFrame pivot_table_with_margins( const std::string& values, const std::string& index, const std::string& columns, const std::string& aggfunc = "mean", double fill_value = std::numeric_limits<double>::quiet_NaN(), bool margins = false, const std::string& margins_name = "All" ) const``
     - DataFrame
     - pd_dataframe.h:16982
     - :ref:`View <example-dataframe-pivot_table_with_margins-344>`
   * - ``DataFrame pivot_table_with_margins( const std::vector<std::string>& values, const std::vector<std::string>& index, const std::vector<std::string>& columns, const std::string& aggfunc = "mean", double fill_value = std::numeric_limits<double>::quiet_NaN(), bool margins = false, const std::string& margins_name = "All" ) const``
     - DataFrame
     - pd_dataframe.h:17017
     - :ref:`View <example-dataframe-pivot_table_with_margins-345>`
   * - ``DataFrame squeeze() const``
     - DataFrame
     - pd_dataframe.h:18091
     - :ref:`View <example-dataframe-squeeze-346>`
   * - ``DataFrame stack(std::optional<int> level = std::nullopt, bool dropna = true, bool sort = true, bool future_stack = false) const``
     - DataFrame
     - pd_dataframe.h:18216
     - :ref:`View <example-dataframe-stack-347>`
   * - ``DataFrame stack_levels(const std::vector<int>& levels, bool dropna = true) const``
     - DataFrame
     - pd_dataframe.h:18469
     - :ref:`View <example-dataframe-stack_levels-348>`
   * - ``Series<numpy::float64> stack_to_series(std::optional<int> level = std::nullopt, bool dropna = true, bool sort = true, bool future_stack = false) const``
     - Series<numpy::float64>
     - pd_dataframe.h:18115
     - 
   * - ``DataFrame swapaxes(int axis1 = 0, int axis2 = 1, bool copy = true) const``
     - DataFrame
     - pd_dataframe.h:13340
     - :ref:`View <example-dataframe-swapaxes-349>`
   * - ``DataFrame transpose() const``
     - DataFrame
     - pd_dataframe.h:15126
     - :ref:`View <example-dataframe-transpose-350>`
   * - ``DataFrame unstack(int level = -1, std::optional<double> fill_value = std::nullopt, bool sort = true) const``
     - DataFrame
     - pd_dataframe.h:18759
     - :ref:`View <example-dataframe-unstack-351>`

Combining
---------

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

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``std::pair<DataFrame, DataFrame> align( const DataFrame& other, const std::string& join = "outer", int axis = -1, std::optional<int> level = std::nullopt, bool copy = true, double fill_value = std::numeric_limits<double>::quiet_NaN(), const std::string& method = "", std::optional<int> limit = std::nullopt, std::optional<int> fill_axis = std::nullopt, std::optional<int> broadcast_axis = std::nullopt) const``
     - std::pair<DataFrame, DataFrame>
     - pd_dataframe.h:25826
     - :ref:`View <example-dataframe-align-352>`
   * - ``std::pair<DataFrame, Series<T>> align_series( const Series<T>& other, const std::string& join = "outer", int axis = -1, double fill_value = std::numeric_limits<double>::quiet_NaN()) const``
     - std::pair<DataFrame, Series<T>>
     - pd_dataframe.h:25916
     - :ref:`View <example-dataframe-align_series-353>`
   * - ``DataFrame combine(const DataFrame& other, Func func, std::optional<double> fill_value = std::nullopt, bool overwrite = true) const``
     - DataFrame
     - pd_dataframe.h:26038
     - :ref:`View <example-dataframe-combine-354>`
   * - ``DataFrame combine_first(const DataFrame& other) const``
     - DataFrame
     - pd_dataframe.h:26266
     - :ref:`View <example-dataframe-combine_first-355>`
   * - ``static std::string combine_promote_dtype_(const std::string& a, const std::string& b)``
     - static std::string
     - pd_dataframe.h:26032
     - 
   * - ``static DataFrame concat( const std::vector<DataFrame>& objs, int axis = 0, const std::string& join = "outer", bool ignore_index = false, const std::vector<std::string>& keys = {}, [[maybe_unused]] const std::vector<std::vector<std::string>>& levels = {}, [[maybe_unused]] const std::vector<std::string>& names = {}, bool verify_integrity = false, bool sort = false, [[maybe_unused]] bool copy = true)``
     - static DataFrame
     - pd_dataframe.h:24240
     - :ref:`View <example-dataframe-concat-356>`
   * - ``static DataFrame concat(const std::vector<DataFrame>& frames, bool ignore_index)``
     - static DataFrame
     - pd_dataframe.h:24720
     - :ref:`View <example-dataframe-concat-357>`
   * - ``std::unique_ptr<NDFrameBase> concat_with(const NDFrameBase& other) const override``
     - std::unique_ptr<NDFrameBase>
     - pd_dataframe.h:27144
     - 
   * - ``DataFrame join( const DataFrame& other, const std::string& how = "left", const std::string& lsuffix = "", const std::string& rsuffix = "_r", bool sort = false, const std::string& on = "", const std::string& validate = "") const``
     - DataFrame
     - pd_dataframe.h:25540
     - :ref:`View <example-dataframe-join-358>`
   * - ``DataFrame merge( const DataFrame& right, const std::string& how = "inner", const std::vector<std::string>& on = {}, const std::vector<std::string>& left_on = {}, const std::vector<std::string>& right_on = {}, const std::pair<std::string, std::string>& suffixes = {"_x", "_y"}, bool left_index = false, bool right_index = false, bool sort = false, bool copy = true, const std::string& indicator = "", const std::string& validate = "", bool preserve_left_index = false) const``
     - DataFrame
     - pd_dataframe.h:24739
     - :ref:`View <example-dataframe-merge-359>`
   * - ``DataFrame merge( const DataFrame& right, const std::string& how, const std::string& on, const std::pair<std::string, std::string>& suffixes = {"_x", "_y"}) const``
     - DataFrame
     - pd_dataframe.h:25504
     - :ref:`View <example-dataframe-merge-360>`
   * - ``DataFrame merge( const DataFrame& right, const std::string& how, const std::vector<std::string>& on, const std::vector<std::string>& left_on, const std::vector<std::string>& right_on, const std::pair<std::string, std::string>& suffixes, bool left_index, bool right_index, bool sort, const std::string& indicator, const std::string& validate) const``
     - DataFrame
     - pd_dataframe.h:25515
     - :ref:`View <example-dataframe-merge-361>`

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

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

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``DataFrame asfreq(const std::string& freq, const std::string& method = "", const std::string& how = "", bool normalize = false, std::optional<double> fill_value = std::nullopt) const``
     - DataFrame
     - pd_dataframe.h:26750
     - :ref:`View <example-dataframe-asfreq-362>`
   * - ``Series<numpy::float64> asof(const std::string& where, const std::vector<std::string>& subset = {}) const``
     - Series<numpy::float64>
     - pd_dataframe.h:27059
     - :ref:`View <example-dataframe-asof-363>`
   * - ``DataFrame asof(const std::vector<std::string>& where, const std::vector<std::string>& subset = {}) const``
     - DataFrame
     - pd_dataframe.h:27065
     - :ref:`View <example-dataframe-asof-364>`
   * - ``DataFrame between_time(const std::string& start_time, const std::string& end_time, bool include_start = true, bool include_end = true, int axis = 0) const``
     - DataFrame
     - pd_dataframe.h:26982
     - :ref:`View <example-dataframe-between_time-365>`
   * - ``DataFrame between_time(const std::string& start_time, const std::string& end_time, const std::string& inclusive, int axis = 0) const``
     - DataFrame
     - pd_dataframe.h:26999
     - :ref:`View <example-dataframe-between_time-366>`
   * - ``DataFrame diff(int periods = 1, int axis = 0) const``
     - DataFrame
     - pd_dataframe.h:20536
     - :ref:`View <example-dataframe-diff-367>`
   * - ``DataFrame pct_change(int periods = 1, const std::string& fill_method = "", std::optional<int> limit = std::nullopt, const std::string& freq = "") const``
     - DataFrame
     - pd_dataframe.h:14556
     - :ref:`View <example-dataframe-pct_change-368>`
   * - ``DataFrame shift(int periods = 1, int axis = 0, std::optional<double> fill_value = std::nullopt, const std::string& freq = "", const std::string& suffix = "") const``
     - DataFrame
     - pd_dataframe.h:20584
     - :ref:`View <example-dataframe-shift-369>`
   * - ``DataFrame to_period(const std::string& freq = "", int axis = 0, bool copy = true) const``
     - DataFrame
     - pd_dataframe.h:26800
     - :ref:`View <example-dataframe-to_period-370>`
   * - ``DataFrame to_timestamp(const std::string& freq = "", const std::string& how = "start", int axis = 0, bool copy = true) const``
     - DataFrame
     - pd_dataframe.h:26841
     - :ref:`View <example-dataframe-to_timestamp-371>`
   * - ``DataFrame tz_convert(const std::string& tz, int axis = 0, int level = -1, bool copy = true) const``
     - DataFrame
     - pd_dataframe.h:26893
     - :ref:`View <example-dataframe-tz_convert-372>`
   * - ``DataFrame tz_localize(const std::string& tz, int axis = 0, int level = -1, bool copy = true, const std::string& ambiguous = "raise", const std::string& nonexistent = "raise") const``
     - DataFrame
     - pd_dataframe.h:26951
     - :ref:`View <example-dataframe-tz_localize-373>`

I/O
---

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

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``std::string to_csv( bool include_index = true, char sep = ',', [[maybe_unused]] std::optional<size_t> chunksize = std::nullopt, const std::vector<std::string>& columns = {}, [[maybe_unused]] const std::string& compression = "infer", [[maybe_unused]] const std::string& date_format = "", char decimal = '.', [[maybe_unused]] const std::string& encoding = "utf-8", const std::string& lineterminator = "\\n", const std::string& na_rep = "", // Additional pandas-compatible parameters [[maybe_unused]] const std::string& path_or_buf = "", // Reserved: file path (C++ returns string) [[maybe_unused]] const std::string& mode = "w", // Reserved: file mode bool header = true, // Write column names const std::string& index_label = "", // Column label for index column(s) [[maybe_unused]] const std::string& errors = "strict", // Reserved: encoding error handling [[maybe_unused]] const std::string& storage_options = "", // Reserved: cloud storage options [[maybe_unused]] const std::string& float_format = "", // Printf-style format string for floats char quotechar = '"', // Character used to quote fields [[maybe_unused]] int quoting = 0, // Reserved: csv.QUOTE_\* constant (0=MINIMAL) bool doublequote = true, // Control quoting of quotechar inside field [[maybe_unused]] const std::string& escapechar = "") const``
     - std::string
     - pd_dataframe.h:27185
     - :ref:`View <example-dataframe-to_csv-374>`
   * - ``void to_gbq( const std::string& destination_table, const std::string& project_id = "", const std::string& if_exists = "fail", bool progress_bar = true, [[maybe_unused]] bool auth_local_webserver = true, [[maybe_unused]] std::optional<size_t> chunksize = std::nullopt, [[maybe_unused]] const std::string& credentials = "", [[maybe_unused]] const std::string& location = "", [[maybe_unused]] bool reauth = false, [[maybe_unused]] const std::string& table_schema = "") const``
     - void
     - pd_dataframe.h:13478
     - :ref:`View <example-dataframe-to_gbq-375>`
   * - ``std::string to_json( const std::string& orient = "columns", [[maybe_unused]] const std::string& compression = "infer", [[maybe_unused]] const std::string& date_format = "epoch", [[maybe_unused]] const std::string& date_unit = "ms", [[maybe_unused]] const std::string& default_handler = "", [[maybe_unused]] int double_precision = 10, [[maybe_unused]] bool force_ascii = true, [[maybe_unused]] int indent = 0, [[maybe_unused]] const std::string& storage_options = "", // Additional pandas-compatible parameters [[maybe_unused]] const std::string& path_or_buf = "", // Reserved: file path (C++ returns string) bool index = true, // Include index in JSON output [[maybe_unused]] bool lines = false, // Reserved: write records per line (JSON Lines format) [[maybe_unused]] const std::string& mode = "w") const``
     - std::string
     - pd_dataframe.h:27462
     - :ref:`View <example-dataframe-to_json-376>`
   * - ``std::string to_xml( const std::string& path_or_buffer = "", // Renamed from 'path' for pandas API compatibility bool index = true, const std::string& root_name = "data", const std::string& row_name = "row", bool pretty_print = true, [[maybe_unused]] const std::vector<std::string>& attr_cols = {}, [[maybe_unused]] const std::string& compression = "infer", [[maybe_unused]] const std::vector<std::string>& elem_cols = {}, const std::string& encoding = "utf-8", const std::string& na_rep = "", [[maybe_unused]] const std::map<std::string, std::string>& namespaces = {}, [[maybe_unused]] const std::string& parser = "lxml", [[maybe_unused]] const std::string& prefix = "", [[maybe_unused]] const std::string& storage_options = "", [[maybe_unused]] const std::string& stylesheet = "", bool xml_declaration = true) const``
     - std::string
     - pd_dataframe.h:13519
     - :ref:`View <example-dataframe-to_xml-377>`

Conversion
----------

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

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``DataFrame astype(const std::string& dtype, bool copy = true, const std::string& errors = "raise") const``
     - DataFrame
     - pd_dataframe.h:21972
     - :ref:`View <example-dataframe-astype-378>`
   * - ``DataFrame astype(const std::map<std::string, std::string>& dtype_map, bool copy = true, const std::string& errors = "raise") const``
     - DataFrame
     - pd_dataframe.h:21998
     - :ref:`View <example-dataframe-astype-379>`
   * - ``astype(std::map<std::string, std::string>{{col_name, inner_norm}}, true, errors)``
     - 
     - pd_dataframe.h:22160
     - :ref:`View <example-dataframe-astype-380>`
   * - ``DataFrame astype(const DtypeSpec& spec, bool copy = true, const std::string& errors = "raise") const``
     - DataFrame
     - pd_dataframe.h:22219
     - :ref:`View <example-dataframe-astype-381>`
   * - ``bool bool_() const``
     - bool
     - pd_dataframe.h:13217
     - :ref:`View <example-dataframe-bool_-382>`
   * - ``DataFrame convert_dtypes( bool infer_objects = true, bool convert_string = true, bool convert_integer = true, bool convert_boolean = true, bool convert_floating = true, const std::string& dtype_backend = "numpy_nullable") const``
     - DataFrame
     - pd_dataframe.h:22796
     - :ref:`View <example-dataframe-convert_dtypes-383>`
   * - ``DataFrame copy([[maybe_unused]] bool deep = true) const``
     - DataFrame
     - pd_dataframe.h:27121
     - :ref:`View <example-dataframe-copy-384>`
   * - ``void copy_value_from(size_t src_idx, size_t dst_idx) override``
     - void
     - pd_dataframe.h:8484
     - 
   * - ``DataFrame infer_objects(bool copy = true) const``
     - DataFrame
     - pd_dataframe.h:22948
     - :ref:`View <example-dataframe-infer_objects-385>`

Iteration
---------

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

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``iterator begin()``
     - iterator
     - pd_dataframe.h:1984
     - :ref:`View <example-dataframe-begin-386>`
   * - ``const_iterator begin() const``
     - const_iterator
     - pd_dataframe.h:1988
     - :ref:`View <example-dataframe-begin-387>`
   * - ``iterator end()``
     - iterator
     - pd_dataframe.h:2000
     - :ref:`View <example-dataframe-end-388>`
   * - ``const_iterator end() const``
     - const_iterator
     - pd_dataframe.h:2004
     - :ref:`View <example-dataframe-end-389>`
   * - ``ItemsRange items() const``
     - ItemsRange
     - pd_dataframe.h:2141
     - :ref:`View <example-dataframe-items-390>`
   * - ``RowsRange iterrows() const``
     - RowsRange
     - pd_dataframe.h:2282
     - :ref:`View <example-dataframe-iterrows-391>`
   * - ``TuplesRange itertuples(bool index = true, const std::string& name = "Pandas") const``
     - TuplesRange
     - pd_dataframe.h:2507
     - :ref:`View <example-dataframe-itertuples-392>`
   * - ``const Index<std::string>& keys() const``
     - const Index<std::string>&
     - pd_dataframe.h:2029
     - :ref:`View <example-dataframe-keys-393>`

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

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

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``Series<numpy::bool_> duplicated(const std::vector<std::string>& subset = {}, const std::string& keep = "first") const``
     - Series<numpy::bool_>
     - pd_dataframe.h:10044
     - :ref:`View <example-dataframe-duplicated-394>`
   * - ``DataFrame isin(const std::vector<T>& values) const``
     - DataFrame
     - pd_dataframe.h:8623
     - :ref:`View <example-dataframe-isin-395>`
   * - ``DataFrame isin(const std::map<std::string, std::vector<T>>& values) const``
     - DataFrame
     - pd_dataframe.h:8693
     - :ref:`View <example-dataframe-isin-396>`

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

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

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``static bool is_bool_string(const std::string& value)``
     - static bool
     - pd_dataframe.h:22597
     - 
   * - ``static bool is_float_actually_integer(double value)``
     - static bool
     - pd_dataframe.h:22643
     - 
   * - ``static bool is_float_string(const std::string& value)``
     - static bool
     - pd_dataframe.h:22623
     - 
   * - ``bool is_homogeneous_type() const``
     - bool
     - pd_dataframe.h:1872
     - 
   * - ``static bool is_integer_string(const std::string& value)``
     - static bool
     - pd_dataframe.h:22605
     - 
   * - ``bool is_na_at(size_t idx) const override``
     - bool
     - pd_dataframe.h:8400
     - :ref:`View <example-dataframe-is_na_at-397>`
   * - ``is_nullable_ext_name(source_common_override)``
     - 
     - pd_dataframe.h:15185
     - 
   * - ``static bool is_numeric_dtype(const std::string& dtype)``
     - static bool
     - pd_dataframe.h:10774
     - :ref:`View <example-dataframe-is_numeric_dtype-398>`
   * - ``static bool is_numeric_dtype_name(const std::string& dt)``
     - static bool
     - pd_dataframe.h:11683
     - 

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

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

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``std::vector<std::vector<double>> B_mat(static_cast<int>(nvalid), std::vector<double>(n_b, 0.0))``
     - std::vector<std::vector<double>>
     - pd_dataframe.h:8116
     - 
   * - ``std::vector<std::vector<double>> B_mat2(static_cast<int>(nvalid), std::vector<double>(n_b2, 0.0))``
     - std::vector<std::vector<double>>
     - pd_dataframe.h:8155
     - 
   * - ``std::vector<std::vector<double>> B_mat2(static_cast<int>(nvalid), std::vector<double>(n_b2, 0.0))``
     - std::vector<std::vector<double>>
     - pd_dataframe.h:8171
     - 
   * - ``PD_TN_TRY(numpy::float64)``
     - 
     - pd_dataframe.h:13430
     - 
   * - ``PD_TN_TRY(numpy::float32)``
     - 
     - pd_dataframe.h:13431
     - 
   * - ``PD_TN_TRY(numpy::int64)``
     - 
     - pd_dataframe.h:13432
     - 
   * - ``PD_TN_TRY(numpy::int32)``
     - 
     - pd_dataframe.h:13433
     - 
   * - ``PD_TN_TRY(numpy::int16)``
     - 
     - pd_dataframe.h:13434
     - 
   * - ``PD_TN_TRY(numpy::int8)``
     - 
     - pd_dataframe.h:13435
     - 
   * - ``PD_TN_TRY(numpy::uint64)``
     - 
     - pd_dataframe.h:13436
     - 
   * - ``PD_TN_TRY(numpy::uint32)``
     - 
     - pd_dataframe.h:13437
     - 
   * - ``PD_TN_TRY(numpy::uint16)``
     - 
     - pd_dataframe.h:13438
     - 
   * - ``PD_TN_TRY(numpy::uint8)``
     - 
     - pd_dataframe.h:13439
     - 
   * - ``PD_TN_TRY(numpy::bool_)``
     - 
     - pd_dataframe.h:13440
     - 
   * - ``std::vector<std::vector<double>> VtV(pn, std::vector<double>(pn, 0.0))``
     - std::vector<std::vector<double>>
     - pd_dataframe.h:8133
     - 
   * - ``DataFrame abs() const``
     - DataFrame
     - pd_dataframe.h:20051
     - :ref:`View <example-dataframe-abs-399>`
   * - ``bool all(int axis = 0, bool bool_only = false, bool skipna = true) const override``
     - bool
     - pd_dataframe.h:23947
     - :ref:`View <example-dataframe-all-400>`
   * - ``Series<numpy::bool_> all_axis(int axis = 0, bool skipna = true) const``
     - Series<numpy::bool_>
     - pd_dataframe.h:23984
     - :ref:`View <example-dataframe-all_axis-401>`
   * - ``bool all_columns_timedelta() const``
     - bool
     - pd_dataframe.h:727
     - :ref:`View <example-dataframe-all_columns_timedelta-402>`
   * - ``bool any(int axis = 0, bool bool_only = false, bool skipna = true) const override``
     - bool
     - pd_dataframe.h:23964
     - :ref:`View <example-dataframe-any-403>`
   * - ``Series<numpy::bool_> any_axis(int axis = 0, bool skipna = true) const``
     - Series<numpy::bool_>
     - pd_dataframe.h:24114
     - :ref:`View <example-dataframe-any_axis-404>`
   * - ``DatetimeArray arr(dt_vals)``
     - DatetimeArray
     - pd_dataframe.h:5517
     - :ref:`View <example-dataframe-arr-405>`
   * - ``static DataFrame assemble_multi_series_dataframe( std::vector<std::unique_ptr<NDFrameBase>> cols, const std::vector<std::string>& names, std::unique_ptr<IndexBase> index_clone)``
     - static DataFrame
     - pd_dataframe.h:2709
     - :ref:`View <example-dataframe-assemble_multi_series_dataframe-406>`
   * - ``Series<numpy::float64> assemble_scalar_series( const std::vector<numpy::float64>& values, const std::vector<std::string>& col_names) const``
     - Series<numpy::float64>
     - pd_dataframe.h:2668
     - :ref:`View <example-dataframe-assemble_scalar_series-407>`
   * - ``Series<std::string> assemble_scalar_string_series( const std::vector<std::string>& values, const std::vector<std::string>& col_names) const``
     - Series<std::string>
     - pd_dataframe.h:2691
     - :ref:`View <example-dataframe-assemble_scalar_string_series-408>`
   * - ``std::vector<const IndexBase\*> axes() const override``
     - std::vector<const IndexBase\*>
     - pd_dataframe.h:1561
     - :ref:`View <example-dataframe-axes-409>`
   * - ``DataFrame broadcast_series_to_bool_dataframe(const Series<numpy::float64>& condition, int axis) const``
     - DataFrame
     - pd_dataframe.h:8908
     - :ref:`View <example-dataframe-broadcast_series_to_bool_dataframe-410>`
   * - ``Axis1ColumnPlan build_axis1_plan(bool numeric_only) const``
     - Axis1ColumnPlan
     - pd_dataframe.h:11695
     - 
   * - ``else build_dt64()``
     - else
     - pd_dataframe.h:6353
     - 
   * - ``build_float(float{})``
     - 
     - pd_dataframe.h:6388
     - 
   * - ``build_float(double{})``
     - 
     - pd_dataframe.h:6392
     - 
   * - ``MultiIndexColumnLabel build_multiindex_column_label(size_t col_idx) const``
     - MultiIndexColumnLabel
     - pd_dataframe.h:3064
     - 
   * - ``build_native_int(int64_t{})``
     - 
     - pd_dataframe.h:6372
     - 
   * - ``build_native_int(int32_t{})``
     - 
     - pd_dataframe.h:6374
     - 
   * - ``build_native_int(int16_t{})``
     - 
     - pd_dataframe.h:6376
     - 
   * - ``build_native_int(int8_t{})``
     - 
     - pd_dataframe.h:6378
     - 
   * - ``build_native_int(uint64_t{})``
     - 
     - pd_dataframe.h:6380
     - 
   * - ``build_native_int(uint32_t{})``
     - 
     - pd_dataframe.h:6382
     - 
   * - ``build_native_int(uint16_t{})``
     - 
     - pd_dataframe.h:6384
     - 
   * - ``build_native_int(uint8_t{})``
     - 
     - pd_dataframe.h:6386
     - 
   * - ``else build_td64()``
     - else
     - pd_dataframe.h:6357
     - 
   * - ``build_with_dtype(bool{}, "bool")``
     - 
     - pd_dataframe.h:21175
     - 
   * - ``build_with_dtype(int64_t{}, "int64")``
     - 
     - pd_dataframe.h:21177
     - 
   * - ``build_with_dtype(uint64_t{}, "uint64")``
     - 
     - pd_dataframe.h:21179
     - 
   * - ``build_with_dtype(float{}, "float32")``
     - 
     - pd_dataframe.h:21181
     - 
   * - ``build_with_dtype(double{}, "float64")``
     - 
     - pd_dataframe.h:21246
     - 
   * - ``build_with_dtype(double{}, "float64")``
     - 
     - pd_dataframe.h:21249
     - 
   * - ``build_with_dtype(bool{}, "bool")``
     - 
     - pd_dataframe.h:21544
     - 
   * - ``build_with_dtype(int64_t{}, "int64")``
     - 
     - pd_dataframe.h:21546
     - 
   * - ``build_with_dtype(uint64_t{}, "uint64")``
     - 
     - pd_dataframe.h:21548
     - 
   * - ``build_with_dtype(float{}, "float32")``
     - 
     - pd_dataframe.h:21550
     - 
   * - ``build_with_dtype(double{}, "float64")``
     - 
     - pd_dataframe.h:21611
     - 
   * - ``build_with_dtype(double{}, "float64")``
     - 
     - pd_dataframe.h:21613
     - 
   * - ``std::vector<std::map<std::string, int>> cat_code_maps(num_sort_cols)``
     - std::vector<std::map<std::string, int>>
     - pd_dataframe.h:14702
     - 
   * - ``const_iterator cbegin() const``
     - const_iterator
     - pd_dataframe.h:1992
     - :ref:`View <example-dataframe-cbegin-411>`
   * - ``DataFrame ceil() const``
     - DataFrame
     - pd_dataframe.h:20044
     - :ref:`View <example-dataframe-ceil-412>`
   * - ``const_iterator cend() const``
     - const_iterator
     - pd_dataframe.h:2008
     - :ref:`View <example-dataframe-cend-413>`
   * - ``ColumnAccessType classify_column_access(const std::string& key) const``
     - ColumnAccessType
     - pd_dataframe.h:3311
     - :ref:`View <example-dataframe-classify_column_access-414>`
   * - ``std::vector<AggColumnInfo> classify_column_dtypes(bool skipna = true, bool numeric_only = false) const``
     - std::vector<AggColumnInfo>
     - pd_dataframe.h:11715
     - :ref:`View <example-dataframe-classify_column_dtypes-415>`
   * - ``void clear_columns_levels()``
     - void
     - pd_dataframe.h:1498
     - 
   * - ``void clear_multiindex()``
     - void
     - pd_dataframe.h:1361
     - 
   * - ``void clear_reduced_series_repr()``
     - void
     - pd_dataframe.h:1412
     - 
   * - ``DataFrame clip(double lower, double upper, std::optional<int> axis = std::nullopt, bool inplace = false) const``
     - DataFrame
     - pd_dataframe.h:20063
     - :ref:`View <example-dataframe-clip-416>`
   * - ``std::unique_ptr<NDFrameBase> clone() const override``
     - std::unique_ptr<NDFrameBase>
     - pd_dataframe.h:27129
     - :ref:`View <example-dataframe-clone-417>`
   * - ``Series<T>& col(const std::string& name)``
     - Series<T>&
     - pd_dataframe.h:3247
     - :ref:`View <example-dataframe-col-418>`
   * - ``const Series<T>& col(const std::string& name) const``
     - const Series<T>&
     - pd_dataframe.h:3261
     - :ref:`View <example-dataframe-col-419>`
   * - ``std::vector<std::vector<numpy::float64>> col_data(ncols())``
     - std::vector<std::vector<numpy::float64>>
     - pd_dataframe.h:20170
     - :ref:`View <example-dataframe-col_data-420>`
   * - ``std::vector<std::vector<numpy::float64>> col_data(ncols())``
     - std::vector<std::vector<numpy::float64>>
     - pd_dataframe.h:20271
     - :ref:`View <example-dataframe-col_data-421>`
   * - ``std::vector<std::vector<numpy::float64>> col_data(ncols())``
     - std::vector<std::vector<numpy::float64>>
     - pd_dataframe.h:20384
     - :ref:`View <example-dataframe-col_data-422>`
   * - ``std::vector<std::vector<numpy::float64>> col_data(ncols())``
     - std::vector<std::vector<numpy::float64>>
     - pd_dataframe.h:20497
     - :ref:`View <example-dataframe-col_data-423>`
   * - ``const Series<T>& column(const std::string& name) const { return col<T>(name)``
     - const Series<T>&
     - pd_dataframe.h:3275
     - :ref:`View <example-dataframe-column-424>`
   * - ``Series<T>& column(const std::string& name) { return col<T>(name)``
     - Series<T>&
     - pd_dataframe.h:3277
     - :ref:`View <example-dataframe-column-425>`
   * - ``const NDFrameBase& column_at(size_t idx) const``
     - const NDFrameBase&
     - pd_dataframe.h:2518
     - :ref:`View <example-dataframe-column_at-426>`
   * - ``std::string column_dtype_override(const std::string& col_name) const``
     - std::string
     - pd_dataframe.h:1593
     - :ref:`View <example-dataframe-column_dtype_override-427>`
   * - ``Series<numpy::float64> column_to_series_f64(size_t col_idx) const``
     - Series<numpy::float64>
     - pd_dataframe.h:2527
     - :ref:`View <example-dataframe-column_to_series_f64-428>`
   * - ``Series<std::string> column_to_series_str(size_t col_idx) const``
     - Series<std::string>
     - pd_dataframe.h:2547
     - :ref:`View <example-dataframe-column_to_series_str-429>`
   * - ``std::unique_ptr<NDFrameBase> column_to_typed_series(size_t c) const``
     - std::unique_ptr<NDFrameBase>
     - pd_dataframe.h:2641
     - :ref:`View <example-dataframe-column_to_typed_series-430>`
   * - ``static bool column_values_are_integers(const NDFrameBase\* col)``
     - static bool
     - pd_dataframe.h:22454
     - 
   * - ``const Index<std::string>& columns() const``
     - const Index<std::string>&
     - pd_dataframe.h:1277
     - :ref:`View <example-dataframe-columns-431>`
   * - ``const std::string& columns_index_dtype() const``
     - const std::string&
     - pd_dataframe.h:1397
     - :ref:`View <example-dataframe-columns_index_dtype-432>`
   * - ``const std::vector<std::string>& columns_level_names() const``
     - const std::vector<std::string>&
     - pd_dataframe.h:1530
     - :ref:`View <example-dataframe-columns_level_names-433>`
   * - ``const std::vector<std::vector<std::string>>& columns_levels() const``
     - const std::vector<std::vector<std::string>>&
     - pd_dataframe.h:1516
     - :ref:`View <example-dataframe-columns_levels-434>`
   * - ``void columns_name(const std::string& name) { set_columns_name(name)``
     - void
     - pd_dataframe.h:1385
     - :ref:`View <example-dataframe-columns_name-435>`
   * - ``const std::vector<std::vector<std::string>>& columns_original_levels() const``
     - const std::vector<std::vector<std::string>>&
     - pd_dataframe.h:1523
     - 
   * - ``std::string compute_axis1_source_common_dtype_() const``
     - std::string
     - pd_dataframe.h:20721
     - 
   * - ``std::string compute_axis1_source_common_dtype_filtered_( const std::vector<size_t>& keep_indices) const``
     - std::string
     - pd_dataframe.h:12222
     - 
   * - ``static double compute_named_stat(const std::vector<double>& vals, const std::string& func_name)``
     - static double
     - pd_dataframe.h:23657
     - 
   * - ``StringColumnStats compute_string_column_stats(size_t col_idx) const``
     - StringColumnStats
     - pd_dataframe.h:10826
     - :ref:`View <example-dataframe-compute_string_column_stats-436>`
   * - ``static numpy::bool_ convert_to_bool(const std::string& value, const std::string& source_dtype, const std::string& col_name, size_t row_idx)``
     - static numpy::bool_
     - pd_dataframe.h:22397
     - 
   * - ``static numpy::float64 convert_to_float64(const std::string& value, const std::string& source_dtype, const std::string& col_name, size_t row_idx)``
     - static numpy::float64
     - pd_dataframe.h:22363
     - 
   * - ``static numpy::int64 convert_to_int64(const std::string& value, const std::string& source_dtype, const std::string& col_name, size_t row_idx)``
     - static numpy::int64
     - pd_dataframe.h:22335
     - 
   * - ``DataFrame corr(const std::string& method = "pearson", std::optional<int> min_periods = std::nullopt, bool numeric_only = false) const``
     - DataFrame
     - pd_dataframe.h:13990
     - :ref:`View <example-dataframe-corr-437>`
   * - ``Series<numpy::float64> corrwith(const DataFrame& other, int axis = 0, bool drop = false, const std::string& method = "pearson", bool numeric_only = false) const``
     - Series<numpy::float64>
     - pd_dataframe.h:14102
     - :ref:`View <example-dataframe-corrwith-438>`
   * - ``Series<numpy::float64> corrwith(const Series<T>& other, int axis = 0, bool drop = false, const std::string& method = "pearson", bool numeric_only = false) const``
     - Series<numpy::float64>
     - pd_dataframe.h:14398
     - :ref:`View <example-dataframe-corrwith-439>`
   * - ``DataFrame cov(std::optional<int> min_periods = std::nullopt, int ddof = 1, bool numeric_only = false) const``
     - DataFrame
     - pd_dataframe.h:14044
     - :ref:`View <example-dataframe-cov-440>`
   * - ``static std::string determine_int_dtype(const std::vector<AggColumnInfo>& infos)``
     - static std::string
     - pd_dataframe.h:11797
     - 
   * - ``numpy::datetime64 dt(l)``
     - numpy::datetime64
     - pd_dataframe.h:5604
     - :ref:`View <example-dataframe-dt-441>`
   * - ``std::string dtype_name() const override``
     - std::string
     - pd_dataframe.h:1234
     - :ref:`View <example-dataframe-dtype_name-442>`
   * - ``std::string dtype_string(const std::string& col_name) const``
     - std::string
     - pd_dataframe.h:1606
     - :ref:`View <example-dataframe-dtype_string-443>`
   * - ``Series<std::string> dtypes() const``
     - Series<std::string>
     - pd_dataframe.h:1568
     - :ref:`View <example-dataframe-dtypes-444>`
   * - ``emit_index_key(oss, r)``
     - 
     - pd_dataframe.h:27621
     - 
   * - ``emit_index_key(oss, r)``
     - 
     - pd_dataframe.h:27647
     - 
   * - ``emit_value(oss, c, r)``
     - 
     - pd_dataframe.h:27623
     - 
   * - ``emit_value(oss, c, r)``
     - 
     - pd_dataframe.h:27637
     - 
   * - ``emit_value(oss, c, r)``
     - 
     - pd_dataframe.h:27652
     - 
   * - ``emit_value(oss, c, r)``
     - 
     - pd_dataframe.h:27665
     - 
   * - ``emit_value(oss, c, r)``
     - 
     - pd_dataframe.h:27688
     - 
   * - ``emit_value(oss, c, r)``
     - 
     - pd_dataframe.h:27782
     - 
   * - ``bool empty() const override``
     - bool
     - pd_dataframe.h:1196
     - :ref:`View <example-dataframe-empty-445>`
   * - ``std::vector<std::vector<std::string>> empty_levels(columns_levels_.size())``
     - std::vector<std::vector<std::string>>
     - pd_dataframe.h:2979
     - 
   * - ``static std::string escape_xml(const std::string& str)``
     - static std::string
     - pd_dataframe.h:13598
     - 
   * - ``std::variant<Series<numpy::float64>, DataFrame, std::monostate> eval( const std::string& expr, bool inplace = false, std::optional<std::map<std::string, double>> local_dict = std::nullopt, std::optional<std::map<std::string, double>> global_dict = std::nullopt, std::optional<std::vector<std::string>> resolvers = std::nullopt, int level = 0, std::optional<std::string> target = std::nullopt, const std::string& parser = "pandas", const std::string& engine = "")``
     - std::variant<Series<numpy::float64>, DataFrame, std::monostate>
     - pd_dataframe.h:9786
     - :ref:`View <example-dataframe-eval-446>`
   * - ``std::vector<double> eval_expression(const std::string& expr) const``
     - std::vector<double>
     - pd_dataframe.h:9907
     - 
   * - ``double eval_postfix(const std::vector<eval_internal::EvalToken>& postfix, size_t row) const``
     - double
     - pd_dataframe.h:9929
     - 
   * - ``bool evaluate_column_comparison(const query::ColumnComparisonNode\* cc, size_t row) const``
     - bool
     - pd_dataframe.h:9653
     - 
   * - ``bool evaluate_comparison(const query::ComparisonNode\* comp, size_t row) const``
     - bool
     - pd_dataframe.h:9623
     - 
   * - ``bool evaluate_membership(const query::MembershipNode\* mem, size_t row) const``
     - bool
     - pd_dataframe.h:9677
     - 
   * - ``bool evaluate_query_node(const query::ASTNode\* node, size_t row) const``
     - bool
     - pd_dataframe.h:9576
     - 
   * - ``evaluate_query_node(and_node->right.get(), row)``
     - 
     - pd_dataframe.h:9602
     - 
   * - ``evaluate_query_node(or_node->right.get(), row)``
     - 
     - pd_dataframe.h:9607
     - 
   * - ``Series<numpy::float64> extract_column_as_numeric_series(const std::string& key) const``
     - Series<numpy::float64>
     - pd_dataframe.h:3514
     - :ref:`View <example-dataframe-extract_column_as_numeric_series-447>`
   * - ``std::unique_ptr<NDFrameBase> extract_column_as_series_base( const std::string& key) const``
     - std::unique_ptr<NDFrameBase>
     - pd_dataframe.h:3556
     - 
   * - ``RowData extract_row_typed(size_t r) const``
     - RowData
     - pd_dataframe.h:2605
     - :ref:`View <example-dataframe-extract_row_typed-448>`
   * - ``std::ofstream file(path_or_buffer)``
     - std::ofstream
     - pd_dataframe.h:13582
     - :ref:`View <example-dataframe-file-449>`
   * - ``DataFrame filter(const std::vector<std::string>& items = {}, const std::string& like = "", const std::string& regex = "", int axis = 1) const``
     - DataFrame
     - pd_dataframe.h:13241
     - :ref:`View <example-dataframe-filter-450>`
   * - ``DataFrame filter_items(const std::vector<std::string>& items) const``
     - DataFrame
     - pd_dataframe.h:4225
     - 
   * - ``DataFrame filter_like(const std::string& like) const``
     - DataFrame
     - pd_dataframe.h:4232
     - 
   * - ``int find_column_by_datetime(int64_t ns_val) const``
     - int
     - pd_dataframe.h:1421
     - 
   * - ``static std::string find_smallest_int_dtype(double min_val, double max_val, bool prefer_signed)``
     - static std::string
     - pd_dataframe.h:22433
     - 
   * - ``const Flags& flags() const override``
     - const Flags&
     - pd_dataframe.h:1846
     - :ref:`View <example-dataframe-flags-451>`
   * - ``Flags& flags_mutable()``
     - Flags&
     - pd_dataframe.h:1853
     - 
   * - ``DataFrame floor() const``
     - DataFrame
     - pd_dataframe.h:20037
     - :ref:`View <example-dataframe-floor-452>`
   * - ``static std::vector<std::string> format_percentile_labels(const std::vector<double>& pcts)``
     - static std::vector<std::string>
     - pd_dataframe.h:10849
     - :ref:`View <example-dataframe-format_percentile_labels-453>`
   * - ``const std::string& frame_dtype_override() const``
     - const std::string&
     - pd_dataframe.h:21721
     - :ref:`View <example-dataframe-frame_dtype_override-454>`
   * - ``bool has_column(const std::string& name) const``
     - bool
     - pd_dataframe.h:3293
     - :ref:`View <example-dataframe-has_column-455>`
   * - ``bool has_columns_level_categories() const``
     - bool
     - pd_dataframe.h:1551
     - 
   * - ``bool has_columns_levels() const``
     - bool
     - pd_dataframe.h:1509
     - :ref:`View <example-dataframe-has_columns_levels-456>`
   * - ``bool has_multiindex() const``
     - bool
     - pd_dataframe.h:1344
     - :ref:`View <example-dataframe-has_multiindex-457>`
   * - ``bool hasnans() const override``
     - bool
     - pd_dataframe.h:7445
     - :ref:`View <example-dataframe-hasnans-458>`
   * - ``const IndexBase& index() const override``
     - const IndexBase&
     - pd_dataframe.h:1284
     - :ref:`View <example-dataframe-index-459>`
   * - ``IndexBase& index_mutable()``
     - IndexBase&
     - pd_dataframe.h:1291
     - 
   * - ``void index_name(const std::string& name)``
     - void
     - pd_dataframe.h:4797
     - :ref:`View <example-dataframe-index_name-460>`
   * - ``std::optional<std::string> index_name() const``
     - std::optional<std::string>
     - pd_dataframe.h:4800
     - :ref:`View <example-dataframe-index_name-461>`
   * - ``static std::string infer_best_dtype( const std::vector<std::string>& str_values, const std::string& source_dtype, bool convert_string, bool convert_integer, bool convert_boolean, bool convert_floating)``
     - static std::string
     - pd_dataframe.h:22658
     - 
   * - ``std::vector<std::vector<std::string>> inner(levels.begin() + 1, levels.end())``
     - std::vector<std::vector<std::string>>
     - pd_dataframe.h:16419
     - 
   * - ``std::vector<std::vector<std::string>> inner_orig(inner.size())``
     - std::vector<std::vector<std::string>>
     - pd_dataframe.h:16421
     - 
   * - ``void isetitem(size_t loc, const std::vector<T>& value)``
     - void
     - pd_dataframe.h:13320
     - :ref:`View <example-dataframe-isetitem-462>`
   * - ``std::istringstream iss(eval_expr)``
     - std::istringstream
     - pd_dataframe.h:9819
     - :ref:`View <example-dataframe-iss-463>`
   * - ``std::istringstream iss(label)``
     - std::istringstream
     - pd_dataframe.h:15557
     - :ref:`View <example-dataframe-iss-464>`
   * - ``std::istringstream iss(label)``
     - std::istringstream
     - pd_dataframe.h:15592
     - :ref:`View <example-dataframe-iss-465>`
   * - ``std::istringstream iss(key)``
     - std::istringstream
     - pd_dataframe.h:16565
     - :ref:`View <example-dataframe-iss-466>`
   * - ``std::istringstream iss(col_composite)``
     - std::istringstream
     - pd_dataframe.h:16905
     - :ref:`View <example-dataframe-iss-467>`
   * - ``std::istringstream iss(idx_val)``
     - std::istringstream
     - pd_dataframe.h:16936
     - :ref:`View <example-dataframe-iss-468>`
   * - ``std::istringstream iss(cn)``
     - std::istringstream
     - pd_dataframe.h:17309
     - :ref:`View <example-dataframe-iss-469>`
   * - ``std::vector<std::vector<std::string>> kept_stacked(stack_lvls.size())``
     - std::vector<std::vector<std::string>>
     - pd_dataframe.h:18572
     - 
   * - ``MultiIndexMatchResult match_multiindex_columns(const std::vector<std::string>& keys) const``
     - MultiIndexMatchResult
     - pd_dataframe.h:2937
     - :ref:`View <example-dataframe-match_multiindex_columns-470>`
   * - ``std::vector<std::vector<std::string>> mi_arrays(index.size())``
     - std::vector<std::vector<std::string>>
     - pd_dataframe.h:16931
     - 
   * - ``std::vector<std::vector<std::string>> mi_arrays(nlevels)``
     - std::vector<std::vector<std::string>>
     - pd_dataframe.h:17222
     - 
   * - ``size_t nbytes() const override``
     - size_t
     - pd_dataframe.h:1222
     - :ref:`View <example-dataframe-nbytes-471>`
   * - ``size_t ncols() const``
     - size_t
     - pd_dataframe.h:1263
     - :ref:`View <example-dataframe-ncols-472>`
   * - ``size_t ndim() const override``
     - size_t
     - pd_dataframe.h:1215
     - :ref:`View <example-dataframe-ndim-473>`
   * - ``static std::vector<double> normalize_percentiles(const std::vector<double>& percentiles)``
     - static std::vector<double>
     - pd_dataframe.h:10737
     - 
   * - ``size_t nrows() const``
     - size_t
     - pd_dataframe.h:1256
     - :ref:`View <example-dataframe-nrows-474>`
   * - ``numeric_aware_sort(unique_index_vals)``
     - 
     - pd_dataframe.h:16637
     - 
   * - ``numeric_aware_sort(unique_col_vals)``
     - 
     - pd_dataframe.h:16638
     - 
   * - ``query::QueryExpression parsed(expr)``
     - query::QueryExpression
     - pd_dataframe.h:9489
     - 
   * - ``propagate_index_to_series(s)``
     - 
     - pd_dataframe.h:3418
     - 
   * - ``propagate_index_to_series(s)``
     - 
     - pd_dataframe.h:3437
     - 
   * - ``propagate_index_to_series(s)``
     - 
     - pd_dataframe.h:3485
     - 
   * - ``propagate_index_to_series(s)``
     - 
     - pd_dataframe.h:3506
     - 
   * - ``propagate_index_to_series(s)``
     - 
     - pd_dataframe.h:3522
     - 
   * - ``void propagate_index_to_series(Series<T>& s) const``
     - void
     - pd_dataframe.h:3608
     - 
   * - ``propagate_index_to_series(result)``
     - 
     - pd_dataframe.h:3635
     - 
   * - ``oss << quote_field(columns_level_names_[lvl])``
     - oss <<
     - pd_dataframe.h:27293
     - 
   * - ``oss << quote_field(columns_levels_[lvl][col_indices[i]])``
     - oss <<
     - pd_dataframe.h:27299
     - 
   * - ``oss << quote_field(mi_names[idx_lvl].value())``
     - oss <<
     - pd_dataframe.h:27320
     - 
   * - ``oss << quote_field(resolve_idx_label())``
     - oss <<
     - pd_dataframe.h:27323
     - 
   * - ``oss << quote_field(mi_names[idx_lvl].value())``
     - oss <<
     - pd_dataframe.h:27338
     - 
   * - ``oss << quote_field(resolve_idx_label()) << sep``
     - oss <<
     - pd_dataframe.h:27345
     - 
   * - ``oss << quote_field(columns_index_.get_value_str(col_indices[i]))``
     - oss <<
     - pd_dataframe.h:27350
     - 
   * - ``oss << quote_field(tup[lvl]) << sep``
     - oss <<
     - pd_dataframe.h:27363
     - 
   * - ``oss << quote_field(index_->get_value_str(r)) << sep``
     - oss <<
     - pd_dataframe.h:27366
     - 
   * - ``oss << quote_field(na_rep)``
     - oss <<
     - pd_dataframe.h:27384
     - 
   * - ``oss << quote_field(apply_decimal(val))``
     - oss <<
     - pd_dataframe.h:27386
     - 
   * - ``oss << quote_field(apply_decimal(std::string(buf)))``
     - oss <<
     - pd_dataframe.h:27398
     - 
   * - ``oss << quote_field(apply_decimal(val_str))``
     - oss <<
     - pd_dataframe.h:27431
     - 
   * - ``oss << quote_field(na_rep)``
     - oss <<
     - pd_dataframe.h:27437
     - 
   * - ``oss << quote_field(apply_decimal(val))``
     - oss <<
     - pd_dataframe.h:27439
     - 
   * - ``std::regex re(regex)``
     - std::regex
     - pd_dataframe.h:13253
     - 
   * - ``std::regex re(regex)``
     - std::regex
     - pd_dataframe.h:13280
     - 
   * - ``int resolve_column_level(int level_int) const``
     - int
     - pd_dataframe.h:18436
     - :ref:`View <example-dataframe-resolve_column_level-475>`
   * - ``int resolve_column_level(const std::string& level_name) const``
     - int
     - pd_dataframe.h:18444
     - :ref:`View <example-dataframe-resolve_column_level-476>`
   * - ``size_t resolve_multiindex_exact_column(const std::vector<std::string>& key) const``
     - size_t
     - pd_dataframe.h:3038
     - 
   * - ``MultiIndexSortResolution resolve_sort_columns_multiindex( const std::vector<std::string>& by_cols) const``
     - MultiIndexSortResolution
     - pd_dataframe.h:14799
     - :ref:`View <example-dataframe-resolve_sort_columns_multiindex-477>`
   * - ``DataFrame round(int decimals = 0) const``
     - DataFrame
     - pd_dataframe.h:19987
     - :ref:`View <example-dataframe-round-478>`
   * - ``std::vector<numpy::object_> row_to_objects(size_t row) const``
     - std::vector<numpy::object_>
     - pd_dataframe.h:3841
     - 
   * - ``std::vector<double> row_values_f64(size_t row_idx) const``
     - std::vector<double>
     - pd_dataframe.h:2564
     - :ref:`View <example-dataframe-row_values_f64-479>`
   * - ``pandas::Series<T> s(casted)``
     - pandas::Series<T>
     - pd_dataframe.h:21157
     - :ref:`View <example-dataframe-s-480>`
   * - ``pandas::Series<T> s(casted)``
     - pandas::Series<T>
     - pd_dataframe.h:21526
     - :ref:`View <example-dataframe-s-481>`
   * - ``std::string s(buf)``
     - std::string
     - pd_dataframe.h:27537
     - :ref:`View <example-dataframe-s-482>`
   * - ``std::string s(buf)``
     - std::string
     - pd_dataframe.h:27566
     - :ref:`View <example-dataframe-s-483>`
   * - ``pandas::Series<std::complex<double>> s_cx(scalar_vals_cx)``
     - pandas::Series<std::complex<double>>
     - pd_dataframe.h:20938
     - 
   * - ``pandas::Series<std::complex<double>> s_cx(scalar_vals_cx)``
     - pandas::Series<std::complex<double>>
     - pd_dataframe.h:21068
     - 
   * - ``pandas::Series<numpy::datetime64> sdt(dt_vals)``
     - pandas::Series<numpy::datetime64>
     - pd_dataframe.h:21202
     - 
   * - ``pandas::Series<numpy::datetime64> sdt(dt_vals)``
     - pandas::Series<numpy::datetime64>
     - pd_dataframe.h:21568
     - 
   * - ``DataFrame select_columns_by_names(const std::vector<std::string>& names, bool multiindex_first_level_match = true) const``
     - DataFrame
     - pd_dataframe.h:2970
     - 
   * - ``DataFrame select_dtypes(const std::vector<std::string>& include = {}, const std::vector<std::string>& exclude = {}) const``
     - DataFrame
     - pd_dataframe.h:7315
     - :ref:`View <example-dataframe-select_dtypes-484>`
   * - ``DataFrame select_multiindex_columns(const std::vector<std::string>& first_level_keys) const``
     - DataFrame
     - pd_dataframe.h:2870
     - :ref:`View <example-dataframe-select_multiindex_columns-485>`
   * - ``DataFrame select_multiindex_partial(const std::vector<std::string>& key) const``
     - DataFrame
     - pd_dataframe.h:3088
     - 
   * - ``void set_attrs(const Attrs& attrs) override``
     - void
     - pd_dataframe.h:1839
     - 
   * - ``void set_column(const std::string& name, const Series<T>& series)``
     - void
     - pd_dataframe.h:6890
     - :ref:`View <example-dataframe-set_column-486>`
   * - ``void set_column_cat_categories(const std::string& col_name, const std::vector<std::string>& cats)``
     - void
     - pd_dataframe.h:1750
     - :ref:`View <example-dataframe-set_column_cat_categories-487>`
   * - ``void set_column_cat_ordered(const std::string& col_name, bool ordered)``
     - void
     - pd_dataframe.h:1760
     - :ref:`View <example-dataframe-set_column_cat_ordered-488>`
   * - ``void set_column_datetime_array(const std::string& col_name, std::shared_ptr<pandas::DatetimeArray> ea)``
     - void
     - pd_dataframe.h:1679
     - 
   * - ``set_column_datetime_array(col_name, ea)``
     - 
     - pd_dataframe.h:1744
     - 
   * - ``void set_column_datetime_ea(const std::string& col_name, const std::vector<std::optional<pandas::Timestamp>>& ts_vec, const std::string& uniform_tz = "")``
     - void
     - pd_dataframe.h:1739
     - :ref:`View <example-dataframe-set_column_datetime_ea-489>`
   * - ``void set_column_dtype(const std::string& col_name, const std::string& dtype_str)``
     - void
     - pd_dataframe.h:1622
     - :ref:`View <example-dataframe-set_column_dtype-490>`
   * - ``set_column_dtype(col_name, dt)``
     - 
     - pd_dataframe.h:26410
     - :ref:`View <example-dataframe-set_column_dtype-491>`
   * - ``void set_column_mask(const std::string& col_name, const numpy::NDArray<numpy::bool_>& mask)``
     - void
     - pd_dataframe.h:1640
     - 
   * - ``void set_column_mixed_tz_array(const std::string& col_name, std::shared_ptr<pandas::MixedTzDatetimeArray> ea)``
     - void
     - pd_dataframe.h:1712
     - 
   * - ``DataFrame& set_column_names(const std::vector<std::string>& new_names)``
     - DataFrame&
     - pd_dataframe.h:5247
     - :ref:`View <example-dataframe-set_column_names-492>`
   * - ``void set_column_resolved( const std::string& name, const ValueKindRange& kinds, const pandas::DtypeOverride& override_ = {})``
     - void
     - pd_dataframe.h:7061
     - :ref:`View <example-dataframe-set_column_resolved-493>`
   * - ``void set_column_sparse_fill_value(const std::string& col_name, double fv, const std::string& inner_name = "")``
     - void
     - pd_dataframe.h:1775
     - :ref:`View <example-dataframe-set_column_sparse_fill_value-494>`
   * - ``void set_columns_index_dtype(const std::string& dtype)``
     - void
     - pd_dataframe.h:1390
     - :ref:`View <example-dataframe-set_columns_index_dtype-495>`
   * - ``void set_columns_level_categories(std::vector<std::vector<std::string>> categories, std::vector<bool> ordered)``
     - void
     - pd_dataframe.h:1489
     - 
   * - ``void set_columns_levels(std::vector<std::vector<std::string>> levels, std::vector<std::string> names, std::vector<std::vector<std::string>> original_levels = {})``
     - void
     - pd_dataframe.h:1465
     - :ref:`View <example-dataframe-set_columns_levels-496>`
   * - ``void set_columns_name(const std::string& name)``
     - void
     - pd_dataframe.h:1378
     - :ref:`View <example-dataframe-set_columns_name-497>`
   * - ``void set_datetime_index(const std::string& start, int periods, const std::string& freq)``
     - void
     - pd_dataframe.h:4832
     - :ref:`View <example-dataframe-set_datetime_index-498>`
   * - ``void set_display_options(size_t width, size_t max_colwidth, size_t max_rows = 0, bool multi_sparse = true, size_t max_cols = 0, bool width_truncation = false)``
     - void
     - pd_dataframe.h:1439
     - :ref:`View <example-dataframe-set_display_options-499>`
   * - ``void set_flags(const Flags& flags, bool copy = true, bool allows_duplicate_labels = true) override``
     - void
     - pd_dataframe.h:1863
     - :ref:`View <example-dataframe-set_flags-500>`
   * - ``void set_frame_dtype_override(const std::string& v)``
     - void
     - pd_dataframe.h:21722
     - 
   * - ``void set_integer_index(std::initializer_list<int64_t> values)``
     - void
     - pd_dataframe.h:4773
     - :ref:`View <example-dataframe-set_integer_index-501>`
   * - ``void set_integer_index(std::initializer_list<int> values)``
     - void
     - pd_dataframe.h:4776
     - :ref:`View <example-dataframe-set_integer_index-502>`
   * - ``void set_multi_index( std::initializer_list<std::initializer_list<const char\*>> levels, const std::vector<std::optional<std::string>>& names = {})``
     - void
     - pd_dataframe.h:4808
     - :ref:`View <example-dataframe-set_multi_index-503>`
   * - ``void set_multi_index(const std::vector<std::vector<std::string>>& levels, const std::vector<std::optional<std::string>>& names = {})``
     - void
     - pd_dataframe.h:4820
     - :ref:`View <example-dataframe-set_multi_index-504>`
   * - ``void set_multiindex(MultiIndex mi)``
     - void
     - pd_dataframe.h:1298
     - :ref:`View <example-dataframe-set_multiindex-505>`
   * - ``void set_multiindex( std::initializer_list<std::initializer_list<const char\*>> levels, const std::vector<std::optional<std::string>>& names = {})``
     - void
     - pd_dataframe.h:1319
     - :ref:`View <example-dataframe-set_multiindex-506>`
   * - ``set_multiindex(MultiIndex::from_arrays<std::string>(arrays, names))``
     - 
     - pd_dataframe.h:1328
     - :ref:`View <example-dataframe-set_multiindex-507>`
   * - ``void set_multiindex( const std::vector<std::vector<std::string>>& levels, const std::vector<std::optional<std::string>>& names = {})``
     - void
     - pd_dataframe.h:1334
     - :ref:`View <example-dataframe-set_multiindex-508>`
   * - ``set_multiindex(MultiIndex::from_arrays<std::string>(levels, names))``
     - 
     - pd_dataframe.h:1338
     - :ref:`View <example-dataframe-set_multiindex-509>`
   * - ``set_multiindex(std::move(mi))``
     - 
     - pd_dataframe.h:4694
     - :ref:`View <example-dataframe-set_multiindex-510>`
   * - ``set_multiindex(MultiIndex::from_arrays<std::string>(arrays, names))``
     - 
     - pd_dataframe.h:4817
     - :ref:`View <example-dataframe-set_multiindex-511>`
   * - ``set_multiindex(MultiIndex::from_arrays<std::string>(levels, names))``
     - 
     - pd_dataframe.h:4823
     - :ref:`View <example-dataframe-set_multiindex-512>`
   * - ``void set_multiindex_names(const std::vector<std::optional<std::string>>& names)``
     - void
     - pd_dataframe.h:1368
     - :ref:`View <example-dataframe-set_multiindex_names-513>`
   * - ``void set_nan_marker(const std::string& col_name, std::initializer_list<bool> mask_init)``
     - void
     - pd_dataframe.h:4854
     - :ref:`View <example-dataframe-set_nan_marker-514>`
   * - ``void set_option(const std::string& key, bool value)``
     - void
     - pd_dataframe.h:1453
     - :ref:`View <example-dataframe-set_option-515>`
   * - ``void set_reduced_series_repr(const std::string& repr)``
     - void
     - pd_dataframe.h:1407
     - 
   * - ``void set_string_index(std::initializer_list<const char\*> values)``
     - void
     - pd_dataframe.h:4770
     - :ref:`View <example-dataframe-set_string_index-516>`
   * - ``static size_t setw_byte_target(const std::string& val, size_t target_codepoint_width)``
     - static size_t
     - pd_dataframe.h:10816
     - 
   * - ``std::vector<size_t> shape() const override``
     - std::vector<size_t>
     - pd_dataframe.h:1203
     - :ref:`View <example-dataframe-shape-517>`
   * - ``std::pair<size_t, size_t> shape_2d() const { return {nrows(), ncols()}``
     - std::pair<size_t, size_t>
     - pd_dataframe.h:1210
     - :ref:`View <example-dataframe-shape_2d-518>`
   * - ``size_t size() const override``
     - size_t
     - pd_dataframe.h:1189
     - :ref:`View <example-dataframe-size-519>`
   * - ``std::vector<std::vector<std::string>> sliced_arrays(mi.nlevels())``
     - std::vector<std::vector<std::string>>
     - pd_dataframe.h:3943
     - 
   * - ``std::vector<std::vector<std::string>> sorted_levels(columns_levels_.size())``
     - std::vector<std::vector<std::string>>
     - pd_dataframe.h:14978
     - 
   * - ``DataFrameSparseAccessor sparse() const``
     - DataFrameSparseAccessor
     - pd_dataframe.h:1899
     - :ref:`View <example-dataframe-sparse-520>`
   * - ``std::stringstream ss(to_split)``
     - std::stringstream
     - pd_dataframe.h:18002
     - :ref:`View <example-dataframe-ss-521>`
   * - ``static int64_t timedelta_unit_factor(const std::string& dt)``
     - static int64_t
     - pd_dataframe.h:7078
     - 
   * - ``trim(inner)``
     - 
     - pd_dataframe.h:22149
     - :ref:`View <example-dataframe-trim-522>`
   * - ``trim(fill_spelled)``
     - 
     - pd_dataframe.h:22150
     - :ref:`View <example-dataframe-trim-523>`
   * - ``DataFrame truncate(const std::optional<std::string>& before = std::nullopt, const std::optional<std::string>& after = std::nullopt, int axis = 0, bool copy = true) const``
     - DataFrame
     - pd_dataframe.h:27012
     - :ref:`View <example-dataframe-truncate-524>`
   * - ``pandas::Timestamp ts(columns_index_[i])``
     - pandas::Timestamp
     - pd_dataframe.h:1428
     - :ref:`View <example-dataframe-ts-525>`
   * - ``static size_t unicode_display_width(const std::string& s)``
     - static size_t
     - pd_dataframe.h:10798
     - 
   * - ``numpy::NDArray<numpy::float64> values() const``
     - numpy::NDArray<numpy::float64>
     - pd_dataframe.h:1810
     - :ref:`View <example-dataframe-values-526>`


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

The following examples are extracted from the test suite.

.. _example-dataframe-dataframe-0:

.. dropdown:: DataFrame (pd_test_1_all.cpp:22011)
   :class-title: example-dropdown

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

      
              void pd_test_where_basic() {
                  std::cout << "========= where basic functionality =======================";
      
                  // Create DataFrame
                  std::map<std::string, std::vector<double>> data;
                  data["A"] = {1.0, 2.0, 3.0, 4.0};
                  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");

.. _example-dataframe-dataframe-1:

.. dropdown:: DataFrame (pd_test_1_all.cpp:22011)
   :class-title: example-dropdown

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

      
              void pd_test_where_basic() {
                  std::cout << "========= where basic functionality =======================";
      
                  // Create DataFrame
                  std::map<std::string, std::vector<double>> data;
                  data["A"] = {1.0, 2.0, 3.0, 4.0};
                  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");

.. _example-dataframe-dataframe-2:

.. dropdown:: DataFrame (pd_test_1_all.cpp:22011)
   :class-title: example-dropdown

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

      
              void pd_test_where_basic() {
                  std::cout << "========= where basic functionality =======================";
      
                  // Create DataFrame
                  std::map<std::string, std::vector<double>> data;
                  data["A"] = {1.0, 2.0, 3.0, 4.0};
                  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");

.. _example-dataframe-dataframe-3:

.. dropdown:: DataFrame (pd_test_1_all.cpp:22011)
   :class-title: example-dropdown

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

      
              void pd_test_where_basic() {
                  std::cout << "========= where basic functionality =======================";
      
                  // Create DataFrame
                  std::map<std::string, std::vector<double>> data;
                  data["A"] = {1.0, 2.0, 3.0, 4.0};
                  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");

.. _example-dataframe-dataframe-4:

.. dropdown:: DataFrame (pd_test_1_all.cpp:22011)
   :class-title: example-dropdown

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

      
              void pd_test_where_basic() {
                  std::cout << "========= where basic functionality =======================";
      
                  // Create DataFrame
                  std::map<std::string, std::vector<double>> data;
                  data["A"] = {1.0, 2.0, 3.0, 4.0};
                  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");

.. _example-dataframe-dataframe-5:

.. dropdown:: DataFrame (pd_test_1_all.cpp:22011)
   :class-title: example-dropdown

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

      
              void pd_test_where_basic() {
                  std::cout << "========= where basic functionality =======================";
      
                  // Create DataFrame
                  std::map<std::string, std::vector<double>> data;
                  data["A"] = {1.0, 2.0, 3.0, 4.0};
                  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");

.. _example-dataframe-dataframe-6:

.. dropdown:: DataFrame (pd_test_1_all.cpp:22011)
   :class-title: example-dropdown

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

      
              void pd_test_where_basic() {
                  std::cout << "========= where basic functionality =======================";
      
                  // Create DataFrame
                  std::map<std::string, std::vector<double>> data;
                  data["A"] = {1.0, 2.0, 3.0, 4.0};
                  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");

.. _example-dataframe-at-7:

.. dropdown:: at (pd_test_1_all.cpp:6581)
   :class-title: example-dropdown

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

                  // Test isna/notna with float data
                  {
                      std::map<std::string, std::vector<numpy::float64>> float_data;
                      float_data["X"] = {1.0, std::nan(""), 3.0};
                      float_data["Y"] = {4.0, 5.0, std::nan("")};
                      pandas::DataFrame df_na(float_data);
      
                      auto na_mask = df_na.isna();
                      // Row 1, col 0 (X) should be NA
                      if (!na_mask.getElementAt({1, 0})) {
                          std::cout << "  [FAIL] : in pd_test_dataframe_manipulation() : isna at (1,0) should be true" << std::endl;
                          throw std::runtime_error("pd_test_dataframe_manipulation failed: isna at (1,0)");
                      }
                      // Row 2, col 1 (Y) should be NA
                      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;

.. _example-dataframe-at_time-8:

.. dropdown:: at_time (pd_test_2_all.cpp:728)
   :class-title: example-dropdown

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

      
              std::cout << "====================================== [OK] pd_test_asof test suite ========================== " << std::endl;
              return 0;
          }
      
      } // namespace dataframe_tests
      // ------------------- pd_test_asof.cpp (end) -----------------------------
      
      // ------------------- pd_test_at_time.cpp (start) -----------------------------
      // dataframe_tests/pd_test_at_time.cpp
      // Tests for DataFrame.at_time() method (pandas 2.0+ API)
      // Selects values at particular time of day from datetime-indexed DataFrame
      #include <iostream>
      #include <stdexcept>
      #include <vector>
      #include <string>
      #include <map>
      #include "../pandas/pd_dataframe.h"
      
      // CRITICAL: No using namespace directives
      

.. _example-dataframe-attrs-9:

.. dropdown:: attrs (pd_test_1_all.cpp:16361)
   :class-title: example-dropdown

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

              // =====================================================================
              // Series Attrs Integration Tests
              // =====================================================================
      
              void pd_test_ndframe_series_attrs() {
                  std::cout << "========= series attrs integration =============================" << std::endl;
      
                  pandas::Series<double> s({1.0, 2.0, 3.0});
      
                  // Test setting attrs on Series
                  s.attrs().set("source", std::string("test_data"));
                  s.attrs().set("timestamp", 1234567890);
      
                  bool passed = s.attrs().get<std::string>("source") == "test_data";
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_ndframe_series_attrs() : set/get source" << std::endl;
                      throw std::runtime_error("pd_test_ndframe_series_attrs failed: set/get source");
                  }
      
                  passed = s.attrs().get<int>("timestamp") == 1234567890;
                  if (!passed) {

.. _example-dataframe-attrs-10:

.. dropdown:: attrs (pd_test_1_all.cpp:16361)
   :class-title: example-dropdown

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

              // =====================================================================
              // Series Attrs Integration Tests
              // =====================================================================
      
              void pd_test_ndframe_series_attrs() {
                  std::cout << "========= series attrs integration =============================" << std::endl;
      
                  pandas::Series<double> s({1.0, 2.0, 3.0});
      
                  // Test setting attrs on Series
                  s.attrs().set("source", std::string("test_data"));
                  s.attrs().set("timestamp", 1234567890);
      
                  bool passed = s.attrs().get<std::string>("source") == "test_data";
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_ndframe_series_attrs() : set/get source" << std::endl;
                      throw std::runtime_error("pd_test_ndframe_series_attrs failed: set/get source");
                  }
      
                  passed = s.attrs().get<int>("timestamp") == 1234567890;
                  if (!passed) {

.. _example-dataframe-first-11:

.. dropdown:: first (pd_test_1_all.cpp:11616)
   :class-title: example-dropdown

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

      
              void pd_test_groupby_first_last() {
                  std::cout << "========= GroupBy first/last ====================";
      
                  std::map<std::string, std::vector<double>> data = {
                      {"category", {1.0, 1.0, 2.0, 2.0}},
                      {"value", {10.0, 20.0, 30.0, 40.0}}
                  };
                  pandas::DataFrame df(data);
      
                  auto first_result = df.groupby("category").first();
                  auto last_result = df.groupby("category").last();
      
                  // First for group 1: 10, group 2: 30
                  // Last for group 1: 20, group 2: 40
                  double first1 = std::stod(first_result["value"].get_value_str(0));
                  double first2 = std::stod(first_result["value"].get_value_str(1));
      
                  bool passed = ((std::abs(first1 - 10.0) < 0.001 && std::abs(first2 - 30.0) < 0.001) ||
                                (std::abs(first1 - 30.0) < 0.001 && std::abs(first2 - 10.0) < 0.001));
                  if (!passed) {

.. _example-dataframe-first_valid_index-12:

.. dropdown:: first_valid_index (pd_test_1_all.cpp:20555)
   :class-title: example-dropdown

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

      
                  std::vector<double> values = {
                      std::numeric_limits<double>::quiet_NaN(),
                      std::numeric_limits<double>::quiet_NaN(),
                      3.0,
                      4.0,
                      5.0
                  };
                  pandas::Series<double> s(values, "test");
      
                  auto first_idx = s.first_valid_index();
      
                  bool passed = first_idx.has_value() && first_idx.value() == 2;
      
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_timeseries_first_valid_index() : expected index 2" << std::endl;
                      throw std::runtime_error("pd_test_timeseries_first_valid_index failed");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }

.. _example-dataframe-get-13:

.. dropdown:: get (pd_test_1_all.cpp:10290)
   :class-title: example-dropdown

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

      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 &&
                         std::get<size_t>(loc_cherry) == 2);
          if (!passed) {
              std::cout << "  [FAIL] : in pd_test_extension_index_get_loc_unique() : get_loc check failed" << std::endl;
              throw std::runtime_error("pd_test_extension_index_get_loc_unique failed");
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      

.. _example-dataframe-get_column_as_series-14:

.. dropdown:: get_column_as_series (pd_test_5_all.cpp:123545)
   :class-title: example-dropdown

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

          auto tuples = mi.to_list();
          if (tuples.size() != nrows) {
              throw std::runtime_error(
                  "format_extractall: MultiIndex size " + std::to_string(tuples.size()) +
                  " != DataFrame nrows " + std::to_string(nrows));
          }
          // Pre-extract each column's string values to avoid repeated lookups.
          std::vector<std::vector<std::string>> col_values;
          col_values.reserve(ncols);
          for (size_t c = 0; c < ncols; ++c) {
              auto s = df.template get_column_as_series<std::string>(c);
              std::vector<std::string> vals;
              vals.reserve(s.size());
              for (size_t r = 0; r < s.size(); ++r) vals.push_back(s.at(r));
              col_values.push_back(std::move(vals));
          }
          for (size_t r = 0; r < nrows; ++r) {
              oss << "\n";
              // tuples[r] is a vector<string> of length 2.
              oss << tuples[r][0] << "," << tuples[r][1];
              for (size_t c = 0; c < ncols; ++c) {

.. _example-dataframe-get_column_as_string_series-15:

.. dropdown:: get_column_as_string_series (pd_test_2_all.cpp:20370)
   :class-title: example-dropdown

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

      void pd_test_getitem_dispatch_category_metadata() {
          std::cout << "pd_test_getitem_dispatch_category_metadata" << std::endl;
          pandas::DataFrame df;
          std::vector<std::string> svals = {"a", "b", "a", "c"};
          auto cs = std::make_unique<pandas::Series<std::string>>(svals, "cat");
          cs->set_dtype_override("category");
          cs->set_cat_categories({"a", "b", "c"});
          cs->set_cat_ordered(true);
          df.insert(0, "cat", std::move(cs), true);
      
          auto s = df.get_column_as_string_series("cat");
          check(s.dtype_name() == "category", "cat dtype");
          check(s.has_cat_categories(), "cat has_categories");
          check(s.cat_ordered() == true, "cat ordered");
          auto cats = s.get_cat_categories();
          check(cats.size() == 3, "cat categories size");
          std::set<std::string> cat_set(cats.begin(), cats.end());
          check(cat_set.count("a") && cat_set.count("b") && cat_set.count("c"), "cat categories content");
      }
      
      void pd_test_getitem_dispatch_index_propagation() {

.. _example-dataframe-get_column_index-16:

.. dropdown:: get_column_index (pd_test_1_all.cpp:22021)
   :class-title: example-dropdown

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

                  // 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";
                  std::string a1 = result.iat<double>(1, col_a_idx) == -1.0 ? "ok" : "fail";
                  std::string a2 = result.iat<double>(2, col_a_idx) == 3.0 ? "ok" : "fail";
                  std::string a3 = result.iat<double>(3, col_a_idx) == 4.0 ? "ok" : "fail";

.. _example-dataframe-get_dummies-17:

.. dropdown:: get_dummies (pd_test_3_all.cpp:13545)
   :class-title: example-dropdown

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

          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      // ============================================================================
      // Get Dummies / From Dummies Tests
      // ============================================================================
      
      void pd_test_top_level_get_dummies() {
          std::cout << "========= get_dummies() ===============================";
      
          std::vector<std::string> data = {"A", "B", "A", "C", "B", "A"};
          pandas::Series<std::string> s(data, "category");
      
          pandas::DataFrame result = pandas::get_dummies(s);
      
          // Should have columns for A, B, C
          if (result.ncols() != 3) {
              std::cout << "  [FAIL] : in pd_test_top_level_get_dummies() : expected 3 columns" << std::endl;
              throw std::runtime_error("pd_test_top_level_get_dummies failed: wrong column count");

.. _example-dataframe-get_duplicate_columns-18:

.. dropdown:: get_duplicate_columns (pd_test_2_all.cpp:20352)
   :class-title: example-dropdown

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

      }
      
      void pd_test_getitem_dispatch_get_duplicates() {
          std::cout << "pd_test_getitem_dispatch_get_duplicates" << std::endl;
          pandas::DataFrame df;
          std::vector<numpy::float64> v1 = {1.0, 2.0, 3.0};
          std::vector<numpy::float64> v2 = {4.0, 5.0, 6.0};
          df.insert(0, "col", std::make_unique<pandas::Series<numpy::float64>>(v1, "col"), true);
          df.insert(1, "col", std::make_unique<pandas::Series<numpy::float64>>(v2, "col"), true);
      
          auto sub = df.get_duplicate_columns("col");
          check(sub.ncols() == 2, "dup ncols");
          check(sub.nrows() == 3, "dup nrows");
          // Both columns named "col"
          check(sub.columns().get_value_str(0) == "col", "dup col0 name");
          check(sub.columns().get_value_str(1) == "col", "dup col1 name");
      }
      
      void pd_test_getitem_dispatch_category_metadata() {
          std::cout << "pd_test_getitem_dispatch_category_metadata" << std::endl;
          pandas::DataFrame df;

.. _example-dataframe-get_optional-19:

.. dropdown:: get_optional (pd_test_1_all.cpp:6741)
   :class-title: example-dropdown

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

                          throw std::runtime_error("pd_test_dataframe_index_ops failed: reindex cols");
                      }
                  }
      
                  // Test get_optional
                  {
                      std::map<std::string, std::vector<int>> data;
                      data["A"] = {1, 2, 3};
                      pandas::DataFrame df(data);
      
                      auto col_opt = df.get_optional("A");
                      if (!col_opt.has_value()) {
                          std::cout << "  [FAIL] : in pd_test_dataframe_index_ops() : get_optional A should exist" << std::endl;
                          throw std::runtime_error("pd_test_dataframe_index_ops failed: get_optional A");
                      }
      
                      auto missing = df.get_optional("Z");
                      if (missing.has_value()) {
                          std::cout << "  [FAIL] : in pd_test_dataframe_index_ops() : get_optional Z should not exist" << std::endl;
                          throw std::runtime_error("pd_test_dataframe_index_ops failed: get_optional Z");
                      }

.. _example-dataframe-get_series-20:

.. dropdown:: get_series (pd_test_5_all.cpp:12970)
   :class-title: example-dropdown

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

              pandas_tests::check(!threw, "query_bool_and_numeric.no_throw", local_fail);
              if (!threw) {
                  pandas_tests::check(result.nrows() == 1, "query_bool_and_numeric.nrows == 1 (got " + std::to_string(result.nrows()) + ")", local_fail);
              }
          }
      
          // === xs_level tests (Error 2) ===
          // Note: xs_level() doesn't exist yet — test will verify it after implementation
      
          // === get_series + unstack tests (Error 1) ===
          // Note: get_series<T>() doesn't exist yet — test will verify it after implementation
      
          if (local_fail > 0) {
              std::cout << "  [FAIL] : in f_test_anal_i_query_bool_unstack() : " << local_fail << " checks failed" << std::endl;
              throw std::runtime_error("f_test_anal_i_query_bool_unstack failed");
          }
          std::cout << " -> tests passed" << std::endl;
      }
      
      
      // --- cpp_f_test_zanal_a_column_width.cpp ---

.. _example-dataframe-get_value_bool-21:

.. dropdown:: get_value_bool (pd_test_5_all.cpp:35197)
   :class-title: example-dropdown

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

          df.add_column_nullable<bool>("X", {true, pandas::NA_BOOL, false});
          pandas_tests::check(df["X"].get_value_double(0) == 1.0, "case_2.idx0_one", local_fail);
          pandas_tests::check(std::isnan(df["X"].get_value_double(1)),
                              "case_2.idx1_nan", local_fail);
          pandas_tests::check(df["X"].get_value_double(2) == 0.0, "case_2.idx2_zero", local_fail);
      }
      
      void bool_nullable_826495_case_3_get_value_bool_mask_aware(int& local_fail) {
          pandas::DataFrame df;
          df.add_column_nullable<bool>("X", {true, pandas::NA_BOOL, false});
          pandas_tests::check(df["X"].get_value_bool(0) == true,  "case_3.idx0_true",   local_fail);
          pandas_tests::check(df["X"].get_value_bool(1) == false, "case_3.idx1_NA_false", local_fail);
          pandas_tests::check(df["X"].get_value_bool(2) == false, "case_3.idx2_false",  local_fail);
      }
      
      void bool_nullable_826495_case_4_is_na_at_mask_aware(int& local_fail) {
          pandas::DataFrame df;
          df.add_column_nullable<bool>("X", {true, pandas::NA_BOOL, false});
          pandas_tests::check(df["X"].is_na_at(0) == false, "case_4.idx0_not_na", local_fail);
          pandas_tests::check(df["X"].is_na_at(1) == true,  "case_4.idx1_is_na",  local_fail);
          pandas_tests::check(df["X"].is_na_at(2) == false, "case_4.idx2_not_na", local_fail);

.. _example-dataframe-head-22:

.. dropdown:: head (pd_test_1_all.cpp:6301)
   :class-title: example-dropdown

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

              void pd_test_dataframe_indexing() {
                  std::cout << "========= indexing (loc/iloc) ==============";
      
                  std::map<std::string, std::vector<numpy::float64>> data;
                  data["A"] = {10.0, 20.0, 30.0, 40.0, 50.0};
                  data["B"] = {1.0, 2.0, 3.0, 4.0, 5.0};
      
                  pandas::DataFrame df(data);
      
                  // Test head
                  auto head_df = df.head(3);
                  if (head_df.nrows() != 3) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_indexing() : head(3) nrows != 3" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_indexing failed: head(3) nrows != 3");
                  }
      
                  // Test tail
                  auto tail_df = df.tail(2);
                  if (tail_df.nrows() != 2) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_indexing() : tail(2) nrows != 2" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_indexing failed: tail(2) nrows != 2");

.. _example-dataframe-iat-23:

.. dropdown:: iat (pd_test_1_all.cpp:22028)
   :class-title: example-dropdown

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

                  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";
                  std::string a1 = result.iat<double>(1, col_a_idx) == -1.0 ? "ok" : "fail";
                  std::string a2 = result.iat<double>(2, col_a_idx) == 3.0 ? "ok" : "fail";
                  std::string a3 = result.iat<double>(3, col_a_idx) == 4.0 ? "ok" : "fail";
      
                  if (a0 != "ok" || a1 != "ok" || a2 != "ok" || a3 != "ok") {
                      passed = false;
                      error_msg = "Column A values incorrect: A[0]=" + a0 + ", A[1]=" + a1 +
                                  ", A[2]=" + a2 + ", A[3]=" + a3;
                  }
      

.. _example-dataframe-idxmax-24:

.. dropdown:: idxmax (pd_test_1_all.cpp:23956)
   :class-title: example-dropdown

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

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

.. _example-dataframe-idxmin-25:

.. dropdown:: idxmin (pd_test_1_all.cpp:23956)
   :class-title: example-dropdown

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

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

.. _example-dataframe-iloc-26:

.. dropdown:: iloc (pd_test_1_all.cpp:19149)
   :class-title: example-dropdown

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

                  pandas::Series<int> s({10, 20, 30, 40, 50});
      
                  // Positional indexing
                  bool passed = s[0] == 10 && s[4] == 50 && s.at(2) == 30;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_series_indexing() : positional indexing failed" << std::endl;
                      throw std::runtime_error("pd_test_series_indexing failed: positional indexing");
                  }
      
                  // iloc slice
                  auto slice = s.iloc(1, 4);
                  passed = slice.size() == 3 && slice[0] == 20 && slice[2] == 40;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_series_indexing() : iloc slice failed" << std::endl;
                      throw std::runtime_error("pd_test_series_indexing failed: iloc slice");
                  }
      
                  // iloc with indices
                  auto selected = s.iloc({0, 2, 4});
                  passed = selected.size() == 3 && selected[0] == 10 && selected[1] == 30 && selected[2] == 50;
                  if (!passed) {

.. _example-dataframe-iloc-27:

.. dropdown:: iloc (pd_test_1_all.cpp:19149)
   :class-title: example-dropdown

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

                  pandas::Series<int> s({10, 20, 30, 40, 50});
      
                  // Positional indexing
                  bool passed = s[0] == 10 && s[4] == 50 && s.at(2) == 30;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_series_indexing() : positional indexing failed" << std::endl;
                      throw std::runtime_error("pd_test_series_indexing failed: positional indexing");
                  }
      
                  // iloc slice
                  auto slice = s.iloc(1, 4);
                  passed = slice.size() == 3 && slice[0] == 20 && slice[2] == 40;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_series_indexing() : iloc slice failed" << std::endl;
                      throw std::runtime_error("pd_test_series_indexing failed: iloc slice");
                  }
      
                  // iloc with indices
                  auto selected = s.iloc({0, 2, 4});
                  passed = selected.size() == 3 && selected[0] == 10 && selected[1] == 30 && selected[2] == 50;
                  if (!passed) {

.. _example-dataframe-iloc-28:

.. dropdown:: iloc (pd_test_1_all.cpp:19149)
   :class-title: example-dropdown

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

                  pandas::Series<int> s({10, 20, 30, 40, 50});
      
                  // Positional indexing
                  bool passed = s[0] == 10 && s[4] == 50 && s.at(2) == 30;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_series_indexing() : positional indexing failed" << std::endl;
                      throw std::runtime_error("pd_test_series_indexing failed: positional indexing");
                  }
      
                  // iloc slice
                  auto slice = s.iloc(1, 4);
                  passed = slice.size() == 3 && slice[0] == 20 && slice[2] == 40;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_series_indexing() : iloc slice failed" << std::endl;
                      throw std::runtime_error("pd_test_series_indexing failed: iloc slice");
                  }
      
                  // iloc with indices
                  auto selected = s.iloc({0, 2, 4});
                  passed = selected.size() == 3 && selected[0] == 10 && selected[1] == 30 && selected[2] == 50;
                  if (!passed) {

.. _example-dataframe-iloc_rows-29:

.. dropdown:: iloc_rows (pd_test_1_all.cpp:6315)
   :class-title: example-dropdown

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

                  }
      
                  // Test tail
                  auto tail_df = df.tail(2);
                  if (tail_df.nrows() != 2) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_indexing() : tail(2) nrows != 2" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_indexing failed: tail(2) nrows != 2");
                  }
      
                  // Test iloc_rows range
                  auto slice = df.iloc_rows(1, 4);
                  if (slice.nrows() != 3) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_indexing() : iloc_rows(1,4) nrows != 3" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_indexing failed: iloc_rows(1,4) nrows != 3");
                  }
      
                  // Test iloc_rows with indices
                  auto selected = df.iloc_rows(std::vector<size_t>{0, 2, 4});
                  if (selected.nrows() != 3) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_indexing() : iloc_rows vector nrows != 3" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_indexing failed: iloc_rows vector nrows != 3");

.. _example-dataframe-iloc_rows-30:

.. dropdown:: iloc_rows (pd_test_1_all.cpp:6315)
   :class-title: example-dropdown

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

                  }
      
                  // Test tail
                  auto tail_df = df.tail(2);
                  if (tail_df.nrows() != 2) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_indexing() : tail(2) nrows != 2" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_indexing failed: tail(2) nrows != 2");
                  }
      
                  // Test iloc_rows range
                  auto slice = df.iloc_rows(1, 4);
                  if (slice.nrows() != 3) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_indexing() : iloc_rows(1,4) nrows != 3" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_indexing failed: iloc_rows(1,4) nrows != 3");
                  }
      
                  // Test iloc_rows with indices
                  auto selected = df.iloc_rows(std::vector<size_t>{0, 2, 4});
                  if (selected.nrows() != 3) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_indexing() : iloc_rows vector nrows != 3" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_indexing failed: iloc_rows vector nrows != 3");

.. _example-dataframe-last-31:

.. dropdown:: last (pd_test_1_all.cpp:11617)
   :class-title: example-dropdown

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

              void pd_test_groupby_first_last() {
                  std::cout << "========= GroupBy first/last ====================";
      
                  std::map<std::string, std::vector<double>> data = {
                      {"category", {1.0, 1.0, 2.0, 2.0}},
                      {"value", {10.0, 20.0, 30.0, 40.0}}
                  };
                  pandas::DataFrame df(data);
      
                  auto first_result = df.groupby("category").first();
                  auto last_result = df.groupby("category").last();
      
                  // First for group 1: 10, group 2: 30
                  // Last for group 1: 20, group 2: 40
                  double first1 = std::stod(first_result["value"].get_value_str(0));
                  double first2 = std::stod(first_result["value"].get_value_str(1));
      
                  bool passed = ((std::abs(first1 - 10.0) < 0.001 && std::abs(first2 - 30.0) < 0.001) ||
                                (std::abs(first1 - 30.0) < 0.001 && std::abs(first2 - 10.0) < 0.001));
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_groupby_first_last() : first values incorrect" << std::endl;

.. _example-dataframe-last_valid_index-32:

.. dropdown:: last_valid_index (pd_test_1_all.cpp:20579)
   :class-title: example-dropdown

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

      
                  std::vector<double> values = {
                      1.0,
                      2.0,
                      3.0,
                      std::numeric_limits<double>::quiet_NaN(),
                      std::numeric_limits<double>::quiet_NaN()
                  };
                  pandas::Series<double> s(values, "test");
      
                  auto last_idx = s.last_valid_index();
      
                  bool passed = last_idx.has_value() && last_idx.value() == 2;
      
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_timeseries_last_valid_index() : expected index 2" << std::endl;
                      throw std::runtime_error("pd_test_timeseries_last_valid_index failed");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }

.. _example-dataframe-loc-33:

.. dropdown:: loc (pd_test_3_all.cpp:10916)
   :class-title: example-dropdown

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

              {{"A","A","B"}, {"x","y","x"}});
          df.set_index(mi);
          if (!df.has_multiindex() || df.multiindex().nlevels() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_set_index_multiindex()" << std::endl;
              throw std::runtime_error("set_index MultiIndex failed");
          }
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_loc_single_arg() {
          std::cout << "========= Fix 3: loc(string) MultiIndex =================";
          pandas::DataFrame df;
          df.add_column<int64_t>("val", {10, 20, 30, 40});
          auto mi = pandas::MultiIndex::from_arrays<std::string>(
              {{"London","London","Paris","Paris"}, {"2020","2021","2020","2021"}});
          df.set_multiindex(mi);
          pandas::DataFrame result = df.loc("London");
          if (result.nrows() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_loc_single_arg() : expected 2 rows" << std::endl;
              throw std::runtime_error("loc single-arg failed");
          }

.. _example-dataframe-loc-34:

.. dropdown:: loc (pd_test_3_all.cpp:10916)
   :class-title: example-dropdown

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

              {{"A","A","B"}, {"x","y","x"}});
          df.set_index(mi);
          if (!df.has_multiindex() || df.multiindex().nlevels() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_set_index_multiindex()" << std::endl;
              throw std::runtime_error("set_index MultiIndex failed");
          }
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_loc_single_arg() {
          std::cout << "========= Fix 3: loc(string) MultiIndex =================";
          pandas::DataFrame df;
          df.add_column<int64_t>("val", {10, 20, 30, 40});
          auto mi = pandas::MultiIndex::from_arrays<std::string>(
              {{"London","London","Paris","Paris"}, {"2020","2021","2020","2021"}});
          df.set_multiindex(mi);
          pandas::DataFrame result = df.loc("London");
          if (result.nrows() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_loc_single_arg() : expected 2 rows" << std::endl;
              throw std::runtime_error("loc single-arg failed");
          }

.. _example-dataframe-loc-35:

.. dropdown:: loc (pd_test_3_all.cpp:10916)
   :class-title: example-dropdown

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

              {{"A","A","B"}, {"x","y","x"}});
          df.set_index(mi);
          if (!df.has_multiindex() || df.multiindex().nlevels() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_set_index_multiindex()" << std::endl;
              throw std::runtime_error("set_index MultiIndex failed");
          }
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_loc_single_arg() {
          std::cout << "========= Fix 3: loc(string) MultiIndex =================";
          pandas::DataFrame df;
          df.add_column<int64_t>("val", {10, 20, 30, 40});
          auto mi = pandas::MultiIndex::from_arrays<std::string>(
              {{"London","London","Paris","Paris"}, {"2020","2021","2020","2021"}});
          df.set_multiindex(mi);
          pandas::DataFrame result = df.loc("London");
          if (result.nrows() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_loc_single_arg() : expected 2 rows" << std::endl;
              throw std::runtime_error("loc single-arg failed");
          }

.. _example-dataframe-loc-36:

.. dropdown:: loc (pd_test_3_all.cpp:10916)
   :class-title: example-dropdown

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

              {{"A","A","B"}, {"x","y","x"}});
          df.set_index(mi);
          if (!df.has_multiindex() || df.multiindex().nlevels() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_set_index_multiindex()" << std::endl;
              throw std::runtime_error("set_index MultiIndex failed");
          }
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_loc_single_arg() {
          std::cout << "========= Fix 3: loc(string) MultiIndex =================";
          pandas::DataFrame df;
          df.add_column<int64_t>("val", {10, 20, 30, 40});
          auto mi = pandas::MultiIndex::from_arrays<std::string>(
              {{"London","London","Paris","Paris"}, {"2020","2021","2020","2021"}});
          df.set_multiindex(mi);
          pandas::DataFrame result = df.loc("London");
          if (result.nrows() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_loc_single_arg() : expected 2 rows" << std::endl;
              throw std::runtime_error("loc single-arg failed");
          }

.. _example-dataframe-loc-37:

.. dropdown:: loc (pd_test_3_all.cpp:10916)
   :class-title: example-dropdown

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

              {{"A","A","B"}, {"x","y","x"}});
          df.set_index(mi);
          if (!df.has_multiindex() || df.multiindex().nlevels() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_set_index_multiindex()" << std::endl;
              throw std::runtime_error("set_index MultiIndex failed");
          }
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_loc_single_arg() {
          std::cout << "========= Fix 3: loc(string) MultiIndex =================";
          pandas::DataFrame df;
          df.add_column<int64_t>("val", {10, 20, 30, 40});
          auto mi = pandas::MultiIndex::from_arrays<std::string>(
              {{"London","London","Paris","Paris"}, {"2020","2021","2020","2021"}});
          df.set_multiindex(mi);
          pandas::DataFrame result = df.loc("London");
          if (result.nrows() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_loc_single_arg() : expected 2 rows" << std::endl;
              throw std::runtime_error("loc single-arg failed");
          }

.. _example-dataframe-mask-38:

.. dropdown:: mask (pd_test_1_all.cpp:9119)
   :class-title: example-dropdown

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

      
      void pd_test_datetime_mixin_array_constructor() {
          std::cout << "========= DatetimeTDMixin array constructor =========================";
      
          // Create DatetimeArray with some values
          numpy::NDArray<numpy::datetime64> data(std::vector<size_t>{3});
          data.setElementAt({0}, numpy::datetime64(1000000000000000000LL, numpy::DateTimeUnit::Nanosecond));  // ~2001
          data.setElementAt({1}, numpy::datetime64(1500000000000000000LL, numpy::DateTimeUnit::Nanosecond));  // ~2017
          data.setElementAt({2}, numpy::datetime64(1600000000000000000LL, numpy::DateTimeUnit::Nanosecond));  // ~2020
      
          numpy::NDArray<numpy::bool_> mask(std::vector<size_t>{3});
          mask.setElementAt({0}, numpy::bool_(false));
          mask.setElementAt({1}, numpy::bool_(false));
          mask.setElementAt({2}, numpy::bool_(false));
      
          pandas::DatetimeArray arr(data, mask);
          pandas::DatetimeTDMixin idx(arr, "timestamps");
      
          bool passed = (idx.size() == 3 && !idx.empty() &&
                         idx.name().has_value() && *idx.name() == "timestamps" &&
                         idx.inferred_type() == "datetime");

.. _example-dataframe-nlargest-39:

.. dropdown:: nlargest (pd_test_1_all.cpp:6425)
   :class-title: example-dropdown

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

      
                  // Test sort_values descending
                  auto sorted_desc = df.sort_values("A", false);
                  first_val = sorted_desc["A"].get_value_str(0);
                  if (std::stod(first_val) != 5.0) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_sorting() : sort_values desc first != 5" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_sorting failed: sort_values desc first != 5");
                  }
      
                  // Test nlargest
                  auto largest = df.nlargest(2, "A");
                  if (largest.nrows() != 2) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_sorting() : nlargest nrows != 2" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_sorting failed: nlargest nrows != 2");
                  }
      
                  // Test nsmallest
                  auto smallest = df.nsmallest(2, "A");
                  if (smallest.nrows() != 2) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_sorting() : nsmallest nrows != 2" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_sorting failed: nsmallest nrows != 2");

.. _example-dataframe-nsmallest-40:

.. dropdown:: nsmallest (pd_test_1_all.cpp:6432)
   :class-title: example-dropdown

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

                  }
      
                  // Test nlargest
                  auto largest = df.nlargest(2, "A");
                  if (largest.nrows() != 2) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_sorting() : nlargest nrows != 2" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_sorting failed: nlargest nrows != 2");
                  }
      
                  // Test nsmallest
                  auto smallest = df.nsmallest(2, "A");
                  if (smallest.nrows() != 2) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_sorting() : nsmallest nrows != 2" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_sorting failed: nsmallest nrows != 2");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              // =====================================================================
              // Test: Rank

.. _example-dataframe-query-41:

.. dropdown:: query (pd_test_1_all.cpp:26418)
   :class-title: example-dropdown

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

      
              std::cout << "====================================== [OK] pd_test_prod test suite ========================== " << std::endl;
              return 0;
          }
      
      } // namespace dataframe_tests
      // ------------------- pd_test_prod.cpp (end) -----------------------------
      
      // ------------------- pd_test_query.cpp (start) -----------------------------
      // dataframe_tests/pd_test_query.cpp
      // Tests for DataFrame.query() method
      
      #include <iostream>
      #include <stdexcept>
      #include <map>
      #include <vector>
      #include <string>
      #include "../pandas/pd_dataframe.h"
      
      namespace dataframe_tests {
          namespace dataframe_tests_query {

.. _example-dataframe-sample-42:

.. dropdown:: sample (pd_test_3_all.cpp:207)
   :class-title: example-dropdown

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

              if (df.index().dtype_name() != "int64") {
                  std::cout << "  [FAIL] : in pd_test_3_all_dtype_typing_overloads() : cookbook_105 integration dtype" << std::endl;
                  throw std::runtime_error("pd_test_3_all_dtype_typing_overloads failed: cookbook_105 integration dtype");
              }
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_sample() {
          std::cout << "========= DataFrame.sample() =======================";
      
          std::map<std::string, std::vector<double>> data = {
              {"A", {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0}},
              {"B", {10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0, 90.0, 100.0}}
          };
          pandas::DataFrame df(data);
      
          // Sample 3 rows
          pandas::DataFrame result = df.sample(3, 42);  // seed=42 for reproducibility
      

.. _example-dataframe-sample-43:

.. dropdown:: sample (pd_test_3_all.cpp:207)
   :class-title: example-dropdown

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

              if (df.index().dtype_name() != "int64") {
                  std::cout << "  [FAIL] : in pd_test_3_all_dtype_typing_overloads() : cookbook_105 integration dtype" << std::endl;
                  throw std::runtime_error("pd_test_3_all_dtype_typing_overloads failed: cookbook_105 integration dtype");
              }
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_sample() {
          std::cout << "========= DataFrame.sample() =======================";
      
          std::map<std::string, std::vector<double>> data = {
              {"A", {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0}},
              {"B", {10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0, 90.0, 100.0}}
          };
          pandas::DataFrame df(data);
      
          // Sample 3 rows
          pandas::DataFrame result = df.sample(3, 42);  // seed=42 for reproducibility
      

.. _example-dataframe-sample-44:

.. dropdown:: sample (pd_test_3_all.cpp:207)
   :class-title: example-dropdown

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

              if (df.index().dtype_name() != "int64") {
                  std::cout << "  [FAIL] : in pd_test_3_all_dtype_typing_overloads() : cookbook_105 integration dtype" << std::endl;
                  throw std::runtime_error("pd_test_3_all_dtype_typing_overloads failed: cookbook_105 integration dtype");
              }
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_sample() {
          std::cout << "========= DataFrame.sample() =======================";
      
          std::map<std::string, std::vector<double>> data = {
              {"A", {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0}},
              {"B", {10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0, 90.0, 100.0}}
          };
          pandas::DataFrame df(data);
      
          // Sample 3 rows
          pandas::DataFrame result = df.sample(3, 42);  // seed=42 for reproducibility
      

.. _example-dataframe-sample-45:

.. dropdown:: sample (pd_test_3_all.cpp:207)
   :class-title: example-dropdown

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

              if (df.index().dtype_name() != "int64") {
                  std::cout << "  [FAIL] : in pd_test_3_all_dtype_typing_overloads() : cookbook_105 integration dtype" << std::endl;
                  throw std::runtime_error("pd_test_3_all_dtype_typing_overloads failed: cookbook_105 integration dtype");
              }
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_sample() {
          std::cout << "========= DataFrame.sample() =======================";
      
          std::map<std::string, std::vector<double>> data = {
              {"A", {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0}},
              {"B", {10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0, 90.0, 100.0}}
          };
          pandas::DataFrame df(data);
      
          // Sample 3 rows
          pandas::DataFrame result = df.sample(3, 42);  // seed=42 for reproducibility
      

.. _example-dataframe-sample-46:

.. dropdown:: sample (pd_test_3_all.cpp:207)
   :class-title: example-dropdown

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

              if (df.index().dtype_name() != "int64") {
                  std::cout << "  [FAIL] : in pd_test_3_all_dtype_typing_overloads() : cookbook_105 integration dtype" << std::endl;
                  throw std::runtime_error("pd_test_3_all_dtype_typing_overloads failed: cookbook_105 integration dtype");
              }
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_sample() {
          std::cout << "========= DataFrame.sample() =======================";
      
          std::map<std::string, std::vector<double>> data = {
              {"A", {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0}},
              {"B", {10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0, 90.0, 100.0}}
          };
          pandas::DataFrame df(data);
      
          // Sample 3 rows
          pandas::DataFrame result = df.sample(3, 42);  // seed=42 for reproducibility
      

.. _example-dataframe-sample_frac-47:

.. dropdown:: sample_frac (pd_test_5_all.cpp:2387)
   :class-title: example-dropdown

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

          // Build stats with string index (asset tickers), then shuffle and sort_index
          pandas::DataFrame stats;
          stats.add_column<double>("Mean",   { 0.002212, 0.001136, 0.000029, 0.000988, -0.000533, 0.000408, 0.000692});
          stats.add_column<double>("Std",    { 0.017966, 0.016225, 0.020372, 0.021692,  0.025519, 0.026644, 0.014562});
          stats.add_column<double>("Sharpe", { 1.955,    1.111,    0.023,    0.723,    -0.331,    0.243,    0.755});
          stats.add_column<double>("Skew",   {-0.049545, 0.024990,-0.075349,-0.009316,  0.088344, 0.017202, 0.182708});
          stats.add_column<double>("Kurt",   {-0.053650,-0.085255,-0.098852, 0.069301,  0.370648,-0.038772, 0.079181});
          stats.set_index_from_list({"AAPL", "MSFT", "GOOGL", "AMZN", "META", "NVDA", "JPM"});
      
          // Shuffle: sample(frac=1, random_state=42) produces order: NVDA,AMZN,JPM,META,AAPL,MSFT,GOOGL
          auto shuf = stats.sample_frac(1.0, 42);
          auto si = shuf.sort_index();
      
          std::string expected =
              "           Mean       Std  Sharpe      Skew      Kurt\n"
              "AAPL   0.002212  0.017966   1.955 -0.049545 -0.053650\n"
              "AMZN   0.000988  0.021692   0.723 -0.009316  0.069301\n"
              "GOOGL  0.000029  0.020372   0.023 -0.075349 -0.098852\n"
              "JPM    0.000692  0.014562   0.755  0.182708  0.079181\n"
              "META  -0.000533  0.025519  -0.331  0.088344  0.370648\n"
              "MSFT   0.001136  0.016225   1.111  0.024990 -0.085255\n"

.. _example-dataframe-set_value_nan-48:

.. dropdown:: set_value_nan (pd_test_5_all.cpp:18478)
   :class-title: example-dropdown

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

              "0    a\n"
              "1  NaN\n"
              "2    c";
          bool ok = (actual == expected);
          pandas_tests::check(ok, "where_mask_dtype_promotion_2_503514_case_10_str_col_where_default.to_string", local_fail);
          if (!ok) dump_diff("case_10", expected, actual);
      }
      
      void where_mask_dtype_promotion_2_503514_case_11_get_value_str_mask_int_renders_NaN(int& local_fail) {
          pandas::Series<std::int64_t> s({10, 20, 30});
          s.set_value_nan(0);
      
          std::string actual = s.get_value_str(0);
          std::string expected = "NaN";
          bool ok = (actual == expected);
          pandas_tests::check(ok, "where_mask_dtype_promotion_2_503514_case_11_get_value_str_mask_int_renders_NaN (got " +
                actual + ")", local_fail);
      
          bool ok1 = (s.get_value_str(1) == "20");
          bool ok2 = (s.get_value_str(2) == "30");
          pandas_tests::check(ok1, "case_11.kept_idx1_eq_20", local_fail);

.. _example-dataframe-tail-49:

.. dropdown:: tail (pd_test_1_all.cpp:6308)
   :class-title: example-dropdown

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

                  pandas::DataFrame df(data);
      
                  // Test head
                  auto head_df = df.head(3);
                  if (head_df.nrows() != 3) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_indexing() : head(3) nrows != 3" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_indexing failed: head(3) nrows != 3");
                  }
      
                  // Test tail
                  auto tail_df = df.tail(2);
                  if (tail_df.nrows() != 2) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_indexing() : tail(2) nrows != 2" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_indexing failed: tail(2) nrows != 2");
                  }
      
                  // Test iloc_rows range
                  auto slice = df.iloc_rows(1, 4);
                  if (slice.nrows() != 3) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_indexing() : iloc_rows(1,4) nrows != 3" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_indexing failed: iloc_rows(1,4) nrows != 3");

.. _example-dataframe-take-50:

.. 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-dataframe-where-51:

.. 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-dataframe-where-52:

.. 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-dataframe-where-53:

.. 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-dataframe-where_resolved-54:

.. dropdown:: where_resolved (pd_test_5_all.cpp:91939)
   :class-title: example-dropdown

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

          auto cond_df = make_2x3_cond_mixed();
      
          pandas::WhereCondition cond;
          cond.kind = pandas::WhereCondKind::DATAFRAME;
          cond.dataframe_ptr = &cond_df;
      
          pandas::WhereOther other;
          other.kind = pandas::WhereOtherKind::SCALAR;
          other.scalar_val = -999.0;
      
          pandas::DataFrame result = df.where_resolved(cond, other, /*axis=*/0);
      
          pandas_tests::check(result.nrows() == 2,
              "case_1_cond_df_other_scalar.nrows_eq_2", local_fail);
          pandas_tests::check(result.ncols() == 3,
              "case_1_cond_df_other_scalar.ncols_eq_3", local_fail);
          pandas_tests::check(!result.to_string().empty(),
              "case_1_cond_df_other_scalar.to_string_nonempty", local_fail);
      }
      
      void case_2_cond_df_other_series() {

.. _example-dataframe-xs-55:

.. dropdown:: xs (pd_test_2_all.cpp:18668)
   :class-title: example-dropdown

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

      
              std::cout << "====================================== [OK] pd_test_tz_localize test suite ========================== " << std::endl;
              return 0;
          }
      
      } // namespace dataframe_tests
      // ------------------- pd_test_tz_localize.cpp (end) -----------------------------
      
      // ------------------- pd_test_xs.cpp (start) -----------------------------
      // dataframe_tests/pd_test_xs.cpp
      // Tests for DataFrame xs() (cross-section) implementation
      
      #include <iostream>
      #include <stdexcept>
      #include <vector>
      #include <string>
      #include <map>
      
      #include "../pandas/pd_dataframe.h"
      
      // CRITICAL: No using namespace directives

.. _example-dataframe-xs-56:

.. dropdown:: xs (pd_test_2_all.cpp:18668)
   :class-title: example-dropdown

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

      
              std::cout << "====================================== [OK] pd_test_tz_localize test suite ========================== " << std::endl;
              return 0;
          }
      
      } // namespace dataframe_tests
      // ------------------- pd_test_tz_localize.cpp (end) -----------------------------
      
      // ------------------- pd_test_xs.cpp (start) -----------------------------
      // dataframe_tests/pd_test_xs.cpp
      // Tests for DataFrame xs() (cross-section) implementation
      
      #include <iostream>
      #include <stdexcept>
      #include <vector>
      #include <string>
      #include <map>
      
      #include "../pandas/pd_dataframe.h"
      
      // CRITICAL: No using namespace directives

.. _example-dataframe-xs-57:

.. dropdown:: xs (pd_test_2_all.cpp:18668)
   :class-title: example-dropdown

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

      
              std::cout << "====================================== [OK] pd_test_tz_localize test suite ========================== " << std::endl;
              return 0;
          }
      
      } // namespace dataframe_tests
      // ------------------- pd_test_tz_localize.cpp (end) -----------------------------
      
      // ------------------- pd_test_xs.cpp (start) -----------------------------
      // dataframe_tests/pd_test_xs.cpp
      // Tests for DataFrame xs() (cross-section) implementation
      
      #include <iostream>
      #include <stdexcept>
      #include <vector>
      #include <string>
      #include <map>
      
      #include "../pandas/pd_dataframe.h"
      
      // CRITICAL: No using namespace directives

.. _example-dataframe-xs_level-58:

.. dropdown:: xs_level (pd_test_5_all.cpp:12967)
   :class-title: example-dropdown

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

              } catch (const std::exception&) {
                  threw = true;
              }
              pandas_tests::check(!threw, "query_bool_and_numeric.no_throw", local_fail);
              if (!threw) {
                  pandas_tests::check(result.nrows() == 1, "query_bool_and_numeric.nrows == 1 (got " + std::to_string(result.nrows()) + ")", local_fail);
              }
          }
      
          // === xs_level tests (Error 2) ===
          // Note: xs_level() doesn't exist yet — test will verify it after implementation
      
          // === get_series + unstack tests (Error 1) ===
          // Note: get_series<T>() doesn't exist yet — test will verify it after implementation
      
          if (local_fail > 0) {
              std::cout << "  [FAIL] : in f_test_anal_i_query_bool_unstack() : " << local_fail << " checks failed" << std::endl;
              throw std::runtime_error("f_test_anal_i_query_bool_unstack failed");
          }
          std::cout << " -> tests passed" << std::endl;
      }

.. _example-dataframe-assign-59:

.. dropdown:: assign (pd_test_1_all.cpp:6653)
   :class-title: example-dropdown

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

                          throw std::runtime_error("pd_test_dataframe_manipulation failed: drop_duplicates");
                      }
                  }
      
                  // Test assign
                  {
                      std::map<std::string, std::vector<numpy::int64>> assign_data;
                      assign_data["A"] = {1, 2, 3};
                      pandas::DataFrame df_assign(assign_data);
      
                      auto df2 = df_assign.assign<numpy::int64>("B", {10, 20, 30});
                      if (df2.ncols() != 2) {
                          std::cout << "  [FAIL] : in pd_test_dataframe_manipulation() : assign ncols != 2" << std::endl;
                          throw std::runtime_error("pd_test_dataframe_manipulation failed: assign ncols");
                      }
                      if (!df2.has_column("B")) {
                          std::cout << "  [FAIL] : in pd_test_dataframe_manipulation() : assign didn't add column B" << std::endl;
                          throw std::runtime_error("pd_test_dataframe_manipulation failed: assign column B");
                      }
                  }
      

.. _example-dataframe-assign-60:

.. dropdown:: assign (pd_test_1_all.cpp:6653)
   :class-title: example-dropdown

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

                          throw std::runtime_error("pd_test_dataframe_manipulation failed: drop_duplicates");
                      }
                  }
      
                  // Test assign
                  {
                      std::map<std::string, std::vector<numpy::int64>> assign_data;
                      assign_data["A"] = {1, 2, 3};
                      pandas::DataFrame df_assign(assign_data);
      
                      auto df2 = df_assign.assign<numpy::int64>("B", {10, 20, 30});
                      if (df2.ncols() != 2) {
                          std::cout << "  [FAIL] : in pd_test_dataframe_manipulation() : assign ncols != 2" << std::endl;
                          throw std::runtime_error("pd_test_dataframe_manipulation failed: assign ncols");
                      }
                      if (!df2.has_column("B")) {
                          std::cout << "  [FAIL] : in pd_test_dataframe_manipulation() : assign didn't add column B" << std::endl;
                          throw std::runtime_error("pd_test_dataframe_manipulation failed: assign column B");
                      }
                  }
      

.. _example-dataframe-assign-61:

.. dropdown:: assign (pd_test_1_all.cpp:6653)
   :class-title: example-dropdown

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

                          throw std::runtime_error("pd_test_dataframe_manipulation failed: drop_duplicates");
                      }
                  }
      
                  // Test assign
                  {
                      std::map<std::string, std::vector<numpy::int64>> assign_data;
                      assign_data["A"] = {1, 2, 3};
                      pandas::DataFrame df_assign(assign_data);
      
                      auto df2 = df_assign.assign<numpy::int64>("B", {10, 20, 30});
                      if (df2.ncols() != 2) {
                          std::cout << "  [FAIL] : in pd_test_dataframe_manipulation() : assign ncols != 2" << std::endl;
                          throw std::runtime_error("pd_test_dataframe_manipulation failed: assign ncols");
                      }
                      if (!df2.has_column("B")) {
                          std::cout << "  [FAIL] : in pd_test_dataframe_manipulation() : assign didn't add column B" << std::endl;
                          throw std::runtime_error("pd_test_dataframe_manipulation failed: assign column B");
                      }
                  }
      

.. _example-dataframe-drop-62:

.. 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-dataframe-drop_duplicates-63:

.. 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-dataframe-droplevel-64:

.. 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-dataframe-droplevel-65:

.. 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-dataframe-droplevel-66:

.. 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-dataframe-droplevel-67:

.. 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-dataframe-dropna-68:

.. 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-dataframe-dropna-69:

.. 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-dataframe-insert-70:

.. 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-dataframe-insert-71:

.. 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-dataframe-insert-72:

.. 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-dataframe-insert-73:

.. 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-dataframe-insert-74:

.. 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-dataframe-insert-75:

.. 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-dataframe-insert-76:

.. 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-dataframe-insert-77:

.. 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-dataframe-insert-78:

.. 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-dataframe-reindex-79:

.. 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-dataframe-reindex-80:

.. 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-dataframe-reindex-81:

.. 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-dataframe-reindex-82:

.. 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-dataframe-reindex-83:

.. 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-dataframe-reindex_like-84:

.. dropdown:: reindex_like (pd_test_1_all.cpp:6777)
   :class-title: example-dropdown

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

                      data1["A"] = {1, 2};
                      data1["B"] = {3, 4};
                      pandas::DataFrame df1(data1);
      
                      std::map<std::string, std::vector<int>> data2;
                      data2["B"] = {10, 20, 30};
                      data2["C"] = {40, 50, 60};
                      pandas::DataFrame df2(data2);
                      df2 = df2.set_axis({"x", "y", "z"}, 0);
      
                      auto reindexed = df1.reindex_like(df2);
                      if (reindexed.nrows() != 3 || reindexed.ncols() != 2) {
                          std::cout << "  [FAIL] : in pd_test_dataframe_index_ops() : reindex_like wrong shape" << std::endl;
                          throw std::runtime_error("pd_test_dataframe_index_ops failed: reindex_like");
                      }
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              // =====================================================================

.. _example-dataframe-reindex_with_indexer-85:

.. dropdown:: reindex_with_indexer (pd_test_5_all.cpp:40388)
   :class-title: example-dropdown

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

          s.set_dtype_override("boolean");
          s.set_freq(std::optional<std::string>("D"));
          s.set_string_na_sentinel_disabled(true);
      
          // Indexer: identity over the 3 source positions.
          numpy::NDArray<numpy::int64> indexer(std::vector<size_t>{3});
          indexer.setElementAt({0}, 0);
          indexer.setElementAt({1}, 1);
          indexer.setElementAt({2}, 2);
      
          auto base = s.reindex_with_indexer(indexer);
          pandas_tests::check(base != nullptr, "case7.reindex_with_indexer_nonnull", local_fail);
          if (!base) return;
      
          auto* r = dynamic_cast<pandas::Series<std::int64_t>*>(base.get());
          pandas_tests::check(r != nullptr, "case7.reindex_with_indexer_is_Series_int64",
                              local_fail);
          if (!r) return;
      
          // dtype_override propagates (oracle says yes).
          pandas_tests::check(r->dtype_override().has_value() &&

.. _example-dataframe-reindex_with_spec-86:

.. dropdown:: reindex_with_spec (pd_test_5_all.cpp:54746)
   :class-title: example-dropdown

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

      }
      
      void case_25_b_bool_int_fill_explicit_spec(int& local_fail) {
          std::cout << "---- 25b bool_int_fill_explicit_spec\n";
      
          pandas::DataFrame df;
          df.add_column<bool>("b", {true, false, true});
      
          // Explicit-spec path: tag=Int is authoritative.
          pandas::FillSpec spec = pandas::FillSpec::integer(0);
          auto r = df.reindex_with_spec({"0", "1", "2", "3", "4"}, 0, spec);
      
          std::string dt = r["b"].dtype_name();
          pandas_tests::check(dt == "object",
                "25b.b dtype should be object via reindex_with_spec "
                "(got '" + dt + "')", local_fail);
      
          std::string rep = r.to_string();
          // Post-fix target: fill is literal int 0 (not False).
          size_t n_false = 0, pos = 0;
          while ((pos = rep.find("False", pos)) != std::string::npos) {

.. _example-dataframe-rename-87:

.. 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-dataframe-rename-88:

.. 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-dataframe-rename_axis-89:

.. dropdown:: rename_axis (pd_test_1_all.cpp:6760)
   :class-title: example-dropdown

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

                          throw std::runtime_error("pd_test_dataframe_index_ops failed: get_optional Z");
                      }
                  }
      
                  // Test rename_axis
                  {
                      std::map<std::string, std::vector<int>> data;
                      data["A"] = {1, 2, 3};
                      pandas::DataFrame df(data);
      
                      auto renamed = df.rename_axis("my_index", 0);
                      // Should not throw
                  }
      
                  // Test reindex_like
                  {
                      std::map<std::string, std::vector<int>> data1;
                      data1["A"] = {1, 2};
                      data1["B"] = {3, 4};
                      pandas::DataFrame df1(data1);
      

.. _example-dataframe-rename_axis-90:

.. dropdown:: rename_axis (pd_test_1_all.cpp:6760)
   :class-title: example-dropdown

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

                          throw std::runtime_error("pd_test_dataframe_index_ops failed: get_optional Z");
                      }
                  }
      
                  // Test rename_axis
                  {
                      std::map<std::string, std::vector<int>> data;
                      data["A"] = {1, 2, 3};
                      pandas::DataFrame df(data);
      
                      auto renamed = df.rename_axis("my_index", 0);
                      // Should not throw
                  }
      
                  // Test reindex_like
                  {
                      std::map<std::string, std::vector<int>> data1;
                      data1["A"] = {1, 2};
                      data1["B"] = {3, 4};
                      pandas::DataFrame df1(data1);
      

.. _example-dataframe-rename_columns-91:

.. dropdown:: rename_columns (pd_test_1_all.cpp:6565)
   :class-title: example-dropdown

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

                  }
      
                  // 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");
                  }
      
                  // Test isna/notna with float data
                  {
                      std::map<std::string, std::vector<numpy::float64>> float_data;
                      float_data["X"] = {1.0, std::nan(""), 3.0};
                      float_data["Y"] = {4.0, 5.0, std::nan("")};

.. _example-dataframe-rename_result-92:

.. dropdown:: rename_result (pd_test_5_all.cpp:50613)
   :class-title: example-dropdown

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

          return df;
      }
      
      void case_1_dict_axis1(int& local_fail) {
          std::cout << "-- case_1_dict_axis1\n";
          auto df = make_flat_frame();
          pandas::RenameSpec spec;
          spec.kind = pandas::RenameSpec::Kind::Dict;
          spec.dict_mapper["a"] = "A";
          spec.dict_mapper["b"] = "B";
          auto r = df.rename_result(spec, /*axis=*/1, /*inplace=*/false, /*errors_raise=*/false);
          pandas_tests::check(r.is_frame(), "case_1.is_frame", local_fail);
          if (!r.is_frame()) return;
          auto& f = *std::get<std::unique_ptr<pandas::DataFrame>>(r.value);
          pandas_tests::check(f.columns().get_value_str(0) == "A", "case_1.col0_A", local_fail);
          pandas_tests::check(f.columns().get_value_str(1) == "B", "case_1.col1_B", local_fail);
      }
      
      void case_2_dict_axis0(int& local_fail) {
          std::cout << "-- case_2_dict_axis0\n";
          auto df = make_flat_frame();

.. _example-dataframe-reorder_levels-93:

.. dropdown:: reorder_levels (pd_test_1_all.cpp:14495)
   :class-title: example-dropdown

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

              void pd_test_multiindex_reorder_levels() {
                  std::cout << "========= reorder_levels ============================== ";
      
                  std::vector<std::vector<std::string>> arrays = {
                      {"a", "b"},
                      {"x", "y"},
                      {"1", "2"}
                  };
      
                  pandas::MultiIndex mi = pandas::MultiIndex::from_arrays<std::string>(arrays);
                  pandas::MultiIndex reordered = mi.reorder_levels({2, 0, 1});
      
                  bool passed = true;
      
                  auto tup = reordered[0];
                  if (tup[0] != "1" || tup[1] != "a" || tup[2] != "x") {
                      std::cout << "  [FAIL] : reordered tuple should be ('1', 'a', 'x')" << std::endl;
                      passed = false;
                  }
      
                  if (!passed) {

.. _example-dataframe-reorder_levels-94:

.. dropdown:: reorder_levels (pd_test_1_all.cpp:14495)
   :class-title: example-dropdown

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

              void pd_test_multiindex_reorder_levels() {
                  std::cout << "========= reorder_levels ============================== ";
      
                  std::vector<std::vector<std::string>> arrays = {
                      {"a", "b"},
                      {"x", "y"},
                      {"1", "2"}
                  };
      
                  pandas::MultiIndex mi = pandas::MultiIndex::from_arrays<std::string>(arrays);
                  pandas::MultiIndex reordered = mi.reorder_levels({2, 0, 1});
      
                  bool passed = true;
      
                  auto tup = reordered[0];
                  if (tup[0] != "1" || tup[1] != "a" || tup[2] != "x") {
                      std::cout << "  [FAIL] : reordered tuple should be ('1', 'a', 'x')" << std::endl;
                      passed = false;
                  }
      
                  if (!passed) {

.. _example-dataframe-reorder_levels-95:

.. dropdown:: reorder_levels (pd_test_1_all.cpp:14495)
   :class-title: example-dropdown

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

              void pd_test_multiindex_reorder_levels() {
                  std::cout << "========= reorder_levels ============================== ";
      
                  std::vector<std::vector<std::string>> arrays = {
                      {"a", "b"},
                      {"x", "y"},
                      {"1", "2"}
                  };
      
                  pandas::MultiIndex mi = pandas::MultiIndex::from_arrays<std::string>(arrays);
                  pandas::MultiIndex reordered = mi.reorder_levels({2, 0, 1});
      
                  bool passed = true;
      
                  auto tup = reordered[0];
                  if (tup[0] != "1" || tup[1] != "a" || tup[2] != "x") {
                      std::cout << "  [FAIL] : reordered tuple should be ('1', 'a', 'x')" << std::endl;
                      passed = false;
                  }
      
                  if (!passed) {

.. _example-dataframe-reorder_levels-96:

.. dropdown:: reorder_levels (pd_test_1_all.cpp:14495)
   :class-title: example-dropdown

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

              void pd_test_multiindex_reorder_levels() {
                  std::cout << "========= reorder_levels ============================== ";
      
                  std::vector<std::vector<std::string>> arrays = {
                      {"a", "b"},
                      {"x", "y"},
                      {"1", "2"}
                  };
      
                  pandas::MultiIndex mi = pandas::MultiIndex::from_arrays<std::string>(arrays);
                  pandas::MultiIndex reordered = mi.reorder_levels({2, 0, 1});
      
                  bool passed = true;
      
                  auto tup = reordered[0];
                  if (tup[0] != "1" || tup[1] != "a" || tup[2] != "x") {
                      std::cout << "  [FAIL] : reordered tuple should be ('1', 'a', 'x')" << std::endl;
                      passed = false;
                  }
      
                  if (!passed) {

.. _example-dataframe-replace-97:

.. dropdown:: replace (pd_test_1_all.cpp:6623)
   :class-title: example-dropdown

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

                      }
                  }
      
                  // Test replace
                  {
                      std::map<std::string, std::vector<numpy::float64>> float_data;
                      float_data["X"] = {1.0, 2.0, 3.0};
                      float_data["Y"] = {2.0, 2.0, 4.0};
                      pandas::DataFrame df_repl(float_data);
      
                      auto replaced = df_repl.replace(2.0, 99.0);
                      // Check some value was replaced (crude check via string)
                      std::string val_str = replaced.col<numpy::float64>("X").get_value_str(1);
                      if (val_str.find("99") == std::string::npos) {
                          std::cout << "  [FAIL] : in pd_test_dataframe_manipulation() : replace didn't work" << std::endl;
                          throw std::runtime_error("pd_test_dataframe_manipulation failed: replace");
                      }
                  }
      
                  // Test drop_duplicates
                  {

.. _example-dataframe-replace-98:

.. dropdown:: replace (pd_test_1_all.cpp:6623)
   :class-title: example-dropdown

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

                      }
                  }
      
                  // Test replace
                  {
                      std::map<std::string, std::vector<numpy::float64>> float_data;
                      float_data["X"] = {1.0, 2.0, 3.0};
                      float_data["Y"] = {2.0, 2.0, 4.0};
                      pandas::DataFrame df_repl(float_data);
      
                      auto replaced = df_repl.replace(2.0, 99.0);
                      // Check some value was replaced (crude check via string)
                      std::string val_str = replaced.col<numpy::float64>("X").get_value_str(1);
                      if (val_str.find("99") == std::string::npos) {
                          std::cout << "  [FAIL] : in pd_test_dataframe_manipulation() : replace didn't work" << std::endl;
                          throw std::runtime_error("pd_test_dataframe_manipulation failed: replace");
                      }
                  }
      
                  // Test drop_duplicates
                  {

.. _example-dataframe-replace-99:

.. dropdown:: replace (pd_test_1_all.cpp:6623)
   :class-title: example-dropdown

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

                      }
                  }
      
                  // Test replace
                  {
                      std::map<std::string, std::vector<numpy::float64>> float_data;
                      float_data["X"] = {1.0, 2.0, 3.0};
                      float_data["Y"] = {2.0, 2.0, 4.0};
                      pandas::DataFrame df_repl(float_data);
      
                      auto replaced = df_repl.replace(2.0, 99.0);
                      // Check some value was replaced (crude check via string)
                      std::string val_str = replaced.col<numpy::float64>("X").get_value_str(1);
                      if (val_str.find("99") == std::string::npos) {
                          std::cout << "  [FAIL] : in pd_test_dataframe_manipulation() : replace didn't work" << std::endl;
                          throw std::runtime_error("pd_test_dataframe_manipulation failed: replace");
                      }
                  }
      
                  // Test drop_duplicates
                  {

.. _example-dataframe-replace-100:

.. dropdown:: replace (pd_test_1_all.cpp:6623)
   :class-title: example-dropdown

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

                      }
                  }
      
                  // Test replace
                  {
                      std::map<std::string, std::vector<numpy::float64>> float_data;
                      float_data["X"] = {1.0, 2.0, 3.0};
                      float_data["Y"] = {2.0, 2.0, 4.0};
                      pandas::DataFrame df_repl(float_data);
      
                      auto replaced = df_repl.replace(2.0, 99.0);
                      // Check some value was replaced (crude check via string)
                      std::string val_str = replaced.col<numpy::float64>("X").get_value_str(1);
                      if (val_str.find("99") == std::string::npos) {
                          std::cout << "  [FAIL] : in pd_test_dataframe_manipulation() : replace didn't work" << std::endl;
                          throw std::runtime_error("pd_test_dataframe_manipulation failed: replace");
                      }
                  }
      
                  // Test drop_duplicates
                  {

.. _example-dataframe-replace-101:

.. dropdown:: replace (pd_test_1_all.cpp:6623)
   :class-title: example-dropdown

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

                      }
                  }
      
                  // Test replace
                  {
                      std::map<std::string, std::vector<numpy::float64>> float_data;
                      float_data["X"] = {1.0, 2.0, 3.0};
                      float_data["Y"] = {2.0, 2.0, 4.0};
                      pandas::DataFrame df_repl(float_data);
      
                      auto replaced = df_repl.replace(2.0, 99.0);
                      // Check some value was replaced (crude check via string)
                      std::string val_str = replaced.col<numpy::float64>("X").get_value_str(1);
                      if (val_str.find("99") == std::string::npos) {
                          std::cout << "  [FAIL] : in pd_test_dataframe_manipulation() : replace didn't work" << std::endl;
                          throw std::runtime_error("pd_test_dataframe_manipulation failed: replace");
                      }
                  }
      
                  // Test drop_duplicates
                  {

.. _example-dataframe-reset_index-102:

.. dropdown:: reset_index (pd_test_3_all.cpp:1618)
   :class-title: example-dropdown

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

          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      // ============================================================================
      // Category 10: Remaining Untested Functions
      // ============================================================================
      
      void pd_test_3_all_series_reset_index() {
          std::cout << "========= Series.reset_index() =======================";
      
          std::vector<double> vals = {10.0, 20.0, 30.0};
          pandas::Series<double> s(vals, "test");
      
          // Set a custom index
          pandas::Index<std::string> custom_idx({"a", "b", "c"});
          s.set_index(custom_idx);
      
          // Reset the index
          s.reset_index(true);  // drop=true

.. _example-dataframe-set_axis-103:

.. dropdown:: set_axis (pd_test_1_all.cpp:6673)
   :class-title: example-dropdown

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

      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              // =====================================================================
              // Test: Index Operations
              // =====================================================================
              void pd_test_dataframe_index_ops() {
                  std::cout << "========= index operations =================";
      
                  // Test set_axis (rows)
                  {
                      std::map<std::string, std::vector<int>> data;
                      data["A"] = {1, 2, 3};
                      pandas::DataFrame df(data);
      
                      auto renamed = df.set_axis({"x", "y", "z"}, 0);
                      std::string idx0 = renamed.index().get_value_str(0);
                      if (idx0 != "x") {
                          std::cout << "  [FAIL] : in pd_test_dataframe_index_ops() : set_axis first label should be 'x'" << std::endl;
                          throw std::runtime_error("pd_test_dataframe_index_ops failed: set_axis");

.. _example-dataframe-set_index-104:

.. dropdown:: set_index (pd_test_1_all.cpp:20318)
   :class-title: example-dropdown

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

      
                  // Set datetime index
                  std::vector<std::string> dates = {
                      "2020-01-01 00:00:00",
                      "2020-01-01 12:00:00",
                      "2020-01-02 00:00:00",
                      "2020-01-02 12:00:00",
                      "2020-01-03 00:00:00",
                      "2020-01-03 12:00:00"
                  };
                  df.set_index(std::make_unique<pandas::Index<std::string>>(dates));
      
                  // Resample to daily
                  auto resampler = df.resample("D");
                  pandas::DataFrame result = resampler.sum();
      
                  // Check that we got aggregated results
                  bool passed = (result.nrows() <= df.nrows());
      
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_timeseries_resample_basic() : resample didn't reduce rows" << std::endl;

.. _example-dataframe-set_index-105:

.. dropdown:: set_index (pd_test_1_all.cpp:20318)
   :class-title: example-dropdown

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

      
                  // Set datetime index
                  std::vector<std::string> dates = {
                      "2020-01-01 00:00:00",
                      "2020-01-01 12:00:00",
                      "2020-01-02 00:00:00",
                      "2020-01-02 12:00:00",
                      "2020-01-03 00:00:00",
                      "2020-01-03 12:00:00"
                  };
                  df.set_index(std::make_unique<pandas::Index<std::string>>(dates));
      
                  // Resample to daily
                  auto resampler = df.resample("D");
                  pandas::DataFrame result = resampler.sum();
      
                  // Check that we got aggregated results
                  bool passed = (result.nrows() <= df.nrows());
      
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_timeseries_resample_basic() : resample didn't reduce rows" << std::endl;

.. _example-dataframe-set_index-106:

.. dropdown:: set_index (pd_test_1_all.cpp:20318)
   :class-title: example-dropdown

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

      
                  // Set datetime index
                  std::vector<std::string> dates = {
                      "2020-01-01 00:00:00",
                      "2020-01-01 12:00:00",
                      "2020-01-02 00:00:00",
                      "2020-01-02 12:00:00",
                      "2020-01-03 00:00:00",
                      "2020-01-03 12:00:00"
                  };
                  df.set_index(std::make_unique<pandas::Index<std::string>>(dates));
      
                  // Resample to daily
                  auto resampler = df.resample("D");
                  pandas::DataFrame result = resampler.sum();
      
                  // Check that we got aggregated results
                  bool passed = (result.nrows() <= df.nrows());
      
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_timeseries_resample_basic() : resample didn't reduce rows" << std::endl;

.. _example-dataframe-set_index-107:

.. dropdown:: set_index (pd_test_1_all.cpp:20318)
   :class-title: example-dropdown

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

      
                  // Set datetime index
                  std::vector<std::string> dates = {
                      "2020-01-01 00:00:00",
                      "2020-01-01 12:00:00",
                      "2020-01-02 00:00:00",
                      "2020-01-02 12:00:00",
                      "2020-01-03 00:00:00",
                      "2020-01-03 12:00:00"
                  };
                  df.set_index(std::make_unique<pandas::Index<std::string>>(dates));
      
                  // Resample to daily
                  auto resampler = df.resample("D");
                  pandas::DataFrame result = resampler.sum();
      
                  // Check that we got aggregated results
                  bool passed = (result.nrows() <= df.nrows());
      
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_timeseries_resample_basic() : resample didn't reduce rows" << std::endl;

.. _example-dataframe-set_index-108:

.. dropdown:: set_index (pd_test_1_all.cpp:20318)
   :class-title: example-dropdown

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

      
                  // Set datetime index
                  std::vector<std::string> dates = {
                      "2020-01-01 00:00:00",
                      "2020-01-01 12:00:00",
                      "2020-01-02 00:00:00",
                      "2020-01-02 12:00:00",
                      "2020-01-03 00:00:00",
                      "2020-01-03 12:00:00"
                  };
                  df.set_index(std::make_unique<pandas::Index<std::string>>(dates));
      
                  // Resample to daily
                  auto resampler = df.resample("D");
                  pandas::DataFrame result = resampler.sum();
      
                  // Check that we got aggregated results
                  bool passed = (result.nrows() <= df.nrows());
      
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_timeseries_resample_basic() : resample didn't reduce rows" << std::endl;

.. _example-dataframe-set_index-109:

.. dropdown:: set_index (pd_test_1_all.cpp:20318)
   :class-title: example-dropdown

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

      
                  // Set datetime index
                  std::vector<std::string> dates = {
                      "2020-01-01 00:00:00",
                      "2020-01-01 12:00:00",
                      "2020-01-02 00:00:00",
                      "2020-01-02 12:00:00",
                      "2020-01-03 00:00:00",
                      "2020-01-03 12:00:00"
                  };
                  df.set_index(std::make_unique<pandas::Index<std::string>>(dates));
      
                  // Resample to daily
                  auto resampler = df.resample("D");
                  pandas::DataFrame result = resampler.sum();
      
                  // Check that we got aggregated results
                  bool passed = (result.nrows() <= df.nrows());
      
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_timeseries_resample_basic() : resample didn't reduce rows" << std::endl;

.. _example-dataframe-set_index-110:

.. dropdown:: set_index (pd_test_1_all.cpp:20318)
   :class-title: example-dropdown

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

      
                  // Set datetime index
                  std::vector<std::string> dates = {
                      "2020-01-01 00:00:00",
                      "2020-01-01 12:00:00",
                      "2020-01-02 00:00:00",
                      "2020-01-02 12:00:00",
                      "2020-01-03 00:00:00",
                      "2020-01-03 12:00:00"
                  };
                  df.set_index(std::make_unique<pandas::Index<std::string>>(dates));
      
                  // Resample to daily
                  auto resampler = df.resample("D");
                  pandas::DataFrame result = resampler.sum();
      
                  // Check that we got aggregated results
                  bool passed = (result.nrows() <= df.nrows());
      
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_timeseries_resample_basic() : resample didn't reduce rows" << std::endl;

.. _example-dataframe-set_index-111:

.. dropdown:: set_index (pd_test_1_all.cpp:20318)
   :class-title: example-dropdown

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

      
                  // Set datetime index
                  std::vector<std::string> dates = {
                      "2020-01-01 00:00:00",
                      "2020-01-01 12:00:00",
                      "2020-01-02 00:00:00",
                      "2020-01-02 12:00:00",
                      "2020-01-03 00:00:00",
                      "2020-01-03 12:00:00"
                  };
                  df.set_index(std::make_unique<pandas::Index<std::string>>(dates));
      
                  // Resample to daily
                  auto resampler = df.resample("D");
                  pandas::DataFrame result = resampler.sum();
      
                  // Check that we got aggregated results
                  bool passed = (result.nrows() <= df.nrows());
      
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_timeseries_resample_basic() : resample didn't reduce rows" << std::endl;

.. _example-dataframe-set_index-112:

.. dropdown:: set_index (pd_test_1_all.cpp:20318)
   :class-title: example-dropdown

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

      
                  // Set datetime index
                  std::vector<std::string> dates = {
                      "2020-01-01 00:00:00",
                      "2020-01-01 12:00:00",
                      "2020-01-02 00:00:00",
                      "2020-01-02 12:00:00",
                      "2020-01-03 00:00:00",
                      "2020-01-03 12:00:00"
                  };
                  df.set_index(std::make_unique<pandas::Index<std::string>>(dates));
      
                  // Resample to daily
                  auto resampler = df.resample("D");
                  pandas::DataFrame result = resampler.sum();
      
                  // Check that we got aggregated results
                  bool passed = (result.nrows() <= df.nrows());
      
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_timeseries_resample_basic() : resample didn't reduce rows" << std::endl;

.. _example-dataframe-set_index-113:

.. dropdown:: set_index (pd_test_1_all.cpp:20318)
   :class-title: example-dropdown

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

      
                  // Set datetime index
                  std::vector<std::string> dates = {
                      "2020-01-01 00:00:00",
                      "2020-01-01 12:00:00",
                      "2020-01-02 00:00:00",
                      "2020-01-02 12:00:00",
                      "2020-01-03 00:00:00",
                      "2020-01-03 12:00:00"
                  };
                  df.set_index(std::make_unique<pandas::Index<std::string>>(dates));
      
                  // Resample to daily
                  auto resampler = df.resample("D");
                  pandas::DataFrame result = resampler.sum();
      
                  // Check that we got aggregated results
                  bool passed = (result.nrows() <= df.nrows());
      
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_timeseries_resample_basic() : resample didn't reduce rows" << std::endl;

.. _example-dataframe-set_index-114:

.. dropdown:: set_index (pd_test_1_all.cpp:20318)
   :class-title: example-dropdown

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

      
                  // Set datetime index
                  std::vector<std::string> dates = {
                      "2020-01-01 00:00:00",
                      "2020-01-01 12:00:00",
                      "2020-01-02 00:00:00",
                      "2020-01-02 12:00:00",
                      "2020-01-03 00:00:00",
                      "2020-01-03 12:00:00"
                  };
                  df.set_index(std::make_unique<pandas::Index<std::string>>(dates));
      
                  // Resample to daily
                  auto resampler = df.resample("D");
                  pandas::DataFrame result = resampler.sum();
      
                  // Check that we got aggregated results
                  bool passed = (result.nrows() <= df.nrows());
      
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_timeseries_resample_basic() : resample didn't reduce rows" << std::endl;

.. _example-dataframe-set_index-115:

.. dropdown:: set_index (pd_test_1_all.cpp:20318)
   :class-title: example-dropdown

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

      
                  // Set datetime index
                  std::vector<std::string> dates = {
                      "2020-01-01 00:00:00",
                      "2020-01-01 12:00:00",
                      "2020-01-02 00:00:00",
                      "2020-01-02 12:00:00",
                      "2020-01-03 00:00:00",
                      "2020-01-03 12:00:00"
                  };
                  df.set_index(std::make_unique<pandas::Index<std::string>>(dates));
      
                  // Resample to daily
                  auto resampler = df.resample("D");
                  pandas::DataFrame result = resampler.sum();
      
                  // Check that we got aggregated results
                  bool passed = (result.nrows() <= df.nrows());
      
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_timeseries_resample_basic() : resample didn't reduce rows" << std::endl;

.. _example-dataframe-set_index-116:

.. dropdown:: set_index (pd_test_1_all.cpp:20318)
   :class-title: example-dropdown

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

      
                  // Set datetime index
                  std::vector<std::string> dates = {
                      "2020-01-01 00:00:00",
                      "2020-01-01 12:00:00",
                      "2020-01-02 00:00:00",
                      "2020-01-02 12:00:00",
                      "2020-01-03 00:00:00",
                      "2020-01-03 12:00:00"
                  };
                  df.set_index(std::make_unique<pandas::Index<std::string>>(dates));
      
                  // Resample to daily
                  auto resampler = df.resample("D");
                  pandas::DataFrame result = resampler.sum();
      
                  // Check that we got aggregated results
                  bool passed = (result.nrows() <= df.nrows());
      
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_timeseries_resample_basic() : resample didn't reduce rows" << std::endl;

.. _example-dataframe-set_index-117:

.. dropdown:: set_index (pd_test_1_all.cpp:20318)
   :class-title: example-dropdown

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

      
                  // Set datetime index
                  std::vector<std::string> dates = {
                      "2020-01-01 00:00:00",
                      "2020-01-01 12:00:00",
                      "2020-01-02 00:00:00",
                      "2020-01-02 12:00:00",
                      "2020-01-03 00:00:00",
                      "2020-01-03 12:00:00"
                  };
                  df.set_index(std::make_unique<pandas::Index<std::string>>(dates));
      
                  // Resample to daily
                  auto resampler = df.resample("D");
                  pandas::DataFrame result = resampler.sum();
      
                  // Check that we got aggregated results
                  bool passed = (result.nrows() <= df.nrows());
      
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_timeseries_resample_basic() : resample didn't reduce rows" << std::endl;

.. _example-dataframe-set_index-118:

.. dropdown:: set_index (pd_test_1_all.cpp:20318)
   :class-title: example-dropdown

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

      
                  // Set datetime index
                  std::vector<std::string> dates = {
                      "2020-01-01 00:00:00",
                      "2020-01-01 12:00:00",
                      "2020-01-02 00:00:00",
                      "2020-01-02 12:00:00",
                      "2020-01-03 00:00:00",
                      "2020-01-03 12:00:00"
                  };
                  df.set_index(std::make_unique<pandas::Index<std::string>>(dates));
      
                  // Resample to daily
                  auto resampler = df.resample("D");
                  pandas::DataFrame result = resampler.sum();
      
                  // Check that we got aggregated results
                  bool passed = (result.nrows() <= df.nrows());
      
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_timeseries_resample_basic() : resample didn't reduce rows" << std::endl;

.. _example-dataframe-set_index-119:

.. dropdown:: set_index (pd_test_1_all.cpp:20318)
   :class-title: example-dropdown

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

      
                  // Set datetime index
                  std::vector<std::string> dates = {
                      "2020-01-01 00:00:00",
                      "2020-01-01 12:00:00",
                      "2020-01-02 00:00:00",
                      "2020-01-02 12:00:00",
                      "2020-01-03 00:00:00",
                      "2020-01-03 12:00:00"
                  };
                  df.set_index(std::make_unique<pandas::Index<std::string>>(dates));
      
                  // Resample to daily
                  auto resampler = df.resample("D");
                  pandas::DataFrame result = resampler.sum();
      
                  // Check that we got aggregated results
                  bool passed = (result.nrows() <= df.nrows());
      
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_timeseries_resample_basic() : resample didn't reduce rows" << std::endl;

.. _example-dataframe-set_index-120:

.. dropdown:: set_index (pd_test_1_all.cpp:20318)
   :class-title: example-dropdown

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

      
                  // Set datetime index
                  std::vector<std::string> dates = {
                      "2020-01-01 00:00:00",
                      "2020-01-01 12:00:00",
                      "2020-01-02 00:00:00",
                      "2020-01-02 12:00:00",
                      "2020-01-03 00:00:00",
                      "2020-01-03 12:00:00"
                  };
                  df.set_index(std::make_unique<pandas::Index<std::string>>(dates));
      
                  // Resample to daily
                  auto resampler = df.resample("D");
                  pandas::DataFrame result = resampler.sum();
      
                  // Check that we got aggregated results
                  bool passed = (result.nrows() <= df.nrows());
      
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_timeseries_resample_basic() : resample didn't reduce rows" << std::endl;

.. _example-dataframe-set_index-121:

.. dropdown:: set_index (pd_test_1_all.cpp:20318)
   :class-title: example-dropdown

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

      
                  // Set datetime index
                  std::vector<std::string> dates = {
                      "2020-01-01 00:00:00",
                      "2020-01-01 12:00:00",
                      "2020-01-02 00:00:00",
                      "2020-01-02 12:00:00",
                      "2020-01-03 00:00:00",
                      "2020-01-03 12:00:00"
                  };
                  df.set_index(std::make_unique<pandas::Index<std::string>>(dates));
      
                  // Resample to daily
                  auto resampler = df.resample("D");
                  pandas::DataFrame result = resampler.sum();
      
                  // Check that we got aggregated results
                  bool passed = (result.nrows() <= df.nrows());
      
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_timeseries_resample_basic() : resample didn't reduce rows" << std::endl;

.. _example-dataframe-set_index-122:

.. dropdown:: set_index (pd_test_1_all.cpp:20318)
   :class-title: example-dropdown

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

      
                  // Set datetime index
                  std::vector<std::string> dates = {
                      "2020-01-01 00:00:00",
                      "2020-01-01 12:00:00",
                      "2020-01-02 00:00:00",
                      "2020-01-02 12:00:00",
                      "2020-01-03 00:00:00",
                      "2020-01-03 12:00:00"
                  };
                  df.set_index(std::make_unique<pandas::Index<std::string>>(dates));
      
                  // Resample to daily
                  auto resampler = df.resample("D");
                  pandas::DataFrame result = resampler.sum();
      
                  // Check that we got aggregated results
                  bool passed = (result.nrows() <= df.nrows());
      
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_timeseries_resample_basic() : resample didn't reduce rows" << std::endl;

.. _example-dataframe-set_index-123:

.. dropdown:: set_index (pd_test_1_all.cpp:20318)
   :class-title: example-dropdown

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

      
                  // Set datetime index
                  std::vector<std::string> dates = {
                      "2020-01-01 00:00:00",
                      "2020-01-01 12:00:00",
                      "2020-01-02 00:00:00",
                      "2020-01-02 12:00:00",
                      "2020-01-03 00:00:00",
                      "2020-01-03 12:00:00"
                  };
                  df.set_index(std::make_unique<pandas::Index<std::string>>(dates));
      
                  // Resample to daily
                  auto resampler = df.resample("D");
                  pandas::DataFrame result = resampler.sum();
      
                  // Check that we got aggregated results
                  bool passed = (result.nrows() <= df.nrows());
      
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_timeseries_resample_basic() : resample didn't reduce rows" << std::endl;

.. _example-dataframe-set_index-124:

.. dropdown:: set_index (pd_test_1_all.cpp:20318)
   :class-title: example-dropdown

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

      
                  // Set datetime index
                  std::vector<std::string> dates = {
                      "2020-01-01 00:00:00",
                      "2020-01-01 12:00:00",
                      "2020-01-02 00:00:00",
                      "2020-01-02 12:00:00",
                      "2020-01-03 00:00:00",
                      "2020-01-03 12:00:00"
                  };
                  df.set_index(std::make_unique<pandas::Index<std::string>>(dates));
      
                  // Resample to daily
                  auto resampler = df.resample("D");
                  pandas::DataFrame result = resampler.sum();
      
                  // Check that we got aggregated results
                  bool passed = (result.nrows() <= df.nrows());
      
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_timeseries_resample_basic() : resample didn't reduce rows" << std::endl;

.. _example-dataframe-set_index-125:

.. dropdown:: set_index (pd_test_1_all.cpp:20318)
   :class-title: example-dropdown

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

      
                  // Set datetime index
                  std::vector<std::string> dates = {
                      "2020-01-01 00:00:00",
                      "2020-01-01 12:00:00",
                      "2020-01-02 00:00:00",
                      "2020-01-02 12:00:00",
                      "2020-01-03 00:00:00",
                      "2020-01-03 12:00:00"
                  };
                  df.set_index(std::make_unique<pandas::Index<std::string>>(dates));
      
                  // Resample to daily
                  auto resampler = df.resample("D");
                  pandas::DataFrame result = resampler.sum();
      
                  // Check that we got aggregated results
                  bool passed = (result.nrows() <= df.nrows());
      
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_timeseries_resample_basic() : resample didn't reduce rows" << std::endl;

.. _example-dataframe-set_index_col-126:

.. dropdown:: set_index_col (pd_test_3_all.cpp:828)
   :class-title: example-dropdown

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

          std::cout << "========= DataFrame.set_index_col brace-init overload =====";
      
          // Case A: 2-element brace-init (the C2668 trigger)
          {
              pandas::DataFrame df;
              df.add_column<std::string>("City",   {"London", "London", "NYC", "NYC"});
              df.add_column<std::string>("Name",   {"Alice",  "Bob",    "Carol","Dave"});
              df.add_column<std::int64_t>("Age",   {28, 35, 30, 25});
              df.add_column<std::int64_t>("Salary",{50000, 60000, 55000, 45000});
      
              auto mi_df = df.set_index_col({"City", "Name"});
      
              if (mi_df.ncols() != 2) {
                  throw std::runtime_error("set_index_col brace-init: ncols mismatch");
              }
              if (mi_df.nrows() != 4) {
                  throw std::runtime_error("set_index_col brace-init: nrows mismatch");
              }
          }
      
          // Case B: single-element brace-init

.. _example-dataframe-set_index_col-127:

.. dropdown:: set_index_col (pd_test_3_all.cpp:828)
   :class-title: example-dropdown

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

          std::cout << "========= DataFrame.set_index_col brace-init overload =====";
      
          // Case A: 2-element brace-init (the C2668 trigger)
          {
              pandas::DataFrame df;
              df.add_column<std::string>("City",   {"London", "London", "NYC", "NYC"});
              df.add_column<std::string>("Name",   {"Alice",  "Bob",    "Carol","Dave"});
              df.add_column<std::int64_t>("Age",   {28, 35, 30, 25});
              df.add_column<std::int64_t>("Salary",{50000, 60000, 55000, 45000});
      
              auto mi_df = df.set_index_col({"City", "Name"});
      
              if (mi_df.ncols() != 2) {
                  throw std::runtime_error("set_index_col brace-init: ncols mismatch");
              }
              if (mi_df.nrows() != 4) {
                  throw std::runtime_error("set_index_col brace-init: nrows mismatch");
              }
          }
      
          // Case B: single-element brace-init

.. _example-dataframe-set_index_col-128:

.. dropdown:: set_index_col (pd_test_3_all.cpp:828)
   :class-title: example-dropdown

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

          std::cout << "========= DataFrame.set_index_col brace-init overload =====";
      
          // Case A: 2-element brace-init (the C2668 trigger)
          {
              pandas::DataFrame df;
              df.add_column<std::string>("City",   {"London", "London", "NYC", "NYC"});
              df.add_column<std::string>("Name",   {"Alice",  "Bob",    "Carol","Dave"});
              df.add_column<std::int64_t>("Age",   {28, 35, 30, 25});
              df.add_column<std::int64_t>("Salary",{50000, 60000, 55000, 45000});
      
              auto mi_df = df.set_index_col({"City", "Name"});
      
              if (mi_df.ncols() != 2) {
                  throw std::runtime_error("set_index_col brace-init: ncols mismatch");
              }
              if (mi_df.nrows() != 4) {
                  throw std::runtime_error("set_index_col brace-init: nrows mismatch");
              }
          }
      
          // Case B: single-element brace-init

.. _example-dataframe-set_index_from_column-129:

.. dropdown:: set_index_from_column (pd_test_3_all.cpp:1343)
   :class-title: example-dropdown

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

              df.add_column<int64_t>("v_num", {1, 2, 3, 4});
              df.set_nan_marker("v_str", {true, false, false, true});
              // exact mask-bit assertions depend on Series<string> mask API
          }
      
          // I. set_index_from_column<T>
          {
              pandas::DataFrame df;
              df.add_column<int64_t>("val", {1, 3});
              df.add_column<int64_t>("count", {30, 70});
              df.set_index_from_column<std::string>("group", {"A", "B"});
              if (!df.index_name().has_value() || df.index_name().value() != "group") {
                  throw std::runtime_error("set_index_from_column: name not set");
              }
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      // ============================================================================
      // Category 8: DateTime Functions

.. _example-dataframe-set_index_from_list-130:

.. dropdown:: set_index_from_list (pd_test_3_all.cpp:1236)
   :class-title: example-dropdown

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

      }
      
      void pd_test_3_all_dataframe_pandas_facade_methods() {
          std::cout << "========= DataFrame pandas-style facade methods =======";
      
          // A. set_index_from_list -- string form
          {
              pandas::DataFrame df;
              df.add_column<int64_t>("one", {1, 2, 3, 4});
              df.add_column<int64_t>("two", {18, 20, 20, 18});
              df.set_index_from_list({"a", "b", "c", "d"});
              if (df.nrows() != 4) {
                  throw std::runtime_error("set_index_from_list(string): nrows changed");
              }
              if (df.index().get_value_str(0) != "a" || df.index().get_value_str(3) != "d") {
                  throw std::runtime_error("set_index_from_list(string): values wrong");
              }
          }
      
          // B. set_index_from_list -- int form (reproduces test 1184)
          {

.. _example-dataframe-set_index_from_list-131:

.. dropdown:: set_index_from_list (pd_test_3_all.cpp:1236)
   :class-title: example-dropdown

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

      }
      
      void pd_test_3_all_dataframe_pandas_facade_methods() {
          std::cout << "========= DataFrame pandas-style facade methods =======";
      
          // A. set_index_from_list -- string form
          {
              pandas::DataFrame df;
              df.add_column<int64_t>("one", {1, 2, 3, 4});
              df.add_column<int64_t>("two", {18, 20, 20, 18});
              df.set_index_from_list({"a", "b", "c", "d"});
              if (df.nrows() != 4) {
                  throw std::runtime_error("set_index_from_list(string): nrows changed");
              }
              if (df.index().get_value_str(0) != "a" || df.index().get_value_str(3) != "d") {
                  throw std::runtime_error("set_index_from_list(string): values wrong");
              }
          }
      
          // B. set_index_from_list -- int form (reproduces test 1184)
          {

.. _example-dataframe-set_index_from_list-132:

.. dropdown:: set_index_from_list (pd_test_3_all.cpp:1236)
   :class-title: example-dropdown

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

      }
      
      void pd_test_3_all_dataframe_pandas_facade_methods() {
          std::cout << "========= DataFrame pandas-style facade methods =======";
      
          // A. set_index_from_list -- string form
          {
              pandas::DataFrame df;
              df.add_column<int64_t>("one", {1, 2, 3, 4});
              df.add_column<int64_t>("two", {18, 20, 20, 18});
              df.set_index_from_list({"a", "b", "c", "d"});
              if (df.nrows() != 4) {
                  throw std::runtime_error("set_index_from_list(string): nrows changed");
              }
              if (df.index().get_value_str(0) != "a" || df.index().get_value_str(3) != "d") {
                  throw std::runtime_error("set_index_from_list(string): values wrong");
              }
          }
      
          // B. set_index_from_list -- int form (reproduces test 1184)
          {

.. _example-dataframe-set_index_from_list-133:

.. dropdown:: set_index_from_list (pd_test_3_all.cpp:1236)
   :class-title: example-dropdown

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

      }
      
      void pd_test_3_all_dataframe_pandas_facade_methods() {
          std::cout << "========= DataFrame pandas-style facade methods =======";
      
          // A. set_index_from_list -- string form
          {
              pandas::DataFrame df;
              df.add_column<int64_t>("one", {1, 2, 3, 4});
              df.add_column<int64_t>("two", {18, 20, 20, 18});
              df.set_index_from_list({"a", "b", "c", "d"});
              if (df.nrows() != 4) {
                  throw std::runtime_error("set_index_from_list(string): nrows changed");
              }
              if (df.index().get_value_str(0) != "a" || df.index().get_value_str(3) != "d") {
                  throw std::runtime_error("set_index_from_list(string): values wrong");
              }
          }
      
          // B. set_index_from_list -- int form (reproduces test 1184)
          {

.. _example-dataframe-set_index_from_list-134:

.. dropdown:: set_index_from_list (pd_test_3_all.cpp:1236)
   :class-title: example-dropdown

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

      }
      
      void pd_test_3_all_dataframe_pandas_facade_methods() {
          std::cout << "========= DataFrame pandas-style facade methods =======";
      
          // A. set_index_from_list -- string form
          {
              pandas::DataFrame df;
              df.add_column<int64_t>("one", {1, 2, 3, 4});
              df.add_column<int64_t>("two", {18, 20, 20, 18});
              df.set_index_from_list({"a", "b", "c", "d"});
              if (df.nrows() != 4) {
                  throw std::runtime_error("set_index_from_list(string): nrows changed");
              }
              if (df.index().get_value_str(0) != "a" || df.index().get_value_str(3) != "d") {
                  throw std::runtime_error("set_index_from_list(string): values wrong");
              }
          }
      
          // B. set_index_from_list -- int form (reproduces test 1184)
          {

.. _example-dataframe-set_index_from_list-135:

.. dropdown:: set_index_from_list (pd_test_3_all.cpp:1236)
   :class-title: example-dropdown

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

      }
      
      void pd_test_3_all_dataframe_pandas_facade_methods() {
          std::cout << "========= DataFrame pandas-style facade methods =======";
      
          // A. set_index_from_list -- string form
          {
              pandas::DataFrame df;
              df.add_column<int64_t>("one", {1, 2, 3, 4});
              df.add_column<int64_t>("two", {18, 20, 20, 18});
              df.set_index_from_list({"a", "b", "c", "d"});
              if (df.nrows() != 4) {
                  throw std::runtime_error("set_index_from_list(string): nrows changed");
              }
              if (df.index().get_value_str(0) != "a" || df.index().get_value_str(3) != "d") {
                  throw std::runtime_error("set_index_from_list(string): values wrong");
              }
          }
      
          // B. set_index_from_list -- int form (reproduces test 1184)
          {

.. _example-dataframe-set_index_from_list-136:

.. dropdown:: set_index_from_list (pd_test_3_all.cpp:1236)
   :class-title: example-dropdown

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

      }
      
      void pd_test_3_all_dataframe_pandas_facade_methods() {
          std::cout << "========= DataFrame pandas-style facade methods =======";
      
          // A. set_index_from_list -- string form
          {
              pandas::DataFrame df;
              df.add_column<int64_t>("one", {1, 2, 3, 4});
              df.add_column<int64_t>("two", {18, 20, 20, 18});
              df.set_index_from_list({"a", "b", "c", "d"});
              if (df.nrows() != 4) {
                  throw std::runtime_error("set_index_from_list(string): nrows changed");
              }
              if (df.index().get_value_str(0) != "a" || df.index().get_value_str(3) != "d") {
                  throw std::runtime_error("set_index_from_list(string): values wrong");
              }
          }
      
          // B. set_index_from_list -- int form (reproduces test 1184)
          {

.. _example-dataframe-set_index_from_list-137:

.. dropdown:: set_index_from_list (pd_test_3_all.cpp:1236)
   :class-title: example-dropdown

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

      }
      
      void pd_test_3_all_dataframe_pandas_facade_methods() {
          std::cout << "========= DataFrame pandas-style facade methods =======";
      
          // A. set_index_from_list -- string form
          {
              pandas::DataFrame df;
              df.add_column<int64_t>("one", {1, 2, 3, 4});
              df.add_column<int64_t>("two", {18, 20, 20, 18});
              df.set_index_from_list({"a", "b", "c", "d"});
              if (df.nrows() != 4) {
                  throw std::runtime_error("set_index_from_list(string): nrows changed");
              }
              if (df.index().get_value_str(0) != "a" || df.index().get_value_str(3) != "d") {
                  throw std::runtime_error("set_index_from_list(string): values wrong");
              }
          }
      
          // B. set_index_from_list -- int form (reproduces test 1184)
          {

.. _example-dataframe-set_index_from_list-138:

.. dropdown:: set_index_from_list (pd_test_3_all.cpp:1236)
   :class-title: example-dropdown

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

      }
      
      void pd_test_3_all_dataframe_pandas_facade_methods() {
          std::cout << "========= DataFrame pandas-style facade methods =======";
      
          // A. set_index_from_list -- string form
          {
              pandas::DataFrame df;
              df.add_column<int64_t>("one", {1, 2, 3, 4});
              df.add_column<int64_t>("two", {18, 20, 20, 18});
              df.set_index_from_list({"a", "b", "c", "d"});
              if (df.nrows() != 4) {
                  throw std::runtime_error("set_index_from_list(string): nrows changed");
              }
              if (df.index().get_value_str(0) != "a" || df.index().get_value_str(3) != "d") {
                  throw std::runtime_error("set_index_from_list(string): values wrong");
              }
          }
      
          // B. set_index_from_list -- int form (reproduces test 1184)
          {

.. _example-dataframe-set_index_from_list-139:

.. dropdown:: set_index_from_list (pd_test_3_all.cpp:1236)
   :class-title: example-dropdown

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

      }
      
      void pd_test_3_all_dataframe_pandas_facade_methods() {
          std::cout << "========= DataFrame pandas-style facade methods =======";
      
          // A. set_index_from_list -- string form
          {
              pandas::DataFrame df;
              df.add_column<int64_t>("one", {1, 2, 3, 4});
              df.add_column<int64_t>("two", {18, 20, 20, 18});
              df.set_index_from_list({"a", "b", "c", "d"});
              if (df.nrows() != 4) {
                  throw std::runtime_error("set_index_from_list(string): nrows changed");
              }
              if (df.index().get_value_str(0) != "a" || df.index().get_value_str(3) != "d") {
                  throw std::runtime_error("set_index_from_list(string): values wrong");
              }
          }
      
          // B. set_index_from_list -- int form (reproduces test 1184)
          {

.. _example-dataframe-set_index_from_strings-140:

.. dropdown:: set_index_from_strings (pd_test_3_all.cpp:1284)
   :class-title: example-dropdown

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

      
              pandas::DataFrame df2;
              df2.add_column<int64_t>("val", {3, 4});
              df2.set_integer_index({2, 3});
              if (df2.index().size() != 2) {
                  throw std::runtime_error("set_integer_index: size wrong");
              }
      
              pandas::DataFrame df3;
              df3.add_column<int64_t>("val", {1, 2, 3, 4, 5});
              df3.set_index_from_strings({"a", "b", "c", "a", "b"});
              if (df3.index().get_value_str(4) != "b") {
                  throw std::runtime_error("set_index_from_strings: values wrong");
              }
          }
      
          // E. set_index_name + index_name() getter/setter
          {
              pandas::DataFrame df;
              df.add_column<int64_t>("val", {1, 2, 3});
              df.set_index_from_list({"r0", "r1", "r2"});

.. _example-dataframe-set_index_from_strings-141:

.. dropdown:: set_index_from_strings (pd_test_3_all.cpp:1284)
   :class-title: example-dropdown

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

      
              pandas::DataFrame df2;
              df2.add_column<int64_t>("val", {3, 4});
              df2.set_integer_index({2, 3});
              if (df2.index().size() != 2) {
                  throw std::runtime_error("set_integer_index: size wrong");
              }
      
              pandas::DataFrame df3;
              df3.add_column<int64_t>("val", {1, 2, 3, 4, 5});
              df3.set_index_from_strings({"a", "b", "c", "a", "b"});
              if (df3.index().get_value_str(4) != "b") {
                  throw std::runtime_error("set_index_from_strings: values wrong");
              }
          }
      
          // E. set_index_name + index_name() getter/setter
          {
              pandas::DataFrame df;
              df.add_column<int64_t>("val", {1, 2, 3});
              df.set_index_from_list({"r0", "r1", "r2"});

.. _example-dataframe-set_index_name-142:

.. dropdown:: set_index_name (pd_test_2_all.cpp:20842)
   :class-title: example-dropdown

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

      
      void test_sgb_apply_result_index_categorical() {
          std::cout << "  -- test_sgb_apply_result_index_categorical --" << std::endl;
      
          std::vector<numpy::float64> values = {5.0, 10.0};
          pandas::Series<std::string> by({"A", "B"});
          pandas::Series<numpy::float64> data(values);
      
          auto sgb = data.groupby(by);
          sgb.set_categorical_categories({"A", "B", "C"});
          sgb.set_index_name("cat_key");
      
          pandas::Series<numpy::float64> result(values);
          std::vector<std::string> idx_labels = {"A", "B"};
          result.set_index(std::make_unique<pandas::Index<std::string>>(idx_labels));
      
          sgb.apply_result_index(result);
      
          // Should have CategoricalIndex (dtype_name() returns "category")
          check(result.index().dtype_name() == "category", "is_categorical_index");
      }

.. _example-dataframe-set_index_name-143:

.. dropdown:: set_index_name (pd_test_2_all.cpp:20842)
   :class-title: example-dropdown

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

      
      void test_sgb_apply_result_index_categorical() {
          std::cout << "  -- test_sgb_apply_result_index_categorical --" << std::endl;
      
          std::vector<numpy::float64> values = {5.0, 10.0};
          pandas::Series<std::string> by({"A", "B"});
          pandas::Series<numpy::float64> data(values);
      
          auto sgb = data.groupby(by);
          sgb.set_categorical_categories({"A", "B", "C"});
          sgb.set_index_name("cat_key");
      
          pandas::Series<numpy::float64> result(values);
          std::vector<std::string> idx_labels = {"A", "B"};
          result.set_index(std::make_unique<pandas::Index<std::string>>(idx_labels));
      
          sgb.apply_result_index(result);
      
          // Should have CategoricalIndex (dtype_name() returns "category")
          check(result.index().dtype_name() == "category", "is_categorical_index");
      }

.. _example-dataframe-swaplevel-144:

.. dropdown:: swaplevel (pd_test_1_all.cpp:14461)
   :class-title: example-dropdown

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

              void pd_test_multiindex_swaplevel() {
                  std::cout << "========= swaplevel =================================== ";
      
                  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);
                  pandas::MultiIndex swapped = mi.swaplevel(0, 1);
      
                  bool passed = true;
      
                  // Tuple should be reversed
                  auto tup = swapped[0];
                  if (tup[0] != "x" || tup[1] != "a") {
                      std::cout << "  [FAIL] : swapped tuple should be ('x', 'a')" << std::endl;
                      passed = false;
                  }
      

.. _example-dataframe-swaplevel-145:

.. dropdown:: swaplevel (pd_test_1_all.cpp:14461)
   :class-title: example-dropdown

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

              void pd_test_multiindex_swaplevel() {
                  std::cout << "========= swaplevel =================================== ";
      
                  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);
                  pandas::MultiIndex swapped = mi.swaplevel(0, 1);
      
                  bool passed = true;
      
                  // Tuple should be reversed
                  auto tup = swapped[0];
                  if (tup[0] != "x" || tup[1] != "a") {
                      std::cout << "  [FAIL] : swapped tuple should be ('x', 'a')" << std::endl;
                      passed = false;
                  }
      

.. _example-dataframe-swaplevel-146:

.. dropdown:: swaplevel (pd_test_1_all.cpp:14461)
   :class-title: example-dropdown

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

              void pd_test_multiindex_swaplevel() {
                  std::cout << "========= swaplevel =================================== ";
      
                  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);
                  pandas::MultiIndex swapped = mi.swaplevel(0, 1);
      
                  bool passed = true;
      
                  // Tuple should be reversed
                  auto tup = swapped[0];
                  if (tup[0] != "x" || tup[1] != "a") {
                      std::cout << "  [FAIL] : swapped tuple should be ('x', 'a')" << std::endl;
                      passed = false;
                  }
      

.. _example-dataframe-update-147:

.. dropdown:: update (pd_test_1_all.cpp:13945)
   :class-title: example-dropdown

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

                  if (!result.has_column("C")) {
                      passed = false;
                      std::cout << "  [FAIL] : in pd_test_joining_combine_first() : missing column C" << std::endl;
                      throw std::runtime_error("pd_test_joining_combine_first failed: col C missing");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              // =====================================================================
              // update() Tests
              // =====================================================================
      
              void pd_test_joining_update() {
                  std::cout << "========= update ======================================";
      
                  std::map<std::string, std::vector<double>> left_data = {
                      {"A", {1.0, 2.0, 3.0}},
                      {"B", {10.0, 20.0, 30.0}}
                  };
                  std::vector<std::string> left_idx = {"x", "y", "z"};

.. _example-dataframe-backfill-148:

.. dropdown:: backfill (pd_test_3_all.cpp:2645)
   :class-title: example-dropdown

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

      
      void pd_test_3_all_df_backfill_pad() {
          std::cout << "========= DataFrame.backfill/pad() =======================";
      
          std::map<std::string, std::vector<double>> data = {
              {"A", {1.0, std::nan(""), std::nan(""), 4.0}},
              {"B", {std::nan(""), 2.0, std::nan(""), 4.0}}
          };
          pandas::DataFrame df(data);
      
          // Test backfill (should fill backward)
          pandas::DataFrame bfill_result = df.backfill(0);
          if (bfill_result.nrows() != 4 || bfill_result.ncols() != 2) {
              throw std::runtime_error("backfill shape failed");
          }
      
          // Test pad (should fill forward)
          pandas::DataFrame pad_result = df.pad(0);
          if (pad_result.nrows() != 4 || pad_result.ncols() != 2) {
              throw std::runtime_error("pad shape failed");
          }

.. _example-dataframe-bfill-149:

.. dropdown:: bfill (pd_test_1_all.cpp:23603)
   :class-title: example-dropdown

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

      
              std::cout << "====================================== [OK] pd_test_equals test suite ========================== " << std::endl;
              return 0;
          }
      
      } // namespace dataframe_tests
      // ------------------- pd_test_equals.cpp (end) -----------------------------
      
      // ------------------- pd_test_ffill_bfill.cpp (start) -----------------------------
      // dataframe_tests/pd_test_ffill_bfill.cpp
      // Test file for DataFrame.ffill() and DataFrame.bfill() methods
      
      #include <iostream>
      #include <stdexcept>
      #include <cmath>
      #include <limits>
      #include <map>
      #include "../pandas/pd_dataframe.h"
      
      // CRITICAL: No using namespace directives
      

.. _example-dataframe-ffill-150:

.. dropdown:: ffill (pd_test_1_all.cpp:23603)
   :class-title: example-dropdown

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

      
              std::cout << "====================================== [OK] pd_test_equals test suite ========================== " << std::endl;
              return 0;
          }
      
      } // namespace dataframe_tests
      // ------------------- pd_test_equals.cpp (end) -----------------------------
      
      // ------------------- pd_test_ffill_bfill.cpp (start) -----------------------------
      // dataframe_tests/pd_test_ffill_bfill.cpp
      // Test file for DataFrame.ffill() and DataFrame.bfill() methods
      
      #include <iostream>
      #include <stdexcept>
      #include <cmath>
      #include <limits>
      #include <map>
      #include "../pandas/pd_dataframe.h"
      
      // CRITICAL: No using namespace directives
      

.. _example-dataframe-fillna-151:

.. 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-dataframe-fillna-152:

.. 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-dataframe-fillna-153:

.. 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-dataframe-fillna-154:

.. 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-dataframe-fillna-155:

.. 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-dataframe-interpolate-156:

.. dropdown:: interpolate (pd_test_1_all.cpp:24365)
   :class-title: example-dropdown

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

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

.. _example-dataframe-isna-157:

.. 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-dataframe-isna_frame-158:

.. dropdown:: isna_frame (pd_test_3_all.cpp:10770)
   :class-title: example-dropdown

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

              if (dtype_name.find("int") == std::string::npos) {
                  std::cout << "  [FAIL] : in pd_test_3_all_niche_residual_fixes() : Case 3 dtype" << std::endl;
                  throw std::runtime_error("pd_test_3_all_niche_residual_fixes failed: Case 3 dtype");
              }
              if (r[static_cast<size_t>(0)] != 50) {
                  std::cout << "  [FAIL] : in pd_test_3_all_niche_residual_fixes() : Case 3 value" << std::endl;
                  throw std::runtime_error("pd_test_3_all_niche_residual_fixes failed: Case 3 value");
              }
          }
      
          // --- Case 4: isna_frame().to_string() ---
          {
              pandas::DataFrame df;
              df.add_column<double>("A", {1.0, std::nan(""), 3.0});
              df.add_column<double>("B", {std::nan(""), 2.0, std::nan("")});
              std::string s = df.isna_frame().to_string();
              if (s.empty()) {
                  std::cout << "  [FAIL] : in pd_test_3_all_niche_residual_fixes() : Case 4 empty" << std::endl;
                  throw std::runtime_error("pd_test_3_all_niche_residual_fixes failed: Case 4 empty");
              }
              // Also verify existing NDArray-returning isna() still compiles

.. _example-dataframe-isnull-159:

.. 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-dataframe-isnull_frame-160:

.. dropdown:: isnull_frame (pd_test_5_all.cpp:34434)
   :class-title: example-dropdown

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

          pandas_tests::check(row_mi_ok, "case2.notna_preserves_row_multiindex", local_fail);
          pandas_tests::check(lvl_vals_ok, "case2.notna_preserves_level_values", local_fail);
      }
      
      void isnamultiindex_629108_case_3_isnull_alias_row_mi_only(int& local_fail) {
          const std::string tag = "[case3]";
          std::cout << "\n" << tag << " === isnull_frame alias: row MI only ===\n";
          bool row_mi_ok = false;
          try {
              auto df = mk_row_mi_only();
              auto out = df.isnull_frame();
              dump_df_mi_state(tag, "isnull", out);
              row_mi_ok = out.has_multiindex();
          } catch (const std::exception& e) {
              std::cout << tag << " exception: " << e.what() << "\n";
          }
          pandas_tests::check(row_mi_ok, "case3.isnull_preserves_row_multiindex", local_fail);
      }
      
      void isnamultiindex_629108_case_4_notnull_alias_row_mi_only(int& local_fail) {
          const std::string tag = "[case4]";

.. _example-dataframe-notna-161:

.. 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-dataframe-notna_frame-162:

.. dropdown:: notna_frame (pd_test_5_all.cpp:34411)
   :class-title: example-dropdown

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

          pandas_tests::check(lvl_vals_ok, "case1.isna_preserves_level_values", local_fail);
      }
      
      void isnamultiindex_629108_case_2_notna_row_mi_only(int& local_fail) {
          const std::string tag = "[case2]";
          std::cout << "\n" << tag << " === notna_frame: row MI only ===\n";
          bool row_mi_ok = false;
          bool lvl_vals_ok = false;
          try {
              auto df = mk_row_mi_only();
              auto out = df.notna_frame();
              dump_df_mi_state(tag, "src",   df);
              dump_df_mi_state(tag, "notna", out);
              row_mi_ok = out.has_multiindex();
              if (row_mi_ok) {
                  const auto& lv0 = out.multiindex().get_level_values_str(0);
                  const auto& lv1 = out.multiindex().get_level_values_str(1);
                  lvl_vals_ok = (lv0.size() == 3 && lv0[0] == "A" && lv0[1] == "A" && lv0[2] == "A"
                                 && lv1.size() == 3 && lv1[0] == "B" && lv1[1] == "C" && lv1[2] == "D");
              }
          } catch (const std::exception& e) {

.. _example-dataframe-notnull-163:

.. 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-dataframe-notnull_frame-164:

.. dropdown:: notnull_frame (pd_test_5_all.cpp:34449)
   :class-title: example-dropdown

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

          }
          pandas_tests::check(row_mi_ok, "case3.isnull_preserves_row_multiindex", local_fail);
      }
      
      void isnamultiindex_629108_case_4_notnull_alias_row_mi_only(int& local_fail) {
          const std::string tag = "[case4]";
          std::cout << "\n" << tag << " === notnull_frame alias: row MI only ===\n";
          bool row_mi_ok = false;
          try {
              auto df = mk_row_mi_only();
              auto out = df.notnull_frame();
              dump_df_mi_state(tag, "notnull", out);
              row_mi_ok = out.has_multiindex();
          } catch (const std::exception& e) {
              std::cout << tag << " exception: " << e.what() << "\n";
          }
          pandas_tests::check(row_mi_ok, "case4.notnull_preserves_row_multiindex", local_fail);
      }
      
      void isnamultiindex_629108_case_5_isna_row_mi_and_col_mi(int& local_fail) {
          const std::string tag = "[case5]";

.. _example-dataframe-pad-165:

.. dropdown:: pad (pd_test_3_all.cpp:1771)
   :class-title: example-dropdown

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

      
          if (result_single.nrows() != 3 || result_single.ncols() != 1) {
              std::cout << "  [FAIL] : in pd_test_3_all_dataframe_unstack() : single col shape mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_dataframe_unstack failed: single col shape");
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_fbbuilder_pad() {
          std::cout << "========= FBBuilder.pad() (internal) =================";
      
          // Note: FBBuilder.pad() is an internal method for FlatBuffer serialization
          // It's not the pandas DataFrame.pad() method (which is ffill alias)
          // This test verifies the to_feather() serialization works, which uses FBBuilder.pad()
      
          std::map<std::string, std::vector<double>> data = {
              {"A", {1.0, 2.0, 3.0}},
              {"B", {4.0, 5.0, 6.0}}
          };
          pandas::DataFrame df(data);

.. _example-dataframe-count-166:

.. dropdown:: count (pd_test_1_all.cpp:66)
   :class-title: example-dropdown

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

              if (arr.is_na(0)) {
                  std::cout << "  [FAIL] : in pd_test_boolean_array_na_handling() : is_na(0) should be false" << std::endl;
                  throw std::runtime_error("pd_test_boolean_array_na_handling failed: is_na(0) should be false");
              }
      
              if (!arr.has_na()) {
                  std::cout << "  [FAIL] : in pd_test_boolean_array_na_handling() : has_na() should be true" << std::endl;
                  throw std::runtime_error("pd_test_boolean_array_na_handling failed: has_na() should be true");
              }
      
              if (arr.count() != 2) {
                  std::cout << "  [FAIL] : in pd_test_boolean_array_na_handling() : count() should be 2" << std::endl;
                  throw std::runtime_error("pd_test_boolean_array_na_handling failed: count() should be 2");
              }
      
              std::cout << " -> tests passed" << std::endl;
          }
      
          void pd_test_boolean_array_kleene_and() {
              std::cout << "========= BooleanArray: Kleene AND ======================= ";
      

.. _example-dataframe-count-167:

.. dropdown:: count (pd_test_1_all.cpp:66)
   :class-title: example-dropdown

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

              if (arr.is_na(0)) {
                  std::cout << "  [FAIL] : in pd_test_boolean_array_na_handling() : is_na(0) should be false" << std::endl;
                  throw std::runtime_error("pd_test_boolean_array_na_handling failed: is_na(0) should be false");
              }
      
              if (!arr.has_na()) {
                  std::cout << "  [FAIL] : in pd_test_boolean_array_na_handling() : has_na() should be true" << std::endl;
                  throw std::runtime_error("pd_test_boolean_array_na_handling failed: has_na() should be true");
              }
      
              if (arr.count() != 2) {
                  std::cout << "  [FAIL] : in pd_test_boolean_array_na_handling() : count() should be 2" << std::endl;
                  throw std::runtime_error("pd_test_boolean_array_na_handling failed: count() should be 2");
              }
      
              std::cout << " -> tests passed" << std::endl;
          }
      
          void pd_test_boolean_array_kleene_and() {
              std::cout << "========= BooleanArray: Kleene AND ======================= ";
      

.. _example-dataframe-count_cols-168:

.. dropdown:: count_cols (pd_test_1_all.cpp:6386)
   :class-title: example-dropdown

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

                  }
      
                  // Test max
                  auto maxs = df.max_cols();
                  if (std::abs(maxs[0] - 5.0) > 1e-10) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_aggregations() : max A != 5" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_aggregations failed: max A != 5");
                  }
      
                  // Test count
                  auto counts = df.count_cols();
                  if (counts[0] != 5) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_aggregations() : count A != 5" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_aggregations failed: count A != 5");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              // =====================================================================
              // Test: Sorting

.. _example-dataframe-cummax-169:

.. dropdown:: cummax (pd_test_1_all.cpp:5152)
   :class-title: example-dropdown

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

                  // cummin: [1, 1, 1, 1]
                  auto cmin = df.cummin();
                  val = cmin["A"].get_value_str(3);
                  passed = std::abs(std::stod(val) - 1.0) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_dataframe_cumulative() : cummin failed" << std::endl;
                      throw std::runtime_error("pd_test_arithmetic_dataframe_cumulative failed: cummin failed");
                  }
      
                  // cummax: [1, 2, 3, 4]
                  auto cmax = df.cummax();
                  val = cmax["A"].get_value_str(2);
                  passed = std::abs(std::stod(val) - 3.0) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_dataframe_cumulative() : cummax failed" << std::endl;
                      throw std::runtime_error("pd_test_arithmetic_dataframe_cumulative failed: cummax failed");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      

.. _example-dataframe-cummin-170:

.. dropdown:: cummin (pd_test_1_all.cpp:5143)
   :class-title: example-dropdown

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

                  // cumprod: [1, 2, 6, 24]
                  auto cp = df.cumprod();
                  val = cp["A"].get_value_str(3);
                  passed = std::abs(std::stod(val) - 24.0) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_dataframe_cumulative() : cumprod failed" << std::endl;
                      throw std::runtime_error("pd_test_arithmetic_dataframe_cumulative failed: cumprod failed");
                  }
      
                  // cummin: [1, 1, 1, 1]
                  auto cmin = df.cummin();
                  val = cmin["A"].get_value_str(3);
                  passed = std::abs(std::stod(val) - 1.0) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_dataframe_cumulative() : cummin failed" << std::endl;
                      throw std::runtime_error("pd_test_arithmetic_dataframe_cumulative failed: cummin failed");
                  }
      
                  // cummax: [1, 2, 3, 4]
                  auto cmax = df.cummax();
                  val = cmax["A"].get_value_str(2);

.. _example-dataframe-cumprod-171:

.. dropdown:: cumprod (pd_test_1_all.cpp:5134)
   :class-title: example-dropdown

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

                  // cumsum: [1, 3, 6, 10]
                  auto cs = df.cumsum();
                  std::string val = cs["A"].get_value_str(2);
                  bool passed = std::abs(std::stod(val) - 6.0) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_dataframe_cumulative() : cumsum failed" << std::endl;
                      throw std::runtime_error("pd_test_arithmetic_dataframe_cumulative failed: cumsum failed");
                  }
      
                  // cumprod: [1, 2, 6, 24]
                  auto cp = df.cumprod();
                  val = cp["A"].get_value_str(3);
                  passed = std::abs(std::stod(val) - 24.0) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_dataframe_cumulative() : cumprod failed" << std::endl;
                      throw std::runtime_error("pd_test_arithmetic_dataframe_cumulative failed: cumprod failed");
                  }
      
                  // cummin: [1, 1, 1, 1]
                  auto cmin = df.cummin();
                  val = cmin["A"].get_value_str(3);

.. _example-dataframe-cumsum-172:

.. dropdown:: cumsum (pd_test_1_all.cpp:5125)
   :class-title: example-dropdown

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

              }
      
              void pd_test_arithmetic_dataframe_cumulative() {
                  std::cout << "========= DataFrame cumulative ==================";
      
                  std::map<std::string, std::vector<double>> data;
                  data["A"] = {1.0, 2.0, 3.0, 4.0};
                  pandas::DataFrame df(data);
      
                  // cumsum: [1, 3, 6, 10]
                  auto cs = df.cumsum();
                  std::string val = cs["A"].get_value_str(2);
                  bool passed = std::abs(std::stod(val) - 6.0) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_dataframe_cumulative() : cumsum failed" << std::endl;
                      throw std::runtime_error("pd_test_arithmetic_dataframe_cumulative failed: cumsum failed");
                  }
      
                  // cumprod: [1, 2, 6, 24]
                  auto cp = df.cumprod();
                  val = cp["A"].get_value_str(3);

.. _example-dataframe-describe-173:

.. dropdown:: describe (pd_test_2_all.cpp:19793)
   :class-title: example-dropdown

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

              ++g_fail;
          }
      }
      
      static bool approx_eq(double a, double b, double tol = 1e-9) {
          if (std::isnan(a) && std::isnan(b)) return true;
          return std::abs(a - b) < tol;
      }
      
      // =====================================================================
      // Test: describe() default mode — numeric columns only
      // =====================================================================
      
      void pd_test_describe_numeric_only() {
          std::cout << "  -- pd_test_describe_numeric_only --" << std::endl;
      
          pandas::DataFrame df;
          df.add_column("A", std::vector<double>{1.0, 2.0, 3.0, 4.0, 5.0});
          df.add_column("B", std::vector<double>{10.0, 20.0, 30.0, 40.0, 50.0});
          df.add_column("Name", std::vector<std::string>{"a", "b", "c", "d", "e"});
      

.. _example-dataframe-describe_full-174:

.. dropdown:: describe_full (pd_test_2_all.cpp:19758)
   :class-title: example-dropdown

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

                    << (dataframe_tests_broadcasting::g_fail == 0 ? "OK" : "FAIL")
                    << "] pd_test_broadcasting test suite ==========================" << std::endl;
      
          return dataframe_tests_broadcasting::g_fail;
      }
      
      } // namespace dataframe_tests
      // ------------------- pd_test_broadcasting.cpp (end) -----------------------------
      
      // ------------------- pd_test_describe.cpp (start) -----------------------------
      // pd_test_describe.cpp - Tests for describe_full() migration
      // StringColumnStats, compute_string_column_stats(), describe_full() modes
      
      #include <iostream>
      #include <string>
      #include <vector>
      #include <cmath>
      
      #include "../pandas/pd_dataframe.h"
      #include "../pandas/pd_series.h"
      #include "../pandas/pd_index.h"

.. _example-dataframe-kurt-175:

.. dropdown:: kurt (pd_test_1_all.cpp:4599)
   :class-title: example-dropdown

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

                  std::cout << "========= Series skew/kurt ======================";
      
                  pandas::Series<double> s({1.0, 2.0, 2.0, 3.0, 9.0});
                  auto skew_val = s.skew();
                  bool passed = skew_val.has_value() && *skew_val > 0;  // Should be right-skewed
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_aggregation_series_skew_kurt() : skew should be positive" << std::endl;
                      throw std::runtime_error("pd_test_aggregation_series_skew_kurt failed: skew should be positive");
                  }
      
                  auto kurt_val = s.kurt();
                  passed = kurt_val.has_value();
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_aggregation_series_skew_kurt() : kurt should have value" << std::endl;
                      throw std::runtime_error("pd_test_aggregation_series_skew_kurt failed: kurt should have value");
                  }
      
                  // Test kurtosis alias
                  auto kurt_alias = s.kurtosis();
                  passed = kurt_alias.has_value() && std::abs(*kurt_alias - *kurt_val) < 0.0001;
                  if (!passed) {

.. _example-dataframe-kurt_cols-176:

.. dropdown:: kurt_cols (pd_test_1_all.cpp:4786)
   :class-title: example-dropdown

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

                      throw std::runtime_error("pd_test_aggregation_dataframe_skew_kurt_cols failed: skew_cols should return 1 value");
                  }
      
                  // Skew should be positive for right-skewed data
                  passed = skew[0] > 0;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_aggregation_dataframe_skew_kurt_cols() : skew should be positive" << std::endl;
                      throw std::runtime_error("pd_test_aggregation_dataframe_skew_kurt_cols failed: skew should be positive");
                  }
      
                  auto kurt = df.kurt_cols();
                  passed = kurt.size() == 1 && !std::isnan(kurt[0]);
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_aggregation_dataframe_skew_kurt_cols() : kurt_cols should return valid value" << std::endl;
                      throw std::runtime_error("pd_test_aggregation_dataframe_skew_kurt_cols failed: kurt_cols should return valid value");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
          } // namespace dataframe_tests_aggregation

.. _example-dataframe-kurtosis-177:

.. dropdown:: kurtosis (pd_test_1_all.cpp:4607)
   :class-title: example-dropdown

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

                  }
      
                  auto kurt_val = s.kurt();
                  passed = kurt_val.has_value();
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_aggregation_series_skew_kurt() : kurt should have value" << std::endl;
                      throw std::runtime_error("pd_test_aggregation_series_skew_kurt failed: kurt should have value");
                  }
      
                  // Test kurtosis alias
                  auto kurt_alias = s.kurtosis();
                  passed = kurt_alias.has_value() && std::abs(*kurt_alias - *kurt_val) < 0.0001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_aggregation_series_skew_kurt() : kurtosis alias failed" << std::endl;
                      throw std::runtime_error("pd_test_aggregation_series_skew_kurt failed: kurtosis alias failed");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_aggregation_series_pct_change() {

.. _example-dataframe-max-178:

.. 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-dataframe-max_cols-179:

.. dropdown:: max_cols (pd_test_1_all.cpp:6379)
   :class-title: example-dropdown

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

                  }
      
                  // Test min
                  auto mins = df.min_cols();
                  if (std::abs(mins[0] - 1.0) > 1e-10) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_aggregations() : min A != 1" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_aggregations failed: min A != 1");
                  }
      
                  // Test max
                  auto maxs = df.max_cols();
                  if (std::abs(maxs[0] - 5.0) > 1e-10) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_aggregations() : max A != 5" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_aggregations failed: max A != 5");
                  }
      
                  // Test count
                  auto counts = df.count_cols();
                  if (counts[0] != 5) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_aggregations() : count A != 5" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_aggregations failed: count A != 5");

.. _example-dataframe-mean-180:

.. dropdown:: mean (pd_test_1_all.cpp:282)
   :class-title: example-dropdown

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

                  std::optional<bool>(true),
                  std::optional<bool>(true)
              });
      
              auto s = arr.sum();
              if (!s.has_value() || s.value() != 3) {
                  std::cout << "  [FAIL] : in pd_test_boolean_array_reductions() : sum should be 3" << std::endl;
                  throw std::runtime_error("pd_test_boolean_array_reductions failed: sum");
              }
      
              auto m = arr.mean();
              if (!m.has_value() || std::abs(m.value() - 0.75) > 0.001) {
                  std::cout << "  [FAIL] : in pd_test_boolean_array_reductions() : mean should be 0.75" << std::endl;
                  throw std::runtime_error("pd_test_boolean_array_reductions failed: mean");
              }
      
              std::cout << " -> tests passed" << std::endl;
          }
      
          void pd_test_boolean_array_dtype() {
              std::cout << "========= BooleanArray: dtype ======================= ";

.. _example-dataframe-mean_cols-181:

.. dropdown:: mean_cols (pd_test_1_all.cpp:6364)
   :class-title: example-dropdown

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

                  if (std::abs(sum_a - 15.0) > 1e-10) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_aggregations() : sum A != 15" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_aggregations failed: sum A != 15");
                  }
                  if (std::abs(sum_b - 150.0) > 1e-10) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_aggregations() : sum B != 150" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_aggregations failed: sum B != 150");
                  }
      
                  // Test mean
                  auto means = df.mean_cols();
                  double mean_a = means[0];
                  if (std::abs(mean_a - 3.0) > 1e-10) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_aggregations() : mean A != 3" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_aggregations failed: mean A != 3");
                  }
      
                  // Test min
                  auto mins = df.min_cols();
                  if (std::abs(mins[0] - 1.0) > 1e-10) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_aggregations() : min A != 1" << std::endl;

.. _example-dataframe-median-182:

.. dropdown:: median (pd_test_1_all.cpp:20910)
   :class-title: example-dropdown

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

                      throw std::runtime_error("pd_test_expanding_var failed: expanding var values incorrect");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_expanding_median() {
                  std::cout << "========= Expanding median ======================";
      
                  pandas::Series<double> s({1.0, 2.0, 3.0, 4.0, 5.0});
                  auto result = s.expanding().median();
      
                  // Expanding median: 1, 1.5, 2, 2.5, 3
                  bool passed = std::abs(result[0] - 1.0) < 0.001 &&
                                std::abs(result[1] - 1.5) < 0.001 &&
                                std::abs(result[2] - 2.0) < 0.001 &&
                                std::abs(result[3] - 2.5) < 0.001 &&
                                std::abs(result[4] - 3.0) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_expanding_median() : expanding median values incorrect" << std::endl;
                      throw std::runtime_error("pd_test_expanding_median failed: expanding median values incorrect");

.. _example-dataframe-median_cols-183:

.. dropdown:: median_cols (pd_test_1_all.cpp:24860)
   :class-title: example-dropdown

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

      
              std::cout << "====================================== [OK] pd_test_interpolate test suite ========================== " << std::endl;
              return 0;
          }
      
      } // namespace dataframe_tests
      // ------------------- pd_test_interpolate.cpp (end) -----------------------------
      
      // ------------------- pd_test_median.cpp (start) -----------------------------
      // dataframe_tests/pd_test_median.cpp
      // Tests for DataFrame.median() and DataFrame.median_cols() methods
      
      #include <iostream>
      #include <stdexcept>
      #include <cmath>
      #include <limits>
      #include "../pandas/pd_dataframe.h"
      
      // CRITICAL: No using namespace directives
      
      namespace dataframe_tests {

.. _example-dataframe-min-184:

.. 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-dataframe-min_cols-185:

.. dropdown:: min_cols (pd_test_1_all.cpp:6372)
   :class-title: example-dropdown

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

      
                  // Test mean
                  auto means = df.mean_cols();
                  double mean_a = means[0];
                  if (std::abs(mean_a - 3.0) > 1e-10) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_aggregations() : mean A != 3" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_aggregations failed: mean A != 3");
                  }
      
                  // Test min
                  auto mins = df.min_cols();
                  if (std::abs(mins[0] - 1.0) > 1e-10) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_aggregations() : min A != 1" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_aggregations failed: min A != 1");
                  }
      
                  // Test max
                  auto maxs = df.max_cols();
                  if (std::abs(maxs[0] - 5.0) > 1e-10) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_aggregations() : max A != 5" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_aggregations failed: max A != 5");

.. _example-dataframe-mode-186:

.. dropdown:: mode (pd_test_1_all.cpp:4569)
   :class-title: example-dropdown

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

                      throw std::runtime_error("pd_test_aggregation_series_quantile failed: quantile(1) should be 5.0");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_aggregation_series_mode() {
                  std::cout << "========= Series mode ===========================";
      
                  pandas::Series<int> s({1, 2, 2, 3, 3, 3});
                  auto m = s.mode();
                  bool passed = m.size() == 1 && m[0] == 3;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_aggregation_series_mode() : mode should be 3" << std::endl;
                      throw std::runtime_error("pd_test_aggregation_series_mode failed: mode should be 3");
                  }
      
                  // Test multi-mode
                  pandas::Series<int> s2({1, 1, 2, 2});
                  auto m2 = s2.mode();
                  passed = m2.size() == 2;  // Both 1 and 2 are modes

.. _example-dataframe-nunique-187:

.. 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-dataframe-nunique_cols-188:

.. dropdown:: nunique_cols (pd_test_1_all.cpp:25375)
   :class-title: example-dropdown

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

      
              std::cout << "====================================== [OK] pd_test_mode test suite ========================== " << std::endl;
              return 0;
          }
      
      } // namespace dataframe_tests
      // ------------------- pd_test_mode.cpp (end) -----------------------------
      
      // ------------------- pd_test_nunique.cpp (start) -----------------------------
      // dataframe_tests/pd_test_nunique.cpp
      // Tests for DataFrame.nunique() and DataFrame.nunique_cols() methods
      
      #include <iostream>
      #include <stdexcept>
      #include <cmath>
      #include <limits>
      #include "../pandas/pd_dataframe.h"
      
      // CRITICAL: No using namespace directives
      
      namespace dataframe_tests {

.. _example-dataframe-prod-189:

.. dropdown:: prod (pd_test_1_all.cpp:26082)
   :class-title: example-dropdown

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

      
              std::cout << "====================================== [OK] pd_test_pivot_table test suite ========================== " << std::endl;
              return 0;
          }
      
      } // namespace dataframe_tests
      // ------------------- pd_test_pivot_table.cpp (end) -----------------------------
      
      // ------------------- pd_test_prod.cpp (start) -----------------------------
      // dataframe_tests/pd_test_prod.cpp
      // Tests for DataFrame.prod() and DataFrame.prod_cols() methods
      
      #include <iostream>
      #include <stdexcept>
      #include <cmath>
      #include <limits>
      #include "../pandas/pd_dataframe.h"
      
      // CRITICAL: No using namespace directives
      
      namespace dataframe_tests {

.. _example-dataframe-prod_cols-190:

.. dropdown:: prod_cols (pd_test_1_all.cpp:26082)
   :class-title: example-dropdown

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

      
              std::cout << "====================================== [OK] pd_test_pivot_table test suite ========================== " << std::endl;
              return 0;
          }
      
      } // namespace dataframe_tests
      // ------------------- pd_test_pivot_table.cpp (end) -----------------------------
      
      // ------------------- pd_test_prod.cpp (start) -----------------------------
      // dataframe_tests/pd_test_prod.cpp
      // Tests for DataFrame.prod() and DataFrame.prod_cols() methods
      
      #include <iostream>
      #include <stdexcept>
      #include <cmath>
      #include <limits>
      #include "../pandas/pd_dataframe.h"
      
      // CRITICAL: No using namespace directives
      
      namespace dataframe_tests {

.. _example-dataframe-product-191:

.. dropdown:: product (pd_test_3_all.cpp:2584)
   :class-title: example-dropdown

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

          // Test quantile along rows
          pandas::Series<numpy::float64> q50_rows = df.quantile(0.5, 1);
          if (q50_rows.size() != 5) {
              throw std::runtime_error("quantile(0.5, axis=1) failed");
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_df_product() {
          std::cout << "========= DataFrame.product(axis) ========================";
      
          std::map<std::string, std::vector<double>> data = {
              {"A", {1.0, 2.0, 3.0}},
              {"B", {4.0, 5.0, 6.0}}
          };
          pandas::DataFrame df(data);
      
          // Test product along columns
          pandas::Series<numpy::float64> prod_cols = df.product(0);
          if (prod_cols.size() != 2 || std::abs(prod_cols[static_cast<size_t>(0)] - 6.0) > 0.001 ||

.. _example-dataframe-quantile-192:

.. dropdown:: quantile (pd_test_1_all.cpp:4540)
   :class-title: example-dropdown

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

                      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() {
                  std::cout << "========= Series quantile =======================";
      
                  pandas::Series<double> s({1.0, 2.0, 3.0, 4.0, 5.0});
                  auto q50 = s.quantile(0.5);
                  bool passed = q50.has_value() && std::abs(*q50 - 3.0) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_aggregation_series_quantile() : quantile(0.5) should be 3.0" << std::endl;
                      throw std::runtime_error("pd_test_aggregation_series_quantile failed: quantile(0.5) should be 3.0");
                  }
      
                  // Test q=0 and q=1
                  auto q0 = s.quantile(0.0);
                  passed = q0.has_value() && std::abs(*q0 - 1.0) < 0.001;
                  if (!passed) {

.. _example-dataframe-quantile_cols-193:

.. dropdown:: quantile_cols (pd_test_1_all.cpp:4753)
   :class-title: example-dropdown

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

              }
      
              void pd_test_aggregation_dataframe_quantile_cols() {
                  std::cout << "========= DataFrame quantile_cols ===============";
      
                  std::map<std::string, std::vector<double>> data;
                  data["A"] = {1.0, 2.0, 3.0, 4.0, 5.0};
                  data["B"] = {10.0, 20.0, 30.0, 40.0, 50.0};
                  pandas::DataFrame df(data);
      
                  auto q50 = df.quantile_cols(0.5);
      
                  // Check A median = 3.0
                  bool passed = std::abs(q50[0] - 3.0) < 0.001 || std::abs(q50[1] - 3.0) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_aggregation_dataframe_quantile_cols() : A median should be 3.0" << std::endl;
                      throw std::runtime_error("pd_test_aggregation_dataframe_quantile_cols failed: A median should be 3.0");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }

.. _example-dataframe-sem-194:

.. dropdown:: sem (pd_test_1_all.cpp:4525)
   :class-title: example-dropdown

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

      #include "../pandas/pd_dataframe.h"
      #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;
              }
      

.. _example-dataframe-skew-195:

.. dropdown:: skew (pd_test_1_all.cpp:4592)
   :class-title: example-dropdown

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

                      throw std::runtime_error("pd_test_aggregation_series_mode failed: multi-mode should return 2 values");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_aggregation_series_skew_kurt() {
                  std::cout << "========= Series skew/kurt ======================";
      
                  pandas::Series<double> s({1.0, 2.0, 2.0, 3.0, 9.0});
                  auto skew_val = s.skew();
                  bool passed = skew_val.has_value() && *skew_val > 0;  // Should be right-skewed
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_aggregation_series_skew_kurt() : skew should be positive" << std::endl;
                      throw std::runtime_error("pd_test_aggregation_series_skew_kurt failed: skew should be positive");
                  }
      
                  auto kurt_val = s.kurt();
                  passed = kurt_val.has_value();
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_aggregation_series_skew_kurt() : kurt should have value" << std::endl;

.. _example-dataframe-skew_cols-196:

.. dropdown:: skew_cols (pd_test_1_all.cpp:4772)
   :class-title: example-dropdown

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

                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_aggregation_dataframe_skew_kurt_cols() {
                  std::cout << "========= DataFrame skew/kurt_cols ==============";
      
                  std::map<std::string, std::vector<double>> data;
                  data["A"] = {1.0, 2.0, 2.0, 3.0, 9.0};
                  pandas::DataFrame df(data);
      
                  auto skew = df.skew_cols();
                  bool passed = skew.size() == 1;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_aggregation_dataframe_skew_kurt_cols() : skew_cols should return 1 value" << std::endl;
                      throw std::runtime_error("pd_test_aggregation_dataframe_skew_kurt_cols failed: skew_cols should return 1 value");
                  }
      
                  // Skew should be positive for right-skewed data
                  passed = skew[0] > 0;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_aggregation_dataframe_skew_kurt_cols() : skew should be positive" << std::endl;

.. _example-dataframe-std-197:

.. 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-dataframe-std_-198:

.. dropdown:: std_ (pd_test_1_all.cpp:20752)
   :class-title: example-dropdown

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

                      throw std::runtime_error("pd_test_rolling_min_periods failed: with min_periods=1, idx 1 should be 3.0");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_rolling_std() {
                  std::cout << "========= Rolling std ===========================";
      
                  pandas::Series<double> s({1.0, 2.0, 3.0, 4.0, 5.0});
                  auto result = s.rolling(3).std_();
      
                  // std([1,2,3]) = 1.0 (ddof=1)
                  // std([2,3,4]) = 1.0
                  // std([3,4,5]) = 1.0
                  bool passed = std::abs(result[2] - 1.0) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_rolling_std() : rolling std should be 1.0" << std::endl;
                      throw std::runtime_error("pd_test_rolling_std failed: rolling std should be 1.0");
                  }
      

.. _example-dataframe-std_-199:

.. dropdown:: std_ (pd_test_1_all.cpp:20752)
   :class-title: example-dropdown

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

                      throw std::runtime_error("pd_test_rolling_min_periods failed: with min_periods=1, idx 1 should be 3.0");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_rolling_std() {
                  std::cout << "========= Rolling std ===========================";
      
                  pandas::Series<double> s({1.0, 2.0, 3.0, 4.0, 5.0});
                  auto result = s.rolling(3).std_();
      
                  // std([1,2,3]) = 1.0 (ddof=1)
                  // std([2,3,4]) = 1.0
                  // std([3,4,5]) = 1.0
                  bool passed = std::abs(result[2] - 1.0) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_rolling_std() : rolling std should be 1.0" << std::endl;
                      throw std::runtime_error("pd_test_rolling_std failed: rolling std should be 1.0");
                  }
      

.. _example-dataframe-std_cols-200:

.. dropdown:: std_cols (pd_test_plan_coverage_gaps.cpp:130)
   :class-title: example-dropdown

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

      
          if (local_fail > 0) throw std::runtime_error("pd_test_cut_retbins_front_equals_min_val_right_false failed");
          std::cout << " -> tests passed" << std::endl;
      }
      
      // -------------------------------------------------------------------------
      // plan_float_reduction_precision — DataFrame axis=0 reducers coverage (R10 gap)
      //
      // The `_3` suite only exercises Series<double>::sum/mean/var/std. The plan's
      // R10 Files-to-Update adds classify_column_dtypes (DataFrame::sum(axis=0)),
      // mean_cols() (DataFrame::mean(axis=0), describe), and std_cols()
      // (DataFrame::std/var(axis=0), describe). None are touched by _3 assertions.
      // -------------------------------------------------------------------------
      void pd_test_dataframe_sum_axis0_small() {
          std::cout << "========= DataFrame::sum(axis=0) small-data sanity =======";
          int local_fail = 0;
      
          std::map<std::string, std::vector<double>> data = {
              {"A", {1.0, 2.0, 3.0, 4.0}},
              {"B", {10.0, 20.0, 30.0, 40.0}}
          };

.. _example-dataframe-sum-201:

.. dropdown:: sum (pd_test_1_all.cpp:276)
   :class-title: example-dropdown

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

              }
      
              // Test sum/mean
              pandas::BooleanArray arr({
                  std::optional<bool>(true),
                  std::optional<bool>(false),
                  std::optional<bool>(true),
                  std::optional<bool>(true)
              });
      
              auto s = arr.sum();
              if (!s.has_value() || s.value() != 3) {
                  std::cout << "  [FAIL] : in pd_test_boolean_array_reductions() : sum should be 3" << std::endl;
                  throw std::runtime_error("pd_test_boolean_array_reductions failed: sum");
              }
      
              auto m = arr.mean();
              if (!m.has_value() || std::abs(m.value() - 0.75) > 0.001) {
                  std::cout << "  [FAIL] : in pd_test_boolean_array_reductions() : mean should be 0.75" << std::endl;
                  throw std::runtime_error("pd_test_boolean_array_reductions failed: mean");
              }

.. _example-dataframe-sum_cols-202:

.. dropdown:: sum_cols (pd_test_1_all.cpp:6351)
   :class-title: example-dropdown

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

              void pd_test_dataframe_aggregations() {
                  std::cout << "========= aggregations =====================";
      
                  std::map<std::string, std::vector<numpy::float64>> data;
                  data["A"] = {1.0, 2.0, 3.0, 4.0, 5.0};
                  data["B"] = {10.0, 20.0, 30.0, 40.0, 50.0};
      
                  pandas::DataFrame df(data);
      
                  // Test sum
                  auto sums = df.sum_cols();
                  double sum_a = sums[0];
                  double sum_b = sums[1];
                  if (std::abs(sum_a - 15.0) > 1e-10) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_aggregations() : sum A != 15" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_aggregations failed: sum A != 15");
                  }
                  if (std::abs(sum_b - 150.0) > 1e-10) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_aggregations() : sum B != 150" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_aggregations failed: sum B != 150");
                  }

.. _example-dataframe-value_counts-203:

.. 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-dataframe-var-204:

.. dropdown:: var (pd_test_1_all.cpp:20890)
   :class-title: example-dropdown

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

                      throw std::runtime_error("pd_test_expanding_std failed: expanding std values incorrect");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_expanding_var() {
                  std::cout << "========= Expanding var =========================";
      
                  pandas::Series<double> s({1.0, 2.0, 3.0, 4.0, 5.0});
                  auto result = s.expanding().var();
      
                  // Expanding var (ddof=1): NaN, 0.5, 1.0, 1.6667, 2.5
                  bool passed = std::isnan(result[0]) &&
                                std::abs(result[1] - 0.5) < 0.001 &&
                                std::abs(result[2] - 1.0) < 0.001 &&
                                std::abs(result[3] - 1.6667) < 0.001 &&
                                std::abs(result[4] - 2.5) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_expanding_var() : expanding var values incorrect" << std::endl;
                      throw std::runtime_error("pd_test_expanding_var failed: expanding var values incorrect");

.. _example-dataframe-agg-205:

.. dropdown:: agg (pd_test_1_all.cpp:11100)
   :class-title: example-dropdown

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

              }
      
              void pd_test_func_apply_series_agg() {
                  std::cout << "========= Series agg ==================================";
      
                  pandas::Series<double> s({1.0, 2.0, 3.0, 4.0, 5.0}, "values");
      
                  bool passed = true;
      
                  // Test string-based aggregation
                  auto sum_result = s.agg("sum");
                  if (!sum_result.has_value() || !approx_equal(sum_result.value(), 15.0)) {
                      passed = false;
                      std::cout << "  [FAIL] : in pd_test_func_apply_series_agg() : sum failed" << std::endl;
                      throw std::runtime_error("pd_test_func_apply_series_agg failed: sum failed");
                  }
      
                  auto mean_result = s.agg("mean");
                  if (!mean_result.has_value() || !approx_equal(mean_result.value(), 3.0)) {
                      passed = false;
                      std::cout << "  [FAIL] : in pd_test_func_apply_series_agg() : mean failed" << std::endl;

.. _example-dataframe-agg-206:

.. dropdown:: agg (pd_test_1_all.cpp:11100)
   :class-title: example-dropdown

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

              }
      
              void pd_test_func_apply_series_agg() {
                  std::cout << "========= Series agg ==================================";
      
                  pandas::Series<double> s({1.0, 2.0, 3.0, 4.0, 5.0}, "values");
      
                  bool passed = true;
      
                  // Test string-based aggregation
                  auto sum_result = s.agg("sum");
                  if (!sum_result.has_value() || !approx_equal(sum_result.value(), 15.0)) {
                      passed = false;
                      std::cout << "  [FAIL] : in pd_test_func_apply_series_agg() : sum failed" << std::endl;
                      throw std::runtime_error("pd_test_func_apply_series_agg failed: sum failed");
                  }
      
                  auto mean_result = s.agg("mean");
                  if (!mean_result.has_value() || !approx_equal(mean_result.value(), 3.0)) {
                      passed = false;
                      std::cout << "  [FAIL] : in pd_test_func_apply_series_agg() : mean failed" << std::endl;

.. _example-dataframe-agg-207:

.. dropdown:: agg (pd_test_1_all.cpp:11100)
   :class-title: example-dropdown

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

              }
      
              void pd_test_func_apply_series_agg() {
                  std::cout << "========= Series agg ==================================";
      
                  pandas::Series<double> s({1.0, 2.0, 3.0, 4.0, 5.0}, "values");
      
                  bool passed = true;
      
                  // Test string-based aggregation
                  auto sum_result = s.agg("sum");
                  if (!sum_result.has_value() || !approx_equal(sum_result.value(), 15.0)) {
                      passed = false;
                      std::cout << "  [FAIL] : in pd_test_func_apply_series_agg() : sum failed" << std::endl;
                      throw std::runtime_error("pd_test_func_apply_series_agg failed: sum failed");
                  }
      
                  auto mean_result = s.agg("mean");
                  if (!mean_result.has_value() || !approx_equal(mean_result.value(), 3.0)) {
                      passed = false;
                      std::cout << "  [FAIL] : in pd_test_func_apply_series_agg() : mean failed" << std::endl;

.. _example-dataframe-agg-208:

.. dropdown:: agg (pd_test_1_all.cpp:11100)
   :class-title: example-dropdown

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

              }
      
              void pd_test_func_apply_series_agg() {
                  std::cout << "========= Series agg ==================================";
      
                  pandas::Series<double> s({1.0, 2.0, 3.0, 4.0, 5.0}, "values");
      
                  bool passed = true;
      
                  // Test string-based aggregation
                  auto sum_result = s.agg("sum");
                  if (!sum_result.has_value() || !approx_equal(sum_result.value(), 15.0)) {
                      passed = false;
                      std::cout << "  [FAIL] : in pd_test_func_apply_series_agg() : sum failed" << std::endl;
                      throw std::runtime_error("pd_test_func_apply_series_agg failed: sum failed");
                  }
      
                  auto mean_result = s.agg("mean");
                  if (!mean_result.has_value() || !approx_equal(mean_result.value(), 3.0)) {
                      passed = false;
                      std::cout << "  [FAIL] : in pd_test_func_apply_series_agg() : mean failed" << std::endl;

.. _example-dataframe-agg_to_series-209:

.. dropdown:: agg_to_series (pd_test_2_all.cpp:19154)
   :class-title: example-dropdown

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

      
          pandas::DataFrame df;
          df.add_column("a", std::vector<numpy::float64>{1.0, 2.0, 3.0, 4.0});
          df.add_column("b", std::vector<numpy::float64>{10.0, 20.0, 30.0, 40.0});
      
          // Dict-simple form: {col: "func"} -> Series
          std::map<std::string, std::string> col_funcs;
          col_funcs["a"] = "sum";
          col_funcs["b"] = "mean";
      
          pandas::Series<numpy::float64> result = df.agg_to_series(col_funcs);
      
          // a.sum() = 10.0, b.mean() = 25.0
          check(result.size() == 2, "result_size_2");
      
          // std::map iterates in alphabetical order: a, b
          check(std::abs(result.get_value_double(0) - 10.0) < 1e-9, "a_sum_10");
          check(std::abs(result.get_value_double(1) - 25.0) < 1e-9, "b_mean_25");
      
          // Check index labels
          check(result.index().get_value_str(0) == "a", "index_0_a");

.. _example-dataframe-agg_to_series-210:

.. dropdown:: agg_to_series (pd_test_2_all.cpp:19154)
   :class-title: example-dropdown

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

      
          pandas::DataFrame df;
          df.add_column("a", std::vector<numpy::float64>{1.0, 2.0, 3.0, 4.0});
          df.add_column("b", std::vector<numpy::float64>{10.0, 20.0, 30.0, 40.0});
      
          // Dict-simple form: {col: "func"} -> Series
          std::map<std::string, std::string> col_funcs;
          col_funcs["a"] = "sum";
          col_funcs["b"] = "mean";
      
          pandas::Series<numpy::float64> result = df.agg_to_series(col_funcs);
      
          // a.sum() = 10.0, b.mean() = 25.0
          check(result.size() == 2, "result_size_2");
      
          // std::map iterates in alphabetical order: a, b
          check(std::abs(result.get_value_double(0) - 10.0) < 1e-9, "a_sum_10");
          check(std::abs(result.get_value_double(1) - 25.0) < 1e-9, "b_mean_25");
      
          // Check index labels
          check(result.index().get_value_str(0) == "a", "index_0_a");

.. _example-dataframe-aggregate-211:

.. dropdown:: aggregate (pd_test_1_all.cpp:11139)
   :class-title: example-dropdown

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

                  auto custom_agg = s.agg([](const std::vector<double>& v) {
                      return std::accumulate(v.begin(), v.end(), 0.0) / v.size();
                  });
                  if (!approx_equal(custom_agg, 3.0)) {
                      passed = false;
                      std::cout << "  [FAIL] : in pd_test_func_apply_series_agg() : custom agg failed" << std::endl;
                      throw std::runtime_error("pd_test_func_apply_series_agg failed: custom agg failed");
                  }
      
                  // Test aggregate alias
                  auto alias_result = s.aggregate("sum");
                  if (!alias_result.has_value() || !approx_equal(alias_result.value(), 15.0)) {
                      passed = false;
                      std::cout << "  [FAIL] : in pd_test_func_apply_series_agg() : aggregate alias failed" << std::endl;
                      throw std::runtime_error("pd_test_func_apply_series_agg failed: aggregate alias failed");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_func_apply_series_pipe() {

.. _example-dataframe-aggregate-212:

.. dropdown:: aggregate (pd_test_1_all.cpp:11139)
   :class-title: example-dropdown

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

                  auto custom_agg = s.agg([](const std::vector<double>& v) {
                      return std::accumulate(v.begin(), v.end(), 0.0) / v.size();
                  });
                  if (!approx_equal(custom_agg, 3.0)) {
                      passed = false;
                      std::cout << "  [FAIL] : in pd_test_func_apply_series_agg() : custom agg failed" << std::endl;
                      throw std::runtime_error("pd_test_func_apply_series_agg failed: custom agg failed");
                  }
      
                  // Test aggregate alias
                  auto alias_result = s.aggregate("sum");
                  if (!alias_result.has_value() || !approx_equal(alias_result.value(), 15.0)) {
                      passed = false;
                      std::cout << "  [FAIL] : in pd_test_func_apply_series_agg() : aggregate alias failed" << std::endl;
                      throw std::runtime_error("pd_test_func_apply_series_agg failed: aggregate alias failed");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_func_apply_series_pipe() {

.. _example-dataframe-aggregate-213:

.. dropdown:: aggregate (pd_test_1_all.cpp:11139)
   :class-title: example-dropdown

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

                  auto custom_agg = s.agg([](const std::vector<double>& v) {
                      return std::accumulate(v.begin(), v.end(), 0.0) / v.size();
                  });
                  if (!approx_equal(custom_agg, 3.0)) {
                      passed = false;
                      std::cout << "  [FAIL] : in pd_test_func_apply_series_agg() : custom agg failed" << std::endl;
                      throw std::runtime_error("pd_test_func_apply_series_agg failed: custom agg failed");
                  }
      
                  // Test aggregate alias
                  auto alias_result = s.aggregate("sum");
                  if (!alias_result.has_value() || !approx_equal(alias_result.value(), 15.0)) {
                      passed = false;
                      std::cout << "  [FAIL] : in pd_test_func_apply_series_agg() : aggregate alias failed" << std::endl;
                      throw std::runtime_error("pd_test_func_apply_series_agg failed: aggregate alias failed");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_func_apply_series_pipe() {

.. _example-dataframe-aggregate-214:

.. dropdown:: aggregate (pd_test_1_all.cpp:11139)
   :class-title: example-dropdown

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

                  auto custom_agg = s.agg([](const std::vector<double>& v) {
                      return std::accumulate(v.begin(), v.end(), 0.0) / v.size();
                  });
                  if (!approx_equal(custom_agg, 3.0)) {
                      passed = false;
                      std::cout << "  [FAIL] : in pd_test_func_apply_series_agg() : custom agg failed" << std::endl;
                      throw std::runtime_error("pd_test_func_apply_series_agg failed: custom agg failed");
                  }
      
                  // Test aggregate alias
                  auto alias_result = s.aggregate("sum");
                  if (!alias_result.has_value() || !approx_equal(alias_result.value(), 15.0)) {
                      passed = false;
                      std::cout << "  [FAIL] : in pd_test_func_apply_series_agg() : aggregate alias failed" << std::endl;
                      throw std::runtime_error("pd_test_func_apply_series_agg failed: aggregate alias failed");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_func_apply_series_pipe() {

.. _example-dataframe-apply-215:

.. dropdown:: apply (pd_test_1_all.cpp:11244)
   :class-title: example-dropdown

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

              void pd_test_func_apply_dataframe_apply_axis0() {
                  std::cout << "========= DataFrame apply axis=0 ======================";
      
                  std::map<std::string, std::vector<double>> data = {
                      {"A", {1.0, 2.0, 3.0}},
                      {"B", {4.0, 5.0, 6.0}}
                  };
                  pandas::DataFrame df(data);
      
                  // apply axis=0 applies function to each column
                  auto result = df.apply([](const std::vector<double>& col) {
                      return std::accumulate(col.begin(), col.end(), 0.0);
                  }, 0);
      
                  bool passed = true;
      
                  // Plan F·dtype: axis=0 reduce now returns a single "result" column
                  // with the original column names ("A", "B") as the row index.
                  // Sum of A: 1+2+3=6, Sum of B: 4+5+6=15
                  const auto& result_col = result["result"];
                  double sum_a = std::stod(result_col.get_value_str(0));

.. _example-dataframe-apply-216:

.. dropdown:: apply (pd_test_1_all.cpp:11244)
   :class-title: example-dropdown

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

              void pd_test_func_apply_dataframe_apply_axis0() {
                  std::cout << "========= DataFrame apply axis=0 ======================";
      
                  std::map<std::string, std::vector<double>> data = {
                      {"A", {1.0, 2.0, 3.0}},
                      {"B", {4.0, 5.0, 6.0}}
                  };
                  pandas::DataFrame df(data);
      
                  // apply axis=0 applies function to each column
                  auto result = df.apply([](const std::vector<double>& col) {
                      return std::accumulate(col.begin(), col.end(), 0.0);
                  }, 0);
      
                  bool passed = true;
      
                  // Plan F·dtype: axis=0 reduce now returns a single "result" column
                  // with the original column names ("A", "B") as the row index.
                  // Sum of A: 1+2+3=6, Sum of B: 4+5+6=15
                  const auto& result_col = result["result"];
                  double sum_a = std::stod(result_col.get_value_str(0));

.. _example-dataframe-apply-217:

.. dropdown:: apply (pd_test_1_all.cpp:11244)
   :class-title: example-dropdown

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

              void pd_test_func_apply_dataframe_apply_axis0() {
                  std::cout << "========= DataFrame apply axis=0 ======================";
      
                  std::map<std::string, std::vector<double>> data = {
                      {"A", {1.0, 2.0, 3.0}},
                      {"B", {4.0, 5.0, 6.0}}
                  };
                  pandas::DataFrame df(data);
      
                  // apply axis=0 applies function to each column
                  auto result = df.apply([](const std::vector<double>& col) {
                      return std::accumulate(col.begin(), col.end(), 0.0);
                  }, 0);
      
                  bool passed = true;
      
                  // Plan F·dtype: axis=0 reduce now returns a single "result" column
                  // with the original column names ("A", "B") as the row index.
                  // Sum of A: 1+2+3=6, Sum of B: 4+5+6=15
                  const auto& result_col = result["result"];
                  double sum_a = std::stod(result_col.get_value_str(0));

.. _example-dataframe-apply_callable-218:

.. dropdown:: apply_callable (pd_test_5_all.cpp:86745)
   :class-title: example-dropdown

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

          auto row_cb = [&](const pandas::ApplyRowInput&) -> pandas::ApplyCellResult {
              pandas::ApplyCellResult out;
              out.kind = pandas::ApplyCellResult::Float;
              out.f    = std::numeric_limits<double>::quiet_NaN();
              return out;
          };
      
          bool threw = false;
          pandas::ApplyResult result;
          try {
              result = df.apply_callable(/*axis=*/0, row_cb, col_cb);
          } catch (const std::exception& e) {
              threw = true;
              std::cout << "    threw: " << e.what() << "\n";
          }
          pandas_tests::check(!threw, "case_27.apply_callable_no_throw", local_fail);
          pandas_tests::check(col_cb_called, "case_27.col_cb_invoked", local_fail);
          pandas_tests::check(observed_idx == 0, "case_27.col_cb_idx_is_0", local_fail);
          pandas_tests::check(observed_name == "a", "case_27.col_cb_name_is_a", local_fail);
      }
      

.. _example-dataframe-apply_resolved_typed-219:

.. dropdown:: apply_resolved_typed (pd_test_5_all.cpp:98141)
   :class-title: example-dropdown

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

          switch (cid) {
              case CbId::Int:   cb = cb_int(hist);    break;
              case CbId::Bool:  cb = cb_bool(hist);   break;
              case CbId::Float: cb = cb_float(hist);  break;
              case CbId::Str:   cb = cb_string(hist); break;
              case CbId::Mixed: cb = cb_mixed(hist);  break;
          }
      
          pandas::Result r;
          try {
              r = s.apply_resolved_typed(cb, hist);
          } catch (const std::exception& e) {
              std::string tag = std::string("apply src=") + src_name(sid) +
                                " cb=" + cb_name(cid) + " mode=" + mode_name(mid);
              std::cout << "[FAIL] : in f_27a_core_3094022_apply_resolved_typed_post_cb_dtype() "
                        << tag << " unexpected exception: " << e.what() << "\n";
              ++pandas_tests::g_failed; ++local_fail;
              ++pandas_tests::g_failed; ++local_fail;
              ++pandas_tests::g_failed; ++local_fail;
              return;
          }

.. _example-dataframe-apply_with_args-220:

.. dropdown:: apply_with_args (pd_test_3_all.cpp:16993)
   :class-title: example-dropdown

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

              }
          }
      
          if (!passed) {
              throw std::runtime_error("pd_test_apply_axis1_broadcast failed");
          }
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_apply_with_args() {
          std::cout << "========= DataFrame.apply_with_args() =================";
      
          std::map<std::string, std::vector<double>> data = {
              {"A", {1.0, 2.0, 3.0}},
              {"B", {4.0, 5.0, 6.0}}
          };
          pandas::DataFrame df(data);
      
          // Apply with additional argument: multiply sum by factor
          auto result = df.apply_with_args(
              [](const std::vector<double>& col, double factor) {

.. _example-dataframe-applymap-221:

.. dropdown:: applymap (pd_test_1_all.cpp:11194)
   :class-title: example-dropdown

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

              void pd_test_func_apply_dataframe_applymap() {
                  std::cout << "========= DataFrame applymap ==========================";
      
                  std::map<std::string, std::vector<double>> data = {
                      {"A", {1.0, 2.0, 3.0}},
                      {"B", {4.0, 5.0, 6.0}}
                  };
                  pandas::DataFrame df(data);
      
                  // applymap applies function element-wise
                  auto result = df.applymap([](double x) { return x * x; });
      
                  bool passed = true;
      
                  // Check column A squared
                  const auto& col_a = result["A"];
                  std::vector<double> expected_a = {1.0, 4.0, 9.0};
                  for (size_t i = 0; i < 3; ++i) {
                      double val = std::stod(col_a.get_value_str(i));
                      if (!approx_equal(val, expected_a[i])) {
                          passed = false;

.. _example-dataframe-ewm-222:

.. dropdown:: ewm (pd_test_3_all.cpp:2961)
   :class-title: example-dropdown

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

          // Test expanding sum
          pandas::DataFrame expanding_sum = df.expanding().sum();
          if (expanding_sum.nrows() != 5 || expanding_sum.ncols() != 2) {
              throw std::runtime_error("expanding().sum() shape failed");
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_df_ewm() {
          std::cout << "========= DataFrame.ewm() ================================";
      
          std::map<std::string, std::vector<double>> data = {
              {"A", {1.0, 2.0, 3.0, 4.0, 5.0}},
              {"B", {10.0, 20.0, 30.0, 40.0, 50.0}}
          };
          pandas::DataFrame df(data);
      
          // Test ewm mean with span=3
          pandas::DataFrame ewm_mean = df.ewm(std::nullopt, 3.0).mean();
          if (ewm_mean.nrows() != 5 || ewm_mean.ncols() != 2) {

.. _example-dataframe-expanding-223:

.. dropdown:: expanding (pd_test_1_all.cpp:20770)
   :class-title: example-dropdown

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

                      throw std::runtime_error("pd_test_rolling_std failed: rolling std should be 1.0");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_expanding_sum() {
                  std::cout << "========= Expanding sum =========================";
      
                  pandas::Series<double> s({1.0, 2.0, 3.0, 4.0, 5.0});
                  auto result = s.expanding().sum();
      
                  // Cumulative sum: 1, 3, 6, 10, 15
                  bool passed = std::abs(result[0] - 1.0) < 0.001 &&
                                std::abs(result[1] - 3.0) < 0.001 &&
                                std::abs(result[2] - 6.0) < 0.001 &&
                                std::abs(result[3] - 10.0) < 0.001 &&
                                std::abs(result[4] - 15.0) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_expanding_sum() : expanding sum values incorrect" << std::endl;
                      throw std::runtime_error("pd_test_expanding_sum failed: expanding sum values incorrect");

.. _example-dataframe-groupby-224:

.. 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-dataframe-groupby-225:

.. 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-dataframe-groupby-226:

.. 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-dataframe-groupby-227:

.. 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-dataframe-groupby-228:

.. 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-dataframe-groupby-229:

.. 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-dataframe-map-230:

.. 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-dataframe-map_callable_resolved-231:

.. dropdown:: map_callable_resolved (pd_test_5_all.cpp:98564)
   :class-title: example-dropdown

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

              case MethodId::TransformA0:
              case MethodId::TransformA1:  return "transform";
          }
          return "?";
      }
      
      static pandas::DataFrame run_method(MethodId mid, const pandas::DataFrame& df,
                                          CbId cid, Hist& hist) {
          if (mid == MethodId::Map) {
              MapCb cb = mk_map_cb(cid, hist);
              return df.map_callable_resolved(cb, hist);
          }
          SeriesCb cb = mk_series_cb(cid, hist);
          switch (mid) {
              case MethodId::ApplyA0:      return df.apply_resolved_typed(cb, hist, 0);
              case MethodId::ApplyA1:      return df.apply_resolved_typed(cb, hist, 1);
              case MethodId::TransformA0:  return df.transform_callable_resolved(cb, hist, 0);
              case MethodId::TransformA1:  return df.transform_callable_resolved(cb, hist, 1);
              default: break;
          }
          return pandas::DataFrame{};

.. _example-dataframe-pipe-232:

.. dropdown:: pipe (pd_test_1_all.cpp:11164)
   :class-title: example-dropdown

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

                  // Pipe applies function to entire Series
                  auto add_mean = [](const pandas::Series<double>& ser, double offset) {
                      auto mean_val = ser.mean();
                      std::vector<double> result;
                      for (size_t i = 0; i < ser.size(); ++i) {
                          result.push_back(ser[i] + mean_val.value_or(0.0) + offset);
                      }
                      return pandas::Series<double>(result, ser.name());
                  };
      
                  auto result = s.pipe(add_mean, 10.0);
      
                  bool passed = true;
                  // mean is 2.5, offset is 10.0, so each value + 12.5
                  std::vector<double> expected = {13.5, 14.5, 15.5, 16.5};
                  for (size_t i = 0; i < result.size(); ++i) {
                      if (!approx_equal(result[i], expected[i])) {
                          passed = false;
                          std::cout << "  [FAIL] : in pd_test_func_apply_series_pipe() : value mismatch at " << i << std::endl;
                          throw std::runtime_error("pd_test_func_apply_series_pipe failed: value mismatch");
                      }

.. _example-dataframe-pipe-233:

.. dropdown:: pipe (pd_test_1_all.cpp:11164)
   :class-title: example-dropdown

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

                  // Pipe applies function to entire Series
                  auto add_mean = [](const pandas::Series<double>& ser, double offset) {
                      auto mean_val = ser.mean();
                      std::vector<double> result;
                      for (size_t i = 0; i < ser.size(); ++i) {
                          result.push_back(ser[i] + mean_val.value_or(0.0) + offset);
                      }
                      return pandas::Series<double>(result, ser.name());
                  };
      
                  auto result = s.pipe(add_mean, 10.0);
      
                  bool passed = true;
                  // mean is 2.5, offset is 10.0, so each value + 12.5
                  std::vector<double> expected = {13.5, 14.5, 15.5, 16.5};
                  for (size_t i = 0; i < result.size(); ++i) {
                      if (!approx_equal(result[i], expected[i])) {
                          passed = false;
                          std::cout << "  [FAIL] : in pd_test_func_apply_series_pipe() : value mismatch at " << i << std::endl;
                          throw std::runtime_error("pd_test_func_apply_series_pipe failed: value mismatch");
                      }

.. _example-dataframe-resample-234:

.. dropdown:: resample (pd_test_1_all.cpp:20321)
   :class-title: example-dropdown

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

                      "2020-01-01 00:00:00",
                      "2020-01-01 12:00:00",
                      "2020-01-02 00:00:00",
                      "2020-01-02 12:00:00",
                      "2020-01-03 00:00:00",
                      "2020-01-03 12:00:00"
                  };
                  df.set_index(std::make_unique<pandas::Index<std::string>>(dates));
      
                  // Resample to daily
                  auto resampler = df.resample("D");
                  pandas::DataFrame result = resampler.sum();
      
                  // Check that we got aggregated results
                  bool passed = (result.nrows() <= df.nrows());
      
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_timeseries_resample_basic() : resample didn't reduce rows" << std::endl;
                      throw std::runtime_error("pd_test_timeseries_resample_basic failed");
                  }
      

.. _example-dataframe-rolling-235:

.. dropdown:: rolling (pd_test_1_all.cpp:20667)
   :class-title: example-dropdown

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

      #include <vector>
      #include "../pandas/pd_series.h"
      
      namespace dataframe_tests {
          namespace dataframe_tests_windowing {
      
              void pd_test_rolling_sum() {
                  std::cout << "========= Rolling sum ===========================";
      
                  pandas::Series<double> s({1.0, 2.0, 3.0, 4.0, 5.0});
                  auto result = s.rolling(3).sum();
      
                  // Window 3:
                  // idx 0: [1] -> NaN (not enough values)
                  // idx 1: [1,2] -> NaN (not enough values)
                  // idx 2: [1,2,3] -> 6
                  // idx 3: [2,3,4] -> 9
                  // idx 4: [3,4,5] -> 12
                  bool passed = result.size() == 5;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_rolling_sum() : result size should be 5" << std::endl;

.. _example-dataframe-transform-236:

.. dropdown:: transform (pd_test_1_all.cpp:11071)
   :class-title: example-dropdown

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

      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_func_apply_series_transform() {
                  std::cout << "========= Series transform ============================";
      
                  pandas::Series<double> s({1.0, 2.0, 3.0, 4.0}, "values");
      
                  // Transform must return same shape
                  auto result = s.transform([](double x) { return x * 2 + 1; });
      
                  bool passed = true;
                  if (result.size() != s.size()) {
                      passed = false;
                      std::cout << "  [FAIL] : in pd_test_func_apply_series_transform() : size changed" << std::endl;
                      throw std::runtime_error("pd_test_func_apply_series_transform failed: size changed");
                  }
      
                  std::vector<double> expected = {3.0, 5.0, 7.0, 9.0};
                  for (size_t i = 0; i < result.size(); ++i) {

.. _example-dataframe-transform-237:

.. dropdown:: transform (pd_test_1_all.cpp:11071)
   :class-title: example-dropdown

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

      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_func_apply_series_transform() {
                  std::cout << "========= Series transform ============================";
      
                  pandas::Series<double> s({1.0, 2.0, 3.0, 4.0}, "values");
      
                  // Transform must return same shape
                  auto result = s.transform([](double x) { return x * 2 + 1; });
      
                  bool passed = true;
                  if (result.size() != s.size()) {
                      passed = false;
                      std::cout << "  [FAIL] : in pd_test_func_apply_series_transform() : size changed" << std::endl;
                      throw std::runtime_error("pd_test_func_apply_series_transform failed: size changed");
                  }
      
                  std::vector<double> expected = {3.0, 5.0, 7.0, 9.0};
                  for (size_t i = 0; i < result.size(); ++i) {

.. _example-dataframe-transform-238:

.. dropdown:: transform (pd_test_1_all.cpp:11071)
   :class-title: example-dropdown

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

      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_func_apply_series_transform() {
                  std::cout << "========= Series transform ============================";
      
                  pandas::Series<double> s({1.0, 2.0, 3.0, 4.0}, "values");
      
                  // Transform must return same shape
                  auto result = s.transform([](double x) { return x * 2 + 1; });
      
                  bool passed = true;
                  if (result.size() != s.size()) {
                      passed = false;
                      std::cout << "  [FAIL] : in pd_test_func_apply_series_transform() : size changed" << std::endl;
                      throw std::runtime_error("pd_test_func_apply_series_transform failed: size changed");
                  }
      
                  std::vector<double> expected = {3.0, 5.0, 7.0, 9.0};
                  for (size_t i = 0; i < result.size(); ++i) {

.. _example-dataframe-transform-239:

.. dropdown:: transform (pd_test_1_all.cpp:11071)
   :class-title: example-dropdown

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

      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_func_apply_series_transform() {
                  std::cout << "========= Series transform ============================";
      
                  pandas::Series<double> s({1.0, 2.0, 3.0, 4.0}, "values");
      
                  // Transform must return same shape
                  auto result = s.transform([](double x) { return x * 2 + 1; });
      
                  bool passed = true;
                  if (result.size() != s.size()) {
                      passed = false;
                      std::cout << "  [FAIL] : in pd_test_func_apply_series_transform() : size changed" << std::endl;
                      throw std::runtime_error("pd_test_func_apply_series_transform failed: size changed");
                  }
      
                  std::vector<double> expected = {3.0, 5.0, 7.0, 9.0};
                  for (size_t i = 0; i < result.size(); ++i) {

.. _example-dataframe-transform-240:

.. dropdown:: transform (pd_test_1_all.cpp:11071)
   :class-title: example-dropdown

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

      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_func_apply_series_transform() {
                  std::cout << "========= Series transform ============================";
      
                  pandas::Series<double> s({1.0, 2.0, 3.0, 4.0}, "values");
      
                  // Transform must return same shape
                  auto result = s.transform([](double x) { return x * 2 + 1; });
      
                  bool passed = true;
                  if (result.size() != s.size()) {
                      passed = false;
                      std::cout << "  [FAIL] : in pd_test_func_apply_series_transform() : size changed" << std::endl;
                      throw std::runtime_error("pd_test_func_apply_series_transform failed: size changed");
                  }
      
                  std::vector<double> expected = {3.0, 5.0, 7.0, 9.0};
                  for (size_t i = 0; i < result.size(); ++i) {

.. _example-dataframe-transform_callable_resolved-241:

.. dropdown:: transform_callable_resolved (pd_test_5_all.cpp:98570)
   :class-title: example-dropdown

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

      static pandas::DataFrame run_method(MethodId mid, const pandas::DataFrame& df,
                                          CbId cid, Hist& hist) {
          if (mid == MethodId::Map) {
              MapCb cb = mk_map_cb(cid, hist);
              return df.map_callable_resolved(cb, hist);
          }
          SeriesCb cb = mk_series_cb(cid, hist);
          switch (mid) {
              case MethodId::ApplyA0:      return df.apply_resolved_typed(cb, hist, 0);
              case MethodId::ApplyA1:      return df.apply_resolved_typed(cb, hist, 1);
              case MethodId::TransformA0:  return df.transform_callable_resolved(cb, hist, 0);
              case MethodId::TransformA1:  return df.transform_callable_resolved(cb, hist, 1);
              default: break;
          }
          return pandas::DataFrame{};
      }
      
      static Shape expected_shape(MethodId mid, const pandas::DataFrame& src) {
          switch (mid) {
              case MethodId::ApplyA0:      return {1u, src.ncols()};
              case MethodId::ApplyA1:      return {src.nrows(), 1u};

.. _example-dataframe-add-242:

.. dropdown:: add (pd_test_1_all.cpp:4844)
   :class-title: example-dropdown

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

      
      namespace dataframe_tests {
          namespace dataframe_tests_arithmetic {
      
              void pd_test_arithmetic_series_named_ops() {
                  std::cout << "========= Series named ops ======================";
      
                  pandas::Series<double> a({1.0, 2.0, 3.0});
                  pandas::Series<double> b({4.0, 5.0, 6.0});
      
                  auto sum = a.add(b);
                  bool passed = std::abs(sum[0] - 5.0) < 0.001 && std::abs(sum[1] - 7.0) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_named_ops() : add failed" << std::endl;
                      throw std::runtime_error("pd_test_arithmetic_series_named_ops failed: add failed");
                  }
      
                  auto diff = a.sub(b);
                  passed = std::abs(diff[0] - (-3.0)) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_named_ops() : sub failed" << std::endl;

.. _example-dataframe-add-243:

.. dropdown:: add (pd_test_1_all.cpp:4844)
   :class-title: example-dropdown

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

      
      namespace dataframe_tests {
          namespace dataframe_tests_arithmetic {
      
              void pd_test_arithmetic_series_named_ops() {
                  std::cout << "========= Series named ops ======================";
      
                  pandas::Series<double> a({1.0, 2.0, 3.0});
                  pandas::Series<double> b({4.0, 5.0, 6.0});
      
                  auto sum = a.add(b);
                  bool passed = std::abs(sum[0] - 5.0) < 0.001 && std::abs(sum[1] - 7.0) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_named_ops() : add failed" << std::endl;
                      throw std::runtime_error("pd_test_arithmetic_series_named_ops failed: add failed");
                  }
      
                  auto diff = a.sub(b);
                  passed = std::abs(diff[0] - (-3.0)) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_named_ops() : sub failed" << std::endl;

.. _example-dataframe-add-244:

.. dropdown:: add (pd_test_1_all.cpp:4844)
   :class-title: example-dropdown

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

      
      namespace dataframe_tests {
          namespace dataframe_tests_arithmetic {
      
              void pd_test_arithmetic_series_named_ops() {
                  std::cout << "========= Series named ops ======================";
      
                  pandas::Series<double> a({1.0, 2.0, 3.0});
                  pandas::Series<double> b({4.0, 5.0, 6.0});
      
                  auto sum = a.add(b);
                  bool passed = std::abs(sum[0] - 5.0) < 0.001 && std::abs(sum[1] - 7.0) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_named_ops() : add failed" << std::endl;
                      throw std::runtime_error("pd_test_arithmetic_series_named_ops failed: add failed");
                  }
      
                  auto diff = a.sub(b);
                  passed = std::abs(diff[0] - (-3.0)) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_named_ops() : sub failed" << std::endl;

.. _example-dataframe-add_column-245:

.. dropdown:: add_column (pd_test_1_all.cpp:6540)
   :class-title: example-dropdown

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

              void pd_test_dataframe_manipulation() {
                  std::cout << "========= data manipulation ================";
      
                  std::map<std::string, std::vector<numpy::int64>> data;
                  data["A"] = {1, 2, 3};
                  data["B"] = {4, 5, 6};
      
                  pandas::DataFrame df(data);
      
                  // Test add_column
                  df.add_column<numpy::int64>("C", {7, 8, 9});
                  if (df.ncols() != 3) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_manipulation() : add_column ncols != 3" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_manipulation failed: add_column ncols != 3");
                  }
      
                  // Test pop
                  auto popped = df.pop("C");
                  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");

.. _example-dataframe-add_column_nullable-246:

.. dropdown:: add_column_nullable (pd_test_3_all.cpp:953)
   :class-title: example-dropdown

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

              df.add_column<pandas::Nullable<bool>>("A", {true, false, pandas::None});
              df.add_column<std::int64_t>("B", {1, 2, 3});
              if (df.ncols() != 2 || df.nrows() != 3) {
                  throw std::runtime_error("Nullable<bool> add_column: shape");
              }
          }
      
          // Case E: add_column_nullable<int64> + NA_INT64
          {
              pandas::DataFrame df;
              df.add_column_nullable<int64_t>("int_na",
                  {1, pandas::NA_INT64, 3, pandas::NA_INT64});
              df.add_column_nullable<bool>("bool_na",
                  {true, pandas::NA_BOOL, false, pandas::NA_BOOL});
              df.add_column_nullable<std::string>("str_na",
                  {std::string("a"), pandas::NA_STRING, std::string("c"), pandas::NA_STRING});
      
              if (df.ncols() != 3 || df.nrows() != 4) {
                  throw std::runtime_error("add_column_nullable: shape");
              }
          }

.. _example-dataframe-add_column_with_dtype_override-247:

.. dropdown:: add_column_with_dtype_override (pd_test_2_all.cpp:19266)
   :class-title: example-dropdown

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

      
      // =====================================================================
      // Test: sum() converts bool columns to int64 counts
      // =====================================================================
      
      void pd_test_agg_dtype_sum_bool_to_int() {
          std::cout << "  -- pd_test_agg_dtype_sum_bool_to_int --" << std::endl;
      
          pandas::DataFrame df;
          // Create a bool column using string values with dtype override
          df.add_column_with_dtype_override("flag", std::vector<std::string>{"True", "False", "True"}, "bool");
      
          auto result = df.sum(0, true, false, 0);
          check(approx_eq(result.iat(static_cast<size_t>(0)), 2.0), "bool_count_true_eq_2");
          check(result.dtype_name() == "int64", "bool_sum_dtype_int64");
      }
      
      // =====================================================================
      // Test: sum() preserves nullable Int64 dtype
      // =====================================================================
      

.. _example-dataframe-add_prefix-248:

.. dropdown:: add_prefix (pd_test_2_all.cpp:4)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 1
      :emphasize-lines: 4

      
      // ------------------- pd_test_add_prefix.cpp (start) -----------------------------
      // dataframe_tests/pd_test_add_prefix.cpp
      // Tests for DataFrame.add_prefix() and add_suffix() methods (pandas 2.0+ API)
      #include <iostream>
      #include <stdexcept>
      #include <vector>
      #include <string>
      #include <map>
      #include "../pandas/pd_dataframe.h"
      #include "../pandas/pd_groupby.h"
      
      // CRITICAL: No using namespace directives
      

.. _example-dataframe-add_suffix-249:

.. dropdown:: add_suffix (pd_test_2_all.cpp:4)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 1
      :emphasize-lines: 4

      
      // ------------------- pd_test_add_prefix.cpp (start) -----------------------------
      // dataframe_tests/pd_test_add_prefix.cpp
      // Tests for DataFrame.add_prefix() and add_suffix() methods (pandas 2.0+ API)
      #include <iostream>
      #include <stdexcept>
      #include <vector>
      #include <string>
      #include <map>
      #include "../pandas/pd_dataframe.h"
      #include "../pandas/pd_groupby.h"
      
      // CRITICAL: No using namespace directives
      

.. _example-dataframe-div-250:

.. dropdown:: div (pd_test_1_all.cpp:4865)
   :class-title: example-dropdown

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

                      throw std::runtime_error("pd_test_arithmetic_series_named_ops failed: sub failed");
                  }
      
                  auto prod = a.mul(b);
                  passed = std::abs(prod[0] - 4.0) < 0.001 && std::abs(prod[1] - 10.0) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_named_ops() : mul failed" << std::endl;
                      throw std::runtime_error("pd_test_arithmetic_series_named_ops failed: mul failed");
                  }
      
                  auto quot = a.div(b);
                  passed = std::abs(quot[0] - 0.25) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_named_ops() : div failed" << std::endl;
                      throw std::runtime_error("pd_test_arithmetic_series_named_ops failed: div failed");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_arithmetic_series_floordiv_mod() {

.. _example-dataframe-div-251:

.. dropdown:: div (pd_test_1_all.cpp:4865)
   :class-title: example-dropdown

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

                      throw std::runtime_error("pd_test_arithmetic_series_named_ops failed: sub failed");
                  }
      
                  auto prod = a.mul(b);
                  passed = std::abs(prod[0] - 4.0) < 0.001 && std::abs(prod[1] - 10.0) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_named_ops() : mul failed" << std::endl;
                      throw std::runtime_error("pd_test_arithmetic_series_named_ops failed: mul failed");
                  }
      
                  auto quot = a.div(b);
                  passed = std::abs(quot[0] - 0.25) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_named_ops() : div failed" << std::endl;
                      throw std::runtime_error("pd_test_arithmetic_series_named_ops failed: div failed");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_arithmetic_series_floordiv_mod() {

.. _example-dataframe-div-252:

.. dropdown:: div (pd_test_1_all.cpp:4865)
   :class-title: example-dropdown

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

                      throw std::runtime_error("pd_test_arithmetic_series_named_ops failed: sub failed");
                  }
      
                  auto prod = a.mul(b);
                  passed = std::abs(prod[0] - 4.0) < 0.001 && std::abs(prod[1] - 10.0) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_named_ops() : mul failed" << std::endl;
                      throw std::runtime_error("pd_test_arithmetic_series_named_ops failed: mul failed");
                  }
      
                  auto quot = a.div(b);
                  passed = std::abs(quot[0] - 0.25) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_named_ops() : div failed" << std::endl;
                      throw std::runtime_error("pd_test_arithmetic_series_named_ops failed: div failed");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_arithmetic_series_floordiv_mod() {

.. _example-dataframe-divide-253:

.. dropdown:: divide (pd_test_3_all.cpp:555)
   :class-title: example-dropdown

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

          if (mul_result.size() != 4) {
              std::cout << "  [FAIL] : in pd_test_3_all_series_arithmetic() : multiply() size mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_series_arithmetic failed: multiply()");
          }
          // 10*2=20
          if (std::abs(mul_result[static_cast<size_t>(0)] - 20.0) > 0.001) {
              std::cout << "  [FAIL] : in pd_test_3_all_series_arithmetic() : multiply() value mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_series_arithmetic failed: multiply() value");
          }
      
          // Test divide()
          pandas::Series<numpy::float64> div_result = s1.divide(s2);
          if (div_result.size() != 4) {
              std::cout << "  [FAIL] : in pd_test_3_all_series_arithmetic() : divide() size mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_series_arithmetic failed: divide()");
          }
          // 10/2=5
          if (std::abs(div_result[static_cast<size_t>(0)] - 5.0) > 0.001) {
              std::cout << "  [FAIL] : in pd_test_3_all_series_arithmetic() : divide() value mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_series_arithmetic failed: divide() value");
          }

.. _example-dataframe-divide-254:

.. dropdown:: divide (pd_test_3_all.cpp:555)
   :class-title: example-dropdown

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

          if (mul_result.size() != 4) {
              std::cout << "  [FAIL] : in pd_test_3_all_series_arithmetic() : multiply() size mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_series_arithmetic failed: multiply()");
          }
          // 10*2=20
          if (std::abs(mul_result[static_cast<size_t>(0)] - 20.0) > 0.001) {
              std::cout << "  [FAIL] : in pd_test_3_all_series_arithmetic() : multiply() value mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_series_arithmetic failed: multiply() value");
          }
      
          // Test divide()
          pandas::Series<numpy::float64> div_result = s1.divide(s2);
          if (div_result.size() != 4) {
              std::cout << "  [FAIL] : in pd_test_3_all_series_arithmetic() : divide() size mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_series_arithmetic failed: divide()");
          }
          // 10/2=5
          if (std::abs(div_result[static_cast<size_t>(0)] - 5.0) > 0.001) {
              std::cout << "  [FAIL] : in pd_test_3_all_series_arithmetic() : divide() value mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_series_arithmetic failed: divide() value");
          }

.. _example-dataframe-dot-255:

.. dropdown:: dot (pd_test_1_all.cpp:22594)
   :class-title: example-dropdown

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

      
              std::cout << "====================================== [OK] pd_test_all_any test suite ========================== " << std::endl;
              return 0;
          }
      
      } // namespace dataframe_tests
      // ------------------- pd_test_all_any.cpp (end) -----------------------------
      
      // ------------------- pd_test_dot.cpp (start) -----------------------------
      // dataframe_tests/pd_test_dot.cpp
      // Test DataFrame.dot() method - matrix multiplication
      
      #include <iostream>
      #include <stdexcept>
      #include <cmath>
      #include "../pandas/pd_dataframe.h"
      
      // CRITICAL: No using namespace directives
      
      namespace dataframe_tests {
          namespace dataframe_tests_dot {

.. _example-dataframe-dot-256:

.. dropdown:: dot (pd_test_1_all.cpp:22594)
   :class-title: example-dropdown

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

      
              std::cout << "====================================== [OK] pd_test_all_any test suite ========================== " << std::endl;
              return 0;
          }
      
      } // namespace dataframe_tests
      // ------------------- pd_test_all_any.cpp (end) -----------------------------
      
      // ------------------- pd_test_dot.cpp (start) -----------------------------
      // dataframe_tests/pd_test_dot.cpp
      // Test DataFrame.dot() method - matrix multiplication
      
      #include <iostream>
      #include <stdexcept>
      #include <cmath>
      #include "../pandas/pd_dataframe.h"
      
      // CRITICAL: No using namespace directives
      
      namespace dataframe_tests {
          namespace dataframe_tests_dot {

.. _example-dataframe-floordiv-257:

.. dropdown:: floordiv (pd_test_1_all.cpp:4881)
   :class-title: example-dropdown

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

      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_arithmetic_series_floordiv_mod() {
                  std::cout << "========= Series floordiv/mod ===================";
      
                  pandas::Series<double> a({7.0, 8.0, 9.0});
                  pandas::Series<double> b({2.0, 3.0, 4.0});
      
                  auto fd = a.floordiv(b);
                  bool passed = std::abs(fd[0] - 3.0) < 0.001;  // 7 // 2 = 3
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_floordiv_mod() : floordiv failed" << std::endl;
                      throw std::runtime_error("pd_test_arithmetic_series_floordiv_mod failed: floordiv failed");
                  }
      
                  auto m = a.mod(b);
                  passed = std::abs(m[0] - 1.0) < 0.001;  // 7 % 2 = 1
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_floordiv_mod() : mod failed" << std::endl;

.. _example-dataframe-floordiv-258:

.. dropdown:: floordiv (pd_test_1_all.cpp:4881)
   :class-title: example-dropdown

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

      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_arithmetic_series_floordiv_mod() {
                  std::cout << "========= Series floordiv/mod ===================";
      
                  pandas::Series<double> a({7.0, 8.0, 9.0});
                  pandas::Series<double> b({2.0, 3.0, 4.0});
      
                  auto fd = a.floordiv(b);
                  bool passed = std::abs(fd[0] - 3.0) < 0.001;  // 7 // 2 = 3
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_floordiv_mod() : floordiv failed" << std::endl;
                      throw std::runtime_error("pd_test_arithmetic_series_floordiv_mod failed: floordiv failed");
                  }
      
                  auto m = a.mod(b);
                  passed = std::abs(m[0] - 1.0) < 0.001;  // 7 % 2 = 1
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_floordiv_mod() : mod failed" << std::endl;

.. _example-dataframe-mod-259:

.. dropdown:: mod (pd_test_1_all.cpp:4888)
   :class-title: example-dropdown

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

                  pandas::Series<double> a({7.0, 8.0, 9.0});
                  pandas::Series<double> b({2.0, 3.0, 4.0});
      
                  auto fd = a.floordiv(b);
                  bool passed = std::abs(fd[0] - 3.0) < 0.001;  // 7 // 2 = 3
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_floordiv_mod() : floordiv failed" << std::endl;
                      throw std::runtime_error("pd_test_arithmetic_series_floordiv_mod failed: floordiv failed");
                  }
      
                  auto m = a.mod(b);
                  passed = std::abs(m[0] - 1.0) < 0.001;  // 7 % 2 = 1
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_floordiv_mod() : mod failed" << std::endl;
                      throw std::runtime_error("pd_test_arithmetic_series_floordiv_mod failed: mod failed");
                  }
      
                  // Scalar operations
                  auto fd_scalar = a.floordiv(2.0);
                  passed = std::abs(fd_scalar[0] - 3.0) < 0.001 && std::abs(fd_scalar[1] - 4.0) < 0.001;
                  if (!passed) {

.. _example-dataframe-mod-260:

.. dropdown:: mod (pd_test_1_all.cpp:4888)
   :class-title: example-dropdown

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

                  pandas::Series<double> a({7.0, 8.0, 9.0});
                  pandas::Series<double> b({2.0, 3.0, 4.0});
      
                  auto fd = a.floordiv(b);
                  bool passed = std::abs(fd[0] - 3.0) < 0.001;  // 7 // 2 = 3
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_floordiv_mod() : floordiv failed" << std::endl;
                      throw std::runtime_error("pd_test_arithmetic_series_floordiv_mod failed: floordiv failed");
                  }
      
                  auto m = a.mod(b);
                  passed = std::abs(m[0] - 1.0) < 0.001;  // 7 % 2 = 1
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_floordiv_mod() : mod failed" << std::endl;
                      throw std::runtime_error("pd_test_arithmetic_series_floordiv_mod failed: mod failed");
                  }
      
                  // Scalar operations
                  auto fd_scalar = a.floordiv(2.0);
                  passed = std::abs(fd_scalar[0] - 3.0) < 0.001 && std::abs(fd_scalar[1] - 4.0) < 0.001;
                  if (!passed) {

.. _example-dataframe-mul-261:

.. dropdown:: mul (pd_test_1_all.cpp:4858)
   :class-title: example-dropdown

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

                      throw std::runtime_error("pd_test_arithmetic_series_named_ops failed: add failed");
                  }
      
                  auto diff = a.sub(b);
                  passed = std::abs(diff[0] - (-3.0)) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_named_ops() : sub failed" << std::endl;
                      throw std::runtime_error("pd_test_arithmetic_series_named_ops failed: sub failed");
                  }
      
                  auto prod = a.mul(b);
                  passed = std::abs(prod[0] - 4.0) < 0.001 && std::abs(prod[1] - 10.0) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_named_ops() : mul failed" << std::endl;
                      throw std::runtime_error("pd_test_arithmetic_series_named_ops failed: mul failed");
                  }
      
                  auto quot = a.div(b);
                  passed = std::abs(quot[0] - 0.25) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_named_ops() : div failed" << std::endl;

.. _example-dataframe-mul-262:

.. dropdown:: mul (pd_test_1_all.cpp:4858)
   :class-title: example-dropdown

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

                      throw std::runtime_error("pd_test_arithmetic_series_named_ops failed: add failed");
                  }
      
                  auto diff = a.sub(b);
                  passed = std::abs(diff[0] - (-3.0)) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_named_ops() : sub failed" << std::endl;
                      throw std::runtime_error("pd_test_arithmetic_series_named_ops failed: sub failed");
                  }
      
                  auto prod = a.mul(b);
                  passed = std::abs(prod[0] - 4.0) < 0.001 && std::abs(prod[1] - 10.0) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_named_ops() : mul failed" << std::endl;
                      throw std::runtime_error("pd_test_arithmetic_series_named_ops failed: mul failed");
                  }
      
                  auto quot = a.div(b);
                  passed = std::abs(quot[0] - 0.25) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_named_ops() : div failed" << std::endl;

.. _example-dataframe-mul-263:

.. dropdown:: mul (pd_test_1_all.cpp:4858)
   :class-title: example-dropdown

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

                      throw std::runtime_error("pd_test_arithmetic_series_named_ops failed: add failed");
                  }
      
                  auto diff = a.sub(b);
                  passed = std::abs(diff[0] - (-3.0)) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_named_ops() : sub failed" << std::endl;
                      throw std::runtime_error("pd_test_arithmetic_series_named_ops failed: sub failed");
                  }
      
                  auto prod = a.mul(b);
                  passed = std::abs(prod[0] - 4.0) < 0.001 && std::abs(prod[1] - 10.0) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_named_ops() : mul failed" << std::endl;
                      throw std::runtime_error("pd_test_arithmetic_series_named_ops failed: mul failed");
                  }
      
                  auto quot = a.div(b);
                  passed = std::abs(quot[0] - 0.25) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_named_ops() : div failed" << std::endl;

.. _example-dataframe-mul-264:

.. dropdown:: mul (pd_test_1_all.cpp:4858)
   :class-title: example-dropdown

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

                      throw std::runtime_error("pd_test_arithmetic_series_named_ops failed: add failed");
                  }
      
                  auto diff = a.sub(b);
                  passed = std::abs(diff[0] - (-3.0)) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_named_ops() : sub failed" << std::endl;
                      throw std::runtime_error("pd_test_arithmetic_series_named_ops failed: sub failed");
                  }
      
                  auto prod = a.mul(b);
                  passed = std::abs(prod[0] - 4.0) < 0.001 && std::abs(prod[1] - 10.0) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_named_ops() : mul failed" << std::endl;
                      throw std::runtime_error("pd_test_arithmetic_series_named_ops failed: mul failed");
                  }
      
                  auto quot = a.div(b);
                  passed = std::abs(quot[0] - 0.25) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_named_ops() : div failed" << std::endl;

.. _example-dataframe-multiindex-265:

.. dropdown:: multiindex (pd_test_1_all.cpp:27024)
   :class-title: example-dropdown

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

                  pandas::DataFrame df(data);
      
                  auto result = df.value_counts();
                  auto& counts = std::get<pandas::Series<numpy::int64>>(result);
      
                  if (!counts.has_multiindex()) {
                      std::cout << "  [FAIL] : expected MultiIndex" << std::endl;
                      throw std::runtime_error("pd_test_value_counts_multiindex_levels failed: no multiindex");
                  }
      
                  const auto& midx = counts.multiindex();
      
                  // Should have 2 levels
                  if (midx.nlevels() != 2) {
                      std::cout << "  [FAIL] : expected 2 levels, got " << midx.nlevels() << std::endl;
                      throw std::runtime_error("pd_test_value_counts_multiindex_levels failed: wrong nlevels");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      

.. _example-dataframe-multiply-266:

.. dropdown:: multiply (pd_test_3_all.cpp:543)
   :class-title: example-dropdown

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

          if (sub_result.size() != 4) {
              std::cout << "  [FAIL] : in pd_test_3_all_series_arithmetic() : subtract() size mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_series_arithmetic failed: subtract()");
          }
          // 10-2=8
          if (std::abs(sub_result[static_cast<size_t>(0)] - 8.0) > 0.001) {
              std::cout << "  [FAIL] : in pd_test_3_all_series_arithmetic() : subtract() value mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_series_arithmetic failed: subtract() value");
          }
      
          // Test multiply()
          pandas::Series<double> mul_result = s1.multiply(s2);
          if (mul_result.size() != 4) {
              std::cout << "  [FAIL] : in pd_test_3_all_series_arithmetic() : multiply() size mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_series_arithmetic failed: multiply()");
          }
          // 10*2=20
          if (std::abs(mul_result[static_cast<size_t>(0)] - 20.0) > 0.001) {
              std::cout << "  [FAIL] : in pd_test_3_all_series_arithmetic() : multiply() value mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_series_arithmetic failed: multiply() value");
          }

.. _example-dataframe-multiply-267:

.. dropdown:: multiply (pd_test_3_all.cpp:543)
   :class-title: example-dropdown

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

          if (sub_result.size() != 4) {
              std::cout << "  [FAIL] : in pd_test_3_all_series_arithmetic() : subtract() size mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_series_arithmetic failed: subtract()");
          }
          // 10-2=8
          if (std::abs(sub_result[static_cast<size_t>(0)] - 8.0) > 0.001) {
              std::cout << "  [FAIL] : in pd_test_3_all_series_arithmetic() : subtract() value mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_series_arithmetic failed: subtract() value");
          }
      
          // Test multiply()
          pandas::Series<double> mul_result = s1.multiply(s2);
          if (mul_result.size() != 4) {
              std::cout << "  [FAIL] : in pd_test_3_all_series_arithmetic() : multiply() size mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_series_arithmetic failed: multiply()");
          }
          // 10*2=20
          if (std::abs(mul_result[static_cast<size_t>(0)] - 20.0) > 0.001) {
              std::cout << "  [FAIL] : in pd_test_3_all_series_arithmetic() : multiply() value mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_series_arithmetic failed: multiply() value");
          }

.. _example-dataframe-pow-268:

.. dropdown:: pow (pd_test_1_all.cpp:4911)
   :class-title: example-dropdown

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

                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_arithmetic_series_pow() {
                  std::cout << "========= Series pow ============================";
      
                  pandas::Series<double> a({2.0, 3.0, 4.0});
      
                  auto p = a.pow(2.0);
                  bool passed = std::abs(p[0] - 4.0) < 0.001 && std::abs(p[1] - 9.0) < 0.001 && std::abs(p[2] - 16.0) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_pow() : pow scalar failed" << std::endl;
                      throw std::runtime_error("pd_test_arithmetic_series_pow failed: pow scalar failed");
                  }
      
                  // Series pow Series
                  pandas::Series<double> exp({1.0, 2.0, 0.5});
                  auto p2 = a.pow(exp);
                  passed = std::abs(p2[0] - 2.0) < 0.001 && std::abs(p2[1] - 9.0) < 0.001;  // 3^2=9

.. _example-dataframe-pow-269:

.. dropdown:: pow (pd_test_1_all.cpp:4911)
   :class-title: example-dropdown

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

                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_arithmetic_series_pow() {
                  std::cout << "========= Series pow ============================";
      
                  pandas::Series<double> a({2.0, 3.0, 4.0});
      
                  auto p = a.pow(2.0);
                  bool passed = std::abs(p[0] - 4.0) < 0.001 && std::abs(p[1] - 9.0) < 0.001 && std::abs(p[2] - 16.0) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_pow() : pow scalar failed" << std::endl;
                      throw std::runtime_error("pd_test_arithmetic_series_pow failed: pow scalar failed");
                  }
      
                  // Series pow Series
                  pandas::Series<double> exp({1.0, 2.0, 0.5});
                  auto p2 = a.pow(exp);
                  passed = std::abs(p2[0] - 2.0) < 0.001 && std::abs(p2[1] - 9.0) < 0.001;  // 3^2=9

.. _example-dataframe-radd-270:

.. dropdown:: radd (pd_test_2_all.cpp:7440)
   :class-title: example-dropdown

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

                  if (std::isinf(a) && std::isinf(b)) return (a > 0) == (b > 0);
                  return std::abs(a - b) < tol;
              }
      
              // Helper to get double value from DataFrame at position
              double get_val(const pandas::DataFrame& df, size_t row, size_t col) {
                  return df.iloc<numpy::float64>(row, col);
              }
      
              void pd_test_radd_scalar() {
                  std::cout << "========= radd() with scalar =====================";
      
                  // Create DataFrame: angles=[0, 3, 4], degrees=[360, 180, 360]
                  std::map<std::string, std::vector<double>> data = {
                      {"angles", {0.0, 3.0, 4.0}},
                      {"degrees", {360.0, 180.0, 360.0}}
                  };
                  pandas::DataFrame df(data);
      
                  // df.radd(1) should be equivalent to 1 + df
                  pandas::DataFrame result = df.radd(1.0);

.. _example-dataframe-radd-271:

.. dropdown:: radd (pd_test_2_all.cpp:7440)
   :class-title: example-dropdown

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

                  if (std::isinf(a) && std::isinf(b)) return (a > 0) == (b > 0);
                  return std::abs(a - b) < tol;
              }
      
              // Helper to get double value from DataFrame at position
              double get_val(const pandas::DataFrame& df, size_t row, size_t col) {
                  return df.iloc<numpy::float64>(row, col);
              }
      
              void pd_test_radd_scalar() {
                  std::cout << "========= radd() with scalar =====================";
      
                  // Create DataFrame: angles=[0, 3, 4], degrees=[360, 180, 360]
                  std::map<std::string, std::vector<double>> data = {
                      {"angles", {0.0, 3.0, 4.0}},
                      {"degrees", {360.0, 180.0, 360.0}}
                  };
                  pandas::DataFrame df(data);
      
                  // df.radd(1) should be equivalent to 1 + df
                  pandas::DataFrame result = df.radd(1.0);

.. _example-dataframe-radd-272:

.. dropdown:: radd (pd_test_2_all.cpp:7440)
   :class-title: example-dropdown

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

                  if (std::isinf(a) && std::isinf(b)) return (a > 0) == (b > 0);
                  return std::abs(a - b) < tol;
              }
      
              // Helper to get double value from DataFrame at position
              double get_val(const pandas::DataFrame& df, size_t row, size_t col) {
                  return df.iloc<numpy::float64>(row, col);
              }
      
              void pd_test_radd_scalar() {
                  std::cout << "========= radd() with scalar =====================";
      
                  // Create DataFrame: angles=[0, 3, 4], degrees=[360, 180, 360]
                  std::map<std::string, std::vector<double>> data = {
                      {"angles", {0.0, 3.0, 4.0}},
                      {"degrees", {360.0, 180.0, 360.0}}
                  };
                  pandas::DataFrame df(data);
      
                  // df.radd(1) should be equivalent to 1 + df
                  pandas::DataFrame result = df.radd(1.0);

.. _example-dataframe-rdiv-273:

.. dropdown:: rdiv (pd_test_2_all.cpp:7713)
   :class-title: example-dropdown

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

                  }
      
                  if (!passed) {
                      throw std::runtime_error("pd_test_rmul_with_fill_value failed");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_rdiv_scalar() {
                  std::cout << "========= rdiv() with scalar =====================";
      
                  // From pandas docs example: df.rdiv(10) divides 10 BY the dataframe
                  std::map<std::string, std::vector<double>> data = {
                      {"angles", {0.0, 3.0, 4.0}},
                      {"degrees", {360.0, 180.0, 360.0}}
                  };
                  pandas::DataFrame df(data);
      
                  // df.rdiv(10) = 10 / df
                  pandas::DataFrame result = df.rdiv(10.0);

.. _example-dataframe-rdiv-274:

.. dropdown:: rdiv (pd_test_2_all.cpp:7713)
   :class-title: example-dropdown

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

                  }
      
                  if (!passed) {
                      throw std::runtime_error("pd_test_rmul_with_fill_value failed");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_rdiv_scalar() {
                  std::cout << "========= rdiv() with scalar =====================";
      
                  // From pandas docs example: df.rdiv(10) divides 10 BY the dataframe
                  std::map<std::string, std::vector<double>> data = {
                      {"angles", {0.0, 3.0, 4.0}},
                      {"degrees", {360.0, 180.0, 360.0}}
                  };
                  pandas::DataFrame df(data);
      
                  // df.rdiv(10) = 10 / df
                  pandas::DataFrame result = df.rdiv(10.0);

.. _example-dataframe-rdiv-275:

.. dropdown:: rdiv (pd_test_2_all.cpp:7713)
   :class-title: example-dropdown

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

                  }
      
                  if (!passed) {
                      throw std::runtime_error("pd_test_rmul_with_fill_value failed");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_rdiv_scalar() {
                  std::cout << "========= rdiv() with scalar =====================";
      
                  // From pandas docs example: df.rdiv(10) divides 10 BY the dataframe
                  std::map<std::string, std::vector<double>> data = {
                      {"angles", {0.0, 3.0, 4.0}},
                      {"degrees", {360.0, 180.0, 360.0}}
                  };
                  pandas::DataFrame df(data);
      
                  // df.rdiv(10) = 10 / df
                  pandas::DataFrame result = df.rdiv(10.0);

.. _example-dataframe-rfloordiv-276:

.. dropdown:: rfloordiv (pd_test_2_all.cpp:7909)
   :class-title: example-dropdown

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

                  }
      
                  if (!passed) {
                      throw std::runtime_error("pd_test_rtruediv_with_fill_value failed");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_rfloordiv_scalar() {
                  std::cout << "========= rfloordiv() with scalar ================";
      
                  std::map<std::string, std::vector<double>> data = {
                      {"A", {3.0, 4.0}},
                      {"B", {7.0, 8.0}}
                  };
                  pandas::DataFrame df(data);
      
                  // df.rfloordiv(10) = 10 // df (floor division)
                  pandas::DataFrame result = df.rfloordiv(10.0);
      

.. _example-dataframe-rfloordiv-277:

.. dropdown:: rfloordiv (pd_test_2_all.cpp:7909)
   :class-title: example-dropdown

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

                  }
      
                  if (!passed) {
                      throw std::runtime_error("pd_test_rtruediv_with_fill_value failed");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_rfloordiv_scalar() {
                  std::cout << "========= rfloordiv() with scalar ================";
      
                  std::map<std::string, std::vector<double>> data = {
                      {"A", {3.0, 4.0}},
                      {"B", {7.0, 8.0}}
                  };
                  pandas::DataFrame df(data);
      
                  // df.rfloordiv(10) = 10 // df (floor division)
                  pandas::DataFrame result = df.rfloordiv(10.0);
      

.. _example-dataframe-rmod-278:

.. dropdown:: rmod (pd_test_2_all.cpp:8121)
   :class-title: example-dropdown

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

                  }
      
                  if (!passed) {
                      throw std::runtime_error("pd_test_rfloordiv_division_by_zero failed");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_rmod_scalar() {
                  std::cout << "========= rmod() with scalar =====================";
      
                  std::map<std::string, std::vector<double>> data = {
                      {"A", {3.0, 4.0}}
                  };
                  pandas::DataFrame df(data);
      
                  // df.rmod(10) = 10 % df
                  pandas::DataFrame result = df.rmod(10.0);
      
                  bool passed = true;

.. _example-dataframe-rmod-279:

.. dropdown:: rmod (pd_test_2_all.cpp:8121)
   :class-title: example-dropdown

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

                  }
      
                  if (!passed) {
                      throw std::runtime_error("pd_test_rfloordiv_division_by_zero failed");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_rmod_scalar() {
                  std::cout << "========= rmod() with scalar =====================";
      
                  std::map<std::string, std::vector<double>> data = {
                      {"A", {3.0, 4.0}}
                  };
                  pandas::DataFrame df(data);
      
                  // df.rmod(10) = 10 % df
                  pandas::DataFrame result = df.rmod(10.0);
      
                  bool passed = true;

.. _example-dataframe-rmul-280:

.. dropdown:: rmul (pd_test_2_all.cpp:7591)
   :class-title: example-dropdown

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

                  }
      
                  if (!passed) {
                      throw std::runtime_error("pd_test_rsub_dataframe failed");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_rmul_scalar() {
                  std::cout << "========= rmul() with scalar =====================";
      
                  std::map<std::string, std::vector<double>> data = {
                      {"A", {2.0, 3.0}},
                      {"B", {4.0, 5.0}}
                  };
                  pandas::DataFrame df(data);
      
                  // df.rmul(10) = 10 * df
                  pandas::DataFrame result = df.rmul(10.0);
      

.. _example-dataframe-rmul-281:

.. dropdown:: rmul (pd_test_2_all.cpp:7591)
   :class-title: example-dropdown

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

                  }
      
                  if (!passed) {
                      throw std::runtime_error("pd_test_rsub_dataframe failed");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_rmul_scalar() {
                  std::cout << "========= rmul() with scalar =====================";
      
                  std::map<std::string, std::vector<double>> data = {
                      {"A", {2.0, 3.0}},
                      {"B", {4.0, 5.0}}
                  };
                  pandas::DataFrame df(data);
      
                  // df.rmul(10) = 10 * df
                  pandas::DataFrame result = df.rmul(10.0);
      

.. _example-dataframe-rmul-282:

.. dropdown:: rmul (pd_test_2_all.cpp:7591)
   :class-title: example-dropdown

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

                  }
      
                  if (!passed) {
                      throw std::runtime_error("pd_test_rsub_dataframe failed");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_rmul_scalar() {
                  std::cout << "========= rmul() with scalar =====================";
      
                  std::map<std::string, std::vector<double>> data = {
                      {"A", {2.0, 3.0}},
                      {"B", {4.0, 5.0}}
                  };
                  pandas::DataFrame df(data);
      
                  // df.rmul(10) = 10 * df
                  pandas::DataFrame result = df.rmul(10.0);
      

.. _example-dataframe-rpow-283:

.. dropdown:: rpow (pd_test_2_all.cpp:8327)
   :class-title: example-dropdown

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

                  }
      
                  if (!passed) {
                      throw std::runtime_error("pd_test_rmod_modulo_by_zero failed");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_rpow_scalar() {
                  std::cout << "========= rpow() with scalar =====================";
      
                  std::map<std::string, std::vector<double>> data = {
                      {"A", {2.0, 3.0}},
                      {"B", {0.0, 1.0}}
                  };
                  pandas::DataFrame df(data);
      
                  // df.rpow(2) = 2 ** df
                  pandas::DataFrame result = df.rpow(2.0);
      

.. _example-dataframe-rpow-284:

.. dropdown:: rpow (pd_test_2_all.cpp:8327)
   :class-title: example-dropdown

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

                  }
      
                  if (!passed) {
                      throw std::runtime_error("pd_test_rmod_modulo_by_zero failed");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_rpow_scalar() {
                  std::cout << "========= rpow() with scalar =====================";
      
                  std::map<std::string, std::vector<double>> data = {
                      {"A", {2.0, 3.0}},
                      {"B", {0.0, 1.0}}
                  };
                  pandas::DataFrame df(data);
      
                  // df.rpow(2) = 2 ** df
                  pandas::DataFrame result = df.rpow(2.0);
      

.. _example-dataframe-rsub-285:

.. dropdown:: rsub (pd_test_2_all.cpp:7520)
   :class-title: example-dropdown

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

                  }
      
                  if (!passed) {
                      throw std::runtime_error("pd_test_radd_dataframe failed");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_rsub_scalar() {
                  std::cout << "========= rsub() with scalar =====================";
      
                  std::map<std::string, std::vector<double>> data = {
                      {"A", {1.0, 2.0, 3.0}},
                      {"B", {4.0, 5.0, 6.0}}
                  };
                  pandas::DataFrame df(data);
      
                  // df.rsub(10) = 10 - df
                  pandas::DataFrame result = df.rsub(10.0);
      

.. _example-dataframe-rsub-286:

.. dropdown:: rsub (pd_test_2_all.cpp:7520)
   :class-title: example-dropdown

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

                  }
      
                  if (!passed) {
                      throw std::runtime_error("pd_test_radd_dataframe failed");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_rsub_scalar() {
                  std::cout << "========= rsub() with scalar =====================";
      
                  std::map<std::string, std::vector<double>> data = {
                      {"A", {1.0, 2.0, 3.0}},
                      {"B", {4.0, 5.0, 6.0}}
                  };
                  pandas::DataFrame df(data);
      
                  // df.rsub(10) = 10 - df
                  pandas::DataFrame result = df.rsub(10.0);
      

.. _example-dataframe-rsub-287:

.. dropdown:: rsub (pd_test_2_all.cpp:7520)
   :class-title: example-dropdown

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

                  }
      
                  if (!passed) {
                      throw std::runtime_error("pd_test_radd_dataframe failed");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_rsub_scalar() {
                  std::cout << "========= rsub() with scalar =====================";
      
                  std::map<std::string, std::vector<double>> data = {
                      {"A", {1.0, 2.0, 3.0}},
                      {"B", {4.0, 5.0, 6.0}}
                  };
                  pandas::DataFrame df(data);
      
                  // df.rsub(10) = 10 - df
                  pandas::DataFrame result = df.rsub(10.0);
      

.. _example-dataframe-rtruediv-288:

.. dropdown:: rtruediv (pd_test_2_all.cpp:7795)
   :class-title: example-dropdown

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

                  }
      
                  if (!passed) {
                      throw std::runtime_error("pd_test_rdiv_dataframe failed");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_rtruediv_scalar() {
                  std::cout << "========= rtruediv() with scalar =================";
      
                  std::map<std::string, std::vector<double>> data = {
                      {"A", {2.0, 4.0}}
                  };
                  pandas::DataFrame df(data);
      
                  // rtruediv is alias for rdiv
                  pandas::DataFrame result = df.rtruediv(10.0);
      
                  bool passed = true;

.. _example-dataframe-rtruediv-289:

.. dropdown:: rtruediv (pd_test_2_all.cpp:7795)
   :class-title: example-dropdown

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

                  }
      
                  if (!passed) {
                      throw std::runtime_error("pd_test_rdiv_dataframe failed");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_rtruediv_scalar() {
                  std::cout << "========= rtruediv() with scalar =================";
      
                  std::map<std::string, std::vector<double>> data = {
                      {"A", {2.0, 4.0}}
                  };
                  pandas::DataFrame df(data);
      
                  // rtruediv is alias for rdiv
                  pandas::DataFrame result = df.rtruediv(10.0);
      
                  bool passed = true;

.. _example-dataframe-sub-290:

.. dropdown:: sub (pd_test_1_all.cpp:4851)
   :class-title: example-dropdown

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

                  pandas::Series<double> a({1.0, 2.0, 3.0});
                  pandas::Series<double> b({4.0, 5.0, 6.0});
      
                  auto sum = a.add(b);
                  bool passed = std::abs(sum[0] - 5.0) < 0.001 && std::abs(sum[1] - 7.0) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_named_ops() : add failed" << std::endl;
                      throw std::runtime_error("pd_test_arithmetic_series_named_ops failed: add failed");
                  }
      
                  auto diff = a.sub(b);
                  passed = std::abs(diff[0] - (-3.0)) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_named_ops() : sub failed" << std::endl;
                      throw std::runtime_error("pd_test_arithmetic_series_named_ops failed: sub failed");
                  }
      
                  auto prod = a.mul(b);
                  passed = std::abs(prod[0] - 4.0) < 0.001 && std::abs(prod[1] - 10.0) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_named_ops() : mul failed" << std::endl;

.. _example-dataframe-sub-291:

.. dropdown:: sub (pd_test_1_all.cpp:4851)
   :class-title: example-dropdown

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

                  pandas::Series<double> a({1.0, 2.0, 3.0});
                  pandas::Series<double> b({4.0, 5.0, 6.0});
      
                  auto sum = a.add(b);
                  bool passed = std::abs(sum[0] - 5.0) < 0.001 && std::abs(sum[1] - 7.0) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_named_ops() : add failed" << std::endl;
                      throw std::runtime_error("pd_test_arithmetic_series_named_ops failed: add failed");
                  }
      
                  auto diff = a.sub(b);
                  passed = std::abs(diff[0] - (-3.0)) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_named_ops() : sub failed" << std::endl;
                      throw std::runtime_error("pd_test_arithmetic_series_named_ops failed: sub failed");
                  }
      
                  auto prod = a.mul(b);
                  passed = std::abs(prod[0] - 4.0) < 0.001 && std::abs(prod[1] - 10.0) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_named_ops() : mul failed" << std::endl;

.. _example-dataframe-sub-292:

.. dropdown:: sub (pd_test_1_all.cpp:4851)
   :class-title: example-dropdown

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

                  pandas::Series<double> a({1.0, 2.0, 3.0});
                  pandas::Series<double> b({4.0, 5.0, 6.0});
      
                  auto sum = a.add(b);
                  bool passed = std::abs(sum[0] - 5.0) < 0.001 && std::abs(sum[1] - 7.0) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_named_ops() : add failed" << std::endl;
                      throw std::runtime_error("pd_test_arithmetic_series_named_ops failed: add failed");
                  }
      
                  auto diff = a.sub(b);
                  passed = std::abs(diff[0] - (-3.0)) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_named_ops() : sub failed" << std::endl;
                      throw std::runtime_error("pd_test_arithmetic_series_named_ops failed: sub failed");
                  }
      
                  auto prod = a.mul(b);
                  passed = std::abs(prod[0] - 4.0) < 0.001 && std::abs(prod[1] - 10.0) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_series_named_ops() : mul failed" << std::endl;

.. _example-dataframe-subtract-293:

.. dropdown:: subtract (pd_test_3_all.cpp:531)
   :class-title: example-dropdown

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

      // ============================================================================
      
      void pd_test_3_all_series_arithmetic() {
          std::cout << "========= Series.subtract/multiply/divide/truediv() =";
      
          std::vector<double> vals1 = {10.0, 20.0, 30.0, 40.0};
          std::vector<double> vals2 = {2.0, 4.0, 6.0, 8.0};
          pandas::Series<double> s1(vals1, "s1");
          pandas::Series<double> s2(vals2, "s2");
      
          // Test subtract()
          pandas::Series<double> sub_result = s1.subtract(s2);
          if (sub_result.size() != 4) {
              std::cout << "  [FAIL] : in pd_test_3_all_series_arithmetic() : subtract() size mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_series_arithmetic failed: subtract()");
          }
          // 10-2=8
          if (std::abs(sub_result[static_cast<size_t>(0)] - 8.0) > 0.001) {
              std::cout << "  [FAIL] : in pd_test_3_all_series_arithmetic() : subtract() value mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_series_arithmetic failed: subtract() value");
          }

.. _example-dataframe-subtract-294:

.. dropdown:: subtract (pd_test_3_all.cpp:531)
   :class-title: example-dropdown

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

      // ============================================================================
      
      void pd_test_3_all_series_arithmetic() {
          std::cout << "========= Series.subtract/multiply/divide/truediv() =";
      
          std::vector<double> vals1 = {10.0, 20.0, 30.0, 40.0};
          std::vector<double> vals2 = {2.0, 4.0, 6.0, 8.0};
          pandas::Series<double> s1(vals1, "s1");
          pandas::Series<double> s2(vals2, "s2");
      
          // Test subtract()
          pandas::Series<double> sub_result = s1.subtract(s2);
          if (sub_result.size() != 4) {
              std::cout << "  [FAIL] : in pd_test_3_all_series_arithmetic() : subtract() size mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_series_arithmetic failed: subtract()");
          }
          // 10-2=8
          if (std::abs(sub_result[static_cast<size_t>(0)] - 8.0) > 0.001) {
              std::cout << "  [FAIL] : in pd_test_3_all_series_arithmetic() : subtract() value mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_series_arithmetic failed: subtract() value");
          }

.. _example-dataframe-truediv-295:

.. dropdown:: truediv (pd_test_3_all.cpp:524)
   :class-title: example-dropdown

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

          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      // ============================================================================
      // Category 3: Series Arithmetic Operations
      // ============================================================================
      
      void pd_test_3_all_series_arithmetic() {
          std::cout << "========= Series.subtract/multiply/divide/truediv() =";
      
          std::vector<double> vals1 = {10.0, 20.0, 30.0, 40.0};
          std::vector<double> vals2 = {2.0, 4.0, 6.0, 8.0};
          pandas::Series<double> s1(vals1, "s1");
          pandas::Series<double> s2(vals2, "s2");
      
          // Test subtract()
          pandas::Series<double> sub_result = s1.subtract(s2);
          if (sub_result.size() != 4) {
              std::cout << "  [FAIL] : in pd_test_3_all_series_arithmetic() : subtract() size mismatch" << std::endl;

.. _example-dataframe-truediv-296:

.. dropdown:: truediv (pd_test_3_all.cpp:524)
   :class-title: example-dropdown

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

          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      // ============================================================================
      // Category 3: Series Arithmetic Operations
      // ============================================================================
      
      void pd_test_3_all_series_arithmetic() {
          std::cout << "========= Series.subtract/multiply/divide/truediv() =";
      
          std::vector<double> vals1 = {10.0, 20.0, 30.0, 40.0};
          std::vector<double> vals2 = {2.0, 4.0, 6.0, 8.0};
          pandas::Series<double> s1(vals1, "s1");
          pandas::Series<double> s2(vals2, "s2");
      
          // Test subtract()
          pandas::Series<double> sub_result = s1.subtract(s2);
          if (sub_result.size() != 4) {
              std::cout << "  [FAIL] : in pd_test_3_all_series_arithmetic() : subtract() size mismatch" << std::endl;

.. _example-dataframe-compare-297:

.. dropdown:: compare (pd_test_1_all.cpp:13989)
   :class-title: example-dropdown

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

                  if (!approx_equal(std::stod(b_col.get_value_str(0)), 10.0)) {
                      passed = false;
                      std::cout << "  [FAIL] : in pd_test_joining_update() : column B was changed" << std::endl;
                      throw std::runtime_error("pd_test_joining_update failed: B changed");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              // =====================================================================
              // compare() Tests
              // =====================================================================
      
              void pd_test_joining_compare() {
                  std::cout << "========= compare =====================================";
      
                  std::map<std::string, std::vector<double>> left_data = {
                      {"A", {1.0, 2.0, 3.0}},
                      {"B", {10.0, 20.0, 30.0}}
                  };
                  pandas::DataFrame left(left_data);

.. _example-dataframe-eq-298:

.. dropdown:: eq (pd_test_2_all.cpp:19680)
   :class-title: example-dropdown

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

      
          std::vector<pandas::Series<numpy::float64>> cols;
          cols.push_back(pandas::Series<numpy::float64>({1.0, 2.0}, "A"));
          cols.push_back(pandas::Series<numpy::float64>({3.0, 3.0}, "B"));
          pandas::DataFrame df(cols, {"A", "B"});
      
          pandas::Series<numpy::float64> s({1.0, 3.0}, "vals");
          s.set_index(std::make_unique<pandas::Index<std::string>>(
              std::vector<std::string>{"A", "B"}));
      
          auto result = df.eq(s, 1);
      
          check(approx(result["A"].get_value_double(0), 1.0), "eq_A_r0_true");
          check(approx(result["A"].get_value_double(1), 0.0), "eq_A_r1_false");
          check(approx(result["B"].get_value_double(0), 1.0), "eq_B_r0_true");
          check(approx(result["B"].get_value_double(1), 1.0), "eq_B_r1_true");
      }
      
      // Test 5: mul scalar broadcast (verify existing behavior still works)
      void pd_test_broadcasting_mul_scalar() {
          std::cout << "  -- pd_test_broadcasting_mul_scalar --" << std::endl;

.. _example-dataframe-eq-299:

.. dropdown:: eq (pd_test_2_all.cpp:19680)
   :class-title: example-dropdown

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

      
          std::vector<pandas::Series<numpy::float64>> cols;
          cols.push_back(pandas::Series<numpy::float64>({1.0, 2.0}, "A"));
          cols.push_back(pandas::Series<numpy::float64>({3.0, 3.0}, "B"));
          pandas::DataFrame df(cols, {"A", "B"});
      
          pandas::Series<numpy::float64> s({1.0, 3.0}, "vals");
          s.set_index(std::make_unique<pandas::Index<std::string>>(
              std::vector<std::string>{"A", "B"}));
      
          auto result = df.eq(s, 1);
      
          check(approx(result["A"].get_value_double(0), 1.0), "eq_A_r0_true");
          check(approx(result["A"].get_value_double(1), 0.0), "eq_A_r1_false");
          check(approx(result["B"].get_value_double(0), 1.0), "eq_B_r0_true");
          check(approx(result["B"].get_value_double(1), 1.0), "eq_B_r1_true");
      }
      
      // Test 5: mul scalar broadcast (verify existing behavior still works)
      void pd_test_broadcasting_mul_scalar() {
          std::cout << "  -- pd_test_broadcasting_mul_scalar --" << std::endl;

.. _example-dataframe-eq-300:

.. dropdown:: eq (pd_test_2_all.cpp:19680)
   :class-title: example-dropdown

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

      
          std::vector<pandas::Series<numpy::float64>> cols;
          cols.push_back(pandas::Series<numpy::float64>({1.0, 2.0}, "A"));
          cols.push_back(pandas::Series<numpy::float64>({3.0, 3.0}, "B"));
          pandas::DataFrame df(cols, {"A", "B"});
      
          pandas::Series<numpy::float64> s({1.0, 3.0}, "vals");
          s.set_index(std::make_unique<pandas::Index<std::string>>(
              std::vector<std::string>{"A", "B"}));
      
          auto result = df.eq(s, 1);
      
          check(approx(result["A"].get_value_double(0), 1.0), "eq_A_r0_true");
          check(approx(result["A"].get_value_double(1), 0.0), "eq_A_r1_false");
          check(approx(result["B"].get_value_double(0), 1.0), "eq_B_r0_true");
          check(approx(result["B"].get_value_double(1), 1.0), "eq_B_r1_true");
      }
      
      // Test 5: mul scalar broadcast (verify existing behavior still works)
      void pd_test_broadcasting_mul_scalar() {
          std::cout << "  -- pd_test_broadcasting_mul_scalar --" << std::endl;

.. _example-dataframe-equals-301:

.. 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-dataframe-ge-302:

.. dropdown:: ge (pd_test_3_all.cpp:303)
   :class-title: example-dropdown

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

          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      // ============================================================================
      // Category 2: DataFrame Comparison Operations
      // ============================================================================
      
      void pd_test_3_all_comparison_ops() {
          std::cout << "========= DataFrame.eq/ne/lt/le/gt/ge() =============";
      
          std::map<std::string, std::vector<double>> data1 = {
              {"A", {1.0, 2.0, 3.0}},
              {"B", {4.0, 5.0, 6.0}}
          };
          std::map<std::string, std::vector<double>> data2 = {
              {"A", {1.0, 3.0, 3.0}},
              {"B", {4.0, 4.0, 7.0}}
          };
          pandas::DataFrame df1(data1);

.. _example-dataframe-ge-303:

.. dropdown:: ge (pd_test_3_all.cpp:303)
   :class-title: example-dropdown

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

          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      // ============================================================================
      // Category 2: DataFrame Comparison Operations
      // ============================================================================
      
      void pd_test_3_all_comparison_ops() {
          std::cout << "========= DataFrame.eq/ne/lt/le/gt/ge() =============";
      
          std::map<std::string, std::vector<double>> data1 = {
              {"A", {1.0, 2.0, 3.0}},
              {"B", {4.0, 5.0, 6.0}}
          };
          std::map<std::string, std::vector<double>> data2 = {
              {"A", {1.0, 3.0, 3.0}},
              {"B", {4.0, 4.0, 7.0}}
          };
          pandas::DataFrame df1(data1);

.. _example-dataframe-ge-304:

.. dropdown:: ge (pd_test_3_all.cpp:303)
   :class-title: example-dropdown

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

          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      // ============================================================================
      // Category 2: DataFrame Comparison Operations
      // ============================================================================
      
      void pd_test_3_all_comparison_ops() {
          std::cout << "========= DataFrame.eq/ne/lt/le/gt/ge() =============";
      
          std::map<std::string, std::vector<double>> data1 = {
              {"A", {1.0, 2.0, 3.0}},
              {"B", {4.0, 5.0, 6.0}}
          };
          std::map<std::string, std::vector<double>> data2 = {
              {"A", {1.0, 3.0, 3.0}},
              {"B", {4.0, 4.0, 7.0}}
          };
          pandas::DataFrame df1(data1);

.. _example-dataframe-gen-305:

.. dropdown:: gen (pd_test_5_all.cpp:35852)
   :class-title: example-dropdown

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

          double pc = pct_change_pc(a, b);
          double pd = pct_change_pd(a, b);
          pandas_tests::check(std::abs(pc - pd) < 1e-12,
                              "case_12.formulas_within_ULP", local_fail);
      }
      
      void bin_edge_412638_case_13_entropy_pct_change_invariance(int& local_fail) {
          // Generate prices via deterministic walk; compute returns by both
          // formulas; bin both; entropy should be IDENTICAL (bin assignments
          // not shifted by ULP-scale formula drift). Cycle-1 finding.
          std::mt19937_64 gen(42);
          std::normal_distribution<double> nd(0.0003, 0.02);
          std::vector<double> prices;
          prices.reserve(500);
          double s = 100.0;
          for (int i = 0; i < 500; ++i) {
              if (i > 0) s = s * std::exp(nd(gen));
              prices.push_back(s);
          }
          std::vector<double> r_pc, r_pd;
          for (size_t i = 1; i < prices.size(); ++i) {

.. _example-dataframe-gt-306:

.. dropdown:: gt (pd_test_3_all.cpp:344)
   :class-title: example-dropdown

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

              throw std::runtime_error("pd_test_3_all_comparison_ops failed: lt() shape");
          }
      
          // Test le()
          pandas::DataFrame le_result = df1.le(df2);
          if (le_result.nrows() != 3 || le_result.ncols() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_comparison_ops() : le() shape mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_comparison_ops failed: le() shape");
          }
      
          // Test gt()
          pandas::DataFrame gt_result = df1.gt(df2);
          if (gt_result.nrows() != 3 || gt_result.ncols() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_comparison_ops() : gt() shape mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_comparison_ops failed: gt() shape");
          }
      
          // Test ge()
          pandas::DataFrame ge_result = df1.ge(df2);
          if (ge_result.nrows() != 3 || ge_result.ncols() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_comparison_ops() : ge() shape mismatch" << std::endl;

.. _example-dataframe-gt-307:

.. dropdown:: gt (pd_test_3_all.cpp:344)
   :class-title: example-dropdown

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

              throw std::runtime_error("pd_test_3_all_comparison_ops failed: lt() shape");
          }
      
          // Test le()
          pandas::DataFrame le_result = df1.le(df2);
          if (le_result.nrows() != 3 || le_result.ncols() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_comparison_ops() : le() shape mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_comparison_ops failed: le() shape");
          }
      
          // Test gt()
          pandas::DataFrame gt_result = df1.gt(df2);
          if (gt_result.nrows() != 3 || gt_result.ncols() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_comparison_ops() : gt() shape mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_comparison_ops failed: gt() shape");
          }
      
          // Test ge()
          pandas::DataFrame ge_result = df1.ge(df2);
          if (ge_result.nrows() != 3 || ge_result.ncols() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_comparison_ops() : ge() shape mismatch" << std::endl;

.. _example-dataframe-gt-308:

.. dropdown:: gt (pd_test_3_all.cpp:344)
   :class-title: example-dropdown

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

              throw std::runtime_error("pd_test_3_all_comparison_ops failed: lt() shape");
          }
      
          // Test le()
          pandas::DataFrame le_result = df1.le(df2);
          if (le_result.nrows() != 3 || le_result.ncols() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_comparison_ops() : le() shape mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_comparison_ops failed: le() shape");
          }
      
          // Test gt()
          pandas::DataFrame gt_result = df1.gt(df2);
          if (gt_result.nrows() != 3 || gt_result.ncols() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_comparison_ops() : gt() shape mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_comparison_ops failed: gt() shape");
          }
      
          // Test ge()
          pandas::DataFrame ge_result = df1.ge(df2);
          if (ge_result.nrows() != 3 || ge_result.ncols() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_comparison_ops() : ge() shape mismatch" << std::endl;

.. _example-dataframe-le-309:

.. dropdown:: le (pd_test_3_all.cpp:337)
   :class-title: example-dropdown

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

              throw std::runtime_error("pd_test_3_all_comparison_ops failed: ne() shape");
          }
      
          // Test lt()
          pandas::DataFrame lt_result = df1.lt(df2);
          if (lt_result.nrows() != 3 || lt_result.ncols() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_comparison_ops() : lt() shape mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_comparison_ops failed: lt() shape");
          }
      
          // Test le()
          pandas::DataFrame le_result = df1.le(df2);
          if (le_result.nrows() != 3 || le_result.ncols() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_comparison_ops() : le() shape mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_comparison_ops failed: le() shape");
          }
      
          // Test gt()
          pandas::DataFrame gt_result = df1.gt(df2);
          if (gt_result.nrows() != 3 || gt_result.ncols() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_comparison_ops() : gt() shape mismatch" << std::endl;

.. _example-dataframe-le-310:

.. dropdown:: le (pd_test_3_all.cpp:337)
   :class-title: example-dropdown

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

              throw std::runtime_error("pd_test_3_all_comparison_ops failed: ne() shape");
          }
      
          // Test lt()
          pandas::DataFrame lt_result = df1.lt(df2);
          if (lt_result.nrows() != 3 || lt_result.ncols() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_comparison_ops() : lt() shape mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_comparison_ops failed: lt() shape");
          }
      
          // Test le()
          pandas::DataFrame le_result = df1.le(df2);
          if (le_result.nrows() != 3 || le_result.ncols() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_comparison_ops() : le() shape mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_comparison_ops failed: le() shape");
          }
      
          // Test gt()
          pandas::DataFrame gt_result = df1.gt(df2);
          if (gt_result.nrows() != 3 || gt_result.ncols() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_comparison_ops() : gt() shape mismatch" << std::endl;

.. _example-dataframe-le-311:

.. dropdown:: le (pd_test_3_all.cpp:337)
   :class-title: example-dropdown

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

              throw std::runtime_error("pd_test_3_all_comparison_ops failed: ne() shape");
          }
      
          // Test lt()
          pandas::DataFrame lt_result = df1.lt(df2);
          if (lt_result.nrows() != 3 || lt_result.ncols() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_comparison_ops() : lt() shape mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_comparison_ops failed: lt() shape");
          }
      
          // Test le()
          pandas::DataFrame le_result = df1.le(df2);
          if (le_result.nrows() != 3 || le_result.ncols() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_comparison_ops() : le() shape mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_comparison_ops failed: le() shape");
          }
      
          // Test gt()
          pandas::DataFrame gt_result = df1.gt(df2);
          if (gt_result.nrows() != 3 || gt_result.ncols() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_comparison_ops() : gt() shape mismatch" << std::endl;

.. _example-dataframe-levels-312:

.. dropdown:: levels (pd_test_2_all.cpp:9787)
   :class-title: example-dropdown

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

                  pandas::DataFrame df(data);
      
                  std::vector<std::string> hier_index = {
                      "Final exam:History:January",
                      "Final exam:Geography:February",
                      "Coursework:History:March",
                      "Coursework:Geography:April"
                  };
                  df.set_index(std::make_unique<pandas::Index<std::string>>(hier_index));
      
                  // Default: swap last two levels (i=-2, j=-1)
                  pandas::DataFrame result = df.swaplevel();
      
                  std::string idx0 = result.index().get_value_str(0);
                  std::string idx1 = result.index().get_value_str(1);
                  std::string idx2 = result.index().get_value_str(2);
                  std::string idx3 = result.index().get_value_str(3);
      
                  bool passed = (idx0 == "Final exam:January:History" &&
                                 idx1 == "Final exam:February:Geography" &&
                                 idx2 == "Coursework:March:History" &&

.. _example-dataframe-levels-313:

.. dropdown:: levels (pd_test_2_all.cpp:9787)
   :class-title: example-dropdown

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

                  pandas::DataFrame df(data);
      
                  std::vector<std::string> hier_index = {
                      "Final exam:History:January",
                      "Final exam:Geography:February",
                      "Coursework:History:March",
                      "Coursework:Geography:April"
                  };
                  df.set_index(std::make_unique<pandas::Index<std::string>>(hier_index));
      
                  // Default: swap last two levels (i=-2, j=-1)
                  pandas::DataFrame result = df.swaplevel();
      
                  std::string idx0 = result.index().get_value_str(0);
                  std::string idx1 = result.index().get_value_str(1);
                  std::string idx2 = result.index().get_value_str(2);
                  std::string idx3 = result.index().get_value_str(3);
      
                  bool passed = (idx0 == "Final exam:January:History" &&
                                 idx1 == "Final exam:February:Geography" &&
                                 idx2 == "Coursework:March:History" &&

.. _example-dataframe-lt-314:

.. dropdown:: lt (pd_test_3_all.cpp:330)
   :class-title: example-dropdown

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

              throw std::runtime_error("pd_test_3_all_comparison_ops failed: eq() shape");
          }
      
          // Test ne()
          pandas::DataFrame ne_result = df1.ne(df2);
          if (ne_result.nrows() != 3 || ne_result.ncols() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_comparison_ops() : ne() shape mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_comparison_ops failed: ne() shape");
          }
      
          // Test lt()
          pandas::DataFrame lt_result = df1.lt(df2);
          if (lt_result.nrows() != 3 || lt_result.ncols() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_comparison_ops() : lt() shape mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_comparison_ops failed: lt() shape");
          }
      
          // Test le()
          pandas::DataFrame le_result = df1.le(df2);
          if (le_result.nrows() != 3 || le_result.ncols() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_comparison_ops() : le() shape mismatch" << std::endl;

.. _example-dataframe-lt-315:

.. dropdown:: lt (pd_test_3_all.cpp:330)
   :class-title: example-dropdown

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

              throw std::runtime_error("pd_test_3_all_comparison_ops failed: eq() shape");
          }
      
          // Test ne()
          pandas::DataFrame ne_result = df1.ne(df2);
          if (ne_result.nrows() != 3 || ne_result.ncols() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_comparison_ops() : ne() shape mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_comparison_ops failed: ne() shape");
          }
      
          // Test lt()
          pandas::DataFrame lt_result = df1.lt(df2);
          if (lt_result.nrows() != 3 || lt_result.ncols() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_comparison_ops() : lt() shape mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_comparison_ops failed: lt() shape");
          }
      
          // Test le()
          pandas::DataFrame le_result = df1.le(df2);
          if (le_result.nrows() != 3 || le_result.ncols() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_comparison_ops() : le() shape mismatch" << std::endl;

.. _example-dataframe-lt-316:

.. dropdown:: lt (pd_test_3_all.cpp:330)
   :class-title: example-dropdown

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

              throw std::runtime_error("pd_test_3_all_comparison_ops failed: eq() shape");
          }
      
          // Test ne()
          pandas::DataFrame ne_result = df1.ne(df2);
          if (ne_result.nrows() != 3 || ne_result.ncols() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_comparison_ops() : ne() shape mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_comparison_ops failed: ne() shape");
          }
      
          // Test lt()
          pandas::DataFrame lt_result = df1.lt(df2);
          if (lt_result.nrows() != 3 || lt_result.ncols() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_comparison_ops() : lt() shape mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_comparison_ops failed: lt() shape");
          }
      
          // Test le()
          pandas::DataFrame le_result = df1.le(df2);
          if (le_result.nrows() != 3 || le_result.ncols() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_comparison_ops() : le() shape mismatch" << std::endl;

.. _example-dataframe-ne-317:

.. dropdown:: ne (pd_test_3_all.cpp:323)
   :class-title: example-dropdown

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

          pandas::DataFrame df1(data1);
          pandas::DataFrame df2(data2);
      
          // Test eq()
          pandas::DataFrame eq_result = df1.eq(df2);
          if (eq_result.nrows() != 3 || eq_result.ncols() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_comparison_ops() : eq() shape mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_comparison_ops failed: eq() shape");
          }
      
          // Test ne()
          pandas::DataFrame ne_result = df1.ne(df2);
          if (ne_result.nrows() != 3 || ne_result.ncols() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_comparison_ops() : ne() shape mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_comparison_ops failed: ne() shape");
          }
      
          // Test lt()
          pandas::DataFrame lt_result = df1.lt(df2);
          if (lt_result.nrows() != 3 || lt_result.ncols() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_comparison_ops() : lt() shape mismatch" << std::endl;

.. _example-dataframe-ne-318:

.. dropdown:: ne (pd_test_3_all.cpp:323)
   :class-title: example-dropdown

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

          pandas::DataFrame df1(data1);
          pandas::DataFrame df2(data2);
      
          // Test eq()
          pandas::DataFrame eq_result = df1.eq(df2);
          if (eq_result.nrows() != 3 || eq_result.ncols() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_comparison_ops() : eq() shape mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_comparison_ops failed: eq() shape");
          }
      
          // Test ne()
          pandas::DataFrame ne_result = df1.ne(df2);
          if (ne_result.nrows() != 3 || ne_result.ncols() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_comparison_ops() : ne() shape mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_comparison_ops failed: ne() shape");
          }
      
          // Test lt()
          pandas::DataFrame lt_result = df1.lt(df2);
          if (lt_result.nrows() != 3 || lt_result.ncols() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_comparison_ops() : lt() shape mismatch" << std::endl;

.. _example-dataframe-ne-319:

.. dropdown:: ne (pd_test_3_all.cpp:323)
   :class-title: example-dropdown

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

          pandas::DataFrame df1(data1);
          pandas::DataFrame df2(data2);
      
          // Test eq()
          pandas::DataFrame eq_result = df1.eq(df2);
          if (eq_result.nrows() != 3 || eq_result.ncols() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_comparison_ops() : eq() shape mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_comparison_ops failed: eq() shape");
          }
      
          // Test ne()
          pandas::DataFrame ne_result = df1.ne(df2);
          if (ne_result.nrows() != 3 || ne_result.ncols() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_comparison_ops() : ne() shape mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_comparison_ops failed: ne() shape");
          }
      
          // Test lt()
          pandas::DataFrame lt_result = df1.lt(df2);
          if (lt_result.nrows() != 3 || lt_result.ncols() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_comparison_ops() : lt() shape mismatch" << std::endl;

.. _example-dataframe-rank-320:

.. dropdown:: rank (pd_test_1_all.cpp:6451)
   :class-title: example-dropdown

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

              // =====================================================================
              // Test: Rank
              // =====================================================================
              void pd_test_dataframe_rank() {
                  std::cout << "========= rank =============================";
      
                  // Test Series rank with default method (average)
                  {
                      std::vector<double> data = {3.0, 1.0, 4.0, 1.0, 5.0};
                      pandas::Series<double> s(data, "test");
                      auto ranked = s.rank();
      
                      // Values: 3, 1, 4, 1, 5 -> Sorted: 1, 1, 3, 4, 5
                      // Ranks (average): 1.5, 1.5, 3, 4, 5
                      // Original positions: 3->3, 1->1.5, 4->4, 1->1.5, 5->5
                      double r0 = std::stod(ranked.get_value_str(0));  // 3.0 -> rank 3
                      double r1 = std::stod(ranked.get_value_str(1));  // 1.0 -> rank 1.5
      
                      if (std::abs(r0 - 3.0) > 1e-10) {
                          std::cout << "  [FAIL] : in pd_test_dataframe_rank() : value 3.0 should have rank 3, got " << r0 << std::endl;
                          throw std::runtime_error("pd_test_dataframe_rank failed: value 3.0 rank");

.. _example-dataframe-sort_index-321:

.. dropdown:: sort_index (pd_test_3_all.cpp:583)
   :class-title: example-dropdown

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

          // 10/2=5
          if (std::abs(truediv_result[static_cast<size_t>(0)] - 5.0) > 0.001) {
              std::cout << "  [FAIL] : in pd_test_3_all_series_arithmetic() : truediv() value mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_series_arithmetic failed: truediv() value");
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_series_sort_index() {
          std::cout << "========= Series.sort_index() ========================";
      
          // NOTE: Series.sort_index() has an implementation issue:
          // It calls index_->argsort() but argsort() is not virtual in IndexBase.
          // This test verifies the function signature exists.
          // When the implementation is fixed, this test should be updated.
      
          std::vector<double> vals = {30.0, 10.0, 20.0};
          pandas::Series<double> s(vals, "test");
      
          // Verify the Series was created correctly

.. _example-dataframe-sort_index-322:

.. dropdown:: sort_index (pd_test_3_all.cpp:583)
   :class-title: example-dropdown

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

          // 10/2=5
          if (std::abs(truediv_result[static_cast<size_t>(0)] - 5.0) > 0.001) {
              std::cout << "  [FAIL] : in pd_test_3_all_series_arithmetic() : truediv() value mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_series_arithmetic failed: truediv() value");
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_series_sort_index() {
          std::cout << "========= Series.sort_index() ========================";
      
          // NOTE: Series.sort_index() has an implementation issue:
          // It calls index_->argsort() but argsort() is not virtual in IndexBase.
          // This test verifies the function signature exists.
          // When the implementation is fixed, this test should be updated.
      
          std::vector<double> vals = {30.0, 10.0, 20.0};
          pandas::Series<double> s(vals, "test");
      
          // Verify the Series was created correctly

.. _example-dataframe-sort_index-323:

.. dropdown:: sort_index (pd_test_3_all.cpp:583)
   :class-title: example-dropdown

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

          // 10/2=5
          if (std::abs(truediv_result[static_cast<size_t>(0)] - 5.0) > 0.001) {
              std::cout << "  [FAIL] : in pd_test_3_all_series_arithmetic() : truediv() value mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_series_arithmetic failed: truediv() value");
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_series_sort_index() {
          std::cout << "========= Series.sort_index() ========================";
      
          // NOTE: Series.sort_index() has an implementation issue:
          // It calls index_->argsort() but argsort() is not virtual in IndexBase.
          // This test verifies the function signature exists.
          // When the implementation is fixed, this test should be updated.
      
          std::vector<double> vals = {30.0, 10.0, 20.0};
          pandas::Series<double> s(vals, "test");
      
          // Verify the Series was created correctly

.. _example-dataframe-sort_values-324:

.. 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-dataframe-sort_values-325:

.. 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-dataframe-sort_values-326:

.. 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-dataframe-sort_values-327:

.. 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-dataframe-sort_values-328:

.. 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-dataframe-sort_values-329:

.. 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-dataframe-sort_values_by_transformed-330:

.. dropdown:: sort_values_by_transformed (pd_test_2_all.cpp:22232)
   :class-title: example-dropdown

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

          }
          std::cout << "====================================== [OK] pd_test_series_dtype_inference test suite ========================== " << std::endl;
          return 0;
      }
      
      } // namespace dataframe_tests
      // ------------------- pd_test_series_dtype_inference.cpp (end) -----------------------------
      
      // ------------------- pd_test_sort_key.cpp (start) -----------------------------
      // pd_test_sort_key.cpp - Tests for sort_values key function support
      // Tests sort_values_by_transformed() and resolve_sort_columns_multiindex()
      
      #include <iostream>
      #include <string>
      #include <vector>
      #include <cmath>
      #include <numeric>
      
      #include "../pandas/pd_dataframe.h"
      
      namespace dataframe_tests {

.. _example-dataframe-t-331:

.. dropdown:: T (pd_test_1_all.cpp:128)
   :class-title: example-dropdown

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

                  throw std::runtime_error("pd_test_boolean_array_kleene_and failed: NA & F");
              }
      
              std::cout << " -> tests passed" << std::endl;
          }
      
          void pd_test_boolean_array_kleene_or() {
              std::cout << "========= BooleanArray: Kleene OR ======================= ";
      
              // Kleene OR truth table:
              // T | T = T, T | F = T, T | NA = T (True dominates)
              // F | T = T, F | F = F, F | NA = NA
              // NA | T = T, NA | F = NA, NA | NA = NA
      
              pandas::BooleanArray t({std::optional<bool>(true)});
              pandas::BooleanArray f({std::optional<bool>(false)});
              pandas::BooleanArray na({std::nullopt});
      
              // T | NA = T (True dominates)
              auto tna = (t | na);
              if (!tna[0].has_value() || !tna[0].value()) {

.. _example-dataframe-explode-332:

.. dropdown:: explode (pd_test_1_all.cpp:6868)
   :class-title: example-dropdown

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

                      }
                  }
      
                  // Test explode
                  {
                      std::map<std::string, std::vector<std::string>> data;
                      data["id"] = {"1", "2"};
                      data["tags"] = {"a,b,c", "d,e"};
                      pandas::DataFrame df(data);
      
                      auto exploded = df.explode("tags");
                      if (exploded.nrows() != 5) {  // 3 + 2 = 5 rows
                          std::cout << "  [FAIL] : in pd_test_dataframe_reshape() : explode nrows != 5, got " << exploded.nrows() << std::endl;
                          throw std::runtime_error("pd_test_dataframe_reshape failed: explode nrows");
                      }
                  }
      
                  // Test squeeze
                  {
                      std::map<std::string, std::vector<int>> data;
                      data["A"] = {1};

.. _example-dataframe-melt-333:

.. dropdown:: melt (pd_test_1_all.cpp:6846)
   :class-title: example-dropdown

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

                  }
      
                  // Test melt
                  {
                      std::map<std::string, std::vector<int>> data;
                      data["id"] = {1, 2};
                      data["A"] = {10, 20};
                      data["B"] = {30, 40};
                      pandas::DataFrame df(data);
      
                      auto melted = df.melt({"id"});
                      if (melted.nrows() != 4) {  // 2 ids * 2 value columns
                          std::cout << "  [FAIL] : in pd_test_dataframe_reshape() : melt nrows != 4, got " << melted.nrows() << std::endl;
                          throw std::runtime_error("pd_test_dataframe_reshape failed: melt nrows");
                      }
                      if (!melted.has_column("variable")) {
                          std::cout << "  [FAIL] : in pd_test_dataframe_reshape() : melt missing 'variable' column" << std::endl;
                          throw std::runtime_error("pd_test_dataframe_reshape failed: melt variable column");
                      }
                      if (!melted.has_column("value")) {
                          std::cout << "  [FAIL] : in pd_test_dataframe_reshape() : melt missing 'value' column" << std::endl;

.. _example-dataframe-melt-334:

.. dropdown:: melt (pd_test_1_all.cpp:6846)
   :class-title: example-dropdown

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

                  }
      
                  // Test melt
                  {
                      std::map<std::string, std::vector<int>> data;
                      data["id"] = {1, 2};
                      data["A"] = {10, 20};
                      data["B"] = {30, 40};
                      pandas::DataFrame df(data);
      
                      auto melted = df.melt({"id"});
                      if (melted.nrows() != 4) {  // 2 ids * 2 value columns
                          std::cout << "  [FAIL] : in pd_test_dataframe_reshape() : melt nrows != 4, got " << melted.nrows() << std::endl;
                          throw std::runtime_error("pd_test_dataframe_reshape failed: melt nrows");
                      }
                      if (!melted.has_column("variable")) {
                          std::cout << "  [FAIL] : in pd_test_dataframe_reshape() : melt missing 'variable' column" << std::endl;
                          throw std::runtime_error("pd_test_dataframe_reshape failed: melt variable column");
                      }
                      if (!melted.has_column("value")) {
                          std::cout << "  [FAIL] : in pd_test_dataframe_reshape() : melt missing 'value' column" << std::endl;

.. _example-dataframe-melt-335:

.. dropdown:: melt (pd_test_1_all.cpp:6846)
   :class-title: example-dropdown

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

                  }
      
                  // Test melt
                  {
                      std::map<std::string, std::vector<int>> data;
                      data["id"] = {1, 2};
                      data["A"] = {10, 20};
                      data["B"] = {30, 40};
                      pandas::DataFrame df(data);
      
                      auto melted = df.melt({"id"});
                      if (melted.nrows() != 4) {  // 2 ids * 2 value columns
                          std::cout << "  [FAIL] : in pd_test_dataframe_reshape() : melt nrows != 4, got " << melted.nrows() << std::endl;
                          throw std::runtime_error("pd_test_dataframe_reshape failed: melt nrows");
                      }
                      if (!melted.has_column("variable")) {
                          std::cout << "  [FAIL] : in pd_test_dataframe_reshape() : melt missing 'variable' column" << std::endl;
                          throw std::runtime_error("pd_test_dataframe_reshape failed: melt variable column");
                      }
                      if (!melted.has_column("value")) {
                          std::cout << "  [FAIL] : in pd_test_dataframe_reshape() : melt missing 'value' column" << std::endl;

.. _example-dataframe-melt-336:

.. dropdown:: melt (pd_test_1_all.cpp:6846)
   :class-title: example-dropdown

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

                  }
      
                  // Test melt
                  {
                      std::map<std::string, std::vector<int>> data;
                      data["id"] = {1, 2};
                      data["A"] = {10, 20};
                      data["B"] = {30, 40};
                      pandas::DataFrame df(data);
      
                      auto melted = df.melt({"id"});
                      if (melted.nrows() != 4) {  // 2 ids * 2 value columns
                          std::cout << "  [FAIL] : in pd_test_dataframe_reshape() : melt nrows != 4, got " << melted.nrows() << std::endl;
                          throw std::runtime_error("pd_test_dataframe_reshape failed: melt nrows");
                      }
                      if (!melted.has_column("variable")) {
                          std::cout << "  [FAIL] : in pd_test_dataframe_reshape() : melt missing 'variable' column" << std::endl;
                          throw std::runtime_error("pd_test_dataframe_reshape failed: melt variable column");
                      }
                      if (!melted.has_column("value")) {
                          std::cout << "  [FAIL] : in pd_test_dataframe_reshape() : melt missing 'value' column" << std::endl;

.. _example-dataframe-pivot-337:

.. dropdown:: pivot (pd_test_1_all.cpp:6827)
   :class-title: example-dropdown

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

                  std::cout << "========= reshaping ========================";
      
                  // Test pivot
                  {
                      std::map<std::string, std::vector<std::string>> data;
                      data["date"] = {"2020-01", "2020-01", "2020-02", "2020-02"};
                      data["city"] = {"NYC", "LA", "NYC", "LA"};
                      data["temp"] = {"30", "65", "35", "70"};
                      pandas::DataFrame df(data);
      
                      auto pivoted = df.pivot("date", "city", "temp");
                      if (pivoted.ncols() != 2) {  // LA, NYC (alphabetical)
                          std::cout << "  [FAIL] : in pd_test_dataframe_reshape() : pivot ncols != 2, got " << pivoted.ncols() << std::endl;
                          throw std::runtime_error("pd_test_dataframe_reshape failed: pivot ncols");
                      }
                      if (pivoted.nrows() != 2) {  // 2020-01, 2020-02
                          std::cout << "  [FAIL] : in pd_test_dataframe_reshape() : pivot nrows != 2, got " << pivoted.nrows() << std::endl;
                          throw std::runtime_error("pd_test_dataframe_reshape failed: pivot nrows");
                      }
                  }
      

.. _example-dataframe-pivot_table-338:

.. dropdown:: pivot_table (pd_test_1_all.cpp:25691)
   :class-title: example-dropdown

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

      namespace dataframe_tests {
          namespace dataframe_tests_pivot_table {
      
              bool approx_equal(double a, double b, double tol = 1e-9) {
                  if (std::isnan(a) && std::isnan(b)) return true;
                  if (std::isnan(a) || std::isnan(b)) return false;
                  return std::abs(a - b) < tol;
              }
      
              void pd_test_pivot_table_sum() {
                  std::cout << "========= pivot_table (sum) ================================";
      
                  // Create test data: region, product, sales (numeric values for aggregation)
                  pandas::DataFrame df;
                  df.add_column<std::string>("region", {"East", "East", "East", "West", "West"});
                  df.add_column<std::string>("product", {"A", "A", "B", "A", "B"});
                  df.add_column<numpy::float64>("sales", {100.0, 150.0, 200.0, 120.0, 80.0});
      
                  // Pivot with sum aggregation
                  pandas::DataFrame result = df.pivot_table("sales", "region", "product", "sum");
      

.. _example-dataframe-pivot_table-339:

.. dropdown:: pivot_table (pd_test_1_all.cpp:25691)
   :class-title: example-dropdown

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

      namespace dataframe_tests {
          namespace dataframe_tests_pivot_table {
      
              bool approx_equal(double a, double b, double tol = 1e-9) {
                  if (std::isnan(a) && std::isnan(b)) return true;
                  if (std::isnan(a) || std::isnan(b)) return false;
                  return std::abs(a - b) < tol;
              }
      
              void pd_test_pivot_table_sum() {
                  std::cout << "========= pivot_table (sum) ================================";
      
                  // Create test data: region, product, sales (numeric values for aggregation)
                  pandas::DataFrame df;
                  df.add_column<std::string>("region", {"East", "East", "East", "West", "West"});
                  df.add_column<std::string>("product", {"A", "A", "B", "A", "B"});
                  df.add_column<numpy::float64>("sales", {100.0, 150.0, 200.0, 120.0, 80.0});
      
                  // Pivot with sum aggregation
                  pandas::DataFrame result = df.pivot_table("sales", "region", "product", "sum");
      

.. _example-dataframe-pivot_table-340:

.. dropdown:: pivot_table (pd_test_1_all.cpp:25691)
   :class-title: example-dropdown

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

      namespace dataframe_tests {
          namespace dataframe_tests_pivot_table {
      
              bool approx_equal(double a, double b, double tol = 1e-9) {
                  if (std::isnan(a) && std::isnan(b)) return true;
                  if (std::isnan(a) || std::isnan(b)) return false;
                  return std::abs(a - b) < tol;
              }
      
              void pd_test_pivot_table_sum() {
                  std::cout << "========= pivot_table (sum) ================================";
      
                  // Create test data: region, product, sales (numeric values for aggregation)
                  pandas::DataFrame df;
                  df.add_column<std::string>("region", {"East", "East", "East", "West", "West"});
                  df.add_column<std::string>("product", {"A", "A", "B", "A", "B"});
                  df.add_column<numpy::float64>("sales", {100.0, 150.0, 200.0, 120.0, 80.0});
      
                  // Pivot with sum aggregation
                  pandas::DataFrame result = df.pivot_table("sales", "region", "product", "sum");
      

.. _example-dataframe-pivot_table-341:

.. dropdown:: pivot_table (pd_test_1_all.cpp:25691)
   :class-title: example-dropdown

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

      namespace dataframe_tests {
          namespace dataframe_tests_pivot_table {
      
              bool approx_equal(double a, double b, double tol = 1e-9) {
                  if (std::isnan(a) && std::isnan(b)) return true;
                  if (std::isnan(a) || std::isnan(b)) return false;
                  return std::abs(a - b) < tol;
              }
      
              void pd_test_pivot_table_sum() {
                  std::cout << "========= pivot_table (sum) ================================";
      
                  // Create test data: region, product, sales (numeric values for aggregation)
                  pandas::DataFrame df;
                  df.add_column<std::string>("region", {"East", "East", "East", "West", "West"});
                  df.add_column<std::string>("product", {"A", "A", "B", "A", "B"});
                  df.add_column<numpy::float64>("sales", {100.0, 150.0, 200.0, 120.0, 80.0});
      
                  // Pivot with sum aggregation
                  pandas::DataFrame result = df.pivot_table("sales", "region", "product", "sum");
      

.. _example-dataframe-pivot_table-342:

.. dropdown:: pivot_table (pd_test_1_all.cpp:25691)
   :class-title: example-dropdown

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

      namespace dataframe_tests {
          namespace dataframe_tests_pivot_table {
      
              bool approx_equal(double a, double b, double tol = 1e-9) {
                  if (std::isnan(a) && std::isnan(b)) return true;
                  if (std::isnan(a) || std::isnan(b)) return false;
                  return std::abs(a - b) < tol;
              }
      
              void pd_test_pivot_table_sum() {
                  std::cout << "========= pivot_table (sum) ================================";
      
                  // Create test data: region, product, sales (numeric values for aggregation)
                  pandas::DataFrame df;
                  df.add_column<std::string>("region", {"East", "East", "East", "West", "West"});
                  df.add_column<std::string>("product", {"A", "A", "B", "A", "B"});
                  df.add_column<numpy::float64>("sales", {100.0, 150.0, 200.0, 120.0, 80.0});
      
                  // Pivot with sum aggregation
                  pandas::DataFrame result = df.pivot_table("sales", "region", "product", "sum");
      

.. _example-dataframe-pivot_table_multi_agg-343:

.. dropdown:: pivot_table_multi_agg (pd_test_2_all.cpp:21310)
   :class-title: example-dropdown

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

                    << dataframe_tests_misc_migration::g_fail << " failed)" << std::endl;
      
          return dataframe_tests_misc_migration::g_fail;
      }
      
      } // namespace dataframe_tests
      // ------------------- pd_test_misc_migration.cpp (end) -----------------------------
      
      // ------------------- pd_test_pivot_ext.cpp (start) -----------------------------
      // pd_test_pivot_ext.cpp - Tests for pivot_table extensions
      // Tests pivot_table_multi_agg(), pivot_table_with_grouper(), auto-detect numeric columns
      
      #include <iostream>
      #include <string>
      #include <vector>
      #include <cmath>
      #include <set>
      
      #include "../pandas/pd_dataframe.h"
      #include "../pandas/pd_groupby.h"
      

.. _example-dataframe-pivot_table_with_margins-344:

.. dropdown:: pivot_table_with_margins (pd_test_3_all.cpp:7480)
   :class-title: example-dropdown

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

          passed = (pivot_fill.nrows() == 2);
          if (!passed) {
              std::cout << "  [FAIL] : in pd_test_3_all_pivot_table() : fill_value test failed" << std::endl;
              throw std::runtime_error("pd_test_3_all_pivot_table failed: fill_value");
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_pivot_table_margins() {
          std::cout << "========= DataFrame.pivot_table_with_margins() =======================";
      
          pandas::DataFrame df;
          df.add_column<std::string>("region", {"East", "East", "West", "West"});
          df.add_column<std::string>("product", {"A", "B", "A", "B"});
          df.add_column<numpy::float64>("sales", {100.0, 150.0, 200.0, 250.0});
      
          // Test without margins (should be same as regular pivot_table)
          pandas::DataFrame pivot_no_margins = df.pivot_table_with_margins(
              "sales", "region", "product", "sum",
              std::numeric_limits<double>::quiet_NaN(), false

.. _example-dataframe-pivot_table_with_margins-345:

.. dropdown:: pivot_table_with_margins (pd_test_3_all.cpp:7480)
   :class-title: example-dropdown

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

          passed = (pivot_fill.nrows() == 2);
          if (!passed) {
              std::cout << "  [FAIL] : in pd_test_3_all_pivot_table() : fill_value test failed" << std::endl;
              throw std::runtime_error("pd_test_3_all_pivot_table failed: fill_value");
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_pivot_table_margins() {
          std::cout << "========= DataFrame.pivot_table_with_margins() =======================";
      
          pandas::DataFrame df;
          df.add_column<std::string>("region", {"East", "East", "West", "West"});
          df.add_column<std::string>("product", {"A", "B", "A", "B"});
          df.add_column<numpy::float64>("sales", {100.0, 150.0, 200.0, 250.0});
      
          // Test without margins (should be same as regular pivot_table)
          pandas::DataFrame pivot_no_margins = df.pivot_table_with_margins(
              "sales", "region", "product", "sum",
              std::numeric_limits<double>::quiet_NaN(), false

.. _example-dataframe-squeeze-346:

.. dropdown:: squeeze (pd_test_1_all.cpp:6881)
   :class-title: example-dropdown

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

                          throw std::runtime_error("pd_test_dataframe_reshape failed: explode nrows");
                      }
                  }
      
                  // Test squeeze
                  {
                      std::map<std::string, std::vector<int>> data;
                      data["A"] = {1};
                      pandas::DataFrame df(data);
      
                      auto squeezed = df.squeeze();
                      // Should return without error for 1x1 DataFrame
                  }
      
                  // Test stack
                  {
                      std::map<std::string, std::vector<int>> data;
                      data["A"] = {1, 2};
                      data["B"] = {3, 4};
                      pandas::DataFrame df(data);
      

.. _example-dataframe-stack-347:

.. dropdown:: stack (pd_test_1_all.cpp:6892)
   :class-title: example-dropdown

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

                      // Should return without error for 1x1 DataFrame
                  }
      
                  // Test stack
                  {
                      std::map<std::string, std::vector<int>> data;
                      data["A"] = {1, 2};
                      data["B"] = {3, 4};
                      pandas::DataFrame df(data);
      
                      auto stacked = df.stack();
                      // Stack should produce 4 rows (2 rows * 2 columns)
                      if (stacked.nrows() != 4) {
                          std::cout << "  [FAIL] : in pd_test_dataframe_reshape() : stack nrows != 4, got " << stacked.nrows() << std::endl;
                          throw std::runtime_error("pd_test_dataframe_reshape failed: stack nrows");
                      }
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      

.. _example-dataframe-stack_levels-348:

.. dropdown:: stack_levels (pd_test_3_all.cpp:28695)
   :class-title: example-dropdown

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

          };
          df.set_columns_levels(lvls, std::vector<std::string>{"l0", "l1"});
          return df;
      }
      
      void pd_test_stack_single_level() {
          std::cout << "  -- pd_test_stack_single_level --" << std::endl;
          int fail = 0;
          auto df = make_ml_df();
          // Default -> stack innermost level (l1 = x,y) -> remaining columns = A,B
          auto r = df.stack_levels({-1}, true);
          fail += spt_check(r.ncols() == 2, "ncols==2");
          fail += spt_check(r.nrows() == 4, "nrows==4 (2 orig rows * 2 stack vals)");
          fail += spt_check(r.has_multiindex(), "multiindex present");
          if (fail == 0) std::cout << "    OK" << std::endl;
          if (fail != 0) throw std::runtime_error("pd_test_stack_single_level failed");
      }
      
      void pd_test_stack_level_param() {
          std::cout << "  -- pd_test_stack_level_param --" << std::endl;
          int fail = 0;

.. _example-dataframe-swapaxes-349:

.. dropdown:: swapaxes (pd_test_3_all.cpp:2276)
   :class-title: example-dropdown

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

          auto sorted_desc = arr.sort_values(false, "last");
          if (*sorted_desc[0] != "c" || *sorted_desc[1] != "b" ||
              *sorted_desc[2] != "a" || sorted_desc[3].has_value()) {
              throw std::runtime_error("sort_values descending failed");
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_categorical_swapaxes() {
          std::cout << "========= CategoricalArray.swapaxes() =================";
      
          std::vector<std::optional<std::string>> values = {"a", "b", "c"};
          pandas::CategoricalArray arr(values);
      
          auto result = arr.swapaxes(0, 0);
          if (result.size() != 3) {
              throw std::runtime_error("swapaxes failed");
          }
      
          bool threw = false;

.. _example-dataframe-transpose-350:

.. 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-dataframe-unstack-351:

.. dropdown:: unstack (pd_test_3_all.cpp:1739)
   :class-title: example-dropdown

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

          }
          if (s.size() != 3) {
              std::cout << "  [FAIL] : in pd_test_3_all_chainable_mutators() : Case H size" << std::endl;
              throw std::runtime_error("pd_test_3_all_chainable_mutators failed: Case H size");
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_dataframe_unstack() {
          std::cout << "========= DataFrame.unstack() ========================";
      
          std::map<std::string, std::vector<double>> data = {
              {"A", {1.0, 2.0, 3.0}},
              {"B", {4.0, 5.0, 6.0}}
          };
          pandas::DataFrame df(data);
      
          // Without MultiIndex, unstack() returns self (matches pandas behavior)
          pandas::DataFrame result = df.unstack();
      

.. _example-dataframe-align-352:

.. dropdown:: align (pd_test_1_all.cpp:14035)
   :class-title: example-dropdown

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

                  if (!approx_equal(a_s1, 2.0) || !approx_equal(a_o1, 99.0)) {
                      passed = false;
                      std::cout << "  [FAIL] : in pd_test_joining_compare() : difference at row 1 not shown" << std::endl;
                      throw std::runtime_error("pd_test_joining_compare failed: diff values");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              // =====================================================================
              // align() Tests
              // =====================================================================
      
              void pd_test_joining_align() {
                  std::cout << "========= align =======================================";
      
                  std::map<std::string, std::vector<double>> left_data = {
                      {"A", {1.0, 2.0}}
                  };
                  std::vector<std::string> left_idx = {"x", "y"};
                  pandas::DataFrame left(left_data, std::make_unique<pandas::Index<std::string>>(left_idx));

.. _example-dataframe-align_series-353:

.. dropdown:: align_series (pd_test_2_all.cpp:21152)
   :class-title: example-dropdown

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

          std::cout << "  -- test_align_df_series_outer --" << std::endl;
      
          pandas::DataFrame df;
          df.add_column("A", std::vector<numpy::float64>{1.0, 2.0});
          df.add_column("B", std::vector<numpy::float64>{3.0, 4.0});
      
          pandas::Series<numpy::float64> s({10.0, 20.0}, "vals");
          s.set_index(std::make_unique<pandas::Index<std::string>>(
              std::vector<std::string>{"B", "C"}));
      
          auto [aligned_df, aligned_s] = df.align_series(s, "outer", 1);
      
          // Outer: columns A, B, C
          check(aligned_df.ncols() == 3, "df_ncols_3");
          check(aligned_s.size() == 3, "s_size_3");
      
          auto df_cols = aligned_df.columns().to_list();
          check(df_cols[0] == "A", "df_col_A");
          check(df_cols[1] == "B", "df_col_B");
          check(df_cols[2] == "C", "df_col_C");
      

.. _example-dataframe-combine-354:

.. dropdown:: combine (pd_test_2_all.cpp:1700)
   :class-title: example-dropdown

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

      
              std::cout << "====================================== [OK] pd_test_between_time test suite ========================== " << std::endl;
              return 0;
          }
      
      } // namespace dataframe_tests
      // ------------------- pd_test_between_time.cpp (end) -----------------------------
      
      // ------------------- pd_test_combine.cpp (start) -----------------------------
      // dataframe_tests/pd_test_combine.cpp
      // Test for DataFrame.combine() - column-wise combine with another DataFrame
      
      #include <iostream>
      #include <cmath>
      #include <stdexcept>
      #include "../pandas/pd_dataframe.h"
      
      // CRITICAL: No using namespace directives
      
      namespace dataframe_tests {
          namespace dataframe_tests_combine {

.. _example-dataframe-combine_first-355:

.. dropdown:: combine_first (pd_test_1_all.cpp:13889)
   :class-title: example-dropdown

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

                  if (!approx_equal(b1, 10.0) || !approx_equal(b2, 20.0)) {
                      passed = false;
                      std::cout << "  [FAIL] : in pd_test_joining_join_index() : matched rows wrong" << std::endl;
                      throw std::runtime_error("pd_test_joining_join_index failed: match values");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              // =====================================================================
              // combine_first() Tests
              // =====================================================================
      
              void pd_test_joining_combine_first() {
                  std::cout << "========= combine_first ===============================";
      
                  std::map<std::string, std::vector<double>> left_data = {
                      {"A", {1.0, std::nan(""), 3.0}},
                      {"B", {std::nan(""), 5.0, std::nan("")}}
                  };
                  std::vector<std::string> left_idx = {"x", "y", "z"};

.. _example-dataframe-concat-356:

.. dropdown:: concat (pd_test_1_all.cpp:17717)
   :class-title: example-dropdown

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

      }
      
      void pd_test_period_index_concat() {
          std::cout << "========= concat factory ==============================";
      
          std::vector<int64_t> ordinals1 = {0, 1};
          std::vector<int64_t> ordinals2 = {2, 3};
          pandas::PeriodIndex idx1(ordinals1, "D");
          pandas::PeriodIndex idx2(ordinals2, "D");
      
          pandas::PeriodIndex concatenated = pandas::PeriodIndex::concat({idx1, idx2});
      
          bool passed = (concatenated.size() == 4);
          if (!passed) {
              std::cout << "  [FAIL] : in pd_test_period_index_concat()" << std::endl;
              throw std::runtime_error("pd_test_period_index_concat failed");
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      

.. _example-dataframe-concat-357:

.. dropdown:: concat (pd_test_1_all.cpp:17717)
   :class-title: example-dropdown

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

      }
      
      void pd_test_period_index_concat() {
          std::cout << "========= concat factory ==============================";
      
          std::vector<int64_t> ordinals1 = {0, 1};
          std::vector<int64_t> ordinals2 = {2, 3};
          pandas::PeriodIndex idx1(ordinals1, "D");
          pandas::PeriodIndex idx2(ordinals2, "D");
      
          pandas::PeriodIndex concatenated = pandas::PeriodIndex::concat({idx1, idx2});
      
          bool passed = (concatenated.size() == 4);
          if (!passed) {
              std::cout << "  [FAIL] : in pd_test_period_index_concat()" << std::endl;
              throw std::runtime_error("pd_test_period_index_concat failed");
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      

.. _example-dataframe-join-358:

.. 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-dataframe-merge-359:

.. dropdown:: merge (pd_test_1_all.cpp:13639)
   :class-title: example-dropdown

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

      namespace dataframe_tests {
          namespace dataframe_tests_joining {
      
              // Helper to check approximate equality
              bool approx_equal(double a, double b, double tol = 1e-9) {
                  if (std::isnan(a) && std::isnan(b)) return true;
                  return std::abs(a - b) < tol;
              }
      
              // =====================================================================
              // merge() Tests
              // =====================================================================
      
              void pd_test_joining_merge_inner() {
                  std::cout << "========= merge inner join ============================";
      
                  // Left DataFrame: id, value_left
                  std::map<std::string, std::vector<double>> left_data = {
                      {"id", {1.0, 2.0, 3.0, 4.0}},
                      {"value_left", {10.0, 20.0, 30.0, 40.0}}
                  };

.. _example-dataframe-merge-360:

.. dropdown:: merge (pd_test_1_all.cpp:13639)
   :class-title: example-dropdown

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

      namespace dataframe_tests {
          namespace dataframe_tests_joining {
      
              // Helper to check approximate equality
              bool approx_equal(double a, double b, double tol = 1e-9) {
                  if (std::isnan(a) && std::isnan(b)) return true;
                  return std::abs(a - b) < tol;
              }
      
              // =====================================================================
              // merge() Tests
              // =====================================================================
      
              void pd_test_joining_merge_inner() {
                  std::cout << "========= merge inner join ============================";
      
                  // Left DataFrame: id, value_left
                  std::map<std::string, std::vector<double>> left_data = {
                      {"id", {1.0, 2.0, 3.0, 4.0}},
                      {"value_left", {10.0, 20.0, 30.0, 40.0}}
                  };

.. _example-dataframe-merge-361:

.. dropdown:: merge (pd_test_1_all.cpp:13639)
   :class-title: example-dropdown

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

      namespace dataframe_tests {
          namespace dataframe_tests_joining {
      
              // Helper to check approximate equality
              bool approx_equal(double a, double b, double tol = 1e-9) {
                  if (std::isnan(a) && std::isnan(b)) return true;
                  return std::abs(a - b) < tol;
              }
      
              // =====================================================================
              // merge() Tests
              // =====================================================================
      
              void pd_test_joining_merge_inner() {
                  std::cout << "========= merge inner join ============================";
      
                  // Left DataFrame: id, value_left
                  std::map<std::string, std::vector<double>> left_data = {
                      {"id", {1.0, 2.0, 3.0, 4.0}},
                      {"value_left", {10.0, 20.0, 30.0, 40.0}}
                  };

.. _example-dataframe-asfreq-362:

.. dropdown:: asfreq (pd_test_1_all.cpp:2869)
   :class-title: example-dropdown

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

              std::cout << "========= PeriodArray: asfreq ======================= ";
      
              // Monthly to quarterly
              pandas::PeriodArray arr_m(std::vector<std::string>{
                  "2024-01",
                  "2024-04",
                  "2024-07",
                  "NaT"
              }, "M");
      
              auto arr_q = arr_m.asfreq("Q");
              if (arr_q.size() != 4) {
                  std::cout << "  [FAIL] : asfreq size should be 4" << std::endl;
                  throw std::runtime_error("pd_test_period_array_asfreq failed: size");
              }
              if (arr_q.freqstr() != "Q") {
                  std::cout << "  [FAIL] : asfreq freqstr should be 'Q'" << std::endl;
                  throw std::runtime_error("pd_test_period_array_asfreq failed: freqstr");
              }
      
              // Check NaT is preserved

.. _example-dataframe-asof-363:

.. 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-dataframe-asof-364:

.. 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-dataframe-between_time-365:

.. dropdown:: between_time (pd_test_2_all.cpp:1154)
   :class-title: example-dropdown

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

      
              std::cout << "====================================== [OK] pd_test_at_time test suite ========================== " << std::endl;
              return 0;
          }
      
      } // namespace dataframe_tests
      // ------------------- pd_test_at_time.cpp (end) -----------------------------
      
      // ------------------- pd_test_between_time.cpp (start) -----------------------------
      // dataframe_tests/pd_test_between_time.cpp
      // Tests for DataFrame.between_time() method (pandas 2.0+ API)
      // Selects values between particular times of day from datetime-indexed DataFrame
      #include <iostream>
      #include <stdexcept>
      #include <vector>
      #include <string>
      #include <map>
      #include "../pandas/pd_dataframe.h"
      
      // CRITICAL: No using namespace directives
      

.. _example-dataframe-between_time-366:

.. dropdown:: between_time (pd_test_2_all.cpp:1154)
   :class-title: example-dropdown

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

      
              std::cout << "====================================== [OK] pd_test_at_time test suite ========================== " << std::endl;
              return 0;
          }
      
      } // namespace dataframe_tests
      // ------------------- pd_test_at_time.cpp (end) -----------------------------
      
      // ------------------- pd_test_between_time.cpp (start) -----------------------------
      // dataframe_tests/pd_test_between_time.cpp
      // Tests for DataFrame.between_time() method (pandas 2.0+ API)
      // Selects values between particular times of day from datetime-indexed DataFrame
      #include <iostream>
      #include <stdexcept>
      #include <vector>
      #include <string>
      #include <map>
      #include "../pandas/pd_dataframe.h"
      
      // CRITICAL: No using namespace directives
      

.. _example-dataframe-diff-367:

.. 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-dataframe-pct_change-368:

.. dropdown:: pct_change (pd_test_1_all.cpp:4621)
   :class-title: example-dropdown

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

                      throw std::runtime_error("pd_test_aggregation_series_skew_kurt failed: kurtosis alias failed");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_aggregation_series_pct_change() {
                  std::cout << "========= Series pct_change =====================";
      
                  pandas::Series<double> s({100.0, 110.0, 121.0});
                  auto pct = s.pct_change();
      
                  // First element should be NaN
                  bool passed = std::isnan(pct[0]);
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_aggregation_series_pct_change() : first element should be NaN" << std::endl;
                      throw std::runtime_error("pd_test_aggregation_series_pct_change failed: first element should be NaN");
                  }
      
                  // Second element should be 0.1 (10% increase)
                  passed = std::abs(pct[1] - 0.1) < 0.001;

.. _example-dataframe-shift-369:

.. 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-dataframe-to_period-370:

.. dropdown:: to_period (pd_test_2_all.cpp:14554)
   :class-title: example-dropdown

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

      
              std::cout << "====================================== [OK] pd_test_to_parquet test suite ========================" << std::endl;
              return 0;
          }
      
      } // namespace dataframe_tests
      // ------------------- pd_test_to_parquet.cpp (end) -----------------------------
      
      // ------------------- pd_test_to_period.cpp (start) -----------------------------
      // dataframe_tests/pd_test_to_period.cpp
      // Test suite for DataFrame.to_period() method
      
      #include <iostream>
      #include <stdexcept>
      #include <vector>
      #include <string>
      #include <map>
      
      #include "../pandas/pd_dataframe.h"
      
      // CRITICAL: No using namespace directives

.. _example-dataframe-to_timestamp-371:

.. dropdown:: to_timestamp (pd_test_1_all.cpp:2830)
   :class-title: example-dropdown

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

          void pd_test_period_array_to_timestamp() {
              std::cout << "========= PeriodArray: to_timestamp ======================= ";
      
              pandas::PeriodArray arr(std::vector<std::string>{
                  "2024-01",
                  "2024-06",
                  "NaT"
              }, "M");
      
              // to_timestamp with start
              auto ts_start = arr.to_timestamp("start");
              if (ts_start.size() != 3) {
                  std::cout << "  [FAIL] : to_timestamp size should be 3" << std::endl;
                  throw std::runtime_error("pd_test_period_array_to_timestamp failed: size");
              }
      
              auto ts0 = ts_start[0];
              if (!ts0.has_value()) {
                  std::cout << "  [FAIL] : ts_start[0] should have value" << std::endl;
                  throw std::runtime_error("pd_test_period_array_to_timestamp failed: ts_start[0]");
              }

.. _example-dataframe-tz_convert-372:

.. 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-dataframe-tz_localize-373:

.. 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-dataframe-to_csv-374:

.. dropdown:: to_csv (pd_test_1_all.cpp:6967)
   :class-title: example-dropdown

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

              void pd_test_dataframe_io() {
                  std::cout << "========= I/O methods ======================";
      
                  std::map<std::string, std::vector<numpy::int64>> data;
                  data["A"] = {1, 2, 3};
                  data["B"] = {4, 5, 6};
      
                  pandas::DataFrame df(data);
      
                  // Test to_csv
                  std::string csv = df.to_csv(false);
                  if (csv.empty()) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_io() : to_csv empty" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_io failed: to_csv empty");
                  }
                  if (csv.find("A") == std::string::npos) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_io() : to_csv missing column name" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_io failed: to_csv missing column name");
                  }
      
                  // Test to_json

.. _example-dataframe-to_gbq-375:

.. dropdown:: to_gbq (pd_test_3_all.cpp:3012)
   :class-title: example-dropdown

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

              throw std::runtime_error("to_xml() missing root element");
          }
          if (xml_output.find("<row>") == std::string::npos) {
              throw std::runtime_error("to_xml() missing row elements");
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_df_to_gbq() {
          std::cout << "========= DataFrame.to_gbq() =============================";
      
          std::map<std::string, std::vector<double>> data = {
              {"A", {1.0, 2.0, 3.0}},
              {"B", {4.0, 5.0, 6.0}}
          };
          pandas::DataFrame df(data);
      
          // Test to_gbq - should throw (not implemented)
          bool threw = false;
          try {

.. _example-dataframe-to_json-376:

.. dropdown:: to_json (pd_test_1_all.cpp:6978)
   :class-title: example-dropdown

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

                  if (csv.empty()) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_io() : to_csv empty" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_io failed: to_csv empty");
                  }
                  if (csv.find("A") == std::string::npos) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_io() : to_csv missing column name" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_io failed: to_csv missing column name");
                  }
      
                  // Test to_json
                  std::string json = df.to_json("columns");
                  if (json.empty()) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_io() : to_json empty" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_io failed: to_json empty");
                  }
                  if (json.find("{") == std::string::npos) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_io() : to_json not JSON" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_io failed: to_json not JSON");
                  }
      
                  // Test to_string

.. _example-dataframe-to_xml-377:

.. dropdown:: to_xml (pd_test_3_all.cpp:2983)
   :class-title: example-dropdown

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

          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      // ============================================================================
      // Category 16: DataFrame Plan 2 - Export Functions
      // ============================================================================
      
      void pd_test_3_all_df_to_xml() {
          std::cout << "========= DataFrame.to_xml() =============================";
      
          std::map<std::string, std::vector<double>> data = {
              {"A", {1.0, 2.0, 3.0}},
              {"B", {4.0, 5.0, 6.0}}
          };
          pandas::DataFrame df(data);
      
          // Test to_xml to string
          std::string xml_output = df.to_xml();
          if (xml_output.empty()) {

.. _example-dataframe-astype-378:

.. 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-dataframe-astype-379:

.. 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-dataframe-astype-380:

.. 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-dataframe-astype-381:

.. 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-dataframe-bool_-382:

.. dropdown:: bool_ (pd_test_1_all.cpp:9120)
   :class-title: example-dropdown

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

      void pd_test_datetime_mixin_array_constructor() {
          std::cout << "========= DatetimeTDMixin array constructor =========================";
      
          // Create DatetimeArray with some values
          numpy::NDArray<numpy::datetime64> data(std::vector<size_t>{3});
          data.setElementAt({0}, numpy::datetime64(1000000000000000000LL, numpy::DateTimeUnit::Nanosecond));  // ~2001
          data.setElementAt({1}, numpy::datetime64(1500000000000000000LL, numpy::DateTimeUnit::Nanosecond));  // ~2017
          data.setElementAt({2}, numpy::datetime64(1600000000000000000LL, numpy::DateTimeUnit::Nanosecond));  // ~2020
      
          numpy::NDArray<numpy::bool_> mask(std::vector<size_t>{3});
          mask.setElementAt({0}, numpy::bool_(false));
          mask.setElementAt({1}, numpy::bool_(false));
          mask.setElementAt({2}, numpy::bool_(false));
      
          pandas::DatetimeArray arr(data, mask);
          pandas::DatetimeTDMixin idx(arr, "timestamps");
      
          bool passed = (idx.size() == 3 && !idx.empty() &&
                         idx.name().has_value() && *idx.name() == "timestamps" &&
                         idx.inferred_type() == "datetime");
          if (!passed) {

.. _example-dataframe-convert_dtypes-383:

.. dropdown:: convert_dtypes (pd_test_1_all.cpp:27317)
   :class-title: example-dropdown

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

              void pd_test_convert_dtypes_integer_strings() {
                  std::cout << "========= convert_dtypes: integer strings ============";
      
                  // 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);
      
                  // Convert dtypes
                  pandas::DataFrame converted = df.convert_dtypes();
      
                  // After conversion, should be int64
                  pandas::Series<std::string> dtypes_after = converted.dtypes();
                  std::string dtype_a = dtypes_after[static_cast<size_t>(0)];
      
                  // Verify the dtype was converted to Int64 (nullable integer, per pandas convert_dtypes behavior)
                  bool passed = (dtype_a == "Int64" || dtype_a == "int64");
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_convert_dtypes_integer_strings() : expected Int64, got " << dtype_a << std::endl;
                      throw std::runtime_error("pd_test_convert_dtypes_integer_strings failed: dtype mismatch");

.. _example-dataframe-copy-384:

.. 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-dataframe-infer_objects-385:

.. 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-dataframe-begin-386:

.. dropdown:: begin (pd_test_1_all.cpp:457)
   :class-title: example-dropdown

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

              };
              pandas::CategoricalArray arr(values);
      
              const std::vector<std::string>& cats = arr.categories();
              if (cats.size() != 3) {
                  std::cout << "  [FAIL] : in pd_test_categorical_array_categories_property() : categories size != 3" << std::endl;
                  throw std::runtime_error("pd_test_categorical_array_categories_property failed: categories size != 3");
              }
      
              // Categories should be unique
              std::set<std::string> unique_cats(cats.begin(), cats.end());
              if (unique_cats.size() != cats.size()) {
                  std::cout << "  [FAIL] : in pd_test_categorical_array_categories_property() : categories not unique" << std::endl;
                  throw std::runtime_error("pd_test_categorical_array_categories_property failed: categories not unique");
              }
      
              std::cout << " -> tests passed" << std::endl;
          }
      
          void pd_test_categorical_array_codes_property() {
              std::cout << "========= CategoricalArray: codes property ======================= ";

.. _example-dataframe-begin-387:

.. dropdown:: begin (pd_test_1_all.cpp:457)
   :class-title: example-dropdown

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

              };
              pandas::CategoricalArray arr(values);
      
              const std::vector<std::string>& cats = arr.categories();
              if (cats.size() != 3) {
                  std::cout << "  [FAIL] : in pd_test_categorical_array_categories_property() : categories size != 3" << std::endl;
                  throw std::runtime_error("pd_test_categorical_array_categories_property failed: categories size != 3");
              }
      
              // Categories should be unique
              std::set<std::string> unique_cats(cats.begin(), cats.end());
              if (unique_cats.size() != cats.size()) {
                  std::cout << "  [FAIL] : in pd_test_categorical_array_categories_property() : categories not unique" << std::endl;
                  throw std::runtime_error("pd_test_categorical_array_categories_property failed: categories not unique");
              }
      
              std::cout << " -> tests passed" << std::endl;
          }
      
          void pd_test_categorical_array_codes_property() {
              std::cout << "========= CategoricalArray: codes property ======================= ";

.. _example-dataframe-end-388:

.. dropdown:: end (pd_test_1_all.cpp:457)
   :class-title: example-dropdown

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

              };
              pandas::CategoricalArray arr(values);
      
              const std::vector<std::string>& cats = arr.categories();
              if (cats.size() != 3) {
                  std::cout << "  [FAIL] : in pd_test_categorical_array_categories_property() : categories size != 3" << std::endl;
                  throw std::runtime_error("pd_test_categorical_array_categories_property failed: categories size != 3");
              }
      
              // Categories should be unique
              std::set<std::string> unique_cats(cats.begin(), cats.end());
              if (unique_cats.size() != cats.size()) {
                  std::cout << "  [FAIL] : in pd_test_categorical_array_categories_property() : categories not unique" << std::endl;
                  throw std::runtime_error("pd_test_categorical_array_categories_property failed: categories not unique");
              }
      
              std::cout << " -> tests passed" << std::endl;
          }
      
          void pd_test_categorical_array_codes_property() {
              std::cout << "========= CategoricalArray: codes property ======================= ";

.. _example-dataframe-end-389:

.. dropdown:: end (pd_test_1_all.cpp:457)
   :class-title: example-dropdown

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

              };
              pandas::CategoricalArray arr(values);
      
              const std::vector<std::string>& cats = arr.categories();
              if (cats.size() != 3) {
                  std::cout << "  [FAIL] : in pd_test_categorical_array_categories_property() : categories size != 3" << std::endl;
                  throw std::runtime_error("pd_test_categorical_array_categories_property failed: categories size != 3");
              }
      
              // Categories should be unique
              std::set<std::string> unique_cats(cats.begin(), cats.end());
              if (unique_cats.size() != cats.size()) {
                  std::cout << "  [FAIL] : in pd_test_categorical_array_categories_property() : categories not unique" << std::endl;
                  throw std::runtime_error("pd_test_categorical_array_categories_property failed: categories not unique");
              }
      
              std::cout << " -> tests passed" << std::endl;
          }
      
          void pd_test_categorical_array_codes_property() {
              std::cout << "========= CategoricalArray: codes property ======================= ";

.. _example-dataframe-items-390:

.. dropdown:: items (pd_test_1_all.cpp:16554)
   :class-title: example-dropdown

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

      
              // =====================================================================
              // Iteration Tests (items, keys)
              // =====================================================================
      
              void pd_test_ndframe_items_keys() {
                  std::cout << "========= items/keys ===========================================" << std::endl;
      
                  pandas::Series<int> s({10, 20, 30});
      
                  // Test items()
                  std::vector<std::string> collected_keys;
                  std::vector<int> collected_values;
      
                  s.items([&](const std::string& key, int value) {
                      collected_keys.push_back(key);
                      collected_values.push_back(value);
                  });
      
                  bool passed = collected_keys.size() == 3;
                  if (!passed) {

.. _example-dataframe-iterrows-391:

.. dropdown:: iterrows (pd_test_2_all.cpp:6498)
   :class-title: example-dropdown

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

                          std::cout << "  [FAIL] : in pd_test_iter_items_content_access() : dtype expected int, got "
                                    << dtype << std::endl;
                          throw std::runtime_error("pd_test_iter_items_content_access failed: dtype");
                      }
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              // =========================================================================
              // iterrows() tests
              // =========================================================================
      
              void pd_test_iter_iterrows_basic() {
                  std::cout << "========= iterrows() basic iteration =============";
      
                  // Create a simple DataFrame
                  std::map<std::string, std::vector<std::string>> data = {
                      {"A", {"a", "b", "c"}},
                      {"B", {"1", "2", "3"}},
                      {"C", {"x", "y", "z"}}

.. _example-dataframe-itertuples-392:

.. dropdown:: itertuples (pd_test_2_all.cpp:6774)
   :class-title: example-dropdown

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

                  passed = (it == end);
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_iter_iterrows_iterator_methods() : didn't reach end" << std::endl;
                      throw std::runtime_error("pd_test_iter_iterrows_iterator_methods failed: didn't reach end");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              // =========================================================================
              // itertuples() tests
              // =========================================================================
      
              void pd_test_iter_itertuples_basic() {
                  std::cout << "========= itertuples() basic iteration ===========";
      
                  // Create a DataFrame similar to pandas example
                  std::map<std::string, std::vector<int>> data = {
                      {"num_legs", {4, 2}},
                      {"num_wings", {0, 2}}
                  };

.. _example-dataframe-keys-393:

.. dropdown:: keys (pd_test_1_all.cpp:16319)
   :class-title: example-dropdown

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

                  }
      
                  // Test default value
                  passed = attrs.get<int>("missing", 99) == 99;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_ndframe_attrs() : default value" << std::endl;
                      throw std::runtime_error("pd_test_ndframe_attrs failed: default value");
                  }
      
                  // Test keys
                  auto keys = attrs.keys();
                  passed = keys.size() == 3;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_ndframe_attrs() : keys()" << std::endl;
                      throw std::runtime_error("pd_test_ndframe_attrs failed: keys()");
                  }
      
                  // Test remove
                  passed = attrs.remove("count") && !attrs.contains("count");
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_ndframe_attrs() : remove" << std::endl;

.. _example-dataframe-duplicated-394:

.. 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-dataframe-isin-395:

.. 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-dataframe-isin-396:

.. 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-dataframe-is_na_at-397:

.. dropdown:: is_na_at (pd_test_5_all.cpp:35205)
   :class-title: example-dropdown

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

          pandas::DataFrame df;
          df.add_column_nullable<bool>("X", {true, pandas::NA_BOOL, false});
          pandas_tests::check(df["X"].get_value_bool(0) == true,  "case_3.idx0_true",   local_fail);
          pandas_tests::check(df["X"].get_value_bool(1) == false, "case_3.idx1_NA_false", local_fail);
          pandas_tests::check(df["X"].get_value_bool(2) == false, "case_3.idx2_false",  local_fail);
      }
      
      void bool_nullable_826495_case_4_is_na_at_mask_aware(int& local_fail) {
          pandas::DataFrame df;
          df.add_column_nullable<bool>("X", {true, pandas::NA_BOOL, false});
          pandas_tests::check(df["X"].is_na_at(0) == false, "case_4.idx0_not_na", local_fail);
          pandas_tests::check(df["X"].is_na_at(1) == true,  "case_4.idx1_is_na",  local_fail);
          pandas_tests::check(df["X"].is_na_at(2) == false, "case_4.idx2_not_na", local_fail);
      }
      
      void bool_nullable_826495_case_5_fillna_preserves_dtype(int& local_fail) {
          pandas::DataFrame df;
          df.add_column_nullable<bool>("X", {true, pandas::NA_BOOL, false});
          pandas_tests::check(df["X"].dtype_name() == "boolean", "case_5.pre_dtype", local_fail);
          auto df_filled = df.fillna(1.0);
          pandas_tests::check(df_filled["X"].dtype_name() == "boolean",

.. _example-dataframe-is_numeric_dtype-398:

.. dropdown:: is_numeric_dtype (pd_test_2_all.cpp:19939)
   :class-title: example-dropdown

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

          check(labels2[0] == "33.3%", "pct_label_33_3");
      }
      
      // =====================================================================
      // Test: is_numeric_dtype covers all expected types
      // =====================================================================
      
      void pd_test_describe_is_numeric_dtype() {
          std::cout << "  -- pd_test_describe_is_numeric_dtype --" << std::endl;
      
          check(pandas::DataFrame::is_numeric_dtype("int64"), "is_numeric_int64");
          check(pandas::DataFrame::is_numeric_dtype("Int64"), "is_numeric_Int64");
          check(pandas::DataFrame::is_numeric_dtype("float64"), "is_numeric_float64");
          check(pandas::DataFrame::is_numeric_dtype("Float64"), "is_numeric_Float64");
          check(pandas::DataFrame::is_numeric_dtype("uint8"), "is_numeric_uint8");
          check(pandas::DataFrame::is_numeric_dtype("UInt32"), "is_numeric_UInt32");
          check(!pandas::DataFrame::is_numeric_dtype("object"), "not_numeric_object");
          check(!pandas::DataFrame::is_numeric_dtype("string"), "not_numeric_string");
          check(!pandas::DataFrame::is_numeric_dtype("bool"), "not_numeric_bool");
          check(!pandas::DataFrame::is_numeric_dtype("datetime64[ns]"), "not_numeric_datetime");
      }

.. _example-dataframe-abs-399:

.. dropdown:: abs (pd_test_1_all.cpp:283)
   :class-title: example-dropdown

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

                  std::optional<bool>(true)
              });
      
              auto s = arr.sum();
              if (!s.has_value() || s.value() != 3) {
                  std::cout << "  [FAIL] : in pd_test_boolean_array_reductions() : sum should be 3" << std::endl;
                  throw std::runtime_error("pd_test_boolean_array_reductions failed: sum");
              }
      
              auto m = arr.mean();
              if (!m.has_value() || std::abs(m.value() - 0.75) > 0.001) {
                  std::cout << "  [FAIL] : in pd_test_boolean_array_reductions() : mean should be 0.75" << std::endl;
                  throw std::runtime_error("pd_test_boolean_array_reductions failed: mean");
              }
      
              std::cout << " -> tests passed" << std::endl;
          }
      
          void pd_test_boolean_array_dtype() {
              std::cout << "========= BooleanArray: dtype ======================= ";
      

.. _example-dataframe-all-400:

.. 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-dataframe-all_axis-401:

.. dropdown:: all_axis (pd_test_1_all.cpp:22302)
   :class-title: example-dropdown

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

      
              std::cout << "====================================== [OK] pd_test_where_mask test suite ========================== " << std::endl;
              return 0;
          }
      
      } // namespace dataframe_tests
      // ------------------- pd_test_where_mask.cpp (end) -----------------------------
      
      // ------------------- pd_test_all_any.cpp (start) -----------------------------
      // dataframe_tests/pd_test_all_any.cpp
      // Tests for DataFrame.all_axis() and DataFrame.any_axis() methods
      
      #include <iostream>
      #include <stdexcept>
      #include <cmath>
      #include <limits>
      #include "../pandas/pd_dataframe.h"
      
      // CRITICAL: No using namespace directives
      
      namespace dataframe_tests {

.. _example-dataframe-all_columns_timedelta-402:

.. dropdown:: all_columns_timedelta (pd_test_5_all.cpp:64597)
   :class-title: example-dropdown

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

          pandas_tests::check(!threw, "case_35_four_col.did_not_throw", local_fail);
          if (threw) return;
          pandas_tests::check(min_dtype == "int32",
              "case_35_four_col.min_dtype_is_int32_got_" + min_dtype, local_fail);
          pandas_tests::check(max_dtype == "int32",
              "case_35_four_col.max_dtype_is_int32_got_" + max_dtype, local_fail);
      }
      
      void f_df_min_max_axis1_dtype_9_4287513_case_36_timedelta_only_regression(int& local_fail) {
          std::cout << "-- f_df_min_max_axis1_dtype_9_4287513_case_36_timedelta_only_regression\n";
          // The all_columns_timedelta() branch is preserved by plan_38 — must
          // remain identical pre-fix and post-fix.
          pandas::DataFrame df;
          df.add_column<pandas::Timedelta>("a", {
              pandas::Timedelta("1 days"),
              pandas::Timedelta("2 days"),
              pandas::Timedelta("3 days")});
          df.add_column<pandas::Timedelta>("b", {
              pandas::Timedelta("4 days"),
              pandas::Timedelta("5 days"),
              pandas::Timedelta("6 days")});

.. _example-dataframe-any-403:

.. 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-dataframe-any_axis-404:

.. dropdown:: any_axis (pd_test_1_all.cpp:22302)
   :class-title: example-dropdown

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

      
              std::cout << "====================================== [OK] pd_test_where_mask test suite ========================== " << std::endl;
              return 0;
          }
      
      } // namespace dataframe_tests
      // ------------------- pd_test_where_mask.cpp (end) -----------------------------
      
      // ------------------- pd_test_all_any.cpp (start) -----------------------------
      // dataframe_tests/pd_test_all_any.cpp
      // Tests for DataFrame.all_axis() and DataFrame.any_axis() methods
      
      #include <iostream>
      #include <stdexcept>
      #include <cmath>
      #include <limits>
      #include "../pandas/pd_dataframe.h"
      
      // CRITICAL: No using namespace directives
      
      namespace dataframe_tests {

.. _example-dataframe-arr-405:

.. 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-dataframe-assemble_multi_series_dataframe-406:

.. dropdown:: assemble_multi_series_dataframe (pd_test_3_all.cpp:29020)
   :class-title: example-dropdown

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

      }
      
      void pd_test_df_apply_assembly_assemble_multi_series_df() {
          std::cout << "  -- pd_test_df_apply_assembly_assemble_multi_series_df --" << std::endl;
          int fail = 0;
          auto df = make_numeric_df();
          std::vector<std::unique_ptr<pandas::NDFrameBase>> cols;
          cols.push_back(df.column_to_typed_series(0));
          cols.push_back(df.column_to_typed_series(1));
          cols.push_back(df.column_to_typed_series(2));
          auto out = pandas::DataFrame::assemble_multi_series_dataframe(
              std::move(cols), {"A", "B", "C"}, df.index().clone());
          fail += dfa_check(out.nrows() == 3, "nrows == 3");
          fail += dfa_check(out.ncols() == 3, "ncols == 3");
          fail += dfa_check(out.columns().get_value_str(0) == "A", "col 0 == A");
          fail += dfa_check(out.columns().get_value_str(2) == "C", "col 2 == C");
          fail += dfa_check(out["A"].get_value_double(1) == 2.0, "A[1] == 2.0");
          fail += dfa_check(out["C"].get_value_double(2) == 9.0, "C[2] == 9.0");
          if (fail == 0) std::cout << "    OK" << std::endl;
          if (fail != 0) throw std::runtime_error("pd_test_df_apply_assembly_assemble_multi_series_df failed");
      }

.. _example-dataframe-assemble_scalar_series-407:

.. dropdown:: assemble_scalar_series (pd_test_3_all.cpp:28979)
   :class-title: example-dropdown

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

              fail += dfa_check(ss->cat_ordered() == true, "cat_ordered preserved");
          }
          if (fail == 0) std::cout << "    OK" << std::endl;
          if (fail != 0) throw std::runtime_error("pd_test_df_apply_assembly_column_to_typed_series_category failed");
      }
      
      void pd_test_df_apply_assembly_assemble_scalar_series_int() {
          std::cout << "  -- pd_test_df_apply_assembly_assemble_scalar_series_int --" << std::endl;
          int fail = 0;
          auto df = make_numeric_df();
          auto s = df.assemble_scalar_series({1.0, 2.0, 3.0}, {"A", "B", "C"});
          fail += dfa_check(s.size() == 3, "size == 3");
          fail += dfa_check(s.dtype_name() == "int64", "dtype int64 from whole-number detection");
          fail += dfa_check(s.index().size() == 3, "index size == 3");
          fail += dfa_check(s.index().get_value_str(0) == "A", "index[0] == A");
          if (fail == 0) std::cout << "    OK" << std::endl;
          if (fail != 0) throw std::runtime_error("pd_test_df_apply_assembly_assemble_scalar_series_int failed");
      }
      
      void pd_test_df_apply_assembly_assemble_scalar_series_float() {
          std::cout << "  -- pd_test_df_apply_assembly_assemble_scalar_series_float --" << std::endl;

.. _example-dataframe-assemble_scalar_string_series-408:

.. dropdown:: assemble_scalar_string_series (pd_test_3_all.cpp:29004)
   :class-title: example-dropdown

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

          fail += dfa_check(s.dtype_name() == "float64", "dtype float64");
          fail += dfa_check(s.index().get_value_str(1) == "B", "index[1] == B");
          if (fail == 0) std::cout << "    OK" << std::endl;
          if (fail != 0) throw std::runtime_error("pd_test_df_apply_assembly_assemble_scalar_series_float failed");
      }
      
      void pd_test_df_apply_assembly_assemble_scalar_string_series() {
          std::cout << "  -- pd_test_df_apply_assembly_assemble_scalar_string_series --" << std::endl;
          int fail = 0;
          auto df = make_numeric_df();
          auto s = df.assemble_scalar_string_series({"foo", "bar", "baz"}, {"A", "B", "C"});
          fail += dfa_check(s.size() == 3, "size == 3");
          fail += dfa_check(s[0] == "foo" && s[2] == "baz", "values");
          fail += dfa_check(s.index().get_value_str(2) == "C", "index[2] == C");
          if (fail == 0) std::cout << "    OK" << std::endl;
          if (fail != 0) throw std::runtime_error("pd_test_df_apply_assembly_assemble_scalar_string_series failed");
      }
      
      void pd_test_df_apply_assembly_assemble_multi_series_df() {
          std::cout << "  -- pd_test_df_apply_assembly_assemble_multi_series_df --" << std::endl;
          int fail = 0;

.. _example-dataframe-axes-409:

.. dropdown:: axes (pd_test_1_all.cpp:16602)
   :class-title: example-dropdown

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

      
              // =====================================================================
              // Axes Tests
              // =====================================================================
      
              void pd_test_ndframe_axes() {
                  std::cout << "========= axes =================================================" << std::endl;
      
                  pandas::Series<double> s({1.0, 2.0, 3.0});
      
                  auto axes = s.axes();
      
                  bool passed = axes.size() == 1;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_ndframe_axes() : axes count" << std::endl;
                      throw std::runtime_error("pd_test_ndframe_axes failed: axes count");
                  }
      
                  passed = axes[0]->size() == 3;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_ndframe_axes() : axis size" << std::endl;

.. _example-dataframe-broadcast_series_to_bool_dataframe-410:

.. dropdown:: broadcast_series_to_bool_dataframe (pd_test_3_all.cpp:28228)
   :class-title: example-dropdown

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

                  r.iat<double>(0, b) != -1.0 || r.iat<double>(1, b) != 4.0) {
                  throw std::runtime_error("pd_test_where_df_condition failed");
              }
              std::cout << "PASSED" << std::endl;
          }
      
          void pd_test_where_series_condition_axis0() {
              std::cout << "  pd_test_where_series_condition_axis0... ";
              auto df = make_df_2x2();
              pandas::Series<numpy::float64> s({1.0, 0.0});
              auto cond = df.broadcast_series_to_bool_dataframe(s, 0);
              auto r = df.where(cond, -1.0);
              size_t a = df.get_column_index("A");
              size_t b = df.get_column_index("B");
              if (r.iat<double>(0, a) != 1.0 || r.iat<double>(1, a) != -1.0 ||
                  r.iat<double>(0, b) != 3.0 || r.iat<double>(1, b) != -1.0) {
                  throw std::runtime_error("pd_test_where_series_condition_axis0 failed");
              }
              std::cout << "PASSED" << std::endl;
          }
      

.. _example-dataframe-cbegin-411:

.. dropdown:: cbegin (pd_test_2_all.cpp:6185)
   :class-title: example-dropdown

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

                  std::cout << "========= const iteration ========================";
      
                  std::map<std::string, std::vector<int>> data = {
                      {"Col1", {1}},
                      {"Col2", {2}}
                  };
                  const pandas::DataFrame df(data);
      
                  // Test const iteration
                  std::vector<std::string> cols;
                  for (auto it = df.cbegin(); it != df.cend(); ++it) {
                      cols.push_back(*it);
                  }
      
                  bool passed = (cols.size() == 2);
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_iter_const_iteration() : expected 2 columns" << std::endl;
                      throw std::runtime_error("pd_test_iter_const_iteration failed: size mismatch");
                  }
      
                  std::cout << " -> tests passed" << std::endl;

.. _example-dataframe-ceil-412:

.. 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-dataframe-cend-413:

.. dropdown:: cend (pd_test_2_all.cpp:6185)
   :class-title: example-dropdown

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

                  std::cout << "========= const iteration ========================";
      
                  std::map<std::string, std::vector<int>> data = {
                      {"Col1", {1}},
                      {"Col2", {2}}
                  };
                  const pandas::DataFrame df(data);
      
                  // Test const iteration
                  std::vector<std::string> cols;
                  for (auto it = df.cbegin(); it != df.cend(); ++it) {
                      cols.push_back(*it);
                  }
      
                  bool passed = (cols.size() == 2);
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_iter_const_iteration() : expected 2 columns" << std::endl;
                      throw std::runtime_error("pd_test_iter_const_iteration failed: size mismatch");
                  }
      
                  std::cout << " -> tests passed" << std::endl;

.. _example-dataframe-classify_column_access-414:

.. dropdown:: classify_column_access (pd_test_2_all.cpp:20218)
   :class-title: example-dropdown

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

      // =========================================================================
      // Classification tests
      // =========================================================================
      
      void pd_test_getitem_dispatch_classify_numeric() {
          std::cout << "pd_test_getitem_dispatch_classify_numeric" << std::endl;
          pandas::DataFrame df;
          std::vector<numpy::float64> vals = {1.0, 2.0, 3.0};
          df.insert(0, "A", std::make_unique<pandas::Series<numpy::float64>>(vals, "A"), true);
      
          auto t = df.classify_column_access("A");
          check(t == pandas::DataFrame::ColumnAccessType::NumericColumn, "float64 -> NumericColumn");
      
          // int64 column
          pandas::DataFrame df2;
          std::vector<numpy::int64> ivals = {10, 20, 30};
          auto iseries = std::make_unique<pandas::Series<numpy::int64>>(ivals, "B");
          iseries->set_dtype_override("int64");
          df2.insert(0, "B", std::move(iseries), true);
          auto t2 = df2.classify_column_access("B");
          check(t2 == pandas::DataFrame::ColumnAccessType::NumericColumn, "int64 -> NumericColumn");

.. _example-dataframe-classify_column_dtypes-415:

.. dropdown:: classify_column_dtypes (pd_test_2_all.cpp:19207)
   :class-title: example-dropdown

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

                    << (dataframe_tests_agg_dispatch::g_fail == 0 ? "OK" : "FAIL")
                    << "] pd_test_agg_dispatch test suite ========================== " << std::endl;
          return dataframe_tests_agg_dispatch::g_fail;
      }
      
      }  // namespace dataframe_tests
      // ------------------- pd_test_agg_dispatch.cpp (end) -----------------------------
      
      // ------------------- pd_test_agg_dtype.cpp (start) -----------------------------
      // pd_test_agg_dtype.cpp - Tests for aggregation dtype resolution migration
      // AggColumnInfo struct, classify_column_dtypes(), enhanced sum()
      
      #include <iostream>
      #include <string>
      #include <vector>
      #include <cmath>
      
      #include "../pandas/pd_dataframe.h"
      #include "../pandas/pd_series.h"
      #include "../pandas/pd_index.h"
      

.. _example-dataframe-clip-416:

.. dropdown:: clip (pd_test_1_all.cpp:5099)
   :class-title: example-dropdown

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

                      throw std::runtime_error("pd_test_arithmetic_dataframe_abs_clip failed: abs failed");
                  }
      
                  val = a["A"].get_value_str(2);
                  passed = std::abs(std::stod(val) - 3.0) < 0.001;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_dataframe_abs_clip() : abs for -3 failed" << std::endl;
                      throw std::runtime_error("pd_test_arithmetic_dataframe_abs_clip failed: abs for -3 failed");
                  }
      
                  auto c = df.clip(-2.0, 2.0);
                  val = c["A"].get_value_str(2);
                  passed = std::abs(std::stod(val) - (-2.0)) < 0.001;  // -3 clipped to -2
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_arithmetic_dataframe_abs_clip() : clip lower failed" << std::endl;
                      throw std::runtime_error("pd_test_arithmetic_dataframe_abs_clip failed: clip lower failed");
                  }
      
                  val = c["A"].get_value_str(3);
                  passed = std::abs(std::stod(val) - 2.0) < 0.001;  // 4 clipped to 2
                  if (!passed) {

.. _example-dataframe-clone-417:

.. 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-dataframe-col-418:

.. dropdown:: col (pd_test_1_all.cpp:6625)
   :class-title: example-dropdown

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

      
                  // Test replace
                  {
                      std::map<std::string, std::vector<numpy::float64>> float_data;
                      float_data["X"] = {1.0, 2.0, 3.0};
                      float_data["Y"] = {2.0, 2.0, 4.0};
                      pandas::DataFrame df_repl(float_data);
      
                      auto replaced = df_repl.replace(2.0, 99.0);
                      // Check some value was replaced (crude check via string)
                      std::string val_str = replaced.col<numpy::float64>("X").get_value_str(1);
                      if (val_str.find("99") == std::string::npos) {
                          std::cout << "  [FAIL] : in pd_test_dataframe_manipulation() : replace didn't work" << std::endl;
                          throw std::runtime_error("pd_test_dataframe_manipulation failed: replace");
                      }
                  }
      
                  // Test drop_duplicates
                  {
                      std::map<std::string, std::vector<numpy::int64>> dup_data;
                      dup_data["A"] = {1, 1, 2, 2};

.. _example-dataframe-col-419:

.. dropdown:: col (pd_test_1_all.cpp:6625)
   :class-title: example-dropdown

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

      
                  // Test replace
                  {
                      std::map<std::string, std::vector<numpy::float64>> float_data;
                      float_data["X"] = {1.0, 2.0, 3.0};
                      float_data["Y"] = {2.0, 2.0, 4.0};
                      pandas::DataFrame df_repl(float_data);
      
                      auto replaced = df_repl.replace(2.0, 99.0);
                      // Check some value was replaced (crude check via string)
                      std::string val_str = replaced.col<numpy::float64>("X").get_value_str(1);
                      if (val_str.find("99") == std::string::npos) {
                          std::cout << "  [FAIL] : in pd_test_dataframe_manipulation() : replace didn't work" << std::endl;
                          throw std::runtime_error("pd_test_dataframe_manipulation failed: replace");
                      }
                  }
      
                  // Test drop_duplicates
                  {
                      std::map<std::string, std::vector<numpy::int64>> dup_data;
                      dup_data["A"] = {1, 1, 2, 2};

.. _example-dataframe-col_data-420:

.. dropdown:: col_data (pd_test_4_all.cpp:5286)
   :class-title: example-dropdown

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

      namespace {
      
      // Build a DataFrame matching the original fixture *after* the sliced setitem.
      // override_fn(orig) computes the replacement value for every row whose
      // C-level (third level of the row MultiIndex) is "C1" or "C3".
      template <typename Fn>
      pandas::DataFrame build_slicer_post_state(Fn override_fn) {
          constexpr size_t N_ROWS = 64;  // 4 * 2 * 4 * 2
          constexpr size_t N_COLS = 4;
      
          std::vector<std::vector<int64_t>> col_data(N_COLS);
          for (auto& v : col_data) v.reserve(N_ROWS);
      
          for (size_t r = 0; r < N_ROWS; ++r) {
              // r decomposes as a*16 + b*8 + c*2 + d  (strides for 4·2·4·2)
              size_t c_lvl = (r / 2) % 4;            // 0..3 → C0..C3
              bool overridden = (c_lvl == 1 || c_lvl == 3);
              for (size_t c = 0; c < N_COLS; ++c) {
                  int64_t orig = static_cast<int64_t>(r * N_COLS + c);
                  col_data[c].push_back(overridden ? override_fn(orig) : orig);
              }

.. _example-dataframe-col_data-421:

.. dropdown:: col_data (pd_test_4_all.cpp:5286)
   :class-title: example-dropdown

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

      namespace {
      
      // Build a DataFrame matching the original fixture *after* the sliced setitem.
      // override_fn(orig) computes the replacement value for every row whose
      // C-level (third level of the row MultiIndex) is "C1" or "C3".
      template <typename Fn>
      pandas::DataFrame build_slicer_post_state(Fn override_fn) {
          constexpr size_t N_ROWS = 64;  // 4 * 2 * 4 * 2
          constexpr size_t N_COLS = 4;
      
          std::vector<std::vector<int64_t>> col_data(N_COLS);
          for (auto& v : col_data) v.reserve(N_ROWS);
      
          for (size_t r = 0; r < N_ROWS; ++r) {
              // r decomposes as a*16 + b*8 + c*2 + d  (strides for 4·2·4·2)
              size_t c_lvl = (r / 2) % 4;            // 0..3 → C0..C3
              bool overridden = (c_lvl == 1 || c_lvl == 3);
              for (size_t c = 0; c < N_COLS; ++c) {
                  int64_t orig = static_cast<int64_t>(r * N_COLS + c);
                  col_data[c].push_back(overridden ? override_fn(orig) : orig);
              }

.. _example-dataframe-col_data-422:

.. dropdown:: col_data (pd_test_4_all.cpp:5286)
   :class-title: example-dropdown

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

      namespace {
      
      // Build a DataFrame matching the original fixture *after* the sliced setitem.
      // override_fn(orig) computes the replacement value for every row whose
      // C-level (third level of the row MultiIndex) is "C1" or "C3".
      template <typename Fn>
      pandas::DataFrame build_slicer_post_state(Fn override_fn) {
          constexpr size_t N_ROWS = 64;  // 4 * 2 * 4 * 2
          constexpr size_t N_COLS = 4;
      
          std::vector<std::vector<int64_t>> col_data(N_COLS);
          for (auto& v : col_data) v.reserve(N_ROWS);
      
          for (size_t r = 0; r < N_ROWS; ++r) {
              // r decomposes as a*16 + b*8 + c*2 + d  (strides for 4·2·4·2)
              size_t c_lvl = (r / 2) % 4;            // 0..3 → C0..C3
              bool overridden = (c_lvl == 1 || c_lvl == 3);
              for (size_t c = 0; c < N_COLS; ++c) {
                  int64_t orig = static_cast<int64_t>(r * N_COLS + c);
                  col_data[c].push_back(overridden ? override_fn(orig) : orig);
              }

.. _example-dataframe-col_data-423:

.. dropdown:: col_data (pd_test_4_all.cpp:5286)
   :class-title: example-dropdown

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

      namespace {
      
      // Build a DataFrame matching the original fixture *after* the sliced setitem.
      // override_fn(orig) computes the replacement value for every row whose
      // C-level (third level of the row MultiIndex) is "C1" or "C3".
      template <typename Fn>
      pandas::DataFrame build_slicer_post_state(Fn override_fn) {
          constexpr size_t N_ROWS = 64;  // 4 * 2 * 4 * 2
          constexpr size_t N_COLS = 4;
      
          std::vector<std::vector<int64_t>> col_data(N_COLS);
          for (auto& v : col_data) v.reserve(N_ROWS);
      
          for (size_t r = 0; r < N_ROWS; ++r) {
              // r decomposes as a*16 + b*8 + c*2 + d  (strides for 4·2·4·2)
              size_t c_lvl = (r / 2) % 4;            // 0..3 → C0..C3
              bool overridden = (c_lvl == 1 || c_lvl == 3);
              for (size_t c = 0; c < N_COLS; ++c) {
                  int64_t orig = static_cast<int64_t>(r * N_COLS + c);
                  col_data[c].push_back(overridden ? override_fn(orig) : orig);
              }

.. _example-dataframe-column-424:

.. dropdown:: column (pd_test_1_all.cpp:22039)
   :class-title: example-dropdown

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

                  std::string a1 = result.iat<double>(1, col_a_idx) == -1.0 ? "ok" : "fail";
                  std::string a2 = result.iat<double>(2, col_a_idx) == 3.0 ? "ok" : "fail";
                  std::string a3 = result.iat<double>(3, col_a_idx) == 4.0 ? "ok" : "fail";
      
                  if (a0 != "ok" || a1 != "ok" || a2 != "ok" || a3 != "ok") {
                      passed = false;
                      error_msg = "Column A values incorrect: A[0]=" + a0 + ", A[1]=" + a1 +
                                  ", A[2]=" + a2 + ", A[3]=" + a3;
                  }
      
                  // Check B column (all should be original)
                  double b0 = result.iat<double>(0, col_b_idx);
                  if (b0 != 5.0) {
                      passed = false;
                      error_msg = "B[0] should be 5, got " + std::to_string(b0);
                  }
      
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_where_basic() : " << error_msg << std::endl;
                      throw std::runtime_error("pd_test_where_basic failed: " + error_msg);
                  }

.. _example-dataframe-column-425:

.. dropdown:: column (pd_test_1_all.cpp:22039)
   :class-title: example-dropdown

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

                  std::string a1 = result.iat<double>(1, col_a_idx) == -1.0 ? "ok" : "fail";
                  std::string a2 = result.iat<double>(2, col_a_idx) == 3.0 ? "ok" : "fail";
                  std::string a3 = result.iat<double>(3, col_a_idx) == 4.0 ? "ok" : "fail";
      
                  if (a0 != "ok" || a1 != "ok" || a2 != "ok" || a3 != "ok") {
                      passed = false;
                      error_msg = "Column A values incorrect: A[0]=" + a0 + ", A[1]=" + a1 +
                                  ", A[2]=" + a2 + ", A[3]=" + a3;
                  }
      
                  // Check B column (all should be original)
                  double b0 = result.iat<double>(0, col_b_idx);
                  if (b0 != 5.0) {
                      passed = false;
                      error_msg = "B[0] should be 5, got " + std::to_string(b0);
                  }
      
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_where_basic() : " << error_msg << std::endl;
                      throw std::runtime_error("pd_test_where_basic failed: " + error_msg);
                  }

.. _example-dataframe-column_at-426:

.. dropdown:: column_at (pd_test_3_all.cpp:23814)
   :class-title: example-dropdown

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

          std::map<std::string, std::vector<double>> data = {
              {"A", {1.0, 2.0, 3.0}}, {"B", {10.0, 20.0, 30.0}}
          };
          pandas::DataFrame df(data);
          pandas::DataFrame result = df.agg("sum", 1);
          // Row sums: 11, 22, 33
          if (result.nrows() != 3) {
              std::cout << "  [FAIL] : in pd_test_agg_axis1_sum() : wrong nrows" << std::endl;
              throw std::runtime_error("pd_test_agg_axis1_sum failed: wrong nrows");
          }
          if (std::abs(result.column_at(0).get_value_double(0) - 11.0) > 1e-10 ||
              std::abs(result.column_at(0).get_value_double(1) - 22.0) > 1e-10 ||
              std::abs(result.column_at(0).get_value_double(2) - 33.0) > 1e-10) {
              std::cout << "  [FAIL] : in pd_test_agg_axis1_sum() : wrong row sums" << std::endl;
              throw std::runtime_error("pd_test_agg_axis1_sum failed: wrong row sums");
          }
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_agg_axis1_mean() {
          std::cout << "========= DataFrame.agg('mean', axis=1) ===============";

.. _example-dataframe-column_dtype_override-427:

.. dropdown:: column_dtype_override (pd_test_2_all.cpp:20590)
   :class-title: example-dropdown

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

      
          std::vector<pandas::NamedAggSpec> specs;
          specs.push_back({"cnt", "val", "count"});
      
          auto result = gb.agg_named(specs);
      
          check(result.has_column("cnt"), "count_has_col");
          check(approx_eq(result["cnt"].get_value_double(0), 2.0), "count_a_eq_2");
          check(approx_eq(result["cnt"].get_value_double(1), 3.0), "count_b_eq_3");
          // count should always produce int64
          check(result.column_dtype_override("cnt") == "int64", "count_dtype_int64");
      }
      
      // =====================================================================
      // Test: agg_named() dtype propagation — int source + sum -> int64
      // =====================================================================
      
      void pd_test_groupby_apply_named_agg_dtype_int_sum() {
          std::cout << "  -- pd_test_groupby_apply_named_agg_dtype_int_sum --" << std::endl;
      
          pandas::DataFrame df;

.. _example-dataframe-column_to_series_f64-428:

.. dropdown:: column_to_series_f64 (pd_test_2_all.cpp:19385)
   :class-title: example-dropdown

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

                    << dataframe_tests_agg_dtype::g_fail << " failed)" << std::endl;
      
          return dataframe_tests_agg_dtype::g_fail;
      }
      
      } // namespace dataframe_tests
      // ------------------- pd_test_agg_dtype.cpp (end) -----------------------------
      
      // ------------------- pd_test_apply_extract.cpp (start) -----------------------------
      // pd_test_apply_extract.cpp - Tests for DataFrame column/row extraction helpers
      // column_to_series_f64(), column_to_series_str(), row_values_f64()
      
      #include <iostream>
      #include <string>
      #include <vector>
      #include <cmath>
      
      #include "../pandas/pd_dataframe.h"
      #include "../pandas/pd_series.h"
      #include "../pandas/pd_index.h"
      

.. _example-dataframe-column_to_series_str-429:

.. dropdown:: column_to_series_str (pd_test_2_all.cpp:19385)
   :class-title: example-dropdown

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

                    << dataframe_tests_agg_dtype::g_fail << " failed)" << std::endl;
      
          return dataframe_tests_agg_dtype::g_fail;
      }
      
      } // namespace dataframe_tests
      // ------------------- pd_test_agg_dtype.cpp (end) -----------------------------
      
      // ------------------- pd_test_apply_extract.cpp (start) -----------------------------
      // pd_test_apply_extract.cpp - Tests for DataFrame column/row extraction helpers
      // column_to_series_f64(), column_to_series_str(), row_values_f64()
      
      #include <iostream>
      #include <string>
      #include <vector>
      #include <cmath>
      
      #include "../pandas/pd_dataframe.h"
      #include "../pandas/pd_series.h"
      #include "../pandas/pd_index.h"
      

.. _example-dataframe-column_to_typed_series-430:

.. dropdown:: column_to_typed_series (pd_test_3_all.cpp:28921)
   :class-title: example-dropdown

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

          fail += dfa_check(rd.numeric_vals[1] == 30.0, "numeric_vals[1]==30.0");
          fail += dfa_check(rd.numeric_vals[2] == 100.0, "numeric_vals[2]==100.0");
          if (fail == 0) std::cout << "    OK" << std::endl;
          if (fail != 0) throw std::runtime_error("pd_test_df_apply_assembly_extract_row_typed_mixed failed");
      }
      
      void pd_test_df_apply_assembly_column_to_typed_series_float() {
          std::cout << "  -- pd_test_df_apply_assembly_column_to_typed_series_float --" << std::endl;
          int fail = 0;
          auto df = make_numeric_df();
          auto s = df.column_to_typed_series(0);
          fail += dfa_check(s != nullptr, "series not null");
          fail += dfa_check(s->size() == 3, "size == 3");
          auto* fs = dynamic_cast<pandas::Series<numpy::float64>*>(s.get());
          fail += dfa_check(fs != nullptr, "dynamic_cast<Series<f64>>");
          if (fs) {
              fail += dfa_check((*fs)[0] == 1.0 && (*fs)[2] == 3.0, "values correct");
          }
          if (fail == 0) std::cout << "    OK" << std::endl;
          if (fail != 0) throw std::runtime_error("pd_test_df_apply_assembly_column_to_typed_series_float failed");
      }

.. _example-dataframe-columns-431:

.. dropdown:: columns (pd_test_1_all.cpp:6220)
   :class-title: example-dropdown

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

                      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");
                  }
      
                  // Test dtypes
                  auto dtypes = df.dtypes();
                  if (dtypes.size() != 3) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_properties() : dtypes size != 3" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_properties failed: dtypes size != 3");
                  }

.. _example-dataframe-columns_index_dtype-432:

.. dropdown:: columns_index_dtype (pd_test_3_all.cpp:23051)
   :class-title: example-dropdown

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

          df2.add_column<double>("B", {3.0, 4.0});
          pandas::construct_helpers::apply_column_index_name(df2, "");
          // name should remain unset or empty
          if (df2.columns().name().has_value() && !df2.columns().name()->empty())
              throw std::runtime_error("test_apply_column_metadata: empty name should not set columns_name");
      
          // apply_int_column_dtype with true
          pandas::DataFrame df3;
          df3.add_column<double>("C", {5.0, 6.0});
          pandas::construct_helpers::apply_int_column_dtype(df3, true);
          if (df3.columns_index_dtype() != "int64")
              throw std::runtime_error("test_apply_column_metadata: columns_index_dtype should be 'int64'");
      
          // apply_int_column_dtype with false -> no change
          pandas::DataFrame df4;
          df4.add_column<double>("D", {7.0, 8.0});
          pandas::construct_helpers::apply_int_column_dtype(df4, false);
          if (df4.columns_index_dtype() == "int64")
              throw std::runtime_error("test_apply_column_metadata: false flag should not set int64 dtype");
      
          std::cout << "    -> test passed" << std::endl;

.. _example-dataframe-columns_level_names-433:

.. dropdown:: columns_level_names (pd_test_5_all.cpp:33080)
   :class-title: example-dropdown

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

              // Flat: just dump columns_index_
              std::cout << tag << " flat_columns=[";
              for (size_t c = 0; c < df.ncols(); ++c) {
                  if (c) std::cout << ", ";
                  std::cout << "\"" << df.columns().get_value_str(c) << "\"";
              }
              std::cout << "]\n";
              return;
          }
          const auto& levels = df.columns_levels();
          const auto& lnames = df.columns_level_names();
          for (size_t lvl = 0; lvl < levels.size(); ++lvl) {
              std::cout << tag << " level[" << lvl << "]"
                        << " name=\""
                        << (lvl < lnames.size() ? lnames[lvl] : std::string("<?>"))
                        << "\" values=[";
              for (size_t c = 0; c < levels[lvl].size(); ++c) {
                  if (c) std::cout << ", ";
                  std::cout << "\"" << levels[lvl][c] << "\"";
              }
              std::cout << "]\n";

.. _example-dataframe-columns_levels-434:

.. dropdown:: columns_levels (pd_test_3_all.cpp:23276)
   :class-title: example-dropdown

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

          // Create a df with 3 columns
          std::map<std::string, std::vector<double>> data = {
              {"a\tx", {1.0}}, {"a\ty", {2.0}}, {"b\tx", {3.0}}
          };
          pandas::DataFrame df(data);
      
          pandas::construct_helpers::apply_multiindex_columns(df, mi);
      
          // Verify columns_levels
          if (!df.has_columns_levels()) throw std::runtime_error("expected columns_levels");
          const auto& levels = df.columns_levels();
          if (levels.size() != 2) throw std::runtime_error("expected 2 levels, got " + std::to_string(levels.size()));
          if (levels[0].size() != 3) throw std::runtime_error("expected 3 entries in level 0");
          if (levels[0][0] != "a" || levels[0][2] != "b") throw std::runtime_error("wrong level 0 values");
          if (levels[1][0] != "x" || levels[1][1] != "y") throw std::runtime_error("wrong level 1 values");
      
          std::cout << "    -> test passed" << std::endl;
      }
      
      void test_reconstruct_multiindex() {
          std::cout << "========= reconstruct_multiindex ======================";

.. _example-dataframe-columns_name-435:

.. dropdown:: columns_name (pd_test_3_all.cpp:10809)
   :class-title: example-dropdown

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

          df.add_column<int64_t>("B", {4, 5, 6});
          auto s = df.shape_2d();
          if (s.first != 3 || s.second != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_shape_2d() : wrong dimensions" << std::endl;
              throw std::runtime_error("pd_test_3_all_shape_2d failed");
          }
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_columns_name_setter() {
          std::cout << "========= DataFrame.columns_name(string) setter ========";
          pandas::DataFrame df;
          df.add_column<int64_t>("A", {1, 2, 3});
          df.columns_name("MyColumns");
          pandas::DataFrame df2;
          df2.add_column<int64_t>("A", {1, 2, 3});
          df2.set_columns_name("MyColumns");
          if (df.to_string() != df2.to_string()) {
              std::cout << "  [FAIL] : in pd_test_3_all_columns_name_setter() : mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_columns_name_setter failed");
          }

.. _example-dataframe-compute_string_column_stats-436:

.. dropdown:: compute_string_column_stats (pd_test_2_all.cpp:19759)
   :class-title: example-dropdown

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

                    << "] pd_test_broadcasting test suite ==========================" << std::endl;
      
          return dataframe_tests_broadcasting::g_fail;
      }
      
      } // namespace dataframe_tests
      // ------------------- pd_test_broadcasting.cpp (end) -----------------------------
      
      // ------------------- pd_test_describe.cpp (start) -----------------------------
      // pd_test_describe.cpp - Tests for describe_full() migration
      // StringColumnStats, compute_string_column_stats(), describe_full() modes
      
      #include <iostream>
      #include <string>
      #include <vector>
      #include <cmath>
      
      #include "../pandas/pd_dataframe.h"
      #include "../pandas/pd_series.h"
      #include "../pandas/pd_index.h"
      

.. _example-dataframe-corr-437:

.. dropdown:: corr (pd_test_1_all.cpp:4655)
   :class-title: example-dropdown

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

              }
      
              void pd_test_aggregation_dataframe_corr() {
                  std::cout << "========= DataFrame corr ========================";
      
                  std::map<std::string, std::vector<double>> data;
                  data["A"] = {1.0, 2.0, 3.0, 4.0, 5.0};
                  data["B"] = {2.0, 4.0, 6.0, 8.0, 10.0};  // Perfect correlation
                  pandas::DataFrame df(data);
      
                  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);

.. _example-dataframe-corrwith-438:

.. dropdown:: corrwith (pd_test_2_all.cpp:2013)
   :class-title: example-dropdown

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

      
              std::cout << "====================================== [OK] pd_test_combine test suite ========================== " << std::endl;
              return 0;
          }
      
      } // namespace dataframe_tests
      // ------------------- pd_test_combine.cpp (end) -----------------------------
      
      // ------------------- pd_test_corrwith.cpp (start) -----------------------------
      // dataframe_tests/pd_test_corrwith.cpp
      // Test suite for DataFrame::corrwith() method
      
      #include <iostream>
      #include <stdexcept>
      #include <cmath>
      #include "../pandas/pd_dataframe.h"
      
      namespace dataframe_tests {
          namespace dataframe_tests_corrwith {
      
              // Helper to check if two doubles are approximately equal

.. _example-dataframe-corrwith-439:

.. dropdown:: corrwith (pd_test_2_all.cpp:2013)
   :class-title: example-dropdown

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

      
              std::cout << "====================================== [OK] pd_test_combine test suite ========================== " << std::endl;
              return 0;
          }
      
      } // namespace dataframe_tests
      // ------------------- pd_test_combine.cpp (end) -----------------------------
      
      // ------------------- pd_test_corrwith.cpp (start) -----------------------------
      // dataframe_tests/pd_test_corrwith.cpp
      // Test suite for DataFrame::corrwith() method
      
      #include <iostream>
      #include <stdexcept>
      #include <cmath>
      #include "../pandas/pd_dataframe.h"
      
      namespace dataframe_tests {
          namespace dataframe_tests_corrwith {
      
              // Helper to check if two doubles are approximately equal

.. _example-dataframe-cov-440:

.. dropdown:: cov (pd_test_1_all.cpp:4690)
   :class-title: example-dropdown

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

                  std::cout << " -> tests passed" << std::endl;
              }
      
              void pd_test_aggregation_dataframe_cov() {
                  std::cout << "========= DataFrame cov =========================";
      
                  std::map<std::string, std::vector<double>> data;
                  data["A"] = {1.0, 2.0, 3.0};
                  pandas::DataFrame df(data);
      
                  auto cov_df = df.cov();
      
                  // Check dimensions
                  bool passed = cov_df.nrows() == 1 && cov_df.ncols() == 1;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_aggregation_dataframe_cov() : cov should be 1x1" << std::endl;
                      throw std::runtime_error("pd_test_aggregation_dataframe_cov failed: cov should be 1x1");
                  }
      
                  // Var(A) = 1.0 with ddof=1
                  std::string aa = cov_df["A"].get_value_str(0);

.. _example-dataframe-dt-441:

.. dropdown:: dt (pd_test_3_all.cpp:18239)
   :class-title: example-dropdown

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

          if (offset.freqstr() != "D") {
              std::cout << "  [FAIL] : Day freqstr() failed" << std::endl;
              throw std::runtime_error("pd_test_day_offset: freqstr() failed");
          }
          if (offset.name() != "Day") {
              std::cout << "  [FAIL] : Day name() failed" << std::endl;
              throw std::runtime_error("pd_test_day_offset: name() failed");
          }
      
          // Test apply
          numpy::datetime64 dt("2020-01-15");
          auto result = offset.apply(dt);
          std::tm tm = result.toTm();
          if (tm.tm_mday != 20) {
              std::cout << "  [FAIL] : Day apply() failed, got day " << tm.tm_mday << std::endl;
              throw std::runtime_error("pd_test_day_offset: apply() failed");
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      

.. _example-dataframe-dtype_name-442:

.. dropdown:: dtype_name (pd_test_1_all.cpp:10104)
   :class-title: example-dropdown

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

      }
      
      void pd_test_extension_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.dtype_name() == "category");
          if (!passed) {
              std::cout << "  [FAIL] : in pd_test_extension_index_array_constructor() : array constructor check failed" << std::endl;
              throw std::runtime_error("pd_test_extension_index_array_constructor failed");
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_extension_index_copy_constructor() {
          std::cout << "========= copy constructor =========================";

.. _example-dataframe-dtype_string-443:

.. dropdown:: dtype_string (pd_test_5_all.cpp:93010)
   :class-title: example-dropdown

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

          pandas_tests::check(threw_neg,
              "f_test_25_iat_resolved_out_of_range_throws_927551.neg_throws",
              local_fail);
      }
      
      void case_27_propagate_dtype_nan_suppresses() {
          // has_nan_from_upcasting=true => no propagation (column dtype unchanged).
          std::cout << "-- case_27_propagate_dtype_nan_suppresses()\n";
          int local_fail = 0;
          auto df = make_1row_df();
          std::string col_before = df.dtype_string("x");
      
          pandas::AlignmentResult ar;
          ar.kind = pandas::SetItemResult::PARTIAL_ALIGN;
          ar.has_nan_from_upcasting = true;
          ar.aligned_values = {std::numeric_limits<double>::quiet_NaN()};
      
          pandas::propagate_aligned_dtype<std::int64_t>(df, std::string("x"), ar,
                                                        std::string("int64"));
          std::string col_after = df.dtype_string("x");
          pandas_tests::check(col_before == col_after,

.. _example-dataframe-dtypes-444:

.. dropdown:: dtypes (pd_test_1_all.cpp:6226)
   :class-title: example-dropdown

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

                      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");
                  }
      
                  // Test dtypes
                  auto dtypes = df.dtypes();
                  if (dtypes.size() != 3) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_properties() : dtypes size != 3" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_properties failed: dtypes size != 3");
                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              // =====================================================================
              // Test: Column Access

.. _example-dataframe-empty-445:

.. dropdown:: empty (pd_test_1_all.cpp:941)
   :class-title: example-dropdown

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

      
      #include "../pandas/pd_config.h"
      
      namespace dataframe_tests {
      
      namespace dataframe_tests_config {
      
          void pd_test_config_version() {
              std::cout << "========= df_config: version info ======================= ";
              const char* version = pandas::DataFrameInfo::version();
              if (version == nullptr || std::string(version).empty()) {
                  std::cout << "[FAIL] : in pd_test_config_version() : version is null or empty" << std::endl;
                  throw std::runtime_error("pd_test_config_version failed: version is null or empty");
              }
              std::cout << "-> tests passed" << std::endl;
          }
      
          void pd_test_config_na_repr() {
              std::cout << "========= df_config: NA representation ======================= ";
              const char* na_repr = pandas::DataFrameConfig::get_na_repr();
              if (na_repr == nullptr) {

.. _example-dataframe-eval-446:

.. dropdown:: eval (pd_test_2_all.cpp:2722)
   :class-title: example-dropdown

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

      
              std::cout << "====================================== [OK] pd_test_droplevel test suite ========================== " << std::endl;
              return 0;
          }
      
      } // namespace dataframe_tests
      // ------------------- pd_test_droplevel.cpp (end) -----------------------------
      
      // ------------------- pd_test_eval.cpp (start) -----------------------------
      // dataframe_tests/pd_test_eval.cpp
      // Test for DataFrame.eval() method
      
      #include <iostream>
      #include <stdexcept>
      #include <cmath>
      #include <vector>
      #include <map>
      #include <string>
      #include <limits>
      #include <variant>
      #include "../pandas/pd_dataframe.h"

.. _example-dataframe-extract_column_as_numeric_series-447:

.. dropdown:: extract_column_as_numeric_series (pd_test_2_all.cpp:20328)
   :class-title: example-dropdown

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

      // =========================================================================
      
      void pd_test_getitem_dispatch_extract_numeric() {
          std::cout << "pd_test_getitem_dispatch_extract_numeric" << std::endl;
          pandas::DataFrame df;
          std::vector<numpy::float64> vals = {1.5, 2.5, 3.5};
          df.insert(0, "val", std::make_unique<pandas::Series<numpy::float64>>(vals, "val"), true);
          df.set_index(std::make_unique<pandas::Index<std::string>>(
              std::vector<std::string>{"a", "b", "c"}));
      
          auto s = df.extract_column_as_numeric_series("val");
          check(s.size() == 3, "numeric size");
          check(std::abs(s.values().getElementAt({0}) - 1.5) < 1e-10, "numeric val[0]");
          check(std::abs(s.values().getElementAt({2}) - 3.5) < 1e-10, "numeric val[2]");
          check(s.name() == "val", "numeric name");
      
          // int32 dtype override preserved
          pandas::DataFrame df2;
          std::vector<numpy::float64> ivals = {10.0, 20.0};
          auto is = std::make_unique<pandas::Series<numpy::float64>>(ivals, "ival");
          is->set_dtype_override("int32");

.. _example-dataframe-extract_row_typed-448:

.. dropdown:: extract_row_typed (pd_test_3_all.cpp:28887)
   :class-title: example-dropdown

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

          df.add_column("Name", std::vector<std::string>{"Alice", "Bob", "Carol"});
          df.add_column("Age", std::vector<numpy::float64>{30.0, 25.0, 40.0});
          df.add_column("Salary", std::vector<numpy::float64>{100.0, 200.0, 300.0});
          return df;
      }
      
      void pd_test_df_apply_assembly_extract_row_typed_numeric() {
          std::cout << "  -- pd_test_df_apply_assembly_extract_row_typed_numeric --" << std::endl;
          int fail = 0;
          auto df = make_numeric_df();
          auto rd = df.extract_row_typed(1);
          fail += dfa_check(rd.size() == 3, "row size == 3");
          fail += dfa_check(!rd.has_string_cols, "all numeric => !has_string_cols");
          fail += dfa_check(rd.col_names[0] == "A" && rd.col_names[2] == "C", "col_names");
          fail += dfa_check(!rd.is_string_col[0] && !rd.is_string_col[1] && !rd.is_string_col[2],
                            "is_string_col all false");
          fail += dfa_check(rd.numeric_vals[0] == 2.0, "numeric_vals[0]==2.0");
          fail += dfa_check(rd.numeric_vals[1] == 5.0, "numeric_vals[1]==5.0");
          fail += dfa_check(rd.numeric_vals[2] == 8.0, "numeric_vals[2]==8.0");
          if (fail == 0) std::cout << "    OK" << std::endl;
          if (fail != 0) throw std::runtime_error("pd_test_df_apply_assembly_extract_row_typed_numeric failed");

.. _example-dataframe-file-449:

.. dropdown:: file (pd_test_2_all.cpp:3463)
   :class-title: example-dropdown

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

                      {"C", {100, 200, 300, 400, 500}}
                  };
      
                  pandas::DataFrame df(data);
      
                  // Export to Excel
                  std::string filepath = "temp/pd_test_excel_basic.xlsx";
                  df.to_excel(filepath);
      
                  // Verify file was created
                  std::ifstream file(filepath, std::ios::binary);
                  if (!file.good()) {
                      std::cout << "  [FAIL] : in pd_test_excel_basic() : File was not created" << std::endl;
                      throw std::runtime_error("pd_test_excel_basic failed: file not created");
                  }
      
                  // Check file size is reasonable (valid XLSX should be > 1KB)
                  file.seekg(0, std::ios::end);
                  auto size = file.tellg();
                  if (size < 1000) {
                      std::cout << "  [FAIL] : in pd_test_excel_basic() : File size too small: " << size << std::endl;

.. _example-dataframe-filter-450:

.. dropdown:: filter (pd_test_3_all.cpp:2805)
   :class-title: example-dropdown

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

              threw = true;
          }
          if (!threw) {
              throw std::runtime_error("bool_() should throw for multi-element DataFrame");
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_df_filter() {
          std::cout << "========= DataFrame.filter() =============================";
      
          std::map<std::string, std::vector<double>> data = {
              {"col_a", {1.0, 2.0, 3.0}},
              {"col_b", {4.0, 5.0, 6.0}},
              {"other", {7.0, 8.0, 9.0}}
          };
          pandas::DataFrame df(data);
      
          // Test filter by items
          pandas::DataFrame filtered_items = df.filter({"col_a", "col_b"});

.. _example-dataframe-flags-451:

.. dropdown:: flags (pd_test_1_all.cpp:16397)
   :class-title: example-dropdown

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

              // =====================================================================
              // Series Flags Integration Tests
              // =====================================================================
      
              void pd_test_ndframe_series_flags() {
                  std::cout << "========= series flags integration =============================" << std::endl;
      
                  pandas::Series<int> s({1, 2, 3});
      
                  // Test default flags
                  bool passed = s.flags().allows_duplicate_labels == true;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_ndframe_series_flags() : default allows_duplicate_labels" << std::endl;
                      throw std::runtime_error("pd_test_ndframe_series_flags failed: default allows_duplicate_labels");
                  }
      
                  passed = s.flags().copy_on_write == false;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_ndframe_series_flags() : default copy_on_write" << std::endl;
                      throw std::runtime_error("pd_test_ndframe_series_flags failed: default copy_on_write");
                  }

.. _example-dataframe-floor-452:

.. 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-dataframe-format_percentile_labels-453:

.. dropdown:: format_percentile_labels (pd_test_2_all.cpp:19921)
   :class-title: example-dropdown

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

      }
      
      // =====================================================================
      // Test: percentile label formatting
      // =====================================================================
      
      void pd_test_describe_percentile_labels() {
          std::cout << "  -- pd_test_describe_percentile_labels --" << std::endl;
      
          // Standard percentiles
          auto labels = pandas::DataFrame::format_percentile_labels({0.25, 0.5, 0.75});
          check(labels.size() == 3, "pct_labels_count_3");
          check(labels[0] == "25%", "pct_label_25");
          check(labels[1] == "50%", "pct_label_50");
          check(labels[2] == "75%", "pct_label_75");
      
          // Non-integer percentile
          auto labels2 = pandas::DataFrame::format_percentile_labels({0.333});
          check(labels2[0] == "33.3%", "pct_label_33_3");
      }
      

.. _example-dataframe-frame_dtype_override-454:

.. dropdown:: frame_dtype_override (pd_test_5_all.cpp:146164)
   :class-title: example-dropdown

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

          };
      }
      
      void case_100_apply_int_all_int_axis0(int& lf) {
          std::cout << "-- case_100_apply_int_all_int_axis0\n";
          auto df = mk_df_one_int64("a", {1.0, 2.0, 3.0});
          auto h = mk_hist_all_int();
          auto out = df.apply_resolved_typed(cb_int_sum(), h, 0);
          pandas_tests::check(out.column_dtype_override("a") == "int64",
              "C_26k_case_100_apply_int_all_int_axis0()_a", lf);
          pandas_tests::check(out.frame_dtype_override() == "int64",
              "C_26k_case_100_apply_int_all_int_axis0()_frame", lf);
      }
      
      void case_101_apply_float_all_int_axis0(int& lf) {
          std::cout << "-- case_101_apply_float_all_int_axis0\n";
          auto df = mk_df_one_float64("a", {1.5, 2.5, 3.5});
          auto h = mk_hist_all_int();
          auto out = df.apply_resolved_typed(cb_int_sum(), h, 0);
          // plan_02: all-int returns infer int64 even on a float64 source
          // (pandas 2.2.2: df(float64).apply(int(sum),axis=0).dtype == int64).

.. _example-dataframe-has_column-455:

.. dropdown:: has_column (pd_test_1_all.cpp:6256)
   :class-title: example-dropdown

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

                  pandas::DataFrame df(data);
      
                  // Test single column access
                  const pandas::NDFrameBase& col_a = df["A"];
                  if (col_a.size() != 3) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_column_access() : column A size != 3" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_column_access failed: column A size != 3");
                  }
      
                  // Test has_column
                  if (!df.has_column("A")) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_column_access() : has_column A should be true" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_column_access failed: has_column A should be true");
                  }
                  if (df.has_column("Z")) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_column_access() : has_column Z should be false" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_column_access failed: has_column Z should be false");
                  }
      
                  // Test multiple column access
                  pandas::DataFrame subset = df[std::vector<std::string>{"A", "C"}];

.. _example-dataframe-has_columns_levels-456:

.. dropdown:: has_columns_levels (pd_test_2_all.cpp:21382)
   :class-title: example-dropdown

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

          auto cols = result.columns().to_list();
          bool has_sum = false, has_mean = false;
          for (const auto& c : cols) {
              if (c.find("sum") != std::string::npos) has_sum = true;
              if (c.find("mean") != std::string::npos) has_mean = true;
          }
          check(has_sum, "has_sum_cols");
          check(has_mean, "has_mean_cols");
      
          // Check that it has multi-level columns
          check(result.has_columns_levels(), "has_columns_levels");
      
          // Verify values: check that expected sum values exist somewhere in the result
          // Column names pattern: (sum, A), (sum, B), (mean, A), (mean, B)
          // or (sum, (sales, A)), etc. depending on single/multi value columns
          auto all_cols = result.columns().to_list();
          bool found_sum_col = false;
          for (const auto& c : all_cols) {
              if (c.find("sum") != std::string::npos) {
                  const auto& col_ref = result[c];
                  for (size_t r = 0; r < result.nrows(); ++r) {

.. _example-dataframe-has_multiindex-457:

.. dropdown:: has_multiindex (pd_test_1_all.cpp:27019)
   :class-title: example-dropdown

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

      
                  std::map<std::string, std::vector<std::string>> data = {
                      {"A", {"a", "a", "b", "b"}},
                      {"B", {"x", "x", "y", "y"}}
                  };
                  pandas::DataFrame df(data);
      
                  auto result = df.value_counts();
                  auto& counts = std::get<pandas::Series<numpy::int64>>(result);
      
                  if (!counts.has_multiindex()) {
                      std::cout << "  [FAIL] : expected MultiIndex" << std::endl;
                      throw std::runtime_error("pd_test_value_counts_multiindex_levels failed: no multiindex");
                  }
      
                  const auto& midx = counts.multiindex();
      
                  // Should have 2 levels
                  if (midx.nlevels() != 2) {
                      std::cout << "  [FAIL] : expected 2 levels, got " << midx.nlevels() << std::endl;
                      throw std::runtime_error("pd_test_value_counts_multiindex_levels failed: wrong nlevels");

.. _example-dataframe-hasnans-458:

.. dropdown:: hasnans (pd_test_1_all.cpp:5363)
   :class-title: example-dropdown

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

      void pd_test_categorical_index_from_codes() {
          std::cout << "========= from_codes =================================";
      
          std::vector<numpy::int32> codes = {0, 1, 0, 2, -1};  // -1 = NA
          std::vector<std::string> categories = {"low", "medium", "high"};
      
          pandas::CategoricalIndex idx = pandas::CategoricalIndex::from_codes(codes, categories, true, "level");
      
          bool passed = (idx.size() == 5 && idx.num_categories() == 3 &&
                         idx.ordered() && idx.name().has_value() && *idx.name() == "level" &&
                         idx.hasnans());  // has NA from code -1
          if (!passed) {
              std::cout << "  [FAIL] : in pd_test_categorical_index_from_codes()" << std::endl;
              throw std::runtime_error("pd_test_categorical_index_from_codes failed");
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_categorical_index_simple_new() {
          std::cout << "========= _simple_new =================================";

.. _example-dataframe-index-459:

.. dropdown:: index (pd_test_1_all.cpp:6680)
   :class-title: example-dropdown

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

              void pd_test_dataframe_index_ops() {
                  std::cout << "========= index operations =================";
      
                  // Test set_axis (rows)
                  {
                      std::map<std::string, std::vector<int>> data;
                      data["A"] = {1, 2, 3};
                      pandas::DataFrame df(data);
      
                      auto renamed = df.set_axis({"x", "y", "z"}, 0);
                      std::string idx0 = renamed.index().get_value_str(0);
                      if (idx0 != "x") {
                          std::cout << "  [FAIL] : in pd_test_dataframe_index_ops() : set_axis first label should be 'x'" << std::endl;
                          throw std::runtime_error("pd_test_dataframe_index_ops failed: set_axis");
                      }
                  }
      
                  // Test set_axis (columns)
                  {
                      std::map<std::string, std::vector<int>> data;
                      data["A"] = {1, 2};

.. _example-dataframe-index_name-460:

.. dropdown:: index_name (pd_test_3_all.cpp:1290)
   :class-title: example-dropdown

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

              }
      
              pandas::DataFrame df3;
              df3.add_column<int64_t>("val", {1, 2, 3, 4, 5});
              df3.set_index_from_strings({"a", "b", "c", "a", "b"});
              if (df3.index().get_value_str(4) != "b") {
                  throw std::runtime_error("set_index_from_strings: values wrong");
              }
          }
      
          // E. set_index_name + index_name() getter/setter
          {
              pandas::DataFrame df;
              df.add_column<int64_t>("val", {1, 2, 3});
              df.set_index_from_list({"r0", "r1", "r2"});
      
              df.set_index_name("City");
              if (!df.index_name().has_value() || df.index_name().value() != "City") {
                  throw std::runtime_error("set_index_name: round-trip failed");
              }
      

.. _example-dataframe-index_name-461:

.. dropdown:: index_name (pd_test_3_all.cpp:1290)
   :class-title: example-dropdown

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

              }
      
              pandas::DataFrame df3;
              df3.add_column<int64_t>("val", {1, 2, 3, 4, 5});
              df3.set_index_from_strings({"a", "b", "c", "a", "b"});
              if (df3.index().get_value_str(4) != "b") {
                  throw std::runtime_error("set_index_from_strings: values wrong");
              }
          }
      
          // E. set_index_name + index_name() getter/setter
          {
              pandas::DataFrame df;
              df.add_column<int64_t>("val", {1, 2, 3});
              df.set_index_from_list({"r0", "r1", "r2"});
      
              df.set_index_name("City");
              if (!df.index_name().has_value() || df.index_name().value() != "City") {
                  throw std::runtime_error("set_index_name: round-trip failed");
              }
      

.. _example-dataframe-isetitem-462:

.. dropdown:: isetitem (pd_test_3_all.cpp:2882)
   :class-title: example-dropdown

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

      
          // Verify first element
          if (std::abs(arr.getElementAt({0, 0}) - 1.0) > 0.001) {
              throw std::runtime_error("to_numpy value failed");
          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_df_isetitem() {
          std::cout << "========= DataFrame.isetitem() ===========================";
      
          std::map<std::string, std::vector<double>> data = {
              {"A", {1.0, 2.0, 3.0}},
              {"B", {4.0, 5.0, 6.0}}
          };
          pandas::DataFrame df(data);
      
          // Set first column to new values
          df.isetitem(static_cast<size_t>(0), std::vector<double>{10.0, 20.0, 30.0});
      

.. _example-dataframe-iss-463:

.. dropdown:: iss (pd_test_2_all.cpp:10348)
   :class-title: example-dropdown

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

                  try {
                      df.to_clipboard(true, '\t', false);  // index=false
                  } catch (const std::exception& e) {
                      std::cout << "  [FAIL] : in pd_test_to_clipboard_no_index() : exception: " << e.what() << std::endl;
                      throw std::runtime_error("pd_test_to_clipboard_no_index failed");
                  }
      
      #ifdef _WIN32
                  std::string clipboard = get_clipboard_text_with_retry();
                  // Without index, first line should be just "A"
                  std::istringstream iss(clipboard);
                  std::string first_line;
                  std::getline(iss, first_line);
                  passed = first_line == "A";
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_to_clipboard_no_index() : first line was '" << first_line << "', expected 'A'" << std::endl;
                      throw std::runtime_error("pd_test_to_clipboard_no_index failed");
                  }
      #endif
      
                  std::cout << " -> tests passed" << std::endl;

.. _example-dataframe-iss-464:

.. dropdown:: iss (pd_test_2_all.cpp:10348)
   :class-title: example-dropdown

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

                  try {
                      df.to_clipboard(true, '\t', false);  // index=false
                  } catch (const std::exception& e) {
                      std::cout << "  [FAIL] : in pd_test_to_clipboard_no_index() : exception: " << e.what() << std::endl;
                      throw std::runtime_error("pd_test_to_clipboard_no_index failed");
                  }
      
      #ifdef _WIN32
                  std::string clipboard = get_clipboard_text_with_retry();
                  // Without index, first line should be just "A"
                  std::istringstream iss(clipboard);
                  std::string first_line;
                  std::getline(iss, first_line);
                  passed = first_line == "A";
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_to_clipboard_no_index() : first line was '" << first_line << "', expected 'A'" << std::endl;
                      throw std::runtime_error("pd_test_to_clipboard_no_index failed");
                  }
      #endif
      
                  std::cout << " -> tests passed" << std::endl;

.. _example-dataframe-iss-465:

.. dropdown:: iss (pd_test_2_all.cpp:10348)
   :class-title: example-dropdown

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

                  try {
                      df.to_clipboard(true, '\t', false);  // index=false
                  } catch (const std::exception& e) {
                      std::cout << "  [FAIL] : in pd_test_to_clipboard_no_index() : exception: " << e.what() << std::endl;
                      throw std::runtime_error("pd_test_to_clipboard_no_index failed");
                  }
      
      #ifdef _WIN32
                  std::string clipboard = get_clipboard_text_with_retry();
                  // Without index, first line should be just "A"
                  std::istringstream iss(clipboard);
                  std::string first_line;
                  std::getline(iss, first_line);
                  passed = first_line == "A";
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_to_clipboard_no_index() : first line was '" << first_line << "', expected 'A'" << std::endl;
                      throw std::runtime_error("pd_test_to_clipboard_no_index failed");
                  }
      #endif
      
                  std::cout << " -> tests passed" << std::endl;

.. _example-dataframe-iss-466:

.. dropdown:: iss (pd_test_2_all.cpp:10348)
   :class-title: example-dropdown

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

                  try {
                      df.to_clipboard(true, '\t', false);  // index=false
                  } catch (const std::exception& e) {
                      std::cout << "  [FAIL] : in pd_test_to_clipboard_no_index() : exception: " << e.what() << std::endl;
                      throw std::runtime_error("pd_test_to_clipboard_no_index failed");
                  }
      
      #ifdef _WIN32
                  std::string clipboard = get_clipboard_text_with_retry();
                  // Without index, first line should be just "A"
                  std::istringstream iss(clipboard);
                  std::string first_line;
                  std::getline(iss, first_line);
                  passed = first_line == "A";
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_to_clipboard_no_index() : first line was '" << first_line << "', expected 'A'" << std::endl;
                      throw std::runtime_error("pd_test_to_clipboard_no_index failed");
                  }
      #endif
      
                  std::cout << " -> tests passed" << std::endl;

.. _example-dataframe-iss-467:

.. dropdown:: iss (pd_test_2_all.cpp:10348)
   :class-title: example-dropdown

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

                  try {
                      df.to_clipboard(true, '\t', false);  // index=false
                  } catch (const std::exception& e) {
                      std::cout << "  [FAIL] : in pd_test_to_clipboard_no_index() : exception: " << e.what() << std::endl;
                      throw std::runtime_error("pd_test_to_clipboard_no_index failed");
                  }
      
      #ifdef _WIN32
                  std::string clipboard = get_clipboard_text_with_retry();
                  // Without index, first line should be just "A"
                  std::istringstream iss(clipboard);
                  std::string first_line;
                  std::getline(iss, first_line);
                  passed = first_line == "A";
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_to_clipboard_no_index() : first line was '" << first_line << "', expected 'A'" << std::endl;
                      throw std::runtime_error("pd_test_to_clipboard_no_index failed");
                  }
      #endif
      
                  std::cout << " -> tests passed" << std::endl;

.. _example-dataframe-iss-468:

.. dropdown:: iss (pd_test_2_all.cpp:10348)
   :class-title: example-dropdown

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

                  try {
                      df.to_clipboard(true, '\t', false);  // index=false
                  } catch (const std::exception& e) {
                      std::cout << "  [FAIL] : in pd_test_to_clipboard_no_index() : exception: " << e.what() << std::endl;
                      throw std::runtime_error("pd_test_to_clipboard_no_index failed");
                  }
      
      #ifdef _WIN32
                  std::string clipboard = get_clipboard_text_with_retry();
                  // Without index, first line should be just "A"
                  std::istringstream iss(clipboard);
                  std::string first_line;
                  std::getline(iss, first_line);
                  passed = first_line == "A";
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_to_clipboard_no_index() : first line was '" << first_line << "', expected 'A'" << std::endl;
                      throw std::runtime_error("pd_test_to_clipboard_no_index failed");
                  }
      #endif
      
                  std::cout << " -> tests passed" << std::endl;

.. _example-dataframe-iss-469:

.. dropdown:: iss (pd_test_2_all.cpp:10348)
   :class-title: example-dropdown

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

                  try {
                      df.to_clipboard(true, '\t', false);  // index=false
                  } catch (const std::exception& e) {
                      std::cout << "  [FAIL] : in pd_test_to_clipboard_no_index() : exception: " << e.what() << std::endl;
                      throw std::runtime_error("pd_test_to_clipboard_no_index failed");
                  }
      
      #ifdef _WIN32
                  std::string clipboard = get_clipboard_text_with_retry();
                  // Without index, first line should be just "A"
                  std::istringstream iss(clipboard);
                  std::string first_line;
                  std::getline(iss, first_line);
                  passed = first_line == "A";
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_to_clipboard_no_index() : first line was '" << first_line << "', expected 'A'" << std::endl;
                      throw std::runtime_error("pd_test_to_clipboard_no_index failed");
                  }
      #endif
      
                  std::cout << " -> tests passed" << std::endl;

.. _example-dataframe-match_multiindex_columns-470:

.. dropdown:: match_multiindex_columns (pd_test_3_all.cpp:29247)
   :class-title: example-dropdown

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

          pandas::DataFrame df;
          df.add_column<numpy::float64>("c0", {1.0, 2.0});
          df.add_column<numpy::float64>("c1", {3.0, 4.0});
          df.add_column<numpy::float64>("c2", {5.0, 6.0});
          std::vector<std::vector<std::string>> levels = {
              {"bar", "bar", "foo"},
              {"one", "two", "one"}
          };
          df.set_columns_levels(levels, {"L0", "L1"});
      
          auto exact = df.match_multiindex_columns({"bar", "one"});
          fail += sm_check(exact.exact_match, "exact match flag set");
          fail += sm_check(exact.matching_cols.size() == 1 && exact.matching_cols[0] == 0, "exact match col index");
      
          auto partial = df.match_multiindex_columns({"bar"});
          fail += sm_check(!partial.exact_match, "partial match not exact");
          fail += sm_check(partial.matching_cols.size() == 2, "partial match 2 cols");
          fail += sm_check(partial.matching_cols[0] == 0 && partial.matching_cols[1] == 1, "partial col indices");
      
          auto none = df.match_multiindex_columns({"baz"});
          fail += sm_check(none.matching_cols.empty(), "no match -> empty");

.. _example-dataframe-nbytes-471:

.. 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-dataframe-ncols-472:

.. dropdown:: ncols (pd_test_1_all.cpp:4658)
   :class-title: example-dropdown

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

                  std::cout << "========= DataFrame corr ========================";
      
                  std::map<std::string, std::vector<double>> data;
                  data["A"] = {1.0, 2.0, 3.0, 4.0, 5.0};
                  data["B"] = {2.0, 4.0, 6.0, 8.0, 10.0};  // Perfect correlation
                  pandas::DataFrame df(data);
      
                  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;

.. _example-dataframe-ndim-473:

.. dropdown:: ndim (pd_test_1_all.cpp:6195)
   :class-title: example-dropdown

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

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

.. _example-dataframe-nrows-474:

.. dropdown:: nrows (pd_test_1_all.cpp:4658)
   :class-title: example-dropdown

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

                  std::cout << "========= DataFrame corr ========================";
      
                  std::map<std::string, std::vector<double>> data;
                  data["A"] = {1.0, 2.0, 3.0, 4.0, 5.0};
                  data["B"] = {2.0, 4.0, 6.0, 8.0, 10.0};  // Perfect correlation
                  pandas::DataFrame df(data);
      
                  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;

.. _example-dataframe-resolve_column_level-475:

.. dropdown:: resolve_column_level (pd_test_3_all.cpp:28773)
   :class-title: example-dropdown

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

          fail += spt_check(r.has_multiindex(), "result has multiindex");
          fail += spt_check(r.multiindex().nlevels() == 2, "multiindex nlevels==2 (row + stacked)");
          if (fail == 0) std::cout << "    OK" << std::endl;
          if (fail != 0) throw std::runtime_error("pd_test_stack_multiindex_result failed");
      }
      
      void pd_test_resolve_column_level_int() {
          std::cout << "  -- pd_test_resolve_column_level_int --" << std::endl;
          int fail = 0;
          auto df = make_ml_df();
          fail += spt_check(df.resolve_column_level(0) == 0, "0 -> 0");
          fail += spt_check(df.resolve_column_level(1) == 1, "1 -> 1");
          fail += spt_check(df.resolve_column_level(-1) == 1, "-1 -> 1");
          fail += spt_check(df.resolve_column_level(-2) == 0, "-2 -> 0");
          fail += spt_check(df.resolve_column_level(5) == -1, "5 -> -1 (out of range)");
          if (fail == 0) std::cout << "    OK" << std::endl;
          if (fail != 0) throw std::runtime_error("pd_test_resolve_column_level_int failed");
      }
      
      void pd_test_resolve_column_level_string() {
          std::cout << "  -- pd_test_resolve_column_level_string --" << std::endl;

.. _example-dataframe-resolve_column_level-476:

.. dropdown:: resolve_column_level (pd_test_3_all.cpp:28773)
   :class-title: example-dropdown

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

          fail += spt_check(r.has_multiindex(), "result has multiindex");
          fail += spt_check(r.multiindex().nlevels() == 2, "multiindex nlevels==2 (row + stacked)");
          if (fail == 0) std::cout << "    OK" << std::endl;
          if (fail != 0) throw std::runtime_error("pd_test_stack_multiindex_result failed");
      }
      
      void pd_test_resolve_column_level_int() {
          std::cout << "  -- pd_test_resolve_column_level_int --" << std::endl;
          int fail = 0;
          auto df = make_ml_df();
          fail += spt_check(df.resolve_column_level(0) == 0, "0 -> 0");
          fail += spt_check(df.resolve_column_level(1) == 1, "1 -> 1");
          fail += spt_check(df.resolve_column_level(-1) == 1, "-1 -> 1");
          fail += spt_check(df.resolve_column_level(-2) == 0, "-2 -> 0");
          fail += spt_check(df.resolve_column_level(5) == -1, "5 -> -1 (out of range)");
          if (fail == 0) std::cout << "    OK" << std::endl;
          if (fail != 0) throw std::runtime_error("pd_test_resolve_column_level_int failed");
      }
      
      void pd_test_resolve_column_level_string() {
          std::cout << "  -- pd_test_resolve_column_level_string --" << std::endl;

.. _example-dataframe-resolve_sort_columns_multiindex-477:

.. dropdown:: resolve_sort_columns_multiindex (pd_test_2_all.cpp:22232)
   :class-title: example-dropdown

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

          }
          std::cout << "====================================== [OK] pd_test_series_dtype_inference test suite ========================== " << std::endl;
          return 0;
      }
      
      } // namespace dataframe_tests
      // ------------------- pd_test_series_dtype_inference.cpp (end) -----------------------------
      
      // ------------------- pd_test_sort_key.cpp (start) -----------------------------
      // pd_test_sort_key.cpp - Tests for sort_values key function support
      // Tests sort_values_by_transformed() and resolve_sort_columns_multiindex()
      
      #include <iostream>
      #include <string>
      #include <vector>
      #include <cmath>
      #include <numeric>
      
      #include "../pandas/pd_dataframe.h"
      
      namespace dataframe_tests {

.. _example-dataframe-round-478:

.. 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-dataframe-row_values_f64-479:

.. dropdown:: row_values_f64 (pd_test_2_all.cpp:19385)
   :class-title: example-dropdown

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

                    << dataframe_tests_agg_dtype::g_fail << " failed)" << std::endl;
      
          return dataframe_tests_agg_dtype::g_fail;
      }
      
      } // namespace dataframe_tests
      // ------------------- pd_test_agg_dtype.cpp (end) -----------------------------
      
      // ------------------- pd_test_apply_extract.cpp (start) -----------------------------
      // pd_test_apply_extract.cpp - Tests for DataFrame column/row extraction helpers
      // column_to_series_f64(), column_to_series_str(), row_values_f64()
      
      #include <iostream>
      #include <string>
      #include <vector>
      #include <cmath>
      
      #include "../pandas/pd_dataframe.h"
      #include "../pandas/pd_series.h"
      #include "../pandas/pd_index.h"
      

.. _example-dataframe-s-480:

.. dropdown:: s (pd_test_1_all.cpp:4524)
   :class-title: example-dropdown

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

      #include <vector>
      #include "../pandas/pd_dataframe.h"
      #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;
              }

.. _example-dataframe-s-481:

.. dropdown:: s (pd_test_1_all.cpp:4524)
   :class-title: example-dropdown

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

      #include <vector>
      #include "../pandas/pd_dataframe.h"
      #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;
              }

.. _example-dataframe-s-482:

.. dropdown:: s (pd_test_1_all.cpp:4524)
   :class-title: example-dropdown

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

      #include <vector>
      #include "../pandas/pd_dataframe.h"
      #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;
              }

.. _example-dataframe-s-483:

.. dropdown:: s (pd_test_1_all.cpp:4524)
   :class-title: example-dropdown

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

      #include <vector>
      #include "../pandas/pd_dataframe.h"
      #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;
              }

.. _example-dataframe-select_dtypes-484:

.. dropdown:: select_dtypes (pd_test_1_all.cpp:7044)
   :class-title: example-dropdown

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

                  std::cout << "========= select_dtypes =============================";
      
                  // Create DataFrame with mixed types using add_column
                  pandas::DataFrame df;
                  df.add_column<numpy::int64>("int_col", {1, 2, 3});
                  df.add_column<numpy::float64>("float_col", {1.1, 2.2, 3.3});
                  df.add_column<std::string>("str_col", {"a", "b", "c"});
                  df.add_column<numpy::bool_>("bool_col", {true, false, true});
      
                  // Test include int
                  pandas::DataFrame int_result = df.select_dtypes({"int"});
                  if (int_result.ncols() != 1 || !int_result.has_column("int_col")) {
                      std::cout << "  [FAIL] : select_dtypes include int" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_select_dtypes failed: include int");
                  }
      
                  // Test include number (numeric types)
                  pandas::DataFrame num_result = df.select_dtypes({"number"});
                  if (num_result.ncols() != 2 || !num_result.has_column("int_col") || !num_result.has_column("float_col")) {
                      std::cout << "  [FAIL] : select_dtypes include number" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_select_dtypes failed: include number");

.. _example-dataframe-select_multiindex_columns-485:

.. dropdown:: select_multiindex_columns (pd_test_3_all.cpp:29220)
   :class-title: example-dropdown

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

          pandas::DataFrame df;
          df.add_column<numpy::float64>("c0", {1.0, 2.0});
          df.add_column<numpy::float64>("c1", {3.0, 4.0});
          df.add_column<numpy::float64>("c2", {5.0, 6.0});
          df.add_column<numpy::float64>("c3", {7.0, 8.0});
          std::vector<std::vector<std::string>> levels = {
              {"bar", "bar", "foo", "baz"},
              {"one", "two", "one", "two"}
          };
          df.set_columns_levels(levels, {"L0", "L1"});
          auto sub = df.select_multiindex_columns({"bar", "foo"});
          fail += sm_check(sub.ncols() == 3, "3 cols selected (bar,bar,foo)");
          fail += sm_check(sub.has_columns_levels(), "MI preserved");
          if (sub.has_columns_levels()) {
              const auto& lv = sub.columns_levels();
              fail += sm_check(lv.size() == 2, "2 levels preserved");
              fail += sm_check(lv[0].size() == 3 && lv[0][0] == "bar" && lv[0][2] == "foo", "level 0 values");
          }
          auto empty = df.select_multiindex_columns({"nonexistent"});
          fail += sm_check(empty.ncols() == 0, "no match -> empty");
          if (fail == 0) std::cout << "    OK" << std::endl;

.. _example-dataframe-set_column-486:

.. dropdown:: set_column (pd_test_3_all.cpp:11118)
   :class-title: example-dropdown

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

      // ============================================================================
      
      void pd_test_3_all_set_column_aligned() {
          std::cout << "========= Fix 1: set_column aligned by index =============";
          pandas::DataFrame df;
          df.add_column<int64_t>("values", {1, 2, 3});
          df.set_index(std::make_unique<pandas::Index<std::string>>(
              std::vector<std::string>{"x", "y", "z"}));
      
          pandas::Series<int> s1({10, 20, 30}, {"z", "x", "y"});
          df.set_column("aligned", s1);
      
          // After alignment: x->20, y->30, z->10
          if (df.ncols() != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_set_column_aligned() : expected 2 cols" << std::endl;
              throw std::runtime_error("set_column aligned failed");
          }
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_set_column_partial() {

.. _example-dataframe-set_column_cat_categories-487:

.. dropdown:: set_column_cat_categories (pd_test_5_all.cpp:29010)
   :class-title: example-dropdown

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

      }
      
      static const std::vector<std::string>& DAYS() {
          static const std::vector<std::string> d = {
              "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"};
          return d;
      }
      
      static pandas::DataFrame make_579_fixture_cat(bool ordered = true) {
          pandas::DataFrame df = make_579_fixture();
          df.set_column_cat_categories("day", DAYS());
          df.set_column_cat_ordered("day", ordered);
          return df;
      }
      
      static std::vector<std::string> result_index_strs(const pandas::DataFrame& r) {
          std::vector<std::string> out;
          const auto& idx = r.index();
          size_t n = idx.size();
          out.reserve(n);
          for (size_t i = 0; i < n; ++i) out.push_back(idx.get_value_str(i));

.. _example-dataframe-set_column_cat_ordered-488:

.. dropdown:: set_column_cat_ordered (pd_test_5_all.cpp:29011)
   :class-title: example-dropdown

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

      
      static const std::vector<std::string>& DAYS() {
          static const std::vector<std::string> d = {
              "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"};
          return d;
      }
      
      static pandas::DataFrame make_579_fixture_cat(bool ordered = true) {
          pandas::DataFrame df = make_579_fixture();
          df.set_column_cat_categories("day", DAYS());
          df.set_column_cat_ordered("day", ordered);
          return df;
      }
      
      static std::vector<std::string> result_index_strs(const pandas::DataFrame& r) {
          std::vector<std::string> out;
          const auto& idx = r.index();
          size_t n = idx.size();
          out.reserve(n);
          for (size_t i = 0; i < n; ++i) out.push_back(idx.get_value_str(i));
          return out;

.. _example-dataframe-set_column_datetime_ea-489:

.. dropdown:: set_column_datetime_ea (pd_test_extension_array.cpp:313)
   :class-title: example-dropdown

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

              numpy::datetime64(1609459200000000000LL, numpy::DateTimeUnit::Nanosecond),
          };
          std::map<std::string, std::vector<numpy::datetime64>> data;
          data["d"] = dt_vec;
          pandas::DataFrame df(data);
          // Use the new C.1 helper to attach the EA.
          std::vector<std::optional<pandas::Timestamp>> ts = {
              pandas::Timestamp(1577836800000000000LL),
              pandas::Timestamp(1609459200000000000LL),
          };
          df.set_column_datetime_ea("d", ts, /*uniform_tz=*/"");
          auto& col = df["d"];
          auto* col_dt = dynamic_cast<pandas::Series<numpy::datetime64>*>(&col);
          check(col_dt != nullptr, "set_column_datetime_ea: col is Series<datetime64>");
          if (col_dt) {
              const auto& da_opt = col_dt->datetime_array();
              check(da_opt.has_value() && *da_opt,
                    "set_column_datetime_ea: column EA populated");
              if (da_opt.has_value() && *da_opt) {
                  check((*da_opt)->size() == 2,
                        "set_column_datetime_ea: EA size matches");

.. _example-dataframe-set_column_dtype-490:

.. dropdown:: set_column_dtype (pd_test_4_all.cpp:2203)
   :class-title: example-dropdown

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

      // ============================================================================
      void na_iloc_slice_with_na() {
          pandas::DataFrame df;
      
          constexpr double NaN = std::numeric_limits<double>::quiet_NaN();
      
          // int_na : Int64 nullable — row 1 NA, row 2 = 3.
          //          Stored as double so NaN can act as the NA sentinel; the
          //          dtype override drives the "<NA>" / integer rendering.
          df.add_column<double>("int_na", {NaN, 3.0});
          df.set_column_dtype("int_na", "Int64");
      
          // float_na : plain float64 with NaN — no override needed.
          df.add_column<double>("float_na", {NaN, 3.0});
      
          // bool_na : nullable boolean — row 1 NA, row 2 = False.
          //           Stored as double with NaN sentinel; dtype override drives
          //           the "<NA>" / "True" / "False" rendering.
          df.add_column<double>("bool_na", {NaN, 0.0});
          df.set_column_dtype("bool_na", "boolean");
      

.. _example-dataframe-set_column_dtype-491:

.. dropdown:: set_column_dtype (pd_test_4_all.cpp:2203)
   :class-title: example-dropdown

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

      // ============================================================================
      void na_iloc_slice_with_na() {
          pandas::DataFrame df;
      
          constexpr double NaN = std::numeric_limits<double>::quiet_NaN();
      
          // int_na : Int64 nullable — row 1 NA, row 2 = 3.
          //          Stored as double so NaN can act as the NA sentinel; the
          //          dtype override drives the "<NA>" / integer rendering.
          df.add_column<double>("int_na", {NaN, 3.0});
          df.set_column_dtype("int_na", "Int64");
      
          // float_na : plain float64 with NaN — no override needed.
          df.add_column<double>("float_na", {NaN, 3.0});
      
          // bool_na : nullable boolean — row 1 NA, row 2 = False.
          //           Stored as double with NaN sentinel; dtype override drives
          //           the "<NA>" / "True" / "False" rendering.
          df.add_column<double>("bool_na", {NaN, 0.0});
          df.set_column_dtype("bool_na", "boolean");
      

.. _example-dataframe-set_column_names-492:

.. dropdown:: set_column_names (pd_test_3_all.cpp:1708)
   :class-title: example-dropdown

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

          pandas::DataFrame f_df;
          f_df.add_column<std::int64_t>("a", {1, 2});
          f_df.add_column<std::int64_t>("b", {3, 4});
          std::map<std::string, std::string> f_mapper{{"a", "A"}, {"b", "B"}};
          auto f = f_df.rename_columns(f_mapper);
          if (f.columns().get_value_str(0) != "A") {
              std::cout << "  [FAIL] : in pd_test_3_all_chainable_mutators() : Case F col[0]" << std::endl;
              throw std::runtime_error("pd_test_3_all_chainable_mutators failed: Case F col[0]");
          }
      
          // --- Case G: set_column_names(vector) returns reference (chainable) ---
          pandas::DataFrame g_df;
          g_df.add_column<std::int64_t>("c1", {1});
          g_df.add_column<std::int64_t>("c2", {2});
          auto& g_ref = g_df.set_column_names(std::vector<std::string>{"x", "y"});
          if (&g_ref != &g_df) {
              std::cout << "  [FAIL] : in pd_test_3_all_chainable_mutators() : Case G not self-ref" << std::endl;
              throw std::runtime_error("pd_test_3_all_chainable_mutators failed: Case G not self-ref");
          }
          if (g_df.columns().get_value_str(0) != "x") {
              std::cout << "  [FAIL] : in pd_test_3_all_chainable_mutators() : Case G col[0]" << std::endl;

.. _example-dataframe-set_column_resolved-493:

.. dropdown:: set_column_resolved (pd_test_5_all.cpp:94241)
   :class-title: example-dropdown

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

          pandas::DtypeOverride ov = pandas::DtypeOverride::parse("Float64");
          auto df = pandas::from_records_resolved<pandas::DataFrame>(rows, cols, ov);
          pandas_tests::check(df.column_dtype_override("n") == "Float64",
              "C_26h_case_144_records_override_applies()_dtype", local_fail);
      }
      
      void case_150_create_new_column(int& local_fail) {
          std::cout << "-- case_150_create_new_column\n";
          pandas::DataFrame df;
          KVec col = { kv_int(1), kv_int(2) };
          df.set_column_resolved("n", col);
          pandas_tests::check(df.has_column("n"),
              "C_26h_case_150_create_new_column()_has", local_fail);
          pandas_tests::check(df.column_dtype_override("n") == "int64",
              "C_26h_case_150_create_new_column()_dtype", local_fail);
      }
      
      void case_151_replace_existing_int_to_float(int& local_fail) {
          std::cout << "-- case_151_replace_existing_int_to_float\n";
          pandas::DataFrame df;
          df.add_column<std::int64_t>("v", { 1, 2, 3 });

.. _example-dataframe-set_column_sparse_fill_value-494:

.. dropdown:: set_column_sparse_fill_value (pd_test_5_all.cpp:23673)
   :class-title: example-dropdown

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

                    df.to_string(), local_fail);
      }
      
      void f_set_index_col_multiindex_display_6_843271_case_12_site1_sparse_all_nan_numeric(int& local_fail) {
          std::cout << "----- case_12_site1_sparse_all_nan_numeric -----\n";
          const double NaN = std::numeric_limits<double>::quiet_NaN();
          pandas::DataFrame df;
          df.add_column<double>("SNaN", {NaN, NaN, NaN});
          // Mark the column as sparse with NaN fill value so is_sparse=true and
          // the sparse-all-NaN bump path fires.
          df.set_column_sparse_fill_value("SNaN", NaN, "float64");
          apply_default_display(df);
          check_str("case_12.site1_sparse_all_nan_numeric",
                    EXPECTED_case_12_site1_sparse_all_nan_numeric,
                    df.to_string(), local_fail);
      }
      
      } // namespace f_test_set_index_col_multiindex_display_6_ns
      
      void f_test_set_index_col_multiindex_display_6() {
          std::cout << "========= f_test_set_index_col_multiindex_display_6 =======";

.. _example-dataframe-set_columns_index_dtype-495:

.. dropdown:: set_columns_index_dtype (pd_test_4_all.cpp:4985)
   :class-title: example-dropdown

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

      //   df.rename(columns={0: 10, 1: 20})
      // Expected pd= block: temp/PandasPython.res:15487
      // ============================================================================
      void rename_int_cols() {
          std::map<std::string, std::vector<int64_t>> data = {
              {"0", {1, 2}},
              {"1", {3, 4}},
              {"2", {5, 6}},
          };
          pandas::DataFrame df(data);
          df.set_columns_index_dtype("int64");
      
          pandas::DataFrame renamed = df.rename_columns(
              std::map<std::string, std::string>{{"0", "10"}, {"1", "20"}});
          renamed.set_columns_index_dtype("int64");
          apply_default_display(renamed);
      
          // Expected verbatim from temp/PandasPython.res:15488-15490
          const std::string expected =
              "   10  20  2 \n"
              "0   1   3   5\n"

.. _example-dataframe-set_columns_levels-496:

.. dropdown:: set_columns_levels (pd_test_2_all.cpp:20310)
   :class-title: example-dropdown

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

          check(t == pandas::DataFrame::ColumnAccessType::DuplicateColumns, "duplicate -> DuplicateColumns");
      }
      
      void pd_test_getitem_dispatch_classify_multiindex() {
          std::cout << "pd_test_getitem_dispatch_classify_multiindex" << std::endl;
          pandas::DataFrame df;
          std::vector<numpy::float64> v1 = {1.0, 2.0};
          std::vector<numpy::float64> v2 = {3.0, 4.0};
          df.insert(0, "A_x", std::make_unique<pandas::Series<numpy::float64>>(v1, "A_x"), true);
          df.insert(1, "A_y", std::make_unique<pandas::Series<numpy::float64>>(v2, "A_y"), true);
          df.set_columns_levels({{"A", "A"}, {"x", "y"}}, {"first", "second"});
      
          auto t = df.classify_column_access("A");
          check(t == pandas::DataFrame::ColumnAccessType::MultiIndexGroup, "multiindex top -> MultiIndexGroup");
      }
      
      // =========================================================================
      // Extraction tests
      // =========================================================================
      
      void pd_test_getitem_dispatch_extract_numeric() {

.. _example-dataframe-set_columns_name-497:

.. dropdown:: set_columns_name (pd_test_3_all.cpp:10815)
   :class-title: example-dropdown

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

          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_columns_name_setter() {
          std::cout << "========= DataFrame.columns_name(string) setter ========";
          pandas::DataFrame df;
          df.add_column<int64_t>("A", {1, 2, 3});
          df.columns_name("MyColumns");
          pandas::DataFrame df2;
          df2.add_column<int64_t>("A", {1, 2, 3});
          df2.set_columns_name("MyColumns");
          if (df.to_string() != df2.to_string()) {
              std::cout << "  [FAIL] : in pd_test_3_all_columns_name_setter() : mismatch" << std::endl;
              throw std::runtime_error("pd_test_3_all_columns_name_setter failed");
          }
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_column_alias() {
          std::cout << "========= DataFrame.column<T>() alias ==================";
          pandas::DataFrame df;

.. _example-dataframe-set_datetime_index-498:

.. dropdown:: set_datetime_index (pd_test_3_all.cpp:1322)
   :class-title: example-dropdown

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

              if (!df.has_multiindex() || df.multiindex().nlevels() != 2) {
                  throw std::runtime_error("set_multi_index: shape wrong");
              }
          }
      
          // G. set_datetime_index
          {
              pandas::DataFrame df;
              df.add_column<double>("price",
                  {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0});
              df.set_datetime_index("2020-01-01", 10, "D");
              if (df.index().size() != 10) {
                  throw std::runtime_error("set_datetime_index: size wrong");
              }
          }
      
          // H. set_nan_marker
          {
              pandas::DataFrame df;
              std::vector<std::string> v_str = {"", "y", "z", ""};
              df.add_column<std::string>("v_str", v_str);

.. _example-dataframe-set_display_options-499:

.. dropdown:: set_display_options (pd_test_4_all.cpp:118)
   :class-title: example-dropdown

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

      }
      static std::string load_expected(const std::string& relpath) {
          std::ifstream f(relpath, std::ios::binary);
          if (!f) throw std::runtime_error("cannot open expected fixture: " + relpath);
          std::string s((std::istreambuf_iterator<char>(f)), std::istreambuf_iterator<char>());
          std::string out; out.reserve(s.size());
          for (char ch : s) if (ch != '\r') out.push_back(ch);
          return out;
      }
      static void apply_default_display(pandas::DataFrame& df) {
          df.set_display_options(80, 50, 60, true);
      }
      
      void unstack_multiindex_compare_all() {
          pandas::DataFrame df;
          df.add_column<int64_t>("A_one", { 0, 2, 4});
          df.add_column<int64_t>("A_two", { 1, 3, 5});
          df.add_column<int64_t>("B_one", { 6, 8, 10});
          df.add_column<int64_t>("B_two", { 7, 9, 11});
      
          auto row_idx = std::make_unique<pandas::Index<std::string>>(

.. _example-dataframe-set_flags-500:

.. dropdown:: set_flags (pd_test_1_all.cpp:16410)
   :class-title: example-dropdown

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

                      throw std::runtime_error("pd_test_ndframe_series_flags failed: default allows_duplicate_labels");
                  }
      
                  passed = s.flags().copy_on_write == false;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_ndframe_series_flags() : default copy_on_write" << std::endl;
                      throw std::runtime_error("pd_test_ndframe_series_flags failed: default copy_on_write");
                  }
      
                  // Test set_flags
                  s.set_flags(pandas::Flags(false, true));
                  passed = s.flags().allows_duplicate_labels == false;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_ndframe_series_flags() : set allows_duplicate_labels" << std::endl;
                      throw std::runtime_error("pd_test_ndframe_series_flags failed: set allows_duplicate_labels");
                  }
      
                  passed = s.flags().copy_on_write == true;
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_ndframe_series_flags() : set copy_on_write" << std::endl;
                      throw std::runtime_error("pd_test_ndframe_series_flags failed: set copy_on_write");

.. _example-dataframe-set_integer_index-501:

.. dropdown:: set_integer_index (pd_test_3_all.cpp:1277)
   :class-title: example-dropdown

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

          {
              pandas::DataFrame df1;
              df1.add_column<double>("temp", {22.1, 23.5, 19.8, 25.0});
              df1.set_string_index({"Mon", "Tue", "Wed", "Thu"});
              if (df1.index().get_value_str(2) != "Wed") {
                  throw std::runtime_error("set_string_index: values wrong");
              }
      
              pandas::DataFrame df2;
              df2.add_column<int64_t>("val", {3, 4});
              df2.set_integer_index({2, 3});
              if (df2.index().size() != 2) {
                  throw std::runtime_error("set_integer_index: size wrong");
              }
      
              pandas::DataFrame df3;
              df3.add_column<int64_t>("val", {1, 2, 3, 4, 5});
              df3.set_index_from_strings({"a", "b", "c", "a", "b"});
              if (df3.index().get_value_str(4) != "b") {
                  throw std::runtime_error("set_index_from_strings: values wrong");
              }

.. _example-dataframe-set_integer_index-502:

.. dropdown:: set_integer_index (pd_test_3_all.cpp:1277)
   :class-title: example-dropdown

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

          {
              pandas::DataFrame df1;
              df1.add_column<double>("temp", {22.1, 23.5, 19.8, 25.0});
              df1.set_string_index({"Mon", "Tue", "Wed", "Thu"});
              if (df1.index().get_value_str(2) != "Wed") {
                  throw std::runtime_error("set_string_index: values wrong");
              }
      
              pandas::DataFrame df2;
              df2.add_column<int64_t>("val", {3, 4});
              df2.set_integer_index({2, 3});
              if (df2.index().size() != 2) {
                  throw std::runtime_error("set_integer_index: size wrong");
              }
      
              pandas::DataFrame df3;
              df3.add_column<int64_t>("val", {1, 2, 3, 4, 5});
              df3.set_index_from_strings({"a", "b", "c", "a", "b"});
              if (df3.index().get_value_str(4) != "b") {
                  throw std::runtime_error("set_index_from_strings: values wrong");
              }

.. _example-dataframe-set_multi_index-503:

.. dropdown:: set_multi_index (pd_test_3_all.cpp:1311)
   :class-title: example-dropdown

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

              df.index_name("year_end");  // setter form, used by 6 failing tests
              if (!df.index_name().has_value() || df.index_name().value() != "year_end") {
                  throw std::runtime_error("index_name(setter): round-trip failed");
              }
          }
      
          // F. set_multi_index -- two-level brace-init
          {
              pandas::DataFrame df;
              df.add_column<int64_t>("val", {10, 20, 30, 40});
              df.set_multi_index({{"A", "A", "B", "B"}, {"1", "2", "1", "2"}});
              if (!df.has_multiindex() || df.multiindex().nlevels() != 2) {
                  throw std::runtime_error("set_multi_index: shape wrong");
              }
          }
      
          // G. set_datetime_index
          {
              pandas::DataFrame df;
              df.add_column<double>("price",
                  {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0});

.. _example-dataframe-set_multi_index-504:

.. dropdown:: set_multi_index (pd_test_3_all.cpp:1311)
   :class-title: example-dropdown

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

              df.index_name("year_end");  // setter form, used by 6 failing tests
              if (!df.index_name().has_value() || df.index_name().value() != "year_end") {
                  throw std::runtime_error("index_name(setter): round-trip failed");
              }
          }
      
          // F. set_multi_index -- two-level brace-init
          {
              pandas::DataFrame df;
              df.add_column<int64_t>("val", {10, 20, 30, 40});
              df.set_multi_index({{"A", "A", "B", "B"}, {"1", "2", "1", "2"}});
              if (!df.has_multiindex() || df.multiindex().nlevels() != 2) {
                  throw std::runtime_error("set_multi_index: shape wrong");
              }
          }
      
          // G. set_datetime_index
          {
              pandas::DataFrame df;
              df.add_column<double>("price",
                  {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0});

.. _example-dataframe-set_multiindex-505:

.. dropdown:: set_multiindex (pd_test_2_all.cpp:20409)
   :class-title: example-dropdown

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

              check(s.get_freq().value() == "D", "freq value D");
          }
      
          // Test MultiIndex propagation
          pandas::DataFrame df2;
          std::vector<numpy::float64> vals2 = {10.0, 20.0};
          df2.insert(0, "A", std::make_unique<pandas::Series<numpy::float64>>(vals2, "A"), true);
          std::vector<std::vector<std::string>> arrays = {{"x", "y"}, {"1", "2"}};
          std::vector<std::optional<std::string>> names = {std::string("first"), std::string("second")};
          auto mi = pandas::MultiIndex::from_arrays<std::string>(arrays, names);
          df2.set_multiindex(mi);
      
          auto s2 = df2.extract_column_as_numeric_series("A");
          check(s2.has_multiindex(), "multiindex propagated");
      }
      
      } // namespace dataframe_tests_getitem_dispatch
      
      int pd_test_getitem_dispatch_main() {
          std::cout << "====================================== pd_test_getitem_dispatch test suite ==========================" << std::endl;
          dataframe_tests_getitem_dispatch::g_pass = 0;

.. _example-dataframe-set_multiindex-506:

.. dropdown:: set_multiindex (pd_test_2_all.cpp:20409)
   :class-title: example-dropdown

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

              check(s.get_freq().value() == "D", "freq value D");
          }
      
          // Test MultiIndex propagation
          pandas::DataFrame df2;
          std::vector<numpy::float64> vals2 = {10.0, 20.0};
          df2.insert(0, "A", std::make_unique<pandas::Series<numpy::float64>>(vals2, "A"), true);
          std::vector<std::vector<std::string>> arrays = {{"x", "y"}, {"1", "2"}};
          std::vector<std::optional<std::string>> names = {std::string("first"), std::string("second")};
          auto mi = pandas::MultiIndex::from_arrays<std::string>(arrays, names);
          df2.set_multiindex(mi);
      
          auto s2 = df2.extract_column_as_numeric_series("A");
          check(s2.has_multiindex(), "multiindex propagated");
      }
      
      } // namespace dataframe_tests_getitem_dispatch
      
      int pd_test_getitem_dispatch_main() {
          std::cout << "====================================== pd_test_getitem_dispatch test suite ==========================" << std::endl;
          dataframe_tests_getitem_dispatch::g_pass = 0;

.. _example-dataframe-set_multiindex-507:

.. dropdown:: set_multiindex (pd_test_2_all.cpp:20409)
   :class-title: example-dropdown

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

              check(s.get_freq().value() == "D", "freq value D");
          }
      
          // Test MultiIndex propagation
          pandas::DataFrame df2;
          std::vector<numpy::float64> vals2 = {10.0, 20.0};
          df2.insert(0, "A", std::make_unique<pandas::Series<numpy::float64>>(vals2, "A"), true);
          std::vector<std::vector<std::string>> arrays = {{"x", "y"}, {"1", "2"}};
          std::vector<std::optional<std::string>> names = {std::string("first"), std::string("second")};
          auto mi = pandas::MultiIndex::from_arrays<std::string>(arrays, names);
          df2.set_multiindex(mi);
      
          auto s2 = df2.extract_column_as_numeric_series("A");
          check(s2.has_multiindex(), "multiindex propagated");
      }
      
      } // namespace dataframe_tests_getitem_dispatch
      
      int pd_test_getitem_dispatch_main() {
          std::cout << "====================================== pd_test_getitem_dispatch test suite ==========================" << std::endl;
          dataframe_tests_getitem_dispatch::g_pass = 0;

.. _example-dataframe-set_multiindex-508:

.. dropdown:: set_multiindex (pd_test_2_all.cpp:20409)
   :class-title: example-dropdown

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

              check(s.get_freq().value() == "D", "freq value D");
          }
      
          // Test MultiIndex propagation
          pandas::DataFrame df2;
          std::vector<numpy::float64> vals2 = {10.0, 20.0};
          df2.insert(0, "A", std::make_unique<pandas::Series<numpy::float64>>(vals2, "A"), true);
          std::vector<std::vector<std::string>> arrays = {{"x", "y"}, {"1", "2"}};
          std::vector<std::optional<std::string>> names = {std::string("first"), std::string("second")};
          auto mi = pandas::MultiIndex::from_arrays<std::string>(arrays, names);
          df2.set_multiindex(mi);
      
          auto s2 = df2.extract_column_as_numeric_series("A");
          check(s2.has_multiindex(), "multiindex propagated");
      }
      
      } // namespace dataframe_tests_getitem_dispatch
      
      int pd_test_getitem_dispatch_main() {
          std::cout << "====================================== pd_test_getitem_dispatch test suite ==========================" << std::endl;
          dataframe_tests_getitem_dispatch::g_pass = 0;

.. _example-dataframe-set_multiindex-509:

.. dropdown:: set_multiindex (pd_test_2_all.cpp:20409)
   :class-title: example-dropdown

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

              check(s.get_freq().value() == "D", "freq value D");
          }
      
          // Test MultiIndex propagation
          pandas::DataFrame df2;
          std::vector<numpy::float64> vals2 = {10.0, 20.0};
          df2.insert(0, "A", std::make_unique<pandas::Series<numpy::float64>>(vals2, "A"), true);
          std::vector<std::vector<std::string>> arrays = {{"x", "y"}, {"1", "2"}};
          std::vector<std::optional<std::string>> names = {std::string("first"), std::string("second")};
          auto mi = pandas::MultiIndex::from_arrays<std::string>(arrays, names);
          df2.set_multiindex(mi);
      
          auto s2 = df2.extract_column_as_numeric_series("A");
          check(s2.has_multiindex(), "multiindex propagated");
      }
      
      } // namespace dataframe_tests_getitem_dispatch
      
      int pd_test_getitem_dispatch_main() {
          std::cout << "====================================== pd_test_getitem_dispatch test suite ==========================" << std::endl;
          dataframe_tests_getitem_dispatch::g_pass = 0;

.. _example-dataframe-set_multiindex-510:

.. dropdown:: set_multiindex (pd_test_2_all.cpp:20409)
   :class-title: example-dropdown

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

              check(s.get_freq().value() == "D", "freq value D");
          }
      
          // Test MultiIndex propagation
          pandas::DataFrame df2;
          std::vector<numpy::float64> vals2 = {10.0, 20.0};
          df2.insert(0, "A", std::make_unique<pandas::Series<numpy::float64>>(vals2, "A"), true);
          std::vector<std::vector<std::string>> arrays = {{"x", "y"}, {"1", "2"}};
          std::vector<std::optional<std::string>> names = {std::string("first"), std::string("second")};
          auto mi = pandas::MultiIndex::from_arrays<std::string>(arrays, names);
          df2.set_multiindex(mi);
      
          auto s2 = df2.extract_column_as_numeric_series("A");
          check(s2.has_multiindex(), "multiindex propagated");
      }
      
      } // namespace dataframe_tests_getitem_dispatch
      
      int pd_test_getitem_dispatch_main() {
          std::cout << "====================================== pd_test_getitem_dispatch test suite ==========================" << std::endl;
          dataframe_tests_getitem_dispatch::g_pass = 0;

.. _example-dataframe-set_multiindex-511:

.. dropdown:: set_multiindex (pd_test_2_all.cpp:20409)
   :class-title: example-dropdown

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

              check(s.get_freq().value() == "D", "freq value D");
          }
      
          // Test MultiIndex propagation
          pandas::DataFrame df2;
          std::vector<numpy::float64> vals2 = {10.0, 20.0};
          df2.insert(0, "A", std::make_unique<pandas::Series<numpy::float64>>(vals2, "A"), true);
          std::vector<std::vector<std::string>> arrays = {{"x", "y"}, {"1", "2"}};
          std::vector<std::optional<std::string>> names = {std::string("first"), std::string("second")};
          auto mi = pandas::MultiIndex::from_arrays<std::string>(arrays, names);
          df2.set_multiindex(mi);
      
          auto s2 = df2.extract_column_as_numeric_series("A");
          check(s2.has_multiindex(), "multiindex propagated");
      }
      
      } // namespace dataframe_tests_getitem_dispatch
      
      int pd_test_getitem_dispatch_main() {
          std::cout << "====================================== pd_test_getitem_dispatch test suite ==========================" << std::endl;
          dataframe_tests_getitem_dispatch::g_pass = 0;

.. _example-dataframe-set_multiindex-512:

.. dropdown:: set_multiindex (pd_test_2_all.cpp:20409)
   :class-title: example-dropdown

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

              check(s.get_freq().value() == "D", "freq value D");
          }
      
          // Test MultiIndex propagation
          pandas::DataFrame df2;
          std::vector<numpy::float64> vals2 = {10.0, 20.0};
          df2.insert(0, "A", std::make_unique<pandas::Series<numpy::float64>>(vals2, "A"), true);
          std::vector<std::vector<std::string>> arrays = {{"x", "y"}, {"1", "2"}};
          std::vector<std::optional<std::string>> names = {std::string("first"), std::string("second")};
          auto mi = pandas::MultiIndex::from_arrays<std::string>(arrays, names);
          df2.set_multiindex(mi);
      
          auto s2 = df2.extract_column_as_numeric_series("A");
          check(s2.has_multiindex(), "multiindex propagated");
      }
      
      } // namespace dataframe_tests_getitem_dispatch
      
      int pd_test_getitem_dispatch_main() {
          std::cout << "====================================== pd_test_getitem_dispatch test suite ==========================" << std::endl;
          dataframe_tests_getitem_dispatch::g_pass = 0;

.. _example-dataframe-set_multiindex_names-513:

.. dropdown:: set_multiindex_names (pd_test_2_all.cpp:20775)
   :class-title: example-dropdown

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

          // Simulate a 2-level groupby result with composite \x1f keys
          using std::string;
          string sep(1, '\x1f');
          std::vector<string> keys = {"A" + sep + "X", "A" + sep + "Y", "B" + sep + "X", "B" + sep + "Y"};
      
          std::vector<numpy::float64> values = {1.0, 2.0, 3.0, 4.0};
          pandas::Series<std::string> by(keys);
          pandas::Series<numpy::float64> data(values);
      
          auto sgb = data.groupby(by);
          sgb.set_multiindex_names({"level0", "level1"});
      
          // Create a "result" series with composite index
          pandas::Series<numpy::float64> result(values);
          result.set_index(std::make_unique<pandas::Index<std::string>>(keys));
      
          sgb.apply_result_index(result);
      
          // Should now have a MultiIndex
          check(result.has_multiindex(), "has_multiindex");
          check(result.multiindex().nlevels() == 2, "nlevels_2");

.. _example-dataframe-set_nan_marker-514:

.. dropdown:: set_nan_marker (pd_test_3_all.cpp:1334)
   :class-title: example-dropdown

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

                  throw std::runtime_error("set_datetime_index: size wrong");
              }
          }
      
          // H. set_nan_marker
          {
              pandas::DataFrame df;
              std::vector<std::string> v_str = {"", "y", "z", ""};
              df.add_column<std::string>("v_str", v_str);
              df.add_column<int64_t>("v_num", {1, 2, 3, 4});
              df.set_nan_marker("v_str", {true, false, false, true});
              // exact mask-bit assertions depend on Series<string> mask API
          }
      
          // I. set_index_from_column<T>
          {
              pandas::DataFrame df;
              df.add_column<int64_t>("val", {1, 3});
              df.add_column<int64_t>("count", {30, 70});
              df.set_index_from_column<std::string>("group", {"A", "B"});
              if (!df.index_name().has_value() || df.index_name().value() != "group") {

.. _example-dataframe-set_option-515:

.. dropdown:: set_option (pd_test_3_all.cpp:10876)
   :class-title: example-dropdown

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

          df.set_multiindex(mi);
          auto result = df.reorder_levels({"second", "first"});
          if (result.nrows() != 4) {
              std::cout << "  [FAIL] : in pd_test_3_all_reorder_levels_initlist() : wrong nrows" << std::endl;
              throw std::runtime_error("pd_test_3_all_reorder_levels_initlist failed");
          }
          std::cout << " -> tests passed" << std::endl;
      }
      
      void pd_test_3_all_set_option_instance() {
          std::cout << "========= DataFrame.set_option() instance ==============";
          pandas::DataFrame df;
          df.add_column<int64_t>("A", {1, 2, 3});
          df.set_option("display.multi_sparse", false);
          df.set_option("display.unknown_key", true);  // should not throw
          std::cout << " -> tests passed" << std::endl;
      }
      
      // ============================================================================
      // Category 48: Indexing Fixes (Plan: plan_indexing_fixes)
      // ============================================================================

.. _example-dataframe-set_string_index-516:

.. dropdown:: set_string_index (pd_test_3_all.cpp:1270)
   :class-title: example-dropdown

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

              df.set_index_from_list(labels);
              if (df.index().get_value_str(1) != "q") {
                  throw std::runtime_error("set_index_from_list(vector): values wrong");
              }
          }
      
          // D. Aliases: set_string_index / set_integer_index / set_index_from_strings
          {
              pandas::DataFrame df1;
              df1.add_column<double>("temp", {22.1, 23.5, 19.8, 25.0});
              df1.set_string_index({"Mon", "Tue", "Wed", "Thu"});
              if (df1.index().get_value_str(2) != "Wed") {
                  throw std::runtime_error("set_string_index: values wrong");
              }
      
              pandas::DataFrame df2;
              df2.add_column<int64_t>("val", {3, 4});
              df2.set_integer_index({2, 3});
              if (df2.index().size() != 2) {
                  throw std::runtime_error("set_integer_index: size wrong");
              }

.. _example-dataframe-shape-517:

.. dropdown:: shape (pd_test_1_all.cpp:6188)
   :class-title: example-dropdown

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

                  std::cout << "========= properties =======================";
      
                  std::map<std::string, std::vector<numpy::float64>> data;
                  data["A"] = {1.0, 2.0, 3.0, 4.0};
                  data["B"] = {5.0, 6.0, 7.0, 8.0};
                  data["C"] = {9.0, 10.0, 11.0, 12.0};
      
                  pandas::DataFrame df(data);
      
                  // Test shape
                  auto shape = df.shape();
                  if (shape.size() != 2 || shape[0] != 4 || shape[1] != 3) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_properties() : shape mismatch" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_properties failed: shape mismatch");
                  }
      
                  // Test ndim
                  if (df.ndim() != 2) {
                      std::cout << "  [FAIL] : in pd_test_dataframe_properties() : ndim != 2" << std::endl;
                      throw std::runtime_error("pd_test_dataframe_properties failed: ndim != 2");
                  }

.. _example-dataframe-shape_2d-518:

.. dropdown:: shape_2d (pd_test_3_all.cpp:10796)
   :class-title: example-dropdown

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

          }
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      // ============================================================================
      // Category 47: Quick Fixes & Aliases Tests
      // ============================================================================
      
      void pd_test_3_all_shape_2d() {
          std::cout << "========= DataFrame.shape_2d() =========================";
          pandas::DataFrame df;
          df.add_column<int64_t>("A", {1, 2, 3});
          df.add_column<int64_t>("B", {4, 5, 6});
          auto s = df.shape_2d();
          if (s.first != 3 || s.second != 2) {
              std::cout << "  [FAIL] : in pd_test_3_all_shape_2d() : wrong dimensions" << std::endl;
              throw std::runtime_error("pd_test_3_all_shape_2d failed");
          }
          std::cout << " -> tests passed" << std::endl;
      }

.. _example-dataframe-size-519:

.. dropdown:: size (pd_test_1_all.cpp:22)
   :class-title: example-dropdown

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

      #include "../pandas/pd_boolean_array.h"
      
      namespace dataframe_tests {
      
      namespace dataframe_tests_boolean_array {
          void pd_test_boolean_array_constructors() {
              std::cout << "========= BooleanArray: constructors ======================= ";
      
              // Default constructor
              pandas::BooleanArray arr1;
              if (arr1.size() != 0) {
                  std::cout << "  [FAIL] : in pd_test_boolean_array_constructors() : default constructor size != 0" << std::endl;
                  throw std::runtime_error("pd_test_boolean_array_constructors failed: default constructor size != 0");
              }
      
              // Initializer list constructor
              pandas::BooleanArray arr2({
                  std::optional<bool>(true),
                  std::optional<bool>(false),
                  std::nullopt,
                  std::optional<bool>(true)

.. _example-dataframe-sparse-520:

.. dropdown:: sparse (pd_test_3_all.cpp:20627)
   :class-title: example-dropdown

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

      #include <cmath>
      
      #include "../pandas/pd_series.h"
      
      // CRITICAL: No using namespace directives
      
      namespace dataframe_tests {
      namespace dataframe_tests_sparse_accessor {
      
      // ============================================================================
      // Test sparse().density() and sparse().npoints()
      // ============================================================================
      
      void pd_test_sparse_density_npoints() {
          std::cout << "========= Series.sparse().density/npoints() =============";
      
          // Create a series with some zeros (sparse values)
          pandas::Series<numpy::float64> s({0.0, 1.0, 0.0, 2.0, 0.0, 3.0});
      
          auto sparse = s.sparse(0.0);  // 0.0 is the fill value
      

.. _example-dataframe-ss-521:

.. dropdown:: ss (pd_test_3_all.cpp:27670)
   :class-title: example-dropdown

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

                  fail++;
              } else {
                  auto cats = str_s->get_cat_categories();
                  if (cats.size() != 3) {
                      std::cout << "    FAIL: expected 3 categories, got " << cats.size() << std::endl;
                      fail++;
                  }
              }
          }
      
          pandas::Series<std::string> ss({"a", "b", "a", "c"}, "strs");
          auto result2 = ss.astype("category");
          auto* str_s2 = dynamic_cast<pandas::Series<std::string>*>(result2.get());
          if (!str_s2) {
              std::cout << "    FAIL: expected Series<string> for string->category" << std::endl;
              fail++;
          } else {
              if (str_s2->dtype_name() != "category") {
                  std::cout << "    FAIL: dtype should be category" << std::endl;
                  fail++;
              }

.. _example-dataframe-trim-522:

.. dropdown:: trim (pd_test_5_all.cpp:58873)
   :class-title: example-dropdown

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

          auto trim = [](const std::string& s) {
              size_t a = s.find_first_not_of(" \t");
              size_t b = s.find_last_not_of(" \t\r");
              if (a == std::string::npos) return std::string();
              return s.substr(a, b - a + 1);
          };
          size_t pos = 0;
          while (pos < body.size()) {
              size_t nl = body.find('\n', pos);
              std::string raw = body.substr(pos, nl == std::string::npos ? std::string::npos : nl - pos);
              std::string t = trim(raw);
              if (!t.empty()) {
                  // tokenise by whitespace
                  std::vector<std::string> toks;
                  std::string cur;
                  for (char c : t) {
                      if (c == ' ' || c == '\t') {
                          if (!cur.empty()) { toks.push_back(cur); cur.clear(); }
                      } else {
                          cur.push_back(c);
                      }

.. _example-dataframe-trim-523:

.. dropdown:: trim (pd_test_5_all.cpp:58873)
   :class-title: example-dropdown

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

          auto trim = [](const std::string& s) {
              size_t a = s.find_first_not_of(" \t");
              size_t b = s.find_last_not_of(" \t\r");
              if (a == std::string::npos) return std::string();
              return s.substr(a, b - a + 1);
          };
          size_t pos = 0;
          while (pos < body.size()) {
              size_t nl = body.find('\n', pos);
              std::string raw = body.substr(pos, nl == std::string::npos ? std::string::npos : nl - pos);
              std::string t = trim(raw);
              if (!t.empty()) {
                  // tokenise by whitespace
                  std::vector<std::string> toks;
                  std::string cur;
                  for (char c : t) {
                      if (c == ' ' || c == '\t') {
                          if (!cur.empty()) { toks.push_back(cur); cur.clear(); }
                      } else {
                          cur.push_back(c);
                      }

.. _example-dataframe-truncate-524:

.. dropdown:: truncate (pd_test_1_all.cpp:20467)
   :class-title: example-dropdown

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

                  std::vector<std::string> dates = {
                      "2020-01-01",
                      "2020-01-02",
                      "2020-01-03",
                      "2020-01-04",
                      "2020-01-05"
                  };
                  df.set_index(std::make_unique<pandas::Index<std::string>>(dates));
      
                  // Truncate to keep only dates from 2020-01-02 to 2020-01-04
                  pandas::DataFrame result = df.truncate("2020-01-02", "2020-01-04");
      
                  bool passed = (result.nrows() == 3);
      
                  if (!passed) {
                      std::cout << "  [FAIL] : in pd_test_timeseries_truncate() : expected 3 rows, got "
                                << result.nrows() << std::endl;
                      throw std::runtime_error("pd_test_timeseries_truncate failed");
                  }
      
                  std::cout << " -> tests passed" << std::endl;

.. _example-dataframe-ts-525:

.. 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-dataframe-values-526:

.. dropdown:: values (pd_test_1_all.cpp:364)
   :class-title: example-dropdown

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

              pandas::CategoricalArray arr1;
              if (arr1.size() != 0) {
                  std::cout << "  [FAIL] : in pd_test_categorical_array_constructors() : default constructor size != 0" << std::endl;
                  throw std::runtime_error("pd_test_categorical_array_constructors failed: default constructor size != 0");
              }
              if (arr1.ordered()) {
                  std::cout << "  [FAIL] : in pd_test_categorical_array_constructors() : default should be unordered" << std::endl;
                  throw std::runtime_error("pd_test_categorical_array_constructors failed: default should be unordered");
              }
      
              // Constructor from values (infer categories)
              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>("c")
              };
              pandas::CategoricalArray arr2(values);
              if (arr2.size() != 4) {
                  std::cout << "  [FAIL] : in pd_test_categorical_array_constructors() : values constructor size != 4" << std::endl;
                  throw std::runtime_error("pd_test_categorical_array_constructors failed: values constructor size != 4");