RangeIndex ========== .. cpp:class:: pandas::RangeIndex Index class for axis labels in pandas data structures. Example ------- .. code-block:: cpp #include using namespace pandas; // Create RangeIndex RangeIndex idx({1, 2, 3}, "my_index"); size_t len = idx.size(); Constructors ------------ .. list-table:: :widths: 55 25 20 :header-rows: 1 * - Signature - Location - Example * - ``explicit RangeIndex(int64_t stop, const std::optional& name = std::nullopt)`` - pd_range_index.h:103 - :ref:`View ` * - ``RangeIndex(const RangeIndex& other)`` - pd_range_index.h:136 - :ref:`View ` * - ``RangeIndex(RangeIndex&& other) noexcept`` - pd_range_index.h:145 - :ref:`View ` Construction ------------ .. list-table:: :widths: 40 20 15 25 :header-rows: 1 * - Signature - Return Type - Location - Example * - ``static RangeIndex from_range(int64_t start, int64_t stop, int64_t step = 1, const std::optional& name = std::nullopt)`` - static RangeIndex - pd_range_index.h:184 - :ref:`View ` Indexing / Selection -------------------- .. list-table:: :widths: 40 20 15 25 :header-rows: 1 * - Signature - Return Type - Location - Example * - ``int64_t at(size_t i) const`` - int64_t - pd_range_index.h:320 - :ref:`View ` * - ``numpy::NDArray get_indexer(const std::vector& target) const`` - numpy::NDArray - pd_range_index.h:425 - :ref:`View ` * - ``numpy::NDArray get_indexer(const RangeIndex& target) const`` - numpy::NDArray - pd_range_index.h:440 - :ref:`View ` * - ``numpy::NDArray get_indexer_for(const std::vector& target) const`` - numpy::NDArray - pd_range_index.h:1685 - :ref:`View ` * - ``get_indexer_non_unique(const std::vector& target) const`` - - pd_range_index.h:1695 - :ref:`View ` * - ``RangeIndex get_level_values(int level) const`` - RangeIndex - pd_range_index.h:2236 - :ref:`View ` * - ``RangeIndex get_level_values(const std::string& level_name) const`` - RangeIndex - pd_range_index.h:2252 - :ref:`View ` * - ``size_t get_loc(int64_t key) const`` - size_t - pd_range_index.h:389 - :ref:`View ` * - ``int64_t get_loc_str(const std::string& key_str) const override`` - int64_t - pd_range_index.h:399 - :ref:`View ` * - ``std::optional get_loc_string(const std::string& key) const override`` - std::optional - pd_range_index.h:414 - :ref:`View ` * - ``std::vector> get_names() const`` - std::vector> - pd_range_index.h:2408 - * - ``size_t get_slice_bound(int64_t label, const std::string& side) const`` - size_t - pd_range_index.h:1727 - :ref:`View ` * - ``std::string get_string(size_t i) const`` - std::string - pd_range_index.h:1295 - :ref:`View ` * - ``std::string get_value_str(size_t index) const override`` - std::string - pd_range_index.h:1286 - :ref:`View ` * - ``Index take(const std::vector& indices) const`` - Index - pd_range_index.h:512 - :ref:`View ` * - ``Index where(const numpy::NDArray& cond, const std::vector& other) const`` - Index - pd_range_index.h:2036 - :ref:`View ` Data Manipulation ----------------- .. list-table:: :widths: 40 20 15 25 :header-rows: 1 * - Signature - Return Type - Location - Example * - ``std::variant> drop(const std::vector& labels) const`` - std::variant> - pd_range_index.h:655 - :ref:`View ` * - ``RangeIndex drop_duplicates(const std::string& keep = "first") const`` - RangeIndex - pd_range_index.h:1786 - :ref:`View ` * - ``RangeIndex droplevel(int level = 0) const`` - RangeIndex - pd_range_index.h:2220 - :ref:`View ` * - ``RangeIndex dropna() const`` - RangeIndex - pd_range_index.h:1777 - :ref:`View ` * - ``std::variant> insert(size_t loc, int64_t item) const`` - std::variant> - pd_range_index.h:549 - :ref:`View ` * - ``std::pair> reindex( const RangeIndex& target, const std::string& method = "") const`` - std::pair> - pd_range_index.h:1935 - :ref:`View ` * - ``RangeIndex rename(const std::optional& new_name) const`` - RangeIndex - pd_range_index.h:707 - :ref:`View ` * - ``RangeIndex set_names(const std::optional& name) const`` - RangeIndex - pd_range_index.h:2177 - :ref:`View ` Missing Data ------------ .. list-table:: :widths: 40 20 15 25 :header-rows: 1 * - Signature - Return Type - Location - Example * - ``RangeIndex fillna(int64_t value) const`` - RangeIndex - pd_range_index.h:1768 - :ref:`View ` * - ``numpy::NDArray isna() const`` - numpy::NDArray - pd_range_index.h:1528 - :ref:`View ` * - ``numpy::NDArray isnull() const`` - numpy::NDArray - pd_range_index.h:1541 - :ref:`View ` * - ``numpy::NDArray notna() const`` - numpy::NDArray - pd_range_index.h:1549 - :ref:`View ` * - ``numpy::NDArray notnull() const`` - numpy::NDArray - pd_range_index.h:1562 - :ref:`View ` Statistics ---------- .. list-table:: :widths: 40 20 15 25 :header-rows: 1 * - Signature - Return Type - Location - Example * - ``int64_t max() const`` - int64_t - pd_range_index.h:1090 - :ref:`View ` * - ``double mean() const`` - double - pd_range_index.h:1132 - :ref:`View ` * - ``int64_t min() const`` - int64_t - pd_range_index.h:1080 - :ref:`View ` * - ``size_t nunique(bool dropna = true) const`` - size_t - pd_range_index.h:1606 - :ref:`View ` * - ``int64_t sum() const`` - int64_t - pd_range_index.h:1120 - :ref:`View ` * - ``std::pair, numpy::NDArray> value_counts( bool normalize = false, bool sort = true, bool ascending = false, bool dropna = true) const`` - std::pair, numpy::NDArray> - pd_range_index.h:2416 - :ref:`View ` Aggregation ----------- .. list-table:: :widths: 40 20 15 25 :header-rows: 1 * - Signature - Return Type - Location - Example * - ``std::unordered_map> groupby( const std::vector& values) const`` - std::unordered_map> - pd_range_index.h:2271 - :ref:`View ` Comparison ---------- .. list-table:: :widths: 40 20 15 25 :header-rows: 1 * - Signature - Return Type - Location - Example * - ``bool equals(const RangeIndex& other) const`` - bool - pd_range_index.h:1255 - :ref:`View ` Sorting ------- .. list-table:: :widths: 40 20 15 25 :header-rows: 1 * - Signature - Return Type - Location - Example * - ``numpy::NDArray argsort(bool ascending = true) const`` - numpy::NDArray - pd_range_index.h:1147 - :ref:`View ` * - ``size_t searchsorted(int64_t value, const std::string& side = "left") const`` - size_t - pd_range_index.h:1355 - :ref:`View ` * - ``RangeIndex sort_values(bool ascending = true) const`` - RangeIndex - pd_range_index.h:1168 - :ref:`View ` Reshaping --------- .. list-table:: :widths: 40 20 15 25 :header-rows: 1 * - Signature - Return Type - Location - Example * - ``FrameData to_frame(bool index = true, const std::optional& name = std::nullopt) const`` - FrameData - pd_range_index.h:2332 - :ref:`View ` * - ``RangeIndex transpose() const`` - RangeIndex - pd_range_index.h:1880 - :ref:`View ` Combining --------- .. list-table:: :widths: 40 20 15 25 :header-rows: 1 * - Signature - Return Type - Location - Example * - ``std::variant> append(const RangeIndex& other) const`` - std::variant> - pd_range_index.h:1054 - :ref:`View ` * - ``join(const RangeIndex& other, const std::string& how = "left", bool sort = false) const`` - - pd_range_index.h:2066 - :ref:`View ` Time Series ----------- .. list-table:: :widths: 40 20 15 25 :header-rows: 1 * - Signature - Return Type - Location - Example * - ``std::optional asof(int64_t label) const`` - std::optional - pd_range_index.h:1620 - :ref:`View ` * - ``numpy::NDArray asof_locs(const std::vector& where) const`` - numpy::NDArray - pd_range_index.h:1665 - :ref:`View ` * - ``Index diff(int64_t periods = 1) const`` - Index - pd_range_index.h:1744 - :ref:`View ` * - ``std::variant> difference(const RangeIndex& other) const`` - std::variant> - pd_range_index.h:932 - :ref:`View ` * - ``Index difference(const Index& other, bool sort = true) const`` - Index - pd_range_index.h:1036 - :ref:`View ` * - ``Index shift(int64_t periods = 1, int64_t fill_value = 0) const`` - Index - pd_range_index.h:2003 - :ref:`View ` I/O --- .. list-table:: :widths: 40 20 15 25 :header-rows: 1 * - Signature - Return Type - Location - Example * - ``numpy::NDArray to_array() const`` - numpy::NDArray - pd_range_index.h:330 - :ref:`View ` * - ``RangeIndex to_flat_index() const`` - RangeIndex - pd_range_index.h:1872 - :ref:`View ` * - ``Index to_index() const`` - Index - pd_range_index.h:1341 - :ref:`View ` * - ``std::vector to_list() const`` - std::vector - pd_range_index.h:345 - :ref:`View ` * - ``numpy::NDArray to_numpy() const`` - numpy::NDArray - pd_range_index.h:1864 - :ref:`View ` * - ``SeriesData to_series(const std::optional& index = std::nullopt, const std::optional& name = std::nullopt) const`` - SeriesData - pd_range_index.h:2372 - :ref:`View ` * - ``std::string to_string() const override`` - std::string - pd_range_index.h:1321 - :ref:`View ` * - ``std::vector to_string_vector() const override`` - std::vector - pd_range_index.h:1273 - :ref:`View ` * - ``std::vector tolist() const`` - std::vector - pd_range_index.h:1856 - :ref:`View ` Conversion ---------- .. list-table:: :widths: 40 20 15 25 :header-rows: 1 * - Signature - Return Type - Location - Example * - ``RangeIndex copy() const`` - RangeIndex - pd_range_index.h:700 - :ref:`View ` * - ``RangeIndex infer_objects() const`` - RangeIndex - pd_range_index.h:1824 - :ref:`View ` * - ``numpy::NDArray view() const`` - numpy::NDArray - pd_range_index.h:1888 - :ref:`View ` Set Operations -------------- .. list-table:: :widths: 40 20 15 25 :header-rows: 1 * - Signature - Return Type - Location - Example * - ``numpy::NDArray duplicated(const std::string& keep = "first") const`` - numpy::NDArray - pd_range_index.h:1796 - :ref:`View ` * - ``std::variant> intersection(const RangeIndex& other) const`` - std::variant> - pd_range_index.h:868 - :ref:`View ` * - ``Index intersection(const Index& other) const`` - Index - pd_range_index.h:1028 - :ref:`View ` * - ``numpy::NDArray isin(const std::vector& values) const override`` - numpy::NDArray - pd_range_index.h:526 - :ref:`View ` * - ``std::variant> symmetric_difference(const RangeIndex& other) const`` - std::variant> - pd_range_index.h:971 - :ref:`View ` * - ``Index symmetric_difference(const Index& other, bool sort = true) const`` - Index - pd_range_index.h:1045 - :ref:`View ` * - ``std::variant> union_(const RangeIndex& other) const`` - std::variant> - pd_range_index.h:817 - :ref:`View ` * - ``Index unique() const`` - Index - pd_range_index.h:2440 - :ref:`View ` Type Checking ------------- .. list-table:: :widths: 40 20 15 25 :header-rows: 1 * - Signature - Return Type - Location - Example * - ``bool is_(const RangeIndex& other) const`` - bool - pd_range_index.h:2190 - :ref:`View ` * - ``bool is_aligned(int64_t value) const`` - bool - pd_range_index.h:83 - * - ``bool is_boolean() const`` - bool - pd_range_index.h:1468 - :ref:`View ` * - ``bool is_categorical() const`` - bool - pd_range_index.h:1476 - :ref:`View ` * - ``bool is_floating() const`` - bool - pd_range_index.h:1484 - :ref:`View ` * - ``bool is_integer() const`` - bool - pd_range_index.h:1492 - :ref:`View ` * - ``bool is_interval() const`` - bool - pd_range_index.h:1500 - :ref:`View ` * - ``bool is_monotonic_decreasing() const`` - bool - pd_range_index.h:297 - :ref:`View ` * - ``bool is_monotonic_increasing() const`` - bool - pd_range_index.h:290 - :ref:`View ` * - ``bool is_numeric() const`` - bool - pd_range_index.h:1508 - :ref:`View ` * - ``bool is_object() const`` - bool - pd_range_index.h:1516 - :ref:`View ` * - ``bool is_range_index() const override`` - bool - pd_range_index.h:257 - :ref:`View ` * - ``bool is_unique() const override`` - bool - pd_range_index.h:262 - :ref:`View ` Other Methods ------------- .. list-table:: :widths: 40 20 15 25 :header-rows: 1 * - Signature - Return Type - Location - Example * - ``std::variant> abs() const`` - std::variant> - pd_range_index.h:786 - :ref:`View ` * - ``bool all(bool skipna = true) const`` - bool - pd_range_index.h:1575 - :ref:`View ` * - ``bool any(bool skipna = true) const`` - bool - pd_range_index.h:1589 - :ref:`View ` * - ``size_t argmax() const`` - size_t - pd_range_index.h:1110 - :ref:`View ` * - ``size_t argmin() const`` - size_t - pd_range_index.h:1100 - :ref:`View ` * - ``size_t cache_memory_usage() const override`` - size_t - pd_range_index.h:1444 - * - ``void clear_cache() const override`` - void - pd_range_index.h:1426 - :ref:`View ` * - ``std::unique_ptr clone() const override`` - std::unique_ptr - pd_range_index.h:1310 - :ref:`View ` * - ``size_t compute_size() const`` - size_t - pd_range_index.h:58 - * - ``bool contains(int64_t value) const`` - bool - pd_range_index.h:364 - :ref:`View ` * - ``bool contains_str(const std::string& key_str) const override`` - bool - pd_range_index.h:374 - :ref:`View ` * - ``std::variant> delete_(size_t loc) const`` - std::variant> - pd_range_index.h:579 - :ref:`View ` * - ``std::variant> delete_(const std::vector& locs) const`` - std::variant> - pd_range_index.h:605 - :ref:`View ` * - ``std::string dtype_name() const override`` - std::string - pd_range_index.h:229 - :ref:`View ` * - ``bool empty() const override`` - bool - pd_range_index.h:222 - :ref:`View ` * - ``std::pair, RangeIndex> factorize() const`` - std::pair, RangeIndex> - pd_range_index.h:1408 - :ref:`View ` * - ``std::vector format(const std::string& na_rep = "NaN") const`` - std::vector - pd_range_index.h:1815 - :ref:`View ` * - ``bool has_cached_values() const override`` - bool - pd_range_index.h:1435 - :ref:`View ` * - ``bool has_duplicates() const override`` - bool - pd_range_index.h:269 - :ref:`View ` * - ``bool holds_integer() const`` - bool - pd_range_index.h:1460 - :ref:`View ` * - ``bool identical(const RangeIndex& other) const`` - bool - pd_range_index.h:1262 - :ref:`View ` * - ``bool in_bounds(int64_t value) const`` - bool - pd_range_index.h:72 - * - ``std::string inferred_type() const override`` - std::string - pd_range_index.h:250 - :ref:`View ` * - ``int64_t item() const`` - int64_t - pd_range_index.h:1832 - :ref:`View ` * - ``size_t memory_usage(bool deep = false) const`` - size_t - pd_range_index.h:1844 - :ref:`View ` * - ``std::optional name() const override`` - std::optional - pd_range_index.h:236 - :ref:`View ` * - ``name_(other.name_)`` - - pd_range_index.h:138 - * - ``name_(std::move(other.name_)), cached_array_(std::move(other.cached_array_))`` - - pd_range_index.h:147 - * - ``size_t nbytes() const override`` - size_t - pd_range_index.h:283 - :ref:`View ` * - ``size_t nlevels() const`` - size_t - pd_range_index.h:2400 - :ref:`View ` * - ``Index putmask(const numpy::NDArray& mask, int64_t value) const`` - Index - pd_range_index.h:1910 - :ref:`View ` * - ``numpy::NDArray ravel() const`` - numpy::NDArray - pd_range_index.h:1896 - :ref:`View ` * - ``Index repeat(size_t repeats) const`` - Index - pd_range_index.h:1948 - :ref:`View ` * - ``Index repeat(const std::vector& repeats) const`` - Index - pd_range_index.h:1967 - :ref:`View ` * - ``std::string repr() const override`` - std::string - pd_range_index.h:1334 - :ref:`View ` * - ``RangeIndex result(\*this)`` - RangeIndex - pd_range_index.h:708 - :ref:`View ` * - ``RangeIndex round(int decimals = 0) const`` - RangeIndex - pd_range_index.h:1992 - :ref:`View ` * - ``void set_name(const std::optional& name) override`` - void - pd_range_index.h:243 - :ref:`View ` * - ``size_t size() const override`` - size_t - pd_range_index.h:215 - :ref:`View ` * - ``RangeIndex slice(size_t start_idx, size_t stop_idx, int64_t step_idx = 1) const`` - RangeIndex - pd_range_index.h:455 - :ref:`View ` * - ``std::pair slice_indexer(std::optional start = std::nullopt, std::optional stop = std::nullopt, size_t step = 1) const`` - std::pair - pd_range_index.h:2201 - :ref:`View ` * - ``std::pair slice_locs( std::optional start = std::nullopt, std::optional stop = std::nullopt) const`` - std::pair - pd_range_index.h:476 - :ref:`View ` * - ``RangeIndex sort(bool ascending = true) const`` - RangeIndex - pd_range_index.h:2447 - :ref:`View ` * - ``std::pair> sortlevel( int level = 0, bool ascending = true, bool sort_remaining = true, const std::string& na_position = "first") const`` - std::pair> - pd_range_index.h:2297 - :ref:`View ` * - ``int64_t start() const`` - int64_t - pd_range_index.h:196 - :ref:`View ` * - ``int64_t step() const`` - int64_t - pd_range_index.h:206 - :ref:`View ` * - ``int64_t stop() const`` - int64_t - pd_range_index.h:201 - :ref:`View ` * - ``StringMethods str() const`` - StringMethods - pd_range_index.h:1303 - :ref:`View ` * - ``IndexTypeId type_id() const override`` - IndexTypeId - pd_range_index.h:1314 - :ref:`View ` Code Examples ------------- The following examples are extracted from the test suite. .. _example-rangeindex-rangeindex-0: .. dropdown:: RangeIndex (pd_test_1_all.cpp:18370) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 18360 :emphasize-lines: 11 throw std::runtime_error("pd_test_range_index_insert failed"); } std::cout << "-> tests passed" << std::endl; } void pd_test_range_index_delete() { std::cout << "========= delete ====================================== " << std::endl; pandas::RangeIndex ri(0, 10); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] std::cout << " Created RangeIndex(0, 10) with " << ri.size() << " elements" << std::endl; bool passed = true; // ===== Single Element Tests (existing) ===== // Delete from start preserves range std::cout << " Test 1: Single delete_(0)..." << std::endl; auto result1 = ri.delete_(0); bool is_ri1 = std::holds_alternative(result1); std::cout << " Type: " << (is_ri1 ? "RangeIndex" : "Index") << std::endl; .. _example-rangeindex-rangeindex-1: .. dropdown:: RangeIndex (pd_test_1_all.cpp:18370) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 18360 :emphasize-lines: 11 throw std::runtime_error("pd_test_range_index_insert failed"); } std::cout << "-> tests passed" << std::endl; } void pd_test_range_index_delete() { std::cout << "========= delete ====================================== " << std::endl; pandas::RangeIndex ri(0, 10); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] std::cout << " Created RangeIndex(0, 10) with " << ri.size() << " elements" << std::endl; bool passed = true; // ===== Single Element Tests (existing) ===== // Delete from start preserves range std::cout << " Test 1: Single delete_(0)..." << std::endl; auto result1 = ri.delete_(0); bool is_ri1 = std::holds_alternative(result1); std::cout << " Type: " << (is_ri1 ? "RangeIndex" : "Index") << std::endl; .. _example-rangeindex-rangeindex-2: .. dropdown:: RangeIndex (pd_test_1_all.cpp:18370) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 18360 :emphasize-lines: 11 throw std::runtime_error("pd_test_range_index_insert failed"); } std::cout << "-> tests passed" << std::endl; } void pd_test_range_index_delete() { std::cout << "========= delete ====================================== " << std::endl; pandas::RangeIndex ri(0, 10); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] std::cout << " Created RangeIndex(0, 10) with " << ri.size() << " elements" << std::endl; bool passed = true; // ===== Single Element Tests (existing) ===== // Delete from start preserves range std::cout << " Test 1: Single delete_(0)..." << std::endl; auto result1 = ri.delete_(0); bool is_ri1 = std::holds_alternative(result1); std::cout << " Type: " << (is_ri1 ? "RangeIndex" : "Index") << std::endl; .. _example-rangeindex-from_range-3: .. dropdown:: from_range (pd_test_1_all.cpp:17986) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 17976 :emphasize-lines: 11 std::cout << " [FAIL] : full constructor" << std::endl; throw std::runtime_error("pd_test_range_index_full_constructor failed"); } std::cout << "-> tests passed" << std::endl; } void pd_test_range_index_from_range() { std::cout << "========= from_range factory ========================== "; pandas::RangeIndex ri = pandas::RangeIndex::from_range(5, 20, 3, "test"); bool passed = (ri.size() == 5 && ri.start() == 5 && ri.stop() == 20 && ri.step() == 3 && ri.name().value() == "test" && ri[0] == 5 && ri[4] == 17); if (!passed) { std::cout << " [FAIL] : from_range factory" << std::endl; .. _example-rangeindex-at-4: .. dropdown:: at (pd_test_1_all.cpp:6581) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 6571 :emphasize-lines: 11 // Test isna/notna with float data { std::map> float_data; float_data["X"] = {1.0, std::nan(""), 3.0}; float_data["Y"] = {4.0, 5.0, std::nan("")}; pandas::DataFrame df_na(float_data); auto na_mask = df_na.isna(); // Row 1, col 0 (X) should be NA if (!na_mask.getElementAt({1, 0})) { std::cout << " [FAIL] : in pd_test_dataframe_manipulation() : isna at (1,0) should be true" << std::endl; throw std::runtime_error("pd_test_dataframe_manipulation failed: isna at (1,0)"); } // Row 2, col 1 (Y) should be NA if (!na_mask.getElementAt({2, 1})) { std::cout << " [FAIL] : in pd_test_dataframe_manipulation() : isna at (2,1) should be true" << std::endl; throw std::runtime_error("pd_test_dataframe_manipulation failed: isna at (2,1)"); } // Row 0, col 0 should NOT be NA if (na_mask.getElementAt({0, 0})) { std::cout << " [FAIL] : in pd_test_dataframe_manipulation() : isna at (0,0) should be false" << std::endl; .. _example-rangeindex-get_indexer-5: .. dropdown:: get_indexer (pd_test_1_all.cpp:10332) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 10322 :emphasize-lines: 11 void pd_test_extension_index_get_indexer() { std::cout << "========= get_indexer ========================="; pandas::CategoricalArray arr1({"a", "b", "c", "d"}); pandas::CategoricalIndex idx1(arr1); pandas::CategoricalArray arr2({"b", "d", "x"}); pandas::CategoricalIndex idx2(arr2); auto indexer = idx1.get_indexer(idx2); bool passed = (indexer.getSize() == 3 && indexer.getElementAt({0}) == 1 && indexer.getElementAt({1}) == 3 && indexer.getElementAt({2}) == -1); if (!passed) { std::cout << " [FAIL] : in pd_test_extension_index_get_indexer() : get_indexer check failed" << std::endl; throw std::runtime_error("pd_test_extension_index_get_indexer failed"); } .. _example-rangeindex-get_indexer-6: .. dropdown:: get_indexer (pd_test_1_all.cpp:10332) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 10322 :emphasize-lines: 11 void pd_test_extension_index_get_indexer() { std::cout << "========= get_indexer ========================="; pandas::CategoricalArray arr1({"a", "b", "c", "d"}); pandas::CategoricalIndex idx1(arr1); pandas::CategoricalArray arr2({"b", "d", "x"}); pandas::CategoricalIndex idx2(arr2); auto indexer = idx1.get_indexer(idx2); bool passed = (indexer.getSize() == 3 && indexer.getElementAt({0}) == 1 && indexer.getElementAt({1}) == 3 && indexer.getElementAt({2}) == -1); if (!passed) { std::cout << " [FAIL] : in pd_test_extension_index_get_indexer() : get_indexer check failed" << std::endl; throw std::runtime_error("pd_test_extension_index_get_indexer failed"); } .. _example-rangeindex-get_indexer_for-7: .. dropdown:: get_indexer_for (pd_test_3_all.cpp:716) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 706 :emphasize-lines: 11 // ============================================================================ // Category 6: Index Indexer Methods // ============================================================================ void pd_test_3_all_index_indexers() { std::cout << "========= Index.get_indexer_for/non_unique/slice_indexer() "; std::vector vals = {"a", "b", "c", "d", "e"}; pandas::Index idx(vals); // Test get_indexer_for() std::vector target = {"b", "d", "f"}; // "f" doesn't exist numpy::NDArray indexer = idx.get_indexer_for(target); if (indexer.getSize() != 3) { std::cout << " [FAIL] : in pd_test_3_all_index_indexers() : get_indexer_for size mismatch" << std::endl; throw std::runtime_error("pd_test_3_all_index_indexers failed: get_indexer_for size"); } // "b" is at index 1 if (indexer.getElementAt({0}) != 1) { std::cout << " [FAIL] : in pd_test_3_all_index_indexers() : 'b' should be at index 1" << std::endl; throw std::runtime_error("pd_test_3_all_index_indexers failed: 'b' index"); .. _example-rangeindex-get_indexer_non_unique-8: .. dropdown:: get_indexer_non_unique (pd_test_3_all.cpp:739) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 729 :emphasize-lines: 11 if (indexer.getElementAt({1}) != 3) { std::cout << " [FAIL] : in pd_test_3_all_index_indexers() : 'd' should be at index 3" << std::endl; throw std::runtime_error("pd_test_3_all_index_indexers failed: 'd' index"); } // "f" doesn't exist -> -1 if (indexer.getElementAt({2}) != -1) { std::cout << " [FAIL] : in pd_test_3_all_index_indexers() : 'f' should be -1" << std::endl; throw std::runtime_error("pd_test_3_all_index_indexers failed: 'f' index"); } // Test get_indexer_non_unique() std::vector target2 = {"a", "c", "z"}; // "z" doesn't exist pandas::Index target_idx(target2); auto [indexer2, missing] = idx.get_indexer_non_unique(target_idx); if (indexer2.getSize() < 2) { std::cout << " [FAIL] : in pd_test_3_all_index_indexers() : get_indexer_non_unique size too small" << std::endl; throw std::runtime_error("pd_test_3_all_index_indexers failed: get_indexer_non_unique size"); } // Test slice_indexer() .. _example-rangeindex-get_level_values-9: .. dropdown:: get_level_values (pd_test_3_all.cpp:4524) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 4514 :emphasize-lines: 11 } std::cout << " -> tests passed" << std::endl; } void pd_test_3_all_interval_index_get_level_values_droplevel() { std::cout << "========= IntervalIndex.get_level_values/droplevel() "; pandas::IntervalIndex64 idx = pandas::IntervalIndex64::from_breaks({0, 10, 20, 30}); // get_level_values(0) should work pandas::IntervalIndex64 level_vals = idx.get_level_values(0); if (level_vals.size() != idx.size()) { throw std::runtime_error("get_level_values(0) size mismatch"); } // get_level_values(1) should throw bool threw = false; try { idx.get_level_values(1); } catch (const std::out_of_range&) { .. _example-rangeindex-get_level_values-10: .. dropdown:: get_level_values (pd_test_3_all.cpp:4524) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 4514 :emphasize-lines: 11 } std::cout << " -> tests passed" << std::endl; } void pd_test_3_all_interval_index_get_level_values_droplevel() { std::cout << "========= IntervalIndex.get_level_values/droplevel() "; pandas::IntervalIndex64 idx = pandas::IntervalIndex64::from_breaks({0, 10, 20, 30}); // get_level_values(0) should work pandas::IntervalIndex64 level_vals = idx.get_level_values(0); if (level_vals.size() != idx.size()) { throw std::runtime_error("get_level_values(0) size mismatch"); } // get_level_values(1) should throw bool threw = false; try { idx.get_level_values(1); } catch (const std::out_of_range&) { .. _example-rangeindex-get_loc-11: .. dropdown:: get_loc (pd_test_1_all.cpp:10281) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 10271 :emphasize-lines: 11 bool passed = (idx.contains("apple") && idx.contains("banana") && !idx.contains("grape")); if (!passed) { std::cout << " [FAIL] : in pd_test_extension_index_contains() : contains check failed" << std::endl; throw std::runtime_error("pd_test_extension_index_contains failed"); } std::cout << " -> tests passed" << std::endl; } void pd_test_extension_index_get_loc_unique() { std::cout << "========= get_loc (unique) ========================="; pandas::CategoricalArray arr({"apple", "banana", "cherry"}); pandas::CategoricalIndex idx(arr); auto loc_apple = idx.get_loc("apple"); auto loc_banana = idx.get_loc("banana"); auto loc_cherry = idx.get_loc("cherry"); bool passed = (std::holds_alternative(loc_apple) && std::get(loc_apple) == 0 && std::get(loc_banana) == 1 && .. _example-rangeindex-get_loc_str-12: .. dropdown:: get_loc_str (pd_test_1_all.cpp:10890) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 10880 :emphasize-lines: 11 std::cout << " -> tests passed" << std::endl; } void pd_test_extension_index_contains_str_get_loc_str() { std::cout << "========= contains_str/get_loc_str ========================="; pandas::CategoricalArray arr({"apple", "banana", "cherry"}); pandas::CategoricalIndex idx(arr); bool passed = (idx.contains_str("apple") && !idx.contains_str("grape") && idx.get_loc_str("banana") == 1 && idx.get_loc_str("grape") == -1); if (!passed) { std::cout << " [FAIL] : in pd_test_extension_index_contains_str_get_loc_str() : contains_str/get_loc_str check failed" << std::endl; throw std::runtime_error("pd_test_extension_index_contains_str_get_loc_str failed"); } std::cout << " -> tests passed" << std::endl; } void pd_test_extension_index_repr() { std::cout << "========= repr ========================="; .. _example-rangeindex-get_loc_string-13: .. dropdown:: get_loc_string (pd_test_3_all.cpp:28108) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 28098 :emphasize-lines: 11 vals.push_back(numpy::timedelta64(ns, numpy::DateTimeUnit::Nanosecond)); } return pandas::TimedeltaArray(vals); } void pd_test_getitem_timedelta_str_lookup() { std::cout << " -- pd_test_getitem_timedelta_str_lookup --" << std::endl; int fail = 0; auto tda = ge_make_tda({1 * GE_NS_PER_DAY, 2 * GE_NS_PER_DAY, 3 * GE_NS_PER_DAY}); pandas::TimedeltaIndex tdi(tda); auto pos = tdi.get_loc_string("2 days"); if (!pos.has_value()) { std::cout << " FAIL: '2 days' not found" << std::endl; fail++; } else if (*pos != 1) { std::cout << " FAIL: expected pos=1, got " << *pos << std::endl; fail++; } if (fail == 0) std::cout << " OK" << std::endl; if (fail) throw std::runtime_error("pd_test_getitem_timedelta_str_lookup failed"); } void pd_test_getitem_timedelta_str_not_found() { std::cout << " -- pd_test_getitem_timedelta_str_not_found --" << std::endl; int fail = 0; auto tda = ge_make_tda({1 * GE_NS_PER_DAY}); .. _example-rangeindex-get_slice_bound-14: .. dropdown:: get_slice_bound (pd_test_3_all.cpp:3644) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 3634 :emphasize-lines: 11 formatted = idx.format(custom_formatter); if (formatted[0] != "val:1") { throw std::runtime_error("custom formatter failed"); } std::cout << " -> tests passed" << std::endl; } void pd_test_3_all_index_get_slice_bound() { std::cout << "========= Index.get_slice_bound() =================="; pandas::Index idx({10, 20, 30, 40, 50}); // Exact match, left side size_t bound = idx.get_slice_bound(30, "left"); if (bound != 2) { throw std::runtime_error("left bound for 30 should be 2"); } // Exact match, right side .. _example-rangeindex-get_string-15: .. dropdown:: get_string (pd_test_3_all.cpp:27746) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 27736 :emphasize-lines: 11 } } pandas::Series si({10, 20, 30}, "ints"); auto result2 = si.astype("str"); auto* str_s2 = dynamic_cast*>(result2.get()); if (!str_s2) { std::cout << " FAIL: expected Series from int" << std::endl; fail++; } else { if (str_s2->get_string(0) != "10") { std::cout << " FAIL: expected '10', got '" << str_s2->get_string(0) << "'" << std::endl; fail++; } } if (fail == 0) std::cout << " OK" << std::endl; } void pd_test_astype_datetime_to_string() { std::cout << " -- pd_test_astype_datetime_to_string --" << std::endl; .. _example-rangeindex-get_value_str-16: .. dropdown:: get_value_str (pd_test_1_all.cpp:4665) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 4655 :emphasize-lines: 11 auto corr_df = df.corr(); // Check dimensions bool passed = corr_df.nrows() == 2 && corr_df.ncols() == 2; if (!passed) { std::cout << " [FAIL] : in pd_test_aggregation_dataframe_corr() : corr should be 2x2" << std::endl; throw std::runtime_error("pd_test_aggregation_dataframe_corr failed: corr should be 2x2"); } // Diagonal should be 1.0 std::string aa = corr_df["A"].get_value_str(0); passed = std::abs(std::stod(aa) - 1.0) < 0.001; if (!passed) { std::cout << " [FAIL] : in pd_test_aggregation_dataframe_corr() : diagonal should be 1.0" << std::endl; throw std::runtime_error("pd_test_aggregation_dataframe_corr failed: diagonal should be 1.0"); } // A-B correlation should be 1.0 (perfect correlation) std::string ab = corr_df["B"].get_value_str(0); passed = std::abs(std::stod(ab) - 1.0) < 0.001; if (!passed) { .. _example-rangeindex-take-17: .. dropdown:: take (pd_test_1_all.cpp:5903) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 5893 :emphasize-lines: 11 // Inherited Operations Tests // ============================================================================ void pd_test_categorical_index_take() { std::cout << "========= inherited take =============================="; pandas::CategoricalArray arr({"a", "b", "c", "d"}); pandas::CategoricalIndex idx(arr); std::vector indices = {0, 2, 3}; pandas::ExtensionIndex taken = idx.take(indices); bool passed = (taken.size() == 3); if (!passed) { std::cout << " [FAIL] : in pd_test_categorical_index_take()" << std::endl; throw std::runtime_error("pd_test_categorical_index_take failed"); } std::cout << " -> tests passed" << std::endl; } .. _example-rangeindex-where-18: .. dropdown:: where (pd_test_1_all.cpp:22018) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 22008 :emphasize-lines: 11 data["B"] = {5.0, 6.0, 7.0, 8.0}; pandas::DataFrame df(data); // Create condition DataFrame (values > 2) std::map> 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(0, col_a_idx) == -1.0 ? "ok" : "fail"; .. _example-rangeindex-drop-19: .. dropdown:: drop (pd_test_1_all.cpp:6558) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 6548 :emphasize-lines: 11 if (df.ncols() != 2) { std::cout << " [FAIL] : in pd_test_dataframe_manipulation() : pop ncols != 2" << std::endl; throw std::runtime_error("pd_test_dataframe_manipulation failed: pop ncols != 2"); } if (!popped) { std::cout << " [FAIL] : in pd_test_dataframe_manipulation() : popped is null" << std::endl; throw std::runtime_error("pd_test_dataframe_manipulation failed: popped is null"); } // Test drop columns auto dropped = df.drop(std::vector{"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{{"A", "X"}}); if (!renamed.has_column("X")) { std::cout << " [FAIL] : in pd_test_dataframe_manipulation() : rename failed" << std::endl; throw std::runtime_error("pd_test_dataframe_manipulation failed: rename failed"); .. _example-rangeindex-drop_duplicates-20: .. dropdown:: drop_duplicates (pd_test_1_all.cpp:6639) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 6629 :emphasize-lines: 11 } } // Test drop_duplicates { std::map> 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> assign_data; .. _example-rangeindex-droplevel-21: .. dropdown:: droplevel (pd_test_1_all.cpp:14428) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 14418 :emphasize-lines: 11 void pd_test_multiindex_droplevel() { std::cout << "========= droplevel =================================== "; std::vector> arrays = { {"a", "a", "b"}, {"x", "y", "z"}, {"1", "2", "3"} }; pandas::MultiIndex mi = pandas::MultiIndex::from_arrays(arrays); pandas::MultiIndex dropped = mi.droplevel(1); bool passed = true; if (dropped.nlevels() != 2) { std::cout << " [FAIL] : nlevels should be 2 after drop" << std::endl; passed = false; } // Check remaining levels auto tup = dropped[0]; .. _example-rangeindex-dropna-22: .. dropdown:: dropna (pd_test_1_all.cpp:531) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 521 :emphasize-lines: 11 } // Test isna array numpy::NDArray na_mask = arr.isna(); if (na_mask.getSize() != 4) { std::cout << " [FAIL] : in pd_test_categorical_array_na_handling() : isna size != 4" << std::endl; throw std::runtime_error("pd_test_categorical_array_na_handling failed: isna size != 4"); } // Test dropna pandas::CategoricalArray dropped = arr.dropna(); if (dropped.size() != 2) { std::cout << " [FAIL] : in pd_test_categorical_array_na_handling() : dropna size != 2" << std::endl; throw std::runtime_error("pd_test_categorical_array_na_handling failed: dropna size != 2"); } // Test fillna (fill with existing category) pandas::CategoricalArray filled = arr.fillna("a"); // 'a' is in categories if (filled.has_na()) { std::cout << " [FAIL] : in pd_test_categorical_array_na_handling() : fillna should have no NA" << std::endl; throw std::runtime_error("pd_test_categorical_array_na_handling failed: fillna should have no NA"); .. _example-rangeindex-insert-23: .. dropdown:: insert (pd_test_1_all.cpp:12028) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 12018 :emphasize-lines: 11 } std::cout << " -> tests passed" << std::endl; } void pd_test_index_insert_delete() { std::cout << "========= insert and delete ==========================="; pandas::Index idx{1, 2, 4, 5}; auto inserted = idx.insert(2, 3); bool passed = (inserted.size() == 5); passed = passed && (inserted[2] == 3); auto deleted = inserted.delete_(2); passed = passed && (deleted.size() == 4); passed = passed && deleted.equals(idx); if (!passed) { std::cout << " [FAIL] : in pd_test_index_insert_delete() : insert/delete failed" << std::endl; throw std::runtime_error("pd_test_index_insert_delete failed"); .. _example-rangeindex-reindex-24: .. dropdown:: reindex (pd_test_1_all.cpp:6708) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 6698 :emphasize-lines: 11 } } // Test reindex rows { std::map> data; data["A"] = {1.0, 2.0, 3.0}; pandas::DataFrame df(data); df = df.set_axis({"x", "y", "z"}, 0); auto reindexed = df.reindex({"x", "z", "w"}, 0); if (reindexed.nrows() != 3) { std::cout << " [FAIL] : in pd_test_dataframe_index_ops() : reindex wrong nrows" << std::endl; throw std::runtime_error("pd_test_dataframe_index_ops failed: reindex nrows"); } // 'w' should have NaN std::string val = reindexed["A"].get_value_str(2); if (!std::isnan(std::stod(val))) { std::cout << " [FAIL] : in pd_test_dataframe_index_ops() : missing label should be NaN" << std::endl; throw std::runtime_error("pd_test_dataframe_index_ops failed: reindex NaN"); } .. _example-rangeindex-rename-25: .. dropdown:: rename (pd_test_1_all.cpp:5816) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 5806 :emphasize-lines: 11 std::cout << " -> tests passed" << std::endl; } void pd_test_categorical_index_rename() { std::cout << "========= rename ======================================"; pandas::CategoricalArray arr({"x", "y"}); pandas::CategoricalIndex idx(arr, "old_name"); pandas::CategoricalIndex renamed = idx.rename("new_name"); bool passed = (renamed.name().has_value() && *renamed.name() == "new_name" && renamed.size() == idx.size() && renamed.categories() == idx.categories()); if (!passed) { std::cout << " [FAIL] : in pd_test_categorical_index_rename()" << std::endl; throw std::runtime_error("pd_test_categorical_index_rename failed"); } std::cout << " -> tests passed" << std::endl; } .. _example-rangeindex-set_names-26: .. dropdown:: set_names (pd_test_1_all.cpp:14519) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 14509 :emphasize-lines: 11 std::cout << "-> tests passed" << std::endl; } void pd_test_multiindex_set_names() { std::cout << "========= set_names =================================== "; std::vector> arrays = {{"a", "b"}, {"x", "y"}}; pandas::MultiIndex mi = pandas::MultiIndex::from_arrays(arrays); std::vector> new_names = {"level_a", "level_b"}; pandas::MultiIndex named = mi.set_names(new_names); bool passed = (named.names()[0] == "level_a" && named.names()[1] == "level_b"); if (!passed) { std::cout << " [FAIL] : names not set correctly" << std::endl; throw std::runtime_error("pd_test_multiindex_set_names failed"); } std::cout << "-> tests passed" << std::endl; } .. _example-rangeindex-fillna-27: .. dropdown:: fillna (pd_test_1_all.cpp:537) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 527 :emphasize-lines: 11 throw std::runtime_error("pd_test_categorical_array_na_handling failed: isna size != 4"); } // Test dropna pandas::CategoricalArray dropped = arr.dropna(); if (dropped.size() != 2) { std::cout << " [FAIL] : in pd_test_categorical_array_na_handling() : dropna size != 2" << std::endl; throw std::runtime_error("pd_test_categorical_array_na_handling failed: dropna size != 2"); } // Test fillna (fill with existing category) pandas::CategoricalArray filled = arr.fillna("a"); // 'a' is in categories if (filled.has_na()) { std::cout << " [FAIL] : in pd_test_categorical_array_na_handling() : fillna should have no NA" << std::endl; throw std::runtime_error("pd_test_categorical_array_na_handling failed: fillna should have no NA"); } std::cout << " -> tests passed" << std::endl; } void pd_test_categorical_array_add_categories() { .. _example-rangeindex-isna-28: .. dropdown:: isna (pd_test_1_all.cpp:524) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 514 :emphasize-lines: 11 throw std::runtime_error("pd_test_categorical_array_na_handling failed: has_na() should be true"); } // Test count (non-NA) if (arr.count() != 2) { std::cout << " [FAIL] : in pd_test_categorical_array_na_handling() : count() != 2" << std::endl; throw std::runtime_error("pd_test_categorical_array_na_handling failed: count() != 2"); } // Test isna array numpy::NDArray na_mask = arr.isna(); if (na_mask.getSize() != 4) { std::cout << " [FAIL] : in pd_test_categorical_array_na_handling() : isna size != 4" << std::endl; throw std::runtime_error("pd_test_categorical_array_na_handling failed: isna size != 4"); } // Test dropna pandas::CategoricalArray dropped = arr.dropna(); if (dropped.size() != 2) { std::cout << " [FAIL] : in pd_test_categorical_array_na_handling() : dropna size != 2" << std::endl; throw std::runtime_error("pd_test_categorical_array_na_handling failed: dropna size != 2"); .. _example-rangeindex-isnull-29: .. dropdown:: isnull (pd_test_3_all.cpp:671) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 661 :emphasize-lines: 11 // Category 5: Index Null Detection // ============================================================================ void pd_test_3_all_index_null_detection() { std::cout << "========= Index.isnull/notnull() ====================="; // Test with float index (can have NaN) std::vector vals = {1.0, std::nan(""), 3.0, std::nan("")}; pandas::Index idx(vals); numpy::NDArray isnull_result = idx.isnull(); if (isnull_result.getSize() != 4) { std::cout << " [FAIL] : in pd_test_3_all_index_null_detection() : isnull() size mismatch" << std::endl; throw std::runtime_error("pd_test_3_all_index_null_detection failed: isnull() size"); } // Index 0: 1.0 -> not null if (isnull_result.getElementAt({0})) { std::cout << " [FAIL] : in pd_test_3_all_index_null_detection() : index 0 should not be null" << std::endl; throw std::runtime_error("pd_test_3_all_index_null_detection failed: index 0"); } // Index 1: NaN -> null .. _example-rangeindex-notna-30: .. dropdown:: notna (pd_test_1_all.cpp:6595) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 6585 :emphasize-lines: 11 if (!na_mask.getElementAt({2, 1})) { std::cout << " [FAIL] : in pd_test_dataframe_manipulation() : isna at (2,1) should be true" << std::endl; throw std::runtime_error("pd_test_dataframe_manipulation failed: isna at (2,1)"); } // Row 0, col 0 should NOT be NA if (na_mask.getElementAt({0, 0})) { std::cout << " [FAIL] : in pd_test_dataframe_manipulation() : isna at (0,0) should be false" << std::endl; throw std::runtime_error("pd_test_dataframe_manipulation failed: isna at (0,0)"); } auto notna_mask = df_na.notna(); if (notna_mask.getElementAt({1, 0})) { std::cout << " [FAIL] : in pd_test_dataframe_manipulation() : notna at (1,0) should be false" << std::endl; throw std::runtime_error("pd_test_dataframe_manipulation failed: notna at (1,0)"); } } // Test fillna { std::map> float_data; float_data["X"] = {1.0, std::nan(""), 3.0}; .. _example-rangeindex-notnull-31: .. dropdown:: notnull (pd_test_3_all.cpp:665) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 655 :emphasize-lines: 11 } std::cout << " -> tests passed" << std::endl; } // ============================================================================ // Category 5: Index Null Detection // ============================================================================ void pd_test_3_all_index_null_detection() { std::cout << "========= Index.isnull/notnull() ====================="; // Test with float index (can have NaN) std::vector vals = {1.0, std::nan(""), 3.0, std::nan("")}; pandas::Index idx(vals); numpy::NDArray isnull_result = idx.isnull(); if (isnull_result.getSize() != 4) { std::cout << " [FAIL] : in pd_test_3_all_index_null_detection() : isnull() size mismatch" << std::endl; throw std::runtime_error("pd_test_3_all_index_null_detection failed: isnull() size"); } .. _example-rangeindex-max-32: .. dropdown:: max (pd_test_1_all.cpp:771) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 761 :emphasize-lines: 11 pandas::CategoricalArray arr = pandas::CategoricalArray::from_codes(codes, cats, true); // ordered // Test min std::optional 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 max_val = arr.max(); if (!max_val.has_value() || *max_val != "high") { std::cout << " [FAIL] : in pd_test_categorical_array_ordered_operations() : max != 'high'" << std::endl; throw std::runtime_error("pd_test_categorical_array_ordered_operations failed: max != 'high'"); } // Test unordered throws for min/max pandas::CategoricalArray unordered = arr.as_unordered(); bool threw = false; try { unordered.min(); .. _example-rangeindex-mean-33: .. dropdown:: mean (pd_test_1_all.cpp:282) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 272 :emphasize-lines: 11 std::optional(true), std::optional(true) }); auto s = arr.sum(); if (!s.has_value() || s.value() != 3) { std::cout << " [FAIL] : in pd_test_boolean_array_reductions() : sum should be 3" << std::endl; throw std::runtime_error("pd_test_boolean_array_reductions failed: sum"); } auto m = arr.mean(); if (!m.has_value() || std::abs(m.value() - 0.75) > 0.001) { std::cout << " [FAIL] : in pd_test_boolean_array_reductions() : mean should be 0.75" << std::endl; throw std::runtime_error("pd_test_boolean_array_reductions failed: mean"); } std::cout << " -> tests passed" << std::endl; } void pd_test_boolean_array_dtype() { std::cout << "========= BooleanArray: dtype ======================= "; .. _example-rangeindex-min-34: .. dropdown:: min (pd_test_1_all.cpp:764) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 754 :emphasize-lines: 11 } void pd_test_categorical_array_ordered_operations() { std::cout << "========= CategoricalArray: ordered operations (min/max) ======================= "; std::vector cats = {"low", "medium", "high"}; std::vector 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 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 max_val = arr.max(); if (!max_val.has_value() || *max_val != "high") { std::cout << " [FAIL] : in pd_test_categorical_array_ordered_operations() : max != 'high'" << std::endl; throw std::runtime_error("pd_test_categorical_array_ordered_operations failed: max != 'high'"); .. _example-rangeindex-nunique-35: .. dropdown:: nunique (pd_test_1_all.cpp:10604) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 10594 :emphasize-lines: 11 std::cout << " -> tests passed" << std::endl; } void pd_test_extension_index_nunique() { std::cout << "========= nunique ========================="; pandas::CategoricalArray arr({"a", "b", "a", "c", "b", std::nullopt}); pandas::CategoricalIndex idx(arr); bool passed = (idx.nunique(true) == 3 && idx.nunique(false) == 4); if (!passed) { std::cout << " [FAIL] : in pd_test_extension_index_nunique() : nunique check failed" << std::endl; throw std::runtime_error("pd_test_extension_index_nunique failed"); } std::cout << " -> tests passed" << std::endl; } void pd_test_extension_index_factorize() { std::cout << "========= factorize ========================="; .. _example-rangeindex-sum-36: .. dropdown:: sum (pd_test_1_all.cpp:276) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 266 :emphasize-lines: 11 } // Test sum/mean pandas::BooleanArray arr({ std::optional(true), std::optional(false), std::optional(true), std::optional(true) }); auto s = arr.sum(); if (!s.has_value() || s.value() != 3) { std::cout << " [FAIL] : in pd_test_boolean_array_reductions() : sum should be 3" << std::endl; throw std::runtime_error("pd_test_boolean_array_reductions failed: sum"); } auto m = arr.mean(); if (!m.has_value() || std::abs(m.value() - 0.75) > 0.001) { std::cout << " [FAIL] : in pd_test_boolean_array_reductions() : mean should be 0.75" << std::endl; throw std::runtime_error("pd_test_boolean_array_reductions failed: mean"); } .. _example-rangeindex-value_counts-37: .. dropdown:: value_counts (pd_test_1_all.cpp:865) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 855 :emphasize-lines: 11 std::vector> values = { std::optional("a"), std::optional("b"), std::optional("a"), std::optional("a"), std::optional("b"), std::nullopt // NA not counted }; pandas::CategoricalArray arr(values); auto [cats, counts] = arr.value_counts(); // Should have 2 categories if (cats.size() != 2 || counts.size() != 2) { std::cout << " [FAIL] : in pd_test_categorical_array_value_counts() : wrong size" << std::endl; throw std::runtime_error("pd_test_categorical_array_value_counts failed: wrong size"); } // Find 'a' count int64_t a_count = 0, b_count = 0; for (size_t i = 0; i < cats.size(); ++i) { .. _example-rangeindex-groupby-38: .. dropdown:: groupby (pd_test_1_all.cpp:11495) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 11485 :emphasize-lines: 11 std::cout << "========= GroupBy basic ========================="; // Create DataFrame with category column std::map> data = { {"category", {1.0, 1.0, 2.0, 2.0, 2.0}}, {"value", {10.0, 20.0, 30.0, 40.0, 50.0}} }; pandas::DataFrame df(data); // Test groupby auto grouped = df.groupby("category"); bool passed = grouped.ngroups() == 2; if (!passed) { std::cout << " [FAIL] : in pd_test_groupby_basic() : ngroups should be 2" << std::endl; throw std::runtime_error("pd_test_groupby_basic failed: ngroups should be 2"); } std::cout << " -> tests passed" << std::endl; } .. _example-rangeindex-equals-39: .. dropdown:: equals (pd_test_1_all.cpp:5866) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 5856 :emphasize-lines: 11 std::cout << "========= equals ======================================"; pandas::CategoricalArray arr1({"a", "b", "a"}); pandas::CategoricalArray arr2({"a", "b", "a"}); pandas::CategoricalArray arr3({"a", "b", "c"}); pandas::CategoricalIndex idx1(arr1); pandas::CategoricalIndex idx2(arr2); pandas::CategoricalIndex idx3(arr3); bool passed = (idx1.equals(idx2) && !idx1.equals(idx3)); if (!passed) { std::cout << " [FAIL] : in pd_test_categorical_index_equals()" << std::endl; throw std::runtime_error("pd_test_categorical_index_equals failed"); } std::cout << " -> tests passed" << std::endl; } void pd_test_categorical_index_identical() { std::cout << "========= identical ==================================="; .. _example-rangeindex-argsort-40: .. dropdown:: argsort (pd_test_1_all.cpp:1304) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 1294 :emphasize-lines: 11 std::cout << "========= DatetimeArray: sorting ======================= "; pandas::DatetimeArray arr(std::vector{ "2023-06-15", "NaT", "2023-01-01", "2023-12-31" }); // argsort ascending auto indices = arr.argsort(true, "last"); // Expected order: 2023-01-01(2), 2023-06-15(0), 2023-12-31(3), NaT(1) if (indices.getElementAt({0}) != 2) { std::cout << " [FAIL] : argsort: first should be index 2 (2023-01-01)" << std::endl; throw std::runtime_error("pd_test_datetime_array_sorting failed: argsort first"); } if (indices.getElementAt({3}) != 1) { std::cout << " [FAIL] : argsort: last should be index 1 (NaT)" << std::endl; throw std::runtime_error("pd_test_datetime_array_sorting failed: NaT position"); } .. _example-rangeindex-searchsorted-41: .. dropdown:: searchsorted (pd_test_1_all.cpp:18958) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 18948 :emphasize-lines: 11 // ========================================================================= // Search Tests // ========================================================================= void pd_test_range_index_searchsorted() { std::cout << "========= searchsorted ================================ "; pandas::RangeIndex ri(0, 10, 2); // [0, 2, 4, 6, 8] bool passed = (ri.searchsorted(4, "left") == 2 && ri.searchsorted(4, "right") == 3 && ri.searchsorted(3, "left") == 2 && // 3 would go between 2 and 4 ri.searchsorted(-1, "left") == 0 && // Before all ri.searchsorted(10, "left") == 5); // After all if (!passed) { std::cout << " [FAIL] : searchsorted" << std::endl; throw std::runtime_error("pd_test_range_index_searchsorted failed"); } .. _example-rangeindex-sort_values-42: .. dropdown:: sort_values (pd_test_1_all.cpp:6408) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 6398 :emphasize-lines: 11 void pd_test_dataframe_sorting() { std::cout << "========= sorting =========================="; std::map> data; data["A"] = {3.0, 1.0, 4.0, 1.0, 5.0}; data["B"] = {9.0, 2.0, 6.0, 5.0, 3.0}; pandas::DataFrame df(data); // Test sort_values ascending auto sorted_asc = df.sort_values("A", true); // First value should be smallest (1.0) std::string first_val = sorted_asc["A"].get_value_str(0); if (std::stod(first_val) != 1.0) { std::cout << " [FAIL] : in pd_test_dataframe_sorting() : sort_values asc first != 1" << std::endl; throw std::runtime_error("pd_test_dataframe_sorting failed: sort_values asc first != 1"); } // Test sort_values descending auto sorted_desc = df.sort_values("A", false); first_val = sorted_desc["A"].get_value_str(0); .. _example-rangeindex-to_frame-43: .. dropdown:: to_frame (pd_test_3_all.cpp:4931) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 4921 :emphasize-lines: 11 size_t usage = mi.memory_usage(true); if (usage == 0) { throw std::runtime_error("memory_usage() should return > 0"); } std::cout << " -> tests passed" << std::endl; } void pd_test_3_all_multiindex_to_frame() { std::cout << "========= MultiIndex.to_frame() ======================="; std::vector> arrays = {{"a", "b"}, {"x", "y"}}; std::vector> names = {"first", "second"}; pandas::MultiIndex mi = pandas::MultiIndex::from_arrays(arrays, names); auto frame = mi.to_frame(); if (frame.find("first") == frame.end() || frame.find("second") == frame.end()) { throw std::runtime_error("to_frame() missing columns"); } .. _example-rangeindex-transpose-44: .. dropdown:: transpose (pd_test_1_all.cpp:16648) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 16638 :emphasize-lines: 11 std::cout << " [FAIL] : in pd_test_ndframe_transpose() : T_() size" << std::endl; throw std::runtime_error("pd_test_ndframe_transpose failed: T_() size"); } passed = transposed[0] == 1 && transposed[1] == 2 && transposed[2] == 3; if (!passed) { std::cout << " [FAIL] : in pd_test_ndframe_transpose() : T_() values" << std::endl; throw std::runtime_error("pd_test_ndframe_transpose failed: T_() values"); } // Test transpose() alias auto transposed2 = s.transpose(); passed = transposed2.size() == s.size(); if (!passed) { std::cout << " [FAIL] : in pd_test_ndframe_transpose() : transpose() size" << std::endl; throw std::runtime_error("pd_test_ndframe_transpose failed: transpose() size"); } std::cout << " -> tests passed" << std::endl; } .. _example-rangeindex-append-45: .. dropdown:: append (pd_test_1_all.cpp:10650) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 10640 :emphasize-lines: 11 std::cout << "========= append ========================="; // Use same categories for both arrays (required by CategoricalArray::concat) std::vector cats = {"a", "b", "c", "d"}; pandas::CategoricalArray arr1({"a", "b"}, cats); pandas::CategoricalIndex idx1(arr1); pandas::CategoricalArray arr2({"c", "d"}, cats); pandas::CategoricalIndex idx2(arr2); auto appended = idx1.append(idx2); bool passed = (appended.size() == 4); if (!passed) { std::cout << " [FAIL] : in pd_test_extension_index_append() : append check failed" << std::endl; throw std::runtime_error("pd_test_extension_index_append failed"); } std::cout << " -> tests passed" << std::endl; } .. _example-rangeindex-join-46: .. dropdown:: join (pd_test_1_all.cpp:12353) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 12343 :emphasize-lines: 11 std::cout << " -> tests passed" << std::endl; } void pd_test_index_join() { std::cout << "========= join ========================================"; pandas::Index idx1{1, 2, 3}; pandas::Index idx2{2, 3, 4}; auto [inner_joined, left_idx, right_idx] = idx1.join(idx2, "inner"); bool passed = (inner_joined.size() == 2); // {2, 3} auto [outer_joined, ol_idx, or_idx] = idx1.join(idx2, "outer"); passed = passed && (outer_joined.size() == 4); // {1, 2, 3, 4} if (!passed) { std::cout << " [FAIL] : in pd_test_index_join() : join failed" << std::endl; throw std::runtime_error("pd_test_index_join failed"); } .. _example-rangeindex-asof-47: .. dropdown:: asof (pd_test_2_all.cpp:366) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 356 :emphasize-lines: 11 std::cout << "====================================== [OK] pd_test_add_prefix test suite ========================== " << std::endl; return 0; } } // namespace dataframe_tests // ------------------- pd_test_add_prefix.cpp (end) ----------------------------- // ------------------- pd_test_asof.cpp (start) ----------------------------- // dataframe_tests/pd_test_asof.cpp // Test for DataFrame.asof() method #include #include #include #include #include "../pandas/pd_dataframe.h" // CRITICAL: No using namespace directives namespace dataframe_tests { .. _example-rangeindex-asof_locs-48: .. dropdown:: asof_locs (pd_test_3_all.cpp:3557) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 3547 :emphasize-lines: 11 throw std::runtime_error("all() should be true for empty index"); } if (empty_idx.any()) { throw std::runtime_error("any() should be false for empty index"); } std::cout << " -> tests passed" << std::endl; } void pd_test_3_all_index_asof() { std::cout << "========= Index.asof()/asof_locs() ================="; // Test with monotonically increasing index pandas::Index idx({10, 20, 30, 40, 50}); // Exact match auto result = idx.asof(30); if (!result.has_value() || result.value() != 30) { throw std::runtime_error("asof() exact match should return 30"); } .. _example-rangeindex-diff-49: .. dropdown:: diff (pd_test_1_all.cpp:5171) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 5161 :emphasize-lines: 11 } void pd_test_arithmetic_dataframe_diff_shift() { std::cout << "========= DataFrame diff/shift =================="; std::map> data; data["A"] = {1.0, 3.0, 6.0, 10.0}; pandas::DataFrame df(data); // diff: [NaN, 2, 3, 4] auto d = df.diff(); std::string val = d["A"].get_value_str(1); bool passed = std::abs(std::stod(val) - 2.0) < 0.001; if (!passed) { std::cout << " [FAIL] : in pd_test_arithmetic_dataframe_diff_shift() : diff failed" << std::endl; throw std::runtime_error("pd_test_arithmetic_dataframe_diff_shift failed: diff failed"); } // First element should be NaN val = d["A"].get_value_str(0); passed = std::isnan(std::stod(val)); .. _example-rangeindex-difference-50: .. dropdown:: difference (pd_test_1_all.cpp:10718) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 10708 :emphasize-lines: 11 std::cout << "========= difference ========================="; // Use same categories for both arrays std::vector cats = {"a", "b", "c", "d"}; pandas::CategoricalArray arr1({"a", "b", "c", "d"}, cats); pandas::CategoricalIndex idx1(arr1); pandas::CategoricalArray arr2({"b", "d"}, cats); pandas::CategoricalIndex idx2(arr2); auto diff = idx1.difference(idx2); bool passed = (diff.size() == 2 && diff.contains("a") && diff.contains("c") && !diff.contains("b") && !diff.contains("d")); if (!passed) { std::cout << " [FAIL] : in pd_test_extension_index_difference() : difference check failed" << std::endl; throw std::runtime_error("pd_test_extension_index_difference failed"); } std::cout << " -> tests passed" << std::endl; .. _example-rangeindex-difference-51: .. dropdown:: difference (pd_test_1_all.cpp:10718) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 10708 :emphasize-lines: 11 std::cout << "========= difference ========================="; // Use same categories for both arrays std::vector cats = {"a", "b", "c", "d"}; pandas::CategoricalArray arr1({"a", "b", "c", "d"}, cats); pandas::CategoricalIndex idx1(arr1); pandas::CategoricalArray arr2({"b", "d"}, cats); pandas::CategoricalIndex idx2(arr2); auto diff = idx1.difference(idx2); bool passed = (diff.size() == 2 && diff.contains("a") && diff.contains("c") && !diff.contains("b") && !diff.contains("d")); if (!passed) { std::cout << " [FAIL] : in pd_test_extension_index_difference() : difference check failed" << std::endl; throw std::runtime_error("pd_test_extension_index_difference failed"); } std::cout << " -> tests passed" << std::endl; .. _example-rangeindex-shift-52: .. dropdown:: shift (pd_test_1_all.cpp:5188) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 5178 :emphasize-lines: 11 // First element should be NaN val = d["A"].get_value_str(0); passed = std::isnan(std::stod(val)); if (!passed) { std::cout << " [FAIL] : in pd_test_arithmetic_dataframe_diff_shift() : diff NaN failed" << std::endl; throw std::runtime_error("pd_test_arithmetic_dataframe_diff_shift failed: diff NaN failed"); } // shift: [NaN, 1, 3, 6] auto s = df.shift(); val = s["A"].get_value_str(1); passed = std::abs(std::stod(val) - 1.0) < 0.001; if (!passed) { std::cout << " [FAIL] : in pd_test_arithmetic_dataframe_diff_shift() : shift failed" << std::endl; throw std::runtime_error("pd_test_arithmetic_dataframe_diff_shift failed: shift failed"); } std::cout << " -> tests passed" << std::endl; } .. _example-rangeindex-to_array-53: .. dropdown:: to_array (pd_test_1_all.cpp:18132) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 18122 :emphasize-lines: 11 if (!passed) { std::cout << " [FAIL] : element access" << std::endl; throw std::runtime_error("pd_test_range_index_element_access failed"); } std::cout << "-> tests passed" << std::endl; } void pd_test_range_index_to_array() { std::cout << "========= to_array (lazy generation) ================== "; pandas::RangeIndex ri(0, 5); numpy::NDArray arr = ri.to_array(); bool passed = (arr.getSize() == 5 && arr.getElementAt({0}) == 0 && arr.getElementAt({4}) == 4); if (!passed) { std::cout << " [FAIL] : to_array" << std::endl; .. _example-rangeindex-to_flat_index-54: .. dropdown:: to_flat_index (pd_test_1_all.cpp:14733) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 14723 :emphasize-lines: 11 void pd_test_multiindex_to_flat_index() { std::cout << "========= to_flat_index =============================== "; std::vector> arrays = { {"a", "b"}, {"x", "y"} }; pandas::MultiIndex mi = pandas::MultiIndex::from_arrays(arrays); auto flat = mi.to_flat_index(); bool passed = (flat.size() == 2 && flat[0][0] == "a" && flat[0][1] == "x" && flat[1][0] == "b" && flat[1][1] == "y"); if (!passed) { std::cout << " [FAIL] : to_flat_index incorrect" << std::endl; throw std::runtime_error("pd_test_multiindex_to_flat_index failed"); } .. _example-rangeindex-to_index-55: .. dropdown:: to_index (pd_test_1_all.cpp:18935) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 18925 :emphasize-lines: 11 throw std::runtime_error("pd_test_range_index_clone failed"); } std::cout << "-> tests passed" << std::endl; } void pd_test_range_index_to_index() { std::cout << "========= to_index ==================================== "; pandas::RangeIndex ri(0, 5, 1, "test"); pandas::Index idx = ri.to_index(); bool passed = (idx.size() == 5 && idx[0] == 0 && idx[4] == 4 && idx.name().value() == "test"); if (!passed) { std::cout << " [FAIL] : to_index" << std::endl; throw std::runtime_error("pd_test_range_index_to_index failed"); } .. _example-rangeindex-to_list-56: .. dropdown:: to_list (pd_test_1_all.cpp:10247) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 10237 :emphasize-lines: 11 std::cout << " -> tests passed" << std::endl; } void pd_test_extension_index_to_list() { std::cout << "========= to_list ========================="; pandas::CategoricalArray arr({"x", "y", "z"}); pandas::CategoricalIndex idx(arr); auto list = idx.to_list(); bool passed = (list.size() == 3 && list[0].has_value() && *list[0] == "x" && list[1].has_value() && *list[1] == "y" && list[2].has_value() && *list[2] == "z"); if (!passed) { std::cout << " [FAIL] : in pd_test_extension_index_to_list() : to_list check failed" << std::endl; throw std::runtime_error("pd_test_extension_index_to_list failed"); } .. _example-rangeindex-to_numpy-57: .. dropdown:: to_numpy (pd_test_1_all.cpp:16764) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 16754 :emphasize-lines: 11 // ===================================================================== // to_numpy Tests // ===================================================================== void pd_test_ndframe_to_numpy() { std::cout << "========= to_numpy =============================================" << std::endl; pandas::Series s({10, 20, 30}); auto arr = s.to_numpy(); bool passed = arr.getSize() == 3; if (!passed) { std::cout << " [FAIL] : in pd_test_ndframe_to_numpy() : size" << std::endl; throw std::runtime_error("pd_test_ndframe_to_numpy failed: size"); } passed = arr.getElementAt({0}) == 10 && arr.getElementAt({1}) == 20 && arr.getElementAt({2}) == 30; if (!passed) { std::cout << " [FAIL] : in pd_test_ndframe_to_numpy() : values" << std::endl; .. _example-rangeindex-to_series-58: .. dropdown:: to_series (pd_test_3_all.cpp:5788) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 5778 :emphasize-lines: 11 throw std::runtime_error("to_frame use_index should be false when index=false"); } if (frame3.column_name != "0") { throw std::runtime_error("to_frame column_name should be '0' when no name"); } std::cout << " -> tests passed" << std::endl; } void pd_test_3_all_period_index_to_series() { std::cout << "========= PeriodIndex.to_series() ====================="; pandas::PeriodIndex idx = make_period_index({1, 2, 3}, "M").rename("periods"); // Test to_series() with default parameters pandas::PeriodIndex::SeriesData series = idx.to_series(); // values should have same size if (series.values.size() != 3) { throw std::runtime_error("to_series values size should be 3"); } .. _example-rangeindex-to_string-59: .. dropdown:: to_string (pd_test_1_all.cpp:2693) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 2683 :emphasize-lines: 11 pandas::PeriodArray arr_m(std::vector{ "2020-01", "NaT", "2025-06" }, "M"); // Year auto years = arr_m.year(); auto y0 = years[0]; if (!y0.has_value() || y0.value() != 2020) { std::cout << " [FAIL] : year[0] should be 2020, got " << (y0.has_value() ? std::to_string(y0.value()) : "NA") << std::endl; throw std::runtime_error("pd_test_period_array_year_month_quarter failed: year[0]"); } auto y1 = years[1]; if (y1.has_value()) { std::cout << " [FAIL] : year[1] should be NA (NaT)" << std::endl; throw std::runtime_error("pd_test_period_array_year_month_quarter failed: year[1] should be NA"); } auto y2 = years[2]; .. _example-rangeindex-to_string_vector-60: .. dropdown:: to_string_vector (pd_test_1_all.cpp:10871) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 10861 :emphasize-lines: 11 std::cout << " -> tests passed" << std::endl; } void pd_test_extension_index_to_string_vector() { std::cout << "========= to_string_vector ========================="; pandas::CategoricalArray arr({"a", std::nullopt, "c"}); pandas::CategoricalIndex idx(arr); auto str_vec = idx.to_string_vector(); bool passed = (str_vec.size() == 3 && str_vec[0] == "a" && str_vec[1] == "NA" && str_vec[2] == "c"); if (!passed) { std::cout << " [FAIL] : in pd_test_extension_index_to_string_vector() : to_string_vector check failed" << std::endl; throw std::runtime_error("pd_test_extension_index_to_string_vector failed"); } std::cout << " -> tests passed" << std::endl; } .. _example-rangeindex-tolist-61: .. dropdown:: tolist (pd_test_3_all.cpp:2300) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 2290 :emphasize-lines: 11 threw = true; } if (!threw) { throw std::runtime_error("swapaxes should throw for invalid axes"); } std::cout << " -> tests passed" << std::endl; } void pd_test_3_all_categorical_to_list() { std::cout << "========= CategoricalArray.to_list()/tolist() ========="; std::vector> values = {"a", "b", std::nullopt, "c"}; pandas::CategoricalArray arr(values); auto list = arr.to_list(); if (list.size() != 4 || *list[0] != "a" || *list[1] != "b" || list[2].has_value() || *list[3] != "c") { throw std::runtime_error("to_list failed"); } .. _example-rangeindex-copy-62: .. dropdown:: copy (pd_test_1_all.cpp:5798) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 5788 :emphasize-lines: 11 // ============================================================================ // Copy/Rename Tests // ============================================================================ void pd_test_categorical_index_copy() { std::cout << "========= copy ========================================"; pandas::CategoricalArray arr({"a", "b", "c"}); pandas::CategoricalIndex idx(arr, "original"); pandas::CategoricalIndex copied = idx.copy(); bool passed = (copied.size() == idx.size() && copied.name() == idx.name() && copied.categories() == idx.categories() && copied.ordered() == idx.ordered()); if (!passed) { std::cout << " [FAIL] : in pd_test_categorical_index_copy()" << std::endl; throw std::runtime_error("pd_test_categorical_index_copy failed"); } std::cout << " -> tests passed" << std::endl; } .. _example-rangeindex-infer_objects-63: .. dropdown:: infer_objects (pd_test_1_all.cpp:27595) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 27585 :emphasize-lines: 11 // Create DataFrame with string column containing integers std::map> data; data["A"] = {"1", "2", "3", "4", "5"}; pandas::DataFrame df(data); // Before inference, dtype should be string/object std::string before_dtype = df["A"].dtype_name(); // Apply infer_objects pandas::DataFrame result = df.infer_objects(); // After inference, dtype should be int64 std::string after_dtype = result["A"].dtype_name(); bool passed = (after_dtype == "int64"); if (!passed) { std::cout << " [FAIL] : in pd_test_infer_objects_integer_column() : expected int64, got " << after_dtype << std::endl; throw std::runtime_error("pd_test_infer_objects_integer_column failed"); } .. _example-rangeindex-view-64: .. dropdown:: view (pd_test_3_all.cpp:2147) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 2137 :emphasize-lines: 11 throw std::runtime_error("memory_usage shallow too small"); } if (deep < shallow) { throw std::runtime_error("memory_usage deep should be >= shallow"); } std::cout << " -> tests passed" << std::endl; } void pd_test_3_all_categorical_ravel_view() { std::cout << "========= CategoricalArray.ravel()/view() ============="; std::vector> values = {"a", "b", "c"}; pandas::CategoricalArray arr(values); auto raveled = arr.ravel(); if (raveled.size() != 3 || !raveled.equals(arr)) { throw std::runtime_error("ravel failed"); } auto viewed = arr.view(); .. _example-rangeindex-duplicated-65: .. dropdown:: duplicated (pd_test_1_all.cpp:10583) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 10573 :emphasize-lines: 11 std::cout << " -> tests passed" << std::endl; } void pd_test_extension_index_duplicated() { std::cout << "========= duplicated ========================="; pandas::CategoricalArray arr({"a", "b", "a", "c", "a"}); pandas::CategoricalIndex idx(arr); auto dup_mask = idx.duplicated("first"); bool passed = (dup_mask.getElementAt({0}) == false && dup_mask.getElementAt({1}) == false && dup_mask.getElementAt({2}) == true && dup_mask.getElementAt({3}) == false && dup_mask.getElementAt({4}) == true); if (!passed) { std::cout << " [FAIL] : in pd_test_extension_index_duplicated() : duplicated check failed" << std::endl; throw std::runtime_error("pd_test_extension_index_duplicated failed"); } .. _example-rangeindex-intersection-66: .. dropdown:: intersection (pd_test_1_all.cpp:10672) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 10662 :emphasize-lines: 11 std::cout << "========= intersection ========================="; // Use same categories for both arrays std::vector cats = {"a", "b", "c", "d", "e", "f"}; pandas::CategoricalArray arr1({"a", "b", "c", "d"}, cats); pandas::CategoricalIndex idx1(arr1); pandas::CategoricalArray arr2({"b", "c", "e", "f"}, cats); pandas::CategoricalIndex idx2(arr2); auto inter = idx1.intersection(idx2); bool passed = (inter.size() == 2 && inter.contains("b") && inter.contains("c")); if (!passed) { std::cout << " [FAIL] : in pd_test_extension_index_intersection() : intersection check failed" << std::endl; throw std::runtime_error("pd_test_extension_index_intersection failed"); } std::cout << " -> tests passed" << std::endl; } .. _example-rangeindex-intersection-67: .. dropdown:: intersection (pd_test_1_all.cpp:10672) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 10662 :emphasize-lines: 11 std::cout << "========= intersection ========================="; // Use same categories for both arrays std::vector cats = {"a", "b", "c", "d", "e", "f"}; pandas::CategoricalArray arr1({"a", "b", "c", "d"}, cats); pandas::CategoricalIndex idx1(arr1); pandas::CategoricalArray arr2({"b", "c", "e", "f"}, cats); pandas::CategoricalIndex idx2(arr2); auto inter = idx1.intersection(idx2); bool passed = (inter.size() == 2 && inter.contains("b") && inter.contains("c")); if (!passed) { std::cout << " [FAIL] : in pd_test_extension_index_intersection() : intersection check failed" << std::endl; throw std::runtime_error("pd_test_extension_index_intersection failed"); } std::cout << " -> tests passed" << std::endl; } .. _example-rangeindex-isin-68: .. dropdown:: isin (pd_test_1_all.cpp:5938) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 5928 :emphasize-lines: 11 std::cout << " -> tests passed" << std::endl; } void pd_test_categorical_index_isin() { std::cout << "========= inherited isin =============================="; pandas::CategoricalArray arr({"a", "b", "c", "d"}); pandas::CategoricalIndex idx(arr); std::vector values = {"a", "c"}; numpy::NDArray mask = idx.isin(values); bool passed = (mask.getSize() == 4 && mask.getElementAt({0}) == true && // a mask.getElementAt({1}) == false && // b mask.getElementAt({2}) == true && // c mask.getElementAt({3}) == false); // d if (!passed) { std::cout << " [FAIL] : in pd_test_categorical_index_isin()" << std::endl; throw std::runtime_error("pd_test_categorical_index_isin failed"); } .. _example-rangeindex-symmetric_difference-69: .. dropdown:: symmetric_difference (pd_test_1_all.cpp:10742) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 10732 :emphasize-lines: 11 std::cout << "========= symmetric_difference ========================="; // Use same categories for both arrays std::vector cats = {"a", "b", "c", "d"}; pandas::CategoricalArray arr1({"a", "b", "c"}, cats); pandas::CategoricalIndex idx1(arr1); pandas::CategoricalArray arr2({"b", "c", "d"}, cats); pandas::CategoricalIndex idx2(arr2); auto sym_diff = idx1.symmetric_difference(idx2); bool passed = (sym_diff.size() == 2 && sym_diff.contains("a") && sym_diff.contains("d") && !sym_diff.contains("b") && !sym_diff.contains("c")); if (!passed) { std::cout << " [FAIL] : in pd_test_extension_index_symmetric_difference() : symmetric_difference check failed" << std::endl; throw std::runtime_error("pd_test_extension_index_symmetric_difference failed"); } std::cout << " -> tests passed" << std::endl; .. _example-rangeindex-symmetric_difference-70: .. dropdown:: symmetric_difference (pd_test_1_all.cpp:10742) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 10732 :emphasize-lines: 11 std::cout << "========= symmetric_difference ========================="; // Use same categories for both arrays std::vector cats = {"a", "b", "c", "d"}; pandas::CategoricalArray arr1({"a", "b", "c"}, cats); pandas::CategoricalIndex idx1(arr1); pandas::CategoricalArray arr2({"b", "c", "d"}, cats); pandas::CategoricalIndex idx2(arr2); auto sym_diff = idx1.symmetric_difference(idx2); bool passed = (sym_diff.size() == 2 && sym_diff.contains("a") && sym_diff.contains("d") && !sym_diff.contains("b") && !sym_diff.contains("c")); if (!passed) { std::cout << " [FAIL] : in pd_test_extension_index_symmetric_difference() : symmetric_difference check failed" << std::endl; throw std::runtime_error("pd_test_extension_index_symmetric_difference failed"); } std::cout << " -> tests passed" << std::endl; .. _example-rangeindex-union_-71: .. dropdown:: union_ (pd_test_1_all.cpp:10694) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 10684 :emphasize-lines: 11 std::cout << "========= union ========================="; // Use same categories for both arrays std::vector cats = {"a", "b", "c", "d", "e"}; pandas::CategoricalArray arr1({"a", "b", "c"}, cats); pandas::CategoricalIndex idx1(arr1); pandas::CategoricalArray arr2({"b", "c", "d", "e"}, cats); pandas::CategoricalIndex idx2(arr2); auto uni = idx1.union_(idx2); bool passed = (uni.size() == 5 && uni.contains("a") && uni.contains("b") && uni.contains("c") && uni.contains("d") && uni.contains("e")); if (!passed) { std::cout << " [FAIL] : in pd_test_extension_index_union() : union check failed" << std::endl; throw std::runtime_error("pd_test_extension_index_union failed"); } std::cout << " -> tests passed" << std::endl; .. _example-rangeindex-unique-72: .. dropdown:: unique (pd_test_1_all.cpp:1345) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 1335 :emphasize-lines: 11 pandas::DatetimeArray arr(std::vector{ "2023-01-01", "2023-06-15", "2023-01-01", "NaT", "2023-06-15", "NaT" }); // unique auto uniq = arr.unique(); // Should have: NaT, 2023-01-01, 2023-06-15 (3 unique values) if (uniq.size() != 3) { std::cout << " [FAIL] : unique size should be 3, got " << uniq.size() << std::endl; throw std::runtime_error("pd_test_datetime_array_unique failed: size"); } // factorize auto [codes, uniques] = arr.factorize(); // Codes for NaT should be -1 if (codes.getElementAt({3}) != -1) { .. _example-rangeindex-is_-73: .. dropdown:: is_ (pd_test_3_all.cpp:3972) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 3962 :emphasize-lines: 11 // For typed Index, this is a no-op if (result.size() != 5) { throw std::runtime_error("infer_objects size should be 5"); } std::cout << " -> tests passed" << std::endl; } void pd_test_3_all_index_is_() { std::cout << "========= Index.is_() =============================="; pandas::Index idx1({1, 2, 3, 4, 5}); pandas::Index idx2({1, 2, 3, 4, 5}); // Different object // Different objects should not be the same if (idx1.is_(idx2)) { throw std::runtime_error("different objects should not be is_() equal"); } // Same object should be the same .. _example-rangeindex-is_boolean-74: .. dropdown:: is_boolean (pd_test_3_all.cpp:3290) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 3280 :emphasize-lines: 11 std::cout << " -> tests passed" << std::endl; } void pd_test_3_all_datetime_index_type_checks() { std::cout << "========= DatetimeIndex type checks ======================"; pandas::DatetimeIndex idx = pandas::date_range("2024-01-01", "2024-01-05", std::nullopt, "D"); // Type check methods if (idx.is_boolean()) { throw std::runtime_error("is_boolean() should be false"); } if (idx.is_categorical()) { throw std::runtime_error("is_categorical() should be false"); } if (idx.is_floating()) { throw std::runtime_error("is_floating() should be false"); } if (idx.is_integer()) { throw std::runtime_error("is_integer() should be false"); .. _example-rangeindex-is_categorical-75: .. dropdown:: is_categorical (pd_test_3_all.cpp:3293) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 3283 :emphasize-lines: 11 void pd_test_3_all_datetime_index_type_checks() { std::cout << "========= DatetimeIndex type checks ======================"; pandas::DatetimeIndex idx = pandas::date_range("2024-01-01", "2024-01-05", std::nullopt, "D"); // Type check methods if (idx.is_boolean()) { throw std::runtime_error("is_boolean() should be false"); } if (idx.is_categorical()) { throw std::runtime_error("is_categorical() should be false"); } if (idx.is_floating()) { throw std::runtime_error("is_floating() should be false"); } if (idx.is_integer()) { throw std::runtime_error("is_integer() should be false"); } if (idx.is_interval()) { throw std::runtime_error("is_interval() should be false"); .. _example-rangeindex-is_floating-76: .. dropdown:: is_floating (pd_test_3_all.cpp:622) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 612 :emphasize-lines: 11 // Test with integer index pandas::IndexDtype int_dtype; if (!int_dtype.is_numeric()) { std::cout << " [FAIL] : in pd_test_3_all_index_dtype_checks() : int should be numeric" << std::endl; throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_numeric"); } if (!int_dtype.is_integer()) { std::cout << " [FAIL] : in pd_test_3_all_index_dtype_checks() : int should be integer" << std::endl; throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_integer"); } if (int_dtype.is_floating()) { std::cout << " [FAIL] : in pd_test_3_all_index_dtype_checks() : int should not be floating" << std::endl; throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_floating"); } if (int_dtype.is_object()) { std::cout << " [FAIL] : in pd_test_3_all_index_dtype_checks() : int should not be object" << std::endl; throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_object"); } // Test with float index pandas::IndexDtype float_dtype; .. _example-rangeindex-is_integer-77: .. dropdown:: is_integer (pd_test_3_all.cpp:618) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 608 :emphasize-lines: 11 void pd_test_3_all_index_dtype_checks() { std::cout << "========= IndexDtype.is_numeric/integer/floating/object() "; // Test with integer index pandas::IndexDtype int_dtype; if (!int_dtype.is_numeric()) { std::cout << " [FAIL] : in pd_test_3_all_index_dtype_checks() : int should be numeric" << std::endl; throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_numeric"); } if (!int_dtype.is_integer()) { std::cout << " [FAIL] : in pd_test_3_all_index_dtype_checks() : int should be integer" << std::endl; throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_integer"); } if (int_dtype.is_floating()) { std::cout << " [FAIL] : in pd_test_3_all_index_dtype_checks() : int should not be floating" << std::endl; throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_floating"); } if (int_dtype.is_object()) { std::cout << " [FAIL] : in pd_test_3_all_index_dtype_checks() : int should not be object" << std::endl; throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_object"); .. _example-rangeindex-is_interval-78: .. dropdown:: is_interval (pd_test_3_all.cpp:3302) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 3292 :emphasize-lines: 11 } if (idx.is_categorical()) { throw std::runtime_error("is_categorical() should be false"); } if (idx.is_floating()) { throw std::runtime_error("is_floating() should be false"); } if (idx.is_integer()) { throw std::runtime_error("is_integer() should be false"); } if (idx.is_interval()) { throw std::runtime_error("is_interval() should be false"); } if (idx.is_numeric()) { throw std::runtime_error("is_numeric() should be false"); } if (idx.is_object()) { throw std::runtime_error("is_object() should be false"); } if (idx.holds_integer()) { throw std::runtime_error("holds_integer() should be false"); .. _example-rangeindex-is_monotonic_decreasing-79: .. dropdown:: is_monotonic_decreasing (pd_test_1_all.cpp:10203) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 10193 :emphasize-lines: 11 } void pd_test_extension_index_monotonicity() { std::cout << "========= monotonicity ========================="; pandas::CategoricalArray arr1({"a", "b", "c"}); pandas::CategoricalIndex idx1(arr1); // Just test that the methods work (result depends on internal ordering) bool inc = idx1.is_monotonic_increasing(); bool dec = idx1.is_monotonic_decreasing(); bool passed = (inc || dec || (!inc && !dec)); // Any result is valid if (!passed) { std::cout << " [FAIL] : in pd_test_extension_index_monotonicity() : monotonicity check failed" << std::endl; throw std::runtime_error("pd_test_extension_index_monotonicity failed"); } std::cout << " -> tests passed" << std::endl; } .. _example-rangeindex-is_monotonic_increasing-80: .. dropdown:: is_monotonic_increasing (pd_test_1_all.cpp:10202) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 10192 :emphasize-lines: 11 std::cout << " -> tests passed" << std::endl; } void pd_test_extension_index_monotonicity() { std::cout << "========= monotonicity ========================="; pandas::CategoricalArray arr1({"a", "b", "c"}); pandas::CategoricalIndex idx1(arr1); // Just test that the methods work (result depends on internal ordering) bool inc = idx1.is_monotonic_increasing(); bool dec = idx1.is_monotonic_decreasing(); bool passed = (inc || dec || (!inc && !dec)); // Any result is valid if (!passed) { std::cout << " [FAIL] : in pd_test_extension_index_monotonicity() : monotonicity check failed" << std::endl; throw std::runtime_error("pd_test_extension_index_monotonicity failed"); } std::cout << " -> tests passed" << std::endl; } .. _example-rangeindex-is_numeric-81: .. dropdown:: is_numeric (pd_test_3_all.cpp:614) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 604 :emphasize-lines: 11 // ============================================================================ // Category 4: Index Type Checking (IndexDtype) // ============================================================================ void pd_test_3_all_index_dtype_checks() { std::cout << "========= IndexDtype.is_numeric/integer/floating/object() "; // Test with integer index pandas::IndexDtype int_dtype; if (!int_dtype.is_numeric()) { std::cout << " [FAIL] : in pd_test_3_all_index_dtype_checks() : int should be numeric" << std::endl; throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_numeric"); } if (!int_dtype.is_integer()) { std::cout << " [FAIL] : in pd_test_3_all_index_dtype_checks() : int should be integer" << std::endl; throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_integer"); } if (int_dtype.is_floating()) { std::cout << " [FAIL] : in pd_test_3_all_index_dtype_checks() : int should not be floating" << std::endl; throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_floating"); .. _example-rangeindex-is_object-82: .. dropdown:: is_object (pd_test_3_all.cpp:626) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 616 :emphasize-lines: 11 throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_numeric"); } if (!int_dtype.is_integer()) { std::cout << " [FAIL] : in pd_test_3_all_index_dtype_checks() : int should be integer" << std::endl; throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_integer"); } if (int_dtype.is_floating()) { std::cout << " [FAIL] : in pd_test_3_all_index_dtype_checks() : int should not be floating" << std::endl; throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_floating"); } if (int_dtype.is_object()) { std::cout << " [FAIL] : in pd_test_3_all_index_dtype_checks() : int should not be object" << std::endl; throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_object"); } // Test with float index pandas::IndexDtype float_dtype; if (!float_dtype.is_numeric()) { std::cout << " [FAIL] : in pd_test_3_all_index_dtype_checks() : float should be numeric" << std::endl; throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: float is_numeric"); } .. _example-rangeindex-is_range_index-83: .. dropdown:: is_range_index (pd_test_5_all.cpp:21595) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 21585 :emphasize-lines: 11 << local_fail << " checks failed" << std::endl; throw std::runtime_error("f_test_merge_int_dtype_upcast_4 failed"); } std::cout << " -> tests passed" << std::endl; } // --- f_test_rename_column_width_bug_4.cpp --- namespace f_test_rename_column_width_bug_4_ns { static bool is_range_index(const pandas::DataFrame& df) { return dynamic_cast(&df.index()) != nullptr; } static void diff_print(const std::string& got, const std::string& expected, const std::string& label) { if (got == expected) return; std::cout << " [" << label << "] to_string MISMATCH\n"; std::cout << " --- got ---\n"; std::cout << got << "\n"; .. _example-rangeindex-is_unique-84: .. dropdown:: is_unique (pd_test_1_all.cpp:5962) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 5952 :emphasize-lines: 11 void pd_test_categorical_index_is_unique() { std::cout << "========= inherited is_unique ========================="; pandas::CategoricalArray arr_unique({"a", "b", "c"}); pandas::CategoricalArray arr_dups({"a", "b", "a"}); pandas::CategoricalIndex idx_unique(arr_unique); pandas::CategoricalIndex idx_dups(arr_dups); bool passed = (idx_unique.is_unique() && !idx_dups.is_unique()); if (!passed) { std::cout << " [FAIL] : in pd_test_categorical_index_is_unique()" << std::endl; throw std::runtime_error("pd_test_categorical_index_is_unique failed"); } std::cout << " -> tests passed" << std::endl; } void pd_test_categorical_index_hasnans() { std::cout << "========= inherited hasnans ==========================="; .. _example-rangeindex-abs-85: .. dropdown:: abs (pd_test_1_all.cpp:283) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 273 :emphasize-lines: 11 std::optional(true) }); auto s = arr.sum(); if (!s.has_value() || s.value() != 3) { std::cout << " [FAIL] : in pd_test_boolean_array_reductions() : sum should be 3" << std::endl; throw std::runtime_error("pd_test_boolean_array_reductions failed: sum"); } auto m = arr.mean(); if (!m.has_value() || std::abs(m.value() - 0.75) > 0.001) { std::cout << " [FAIL] : in pd_test_boolean_array_reductions() : mean should be 0.75" << std::endl; throw std::runtime_error("pd_test_boolean_array_reductions failed: mean"); } std::cout << " -> tests passed" << std::endl; } void pd_test_boolean_array_dtype() { std::cout << "========= BooleanArray: dtype ======================= "; .. _example-rangeindex-all-86: .. dropdown:: all (pd_test_1_all.cpp:247) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 237 :emphasize-lines: 11 pandas::BooleanArray has_true({ std::optional(false), std::optional(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(true), std::optional(true) }); auto all_result = all_true.all(); if (!all_result.has_value() || !all_result.value()) { std::cout << " [FAIL] : in pd_test_boolean_array_reductions() : all() of all True" << std::endl; throw std::runtime_error("pd_test_boolean_array_reductions failed: all() all True"); } .. _example-rangeindex-any-87: .. dropdown:: any (pd_test_1_all.cpp:226) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 216 :emphasize-lines: 11 std::cout << " [FAIL] : in pd_test_boolean_array_kleene_not() : ~NA should be NA" << std::endl; throw std::runtime_error("pd_test_boolean_array_kleene_not failed: ~NA"); } std::cout << " -> tests passed" << std::endl; } void pd_test_boolean_array_reductions() { std::cout << "========= BooleanArray: reductions ======================= "; // Test any() pandas::BooleanArray all_false({ std::optional(false), std::optional(false) }); auto any_result = all_false.any(); if (!any_result.has_value() || any_result.value()) { std::cout << " [FAIL] : in pd_test_boolean_array_reductions() : any() of all False" << std::endl; throw std::runtime_error("pd_test_boolean_array_reductions failed: any() all False"); } .. _example-rangeindex-argmax-88: .. dropdown:: argmax (pd_test_1_all.cpp:1323) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 1313 :emphasize-lines: 11 } // argmin auto min_idx = arr.argmin(); if (!min_idx.has_value() || min_idx.value() != 2) { std::cout << " [FAIL] : argmin should be 2 (2023-01-01)" << std::endl; throw std::runtime_error("pd_test_datetime_array_sorting failed: argmin"); } // argmax auto max_idx = arr.argmax(); if (!max_idx.has_value() || max_idx.value() != 3) { std::cout << " [FAIL] : argmax should be 3 (2023-12-31)" << std::endl; throw std::runtime_error("pd_test_datetime_array_sorting failed: argmax"); } std::cout << " -> tests passed" << std::endl; } void pd_test_datetime_array_unique() { std::cout << "========= DatetimeArray: unique/factorize ======================= "; .. _example-rangeindex-argmin-89: .. dropdown:: argmin (pd_test_1_all.cpp:1316) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 1306 :emphasize-lines: 11 if (indices.getElementAt({0}) != 2) { std::cout << " [FAIL] : argsort: first should be index 2 (2023-01-01)" << std::endl; throw std::runtime_error("pd_test_datetime_array_sorting failed: argsort first"); } if (indices.getElementAt({3}) != 1) { std::cout << " [FAIL] : argsort: last should be index 1 (NaT)" << std::endl; throw std::runtime_error("pd_test_datetime_array_sorting failed: NaT position"); } // argmin auto min_idx = arr.argmin(); if (!min_idx.has_value() || min_idx.value() != 2) { std::cout << " [FAIL] : argmin should be 2 (2023-01-01)" << std::endl; throw std::runtime_error("pd_test_datetime_array_sorting failed: argmin"); } // argmax auto max_idx = arr.argmax(); if (!max_idx.has_value() || max_idx.value() != 3) { std::cout << " [FAIL] : argmax should be 3 (2023-12-31)" << std::endl; throw std::runtime_error("pd_test_datetime_array_sorting failed: argmax"); .. _example-rangeindex-clear_cache-90: .. dropdown:: clear_cache (pd_test_1_all.cpp:19413) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 19403 :emphasize-lines: 11 s.mean(); s.min(); s.max(); passed = s.has_cached_values() == true; if (!passed) { std::cout << " [FAIL] : in pd_test_series_cache() : cache not populated" << std::endl; throw std::runtime_error("pd_test_series_cache failed: cache not populated"); } s.clear_cache(); passed = s.has_cached_values() == false; if (!passed) { std::cout << " [FAIL] : in pd_test_series_cache() : cache not cleared" << std::endl; throw std::runtime_error("pd_test_series_cache failed: cache not cleared"); } std::cout << " -> tests passed" << std::endl; } void pd_test_series_string_repr() { .. _example-rangeindex-clone-91: .. dropdown:: clone (pd_test_1_all.cpp:5776) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 5766 :emphasize-lines: 11 std::cout << " -> tests passed" << std::endl; } void pd_test_categorical_index_clone() { std::cout << "========= clone ======================================="; pandas::CategoricalArray arr({"p", "q", "r"}); pandas::CategoricalIndex idx(arr, "original"); std::unique_ptr cloned = idx.clone(); bool passed = (cloned != nullptr && cloned->size() == idx.size() && cloned->name() == idx.name()); if (!passed) { std::cout << " [FAIL] : in pd_test_categorical_index_clone()" << std::endl; throw std::runtime_error("pd_test_categorical_index_clone failed"); } std::cout << " -> tests passed" << std::endl; } .. _example-rangeindex-contains-92: .. dropdown:: contains (pd_test_1_all.cpp:2200) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 2190 :emphasize-lines: 11 // Test: contains method // ============================================================================ void test_contains() { std::cout << "========= IntervalArray: contains ======================= "; std::vector breaks = {0.0, 1.0, 2.0, 3.0}; // Right-closed intervals: (0, 1], (1, 2], (2, 3] auto arr_right = pandas::IntervalArrayFloat64::from_breaks(breaks, pandas::IntervalClosed::Right); // Test contains(1.0) - should be in interval 0 but not 1 (since 1 is exclusive on left of interval 1) auto contains_1 = arr_right.contains(1.0); // (0, 1] contains 1: yes, (1, 2] contains 1: no (open on left), (2, 3] contains 1: no if (contains_1[0].value_or(false) != true || contains_1[1].value_or(true) != false || contains_1[2].value_or(true) != false) { std::cout << "[FAIL] : in test_contains() : right-closed contains 1.0" << std::endl; return; } // Left-closed intervals: [0, 1), [1, 2), [2, 3) .. _example-rangeindex-contains_str-93: .. dropdown:: contains_str (pd_test_1_all.cpp:10889) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 10879 :emphasize-lines: 11 std::cout << " -> tests passed" << std::endl; } void pd_test_extension_index_contains_str_get_loc_str() { std::cout << "========= contains_str/get_loc_str ========================="; pandas::CategoricalArray arr({"apple", "banana", "cherry"}); pandas::CategoricalIndex idx(arr); bool passed = (idx.contains_str("apple") && !idx.contains_str("grape") && idx.get_loc_str("banana") == 1 && idx.get_loc_str("grape") == -1); if (!passed) { std::cout << " [FAIL] : in pd_test_extension_index_contains_str_get_loc_str() : contains_str/get_loc_str check failed" << std::endl; throw std::runtime_error("pd_test_extension_index_contains_str_get_loc_str failed"); } std::cout << " -> tests passed" << std::endl; } void pd_test_extension_index_repr() { .. _example-rangeindex-delete_-94: .. dropdown:: delete_ (pd_test_1_all.cpp:10501) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 10491 :emphasize-lines: 11 std::cout << " -> tests passed" << std::endl; } void pd_test_extension_index_delete() { std::cout << "========= delete_ ========================="; pandas::CategoricalArray arr({"a", "b", "c", "d"}); pandas::CategoricalIndex idx(arr); auto deleted = idx.delete_(1); auto v0 = deleted[0]; auto v1 = deleted[1]; auto v2 = deleted[2]; bool passed = (deleted.size() == 3 && v0.has_value() && *v0 == "a" && v1.has_value() && *v1 == "c" && v2.has_value() && *v2 == "d"); if (!passed) { std::cout << " [FAIL] : in pd_test_extension_index_delete() : delete_ check failed" << std::endl; .. _example-rangeindex-delete_-95: .. dropdown:: delete_ (pd_test_1_all.cpp:10501) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 10491 :emphasize-lines: 11 std::cout << " -> tests passed" << std::endl; } void pd_test_extension_index_delete() { std::cout << "========= delete_ ========================="; pandas::CategoricalArray arr({"a", "b", "c", "d"}); pandas::CategoricalIndex idx(arr); auto deleted = idx.delete_(1); auto v0 = deleted[0]; auto v1 = deleted[1]; auto v2 = deleted[2]; bool passed = (deleted.size() == 3 && v0.has_value() && *v0 == "a" && v1.has_value() && *v1 == "c" && v2.has_value() && *v2 == "d"); if (!passed) { std::cout << " [FAIL] : in pd_test_extension_index_delete() : delete_ check failed" << std::endl; .. _example-rangeindex-dtype_name-96: .. dropdown:: dtype_name (pd_test_1_all.cpp:10104) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 10094 :emphasize-lines: 11 } void pd_test_extension_index_array_constructor() { std::cout << "========= array constructor ========================="; pandas::CategoricalArray arr({"apple", "banana", "apple", "cherry"}); pandas::CategoricalIndex idx(arr, "fruits"); bool passed = (idx.size() == 4 && !idx.empty() && idx.name().has_value() && *idx.name() == "fruits" && idx.dtype_name() == "category"); if (!passed) { std::cout << " [FAIL] : in pd_test_extension_index_array_constructor() : array constructor check failed" << std::endl; throw std::runtime_error("pd_test_extension_index_array_constructor failed"); } std::cout << " -> tests passed" << std::endl; } void pd_test_extension_index_copy_constructor() { std::cout << "========= copy constructor ========================="; .. _example-rangeindex-empty-97: .. dropdown:: empty (pd_test_1_all.cpp:941) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 931 :emphasize-lines: 11 #include "../pandas/pd_config.h" namespace dataframe_tests { namespace dataframe_tests_config { void pd_test_config_version() { std::cout << "========= df_config: version info ======================= "; const char* version = pandas::DataFrameInfo::version(); if (version == nullptr || std::string(version).empty()) { std::cout << "[FAIL] : in pd_test_config_version() : version is null or empty" << std::endl; throw std::runtime_error("pd_test_config_version failed: version is null or empty"); } std::cout << "-> tests passed" << std::endl; } void pd_test_config_na_repr() { std::cout << "========= df_config: NA representation ======================= "; const char* na_repr = pandas::DataFrameConfig::get_na_repr(); if (na_repr == nullptr) { .. _example-rangeindex-factorize-98: .. dropdown:: factorize (pd_test_1_all.cpp:1353) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 1343 :emphasize-lines: 11 // unique auto uniq = arr.unique(); // Should have: NaT, 2023-01-01, 2023-06-15 (3 unique values) if (uniq.size() != 3) { std::cout << " [FAIL] : unique size should be 3, got " << uniq.size() << std::endl; throw std::runtime_error("pd_test_datetime_array_unique failed: size"); } // factorize auto [codes, uniques] = arr.factorize(); // Codes for NaT should be -1 if (codes.getElementAt({3}) != -1) { std::cout << " [FAIL] : factorize: NaT code should be -1" << std::endl; throw std::runtime_error("pd_test_datetime_array_unique failed: NaT code"); } // Same values should have same codes if (codes.getElementAt({0}) != codes.getElementAt({2})) { std::cout << " [FAIL] : factorize: 2023-01-01 values should have same code" << std::endl; throw std::runtime_error("pd_test_datetime_array_unique failed: same code"); } .. _example-rangeindex-format-99: .. dropdown:: format (main.cpp:20) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 10 :emphasize-lines: 11 int main() { // Automatically log all output to temp/pd_test_output.log numpy::TestLogger logger("temp/pd_test_output.log"); int res = 0; int res1 = 0; std::string resS = ""; // call all the tests res1 = dataframe_tests::pd_test_main(); resS += std::format(" pd_test_main: {} errors\n", res1); res += res1; std::cout << "\n------------------------- main --------------------------------------------\n"; std::cout << std::endl << "All tests completed. Nb errors = " << res << std::endl; std::cout << "Details: \n" << resS; std::cout << "\n---------------------------------------------------------------------------\n"; return res; } .. _example-rangeindex-has_cached_values-100: .. dropdown:: has_cached_values (pd_test_1_all.cpp:19395) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 19385 :emphasize-lines: 11 } std::cout << " -> tests passed" << std::endl; } void pd_test_series_cache() { std::cout << "========= cache management ========================================="; pandas::Series s({1.0, 2.0, 3.0, 4.0, 5.0}); bool passed = s.has_cached_values() == false; if (!passed) { std::cout << " [FAIL] : in pd_test_series_cache() : initial cache not empty" << std::endl; throw std::runtime_error("pd_test_series_cache failed: initial cache not empty"); } // Trigger cache s.sum(); s.mean(); s.min(); s.max(); .. _example-rangeindex-has_duplicates-101: .. dropdown:: has_duplicates (pd_test_1_all.cpp:10176) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 10166 :emphasize-lines: 11 std::cout << " -> tests passed" << std::endl; } void pd_test_extension_index_uniqueness() { std::cout << "========= uniqueness ========================="; // Unique values pandas::CategoricalArray arr1({"a", "b", "c"}); pandas::CategoricalIndex idx1(arr1); bool passed1 = (idx1.is_unique() && !idx1.has_duplicates()); if (!passed1) { std::cout << " [FAIL] : in pd_test_extension_index_uniqueness() : unique check failed" << std::endl; throw std::runtime_error("pd_test_extension_index_uniqueness failed"); } // With duplicates pandas::CategoricalArray arr2({"a", "b", "a", "c"}); pandas::CategoricalIndex idx2(arr2); bool passed2 = (!idx2.is_unique() && idx2.has_duplicates()); .. _example-rangeindex-holds_integer-102: .. dropdown:: holds_integer (pd_test_3_all.cpp:3311) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 3301 :emphasize-lines: 11 } if (idx.is_interval()) { throw std::runtime_error("is_interval() should be false"); } if (idx.is_numeric()) { throw std::runtime_error("is_numeric() should be false"); } if (idx.is_object()) { throw std::runtime_error("is_object() should be false"); } if (idx.holds_integer()) { throw std::runtime_error("holds_integer() should be false"); } std::cout << " -> tests passed" << std::endl; } void pd_test_3_all_datetime_index_sort() { std::cout << "========= DatetimeIndex.sort_values() ===================="; pandas::DatetimeIndex idx = pandas::date_range("2024-01-01", "2024-01-05", std::nullopt, "D"); .. _example-rangeindex-identical-103: .. dropdown:: identical (pd_test_1_all.cpp:5883) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 5873 :emphasize-lines: 11 } void pd_test_categorical_index_identical() { std::cout << "========= identical ==================================="; pandas::CategoricalArray arr({"a", "b"}); pandas::CategoricalIndex idx1(arr, "same_name"); pandas::CategoricalIndex idx2(arr, "same_name"); pandas::CategoricalIndex idx3(arr, "diff_name"); bool passed = (idx1.identical(idx2) && !idx1.identical(idx3)); if (!passed) { std::cout << " [FAIL] : in pd_test_categorical_index_identical()" << std::endl; throw std::runtime_error("pd_test_categorical_index_identical failed"); } std::cout << " -> tests passed" << std::endl; } // ============================================================================ // Inherited Operations Tests .. _example-rangeindex-inferred_type-104: .. dropdown:: inferred_type (pd_test_1_all.cpp:5270) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 5260 :emphasize-lines: 11 } void pd_test_categorical_index_array_constructor() { std::cout << "========= array constructor ==========================="; pandas::CategoricalArray arr({"apple", "banana", "apple", "cherry"}); pandas::CategoricalIndex idx(arr, "fruits"); bool passed = (idx.size() == 4 && !idx.empty() && idx.name().has_value() && *idx.name() == "fruits" && idx.inferred_type() == "categorical"); if (!passed) { std::cout << " [FAIL] : in pd_test_categorical_index_array_constructor()" << std::endl; throw std::runtime_error("pd_test_categorical_index_array_constructor failed"); } std::cout << " -> tests passed" << std::endl; } void pd_test_categorical_index_values_constructor() { std::cout << "========= values constructor =========================="; .. _example-rangeindex-item-105: .. dropdown:: item (pd_test_3_all.cpp:3712) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 3702 :emphasize-lines: 11 // Test is_interval (always false for base Index) if (int_idx.is_interval()) { throw std::runtime_error("base Index should not be interval"); } std::cout << " -> tests passed" << std::endl; } void pd_test_3_all_index_item() { std::cout << "========= Index.item() ============================="; pandas::Index idx1({42}); numpy::int64 val = idx1.item(); if (val != 42) { throw std::runtime_error("item() should return 42"); } // Test error for size != 1 pandas::Index idx2({1, 2, 3}); .. _example-rangeindex-memory_usage-106: .. dropdown:: memory_usage (pd_test_1_all.cpp:27063) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 27053 :emphasize-lines: 11 } std::cout << "====================================== [OK] pd_test_value_counts test suite ========================== " << std::endl; return 0; } } // namespace dataframe_tests // ------------------- pd_test_value_counts.cpp (end) ----------------------------- // ------------------- pd_test_memory_usage.cpp (start) ----------------------------- // Tests for DataFrame.memory_usage() - pandas-compatible memory usage reporting namespace dataframe_tests { namespace dataframe_tests_memory_usage { void pd_test_memory_usage_basic() { std::cout << "========= basic memory_usage ======================="; // Create a simple DataFrame with multiple columns std::map> data; data["A"] = {1.0, 2.0, 3.0, 4.0, 5.0}; .. _example-rangeindex-name-107: .. dropdown:: name (pd_test_1_all.cpp:295) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 285 :emphasize-lines: 11 throw std::runtime_error("pd_test_boolean_array_reductions failed: mean"); } std::cout << " -> tests passed" << std::endl; } void pd_test_boolean_array_dtype() { std::cout << "========= BooleanArray: dtype ======================= "; pandas::BooleanArray arr; if (arr.dtype().name() != "boolean") { std::cout << " [FAIL] : in pd_test_boolean_array_dtype() : dtype name should be 'boolean'" << std::endl; throw std::runtime_error("pd_test_boolean_array_dtype failed: dtype name"); } if (arr.dtype().kind() != "b") { std::cout << " [FAIL] : in pd_test_boolean_array_dtype() : dtype kind should be 'b'" << std::endl; throw std::runtime_error("pd_test_boolean_array_dtype failed: dtype kind"); } std::cout << " -> tests passed" << std::endl; .. _example-rangeindex-nbytes-108: .. dropdown:: nbytes (pd_test_1_all.cpp:6214) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 6204 :emphasize-lines: 11 } // Test empty DataFrame pandas::DataFrame empty_df; if (!empty_df.empty()) { std::cout << " [FAIL] : in pd_test_dataframe_properties() : should be empty" << std::endl; throw std::runtime_error("pd_test_dataframe_properties failed: should be empty"); } // Test nbytes > 0 for non-empty if (df.nbytes() == 0) { std::cout << " [FAIL] : in pd_test_dataframe_properties() : nbytes should be > 0" << std::endl; throw std::runtime_error("pd_test_dataframe_properties failed: nbytes should be > 0"); } // Test columns index if (df.columns().size() != 3) { std::cout << " [FAIL] : in pd_test_dataframe_properties() : columns size != 3" << std::endl; throw std::runtime_error("pd_test_dataframe_properties failed: columns size != 3"); } .. _example-rangeindex-nlevels-109: .. dropdown:: nlevels (pd_test_1_all.cpp:14138) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 14128 :emphasize-lines: 11 // ===================================================================== // Constructor Tests // ===================================================================== void pd_test_multiindex_default_constructor() { std::cout << "========= default constructor ========================= "; pandas::MultiIndex mi; bool passed = (mi.nlevels() == 0) && (mi.size() == 0) && mi.empty(); if (!passed) { std::cout << " [FAIL] : in pd_test_multiindex_default_constructor()" << std::endl; throw std::runtime_error("pd_test_multiindex_default_constructor failed"); } std::cout << "-> tests passed" << std::endl; } void pd_test_multiindex_from_arrays() { .. _example-rangeindex-putmask-110: .. dropdown:: putmask (pd_test_3_all.cpp:3752) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 3742 :emphasize-lines: 11 // Should be at least sizeof index + 5 * sizeof(int64) if (usage < 5 * sizeof(numpy::int64)) { throw std::runtime_error("memory_usage too small"); } std::cout << " -> tests passed" << std::endl; } void pd_test_3_all_index_putmask() { std::cout << "========= Index.putmask() =========================="; pandas::Index idx({1, 2, 3, 4, 5}); numpy::NDArray mask(std::vector{5}); mask.setElementAt({0}, numpy::bool_(true)); mask.setElementAt({1}, numpy::bool_(false)); mask.setElementAt({2}, numpy::bool_(true)); mask.setElementAt({3}, numpy::bool_(false)); mask.setElementAt({4}, numpy::bool_(true)); auto result = idx.putmask(mask, numpy::int64(99)); .. _example-rangeindex-ravel-111: .. dropdown:: ravel (pd_test_3_all.cpp:2147) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 2137 :emphasize-lines: 11 throw std::runtime_error("memory_usage shallow too small"); } if (deep < shallow) { throw std::runtime_error("memory_usage deep should be >= shallow"); } std::cout << " -> tests passed" << std::endl; } void pd_test_3_all_categorical_ravel_view() { std::cout << "========= CategoricalArray.ravel()/view() ============="; std::vector> values = {"a", "b", "c"}; pandas::CategoricalArray arr(values); auto raveled = arr.ravel(); if (raveled.size() != 3 || !raveled.equals(arr)) { throw std::runtime_error("ravel failed"); } auto viewed = arr.view(); .. _example-rangeindex-repeat-112: .. dropdown:: repeat (pd_test_3_all.cpp:2166) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 2156 :emphasize-lines: 11 auto viewed = arr.view(); if (viewed.size() != 3 || !viewed.equals(arr)) { throw std::runtime_error("view failed"); } std::cout << " -> tests passed" << std::endl; } void pd_test_3_all_categorical_repeat() { std::cout << "========= CategoricalArray.repeat() ==================="; std::vector> values = {"a", "b"}; pandas::CategoricalArray arr(values); auto result = arr.repeat(3); if (result.size() != 6 || *result[0] != "a" || *result[2] != "a" || *result[3] != "b" || *result[5] != "b") { throw std::runtime_error("repeat scalar failed"); } .. _example-rangeindex-repeat-113: .. dropdown:: repeat (pd_test_3_all.cpp:2166) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 2156 :emphasize-lines: 11 auto viewed = arr.view(); if (viewed.size() != 3 || !viewed.equals(arr)) { throw std::runtime_error("view failed"); } std::cout << " -> tests passed" << std::endl; } void pd_test_3_all_categorical_repeat() { std::cout << "========= CategoricalArray.repeat() ==================="; std::vector> values = {"a", "b"}; pandas::CategoricalArray arr(values); auto result = arr.repeat(3); if (result.size() != 6 || *result[0] != "a" || *result[2] != "a" || *result[3] != "b" || *result[5] != "b") { throw std::runtime_error("repeat scalar failed"); } .. _example-rangeindex-repr-114: .. dropdown:: repr (pd_test_1_all.cpp:10906) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 10896 :emphasize-lines: 11 std::cout << " -> tests passed" << std::endl; } void pd_test_extension_index_repr() { std::cout << "========= repr ========================="; pandas::CategoricalArray arr({"a", "b", "c"}); // Use ExtensionIndex directly to test base class repr pandas::ExtensionIndex idx(arr, "test"); std::string repr_str = idx.repr(); bool passed = (!repr_str.empty() && repr_str.find("ExtensionIndex") != std::string::npos); if (!passed) { std::cout << " [FAIL] : in pd_test_extension_index_repr() : repr check failed" << std::endl; throw std::runtime_error("pd_test_extension_index_repr failed"); } std::cout << " -> tests passed" << std::endl; } .. _example-rangeindex-result-115: .. dropdown:: result (pd_test_1_all.cpp:15406) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 15396 :emphasize-lines: 11 data.setElementAt({0}, numpy::datetime64(100LL, numpy::DateTimeUnit::Nanosecond)); data.setElementAt({1}, numpy::datetime64(200LL, numpy::DateTimeUnit::Nanosecond)); numpy::NDArray mask(std::vector{2}); mask.setElementAt({0}, numpy::bool_(false)); mask.setElementAt({1}, numpy::bool_(false)); pandas::DatetimeArray arr(data, mask); pandas::DatetimeIndexBase idx(arr, "original"); // Create join result (int64 values) numpy::NDArray join_result(std::vector{3}); join_result.setElementAt({0}, numpy::int64(500LL)); join_result.setElementAt({1}, numpy::int64(600LL)); join_result.setElementAt({2}, numpy::int64(700LL)); auto new_idx = idx._from_join_target(join_result); bool passed = (new_idx.size() == 3 && new_idx.name().has_value() && *new_idx.name() == "original"); if (!passed) { .. _example-rangeindex-round-116: .. dropdown:: round (pd_test_1_all.cpp:1688) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 1678 :emphasize-lines: 11 void pd_test_floating_array_rounding() { std::cout << "========= FloatingArray: rounding ======================= "; pandas::FloatingArray arr({ std::optional(1.234), std::optional(2.567), std::nullopt }); auto rounded = arr.round(2); if (std::abs(rounded[0].value() - 1.23) > 0.001 || std::abs(rounded[1].value() - 2.57) > 0.001) { std::cout << " [FAIL] : in pd_test_floating_array_rounding() : round(2)" << std::endl; throw std::runtime_error("pd_test_floating_array_rounding failed: round(2)"); } if (!rounded.is_na(2)) { std::cout << " [FAIL] : in pd_test_floating_array_rounding() : round should preserve NA" << std::endl; throw std::runtime_error("pd_test_floating_array_rounding failed: NA preservation"); } .. _example-rangeindex-set_name-117: .. dropdown:: set_name (pd_test_1_all.cpp:11798) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 11788 :emphasize-lines: 11 throw std::runtime_error("pd_test_index_vector_constructor failed"); } std::cout << " -> tests passed" << std::endl; } void pd_test_index_copy_constructor() { std::cout << "========= copy constructor ============================"; pandas::Index idx1{1, 2, 3}; idx1.set_name("original"); pandas::Index idx2(idx1); bool passed = (idx2.size() == 3); passed = passed && (idx2.name().value() == "original"); passed = passed && idx2.equals(idx1); if (!passed) { std::cout << " [FAIL] : in pd_test_index_copy_constructor() : copy failed" << std::endl; throw std::runtime_error("pd_test_index_copy_constructor failed"); .. _example-rangeindex-size-118: .. dropdown:: size (pd_test_1_all.cpp:22) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 12 :emphasize-lines: 11 #include "../pandas/pd_boolean_array.h" namespace dataframe_tests { namespace dataframe_tests_boolean_array { void pd_test_boolean_array_constructors() { std::cout << "========= BooleanArray: constructors ======================= "; // Default constructor pandas::BooleanArray arr1; if (arr1.size() != 0) { std::cout << " [FAIL] : in pd_test_boolean_array_constructors() : default constructor size != 0" << std::endl; throw std::runtime_error("pd_test_boolean_array_constructors failed: default constructor size != 0"); } // Initializer list constructor pandas::BooleanArray arr2({ std::optional(true), std::optional(false), std::nullopt, std::optional(true) .. _example-rangeindex-slice-119: .. dropdown:: slice (pd_test_1_all.cpp:17546) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 17536 :emphasize-lines: 11 // ============================================================================ // Slicing / Indexing Tests // ============================================================================ void pd_test_period_index_slice() { std::cout << "========= slice method ================================"; std::vector ordinals = {0, 1, 2, 3, 4}; pandas::PeriodIndex idx(ordinals, "D"); pandas::PeriodIndex sliced = idx.slice(1, 4); bool passed = (sliced.size() == 3 && sliced[0].has_value() && *sliced[0] == 1); if (!passed) { std::cout << " [FAIL] : in pd_test_period_index_slice()" << std::endl; throw std::runtime_error("pd_test_period_index_slice failed"); } std::cout << " -> tests passed" << std::endl; } .. _example-rangeindex-slice_indexer-120: .. dropdown:: slice_indexer (pd_test_3_all.cpp:711) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 701 :emphasize-lines: 11 } std::cout << " -> tests passed" << std::endl; } // ============================================================================ // Category 6: Index Indexer Methods // ============================================================================ void pd_test_3_all_index_indexers() { std::cout << "========= Index.get_indexer_for/non_unique/slice_indexer() "; std::vector vals = {"a", "b", "c", "d", "e"}; pandas::Index idx(vals); // Test get_indexer_for() std::vector target = {"b", "d", "f"}; // "f" doesn't exist numpy::NDArray indexer = idx.get_indexer_for(target); if (indexer.getSize() != 3) { std::cout << " [FAIL] : in pd_test_3_all_index_indexers() : get_indexer_for size mismatch" << std::endl; throw std::runtime_error("pd_test_3_all_index_indexers failed: get_indexer_for size"); .. _example-rangeindex-slice_locs-121: .. dropdown:: slice_locs (pd_test_1_all.cpp:18275) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 18265 :emphasize-lines: 11 } std::cout << "-> tests passed" << std::endl; } void pd_test_range_index_slice_locs() { std::cout << "========= slice_locs ================================== "; pandas::RangeIndex ri(0, 10); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] auto [start_idx, stop_idx] = ri.slice_locs(3, 7); bool passed = (start_idx == 3 && stop_idx == 8); if (!passed) { std::cout << " [FAIL] : slice_locs" << std::endl; throw std::runtime_error("pd_test_range_index_slice_locs failed"); } std::cout << "-> tests passed" << std::endl; } .. _example-rangeindex-sort-122: .. dropdown:: sort (pd_test_3_all.cpp:3869) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 3859 :emphasize-lines: 11 throw std::runtime_error("last 2 positions should be NaN"); } if (std::abs(result[0] - 3.0) > 0.001) { throw std::runtime_error("shift(-2) [0] should be 3.0"); } std::cout << " -> tests passed" << std::endl; } void pd_test_3_all_index_sort() { std::cout << "========= Index.sort() ============================="; pandas::Index idx({3, 1, 4, 1, 5, 9, 2, 6}); auto result = idx.sort(); if (result[0] != 1 || result[1] != 1 || result[7] != 9) { throw std::runtime_error("sort() not working correctly"); } // Test descending result = idx.sort(false); .. _example-rangeindex-sortlevel-123: .. dropdown:: sortlevel (pd_test_1_all.cpp:14676) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 14666 :emphasize-lines: 11 void pd_test_multiindex_sortlevel() { std::cout << "========= sortlevel =================================== "; std::vector> arrays = { {"b", "a", "c"}, {"2", "1", "3"} }; pandas::MultiIndex mi = pandas::MultiIndex::from_arrays(arrays); auto [sorted, indices] = mi.sortlevel(0); bool passed = true; // After sorting by level 0: a, b, c if (sorted[0][0] != "a" || sorted[1][0] != "b" || sorted[2][0] != "c") { std::cout << " [FAIL] : not sorted correctly by level 0" << std::endl; passed = false; } if (!passed) { .. _example-rangeindex-start-124: .. dropdown:: start (pd_test_1_all.cpp:17898) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 17888 :emphasize-lines: 11 // Constructor Tests // ========================================================================= void pd_test_range_index_default_constructor() { std::cout << "========= default constructor ========================= "; pandas::RangeIndex ri; bool passed = (ri.size() == 0 && ri.empty() && ri.start() == 0 && ri.stop() == 0 && ri.step() == 1 && !ri.name().has_value()); if (!passed) { std::cout << " [FAIL] : default constructor" << std::endl; throw std::runtime_error("pd_test_range_index_default_constructor failed"); } std::cout << "-> tests passed" << std::endl; .. _example-rangeindex-step-125: .. dropdown:: step (pd_test_1_all.cpp:17900) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 17890 :emphasize-lines: 11 void pd_test_range_index_default_constructor() { std::cout << "========= default constructor ========================= "; pandas::RangeIndex ri; bool passed = (ri.size() == 0 && ri.empty() && ri.start() == 0 && ri.stop() == 0 && ri.step() == 1 && !ri.name().has_value()); if (!passed) { std::cout << " [FAIL] : default constructor" << std::endl; throw std::runtime_error("pd_test_range_index_default_constructor failed"); } std::cout << "-> tests passed" << std::endl; } .. _example-rangeindex-stop-126: .. dropdown:: stop (pd_test_1_all.cpp:17899) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 17889 :emphasize-lines: 11 // ========================================================================= void pd_test_range_index_default_constructor() { std::cout << "========= default constructor ========================= "; pandas::RangeIndex ri; bool passed = (ri.size() == 0 && ri.empty() && ri.start() == 0 && ri.stop() == 0 && ri.step() == 1 && !ri.name().has_value()); if (!passed) { std::cout << " [FAIL] : default constructor" << std::endl; throw std::runtime_error("pd_test_range_index_default_constructor failed"); } std::cout << "-> tests passed" << std::endl; } .. _example-rangeindex-str-127: .. dropdown:: str (pd_test_1_all.cpp:7137) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 7127 :emphasize-lines: 11 // Test basic info() with stringstream std::map> data = { {"A", {1, 2, 3, 4, 5}}, {"B", {10, 20, 30, 40, 50}}, {"C", {100, 200, 300, 400, 500}} }; pandas::DataFrame df(data); std::ostringstream oss; df.info(oss); std::string output = oss.str(); // Verify key components if (output.find("") == std::string::npos) { std::cout << " [FAIL] : info missing class name" << std::endl; throw std::runtime_error("pd_test_dataframe_info failed: missing class name"); } if (output.find("RangeIndex:") == std::string::npos) { std::cout << " [FAIL] : info missing RangeIndex" << std::endl; throw std::runtime_error("pd_test_dataframe_info failed: missing RangeIndex"); } .. _example-rangeindex-type_id-128: .. dropdown:: type_id (pd_test_3_all.cpp:25592) :class-title: example-dropdown .. code-block:: cpp :linenos: :lineno-start: 25582 :emphasize-lines: 11 // ------------------- pd_test_value_classify (end) ------------------ // ------------------- pd_test_index_type_id (start) ------------------ namespace dataframe_tests_index_type_id { void pd_test_index_type_id_dispatch() { std::cout << "========= IndexTypeId dispatch ======================="; // RangeIndex ::pandas::RangeIndex ri(0, 5); if (ri.type_id() != ::pandas::IndexTypeId::RangeIndex) throw std::runtime_error("RangeIndex type_id failed"); // Index ::pandas::Index si(std::vector{"a", "b", "c"}); if (si.type_id() != ::pandas::IndexTypeId::IndexString) throw std::runtime_error("Index type_id failed"); // Index ::pandas::Index ii(std::vector{1, 2, 3}); if (ii.type_id() != ::pandas::IndexTypeId::IndexInt64)