MultiIndex
==========

.. cpp:class:: numpy::MultiIndex

   numpy C++ class.

Example
-------

.. code-block:: cpp

   #include <numpy/np_ndarray.h>
   using namespace numpy;

   // Use MultiIndex
   MultiIndex obj;
   // ... operations ...

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

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

   * - Signature
     - Location
     - Example
   * - ``MultiIndex(std::vector<std::unique_ptr<IndexBase>>&& levels, std::vector<numpy::NDArray<numpy::int64>>&& codes, std::vector<std::optional<std::string>> names =``
     - df_multiindex.h:80
     - 
   * - ``MultiIndex(const MultiIndex& other)``
     - df_multiindex.h:117
     - 
   * - ``MultiIndex(MultiIndex&& other) noexcept = default``
     - df_multiindex.h:139
     - 

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

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

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``static MultiIndex from_arrays(const std::vector<std::vector<T>>& arrays, const std::vector<std::optional<std::string>>& names =``
     - MultiIndex
     - df_multiindex.h:173
     - 
   * - ``static MultiIndex from_frame(const std::vector<std::vector<ColType>>& columns, const std::vector<std::optional<std::string>>& names =``
     - MultiIndex
     - df_multiindex.h:1542
     - 
   * - ``static MultiIndex from_mixed_arrays( const std::vector<std::vector<numpy::int64>>& int_arrays, const std::vector<std::vector<std::string>>& str_arrays, const std::string& level_types, const std::vector<std::optional<std::string>>& names =``
     - static MultiIndex
     - df_multiindex.h:223
     - 
   * - ``static MultiIndex from_product(const std::vector<std::vector<T>>& iterables, const std::vector<std::optional<std::string>>& names =``
     - MultiIndex
     - df_multiindex.h:350
     - 
   * - ``static MultiIndex from_tuples(const std::vector<std::vector<T>>& tuples, const std::vector<std::optional<std::string>>& names =``
     - MultiIndex
     - df_multiindex.h:317
     - 
   * - ``static std::string make_tuple_key(const std::vector<std::string>& values)``
     - static std::string
     - df_multiindex.h:2811
     - 
   * - ``std::string make_tuple_key_at(size_t index) const``
     - std::string
     - df_multiindex.h:2823
     - 

Array Creation
--------------

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

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``bool empty() const``
     - bool
     - df_multiindex.h:430
     - :ref:`View <example-multiindex-empty-0>`

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

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

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``numpy::NDArray<numpy::int64> get_indexer(const MultiIndex& target) const``
     - numpy::NDArray<numpy::int64>
     - df_multiindex.h:785
     - 
   * - ``numpy::NDArray<numpy::int64> get_indexer_for(const MultiIndex& target) const``
     - numpy::NDArray<numpy::int64>
     - df_multiindex.h:1552
     - 
   * - ``get_indexer_non_unique(const MultiIndex& target) const``
     - 
     - df_multiindex.h:1562
     - 
   * - ``const IndexBase& get_level(size_t level) const``
     - const IndexBase&
     - df_multiindex.h:571
     - 
   * - ``std::unique_ptr<IndexBase> get_level_values(int level) const``
     - std::unique_ptr<IndexBase>
     - df_multiindex.h:497
     - 
   * - ``std::unique_ptr<IndexBase> get_level_values(const std::string& level_name) const``
     - std::unique_ptr<IndexBase>
     - df_multiindex.h:526
     - 
   * - ``std::vector<std::string> get_level_values_str(size_t level) const``
     - std::vector<std::string>
     - df_multiindex.h:549
     - 
   * - ``Index<T> get_level_values_typed(size_t level) const``
     - Index<T>
     - df_multiindex.h:1592
     - 
   * - ``std::variant<size_t, std::vector<size_t>> get_loc(const std::vector<std::string>& key) const``
     - std::variant<size_t, std::vector<size_t>>
     - df_multiindex.h:748
     - 
   * - ``std::pair<std::vector<size_t>, MultiIndex> get_loc_level( const std::string& key, size_t level = 0, bool drop_level = true) const``
     - std::pair<std::vector<size_t>, MultiIndex>
     - df_multiindex.h:1621
     - 
   * - ``numpy::NDArray<numpy::int64> get_locs(const std::vector<std::vector<std::string>>& seq) const``
     - numpy::NDArray<numpy::int64>
     - df_multiindex.h:1651
     - 
   * - ``std::optional<std::string> get_name(size_t level) const``
     - std::optional<std::string>
     - df_multiindex.h:581
     - 
   * - ``size_t get_slice_bound(const std::vector<std::string>& label, const std::string& side) const``
     - size_t
     - df_multiindex.h:1679
     - 
   * - ``std::vector<std::string> get_tuple_str(size_t index) const``
     - std::vector<std::string>
     - df_multiindex.h:811
     - 
   * - ``std::vector<std::string> item() const``
     - std::vector<std::string>
     - df_multiindex.h:1941
     - :ref:`View <example-multiindex-item-1>`
   * - ``MultiIndex putmask(const numpy::NDArray<numpy::bool\_>& mask, const std::vector<std::string>& value) const``
     - MultiIndex
     - df_multiindex.h:2165
     - :ref:`View <example-multiindex-putmask-2>`
   * - ``size_t searchsorted(const std::vector<std::string>& value, const std::string& side = "left") const``
     - size_t
     - df_multiindex.h:2275
     - :ref:`View <example-multiindex-searchsorted-3>`
   * - ``std::pair<MultiIndex, numpy::NDArray<numpy::int64>> take(const std::vector<size_t>& indices) const``
     - std::pair<MultiIndex, numpy::NDArray<numpy::int64>>
     - df_multiindex.h:981
     - :ref:`View <example-multiindex-take-4>`
   * - ``MultiIndex where(const numpy::NDArray<numpy::bool\_>& cond, const std::vector<std::string>& other) const``
     - MultiIndex
     - df_multiindex.h:2674
     - :ref:`View <example-multiindex-where-5>`

Shape Manipulation
------------------

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

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``std::vector<std::vector<std::string>> ravel() const``
     - std::vector<std::vector<std::string>>
     - df_multiindex.h:2198
     - :ref:`View <example-multiindex-ravel-6>`
   * - ``MultiIndex transpose(bool copy_data = false) const``
     - MultiIndex
     - df_multiindex.h:2537
     - :ref:`View <example-multiindex-transpose-7>`

Statistics
----------

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

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``std::vector<std::string> max() const``
     - std::vector<std::string>
     - df_multiindex.h:2081
     - :ref:`View <example-multiindex-max-8>`
   * - ``std::vector<std::string> min() const``
     - std::vector<std::string>
     - df_multiindex.h:2125
     - :ref:`View <example-multiindex-min-9>`

Sorting
-------

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

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``numpy::NDArray<numpy::int64> argsort() const``
     - numpy::NDArray<numpy::int64>
     - df_multiindex.h:944
     - :ref:`View <example-multiindex-argsort-10>`
   * - ``MultiIndex sort(bool ascending = true) const``
     - MultiIndex
     - df_multiindex.h:2405
     - :ref:`View <example-multiindex-sort-11>`
   * - ``MultiIndex sort_values(bool ascending = true) const``
     - MultiIndex
     - df_multiindex.h:2414
     - 
   * - ``std::pair<MultiIndex, numpy::NDArray<numpy::int64>> sortlevel( size_t level = 0, bool ascending = true) const``
     - std::pair<MultiIndex, numpy::NDArray<numpy::int64>>
     - df_multiindex.h:913
     - 

Math Operations
---------------

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

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``MultiIndex round(int decimals = 0) const``
     - MultiIndex
     - df_multiindex.h:2264
     - :ref:`View <example-multiindex-round-12>`
   * - ``MultiIndex truncate( const std::optional<std::vector<std::string>>& before = std::nullopt, const std::optional<std::vector<std::string>>& after = std::nullopt) const``
     - MultiIndex
     - df_multiindex.h:2550
     - :ref:`View <example-multiindex-truncate-13>`

Linear Algebra
--------------

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

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``void invalidate_caches() const``
     - void
     - df_multiindex.h:2836
     - 

Comparison
----------

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

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``bool equal_levels(const MultiIndex& other) const``
     - bool
     - df_multiindex.h:1412
     - 
   * - ``bool equals(const MultiIndex& other) const``
     - bool
     - df_multiindex.h:1436
     - 

Logical
-------

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

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``bool all() const``
     - bool
     - df_multiindex.h:1057
     - :ref:`View <example-multiindex-all-14>`
   * - ``bool any() const``
     - bool
     - df_multiindex.h:1066
     - :ref:`View <example-multiindex-any-15>`

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

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

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``numpy::NDArray<numpy::bool\_> isin(const std::vector<std::vector<std::string>>& values) const``
     - numpy::NDArray<numpy::bool\_>
     - df_multiindex.h:1902
     - :ref:`View <example-multiindex-isin-16>`
   * - ``MultiIndex unique() const``
     - MultiIndex
     - df_multiindex.h:2613
     - :ref:`View <example-multiindex-unique-17>`

I/O
---

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

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``std::vector<std::vector<std::string>> to_flat_index() const``
     - std::vector<std::vector<std::string>>
     - df_multiindex.h:841
     - 
   * - ``std::map<std::string, std::vector<std::string>> to_frame(bool index = true) const``
     - std::map<std::string, std::vector<std::string>>
     - df_multiindex.h:2480
     - 
   * - ``std::vector<std::vector<std::string>> to_list() const``
     - std::vector<std::vector<std::string>>
     - df_multiindex.h:2496
     - 
   * - ``std::vector<std::vector<std::string>> to_numpy() const``
     - std::vector<std::vector<std::string>>
     - df_multiindex.h:2504
     - :ref:`View <example-multiindex-to_numpy-18>`
   * - ``to_series(bool index = true) const``
     - 
     - df_multiindex.h:2514
     - 
   * - ``std::string to_string() const``
     - std::string
     - df_multiindex.h:855
     - :ref:`View <example-multiindex-to_string-19>`
   * - ``std::vector<std::vector<std::string>> tolist() const``
     - std::vector<std::vector<std::string>>
     - df_multiindex.h:2528
     - :ref:`View <example-multiindex-tolist-20>`

Joining / Splitting
-------------------

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

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``MultiIndex append(const MultiIndex& other) const``
     - MultiIndex
     - df_multiindex.h:1015
     - :ref:`View <example-multiindex-append-21>`
   * - ``MultiIndex delete\_(size_t loc) const``
     - MultiIndex
     - df_multiindex.h:1184
     - :ref:`View <example-multiindex-delete_-22>`
   * - ``MultiIndex delete\_(const std::vector<size_t>& locs) const``
     - MultiIndex
     - df_multiindex.h:1205
     - :ref:`View <example-multiindex-delete_-23>`
   * - ``MultiIndex insert(size_t loc, const std::vector<std::string>& item) const``
     - MultiIndex
     - df_multiindex.h:1755
     - :ref:`View <example-multiindex-insert-24>`
   * - ``MultiIndex repeat(size_t repeats) const``
     - MultiIndex
     - df_multiindex.h:2241
     - :ref:`View <example-multiindex-repeat-25>`

Type Handling
-------------

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

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``MultiIndex astype(const std::string& dtype) const``
     - MultiIndex
     - df_multiindex.h:1170
     - :ref:`View <example-multiindex-astype-26>`
   * - ``MultiIndex copy() const``
     - MultiIndex
     - df_multiindex.h:1045
     - :ref:`View <example-multiindex-copy-27>`
   * - ``MultiIndex view() const``
     - MultiIndex
     - df_multiindex.h:2664
     - :ref:`View <example-multiindex-view-28>`

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

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

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``bool is\_(const MultiIndex& other) const``
     - bool
     - df_multiindex.h:1828
     - 
   * - ``bool is_boolean() const``
     - bool
     - df_multiindex.h:1835
     - 
   * - ``bool is_categorical() const``
     - bool
     - df_multiindex.h:1842
     - 
   * - ``bool is_floating() const``
     - bool
     - df_multiindex.h:1849
     - 
   * - ``bool is_integer() const``
     - bool
     - df_multiindex.h:1861
     - 
   * - ``bool is_interval() const``
     - bool
     - df_multiindex.h:1874
     - 
   * - ``bool is_monotonic_decreasing() const``
     - bool
     - df_multiindex.h:2721
     - 
   * - ``bool is_monotonic_increasing() const``
     - bool
     - df_multiindex.h:2707
     - 
   * - ``bool is_numeric() const``
     - bool
     - df_multiindex.h:1881
     - :ref:`View <example-multiindex-is_numeric-29>`
   * - ``bool is_object() const``
     - bool
     - df_multiindex.h:1888
     - 
   * - ``bool is_unique() const``
     - bool
     - df_multiindex.h:458
     - :ref:`View <example-multiindex-is_unique-30>`

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

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

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``size_t argmax() const``
     - size_t
     - df_multiindex.h:1073
     - :ref:`View <example-multiindex-argmax-31>`
   * - ``size_t argmin() const``
     - size_t
     - df_multiindex.h:1090
     - :ref:`View <example-multiindex-argmin-32>`
   * - ``std::vector<std::vector<T>> arrays(nlevels)``
     - std::vector<std::vector<T>>
     - df_multiindex.h:327
     - :ref:`View <example-multiindex-arrays-33>`
   * - ``std::vector<std::vector<T>> arrays(nlevels)``
     - std::vector<std::vector<T>>
     - df_multiindex.h:369
     - :ref:`View <example-multiindex-arrays-34>`
   * - ``std::vector<std::vector<std::string>> arrays(nlevels())``
     - std::vector<std::vector<std::string>>
     - df_multiindex.h:1024
     - :ref:`View <example-multiindex-arrays-35>`
   * - ``std::vector<std::vector<std::string>> arrays(nlevels())``
     - std::vector<std::vector<std::string>>
     - df_multiindex.h:1763
     - :ref:`View <example-multiindex-arrays-36>`
   * - ``std::optional<std::vector<std::string>> asof(const std::vector<std::string>& key) const``
     - std::optional<std::vector<std::string>>
     - df_multiindex.h:1109
     - 
   * - ``numpy::NDArray<numpy::int64> asof_locs( const std::vector<std::vector<std::string>>& where, const numpy::NDArray<numpy::bool\_>& mask) const``
     - numpy::NDArray<numpy::int64>
     - df_multiindex.h:1137
     - 
   * - ``void build_hash_table() const``
     - void
     - df_multiindex.h:2788
     - 
   * - ``numpy::NDArray<numpy::int64> code_arr(std::vector<size_t>``
     - numpy::NDArray<numpy::int64>
     - df_multiindex.h:194
     - 
   * - ``numpy::NDArray<numpy::int64> code_arr(std::vector<size_t>``
     - numpy::NDArray<numpy::int64>
     - df_multiindex.h:257
     - 
   * - ``numpy::NDArray<numpy::int64> code_arr(std::vector<size_t>``
     - numpy::NDArray<numpy::int64>
     - df_multiindex.h:286
     - 
   * - ``const std::vector<numpy::NDArray<numpy::int64>>& codes() const``
     - const std::vector<numpy::NDArray<numpy::int64>>&
     - df_multiindex.h:444
     - 
   * - ``numpy::NDArray<numpy::int64> codes(std::vector<size_t>``
     - numpy::NDArray<numpy::int64>
     - df_multiindex.h:1472
     - 
   * - ``int compare_tuples(size_t idx_a, size_t idx_b) const``
     - int
     - df_multiindex.h:2750
     - 
   * - ``bool contains(const std::vector<std::string>& key) const``
     - bool
     - df_multiindex.h:770
     - :ref:`View <example-multiindex-contains-37>`
   * - ``std::vector<std::optional<std::string>> diff(int periods = 1) const``
     - std::vector<std::optional<std::string>>
     - df_multiindex.h:1224
     - :ref:`View <example-multiindex-diff-38>`
   * - ``MultiIndex difference(const MultiIndex& other) const``
     - MultiIndex
     - df_multiindex.h:1247
     - :ref:`View <example-multiindex-difference-39>`
   * - ``MultiIndex drop(const std::vector<std::vector<std::string>>& labels) const``
     - MultiIndex
     - df_multiindex.h:1278
     - 
   * - ``MultiIndex drop_duplicates(const std::string& keep = "first") const``
     - MultiIndex
     - df_multiindex.h:1307
     - 
   * - ``MultiIndex droplevel(size_t level) const``
     - MultiIndex
     - df_multiindex.h:609
     - 
   * - ``MultiIndex dropna(const std::string& how = "any") const``
     - MultiIndex
     - df_multiindex.h:1359
     - 
   * - ``std::vector<std::string> dtypes() const``
     - std::vector<std::string>
     - df_multiindex.h:2736
     - :ref:`View <example-multiindex-dtypes-40>`
   * - ``numpy::NDArray<numpy::bool\_> duplicated(const std::string& keep = "first") const``
     - numpy::NDArray<numpy::bool\_>
     - df_multiindex.h:1369
     - 
   * - ``void ensure_hash_table() const``
     - void
     - df_multiindex.h:2802
     - 
   * - ``std::pair<numpy::NDArray<numpy::int64>, MultiIndex> factorize(bool sort = false) const``
     - std::pair<numpy::NDArray<numpy::int64>, MultiIndex>
     - df_multiindex.h:1463
     - 
   * - ``MultiIndex fillna(const std::vector<std::string>& value) const``
     - MultiIndex
     - df_multiindex.h:1492
     - 
   * - ``std::vector<std::string> format(bool name = true, size_t max_seq_items = 100) const``
     - std::vector<std::string>
     - df_multiindex.h:1503
     - :ref:`View <example-multiindex-format-41>`
   * - ``groupby(const std::vector<std::string>& values) const``
     - 
     - df_multiindex.h:1705
     - 
   * - ``bool has_duplicates() const``
     - bool
     - df_multiindex.h:476
     - 
   * - ``bool holds_integer() const``
     - bool
     - df_multiindex.h:1723
     - 
   * - ``bool identical(const MultiIndex& other) const``
     - bool
     - df_multiindex.h:1737
     - 
   * - ``numpy::NDArray<numpy::int64> idx_arr(std::vector<size_t>``
     - numpy::NDArray<numpy::int64>
     - df_multiindex.h:1000
     - 
   * - ``numpy::NDArray<numpy::int64> indexer(std::vector<size_t>``
     - numpy::NDArray<numpy::int64>
     - df_multiindex.h:1563
     - 
   * - ``MultiIndex infer_objects() const``
     - MultiIndex
     - df_multiindex.h:1745
     - 
   * - ``MultiIndex intersection(const MultiIndex& other) const``
     - MultiIndex
     - df_multiindex.h:1794
     - 
   * - ``numpy::NDArray<numpy::bool\_> isna() const``
     - numpy::NDArray<numpy::bool\_>
     - df_multiindex.h:1922
     - 
   * - ``numpy::NDArray<numpy::bool\_> isnull() const``
     - numpy::NDArray<numpy::bool\_>
     - df_multiindex.h:1933
     - 
   * - ``join(const MultiIndex& other, const std::string& how = "left") const``
     - 
     - df_multiindex.h:1955
     - :ref:`View <example-multiindex-join-42>`
   * - ``numpy::NDArray<numpy::int64> left_arr(std::vector<size_t>``
     - numpy::NDArray<numpy::int64>
     - df_multiindex.h:2044
     - 
   * - ``const std::vector<std::unique_ptr<IndexBase>>& levels() const``
     - const std::vector<std::unique_ptr<IndexBase>>&
     - df_multiindex.h:437
     - :ref:`View <example-multiindex-levels-43>`
   * - ``std::vector<size_t> levshape() const``
     - std::vector<size_t>
     - df_multiindex.h:408
     - 
   * - ``MultiIndex map(Func mapper) const``
     - MultiIndex
     - df_multiindex.h:2064
     - 
   * - ``size_t memory_usage(bool deep = false) const``
     - size_t
     - df_multiindex.h:2093
     - 
   * - ``numpy::NDArray<numpy::bool\_> missing(std::vector<size_t>``
     - numpy::NDArray<numpy::bool\_>
     - df_multiindex.h:1564
     - 
   * - ``const std::vector<std::optional<std::string>>& names() const``
     - const std::vector<std::optional<std::string>>&
     - df_multiindex.h:451
     - :ref:`View <example-multiindex-names-44>`
   * - ``numpy::NDArray<numpy::int64> new_code_arr(std::vector<size_t>``
     - numpy::NDArray<numpy::int64>
     - df_multiindex.h:728
     - 
   * - ``numpy::NDArray<numpy::int64> new_code_arr(std::vector<size_t>``
     - numpy::NDArray<numpy::int64>
     - df_multiindex.h:986
     - 
   * - ``size_t nlevels() const``
     - size_t
     - df_multiindex.h:401
     - 
   * - ``numpy::NDArray<numpy::bool\_> notna() const``
     - numpy::NDArray<numpy::bool\_>
     - df_multiindex.h:2136
     - 
   * - ``numpy::NDArray<numpy::bool\_> notnull() const``
     - numpy::NDArray<numpy::bool\_>
     - df_multiindex.h:2147
     - 
   * - ``size_t nunique() const``
     - size_t
     - df_multiindex.h:2154
     - 
   * - ``std::vector<std::pair<std::string, size_t>> pairs(counts.begin(), counts.end())``
     - std::vector<std::pair<std::string, size_t>>
     - df_multiindex.h:2639
     - :ref:`View <example-multiindex-pairs-45>`
   * - ``reindex(const MultiIndex& target, const std::string& method = "") const``
     - 
     - df_multiindex.h:2209
     - 
   * - ``MultiIndex remove_unused_levels() const``
     - MultiIndex
     - df_multiindex.h:701
     - 
   * - ``MultiIndex rename(const std::vector<std::optional<std::string>>& new_names, std::optional<size_t> level = std::nullopt) const``
     - MultiIndex
     - df_multiindex.h:2221
     - 
   * - ``MultiIndex reorder_levels(const std::vector<size_t>& order) const``
     - MultiIndex
     - df_multiindex.h:667
     - 
   * - ``std::string repr() const``
     - std::string
     - df_multiindex.h:892
     - 
   * - ``MultiIndex result(\*this)``
     - MultiIndex
     - df_multiindex.h:596
     - :ref:`View <example-multiindex-result-46>`
   * - ``std::vector<std::optional<std::string>> result(size())``
     - std::vector<std::optional<std::string>>
     - df_multiindex.h:1225
     - :ref:`View <example-multiindex-result-47>`
   * - ``std::vector<std::vector<std::string>> result_arrays(nlevels())``
     - std::vector<std::vector<std::string>>
     - df_multiindex.h:1248
     - 
   * - ``std::vector<std::vector<std::string>> result_arrays(nlevels())``
     - std::vector<std::vector<std::string>>
     - df_multiindex.h:1284
     - 
   * - ``std::vector<std::vector<std::string>> result_arrays(nlevels())``
     - std::vector<std::vector<std::string>>
     - df_multiindex.h:1795
     - 
   * - ``std::vector<std::vector<std::string>> result_arrays(nlevels())``
     - std::vector<std::vector<std::string>>
     - df_multiindex.h:1956
     - 
   * - ``std::vector<std::vector<std::string>> result_arrays(nlevels())``
     - std::vector<std::vector<std::string>>
     - df_multiindex.h:2065
     - 
   * - ``std::vector<std::vector<std::string>> result_arrays(nlevels())``
     - std::vector<std::vector<std::string>>
     - df_multiindex.h:2174
     - 
   * - ``std::vector<std::vector<std::string>> result_arrays(nlevels())``
     - std::vector<std::vector<std::string>>
     - df_multiindex.h:2242
     - 
   * - ``std::vector<std::vector<std::string>> result_arrays(nlevels())``
     - std::vector<std::vector<std::string>>
     - df_multiindex.h:2438
     - 
   * - ``std::vector<std::vector<std::string>> result_arrays(nlevels())``
     - std::vector<std::vector<std::string>>
     - df_multiindex.h:2574
     - 
   * - ``std::vector<std::vector<std::string>> result_arrays(nlevels())``
     - std::vector<std::vector<std::string>>
     - df_multiindex.h:2683
     - 
   * - ``numpy::NDArray<numpy::int64> right_arr(std::vector<size_t>``
     - numpy::NDArray<numpy::int64>
     - df_multiindex.h:2045
     - 
   * - ``MultiIndex set_codes(const std::vector<numpy::NDArray<numpy::int64>>& new_codes, std::optional<size_t> level = std::nullopt, bool verify_integrity = true) const``
     - MultiIndex
     - df_multiindex.h:2287
     - 
   * - ``MultiIndex set_levels(const std::vector<std::vector<std::string>>& new_levels, std::optional<size_t> level = std::nullopt, bool verify_integrity = true) const``
     - MultiIndex
     - df_multiindex.h:2323
     - 
   * - ``MultiIndex set_names(const std::vector<std::optional<std::string>>& new_names) const``
     - MultiIndex
     - df_multiindex.h:595
     - 
   * - ``MultiIndex shift(int periods = 1) const``
     - MultiIndex
     - df_multiindex.h:2359
     - :ref:`View <example-multiindex-shift-48>`
   * - ``size_t size() const``
     - size_t
     - df_multiindex.h:420
     - :ref:`View <example-multiindex-size-49>`
   * - ``std::pair<size_t, size_t> slice_indexer( const std::optional<std::vector<std::string>>& start = std::nullopt, const std::optional<std::vector<std::string>>& end = std::nullopt) const``
     - std::pair<size_t, size_t>
     - df_multiindex.h:2370
     - 
   * - ``std::pair<size_t, size_t> slice_locs( const std::optional<std::vector<std::string>>& start = std::nullopt, const std::optional<std::vector<std::string>>& end = std::nullopt) const``
     - std::pair<size_t, size_t>
     - df_multiindex.h:2393
     - 
   * - ``MultiIndex swaplevel(size_t i, size_t j) const``
     - MultiIndex
     - df_multiindex.h:637
     - 
   * - ``MultiIndex symmetric_difference(const MultiIndex& other) const``
     - MultiIndex
     - df_multiindex.h:2437
     - 
   * - ``MultiIndex temp(other)``
     - MultiIndex
     - df_multiindex.h:146
     - 
   * - ``MultiIndex union\_(const MultiIndex& other) const``
     - MultiIndex
     - df_multiindex.h:2573
     - 
   * - ``value_counts(bool sort = true, bool ascending = false, bool dropna = true) const``
     - 
     - df_multiindex.h:2625
     - 
   * - ``\* Creates a new Index containing the expanded level values (one per row).``
     - \* Creates a new Index containing the expanded level
     - df_multiindex.h:487
     - :ref:`View <example-multiindex-values-50>`
   * - ``void verify_integrity_impl() const``
     - void
     - df_multiindex.h:2771
     - 


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

The following examples are extracted from the test suite.

.. _example-multiindex-empty-0:

.. dropdown:: empty (np_test_1_all.cpp:6316)
   :class-title: example-dropdown

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

      }
      
      void test_data_generator_emptyBenchmarkSorting() {
          std::cout << "========= test_data_generator_empty =======================";
      
          DataGenerator<int> gen(42);
      
          // Test empty data generation
          std::vector<int> data = gen.generate(0, DataPattern::RANDOM);
      
          if (!(data.empty())) {
              std::string description = std::string("test_data_generator_emptyBenchmarkSorting():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(data.empty())";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
      
          // std::cout << "Empty data generation test passed" << std::endl;
      
          std::cout << " -> tests passed" << std::endl;
      }
      

.. _example-multiindex-item-1:

.. dropdown:: item (np_test_4_all.cpp:20048)
   :class-title: example-dropdown

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

       
      /**
       * @file np_test_phase6.cpp
       * @brief Test suite for Phase 6A - HIGH PRIORITY NDArray methods and masked array utilities
       *
       * Tests:
       * - ndarray.nonzero() - Return indices of non-zero elements
       * - ndarray.tobytes() - Convert to bytes representation
       * - ndarray.tolist() - Convert to nested list string
       * - ndarray.fill() - Fill with scalar value (in-place)
       * - ndarray.item() - Get single element as scalar
       * - ndarray.itemset() - Set single element value
       * - ma.masked_all_like() - Create masked array with all elements masked
       *
       * Created: 2025-10-28
       * Status: Phase 6A Implementation - HIGH PRIORITY functions
       */
      
      #include "../numpy/np_ndarray.h"
      #include "../numpy/np_masked_array.h"
      #include <iostream>

.. _example-multiindex-putmask-2:

.. dropdown:: putmask (np_test_5_all.cpp:4659)
   :class-title: example-dropdown

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

            mask.setElementAt({ 1 }, false);
            mask.setElementAt({ 2 }, true);
            mask.setElementAt({ 3 }, false);
            mask.setElementAt({ 4 }, true);
      
            // Create value array
            numpy::NDArray<int32_t> values({ 1 });
            values.setElementAt({ 0 }, 99);
      
            // Apply putmask
            numpy::putmask(arr, mask, values);
      
            // Expected: [99, 2, 99, 4, 99]
            if (arr.getElementAt({ 0 }) != 99 || arr.getElementAt({ 1 }) != 2 ||
              arr.getElementAt({ 2 }) != 99 || arr.getElementAt({ 3 }) != 4 ||
              arr.getElementAt({ 4 }) != 99) {
              std::cout << "  [FAIL] : in np_test_putmask() : Incorrect result";
              throw std::runtime_error("Test failed");
            }
      
            // Test with multiple values

.. _example-multiindex-searchsorted-3:

.. dropdown:: searchsorted (np_test_2_all.cpp:8204)
   :class-title: example-dropdown

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

      
            // Test missing NumPy functions
            void test_numpy_functions() {
              std::cout << "========= NumPy Functions Test ==========================";
      
              // Test searchsorted
              {
                std::vector<int> sorted_arr = { 1, 3, 5, 7, 9 };
                std::vector<int> values = { 2, 6, 8 };
      
                auto result = numpy::searchsorted(sorted_arr, values, "left");
                std::vector<size_t> expected = { 1, 3, 4 };
      
                if (result != expected) {
                  std::cout << "   searchsorted (left):                                                                   -> [FAIL]";
                  throw std::runtime_error("searchsorted (left): FAILED - incorrect result indices");
                }
                // std::cout << "[OK] searchsorted (left): PASSED" << std::endl;
      
                auto result_right = numpy::searchsorted(sorted_arr, values, "right");
                std::vector<size_t> expected_right = { 1, 3, 4 };

.. _example-multiindex-take-4:

.. dropdown:: take (np_test_5_all.cpp:4313)
   :class-title: example-dropdown

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

            for (size_t i = 0; i < 6; ++i) {
              arr.setElementAt({ i }, static_cast<int32_t>(i * 10));  // [0, 10, 20, 30, 40, 50]
            }
      
            // Take specific indices
            numpy::NDArray<size_t> indices({ 3 });
            indices.setElementAt({ 0 }, 5);  // 50
            indices.setElementAt({ 1 }, 2);  // 20
            indices.setElementAt({ 2 }, 0);  // 0
      
            auto result = numpy::take(arr, indices);
      
            if (result.getSize() != 3) {
              std::cout << "  [FAIL] : in np_test_take_basic() : Wrong result size";
              throw std::runtime_error("Test failed");
            }
      
            if (result.getElementAt({ 0 }) != 50 || result.getElementAt({ 1 }) != 20 || result.getElementAt({ 2 }) != 0) {
              std::cout << "  [FAIL] : in np_test_take_basic() : Wrong values extracted";
              throw std::runtime_error("Test failed");
            }

.. _example-multiindex-where-5:

.. dropdown:: where (np_test_3_all.cpp:15253)
   :class-title: example-dropdown

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

      
            auto y_data = createInt32Array({ 4 }, 0);
            y_data.setElementAt({ 0 }, 100);
            y_data.setElementAt({ 1 }, 200);
            y_data.setElementAt({ 2 }, 300);
            y_data.setElementAt({ 3 }, 400);
      
            auto y_mask = createBoolArray({ 4 }, false);
            MaskedArray<int32> y(y_data, y_mask, -999);
      
            // Test where() selection
            auto result = where(condition, x, y);
      
            if (!(result.getElementAt({ 0 }) == 10)) {
                std::string description = std::string("test_where_selection():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(result.getElementAt({ 0 }) == 10)";
                std::cout << std::string("[FAIL] ") + description << std::endl;
                throw std::runtime_error(description);
            }
            if (!(result.getElementAt({ 1 }) == 200)) {
                std::string description = std::string("test_where_selection():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(result.getElementAt({ 1 }) == 200)";
                std::cout << std::string("[FAIL] ") + description << std::endl;

.. _example-multiindex-ravel-6:

.. dropdown:: ravel (np_test_1_all.cpp:4082)
   :class-title: example-dropdown

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

          std::cout << "Testing ravel function...\n";
      
          // Test with 2-D array
          auto arr_2d = createFloat64Array({ 2, 3 });
          for (size_t i = 0; i < 2; ++i) {
              for (size_t j = 0; j < 3; ++j) {
                  arr_2d.setElementAt({ i, j }, static_cast<double>(i * 3 + j));
              }
          }
      
          auto raveled = ravel(arr_2d);
          if (!(raveled.getShape() == std::vector<size_t>({ 6 }))) {
              std::string description = std::string("testRavelFunction():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(raveled.getShape() == std::vector<size_t>({ 6 }))";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
      
          for (size_t i = 0; i < 6; ++i) {
              if (!(isApproxEqualExt(raveled.getElementAt({ i }), static_cast<double>(i)))) {
                  std::string description = std::string("testRavelFunction():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(isApproxEqualExt(raveled.getElementAt({ i }), static_cast<double>(i)))";
                  std::cout << std::string("[FAIL] ") + description << std::endl;

.. _example-multiindex-transpose-7:

.. dropdown:: transpose (np_test_2_all.cpp:4973)
   :class-title: example-dropdown

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

          }
      
          /**
           * Test matrix properties and methods
           */
          void testMatrixProperties() {
            std::cout << "========= testMatrixProperties =======================";
      
            // Test transpose
            numpy::Matrix<double> m("1 2 3; 4 5 6");
            auto mt = m.transpose();
            assert_test(mt.rows() == 3, "Transpose rows");
            assert_test(mt.cols() == 2, "Transpose cols");
            assert_test(std::abs(mt(0, 1) - 4.0) < 1e-10, "Transpose element");
            assert_test(std::abs(mt(2, 0) - 3.0) < 1e-10, "Transpose element");
      
            // Test trace for square matrix
            numpy::Matrix<double> square("1 2; 3 4");
            double tr = square.trace();
            assert_test(std::abs(tr - 5.0) < 1e-10, "Matrix trace");
      

.. _example-multiindex-max-8:

.. dropdown:: max (np_test_1_all.cpp:7274)
   :class-title: example-dropdown

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

      
          if (sizeof(uintp) == sizeof(void*)) {
              // std::cout << "                -> uintp size matches pointer size";
          } else {
              // std::cout << "  ✗ uintp size doesn't match pointer size" << std::endl;
          }
      
          // Test range limits
          // std::cout << "Range Information:" << std::endl;
          // std::cout << "  intp min: " << std::numeric_limits<intp>::min() << std::endl;
          // std::cout << "  intp max: " << std::numeric_limits<intp>::max() << std::endl;
          // std::cout << "  uintp max: " << std::numeric_limits<uintp>::max() << std::endl;
          // std::cout << "  longdouble digits: " << std::numeric_limits<longdouble>::digits << std::endl;
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void testComplexArithmeticExtendedTypes() {
          std::cout << "========= testComplexArithmeticExtendedTypes =======================";
      
          clongdouble c1(3.0L, 4.0L);  // 3 + 4i

.. _example-multiindex-min-9:

.. dropdown:: min (np_test_1_all.cpp:2350)
   :class-title: example-dropdown

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

              if (i % 3 == 0) {
                  large_array.setElementAt({i}, object_(static_cast<int>(i)));
              } else if (i % 3 == 1) {
                  large_array.setElementAt({i}, object_(static_cast<double>(i) * 0.5));
              } else {
                  large_array.setElementAt({i}, object_(std::string("str") + std::to_string(i)));
              }
          }
      
          // Verify pattern
          for (size_t i = 0; i < std::min(large_size, size_t(100)); ++i) {  // Check first 100
              object_ obj = large_array.getElementAt({i});
              if (i % 3 == 0) {
                  if (!(obj.is_type<int>())) {
                      std::string description = std::string("testArrayEdgeCases():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(obj.is_type<int>())";
                      std::cout << std::string("[FAIL] ") + description << std::endl;
                      throw std::runtime_error(description);
                  }
              } else if (i % 3 == 1) {
                  if (!(obj.is_type<double>())) {
                      std::string description = std::string("unknown_function():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(obj.is_type<double>())";

.. _example-multiindex-argsort-10:

.. dropdown:: argsort (np_test_1_all.cpp:16841)
   :class-title: example-dropdown

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

          std::cout << "========= test_argsort =======================";
      
          // Test 1D array argsort
          NDArray<int> arr1d({ 5 });
          arr1d.setElementAt({ 0 }, 30);  // index 0
          arr1d.setElementAt({ 1 }, 10);  // index 1 
          arr1d.setElementAt({ 2 }, 40);  // index 2
          arr1d.setElementAt({ 3 }, 20);  // index 3
          arr1d.setElementAt({ 4 }, 50);  // index 4
      
          auto indices = argsort(arr1d);
      
          // Expected order: 10(idx1), 20(idx3), 30(idx0), 40(idx2), 50(idx4)
          if (!(indices.getElementAt({ 0 }) == 1)) {
              std::string description = std::string("test_argsort():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(indices.getElementAt({ 0 }) == 1)";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
          if (!(indices.getElementAt({ 1 }) == 3)) {
              std::string description = std::string("test_argsort():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(indices.getElementAt({ 1 }) == 3)";
              std::cout << std::string("[FAIL] ") + description << std::endl;

.. _example-multiindex-sort-11:

.. dropdown:: sort (np_test_1_all.cpp:6258)
   :class-title: example-dropdown

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

          std::vector<int> data = gen.generate(100, DataPattern::FEW_UNIQUE);
      
          if (!(data.size() == 100)) {
              std::string description = std::string("test_data_generator_few_uniqueBenchmarkSorting():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(data.size() == 100)";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
      
          // Count unique values
          std::vector<int> sorted_copy = data;
          std::sort(sorted_copy.begin(), sorted_copy.end());
          auto unique_end = std::unique(sorted_copy.begin(), sorted_copy.end());
          size_t unique_count = std::distance(sorted_copy.begin(), unique_end);
      
          // Should have significantly fewer unique values than total elements
          if (!(unique_count < data.size() / 2)) {
              std::string description = std::string("test_data_generator_few_uniqueBenchmarkSorting():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(unique_count < data.size() / 2)";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
      

.. _example-multiindex-round-12:

.. dropdown:: round (np_test_1_all.cpp:23769)
   :class-title: example-dropdown

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

                throw std::runtime_error(description);
            }
            if (!(power_scalar_result.getShape() == array.getShape())) {
                std::string description = std::string("testMathFunctionSignatures():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(power_scalar_result.getShape() == array.getShape())";
                std::cout << std::string("[FAIL] ") + description << std::endl;
                throw std::runtime_error(description);
            }
            // std::cout << "[OK] Power functions have correct signatures\n";
      
            // Test rounding functions with new decimals parameter
            auto round_result = round(array);        // Default decimals=0
            auto round_decimals_result = round(array, 2);  // With decimals
            if (!(round_result.getShape() == array.getShape())) {
                std::string description = std::string("testMathFunctionSignatures():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(round_result.getShape() == array.getShape())";
                std::cout << std::string("[FAIL] ") + description << std::endl;
                throw std::runtime_error(description);
            }
            if (!(round_decimals_result.getShape() == array.getShape())) {
                std::string description = std::string("testMathFunctionSignatures():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(round_decimals_result.getShape() == array.getShape())";
                std::cout << std::string("[FAIL] ") + description << std::endl;
                throw std::runtime_error(description);

.. _example-multiindex-truncate-13:

.. dropdown:: truncate (np_test_5_all.cpp:7536)
   :class-title: example-dropdown

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

      
            if (!passed) {
              std::cout << "  [FAIL] : cutdeg failed";
              throw std::runtime_error("np_test_cutdeg failed");
            }
      
            std::cout << " -> tests passed" << std::endl;
          }
      
          void np_test_truncate() {
            std::cout << "========= truncate: truncate to size =======================";
      
            numpy::Polynomial<double> p({ 1.0, 2.0, 3.0, 4.0, 5.0 });
            auto truncated = p.truncate(3);  // Keep only first 3 coefficients
      
            auto coefs = truncated.coefficients();
            bool passed = (coefs.size() == 3 &&
              std::abs(coefs[0] - 1.0) < 1e-10 &&
              std::abs(coefs[1] - 2.0) < 1e-10 &&
              std::abs(coefs[2] - 3.0) < 1e-10);
      

.. _example-multiindex-all-14:

.. dropdown:: all (np_test_4_all.cpp:23928)
   :class-title: example-dropdown

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

                              }
                          }
                      }
      
                      auto result = numpy::einsum<numpy::float64>("ijk->ik", {A});
      
                      if (result.getShape()[0] != 2 || result.getShape()[1] != 2) {
                          throw std::runtime_error("einsum partial sum shape wrong");
                      }
      
                      // Sum over j: 1+2+3 = 6 for all (i,k) positions
                      if (std::abs(result.getElementAt({0, 0}) - 6.0) > 1e-10 ||
                          std::abs(result.getElementAt({1, 1}) - 6.0) > 1e-10) {
                          throw std::runtime_error("einsum partial sum values wrong");
                      }
      
                      // std::cout << "  OK: Partial sum: 'ijk->ik'\n";
                  }
      
                  // Test 5: Size-1 dimension handling
                  {

.. _example-multiindex-any-15:

.. dropdown:: any (np_test_2_all.cpp:16758)
   :class-title: example-dropdown

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

          // ANY() TESTS - SCALAR RESULT
          // ============================================================================
      
          void np_test_logic_any_scalar_all_false() {
            std::cout << "========= any: all false elements =======================";
      
            // Create array with all false/zero elements
            std::vector<double> data = { 0.0, 0.0, 0.0 };
            numpy::NDArray<double> arr = numpy::createArrayFromVector<double>({ 3 }, data);
      
            bool result = numpy::any(arr);
      
            if (result != false) {
              std::cout << "  [FAIL] : in np_test_logic_any_scalar_all_false() : expected false for all-zero array";
              throw std::runtime_error("np_test_logic_any_scalar_all_false failed: expected false");
            }
      
            std::cout << " -> tests passed" << std::endl;
          }
      
          void np_test_logic_any_scalar_all_true() {

.. _example-multiindex-isin-16:

.. dropdown:: isin (np_test_1_all.cpp:19434)
   :class-title: example-dropdown

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

              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
          if (!(membership.getElementAt({ 5 }) == false)) {
              std::string description = std::string("testMembershipOperations():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(membership.getElementAt({ 5 }) == false)";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
          // std::cout << "[OK] Membership testing (in1d) works correctly\n";
      
          // Test isin (alias for in1d)
          auto isin_result = isin(test_array, test_values);
      
          // Should be identical to in1d result
          for (size_t i = 0; i < membership.getSize(); ++i) {
            if (!(isin_result.getElementAt({ i }) == membership.getElementAt({ i }))) {
                std::string description = std::string("testMembershipOperations():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(isin_result.getElementAt({ i }) == membership.getElementAt({ i }))";
                std::cout << std::string("[FAIL] ") + description << std::endl;
                throw std::runtime_error(description);
            }
          }

.. _example-multiindex-unique-17:

.. dropdown:: unique (np_test_1_all.cpp:6259)
   :class-title: example-dropdown

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

      
          if (!(data.size() == 100)) {
              std::string description = std::string("test_data_generator_few_uniqueBenchmarkSorting():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(data.size() == 100)";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
      
          // Count unique values
          std::vector<int> sorted_copy = data;
          std::sort(sorted_copy.begin(), sorted_copy.end());
          auto unique_end = std::unique(sorted_copy.begin(), sorted_copy.end());
          size_t unique_count = std::distance(sorted_copy.begin(), unique_end);
      
          // Should have significantly fewer unique values than total elements
          if (!(unique_count < data.size() / 2)) {
              std::string description = std::string("test_data_generator_few_uniqueBenchmarkSorting():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(unique_count < data.size() / 2)";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
      
          // std::cout << "Few unique data generation test passed. Unique values: " << unique_count << std::endl;

.. _example-multiindex-to_numpy-18:

.. dropdown:: to_numpy (np_test_5_all.cpp:21373)
   :class-title: example-dropdown

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

          if (errors == 0) {
              std::cout << "np_test_timedelta_components -> tests passed" << std::endl;
          }
          return errors;
      }
      
      // =============================================================================
      // Test 4: Total Conversion Properties
      // =============================================================================
      int np_test_timedelta_total_conversions() {
          int errors = 0;
      
          numpy::Timedelta td(1, 12, 0);  // 1 day 12 hours = 1.5 days = 36 hours
      
          // total_seconds
          {
              double secs = td.total_seconds();
              double expected = (24 + 12) * 3600.0;
              if (std::abs(secs - expected) > 0.0001) {
                  std::cout << "[FAIL] np_test_timedelta_total_conversions: total_seconds expected "
                            << expected << ", got " << secs << std::endl;

.. _example-multiindex-to_string-19:

.. dropdown:: to_string (np_test_1_all.cpp:454)
   :class-title: example-dropdown

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

          // Modify through different views
          view1.setElementAt({0, 0}, 100);
          view2.setElementAt({2, 1}, 200);  // This is (1, 2) in original
          view3.setElementAt({0, 0}, 300);  // This is (1, 1) in original
      
          // std::cout << "After modifications through multiple views:" << std::endl;
          //original.printArray();
      
          // Verify all changes are reflected
          if (!(original.getElementAt({0, 0}) == 100)) {
              std::string description = std::string("testAdvancedViewLifecycle():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(original.getElementAt({0, 0}) == 100)";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
          if (!(original.getElementAt({1, 2}) == 200)) {
              std::string description = std::string("testAdvancedViewLifecycle():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(original.getElementAt({1, 2}) == 200)";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
          if (!(original.getElementAt({1, 1}) == 300)) {
              std::string description = std::string("testAdvancedViewLifecycle():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(original.getElementAt({1, 1}) == 300)";

.. _example-multiindex-tolist-20:

.. dropdown:: tolist (np_test_4_all.cpp:20046)
   :class-title: example-dropdown

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

      
      } // namespace numpy_tests
       
      /**
       * @file np_test_phase6.cpp
       * @brief Test suite for Phase 6A - HIGH PRIORITY NDArray methods and masked array utilities
       *
       * Tests:
       * - ndarray.nonzero() - Return indices of non-zero elements
       * - ndarray.tobytes() - Convert to bytes representation
       * - ndarray.tolist() - Convert to nested list string
       * - ndarray.fill() - Fill with scalar value (in-place)
       * - ndarray.item() - Get single element as scalar
       * - ndarray.itemset() - Set single element value
       * - ma.masked_all_like() - Create masked array with all elements masked
       *
       * Created: 2025-10-28
       * Status: Phase 6A Implementation - HIGH PRIORITY functions
       */
      
      #include "../numpy/np_ndarray.h"

.. _example-multiindex-append-21:

.. dropdown:: append (np_test_2_all.cpp:7028)
   :class-title: example-dropdown

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

                throw std::runtime_error(description);
            }
            if (!(deleted_dups.getElementAt({ 2 }) == 3)) {
                std::string description = std::string("testModificationOperations():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(deleted_dups.getElementAt({ 2 }) == 3)";
                std::cout << std::string("[FAIL] ") + description << std::endl;
                throw std::runtime_error(description);
            }
            // std::cout << "[OK] Delete with duplicate indices works correctly\n";
      
            // Test append
            auto appended = append(array, 100);
            if (!(appended.getSize() == array.getSize() + 1)) {
                std::string description = std::string("testModificationOperations():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(appended.getSize() == array.getSize() + 1)";
                std::cout << std::string("[FAIL] ") + description << std::endl;
                throw std::runtime_error(description);
            }
            if (!(appended.getElementAt({ appended.getSize() - 1 }) == 100)) {
                std::string description = std::string("testModificationOperations():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(appended.getElementAt({ appended.getSize() - 1 }) == 100)";
                std::cout << std::string("[FAIL] ") + description << std::endl;
                throw std::runtime_error(description);
            }

.. _example-multiindex-delete_-22:

.. dropdown:: delete_ (np_test_4_all.cpp:18411)
   :class-title: example-dropdown

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

          }
      
          // ============================================================================
          // SPRINT 1.2: ESSENTIAL OPERATIONS TESTS
          // ============================================================================
      
          void np_test_phase1_delete() {
            std::cout << "========= delete_: element deletion ====";
      
            auto arr = numpy::array({10, 20, 30, 40, 50});
            auto result = numpy::delete_(arr, 2);  // Delete index 2 (value 30)
      
            // Verify size reduced
            if (result.getSize() != 4) {
              std::cout << "  [FAIL] : delete_ result size is " << result.getSize() << ", expected 4\n";
              throw std::runtime_error("delete_ failed: wrong size");
            }
      
            // Verify correct element was removed
            if (result.getElementAt({0}) != 10 || result.getElementAt({1}) != 20 ||
                result.getElementAt({2}) != 40 || result.getElementAt({3}) != 50) {

.. _example-multiindex-delete_-23:

.. dropdown:: delete_ (np_test_4_all.cpp:18411)
   :class-title: example-dropdown

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

          }
      
          // ============================================================================
          // SPRINT 1.2: ESSENTIAL OPERATIONS TESTS
          // ============================================================================
      
          void np_test_phase1_delete() {
            std::cout << "========= delete_: element deletion ====";
      
            auto arr = numpy::array({10, 20, 30, 40, 50});
            auto result = numpy::delete_(arr, 2);  // Delete index 2 (value 30)
      
            // Verify size reduced
            if (result.getSize() != 4) {
              std::cout << "  [FAIL] : delete_ result size is " << result.getSize() << ", expected 4\n";
              throw std::runtime_error("delete_ failed: wrong size");
            }
      
            // Verify correct element was removed
            if (result.getElementAt({0}) != 10 || result.getElementAt({1}) != 20 ||
                result.getElementAt({2}) != 40 || result.getElementAt({3}) != 50) {

.. _example-multiindex-insert-24:

.. dropdown:: insert (np_test_1_all.cpp:6990)
   :class-title: example-dropdown

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

      }
      
      void testBusinessDateRangeDateTime() {
          std::cout << "========= testBusinessDateRangeDateTime =======================";
      
          datetime64 start("2024-03-11");  // Monday
          datetime64 end("2024-03-22");    // Friday (2 weeks later)
      
          // Create holidays set
          std::set<datetime64> holidays;
          holidays.insert(datetime64("2024-03-15"));  // Friday holiday
      
          auto business_dates = createBusinessDateRange(start, end, holidays);
          // std::cout << "Business dates from " << start.toString()
                    // << " to " << end.toString() << " (excluding 2024-03-15):" << std::endl;
          //business_dates.printArray();
      
              std::cout << " -> tests passed" << std::endl;
      }
      
      void testMonthRangeDateTime() {

.. _example-multiindex-repeat-25:

.. dropdown:: repeat (np_test_1_all.cpp:18268)
   :class-title: example-dropdown

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

      
          // Create test array
          auto array = createInt32Array({ 2, 3 }, 0);
          for (size_t i = 0; i < 2; ++i) {
            for (size_t j = 0; j < 3; ++j) {
              array.setElementAt({ i, j }, static_cast<int32_t>(i * 3 + j + 1));
            }
          }
      
          // Test repeat without axis (flattened)
          auto repeated_flat = repeat(array, 2);
          if (!(repeated_flat.getShape()[0] == 12)) {
              std::string description = std::string("testRepeat():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(repeated_flat.getShape()[0] == 12)";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
          if (!(repeated_flat.getElementAt({ 0 }) == 1)) {
              std::string description = std::string("testRepeat():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(repeated_flat.getElementAt({ 0 }) == 1)";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }

.. _example-multiindex-astype-26:

.. dropdown:: astype (np_test_3_all.cpp:796)
   :class-title: example-dropdown

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

              auto ufunc_square = numpy::frompyfunc(square, 1, 1);
      
              numpy::NDArray<double> arr({ 3 });
              arr.setElementAt({ 0 }, 2.0);
              arr.setElementAt({ 1 }, 3.0);
              arr.setElementAt({ 2 }, 4.0);
      
              auto result = ufunc_square(arr);
      
              // Convert back to double to check values
              auto typed_result = numpy::astype<double>(result);
              if (std::abs(typed_result.getElementAt({ 0 }) - 4.0) > 1e-10 ||
                std::abs(typed_result.getElementAt({ 1 }) - 9.0) > 1e-10 ||
                std::abs(typed_result.getElementAt({ 2 }) - 16.0) > 1e-10) {
                std::cout << "[FAIL] Basic frompyfunc creation failed";
                return 1;
              }
      
              // std::cout << "[OK] Basic frompyfunc creation works correctly" << std::endl;
              std::cout << " -> tests passed" << std::endl;
              return 0;

.. _example-multiindex-copy-27:

.. dropdown:: copy (np_test_1_all.cpp:9812)
   :class-title: example-dropdown

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

          //original.printArray();
      
          // The modification should be at position (1,1) in original
          if (!(original.getElementAt({1, 1}) == 9999)) {
              std::string description = std::string("testSliceCopyVsViewMemoryOwnership():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(original.getElementAt({1, 1}) == 9999)";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
          // std::cout << "[OK] Slice view shares memory with original";
      
          // Test slice copy (should be independent)
          auto slice_copy = original.sliceArray({{2, 4}, {2, 4}});
          // std::cout << "Slice copy [2:4, 2:4]:";
          //slice_copy.printArray();
      
          slice_copy.setElementAt({0, 0}, 7777);
      
          // std::cout << "After modifying slice copy at (0,0):" << std::endl;
          // std::cout << "Original array:" << std::endl;
          //original.printArray();
          // std::cout << "Slice copy:" << std::endl;

.. _example-multiindex-view-28:

.. dropdown:: view (np_test_1_all.cpp:440)
   :class-title: example-dropdown

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

          for (size_t i = 0; i < 3; ++i) {
              for (size_t j = 0; j < 3; ++j) {
                  original.setElementAt({i, j}, static_cast<int32_t>(i * 3 + j));
              }
          }
      
          // std::cout << "Original array:" << std::endl;
          //original.printArray();
      
          // Create multiple views
          auto view1 = original.view();
          auto view2 = original.transposeView();
          auto view3 = original.sliceView({{1, 3}, {1, 3}});
      
          // Modify through different views
          view1.setElementAt({0, 0}, 100);
          view2.setElementAt({2, 1}, 200);  // This is (1, 2) in original
          view3.setElementAt({0, 0}, 300);  // This is (1, 1) in original
      
          // std::cout << "After modifications through multiple views:" << std::endl;
          //original.printArray();

.. _example-multiindex-is_numeric-29:

.. dropdown:: is_numeric (np_test_1_all.cpp:7511)
   :class-title: example-dropdown

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

          std::cout << " -> tests passed" << std::endl;
      }
      
      void testNumericConversionStringTypes() {
          std::cout << "========= testNumericStringOperationsStringTypes =======================";
      
          str32 num_str1("123.45");
          str32 num_str2("67.89");
          str32 not_num("hello");
      
          // std::cout << "String '" << num_str1 << "' is numeric: " << is_numeric(num_str1) << std::endl;
          // std::cout << "String '" << not_num << "' is numeric: " << is_numeric(not_num) << std::endl;
      
          if (is_numeric(num_str1)) {
              double val1 = to_numeric(num_str1);
              // std::cout << "Numeric value of '" << num_str1 << "': " << val1 << std::endl;
          }
      
          if (is_numeric(num_str2)) {
              double val2 = to_numeric(num_str2);
              // std::cout << "Numeric value of '" << num_str2 << "': " << val2 << std::endl;

.. _example-multiindex-is_unique-30:

.. dropdown:: is_unique (np_test_1_all.cpp:19676)
   :class-title: example-dropdown

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

          unique_array.setElementAt({ 1 }, 2);
          unique_array.setElementAt({ 2 }, 3);
          unique_array.setElementAt({ 3 }, 4);
      
          auto duplicate_array = createInt32Array({ 4 }, 0);
          duplicate_array.setElementAt({ 0 }, 1);
          duplicate_array.setElementAt({ 1 }, 2);
          duplicate_array.setElementAt({ 2 }, 2);  // Duplicate
          duplicate_array.setElementAt({ 3 }, 4);
      
          if (!(set_ops::is_unique(unique_array) == true)) {
              std::string description = std::string("testUtilityFunctions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(set_ops::is_unique(unique_array) == true)";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
          if (!(set_ops::is_unique(duplicate_array) == false)) {
              std::string description = std::string("testUtilityFunctions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(set_ops::is_unique(duplicate_array) == false)";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
          // std::cout << "[OK] is_unique function works correctly\n";

.. _example-multiindex-argmax-31:

.. dropdown:: argmax (np_test_3_all.cpp:20521)
   :class-title: example-dropdown

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

      
          auto result = numpy::argmin(arr);
          // Should return 1 (index of (1,5))
          if (result.getElementAt({0}) != 1) {
              throw std::runtime_error("argmin() failed: expected index 1");
          }
          std::cout << "PASSED\n";
      }
      
      void test_argmax_complex128() {
          std::cout << "  Testing argmax() with complex128... ";
          numpy::NDArray<complex128> arr({3});
          arr.setElementAt({0}, complex128(3.0, 1.0));  // index 0 - largest
          arr.setElementAt({1}, complex128(1.0, 5.0));  // index 1
          arr.setElementAt({2}, complex128(2.0, 2.0));  // index 2
      
          auto result = numpy::argmax(arr);
          // Should return 0 (index of (3,1))
          if (result.getElementAt({0}) != 0) {
              throw std::runtime_error("argmax() failed: expected index 0");
          }

.. _example-multiindex-argmin-32:

.. dropdown:: argmin (np_test_3_all.cpp:20506)
   :class-title: example-dropdown

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

          if (min_result.getElementAt({0}).real() != 2.0 || min_result.getElementAt({0}).imag() != 1.0) {
              throw std::runtime_error("min() tie-breaking failed: expected (2,1)");
          }
          if (max_result.getElementAt({0}).real() != 2.0 || max_result.getElementAt({0}).imag() != 5.0) {
              throw std::runtime_error("max() tie-breaking failed: expected (2,5)");
          }
          std::cout << "PASSED\n";
      }
      
      void test_argmin_complex128() {
          std::cout << "  Testing argmin() with complex128... ";
          numpy::NDArray<complex128> arr({3});
          arr.setElementAt({0}, complex128(3.0, 1.0));  // index 0
          arr.setElementAt({1}, complex128(1.0, 5.0));  // index 1 - smallest
          arr.setElementAt({2}, complex128(2.0, 2.0));  // index 2
      
          auto result = numpy::argmin(arr);
          // Should return 1 (index of (1,5))
          if (result.getElementAt({0}) != 1) {
              throw std::runtime_error("argmin() failed: expected index 1");
          }

.. _example-multiindex-arrays-33:

.. dropdown:: arrays (np_test_1_all.cpp:11637)
   :class-title: example-dropdown

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

              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
          // std::cout << "[OK] Skewness with small array returns NaN\n";
      
          // Test with constant values
          auto constant_array = createFloat32Array({ 5 }, 3.0f);
          auto skew_const = skew(constant_array);
          auto kurt_const = kurtosis(constant_array);
      
          // Should be 0 for constant arrays (no variation)
          if (!(approx_equal(skew_const.getElementAt({ 0 }), 0.0, 1e-10))) {
              std::string description = std::string("testStatisticalEdgeCases():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(approx_equal(skew_const.getElementAt({ 0 }), 0.0, 1e-10))";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
          if (!(approx_equal(kurt_const.getElementAt({ 0 }), 0.0, 1e-10))) {
              std::string description = std::string("testStatisticalEdgeCases():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(approx_equal(kurt_const.getElementAt({ 0 }), 0.0, 1e-10))";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }

.. _example-multiindex-arrays-34:

.. dropdown:: arrays (np_test_1_all.cpp:11637)
   :class-title: example-dropdown

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

              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
          // std::cout << "[OK] Skewness with small array returns NaN\n";
      
          // Test with constant values
          auto constant_array = createFloat32Array({ 5 }, 3.0f);
          auto skew_const = skew(constant_array);
          auto kurt_const = kurtosis(constant_array);
      
          // Should be 0 for constant arrays (no variation)
          if (!(approx_equal(skew_const.getElementAt({ 0 }), 0.0, 1e-10))) {
              std::string description = std::string("testStatisticalEdgeCases():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(approx_equal(skew_const.getElementAt({ 0 }), 0.0, 1e-10))";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
          if (!(approx_equal(kurt_const.getElementAt({ 0 }), 0.0, 1e-10))) {
              std::string description = std::string("testStatisticalEdgeCases():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(approx_equal(kurt_const.getElementAt({ 0 }), 0.0, 1e-10))";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }

.. _example-multiindex-arrays-35:

.. dropdown:: arrays (np_test_1_all.cpp:11637)
   :class-title: example-dropdown

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

              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
          // std::cout << "[OK] Skewness with small array returns NaN\n";
      
          // Test with constant values
          auto constant_array = createFloat32Array({ 5 }, 3.0f);
          auto skew_const = skew(constant_array);
          auto kurt_const = kurtosis(constant_array);
      
          // Should be 0 for constant arrays (no variation)
          if (!(approx_equal(skew_const.getElementAt({ 0 }), 0.0, 1e-10))) {
              std::string description = std::string("testStatisticalEdgeCases():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(approx_equal(skew_const.getElementAt({ 0 }), 0.0, 1e-10))";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
          if (!(approx_equal(kurt_const.getElementAt({ 0 }), 0.0, 1e-10))) {
              std::string description = std::string("testStatisticalEdgeCases():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(approx_equal(kurt_const.getElementAt({ 0 }), 0.0, 1e-10))";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }

.. _example-multiindex-arrays-36:

.. dropdown:: arrays (np_test_1_all.cpp:11637)
   :class-title: example-dropdown

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

              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
          // std::cout << "[OK] Skewness with small array returns NaN\n";
      
          // Test with constant values
          auto constant_array = createFloat32Array({ 5 }, 3.0f);
          auto skew_const = skew(constant_array);
          auto kurt_const = kurtosis(constant_array);
      
          // Should be 0 for constant arrays (no variation)
          if (!(approx_equal(skew_const.getElementAt({ 0 }), 0.0, 1e-10))) {
              std::string description = std::string("testStatisticalEdgeCases():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(approx_equal(skew_const.getElementAt({ 0 }), 0.0, 1e-10))";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
          if (!(approx_equal(kurt_const.getElementAt({ 0 }), 0.0, 1e-10))) {
              std::string description = std::string("testStatisticalEdgeCases():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(approx_equal(kurt_const.getElementAt({ 0 }), 0.0, 1e-10))";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }

.. _example-multiindex-contains-37:

.. dropdown:: contains (np_test_2_all.cpp:10521)
   :class-title: example-dropdown

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

      
            auto npz_file = load_npz(TEMP_DIR + "test_multiple.npz");
      
            // Verify keys
            auto keys = npz_file.keys();
            if (!(keys.size() == 3)) {
                std::string description = std::string("testNPZOperations():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(keys.size() == 3)";
                std::cout << std::string("[FAIL] ") + description << std::endl;
                throw std::runtime_error(description);
            }
            if (!(npz_file.contains("integers"))) {
                std::string description = std::string("testNPZOperations():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(npz_file.contains(\"integers\"))";
                std::cout << std::string("[FAIL] ") + description << std::endl;
                throw std::runtime_error(description);
            }
            if (!(npz_file.contains("floats"))) {
                std::string description = std::string("testNPZOperations():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(npz_file.contains(\"floats\"))";
                std::cout << std::string("[FAIL] ") + description << std::endl;
                throw std::runtime_error(description);
            }
            if (!(npz_file.contains("complex_nums"))) {

.. _example-multiindex-diff-38:

.. dropdown:: diff (np_test_2_all.cpp:4947)
   :class-title: example-dropdown

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

      
            // Test matrix addition and subtraction
            numpy::Matrix<double> a("1 2; 3 4");
            numpy::Matrix<double> b("5 6; 7 8");
      
            auto sum = a + b;
            assert_test(std::abs(sum(0, 0) - 6.0) < 1e-10, "Matrix addition");
            assert_test(std::abs(sum(1, 1) - 12.0) < 1e-10, "Matrix addition");
      
            auto diff = b - a;
            assert_test(std::abs(diff(0, 0) - 4.0) < 1e-10, "Matrix subtraction");
            assert_test(std::abs(diff(1, 1) - 4.0) < 1e-10, "Matrix subtraction");
      
            // Test matrix multiplication (not element-wise!)
            auto product = a * b;
            assert_test(std::abs(product(0, 0) - 19.0) < 1e-10, "Matrix multiplication 0,0");
            assert_test(std::abs(product(0, 1) - 22.0) < 1e-10, "Matrix multiplication 0,1");
            assert_test(std::abs(product(1, 0) - 43.0) < 1e-10, "Matrix multiplication 1,0");
            assert_test(std::abs(product(1, 1) - 50.0) < 1e-10, "Matrix multiplication 1,1");
      
            // Test scalar multiplication

.. _example-multiindex-difference-39:

.. dropdown:: difference (np_test_1_all.cpp:19333)
   :class-title: example-dropdown

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

              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
          if (!(difference.getElementAt({ 2 }) == 5)) {
              std::string description = std::string("testSetDifferenceOperations():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(difference.getElementAt({ 2 }) == 5)";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
          // std::cout << "[OK] Set difference works correctly\n";
      
          // Test symmetric difference (XOR)
          auto xor_result = setxor1d(arr1, arr2);
      
          if (!(xor_result.getSize() == 4)) {
              std::string description = std::string("testSetDifferenceOperations():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(xor_result.getSize() == 4)";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
          if (!(xor_result.getElementAt({ 0 }) == 1)) {
              std::string description = std::string("testSetDifferenceOperations():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(xor_result.getElementAt({ 0 }) == 1)";
              std::cout << std::string("[FAIL] ") + description << std::endl;

.. _example-multiindex-dtypes-40:

.. dropdown:: dtypes (np_test_4_all.cpp:10403)
   :class-title: example-dropdown

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

          }
          catch (const std::exception& e) {
            std::cout << "====================================== np_test_power_scalar FAILED ==================================== ";
            std::cout << "Exception: " << e.what() << std::endl;
            return 1;
          }
        }
      
      } // namespace numpy_tests
      // Test file for abs() scalar support
      // Tests all 13 dtypes (8 int, 1 bool, 2 float, 2 complex) + edge cases
      // Expected: 17 tests, all passing
      
      #include <iostream>
      #include <cmath>
      #include <stdexcept>
      #include "../numpy/np_ndarray.h"
      #include "../numpy/np_math_utils_sqrt.h"
      
      namespace numpy_tests {
      namespace numpy_tests_abs_scalar {

.. _example-multiindex-format-41:

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

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

      int main() {
        // Automatically log all output to temp/test_output.log
        numpy::TestLogger logger("temp/test_output.log");
      
        int res = 0;
        int res1 = 0;
        std::string resS = "";
      
        // call all the tests
        res1 = numpy_tests::np_test_main();
        resS += std::format("             np_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-multiindex-join-42:

.. dropdown:: join (np_test_5_all.cpp:1341)
   :class-title: example-dropdown

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

          // ============================================================================
      
          void np_test_string_join() {
            std::cout << "========= join operation =======================";
      
            // Join takes a separator string and vector of CharArrays
            std::vector<numpy::CharArray<32>> arrays;
            arrays.push_back(numpy::char_::array<32>({ "a", "b", "c" }));
            arrays.push_back(numpy::char_::array<32>({ "x", "y", "z" }));
      
            auto result = numpy::char_::join("-", arrays);
      
            bool passed = true;
      
            if (!passed) {
              std::cout << "  [FAIL] : in np_test_string_join() : join operation failed";
              throw std::runtime_error("np_test_string_join failed");
            }
      
            std::cout << " -> tests passed" << std::endl;
          }

.. _example-multiindex-levels-43:

.. dropdown:: levels (np_test_5_all.cpp:105)
   :class-title: example-dropdown

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

                  }
      
                  std::cout << " -> tests passed" << std::endl;
              }
      
              // ===========================================================================
              // Test 2: Compression Levels
              // ===========================================================================
      
              void np_test_zlib_compression_levels() {
                  std::cout << "========= compression levels (0-9) =============================";
      
                  std::vector<unsigned char> data = create_test_data(1000, 'A');
      
                  for (int level = 0; level <= 9; ++level) {
                      uLongf compressed_len = compressBound(static_cast<uLong>(data.size()));
                      std::vector<Bytef> compressed(compressed_len);
      
                      int result = compress2(compressed.data(), &compressed_len,
                                            data.data(), static_cast<uLong>(data.size()), level);
      

.. _example-multiindex-names-44:

.. dropdown:: names (np_test_2_all.cpp:18817)
   :class-title: example-dropdown

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

            create_txt_file("test_auto_names.txt");
      
            // Don't provide names - should generate f0, f1, f2, f3
            auto data = numpy::io::recfromtxt(csv_test_dir + "test_auto_names.txt");
      
            auto dtype = data.getDType();
      
            // Verify auto-generated names
            if (!dtype.hasField("f0") || !dtype.hasField("f1") ||
              !dtype.hasField("f2") || !dtype.hasField("f3")) {
              std::cout << "  [FAIL] : Missing auto-generated field names (f0, f1, f2, f3)";
              throw std::runtime_error("np_test_io_extensions_recfromtxt_auto_names failed: missing auto names");
            }
      
            std::cout << " -> tests passed" << std::endl;
          }
      
          // ============================================================================
          // ERROR HANDLING TESTS
          // ============================================================================
      

.. _example-multiindex-pairs-45:

.. dropdown:: pairs (np_test_2_all.cpp:8793)
   :class-title: example-dropdown

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

      
                if (result != expected) {
                  std::cout << "   IPP integer msort:                                                                      -> [FAIL]";
                  throw std::runtime_error("IPP integer msort: FAILED - incorrect sorted order");
                }
                // std::cout << "[OK] IPP integer msort: PASSED" << std::endl;
              }
      
              // Test 2: Float msort with stability test
              {
                // Test stability using pairs (value, original_index)
                struct TestPair {
                  double value;
                  int original_index;
                  bool operator==(const TestPair& other) const {
                    return value == other.value && original_index == other.original_index;
                  }
                  bool operator<(const TestPair& other) const {
                    return value < other.value;
                  }
                };

.. _example-multiindex-result-46:

.. dropdown:: result (np_test_1_all.cpp:6090)
   :class-title: example-dropdown

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

              throw std::runtime_error(description);
          }
          // std::cout << "Timer restart test passed. Second: " << second_elapsed << " ms" << std::endl;
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void test_benchmark_result_storageBenchmarkSorting() {
          std::cout << "========= test_benchmark_result_storage =======================";
      
          BenchmarkResult result("TestAlgorithm", 1000, 15.5, true, 4096);
      
          if (!(result.algorithm_name == "TestAlgorithm")) {
              std::string description = std::string("test_benchmark_result_storageBenchmarkSorting():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(result.algorithm_name == \"TestAlgorithm\")";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
          if (!(result.array_size == 1000)) {
              std::string description = std::string("test_benchmark_result_storageBenchmarkSorting():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(result.array_size == 1000)";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);

.. _example-multiindex-result-47:

.. dropdown:: result (np_test_1_all.cpp:6090)
   :class-title: example-dropdown

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

              throw std::runtime_error(description);
          }
          // std::cout << "Timer restart test passed. Second: " << second_elapsed << " ms" << std::endl;
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void test_benchmark_result_storageBenchmarkSorting() {
          std::cout << "========= test_benchmark_result_storage =======================";
      
          BenchmarkResult result("TestAlgorithm", 1000, 15.5, true, 4096);
      
          if (!(result.algorithm_name == "TestAlgorithm")) {
              std::string description = std::string("test_benchmark_result_storageBenchmarkSorting():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(result.algorithm_name == \"TestAlgorithm\")";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
          if (!(result.array_size == 1000)) {
              std::string description = std::string("test_benchmark_result_storageBenchmarkSorting():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(result.array_size == 1000)";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);

.. _example-multiindex-shift-48:

.. dropdown:: shift (np_test_1_all.cpp:2761)
   :class-title: example-dropdown

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

              throw std::runtime_error(description);
          }
          if (!(left_array.getElementAt({3}) == 16384)) {
              std::string description = std::string("testBitShifts():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(left_array.getElementAt({3}) == 16384)";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
      
          // std::cout << "[OK] Left shift by array\n";
      
          // Test excessive shift (should result in 0)
          auto excessive_left = left_shift(arr, 20); // More than 16 bits
          if (!(excessive_left.getElementAt({0}) == 0)) {
              std::string description = std::string("testBitShifts():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(excessive_left.getElementAt({0}) == 0)";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
          if (!(excessive_left.getElementAt({1}) == 0)) {
              std::string description = std::string("testBitShifts():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(excessive_left.getElementAt({1}) == 0)";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);

.. _example-multiindex-size-49:

.. dropdown:: size (np_test_1_all.cpp:47)
   :class-title: example-dropdown

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

      
      using namespace numpy;
      using namespace numpy::benchmark;
      using namespace numpy::char_;
      
      // Helper functions for array comparison tests
      namespace {
          const double TOLERANCE = 1e-10;
      
          bool allTrue(const NDArray<bool>& arr) {
              std::vector<size_t> indices(arr.getShape().size(), 0);
              do {
                  if (!arr.getElementAt(indices)) {
                      return false;
                  }
              } while (incrementIndices(indices, arr.getShape()));
              return true;
          }
      
          bool allFalse(const NDArray<bool>& arr) {
              std::vector<size_t> indices(arr.getShape().size(), 0);

.. _example-multiindex-values-50:

.. dropdown:: values (np_test_1_all.cpp:15133)
   :class-title: example-dropdown

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

              std::cout << " -> tests passed" << std::endl;
            }
            else {
              std::cout << "[FAIL] Where function failed" << std::endl;
              errors++;
            }
      
            // Test 8: Clip function
            std::cout << "========= test_clip_function =======================" ;
      
            numpy::NDArray<double> values({ 5 });
            values.setElementAt({ 0 }, -2.0);
            values.setElementAt({ 1 }, -1.0);
            values.setElementAt({ 2 }, 0.5);
            values.setElementAt({ 3 }, 2.0);
            values.setElementAt({ 4 }, 5.0);
            double min_val = -1.0;
            double max_val = 3.0;
      
            auto clip_result = numpy::clip(values, min_val, max_val);