DataFrame

class pandas::DataFrame

Core data container class in the pandas namespace.

Example

#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

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	View
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	View
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	View
DataFrame(const DataFrame& other)	pd_dataframe.h:939	View
DataFrame(DataFrame&& other) noexcept	pd_dataframe.h:964	View
DataFrame(const std::map<std::string, std::vector<std::complex<double>>>& cols)	pd_dataframe.h:1078	View
DataFrame(const std::map<std::string, ColumnSource>& cols)	pd_dataframe.h:1123	View

Construction

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

Signature	Return Type	Location	Example
T at(const std::string& row_label, const std::string& col_label) const	T	pd_dataframe.h:3997	View
DataFrame at_time(const std::string& time, bool asof = false, int axis = 0) const	DataFrame	pd_dataframe.h:26966	View
const Attrs& attrs() const override	const Attrs&	pd_dataframe.h:1825	View
Attrs& attrs() override	Attrs&	pd_dataframe.h:1832	View
DataFrame first(const std::string& offset) const	DataFrame	pd_dataframe.h:27022	View
std::optional<std::string> first_valid_index() const	std::optional<std::string>	pd_dataframe.h:13168	View
std::optional<ReturnType> get(const std::string& key, std::optional<ReturnType> default_value = std::nullopt) const	std::optional<ReturnType>	pd_dataframe.h:13303	View
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	View
Series<std::string> get_column_as_string_series(const std::string& key) const	Series<std::string>	pd_dataframe.h:3422	View
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	View
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	View
DataFrame get_duplicate_columns(const std::string& key) const	DataFrame	pd_dataframe.h:3347	View
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	View
Series<T> get_series(const std::string& col_name) const	Series<T>	pd_dataframe.h:3630	View
bool get_value_bool(size_t idx) const override	bool	pd_dataframe.h:8435	View
DataFrame head(size_t n = 5) const	DataFrame	pd_dataframe.h:4016	View
T iat(size_t row, size_t col_idx) const	T	pd_dataframe.h:4005	View
Series<std::string> idxmax(int axis = 0, bool skipna = true, bool numeric_only = false) const	Series<std::string>	pd_dataframe.h:10501	View
Series<std::string> idxmin(int axis = 0, bool skipna = true, bool numeric_only = false) const	Series<std::string>	pd_dataframe.h:10587	View
DataFrame iloc(size_t start, size_t stop) const	DataFrame	pd_dataframe.h:3794	View
T iloc(size_t row, size_t col_idx) const	T	pd_dataframe.h:3802	View
DataFrame iloc(const std::vector<size_t>& row_indices, const std::vector<size_t>& col_indices) const	DataFrame	pd_dataframe.h:3983	View
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	View
DataFrame iloc_rows(const std::vector<size_t>& row_indices) const	DataFrame	pd_dataframe.h:3865	View
DataFrame last(const std::string& offset) const	DataFrame	pd_dataframe.h:27029	View
std::optional<std::string> last_valid_index() const	std::optional<std::string>	pd_dataframe.h:13188	View
T loc(const std::string& row_label, const std::string& col_label) const	T	pd_dataframe.h:3709	View
DataFrame loc(const std::string& start_label, const std::string& end_label) const	DataFrame	pd_dataframe.h:3718	View
LocProxy loc(const std::string& label1, const std::string& label2)	LocProxy	pd_dataframe.h:3730	View
DataFrame loc(const std::string& first_level_label) const	DataFrame	pd_dataframe.h:3737	View
DataFrame loc(const std::vector<std::string>& row_labels, const std::vector<std::string>& col_labels) const	DataFrame	pd_dataframe.h:3781	View
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	View
DataFrame nlargest(size_t n, const std::string& columns, const std::string& keep = "first") const	DataFrame	pd_dataframe.h:15038	View
DataFrame nsmallest(size_t n, const std::string& columns, const std::string& keep = "first") const	DataFrame	pd_dataframe.h:15051	View
DataFrame query(const std::string& expr, bool inplace = false) const	DataFrame	pd_dataframe.h:9486	View
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	View
DataFrame sample(T n, unsigned int seed) const	DataFrame	pd_dataframe.h:4141	View
DataFrame sample(T n, unsigned int seed) const	DataFrame	pd_dataframe.h:4155	View
DataFrame sample(std::optional<size_t> n, std::optional<double> frac, bool replace, unsigned int random_state) const	DataFrame	pd_dataframe.h:4176	View
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	View
DataFrame sample_frac(double frac, unsigned int seed = 0) const	DataFrame	pd_dataframe.h:4168	View
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	View
DataFrame tail(size_t n = 5) const	DataFrame	pd_dataframe.h:4024	View
DataFrame take(const std::vector<size_t>& indices, int axis = 0) const	DataFrame	pd_dataframe.h:4201	View
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	View
DataFrame where(const DataFrame& cond, const DataFrame& other) const	DataFrame	pd_dataframe.h:8993	View
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	View
DataFrame where_resolved(const WhereCondition& cond, const WhereOther& other, int axis) const	DataFrame	pd_dataframe.h:9271	View
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	View
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	View
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	View
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	View
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

Signature	Return Type	Location	Example
DataFrame assign(const std::string& col_name, const std::vector<T>& data) const	DataFrame	pd_dataframe.h:10259	View
DataFrame assign(const std::string& col_name, const Series<numpy::float64>& s) const	DataFrame	pd_dataframe.h:10300	View
DataFrame assign(const std::string& col_name, const Series<std::string>& s) const	DataFrame	pd_dataframe.h:10322	View
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	View
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	View
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	View
DataFrame droplevel(int level, const std::string& axis) const	DataFrame	pd_dataframe.h:15313	View
DataFrame droplevel(const std::string& level_name, int axis = 0) const	DataFrame	pd_dataframe.h:15335	View
DataFrame droplevel(const std::vector<int>& levels, int axis = 0) const	DataFrame	pd_dataframe.h:15365	View
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	View
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	View
void insert(size_t loc, const std::string& column, std::unique_ptr<NDFrameBase> value, bool allow_duplicates = false)	void	pd_dataframe.h:6806	View
insert(ncols(), name, std::move(s))		pd_dataframe.h:6874	View
insert(ncols(), name, std::make_unique<Series<T>>(data, name))		pd_dataframe.h:6877	View
insert(ncols(), name, std::move(new_col))		pd_dataframe.h:6906	View
insert(ncols(), name, std::move(new_col))		pd_dataframe.h:6942	View
insert(ncols(), name, std::move(new_col))		pd_dataframe.h:6965	View
insert(ncols(), name, std::move(s))		pd_dataframe.h:7006	View
insert(ncols(), name, std::move(s))		pd_dataframe.h:7026	View
insert(ncols(), name, std::move(s))		pd_dataframe.h:7039	View
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	View
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	View
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	View
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	View
DataFrame reindex(const std::vector<std::int64_t>& int_labels, int axis = 0, double fill_value = std::nan("")) const	DataFrame	pd_dataframe.h:6513	View
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	View
std::unique_ptr<NDFrameBase> reindex_with_indexer(const numpy::NDArray<numpy::int64>& indexer) const override	std::unique_ptr<NDFrameBase>	pd_dataframe.h:27156	View
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	View
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	View
DataFrame rename(const std::map<std::string, std::string>& mapper, int axis) const	DataFrame	pd_dataframe.h:5385	View
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	View
DataFrame rename_axis(const std::string& mapper, int axis) const	DataFrame	pd_dataframe.h:6642	View
DataFrame rename_columns(const std::map<std::string, std::string>& mapper) const	DataFrame	pd_dataframe.h:5278	View
Result rename_result(const RenameSpec& spec, int axis, bool inplace, bool errors_raise)	Result	pd_dataframe.h:5403	View
DataFrame reorder_levels(const std::vector<int>& order, int axis = 0) const	DataFrame	pd_dataframe.h:15657	View
DataFrame reorder_levels(const std::vector<int>& order, const std::string& axis) const	DataFrame	pd_dataframe.h:15708	View
DataFrame reorder_levels(const std::vector<std::string>& order, int axis = 0) const	DataFrame	pd_dataframe.h:15731	View
DataFrame reorder_levels(std::initializer_list<const char\*> order, int axis = 0) const	DataFrame	pd_dataframe.h:15766	View
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	View
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	View
DataFrame replace(const std::map<std::string,std::string>& mapping, bool inplace = false) const	DataFrame	pd_dataframe.h:9075	View
DataFrame replace(std::int64_t to_replace, std::int64_t value) const	DataFrame	pd_dataframe.h:9095	View
DataFrame replace(int old_val, int new_val) const	DataFrame	pd_dataframe.h:9100	View
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	View
DataFrame set_axis(const std::vector<std::string>& labels, int axis = 0, bool copy = true) const	DataFrame	pd_dataframe.h:6559	View
void set_index(std::unique_ptr<IndexBase> new_index) override	void	pd_dataframe.h:4611	View
void set_index(const std::shared_ptr<IdxT>& new_index)	void	pd_dataframe.h:4630	View
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	View
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	View
DataFrame set_index(const std::string& key, bool drop = true, bool append = false, bool verify_integrity = false) const	DataFrame	pd_dataframe.h:4663	View
void set_index(const IdxT& idx)	void	pd_dataframe.h:4682	View
set_index(idx.clone())		pd_dataframe.h:4684	View
void set_index(const MultiIndex& mi)	void	pd_dataframe.h:4690	View
void set_index(MultiIndex&& mi)	void	pd_dataframe.h:4693	View
void set_index(std::initializer_list<std::type_identity_t<T>> values)	void	pd_dataframe.h:4713	View
set_index(std::make_unique<Index<T>>(std::move(vec)))		pd_dataframe.h:4715	View
void set_index(const std::vector<std::type_identity_t<T>>& values)	void	pd_dataframe.h:4720	View
set_index(std::make_unique<Index<T>>(values))		pd_dataframe.h:4721	View
void set_index(std::vector<std::type_identity_t<T>>&& values)	void	pd_dataframe.h:4726	View
set_index(std::make_unique<Index<T>>(std::move(values)))		pd_dataframe.h:4727	View
set_index(std::make_unique<Index<std::string>>(vec))		pd_dataframe.h:4740	View
set_index(std::make_unique<Index<numpy::int64>>(vec))		pd_dataframe.h:4745	View
set_index(std::make_unique<Index<numpy::int64>>(vec))		pd_dataframe.h:4752	View
set_index(std::make_unique<Index<numpy::int64>>(vec))		pd_dataframe.h:4762	View
set_index(std::make_unique<Index<std::string>>(values))		pd_dataframe.h:4766	View
set_index(std::make_unique<DatetimeIndex>(std::move(dti)))		pd_dataframe.h:4842	View
set_index(std::move(idx))		pd_dataframe.h:4890	View
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	View
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	View
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	View
void set_index_from_column(const std::string& name, std::initializer_list<T> values)	void	pd_dataframe.h:4884	View
void set_index_from_list(std::initializer_list<const char\*> values)	void	pd_dataframe.h:4738	View
void set_index_from_list(std::initializer_list<int64_t> values)	void	pd_dataframe.h:4743	View
void set_index_from_list(std::initializer_list<int> values)	void	pd_dataframe.h:4748	View
void set_index_from_list(std::initializer_list<long> values)	void	pd_dataframe.h:4758	View
void set_index_from_list(const std::vector<std::string>& values)	void	pd_dataframe.h:4765	View
set_index_from_list(values)		pd_dataframe.h:4771	View
set_index_from_list(values)		pd_dataframe.h:4774	View
set_index_from_list(values)		pd_dataframe.h:4777	View
set_index_from_list(values)		pd_dataframe.h:4780	View
set_index_from_list(values)		pd_dataframe.h:4783	View
void set_index_from_strings(std::initializer_list<const char\*> values)	void	pd_dataframe.h:4779	View
void set_index_from_strings(const std::vector<std::string>& values)	void	pd_dataframe.h:4782	View
void set_index_name(const std::string& name)	void	pd_dataframe.h:4789	View
set_index_name(name)		pd_dataframe.h:4798	View
DataFrame swaplevel(int i = -2, int j = -1, int axis = 0) const	DataFrame	pd_dataframe.h:15815	View
DataFrame swaplevel(int i, int j, const std::string& axis) const	DataFrame	pd_dataframe.h:15863	View
DataFrame swaplevel(const std::string& i, const std::string& j, int axis = 0) const	DataFrame	pd_dataframe.h:15886	View
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	View

Missing Data

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	View
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	View
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	View
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	View
DataFrame fillna(const std::string& value) const	DataFrame	pd_dataframe.h:8819	View
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	View
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	View
DataFrame fillna(const DataFrame& fill_df, int axis = 0, std::optional<int> limit = std::nullopt) const	DataFrame	pd_dataframe.h:8877	View
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	View
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	View
DataFrame isna_frame() const	DataFrame	pd_dataframe.h:8538	View
numpy::NDArray<numpy::bool_> isnull() const	numpy::NDArray<numpy::bool_>	pd_dataframe.h:13126	View
DataFrame isnull_frame() const	DataFrame	pd_dataframe.h:8591	View
numpy::NDArray<numpy::bool_> notna() const	numpy::NDArray<numpy::bool_>	pd_dataframe.h:8523	View
DataFrame notna_frame() const	DataFrame	pd_dataframe.h:8565	View
numpy::NDArray<numpy::bool_> notnull() const	numpy::NDArray<numpy::bool_>	pd_dataframe.h:13134	View
DataFrame notnull_frame() const	DataFrame	pd_dataframe.h:8598	View
DataFrame pad(int axis = 0, std::optional<int> limit = std::nullopt, bool inplace = false, const std::string& downcast = "") const	DataFrame	pd_dataframe.h:13159	View

Statistics

Signature	Return Type	Location	Example
size_t count() const override	size_t	pd_dataframe.h:7458	View
Series<numpy::int64> count(int axis, bool numeric_only = false) const	Series<numpy::int64>	pd_dataframe.h:7472	View
Series<numpy::int64> count_cols() const	Series<numpy::int64>	pd_dataframe.h:10719	View
DataFrame cummax(int axis = 0, bool skipna = true) const	DataFrame	pd_dataframe.h:20426	View
DataFrame cummin(int axis = 0, bool skipna = true) const	DataFrame	pd_dataframe.h:20311	View
DataFrame cumprod(int axis = 0, bool skipna = true) const	DataFrame	pd_dataframe.h:20214	View
DataFrame cumsum(int axis = 0, bool skipna = true) const	DataFrame	pd_dataframe.h:20108	View
DataFrame describe(const std::vector<double>& percentiles = {0.25, 0.5, 0.75}) const	DataFrame	pd_dataframe.h:11001	View
DataFrame describe_full(const std::vector<double>& percentiles = {0.25, 0.5, 0.75}, int include_mode = 0) const	DataFrame	pd_dataframe.h:10868	View
Series<numpy::float64> kurt(int axis = 0, bool skipna = true, bool numeric_only = false) const	Series<numpy::float64>	pd_dataframe.h:12411	View
Series<numpy::float64> kurt_cols(bool skipna = true) const	Series<numpy::float64>	pd_dataframe.h:11071	View
Series<numpy::float64> kurtosis(int axis = 0, bool skipna = true, bool numeric_only = false) const	Series<numpy::float64>	pd_dataframe.h:12465	View
Series<numpy::float64> max(int axis = 0, bool skipna = true, bool numeric_only = false) const	Series<numpy::float64>	pd_dataframe.h:12250	View
Series<numpy::float64> max_cols(bool skipna = true) const	Series<numpy::float64>	pd_dataframe.h:10459	View
Series<numpy::float64> mean(int axis = 0, bool skipna = true, bool numeric_only = false) const	Series<numpy::float64>	pd_dataframe.h:12011	View
Series<numpy::float64> mean_cols(bool skipna = true) const	Series<numpy::float64>	pd_dataframe.h:10392	View
Series<numpy::float64> median(int axis = 0, bool skipna = true, bool numeric_only = false) const	Series<numpy::float64>	pd_dataframe.h:11174	View
Series<numpy::float64> median_cols(bool skipna = true) const	Series<numpy::float64>	pd_dataframe.h:11126	View
Series<numpy::float64> min(int axis = 0, bool skipna = true, bool numeric_only = false) const	Series<numpy::float64>	pd_dataframe.h:12158	View
Series<numpy::float64> min_cols(bool skipna = true) const	Series<numpy::float64>	pd_dataframe.h:10430	View
DataFrame mode(int axis = 0, bool numeric_only = false, bool dropna = true) const	DataFrame	pd_dataframe.h:11242	View
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	View
Series<numpy::int64> nunique_cols(bool dropna = true) const	Series<numpy::int64>	pd_dataframe.h:13622	View
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	View
Series<numpy::float64> prod_cols(bool skipna = true) const	Series<numpy::float64>	pd_dataframe.h:11507	View
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	View
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	View
Series<numpy::float64> quantile_cols(double q, const std::string& interpolation = "linear") const	Series<numpy::float64>	pd_dataframe.h:13949	View
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	View
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	View
Series<numpy::float64> skew_cols(bool skipna = true) const	Series<numpy::float64>	pd_dataframe.h:11024	View
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	View
pandas::Series<numpy::timedelta64> std_(td_vals)	pandas::Series<numpy::timedelta64>	pd_dataframe.h:21232	View
pandas::Series<numpy::timedelta64> std_(td_vals)	pandas::Series<numpy::timedelta64>	pd_dataframe.h:21597	View
Series<numpy::float64> std_cols(bool skipna = true, int ddof = 1) const	Series<numpy::float64>	pd_dataframe.h:10660	View
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	View
Series<numpy::float64> sum_cols(bool skipna = true) const	Series<numpy::float64>	pd_dataframe.h:10341	View
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	View
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	View
Series<numpy::float64> var_cols(bool skipna = true, int ddof = 1) const	Series<numpy::float64>	pd_dataframe.h:10703

Aggregation

Signature	Return Type	Location	Example
DataFrame agg(const std::string& func, int axis = 0) const	DataFrame	pd_dataframe.h:23703	View
DataFrame agg(const std::vector<std::string>& funcs, int axis = 0) const	DataFrame	pd_dataframe.h:23742	View
DataFrame agg(const std::map<std::string, std::string>& col_func_map, int axis = 0) const	DataFrame	pd_dataframe.h:23795	View
DataFrame agg(const std::map<std::string, std::vector<std::string>>& col_funcs_map, int axis = 0) const	DataFrame	pd_dataframe.h:23820	View
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	View
Series<numpy::float64> agg_to_series(const std::string& func, int axis = 0) const	Series<numpy::float64>	pd_dataframe.h:23893	View
DataFrame aggregate(const std::string& func, int axis = 0) const	DataFrame	pd_dataframe.h:23776	View
DataFrame aggregate(const std::vector<std::string>& funcs, int axis = 0) const	DataFrame	pd_dataframe.h:23785	View
DataFrame aggregate(const std::map<std::string, std::string>& col_func_map, int axis = 0) const	DataFrame	pd_dataframe.h:23861	View
DataFrame aggregate(const std::map<std::string, std::vector<std::string>>& col_funcs_map, int axis = 0) const	DataFrame	pd_dataframe.h:23864	View
DataFrame apply(Func&& func, int axis = 0) const	DataFrame	pd_dataframe.h:20839	View
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	View
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	View
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	View
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	View
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	View
DataFrame applymap(Func&& func, const std::string& na_action = "") const	DataFrame	pd_dataframe.h:21859	View
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	View
DataFrameExpanding expanding(size_t min_periods = 1, int axis = 0, const std::string& method = "single") const	DataFrameExpanding	pd_dataframe.h:13055	View
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	View
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	View
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	View
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	View
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	View
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	View
DataFrame map(Func&& func, const std::string& na_action = "") const	DataFrame	pd_dataframe.h:21888	View
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	View
auto pipe(Func&& func, Args&&... args) const	auto	pd_dataframe.h:23921	View
auto pipe(Func&& func, Args&&... args)	auto	pd_dataframe.h:23930	View
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	View
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	View
DataFrame transform(Func&& func, int axis = 0) const	DataFrame	pd_dataframe.h:23357	View
DataFrame transform(const std::string& func_name, int axis = 0) const	DataFrame	pd_dataframe.h:23455	View
DataFrame transform(const std::vector<std::string>& func_names, int axis = 0) const	DataFrame	pd_dataframe.h:23525	View
DataFrame transform(const std::map<std::string, std::string>& col_func_map, int axis = 0) const	DataFrame	pd_dataframe.h:23565	View
DataFrame transform(const std::map<std::string, std::vector<std::string>>& col_funcs_map, int axis = 0) const	DataFrame	pd_dataframe.h:23614	View
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	View

Arithmetic

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	View
DataFrame add(double scalar) const	DataFrame	pd_dataframe.h:19529	View
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	View
void add_column(const std::string& name, const std::vector<T>& data)	void	pd_dataframe.h:6854	View
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	View
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	View
DataFrame add_prefix(const std::string& prefix, int axis = -1) const	DataFrame	pd_dataframe.h:6660	View
DataFrame add_suffix(const std::string& suffix, int axis = -1) const	DataFrame	pd_dataframe.h:6711	View
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	View
DataFrame div(double scalar) const	DataFrame	pd_dataframe.h:19631	View
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	View
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	View
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	View
DataFrame dot(const DataFrame& other) const	DataFrame	pd_dataframe.h:19264	View
Series<double> dot(const Series<T>& other) const	Series<double>	pd_dataframe.h:19323	View
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	View
DataFrame floordiv(double scalar) const	DataFrame	pd_dataframe.h:19687	View
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	View
DataFrame mod(double scalar) const	DataFrame	pd_dataframe.h:19707	View
DataFrame mul(const numpy::NDArray<numpy::float64>& rhs) const	DataFrame	pd_dataframe.h:3239	View
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	View
DataFrame mul(double scalar) const	DataFrame	pd_dataframe.h:19593	View
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	View
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	View
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	View
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	View
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	View
DataFrame pow(double exponent) const	DataFrame	pd_dataframe.h:19727	View
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	View
DataFrame radd(double scalar, double fill_value = std::numeric_limits<double>::quiet_NaN()) const	DataFrame	pd_dataframe.h:19756	View
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	View
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	View
DataFrame rdiv(double scalar, double fill_value = std::numeric_limits<double>::quiet_NaN()) const	DataFrame	pd_dataframe.h:19863	View
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	View
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	View
DataFrame rfloordiv(double scalar, double fill_value = std::numeric_limits<double>::quiet_NaN()) const	DataFrame	pd_dataframe.h:19915	View
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	View
DataFrame rmod(double scalar, double fill_value = std::numeric_limits<double>::quiet_NaN()) const	DataFrame	pd_dataframe.h:19943	View
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	View
DataFrame rmul(double scalar, double fill_value = std::numeric_limits<double>::quiet_NaN()) const	DataFrame	pd_dataframe.h:19828	View
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	View
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	View
DataFrame rpow(double base, double fill_value = std::numeric_limits<double>::quiet_NaN()) const	DataFrame	pd_dataframe.h:19971	View
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	View
DataFrame rsub(double scalar, double fill_value = std::numeric_limits<double>::quiet_NaN()) const	DataFrame	pd_dataframe.h:19792	View
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	View
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	View
DataFrame rtruediv(double scalar, double fill_value = std::numeric_limits<double>::quiet_NaN()) const	DataFrame	pd_dataframe.h:19891	View
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	View
DataFrame sub(double scalar) const	DataFrame	pd_dataframe.h:19555	View
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	View
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	View
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	View
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	View
DataFrame truediv(double scalar) const	DataFrame	pd_dataframe.h:19667	View

Comparison

Signature	Return Type	Location	Example
DataFrame compare( const DataFrame& other, bool keep_shape = false, bool keep_equal = false) const	DataFrame	pd_dataframe.h:26425	View
DataFrame eq(const DataFrame& other, int axis = 1, std::optional<int> level = std::nullopt) const	DataFrame	pd_dataframe.h:19373	View
DataFrame eq(const Series<numpy::float64>& other, int axis = 1) const	DataFrame	pd_dataframe.h:19446	View
DataFrame eq(double scalar) const	DataFrame	pd_dataframe.h:19466	View
bool equals(const DataFrame& other) const	bool	pd_dataframe.h:10199	View
DataFrame ge(const DataFrame& other, int axis = 1, std::optional<int> level = std::nullopt) const	DataFrame	pd_dataframe.h:19438	View
DataFrame ge(const Series<numpy::float64>& other, int axis = 1) const	DataFrame	pd_dataframe.h:19461	View
DataFrame ge(double scalar) const	DataFrame	pd_dataframe.h:19486	View
std::mt19937 gen(random_state == 0 ? std::random_device{}() : random_state)	std::mt19937	pd_dataframe.h:4063	View
DataFrame gt(const DataFrame& other, int axis = 1, std::optional<int> level = std::nullopt) const	DataFrame	pd_dataframe.h:19425	View
DataFrame gt(const Series<numpy::float64>& other, int axis = 1) const	DataFrame	pd_dataframe.h:19458	View
DataFrame gt(double scalar) const	DataFrame	pd_dataframe.h:19482	View
DataFrame le(const DataFrame& other, int axis = 1, std::optional<int> level = std::nullopt) const	DataFrame	pd_dataframe.h:19412	View
DataFrame le(const Series<numpy::float64>& other, int axis = 1) const	DataFrame	pd_dataframe.h:19455	View
DataFrame le(double scalar) const	DataFrame	pd_dataframe.h:19478	View
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	View
std::vector<std::vector<std::string>> levels(1 + n_inner)	std::vector<std::vector<std::string>>	pd_dataframe.h:17300	View
DataFrame lt(const DataFrame& other, int axis = 1, std::optional<int> level = std::nullopt) const	DataFrame	pd_dataframe.h:19399	View
DataFrame lt(const Series<numpy::float64>& other, int axis = 1) const	DataFrame	pd_dataframe.h:19452	View
DataFrame lt(double scalar) const	DataFrame	pd_dataframe.h:19474	View
DataFrame ne(const DataFrame& other, int axis = 1, std::optional<int> level = std::nullopt) const	DataFrame	pd_dataframe.h:19386	View
DataFrame ne(const Series<numpy::float64>& other, int axis = 1) const	DataFrame	pd_dataframe.h:19449	View
DataFrame ne(double scalar) const	DataFrame	pd_dataframe.h:19470	View
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

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	View
DataFrame sort_index(bool ascending) const	DataFrame	pd_dataframe.h:14908	View
DataFrame sort_index(int axis, bool ascending) const	DataFrame	pd_dataframe.h:14911	View
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	View
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	View
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	View
DataFrame sort_values(std::initializer_list<const char\*> by_init, bool ascending = true) const	DataFrame	pd_dataframe.h:14642	View
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	View
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	View
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	View
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	View

Reshaping

Signature	Return Type	Location	Example
DataFrame T() const	DataFrame	pd_dataframe.h:1270	View
DataFrame explode(const std::string& column, bool ignore_index = false) const	DataFrame	pd_dataframe.h:17984	View
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	View
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	View
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	View
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	View
DataFrame pivot(const std::string& columns, const std::string& index = "", const std::string& values = "") const	DataFrame	pd_dataframe.h:16099	View
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	View
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	View
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	View
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	View
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	View
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	View
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	View
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	View
DataFrame squeeze() const	DataFrame	pd_dataframe.h:18091	View
DataFrame stack(std::optional<int> level = std::nullopt, bool dropna = true, bool sort = true, bool future_stack = false) const	DataFrame	pd_dataframe.h:18216	View
DataFrame stack_levels(const std::vector<int>& levels, bool dropna = true) const	DataFrame	pd_dataframe.h:18469	View
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	View
DataFrame transpose() const	DataFrame	pd_dataframe.h:15126	View
DataFrame unstack(int level = -1, std::optional<double> fill_value = std::nullopt, bool sort = true) const	DataFrame	pd_dataframe.h:18759	View

Combining

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	View
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	View
DataFrame combine(const DataFrame& other, Func func, std::optional<double> fill_value = std::nullopt, bool overwrite = true) const	DataFrame	pd_dataframe.h:26038	View
DataFrame combine_first(const DataFrame& other) const	DataFrame	pd_dataframe.h:26266	View
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	View
static DataFrame concat(const std::vector<DataFrame>& frames, bool ignore_index)	static DataFrame	pd_dataframe.h:24720	View
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	View
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	View
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	View
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	View

Time Series

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	View
Series<numpy::float64> asof(const std::string& where, const std::vector<std::string>& subset = {}) const	Series<numpy::float64>	pd_dataframe.h:27059	View
DataFrame asof(const std::vector<std::string>& where, const std::vector<std::string>& subset = {}) const	DataFrame	pd_dataframe.h:27065	View
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	View
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	View
DataFrame diff(int periods = 1, int axis = 0) const	DataFrame	pd_dataframe.h:20536	View
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	View
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	View
DataFrame to_period(const std::string& freq = "", int axis = 0, bool copy = true) const	DataFrame	pd_dataframe.h:26800	View
DataFrame to_timestamp(const std::string& freq = "", const std::string& how = "start", int axis = 0, bool copy = true) const	DataFrame	pd_dataframe.h:26841	View
DataFrame tz_convert(const std::string& tz, int axis = 0, int level = -1, bool copy = true) const	DataFrame	pd_dataframe.h:26893	View
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	View

I/O

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	View
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	View
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	View
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	View

Conversion

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	View
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	View
astype(std::map<std::string, std::string>{{col_name, inner_norm}}, true, errors)		pd_dataframe.h:22160	View
DataFrame astype(const DtypeSpec& spec, bool copy = true, const std::string& errors = "raise") const	DataFrame	pd_dataframe.h:22219	View
bool bool_() const	bool	pd_dataframe.h:13217	View
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	View
DataFrame copy([[maybe_unused]] bool deep = true) const	DataFrame	pd_dataframe.h:27121	View
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	View

Iteration

Signature	Return Type	Location	Example
iterator begin()	iterator	pd_dataframe.h:1984	View
const_iterator begin() const	const_iterator	pd_dataframe.h:1988	View
iterator end()	iterator	pd_dataframe.h:2000	View
const_iterator end() const	const_iterator	pd_dataframe.h:2004	View
ItemsRange items() const	ItemsRange	pd_dataframe.h:2141	View
RowsRange iterrows() const	RowsRange	pd_dataframe.h:2282	View
TuplesRange itertuples(bool index = true, const std::string& name = "Pandas") const	TuplesRange	pd_dataframe.h:2507	View
const Index<std::string>& keys() const	const Index<std::string>&	pd_dataframe.h:2029	View

Set Operations

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	View
DataFrame isin(const std::vector<T>& values) const	DataFrame	pd_dataframe.h:8623	View
DataFrame isin(const std::map<std::string, std::vector<T>>& values) const	DataFrame	pd_dataframe.h:8693	View

Type Checking

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	View
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	View
static bool is_numeric_dtype_name(const std::string& dt)	static bool	pd_dataframe.h:11683

Other Methods

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	View
bool all(int axis = 0, bool bool_only = false, bool skipna = true) const override	bool	pd_dataframe.h:23947	View
Series<numpy::bool_> all_axis(int axis = 0, bool skipna = true) const	Series<numpy::bool_>	pd_dataframe.h:23984	View
bool all_columns_timedelta() const	bool	pd_dataframe.h:727	View
bool any(int axis = 0, bool bool_only = false, bool skipna = true) const override	bool	pd_dataframe.h:23964	View
Series<numpy::bool_> any_axis(int axis = 0, bool skipna = true) const	Series<numpy::bool_>	pd_dataframe.h:24114	View
DatetimeArray arr(dt_vals)	DatetimeArray	pd_dataframe.h:5517	View
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	View
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	View
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	View
std::vector<const IndexBase\*> axes() const override	std::vector<const IndexBase*>	pd_dataframe.h:1561	View
DataFrame broadcast_series_to_bool_dataframe(const Series<numpy::float64>& condition, int axis) const	DataFrame	pd_dataframe.h:8908	View
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	View
DataFrame ceil() const	DataFrame	pd_dataframe.h:20044	View
const_iterator cend() const	const_iterator	pd_dataframe.h:2008	View
ColumnAccessType classify_column_access(const std::string& key) const	ColumnAccessType	pd_dataframe.h:3311	View
std::vector<AggColumnInfo> classify_column_dtypes(bool skipna = true, bool numeric_only = false) const	std::vector<AggColumnInfo>	pd_dataframe.h:11715	View
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	View
std::unique_ptr<NDFrameBase> clone() const override	std::unique_ptr<NDFrameBase>	pd_dataframe.h:27129	View
Series<T>& col(const std::string& name)	Series<T>&	pd_dataframe.h:3247	View
const Series<T>& col(const std::string& name) const	const Series<T>&	pd_dataframe.h:3261	View
std::vector<std::vector<numpy::float64>> col_data(ncols())	std::vector<std::vector<numpy::float64>>	pd_dataframe.h:20170	View
std::vector<std::vector<numpy::float64>> col_data(ncols())	std::vector<std::vector<numpy::float64>>	pd_dataframe.h:20271	View
std::vector<std::vector<numpy::float64>> col_data(ncols())	std::vector<std::vector<numpy::float64>>	pd_dataframe.h:20384	View
std::vector<std::vector<numpy::float64>> col_data(ncols())	std::vector<std::vector<numpy::float64>>	pd_dataframe.h:20497	View
const Series<T>& column(const std::string& name) const { return col<T>(name)	const Series<T>&	pd_dataframe.h:3275	View
Series<T>& column(const std::string& name) { return col<T>(name)	Series<T>&	pd_dataframe.h:3277	View
const NDFrameBase& column_at(size_t idx) const	const NDFrameBase&	pd_dataframe.h:2518	View
std::string column_dtype_override(const std::string& col_name) const	std::string	pd_dataframe.h:1593	View
Series<numpy::float64> column_to_series_f64(size_t col_idx) const	Series<numpy::float64>	pd_dataframe.h:2527	View
Series<std::string> column_to_series_str(size_t col_idx) const	Series<std::string>	pd_dataframe.h:2547	View
std::unique_ptr<NDFrameBase> column_to_typed_series(size_t c) const	std::unique_ptr<NDFrameBase>	pd_dataframe.h:2641	View
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	View
const std::string& columns_index_dtype() const	const std::string&	pd_dataframe.h:1397	View
const std::vector<std::string>& columns_level_names() const	const std::vector<std::string>&	pd_dataframe.h:1530	View
const std::vector<std::vector<std::string>>& columns_levels() const	const std::vector<std::vector<std::string>>&	pd_dataframe.h:1516	View
void columns_name(const std::string& name) { set_columns_name(name)	void	pd_dataframe.h:1385	View
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	View
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	View
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	View
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	View
DataFrame cov(std::optional<int> min_periods = std::nullopt, int ddof = 1, bool numeric_only = false) const	DataFrame	pd_dataframe.h:14044	View
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	View
std::string dtype_name() const override	std::string	pd_dataframe.h:1234	View
std::string dtype_string(const std::string& col_name) const	std::string	pd_dataframe.h:1606	View
Series<std::string> dtypes() const	Series<std::string>	pd_dataframe.h:1568	View
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	View
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	View
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	View
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	View
std::ofstream file(path_or_buffer)	std::ofstream	pd_dataframe.h:13582	View
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	View
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	View
Flags& flags_mutable()	Flags&	pd_dataframe.h:1853
DataFrame floor() const	DataFrame	pd_dataframe.h:20037	View
static std::vector<std::string> format_percentile_labels(const std::vector<double>& pcts)	static std::vector<std::string>	pd_dataframe.h:10849	View
const std::string& frame_dtype_override() const	const std::string&	pd_dataframe.h:21721	View
bool has_column(const std::string& name) const	bool	pd_dataframe.h:3293	View
bool has_columns_level_categories() const	bool	pd_dataframe.h:1551
bool has_columns_levels() const	bool	pd_dataframe.h:1509	View
bool has_multiindex() const	bool	pd_dataframe.h:1344	View
bool hasnans() const override	bool	pd_dataframe.h:7445	View
const IndexBase& index() const override	const IndexBase&	pd_dataframe.h:1284	View
IndexBase& index_mutable()	IndexBase&	pd_dataframe.h:1291
void index_name(const std::string& name)	void	pd_dataframe.h:4797	View
std::optional<std::string> index_name() const	std::optional<std::string>	pd_dataframe.h:4800	View
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	View
std::istringstream iss(eval_expr)	std::istringstream	pd_dataframe.h:9819	View
std::istringstream iss(label)	std::istringstream	pd_dataframe.h:15557	View
std::istringstream iss(label)	std::istringstream	pd_dataframe.h:15592	View
std::istringstream iss(key)	std::istringstream	pd_dataframe.h:16565	View
std::istringstream iss(col_composite)	std::istringstream	pd_dataframe.h:16905	View
std::istringstream iss(idx_val)	std::istringstream	pd_dataframe.h:16936	View
std::istringstream iss(cn)	std::istringstream	pd_dataframe.h:17309	View
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	View
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	View
size_t ncols() const	size_t	pd_dataframe.h:1263	View
size_t ndim() const override	size_t	pd_dataframe.h:1215	View
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	View
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	View
int resolve_column_level(const std::string& level_name) const	int	pd_dataframe.h:18444	View
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	View
DataFrame round(int decimals = 0) const	DataFrame	pd_dataframe.h:19987	View
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	View
pandas::Series<T> s(casted)	pandas::Series<T>	pd_dataframe.h:21157	View
pandas::Series<T> s(casted)	pandas::Series<T>	pd_dataframe.h:21526	View
std::string s(buf)	std::string	pd_dataframe.h:27537	View
std::string s(buf)	std::string	pd_dataframe.h:27566	View
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	View
DataFrame select_multiindex_columns(const std::vector<std::string>& first_level_keys) const	DataFrame	pd_dataframe.h:2870	View
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	View
void set_column_cat_categories(const std::string& col_name, const std::vector<std::string>& cats)	void	pd_dataframe.h:1750	View
void set_column_cat_ordered(const std::string& col_name, bool ordered)	void	pd_dataframe.h:1760	View
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	View
void set_column_dtype(const std::string& col_name, const std::string& dtype_str)	void	pd_dataframe.h:1622	View
set_column_dtype(col_name, dt)		pd_dataframe.h:26410	View
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	View
void set_column_resolved( const std::string& name, const ValueKindRange& kinds, const pandas::DtypeOverride& override_ = {})	void	pd_dataframe.h:7061	View
void set_column_sparse_fill_value(const std::string& col_name, double fv, const std::string& inner_name = "")	void	pd_dataframe.h:1775	View
void set_columns_index_dtype(const std::string& dtype)	void	pd_dataframe.h:1390	View
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	View
void set_columns_name(const std::string& name)	void	pd_dataframe.h:1378	View
void set_datetime_index(const std::string& start, int periods, const std::string& freq)	void	pd_dataframe.h:4832	View
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	View
void set_flags(const Flags& flags, bool copy = true, bool allows_duplicate_labels = true) override	void	pd_dataframe.h:1863	View
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	View
void set_integer_index(std::initializer_list<int> values)	void	pd_dataframe.h:4776	View
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	View
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	View
void set_multiindex(MultiIndex mi)	void	pd_dataframe.h:1298	View
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	View
set_multiindex(MultiIndex::from_arrays<std::string>(arrays, names))		pd_dataframe.h:1328	View
void set_multiindex( const std::vector<std::vector<std::string>>& levels, const std::vector<std::optional<std::string>>& names = {})	void	pd_dataframe.h:1334	View
set_multiindex(MultiIndex::from_arrays<std::string>(levels, names))		pd_dataframe.h:1338	View
set_multiindex(std::move(mi))		pd_dataframe.h:4694	View
set_multiindex(MultiIndex::from_arrays<std::string>(arrays, names))		pd_dataframe.h:4817	View
set_multiindex(MultiIndex::from_arrays<std::string>(levels, names))		pd_dataframe.h:4823	View
void set_multiindex_names(const std::vector<std::optional<std::string>>& names)	void	pd_dataframe.h:1368	View
void set_nan_marker(const std::string& col_name, std::initializer_list<bool> mask_init)	void	pd_dataframe.h:4854	View
void set_option(const std::string& key, bool value)	void	pd_dataframe.h:1453	View
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	View
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	View
std::pair<size_t, size_t> shape_2d() const { return {nrows(), ncols()}	std::pair<size_t, size_t>	pd_dataframe.h:1210	View
size_t size() const override	size_t	pd_dataframe.h:1189	View
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	View
std::stringstream ss(to_split)	std::stringstream	pd_dataframe.h:18002	View
static int64_t timedelta_unit_factor(const std::string& dt)	static int64_t	pd_dataframe.h:7078
trim(inner)		pd_dataframe.h:22149	View
trim(fill_spelled)		pd_dataframe.h:22150	View
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	View
pandas::Timestamp ts(columns_index_[i])	pandas::Timestamp	pd_dataframe.h:1428	View
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	View

Code Examples

The following examples are extracted from the test suite.

DataFrame (pd_test_1_all.cpp:22011)

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

DataFrame (pd_test_1_all.cpp:22011)

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

DataFrame (pd_test_1_all.cpp:22011)

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

DataFrame (pd_test_1_all.cpp:22011)

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

DataFrame (pd_test_1_all.cpp:22011)

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

DataFrame (pd_test_1_all.cpp:22011)

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

DataFrame (pd_test_1_all.cpp:22011)

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

at (pd_test_1_all.cpp:6581)

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

at_time (pd_test_2_all.cpp:728)

        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

attrs (pd_test_1_all.cpp:16361)

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

attrs (pd_test_1_all.cpp:16361)

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

first (pd_test_1_all.cpp:11616)

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

first_valid_index (pd_test_1_all.cpp:20555)

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

get (pd_test_1_all.cpp:10290)

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

get_column_as_series (pd_test_5_all.cpp:123545)

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

get_column_as_string_series (pd_test_2_all.cpp:20370)

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

get_column_index (pd_test_1_all.cpp:22021)

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

get_dummies (pd_test_3_all.cpp:13545)

    }

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

get_duplicate_columns (pd_test_2_all.cpp:20352)

}

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;

get_optional (pd_test_1_all.cpp:6741)

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

get_series (pd_test_5_all.cpp:12970)

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

get_value_bool (pd_test_5_all.cpp:35197)

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

head (pd_test_1_all.cpp:6301)

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

iat (pd_test_1_all.cpp:22028)

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

idxmax (pd_test_1_all.cpp:23956)

        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 {

idxmin (pd_test_1_all.cpp:23956)

        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 {

iloc (pd_test_1_all.cpp:19149)

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

iloc (pd_test_1_all.cpp:19149)

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

iloc (pd_test_1_all.cpp:19149)

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

iloc_rows (pd_test_1_all.cpp:6315)

            }

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

iloc_rows (pd_test_1_all.cpp:6315)

            }

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

last (pd_test_1_all.cpp:11617)

        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;

last_valid_index (pd_test_1_all.cpp:20579)

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

loc (pd_test_3_all.cpp:10916)

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

loc (pd_test_3_all.cpp:10916)

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

loc (pd_test_3_all.cpp:10916)

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

loc (pd_test_3_all.cpp:10916)

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

loc (pd_test_3_all.cpp:10916)

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

mask (pd_test_1_all.cpp:9119)

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

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

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

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

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

nlargest (pd_test_1_all.cpp:6425)

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

nsmallest (pd_test_1_all.cpp:6432)

            }

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

query (pd_test_1_all.cpp:26418)

        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 {

sample (pd_test_3_all.cpp:207)

        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

sample (pd_test_3_all.cpp:207)

        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

sample (pd_test_3_all.cpp:207)

        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

sample (pd_test_3_all.cpp:207)

        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

sample (pd_test_3_all.cpp:207)

        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

sample_frac (pd_test_5_all.cpp:2387)

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

set_value_nan (pd_test_5_all.cpp:18478)

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

tail (pd_test_1_all.cpp:6308)

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

take (pd_test_1_all.cpp:5903)

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

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

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

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

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

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

where (pd_test_1_all.cpp:22018)

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

where (pd_test_1_all.cpp:22018)

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

where (pd_test_1_all.cpp:22018)

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

where_resolved (pd_test_5_all.cpp:91939)

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

xs (pd_test_2_all.cpp:18668)

        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

xs (pd_test_2_all.cpp:18668)

        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

xs (pd_test_2_all.cpp:18668)

        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

xs_level (pd_test_5_all.cpp:12967)

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

assign (pd_test_1_all.cpp:6653)

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

assign (pd_test_1_all.cpp:6653)

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

assign (pd_test_1_all.cpp:6653)

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

drop (pd_test_1_all.cpp:6558)

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

drop_duplicates (pd_test_1_all.cpp:6639)

                }
            }

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

droplevel (pd_test_1_all.cpp:14428)

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

droplevel (pd_test_1_all.cpp:14428)

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

droplevel (pd_test_1_all.cpp:14428)

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

droplevel (pd_test_1_all.cpp:14428)

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

dropna (pd_test_1_all.cpp:531)

        }

        // Test isna array
        numpy::NDArray<numpy::bool_> na_mask = arr.isna();
        if (na_mask.getSize() != 4) {
            std::cout << "  [FAIL] : in pd_test_categorical_array_na_handling() : isna size != 4" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_na_handling failed: isna size != 4");
        }

        // Test dropna
        pandas::CategoricalArray dropped = arr.dropna();
        if (dropped.size() != 2) {
            std::cout << "  [FAIL] : in pd_test_categorical_array_na_handling() : dropna size != 2" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_na_handling failed: dropna size != 2");
        }

        // Test fillna (fill with existing category)
        pandas::CategoricalArray filled = arr.fillna("a");  // 'a' is in categories
        if (filled.has_na()) {
            std::cout << "  [FAIL] : in pd_test_categorical_array_na_handling() : fillna should have no NA" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_na_handling failed: fillna should have no NA");

dropna (pd_test_1_all.cpp:531)

        }

        // Test isna array
        numpy::NDArray<numpy::bool_> na_mask = arr.isna();
        if (na_mask.getSize() != 4) {
            std::cout << "  [FAIL] : in pd_test_categorical_array_na_handling() : isna size != 4" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_na_handling failed: isna size != 4");
        }

        // Test dropna
        pandas::CategoricalArray dropped = arr.dropna();
        if (dropped.size() != 2) {
            std::cout << "  [FAIL] : in pd_test_categorical_array_na_handling() : dropna size != 2" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_na_handling failed: dropna size != 2");
        }

        // Test fillna (fill with existing category)
        pandas::CategoricalArray filled = arr.fillna("a");  // 'a' is in categories
        if (filled.has_na()) {
            std::cout << "  [FAIL] : in pd_test_categorical_array_na_handling() : fillna should have no NA" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_na_handling failed: fillna should have no NA");

insert (pd_test_1_all.cpp:12028)

            }

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

insert (pd_test_1_all.cpp:12028)

            }

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

insert (pd_test_1_all.cpp:12028)

            }

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

insert (pd_test_1_all.cpp:12028)

            }

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

insert (pd_test_1_all.cpp:12028)

            }

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

insert (pd_test_1_all.cpp:12028)

            }

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

insert (pd_test_1_all.cpp:12028)

            }

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

insert (pd_test_1_all.cpp:12028)

            }

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

insert (pd_test_1_all.cpp:12028)

            }

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

reindex (pd_test_1_all.cpp:6708)

                }
            }

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

reindex (pd_test_1_all.cpp:6708)

                }
            }

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

reindex (pd_test_1_all.cpp:6708)

                }
            }

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

reindex (pd_test_1_all.cpp:6708)

                }
            }

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

reindex (pd_test_1_all.cpp:6708)

                }
            }

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

reindex_like (pd_test_1_all.cpp:6777)

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

        // =====================================================================

reindex_with_indexer (pd_test_5_all.cpp:40388)

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

reindex_with_spec (pd_test_5_all.cpp:54746)

}

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

rename (pd_test_1_all.cpp:5816)

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

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

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

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

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

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

rename (pd_test_1_all.cpp:5816)

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

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

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

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

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

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

rename_axis (pd_test_1_all.cpp:6760)

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

rename_axis (pd_test_1_all.cpp:6760)

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

rename_columns (pd_test_1_all.cpp:6565)

            }

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

rename_result (pd_test_5_all.cpp:50613)

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

reorder_levels (pd_test_1_all.cpp:14495)

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

reorder_levels (pd_test_1_all.cpp:14495)

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

reorder_levels (pd_test_1_all.cpp:14495)

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

reorder_levels (pd_test_1_all.cpp:14495)

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

replace (pd_test_1_all.cpp:6623)

                }
            }

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

replace (pd_test_1_all.cpp:6623)

                }
            }

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

replace (pd_test_1_all.cpp:6623)

                }
            }

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

replace (pd_test_1_all.cpp:6623)

                }
            }

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

replace (pd_test_1_all.cpp:6623)

                }
            }

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

reset_index (pd_test_3_all.cpp:1618)

    }

    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

set_axis (pd_test_1_all.cpp:6673)

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

set_index (pd_test_1_all.cpp:20318)

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

set_index (pd_test_1_all.cpp:20318)

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

set_index (pd_test_1_all.cpp:20318)

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

set_index (pd_test_1_all.cpp:20318)

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

set_index (pd_test_1_all.cpp:20318)

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

set_index (pd_test_1_all.cpp:20318)

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

set_index (pd_test_1_all.cpp:20318)

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

set_index (pd_test_1_all.cpp:20318)

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

set_index (pd_test_1_all.cpp:20318)

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

set_index (pd_test_1_all.cpp:20318)

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

set_index (pd_test_1_all.cpp:20318)

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

set_index (pd_test_1_all.cpp:20318)

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

set_index (pd_test_1_all.cpp:20318)

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

set_index (pd_test_1_all.cpp:20318)

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

set_index (pd_test_1_all.cpp:20318)

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

set_index (pd_test_1_all.cpp:20318)

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

set_index (pd_test_1_all.cpp:20318)

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

set_index (pd_test_1_all.cpp:20318)

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

set_index (pd_test_1_all.cpp:20318)

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

set_index (pd_test_1_all.cpp:20318)

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

set_index (pd_test_1_all.cpp:20318)

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

set_index (pd_test_1_all.cpp:20318)

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

set_index_col (pd_test_3_all.cpp:828)

    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

set_index_col (pd_test_3_all.cpp:828)

    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

set_index_col (pd_test_3_all.cpp:828)

    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

set_index_from_column (pd_test_3_all.cpp:1343)

        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

set_index_from_list (pd_test_3_all.cpp:1236)

}

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

set_index_from_list (pd_test_3_all.cpp:1236)

}

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

set_index_from_list (pd_test_3_all.cpp:1236)

}

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

set_index_from_list (pd_test_3_all.cpp:1236)

}

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

set_index_from_list (pd_test_3_all.cpp:1236)

}

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

set_index_from_list (pd_test_3_all.cpp:1236)

}

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

set_index_from_list (pd_test_3_all.cpp:1236)

}

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

set_index_from_list (pd_test_3_all.cpp:1236)

}

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

set_index_from_list (pd_test_3_all.cpp:1236)

}

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

set_index_from_list (pd_test_3_all.cpp:1236)

}

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

set_index_from_strings (pd_test_3_all.cpp:1284)

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

set_index_from_strings (pd_test_3_all.cpp:1284)

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

set_index_name (pd_test_2_all.cpp:20842)

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

set_index_name (pd_test_2_all.cpp:20842)

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

swaplevel (pd_test_1_all.cpp:14461)

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

swaplevel (pd_test_1_all.cpp:14461)

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

swaplevel (pd_test_1_all.cpp:14461)

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

update (pd_test_1_all.cpp:13945)

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

backfill (pd_test_3_all.cpp:2645)

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

bfill (pd_test_1_all.cpp:23603)

        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

ffill (pd_test_1_all.cpp:23603)

        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

fillna (pd_test_1_all.cpp:537)

            throw std::runtime_error("pd_test_categorical_array_na_handling failed: isna size != 4");
        }

        // Test dropna
        pandas::CategoricalArray dropped = arr.dropna();
        if (dropped.size() != 2) {
            std::cout << "  [FAIL] : in pd_test_categorical_array_na_handling() : dropna size != 2" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_na_handling failed: dropna size != 2");
        }

        // Test fillna (fill with existing category)
        pandas::CategoricalArray filled = arr.fillna("a");  // 'a' is in categories
        if (filled.has_na()) {
            std::cout << "  [FAIL] : in pd_test_categorical_array_na_handling() : fillna should have no NA" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_na_handling failed: fillna should have no NA");
        }

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

    void pd_test_categorical_array_add_categories() {

fillna (pd_test_1_all.cpp:537)

            throw std::runtime_error("pd_test_categorical_array_na_handling failed: isna size != 4");
        }

        // Test dropna
        pandas::CategoricalArray dropped = arr.dropna();
        if (dropped.size() != 2) {
            std::cout << "  [FAIL] : in pd_test_categorical_array_na_handling() : dropna size != 2" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_na_handling failed: dropna size != 2");
        }

        // Test fillna (fill with existing category)
        pandas::CategoricalArray filled = arr.fillna("a");  // 'a' is in categories
        if (filled.has_na()) {
            std::cout << "  [FAIL] : in pd_test_categorical_array_na_handling() : fillna should have no NA" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_na_handling failed: fillna should have no NA");
        }

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

    void pd_test_categorical_array_add_categories() {

fillna (pd_test_1_all.cpp:537)

            throw std::runtime_error("pd_test_categorical_array_na_handling failed: isna size != 4");
        }

        // Test dropna
        pandas::CategoricalArray dropped = arr.dropna();
        if (dropped.size() != 2) {
            std::cout << "  [FAIL] : in pd_test_categorical_array_na_handling() : dropna size != 2" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_na_handling failed: dropna size != 2");
        }

        // Test fillna (fill with existing category)
        pandas::CategoricalArray filled = arr.fillna("a");  // 'a' is in categories
        if (filled.has_na()) {
            std::cout << "  [FAIL] : in pd_test_categorical_array_na_handling() : fillna should have no NA" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_na_handling failed: fillna should have no NA");
        }

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

    void pd_test_categorical_array_add_categories() {

fillna (pd_test_1_all.cpp:537)

            throw std::runtime_error("pd_test_categorical_array_na_handling failed: isna size != 4");
        }

        // Test dropna
        pandas::CategoricalArray dropped = arr.dropna();
        if (dropped.size() != 2) {
            std::cout << "  [FAIL] : in pd_test_categorical_array_na_handling() : dropna size != 2" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_na_handling failed: dropna size != 2");
        }

        // Test fillna (fill with existing category)
        pandas::CategoricalArray filled = arr.fillna("a");  // 'a' is in categories
        if (filled.has_na()) {
            std::cout << "  [FAIL] : in pd_test_categorical_array_na_handling() : fillna should have no NA" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_na_handling failed: fillna should have no NA");
        }

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

    void pd_test_categorical_array_add_categories() {

fillna (pd_test_1_all.cpp:537)

            throw std::runtime_error("pd_test_categorical_array_na_handling failed: isna size != 4");
        }

        // Test dropna
        pandas::CategoricalArray dropped = arr.dropna();
        if (dropped.size() != 2) {
            std::cout << "  [FAIL] : in pd_test_categorical_array_na_handling() : dropna size != 2" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_na_handling failed: dropna size != 2");
        }

        // Test fillna (fill with existing category)
        pandas::CategoricalArray filled = arr.fillna("a");  // 'a' is in categories
        if (filled.has_na()) {
            std::cout << "  [FAIL] : in pd_test_categorical_array_na_handling() : fillna should have no NA" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_na_handling failed: fillna should have no NA");
        }

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

    void pd_test_categorical_array_add_categories() {

interpolate (pd_test_1_all.cpp:24365)

        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

isna (pd_test_1_all.cpp:524)

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

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

        // Test isna array
        numpy::NDArray<numpy::bool_> na_mask = arr.isna();
        if (na_mask.getSize() != 4) {
            std::cout << "  [FAIL] : in pd_test_categorical_array_na_handling() : isna size != 4" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_na_handling failed: isna size != 4");
        }

        // Test dropna
        pandas::CategoricalArray dropped = arr.dropna();
        if (dropped.size() != 2) {
            std::cout << "  [FAIL] : in pd_test_categorical_array_na_handling() : dropna size != 2" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_na_handling failed: dropna size != 2");

isna_frame (pd_test_3_all.cpp:10770)

        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

isnull (pd_test_3_all.cpp:671)

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

isnull_frame (pd_test_5_all.cpp:34434)

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

notna (pd_test_1_all.cpp:6595)

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

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

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

notna_frame (pd_test_5_all.cpp:34411)

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

notnull (pd_test_3_all.cpp:665)

    }

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

notnull_frame (pd_test_5_all.cpp:34449)

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

pad (pd_test_3_all.cpp:1771)

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

count (pd_test_1_all.cpp:66)

        if (arr.is_na(0)) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_na_handling() : is_na(0) should be false" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_na_handling failed: is_na(0) should be false");
        }

        if (!arr.has_na()) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_na_handling() : has_na() should be true" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_na_handling failed: has_na() should be true");
        }

        if (arr.count() != 2) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_na_handling() : count() should be 2" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_na_handling failed: count() should be 2");
        }

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

    void pd_test_boolean_array_kleene_and() {
        std::cout << "========= BooleanArray: Kleene AND ======================= ";

count (pd_test_1_all.cpp:66)

        if (arr.is_na(0)) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_na_handling() : is_na(0) should be false" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_na_handling failed: is_na(0) should be false");
        }

        if (!arr.has_na()) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_na_handling() : has_na() should be true" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_na_handling failed: has_na() should be true");
        }

        if (arr.count() != 2) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_na_handling() : count() should be 2" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_na_handling failed: count() should be 2");
        }

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

    void pd_test_boolean_array_kleene_and() {
        std::cout << "========= BooleanArray: Kleene AND ======================= ";

count_cols (pd_test_1_all.cpp:6386)

            }

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

cummax (pd_test_1_all.cpp:5152)

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

cummin (pd_test_1_all.cpp:5143)

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

cumprod (pd_test_1_all.cpp:5134)

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

cumsum (pd_test_1_all.cpp:5125)

        }

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

describe (pd_test_2_all.cpp:19793)

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

describe_full (pd_test_2_all.cpp:19758)

              << (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"

kurt (pd_test_1_all.cpp:4599)

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

kurt_cols (pd_test_1_all.cpp:4786)

                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

kurtosis (pd_test_1_all.cpp:4607)

            }

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

max (pd_test_1_all.cpp:771)

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

max_cols (pd_test_1_all.cpp:6379)

            }

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

mean (pd_test_1_all.cpp:282)

            std::optional<bool>(true),
            std::optional<bool>(true)
        });

        auto s = arr.sum();
        if (!s.has_value() || s.value() != 3) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_reductions() : sum should be 3" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_reductions failed: sum");
        }

        auto m = arr.mean();
        if (!m.has_value() || std::abs(m.value() - 0.75) > 0.001) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_reductions() : mean should be 0.75" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_reductions failed: mean");
        }

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

    void pd_test_boolean_array_dtype() {
        std::cout << "========= BooleanArray: dtype ======================= ";

mean_cols (pd_test_1_all.cpp:6364)

            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;

median (pd_test_1_all.cpp:20910)

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

median_cols (pd_test_1_all.cpp:24860)

        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 {

min (pd_test_1_all.cpp:764)

    }

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

min_cols (pd_test_1_all.cpp:6372)

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

mode (pd_test_1_all.cpp:4569)

                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

nunique (pd_test_1_all.cpp:10604)

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

nunique_cols (pd_test_1_all.cpp:25375)

        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 {

prod (pd_test_1_all.cpp:26082)

        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 {

prod_cols (pd_test_1_all.cpp:26082)

        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 {

product (pd_test_3_all.cpp:2584)

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

quantile (pd_test_1_all.cpp:4540)

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

quantile_cols (pd_test_1_all.cpp:4753)

        }

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

sem (pd_test_1_all.cpp:4525)

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

skew (pd_test_1_all.cpp:4592)

                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;

skew_cols (pd_test_1_all.cpp:4772)

            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;

std (pd_test_1_all.cpp:4526)

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

std_ (pd_test_1_all.cpp:20752)

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

std_ (pd_test_1_all.cpp:20752)

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

std_cols (pd_test_plan_coverage_gaps.cpp:130)

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

sum (pd_test_1_all.cpp:276)

        }

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

sum_cols (pd_test_1_all.cpp:6351)

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

value_counts (pd_test_1_all.cpp:865)

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

var (pd_test_1_all.cpp:20890)

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

agg (pd_test_1_all.cpp:11100)

        }

        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;

agg (pd_test_1_all.cpp:11100)

        }

        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;

agg (pd_test_1_all.cpp:11100)

        }

        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;

agg (pd_test_1_all.cpp:11100)

        }

        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;

agg_to_series (pd_test_2_all.cpp:19154)

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

agg_to_series (pd_test_2_all.cpp:19154)

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

aggregate (pd_test_1_all.cpp:11139)

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

aggregate (pd_test_1_all.cpp:11139)

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

aggregate (pd_test_1_all.cpp:11139)

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

aggregate (pd_test_1_all.cpp:11139)

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

apply (pd_test_1_all.cpp:11244)

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

apply (pd_test_1_all.cpp:11244)

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

apply (pd_test_1_all.cpp:11244)

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

apply_callable (pd_test_5_all.cpp:86745)

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

apply_resolved_typed (pd_test_5_all.cpp:98141)

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

apply_with_args (pd_test_3_all.cpp:16993)

        }
    }

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

applymap (pd_test_1_all.cpp:11194)

        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;

ewm (pd_test_3_all.cpp:2961)

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

expanding (pd_test_1_all.cpp:20770)

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

groupby (pd_test_1_all.cpp:11495)

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

groupby (pd_test_1_all.cpp:11495)

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

groupby (pd_test_1_all.cpp:11495)

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

groupby (pd_test_1_all.cpp:11495)

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

groupby (pd_test_1_all.cpp:11495)

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

groupby (pd_test_1_all.cpp:11495)

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

map (pd_test_1_all.cpp:5839)

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

map_callable_resolved (pd_test_5_all.cpp:98564)

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

pipe (pd_test_1_all.cpp:11164)

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

pipe (pd_test_1_all.cpp:11164)

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

resample (pd_test_1_all.cpp:20321)

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

rolling (pd_test_1_all.cpp:20667)

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

transform (pd_test_1_all.cpp:11071)

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

transform (pd_test_1_all.cpp:11071)

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

transform (pd_test_1_all.cpp:11071)

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

transform (pd_test_1_all.cpp:11071)

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

transform (pd_test_1_all.cpp:11071)

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

transform_callable_resolved (pd_test_5_all.cpp:98570)

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

add (pd_test_1_all.cpp:4844)

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;

add (pd_test_1_all.cpp:4844)

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;

add (pd_test_1_all.cpp:4844)

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;

add_column (pd_test_1_all.cpp:6540)

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

add_column_nullable (pd_test_3_all.cpp:953)

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

add_column_with_dtype_override (pd_test_2_all.cpp:19266)

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

add_prefix (pd_test_2_all.cpp: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

add_suffix (pd_test_2_all.cpp: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

div (pd_test_1_all.cpp:4865)

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

div (pd_test_1_all.cpp:4865)

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

div (pd_test_1_all.cpp:4865)

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

divide (pd_test_3_all.cpp:555)

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

divide (pd_test_3_all.cpp:555)

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

dot (pd_test_1_all.cpp:22594)

        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 {

dot (pd_test_1_all.cpp:22594)

        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 {

floordiv (pd_test_1_all.cpp:4881)

            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;

floordiv (pd_test_1_all.cpp:4881)

            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;

mod (pd_test_1_all.cpp:4888)

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

mod (pd_test_1_all.cpp:4888)

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

mul (pd_test_1_all.cpp:4858)

                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;

mul (pd_test_1_all.cpp:4858)

                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;

mul (pd_test_1_all.cpp:4858)

                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;

mul (pd_test_1_all.cpp:4858)

                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;

multiindex (pd_test_1_all.cpp:27024)

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

multiply (pd_test_3_all.cpp:543)

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

multiply (pd_test_3_all.cpp:543)

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

pow (pd_test_1_all.cpp:4911)

            }

            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

pow (pd_test_1_all.cpp:4911)

            }

            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

radd (pd_test_2_all.cpp:7440)

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

radd (pd_test_2_all.cpp:7440)

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

radd (pd_test_2_all.cpp:7440)

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

rdiv (pd_test_2_all.cpp:7713)

            }

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

rdiv (pd_test_2_all.cpp:7713)

            }

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

rdiv (pd_test_2_all.cpp:7713)

            }

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

rfloordiv (pd_test_2_all.cpp:7909)

            }

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

rfloordiv (pd_test_2_all.cpp:7909)

            }

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

rmod (pd_test_2_all.cpp:8121)

            }

            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;

rmod (pd_test_2_all.cpp:8121)

            }

            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;

rmul (pd_test_2_all.cpp:7591)

            }

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

rmul (pd_test_2_all.cpp:7591)

            }

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

rmul (pd_test_2_all.cpp:7591)

            }

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

rpow (pd_test_2_all.cpp:8327)

            }

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

rpow (pd_test_2_all.cpp:8327)

            }

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

rsub (pd_test_2_all.cpp:7520)

            }

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

rsub (pd_test_2_all.cpp:7520)

            }

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

rsub (pd_test_2_all.cpp:7520)

            }

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

rtruediv (pd_test_2_all.cpp:7795)

            }

            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;

rtruediv (pd_test_2_all.cpp:7795)

            }

            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;

sub (pd_test_1_all.cpp:4851)

            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;

sub (pd_test_1_all.cpp:4851)

            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;

sub (pd_test_1_all.cpp:4851)

            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;

subtract (pd_test_3_all.cpp:531)

// ============================================================================

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

subtract (pd_test_3_all.cpp:531)

// ============================================================================

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

truediv (pd_test_3_all.cpp:524)

    }

    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;

truediv (pd_test_3_all.cpp:524)

    }

    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;

compare (pd_test_1_all.cpp:13989)

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

eq (pd_test_2_all.cpp:19680)

    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;

eq (pd_test_2_all.cpp:19680)

    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;

eq (pd_test_2_all.cpp:19680)

    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;

equals (pd_test_1_all.cpp:5866)

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

ge (pd_test_3_all.cpp:303)

    }

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

ge (pd_test_3_all.cpp:303)

    }

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

ge (pd_test_3_all.cpp:303)

    }

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

gen (pd_test_5_all.cpp:35852)

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

gt (pd_test_3_all.cpp:344)

        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;

gt (pd_test_3_all.cpp:344)

        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;

gt (pd_test_3_all.cpp:344)

        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;

le (pd_test_3_all.cpp:337)

        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;

le (pd_test_3_all.cpp:337)

        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;

le (pd_test_3_all.cpp:337)

        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;

levels (pd_test_2_all.cpp:9787)

            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" &&

levels (pd_test_2_all.cpp:9787)

            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" &&

lt (pd_test_3_all.cpp:330)

        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;

lt (pd_test_3_all.cpp:330)

        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;

lt (pd_test_3_all.cpp:330)

        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;

ne (pd_test_3_all.cpp:323)

    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;

ne (pd_test_3_all.cpp:323)

    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;

ne (pd_test_3_all.cpp:323)

    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;

rank (pd_test_1_all.cpp:6451)

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

sort_index (pd_test_3_all.cpp:583)

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

sort_index (pd_test_3_all.cpp:583)

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

sort_index (pd_test_3_all.cpp:583)

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

sort_values (pd_test_1_all.cpp:6408)

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

sort_values (pd_test_1_all.cpp:6408)

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

sort_values (pd_test_1_all.cpp:6408)

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

sort_values (pd_test_1_all.cpp:6408)

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

sort_values (pd_test_1_all.cpp:6408)

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

sort_values (pd_test_1_all.cpp:6408)

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

sort_values_by_transformed (pd_test_2_all.cpp:22232)

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

T (pd_test_1_all.cpp:128)

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

explode (pd_test_1_all.cpp:6868)

                }
            }

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

melt (pd_test_1_all.cpp:6846)

            }

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

melt (pd_test_1_all.cpp:6846)

            }

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

melt (pd_test_1_all.cpp:6846)

            }

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

melt (pd_test_1_all.cpp:6846)

            }

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

pivot (pd_test_1_all.cpp:6827)

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

pivot_table (pd_test_1_all.cpp:25691)

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

pivot_table (pd_test_1_all.cpp:25691)

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

pivot_table (pd_test_1_all.cpp:25691)

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

pivot_table (pd_test_1_all.cpp:25691)

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

pivot_table (pd_test_1_all.cpp:25691)

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

pivot_table_multi_agg (pd_test_2_all.cpp:21310)

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

pivot_table_with_margins (pd_test_3_all.cpp:7480)

    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

pivot_table_with_margins (pd_test_3_all.cpp:7480)

    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

squeeze (pd_test_1_all.cpp:6881)

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

stack (pd_test_1_all.cpp:6892)

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

stack_levels (pd_test_3_all.cpp:28695)

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

swapaxes (pd_test_3_all.cpp:2276)

    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;

transpose (pd_test_1_all.cpp:16648)

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

unstack (pd_test_3_all.cpp:1739)

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

align (pd_test_1_all.cpp:14035)

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

align_series (pd_test_2_all.cpp:21152)

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

combine (pd_test_2_all.cpp:1700)

        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 {

combine_first (pd_test_1_all.cpp:13889)

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

concat (pd_test_1_all.cpp:17717)

}

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

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

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

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

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

concat (pd_test_1_all.cpp:17717)

}

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

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

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

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

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

join (pd_test_1_all.cpp:12353)

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

merge (pd_test_1_all.cpp:13639)

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

merge (pd_test_1_all.cpp:13639)

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

merge (pd_test_1_all.cpp:13639)

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

asfreq (pd_test_1_all.cpp:2869)

        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

asof (pd_test_2_all.cpp:366)

        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 {

asof (pd_test_2_all.cpp:366)

        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 {

between_time (pd_test_2_all.cpp:1154)

        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

between_time (pd_test_2_all.cpp:1154)

        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

diff (pd_test_1_all.cpp:5171)

        }

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

pct_change (pd_test_1_all.cpp:4621)

                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;

shift (pd_test_1_all.cpp:5188)

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

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

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

to_period (pd_test_2_all.cpp:14554)

        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

to_timestamp (pd_test_1_all.cpp:2830)

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

tz_convert (pd_test_2_all.cpp:17874)

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

tz_localize (pd_test_1_all.cpp:1431)

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

to_csv (pd_test_1_all.cpp:6967)

        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

to_gbq (pd_test_3_all.cpp:3012)

        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 {

to_json (pd_test_1_all.cpp:6978)

            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

to_xml (pd_test_3_all.cpp:2983)

    }

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

astype (pd_test_1_all.cpp:21292)

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

astype (pd_test_1_all.cpp:21292)

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

astype (pd_test_1_all.cpp:21292)

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

astype (pd_test_1_all.cpp:21292)

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

bool_ (pd_test_1_all.cpp:9120)

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

convert_dtypes (pd_test_1_all.cpp:27317)

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

copy (pd_test_1_all.cpp:5798)

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

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

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

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

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

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

infer_objects (pd_test_1_all.cpp:27595)

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

begin (pd_test_1_all.cpp:457)

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

begin (pd_test_1_all.cpp:457)

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

end (pd_test_1_all.cpp:457)

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

end (pd_test_1_all.cpp:457)

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

items (pd_test_1_all.cpp:16554)

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

iterrows (pd_test_2_all.cpp:6498)

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

itertuples (pd_test_2_all.cpp:6774)

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

keys (pd_test_1_all.cpp:16319)

            }

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

duplicated (pd_test_1_all.cpp:10583)

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

isin (pd_test_1_all.cpp:5938)

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

isin (pd_test_1_all.cpp:5938)

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

is_na_at (pd_test_5_all.cpp:35205)

    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",

is_numeric_dtype (pd_test_2_all.cpp:19939)

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

abs (pd_test_1_all.cpp:283)

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

all (pd_test_1_all.cpp:247)

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

all_axis (pd_test_1_all.cpp:22302)

        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 {

all_columns_timedelta (pd_test_5_all.cpp:64597)

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

any (pd_test_1_all.cpp:226)

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

any_axis (pd_test_1_all.cpp:22302)

        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 {

arr (pd_test_1_all.cpp:45)

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

assemble_multi_series_dataframe (pd_test_3_all.cpp:29020)

}

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

assemble_scalar_series (pd_test_3_all.cpp:28979)

        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;

assemble_scalar_string_series (pd_test_3_all.cpp:29004)

    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;

axes (pd_test_1_all.cpp:16602)

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

broadcast_series_to_bool_dataframe (pd_test_3_all.cpp:28228)

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

cbegin (pd_test_2_all.cpp:6185)

            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;

ceil (pd_test_1_all.cpp:4949)

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

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

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

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

cend (pd_test_2_all.cpp:6185)

            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;

classify_column_access (pd_test_2_all.cpp:20218)

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

classify_column_dtypes (pd_test_2_all.cpp:19207)

              << (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"

clip (pd_test_1_all.cpp:5099)

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

clone (pd_test_1_all.cpp:5776)

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

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

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

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

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

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

col (pd_test_1_all.cpp:6625)

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

col (pd_test_1_all.cpp:6625)

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

col_data (pd_test_4_all.cpp:5286)

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

col_data (pd_test_4_all.cpp:5286)

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

col_data (pd_test_4_all.cpp:5286)

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

col_data (pd_test_4_all.cpp:5286)

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

column (pd_test_1_all.cpp:22039)

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

column (pd_test_1_all.cpp:22039)

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

column_at (pd_test_3_all.cpp:23814)

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

column_dtype_override (pd_test_2_all.cpp:20590)

    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;

column_to_series_f64 (pd_test_2_all.cpp:19385)

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

column_to_series_str (pd_test_2_all.cpp:19385)

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

column_to_typed_series (pd_test_3_all.cpp:28921)

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

columns (pd_test_1_all.cpp:6220)

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

columns_index_dtype (pd_test_3_all.cpp:23051)

    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;

columns_level_names (pd_test_5_all.cpp:33080)

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

columns_levels (pd_test_3_all.cpp:23276)

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

columns_name (pd_test_3_all.cpp:10809)

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

compute_string_column_stats (pd_test_2_all.cpp:19759)

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

corr (pd_test_1_all.cpp:4655)

        }

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

corrwith (pd_test_2_all.cpp:2013)

        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

corrwith (pd_test_2_all.cpp:2013)

        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

cov (pd_test_1_all.cpp:4690)

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

dt (pd_test_3_all.cpp:18239)

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

dtype_name (pd_test_1_all.cpp:10104)

}

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

dtype_string (pd_test_5_all.cpp:93010)

    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,

dtypes (pd_test_1_all.cpp:6226)

                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

empty (pd_test_1_all.cpp:941)

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

namespace dataframe_tests {

namespace dataframe_tests_config {

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

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

eval (pd_test_2_all.cpp:2722)

        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"

extract_column_as_numeric_series (pd_test_2_all.cpp:20328)

// =========================================================================

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

extract_row_typed (pd_test_3_all.cpp:28887)

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

file (pd_test_2_all.cpp:3463)

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

filter (pd_test_3_all.cpp:2805)

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

flags (pd_test_1_all.cpp:16397)

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

floor (pd_test_1_all.cpp:4942)

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

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

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

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

format_percentile_labels (pd_test_2_all.cpp:19921)

}

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

frame_dtype_override (pd_test_5_all.cpp:146164)

    };
}

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

has_column (pd_test_1_all.cpp:6256)

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

has_columns_levels (pd_test_2_all.cpp:21382)

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

has_multiindex (pd_test_1_all.cpp:27019)

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

hasnans (pd_test_1_all.cpp:5363)

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

index (pd_test_1_all.cpp:6680)

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

index_name (pd_test_3_all.cpp:1290)

        }

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

index_name (pd_test_3_all.cpp:1290)

        }

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

isetitem (pd_test_3_all.cpp:2882)

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

iss (pd_test_2_all.cpp:10348)

            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;

iss (pd_test_2_all.cpp:10348)

            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;

iss (pd_test_2_all.cpp:10348)

            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;

iss (pd_test_2_all.cpp:10348)

            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;

iss (pd_test_2_all.cpp:10348)

            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;

iss (pd_test_2_all.cpp:10348)

            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;

iss (pd_test_2_all.cpp:10348)

            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;

match_multiindex_columns (pd_test_3_all.cpp:29247)

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

nbytes (pd_test_1_all.cpp:6214)

            }

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

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

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

ncols (pd_test_1_all.cpp:4658)

            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;

ndim (pd_test_1_all.cpp:6195)

            pandas::DataFrame df(data);

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

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

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

nrows (pd_test_1_all.cpp:4658)

            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;

resolve_column_level (pd_test_3_all.cpp:28773)

    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;

resolve_column_level (pd_test_3_all.cpp:28773)

    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;

resolve_sort_columns_multiindex (pd_test_2_all.cpp:22232)

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

round (pd_test_1_all.cpp:1688)

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

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

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

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

row_values_f64 (pd_test_2_all.cpp:19385)

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

s (pd_test_1_all.cpp:4524)

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

s (pd_test_1_all.cpp:4524)

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

s (pd_test_1_all.cpp:4524)

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

s (pd_test_1_all.cpp:4524)

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

select_dtypes (pd_test_1_all.cpp:7044)

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

select_multiindex_columns (pd_test_3_all.cpp:29220)

    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;

set_column (pd_test_3_all.cpp:11118)

// ============================================================================

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

set_column_cat_categories (pd_test_5_all.cpp:29010)

}

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

set_column_cat_ordered (pd_test_5_all.cpp:29011)

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;

set_column_datetime_ea (pd_test_extension_array.cpp:313)

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

set_column_dtype (pd_test_4_all.cpp:2203)

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

set_column_dtype (pd_test_4_all.cpp:2203)

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

set_column_names (pd_test_3_all.cpp:1708)

    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;

set_column_resolved (pd_test_5_all.cpp:94241)

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

set_column_sparse_fill_value (pd_test_5_all.cpp:23673)

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

set_columns_index_dtype (pd_test_4_all.cpp:4985)

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

set_columns_levels (pd_test_2_all.cpp:20310)

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

set_columns_name (pd_test_3_all.cpp:10815)

    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;

set_datetime_index (pd_test_3_all.cpp:1322)

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

set_display_options (pd_test_4_all.cpp:118)

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

set_flags (pd_test_1_all.cpp:16410)

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

set_integer_index (pd_test_3_all.cpp:1277)

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

set_integer_index (pd_test_3_all.cpp:1277)

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

set_multi_index (pd_test_3_all.cpp:1311)

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

set_multi_index (pd_test_3_all.cpp:1311)

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

set_multiindex (pd_test_2_all.cpp:20409)

        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;

set_multiindex (pd_test_2_all.cpp:20409)

        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;

set_multiindex (pd_test_2_all.cpp:20409)

        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;

set_multiindex (pd_test_2_all.cpp:20409)

        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;

set_multiindex (pd_test_2_all.cpp:20409)

        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;

set_multiindex (pd_test_2_all.cpp:20409)

        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;

set_multiindex (pd_test_2_all.cpp:20409)

        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;

set_multiindex (pd_test_2_all.cpp:20409)

        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;

set_multiindex_names (pd_test_2_all.cpp:20775)

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

set_nan_marker (pd_test_3_all.cpp:1334)

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

set_option (pd_test_3_all.cpp:10876)

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

set_string_index (pd_test_3_all.cpp:1270)

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

shape (pd_test_1_all.cpp:6188)

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

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

            pandas::DataFrame df(data);

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

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

shape_2d (pd_test_3_all.cpp:10796)

    }

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

size (pd_test_1_all.cpp:22)

#include "../pandas/pd_boolean_array.h"

namespace dataframe_tests {

namespace dataframe_tests_boolean_array {
    void pd_test_boolean_array_constructors() {
        std::cout << "========= BooleanArray: constructors ======================= ";

        // Default constructor
        pandas::BooleanArray arr1;
        if (arr1.size() != 0) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_constructors() : default constructor size != 0" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_constructors failed: default constructor size != 0");
        }

        // Initializer list constructor
        pandas::BooleanArray arr2({
            std::optional<bool>(true),
            std::optional<bool>(false),
            std::nullopt,
            std::optional<bool>(true)

sparse (pd_test_3_all.cpp:20627)

#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

ss (pd_test_3_all.cpp:27670)

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

trim (pd_test_5_all.cpp:58873)

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

trim (pd_test_5_all.cpp:58873)

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

truncate (pd_test_1_all.cpp:20467)

            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;

ts (pd_test_2_all.cpp:22590)

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

values (pd_test_1_all.cpp:364)

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