NDArrayBackedExtensionIndex

class numpy::NDArrayBackedExtensionIndex

numpy C++ class.

Example

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

// Use NDArrayBackedExtensionIndex
NDArrayBackedExtensionIndex obj;
// ... operations ...

Constructors

Signature	Location	Example
explicit NDArrayBackedExtensionIndex(const ArrayType& array, const std::optional<std::string>& name = std::nullopt, bool copy = false)	df_ndarray_backed_extension_index.h:139
explicit NDArrayBackedExtensionIndex(ArrayType&& array, const std::optional<std::string>& name = std::nullopt)	df_ndarray_backed_extension_index.h:149
NDArrayBackedExtensionIndex(const NDArrayBackedExtensionIndex& other)	df_ndarray_backed_extension_index.h:158
NDArrayBackedExtensionIndex(NDArrayBackedExtensionIndex&& other) noexcept	df_ndarray_backed_extension_index.h:166

Indexing / Selection

Signature	Return Type	Location	Example
std::string get_value_str(size_t index) const override	std::string	df_ndarray_backed_extension_index.h:667

I/O

Signature	Return Type	Location	Example
std::string to_string() const override	std::string	df_ndarray_backed_extension_index.h:611	View

Type Handling

Signature	Return Type	Location	Example
NDArrayBackedExtensionIndex copy() const	NDArrayBackedExtensionIndex	df_ndarray_backed_extension_index.h:712	View

Type Checking

Signature	Return Type	Location	Example
bool is_all_dates() const	bool	df_ndarray_backed_extension_index.h:486

Other Methods

Signature	Return Type	Location	Example
DatetimeArray arr(data, mask)	DatetimeArray	df_ndarray_backed_extension_index.h:276	View
TimedeltaArray arr(data, mask)	TimedeltaArray	df_ndarray_backed_extension_index.h:293	View
DatetimeArray arr(data, mask)	DatetimeArray	df_ndarray_backed_extension_index.h:346	View
TimedeltaArray arr(data, mask)	TimedeltaArray	df_ndarray_backed_extension_index.h:362	View
PeriodArray arr(data, mask, "D")	PeriodArray	df_ndarray_backed_extension_index.h:376	View
PeriodArray arr(data, mask, freq)	PeriodArray	df_ndarray_backed_extension_index.h:402	View
size_t cache_memory_usage() const override	size_t	df_ndarray_backed_extension_index.h:897
\* Clears both the base class caches (from ExtensionIndex) and	* Clears both the base class	df_ndarray_backed_extension_index.h:875
void clear_cache() const override	void	df_ndarray_backed_extension_index.h:878
std::unique_ptr<IndexBase> clone() const override	std::unique_ptr<IndexBase>	df_ndarray_backed_extension_index.h:604	View
numpy::NDArray<numpy::datetime64> data(std::vector<size_t>	numpy::NDArray<numpy::datetime64>	df_ndarray_backed_extension_index.h:263	View
numpy::NDArray<numpy::timedelta64> data(std::vector<size_t>	numpy::NDArray<numpy::timedelta64>	df_ndarray_backed_extension_index.h:281	View
numpy::NDArray<numpy::int64> data(std::vector<size_t>	numpy::NDArray<numpy::int64>	df_ndarray_backed_extension_index.h:298	View
numpy::NDArray<numpy::datetime64> data(std::vector<size_t>	numpy::NDArray<numpy::datetime64>	df_ndarray_backed_extension_index.h:334	View
numpy::NDArray<numpy::timedelta64> data(std::vector<size_t>	numpy::NDArray<numpy::timedelta64>	df_ndarray_backed_extension_index.h:350	View
numpy::NDArray<numpy::int64> data(std::vector<size_t>	numpy::NDArray<numpy::int64>	df_ndarray_backed_extension_index.h:366	View
numpy::NDArray<numpy::int64> data(std::vector<size_t>	numpy::NDArray<numpy::int64>	df_ndarray_backed_extension_index.h:393	View
static std::string format_datetime(const numpy::datetime64& val)	static std::string	df_ndarray_backed_extension_index.h:733
std::string format_period(numpy::int64 ordinal) const	std::string	df_ndarray_backed_extension_index.h:832
static std::string format_timedelta(const numpy::timedelta64& val)	static std::string	df_ndarray_backed_extension_index.h:793
std::string freq_string() const	std::string	df_ndarray_backed_extension_index.h:563
bool has_cached_values() const override	bool	df_ndarray_backed_extension_index.h:888
std::string inferred_type() const override	std::string	df_ndarray_backed_extension_index.h:590
numpy::NDArray<numpy::bool\_> mask(std::vector<size_t>	numpy::NDArray<numpy::bool_>	df_ndarray_backed_extension_index.h:264	View
numpy::NDArray<numpy::bool\_> mask(std::vector<size_t>	numpy::NDArray<numpy::bool_>	df_ndarray_backed_extension_index.h:282	View
numpy::NDArray<numpy::bool\_> mask(std::vector<size_t>	numpy::NDArray<numpy::bool_>	df_ndarray_backed_extension_index.h:299	View
numpy::NDArray<numpy::bool\_> mask(std::vector<size_t>	numpy::NDArray<numpy::bool_>	df_ndarray_backed_extension_index.h:335	View
numpy::NDArray<numpy::bool\_> mask(std::vector<size_t>	numpy::NDArray<numpy::bool_>	df_ndarray_backed_extension_index.h:351	View
numpy::NDArray<numpy::bool\_> mask(std::vector<size_t>	numpy::NDArray<numpy::bool_>	df_ndarray_backed_extension_index.h:367	View
numpy::NDArray<numpy::bool\_> mask(std::vector<size_t>	numpy::NDArray<numpy::bool_>	df_ndarray_backed_extension_index.h:394	View
PeriodArray arr(data, mask, period_freq_to_string(current_arr.freq()))	PeriodArray arr(data, mask,	df_ndarray_backed_extension_index.h:309
NDArrayBackedExtensionIndex rename(const std::optional<std::string>& new_name) const	NDArrayBackedExtensionIndex	df_ndarray_backed_extension_index.h:719
std::string repr() const override	std::string	df_ndarray_backed_extension_index.h:660
std::string resolution() const	std::string	df_ndarray_backed_extension_index.h:424	View
NDArrayBackedExtensionIndex result(\*this)	NDArrayBackedExtensionIndex	df_ndarray_backed_extension_index.h:720	View
std::string unit() const	std::string	df_ndarray_backed_extension_index.h:525
static std::string unit_to_string(numpy::DateTimeUnit unit)	static std::string	df_ndarray_backed_extension_index.h:540
\* int64 values (nanoseconds since epoch, timedelta values, or period ordinals).	* int64	df_ndarray_backed_extension_index.h:214	View

Internal Methods

6 internal methods (prefixed with underscore)

Code Examples

The following examples are extracted from the test suite.

to_string (np_test_1_all.cpp:454)

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

copy (np_test_1_all.cpp:9812)

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

arr (np_test_1_all.cpp:1388)

        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    if (!(*str_obj.get_as<std::string>() == "hello")) {
        std::string description = std::string("testObjectConstruction():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(*str_obj.get_as<std::string>() == \"hello\")";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }

    // Test NDArray construction
    NDArray<double> arr({2, 2}, 3.14);
    object_ arr_obj(arr);
    if (!(!arr_obj.is_null())) {
        std::string description = std::string("testObjectConstruction():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(!arr_obj.is_null())";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    if (!(arr_obj.is_array())) {
        std::string description = std::string("testObjectConstruction():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(arr_obj.is_array())";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);

arr (np_test_1_all.cpp:1388)

        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    if (!(*str_obj.get_as<std::string>() == "hello")) {
        std::string description = std::string("testObjectConstruction():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(*str_obj.get_as<std::string>() == \"hello\")";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }

    // Test NDArray construction
    NDArray<double> arr({2, 2}, 3.14);
    object_ arr_obj(arr);
    if (!(!arr_obj.is_null())) {
        std::string description = std::string("testObjectConstruction():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(!arr_obj.is_null())";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    if (!(arr_obj.is_array())) {
        std::string description = std::string("testObjectConstruction():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(arr_obj.is_array())";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);

arr (np_test_1_all.cpp:1388)

        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    if (!(*str_obj.get_as<std::string>() == "hello")) {
        std::string description = std::string("testObjectConstruction():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(*str_obj.get_as<std::string>() == \"hello\")";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }

    // Test NDArray construction
    NDArray<double> arr({2, 2}, 3.14);
    object_ arr_obj(arr);
    if (!(!arr_obj.is_null())) {
        std::string description = std::string("testObjectConstruction():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(!arr_obj.is_null())";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    if (!(arr_obj.is_array())) {
        std::string description = std::string("testObjectConstruction():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(arr_obj.is_array())";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);

arr (np_test_1_all.cpp:1388)

        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    if (!(*str_obj.get_as<std::string>() == "hello")) {
        std::string description = std::string("testObjectConstruction():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(*str_obj.get_as<std::string>() == \"hello\")";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }

    // Test NDArray construction
    NDArray<double> arr({2, 2}, 3.14);
    object_ arr_obj(arr);
    if (!(!arr_obj.is_null())) {
        std::string description = std::string("testObjectConstruction():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(!arr_obj.is_null())";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    if (!(arr_obj.is_array())) {
        std::string description = std::string("testObjectConstruction():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(arr_obj.is_array())";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);

arr (np_test_1_all.cpp:1388)

        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    if (!(*str_obj.get_as<std::string>() == "hello")) {
        std::string description = std::string("testObjectConstruction():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(*str_obj.get_as<std::string>() == \"hello\")";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }

    // Test NDArray construction
    NDArray<double> arr({2, 2}, 3.14);
    object_ arr_obj(arr);
    if (!(!arr_obj.is_null())) {
        std::string description = std::string("testObjectConstruction():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(!arr_obj.is_null())";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    if (!(arr_obj.is_array())) {
        std::string description = std::string("testObjectConstruction():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(arr_obj.is_array())";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);

arr (np_test_1_all.cpp:1388)

        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    if (!(*str_obj.get_as<std::string>() == "hello")) {
        std::string description = std::string("testObjectConstruction():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(*str_obj.get_as<std::string>() == \"hello\")";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }

    // Test NDArray construction
    NDArray<double> arr({2, 2}, 3.14);
    object_ arr_obj(arr);
    if (!(!arr_obj.is_null())) {
        std::string description = std::string("testObjectConstruction():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(!arr_obj.is_null())";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    if (!(arr_obj.is_array())) {
        std::string description = std::string("testObjectConstruction():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(arr_obj.is_array())";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);

clone (np_test_1_all.cpp:24942)

      }

      // Test reproducibility
      numpy::random::PCG64DXSM rng2(11111);
      if (rng2.next_uint64() != val) {
        std::cout << "  [FAIL] : in np_test_bitgen_pcg64dxsm() : not reproducible";
        throw std::runtime_error("np_test_bitgen_pcg64dxsm failed");
      }

      // Test clone
      auto cloned = rng.clone();
      if (cloned->name() != "PCG64DXSM") {
        std::cout << "  [FAIL] : in np_test_bitgen_pcg64dxsm() : clone name incorrect";
        throw std::runtime_error("np_test_bitgen_pcg64dxsm failed");
      }

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

    // ============================================================================
    // PHILOX TESTS

data (np_test_1_all.cpp:2084)

    }
    if (!(derived_ptr->extra == 2)) {
        std::string description = std::string("testObjectHolderEdgeCases():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(derived_ptr->extra == 2)";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }

    // Test 6: Large object handling
    struct LargeObject {
        std::vector<double> data;
        LargeObject() : data(10000, 3.14159) {}  // Large object
    };

    LargeObject large;
    object_ large_obj(large);  // Should handle large objects
    if (!(!large_obj.is_null())) {
        std::string description = std::string("testObjectHolderEdgeCases():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(!large_obj.is_null())";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    if (!(large_obj.is_type<LargeObject>())) {

data (np_test_1_all.cpp:2084)

    }
    if (!(derived_ptr->extra == 2)) {
        std::string description = std::string("testObjectHolderEdgeCases():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(derived_ptr->extra == 2)";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }

    // Test 6: Large object handling
    struct LargeObject {
        std::vector<double> data;
        LargeObject() : data(10000, 3.14159) {}  // Large object
    };

    LargeObject large;
    object_ large_obj(large);  // Should handle large objects
    if (!(!large_obj.is_null())) {
        std::string description = std::string("testObjectHolderEdgeCases():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(!large_obj.is_null())";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    if (!(large_obj.is_type<LargeObject>())) {

data (np_test_1_all.cpp:2084)

    }
    if (!(derived_ptr->extra == 2)) {
        std::string description = std::string("testObjectHolderEdgeCases():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(derived_ptr->extra == 2)";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }

    // Test 6: Large object handling
    struct LargeObject {
        std::vector<double> data;
        LargeObject() : data(10000, 3.14159) {}  // Large object
    };

    LargeObject large;
    object_ large_obj(large);  // Should handle large objects
    if (!(!large_obj.is_null())) {
        std::string description = std::string("testObjectHolderEdgeCases():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(!large_obj.is_null())";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    if (!(large_obj.is_type<LargeObject>())) {

data (np_test_1_all.cpp:2084)

    }
    if (!(derived_ptr->extra == 2)) {
        std::string description = std::string("testObjectHolderEdgeCases():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(derived_ptr->extra == 2)";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }

    // Test 6: Large object handling
    struct LargeObject {
        std::vector<double> data;
        LargeObject() : data(10000, 3.14159) {}  // Large object
    };

    LargeObject large;
    object_ large_obj(large);  // Should handle large objects
    if (!(!large_obj.is_null())) {
        std::string description = std::string("testObjectHolderEdgeCases():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(!large_obj.is_null())";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    if (!(large_obj.is_type<LargeObject>())) {

data (np_test_1_all.cpp:2084)

    }
    if (!(derived_ptr->extra == 2)) {
        std::string description = std::string("testObjectHolderEdgeCases():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(derived_ptr->extra == 2)";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }

    // Test 6: Large object handling
    struct LargeObject {
        std::vector<double> data;
        LargeObject() : data(10000, 3.14159) {}  // Large object
    };

    LargeObject large;
    object_ large_obj(large);  // Should handle large objects
    if (!(!large_obj.is_null())) {
        std::string description = std::string("testObjectHolderEdgeCases():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(!large_obj.is_null())";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    if (!(large_obj.is_type<LargeObject>())) {

data (np_test_1_all.cpp:2084)

    }
    if (!(derived_ptr->extra == 2)) {
        std::string description = std::string("testObjectHolderEdgeCases():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(derived_ptr->extra == 2)";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }

    // Test 6: Large object handling
    struct LargeObject {
        std::vector<double> data;
        LargeObject() : data(10000, 3.14159) {}  // Large object
    };

    LargeObject large;
    object_ large_obj(large);  // Should handle large objects
    if (!(!large_obj.is_null())) {
        std::string description = std::string("testObjectHolderEdgeCases():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(!large_obj.is_null())";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    if (!(large_obj.is_type<LargeObject>())) {

data (np_test_1_all.cpp:2084)

    }
    if (!(derived_ptr->extra == 2)) {
        std::string description = std::string("testObjectHolderEdgeCases():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(derived_ptr->extra == 2)";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }

    // Test 6: Large object handling
    struct LargeObject {
        std::vector<double> data;
        LargeObject() : data(10000, 3.14159) {}  // Large object
    };

    LargeObject large;
    object_ large_obj(large);  // Should handle large objects
    if (!(!large_obj.is_null())) {
        std::string description = std::string("testObjectHolderEdgeCases():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(!large_obj.is_null())";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    if (!(large_obj.is_type<LargeObject>())) {

mask (np_test_1_all.cpp:27691)

    void test_mask_rows_cols() {
      std::cout << "========= ma::mask_rows() and ma::mask_cols(): mask operations ===";

      auto data = numpy::array({ {1.0, 2.0, 3.0}, {4.0, 5.0, 6.0} });
      auto mask = numpy::array({ {false, true, false}, {false, false, false} });
      auto ma = numpy::ma::masked_array(data, mask);

      auto result_rows = numpy::ma::mask_rows(ma);
      auto result_cols = numpy::ma::mask_cols(ma);

      // std::cout << "  ma::mask_rows(): row 0 fully masked: " << (result_rows.mask().getElementAt({ 0, 0 }) ? "true" : "false") << std::endl;
      // std::cout << "  ma::mask_cols(): column 1 fully masked: " << (result_cols.mask().getElementAt({ 1, 1 }) ? "true" : "false");
      std::cout << " -> tests passed";
    }

    void test_compress_rowcols() {
      std::cout << "========= ma::compress_rowcols(): remove masked rows/columns ===";

      auto data = numpy::array({ {1.0, 2.0, 3.0}, {4.0, 5.0, 6.0}, {7.0, 8.0, 9.0} });
      auto mask = numpy::array({ {false, false, false}, {false, true, false}, {false, false, false} });
      auto ma = numpy::ma::masked_array(data, mask);

mask (np_test_1_all.cpp:27691)

    void test_mask_rows_cols() {
      std::cout << "========= ma::mask_rows() and ma::mask_cols(): mask operations ===";

      auto data = numpy::array({ {1.0, 2.0, 3.0}, {4.0, 5.0, 6.0} });
      auto mask = numpy::array({ {false, true, false}, {false, false, false} });
      auto ma = numpy::ma::masked_array(data, mask);

      auto result_rows = numpy::ma::mask_rows(ma);
      auto result_cols = numpy::ma::mask_cols(ma);

      // std::cout << "  ma::mask_rows(): row 0 fully masked: " << (result_rows.mask().getElementAt({ 0, 0 }) ? "true" : "false") << std::endl;
      // std::cout << "  ma::mask_cols(): column 1 fully masked: " << (result_cols.mask().getElementAt({ 1, 1 }) ? "true" : "false");
      std::cout << " -> tests passed";
    }

    void test_compress_rowcols() {
      std::cout << "========= ma::compress_rowcols(): remove masked rows/columns ===";

      auto data = numpy::array({ {1.0, 2.0, 3.0}, {4.0, 5.0, 6.0}, {7.0, 8.0, 9.0} });
      auto mask = numpy::array({ {false, false, false}, {false, true, false}, {false, false, false} });
      auto ma = numpy::ma::masked_array(data, mask);

mask (np_test_1_all.cpp:27691)

    void test_mask_rows_cols() {
      std::cout << "========= ma::mask_rows() and ma::mask_cols(): mask operations ===";

      auto data = numpy::array({ {1.0, 2.0, 3.0}, {4.0, 5.0, 6.0} });
      auto mask = numpy::array({ {false, true, false}, {false, false, false} });
      auto ma = numpy::ma::masked_array(data, mask);

      auto result_rows = numpy::ma::mask_rows(ma);
      auto result_cols = numpy::ma::mask_cols(ma);

      // std::cout << "  ma::mask_rows(): row 0 fully masked: " << (result_rows.mask().getElementAt({ 0, 0 }) ? "true" : "false") << std::endl;
      // std::cout << "  ma::mask_cols(): column 1 fully masked: " << (result_cols.mask().getElementAt({ 1, 1 }) ? "true" : "false");
      std::cout << " -> tests passed";
    }

    void test_compress_rowcols() {
      std::cout << "========= ma::compress_rowcols(): remove masked rows/columns ===";

      auto data = numpy::array({ {1.0, 2.0, 3.0}, {4.0, 5.0, 6.0}, {7.0, 8.0, 9.0} });
      auto mask = numpy::array({ {false, false, false}, {false, true, false}, {false, false, false} });
      auto ma = numpy::ma::masked_array(data, mask);

mask (np_test_1_all.cpp:27691)

    void test_mask_rows_cols() {
      std::cout << "========= ma::mask_rows() and ma::mask_cols(): mask operations ===";

      auto data = numpy::array({ {1.0, 2.0, 3.0}, {4.0, 5.0, 6.0} });
      auto mask = numpy::array({ {false, true, false}, {false, false, false} });
      auto ma = numpy::ma::masked_array(data, mask);

      auto result_rows = numpy::ma::mask_rows(ma);
      auto result_cols = numpy::ma::mask_cols(ma);

      // std::cout << "  ma::mask_rows(): row 0 fully masked: " << (result_rows.mask().getElementAt({ 0, 0 }) ? "true" : "false") << std::endl;
      // std::cout << "  ma::mask_cols(): column 1 fully masked: " << (result_cols.mask().getElementAt({ 1, 1 }) ? "true" : "false");
      std::cout << " -> tests passed";
    }

    void test_compress_rowcols() {
      std::cout << "========= ma::compress_rowcols(): remove masked rows/columns ===";

      auto data = numpy::array({ {1.0, 2.0, 3.0}, {4.0, 5.0, 6.0}, {7.0, 8.0, 9.0} });
      auto mask = numpy::array({ {false, false, false}, {false, true, false}, {false, false, false} });
      auto ma = numpy::ma::masked_array(data, mask);

mask (np_test_1_all.cpp:27691)

    void test_mask_rows_cols() {
      std::cout << "========= ma::mask_rows() and ma::mask_cols(): mask operations ===";

      auto data = numpy::array({ {1.0, 2.0, 3.0}, {4.0, 5.0, 6.0} });
      auto mask = numpy::array({ {false, true, false}, {false, false, false} });
      auto ma = numpy::ma::masked_array(data, mask);

      auto result_rows = numpy::ma::mask_rows(ma);
      auto result_cols = numpy::ma::mask_cols(ma);

      // std::cout << "  ma::mask_rows(): row 0 fully masked: " << (result_rows.mask().getElementAt({ 0, 0 }) ? "true" : "false") << std::endl;
      // std::cout << "  ma::mask_cols(): column 1 fully masked: " << (result_cols.mask().getElementAt({ 1, 1 }) ? "true" : "false");
      std::cout << " -> tests passed";
    }

    void test_compress_rowcols() {
      std::cout << "========= ma::compress_rowcols(): remove masked rows/columns ===";

      auto data = numpy::array({ {1.0, 2.0, 3.0}, {4.0, 5.0, 6.0}, {7.0, 8.0, 9.0} });
      auto mask = numpy::array({ {false, false, false}, {false, true, false}, {false, false, false} });
      auto ma = numpy::ma::masked_array(data, mask);

mask (np_test_1_all.cpp:27691)

    void test_mask_rows_cols() {
      std::cout << "========= ma::mask_rows() and ma::mask_cols(): mask operations ===";

      auto data = numpy::array({ {1.0, 2.0, 3.0}, {4.0, 5.0, 6.0} });
      auto mask = numpy::array({ {false, true, false}, {false, false, false} });
      auto ma = numpy::ma::masked_array(data, mask);

      auto result_rows = numpy::ma::mask_rows(ma);
      auto result_cols = numpy::ma::mask_cols(ma);

      // std::cout << "  ma::mask_rows(): row 0 fully masked: " << (result_rows.mask().getElementAt({ 0, 0 }) ? "true" : "false") << std::endl;
      // std::cout << "  ma::mask_cols(): column 1 fully masked: " << (result_cols.mask().getElementAt({ 1, 1 }) ? "true" : "false");
      std::cout << " -> tests passed";
    }

    void test_compress_rowcols() {
      std::cout << "========= ma::compress_rowcols(): remove masked rows/columns ===";

      auto data = numpy::array({ {1.0, 2.0, 3.0}, {4.0, 5.0, 6.0}, {7.0, 8.0, 9.0} });
      auto mask = numpy::array({ {false, false, false}, {false, true, false}, {false, false, false} });
      auto ma = numpy::ma::masked_array(data, mask);

mask (np_test_1_all.cpp:27691)

    void test_mask_rows_cols() {
      std::cout << "========= ma::mask_rows() and ma::mask_cols(): mask operations ===";

      auto data = numpy::array({ {1.0, 2.0, 3.0}, {4.0, 5.0, 6.0} });
      auto mask = numpy::array({ {false, true, false}, {false, false, false} });
      auto ma = numpy::ma::masked_array(data, mask);

      auto result_rows = numpy::ma::mask_rows(ma);
      auto result_cols = numpy::ma::mask_cols(ma);

      // std::cout << "  ma::mask_rows(): row 0 fully masked: " << (result_rows.mask().getElementAt({ 0, 0 }) ? "true" : "false") << std::endl;
      // std::cout << "  ma::mask_cols(): column 1 fully masked: " << (result_cols.mask().getElementAt({ 1, 1 }) ? "true" : "false");
      std::cout << " -> tests passed";
    }

    void test_compress_rowcols() {
      std::cout << "========= ma::compress_rowcols(): remove masked rows/columns ===";

      auto data = numpy::array({ {1.0, 2.0, 3.0}, {4.0, 5.0, 6.0}, {7.0, 8.0, 9.0} });
      auto mask = numpy::array({ {false, false, false}, {false, true, false}, {false, false, false} });
      auto ma = numpy::ma::masked_array(data, mask);

resolution (np_test_5_all.cpp:21200)

            std::cout << "[FAIL] np_test_timedelta_constructors: Timedelta(30, 's') expected 30 seconds, got "
                      << td_sec.total_seconds() << std::endl;
            errors++;
        }

        numpy::Timedelta td_ms(500, "ms");  // 500 milliseconds
        std::cout << "  Timedelta(500, 'ms') = " << td_ms.value() << " nanoseconds" << std::endl;
        int64_t expected_ms = 500 * numpy::Timedelta::NANOS_PER_MILLISECOND;
        if (td_ms.value() != expected_ms) {
            std::cout << "[FAIL] np_test_timedelta_constructors: Timedelta(500, 'ms') expected "
                      << expected_ms << " ns, got " << td_ms.value() << std::endl;
            errors++;
        }

        numpy::Timedelta td_us(1000, "us");  // 1000 microseconds
        std::cout << "  Timedelta(1000, 'us') = " << td_us.value() << " nanoseconds" << std::endl;
        int64_t expected_us = 1000 * numpy::Timedelta::NANOS_PER_MICROSECOND;
        if (td_us.value() != expected_us) {
            std::cout << "[FAIL] np_test_timedelta_constructors: Timedelta(1000, 'us') expected "
                      << expected_us << " ns, got " << td_us.value() << std::endl;
            errors++;

result (np_test_1_all.cpp:6090)

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

values (np_test_1_all.cpp:15133)

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