BooleanArray

class numpy::BooleanArray

numpy C++ class.

Example

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

// Use BooleanArray
BooleanArray obj;
// ... operations ...

Constructors

Signature	Location	Example
BooleanArray(const numpy::NDArray<numpy::bool\_>& data, const numpy::NDArray<numpy::bool\_>& mask, bool copy = false)	df_boolean_array.h:66
explicit BooleanArray(const numpy::NDArray<numpy::bool\_>& data)	df_boolean_array.h:79
explicit BooleanArray(const std::vector<std::optional<bool>>& values)	df_boolean_array.h:110

Construction

Signature	Return Type	Location	Example
static BooleanArray from_sequence(const std::vector<std::optional<bool>>& scalars)	static BooleanArray	df_boolean_array.h:312

Array Creation

Signature	Return Type	Location	Example
bool empty() const	bool	df_boolean_array.h:167	View

Indexing / Selection

Signature	Return Type	Location	Example
bool at(size_t index) const	bool	df_boolean_array.h:212	View
BooleanArray take(const std::vector<size_t>& indices, bool allow_fill = false, std::optional<bool> fill_value = std::nullopt) const	BooleanArray	df_boolean_array.h:259	View

Statistics

Signature	Return Type	Location	Example
std::optional<double> mean(bool skipna = true) const	std::optional<double>	df_boolean_array.h:906	View
std::optional<size_t> sum(bool skipna = true) const	std::optional<size_t>	df_boolean_array.h:887	View

Sorting

Signature	Return Type	Location	Example
numpy::NDArray<size_t> argsort(bool ascending = true, const std::string& na_position = "last") const	numpy::NDArray<size_t>	df_boolean_array.h:789	View

Math Operations

Signature	Return Type	Location	Example
BooleanArray logical_and(const BooleanArray& other) const	BooleanArray	df_boolean_array.h:551	View
BooleanArray logical_not() const	BooleanArray	df_boolean_array.h:554	View
BooleanArray logical_or(const BooleanArray& other) const	BooleanArray	df_boolean_array.h:552	View
BooleanArray logical_xor(const BooleanArray& other) const	BooleanArray	df_boolean_array.h:553	View

Logical

Signature	Return Type	Location	Example
std::optional<bool> all(bool skipna = true) const	std::optional<bool>	df_boolean_array.h:859	View
std::optional<bool> any(bool skipna = true) const	std::optional<bool>	df_boolean_array.h:828	View

Set Operations

Signature	Return Type	Location	Example
BooleanArray unique() const	BooleanArray	df_boolean_array.h:709	View

I/O

Signature	Return Type	Location	Example
numpy::NDArray<numpy::bool\_> to_numpy(bool na_value = false) const	numpy::NDArray<numpy::bool_>	df_boolean_array.h:375	View
std::string to_string() const	std::string	df_boolean_array.h:931	View

Type Handling

Signature	Return Type	Location	Example
BooleanArray copy() const	BooleanArray	df_boolean_array.h:252	View

Type Checking

Signature	Return Type	Location	Example
bool is_na(size_t index) const	bool	df_boolean_array.h:223

Other Methods

Signature	Return Type	Location	Example
\* XOR always returns NA if either operand is NA (no short-circuit)	* XOR always returns NA if either operand is	df_boolean_array.h:502
static BooleanArray concat(const std::vector<BooleanArray>& arrays)	static BooleanArray	df_boolean_array.h:319
size_t count() const	size_t	df_boolean_array.h:388	View
const numpy::NDArray<numpy::bool\_>& data() const	const numpy::NDArray<numpy::bool_>&	df_boolean_array.h:185	View
BooleanArray dropna() const	BooleanArray	df_boolean_array.h:362
dtype_type dtype() const	dtype_type	df_boolean_array.h:132	View
std::pair<numpy::NDArray<numpy::int64>, BooleanArray> factorize() const	std::pair<numpy::NDArray<numpy::int64>, BooleanArray>	df_boolean_array.h:740
BooleanArray fillna(bool value) const	BooleanArray	df_boolean_array.h:348
bool has_na() const	bool	df_boolean_array.h:401
numpy::NDArray<numpy::bool\_> isna() const	numpy::NDArray<numpy::bool_>	df_boolean_array.h:234
size_t len() const	size_t	df_boolean_array.h:174
const numpy::NDArray<numpy::bool\_>& mask() const	const numpy::NDArray<numpy::bool_>&	df_boolean_array.h:192	View
size_t nbytes() const	size_t	df_boolean_array.h:146	View
constexpr int ndim() const	constexpr int	df_boolean_array.h:153	View
numpy::NDArray<numpy::bool\_> notna() const	numpy::NDArray<numpy::bool_>	df_boolean_array.h:241
std::string repr() const	std::string	df_boolean_array.h:948
std::vector<size_t> shape() const	std::vector<size_t>	df_boolean_array.h:160	View
size_t size() const	size_t	df_boolean_array.h:139	View
void validate_arrays()	void	df_boolean_array.h:961

Code Examples

The following examples are extracted from the test suite.

empty (np_test_1_all.cpp:6316)

}

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

at (np_test_1_all.cpp:144)

    array.setElementAt({0, 0}, 1);
    array.setElementAt({0, 1}, 2);
    array.setElementAt({0, 2}, 3);
    array.setElementAt({1, 1}, 5);
    array.setElementAt({2, 2}, 9);

    // std::cout << "Array after setting elements:" << std::endl;
    //array.printArray();

    // std::cout << "Element at (1,1): " << array.getElementAt({1, 1}) << std::endl;
    // std::cout << "Element at (2,2): " << array.getElementAt({2, 2});

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

void testArithmetic() {
    std::cout << "========= testArithmeticOperations =======================";

    auto array1 = createFloat32Array({2, 2}, 5.0f);
    auto array2 = createFloat32Array({2, 2}, 3.0f);

take (np_test_5_all.cpp:4313)

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

mean (np_test_1_all.cpp:11714)

    // Create test array
    auto array = createInt32Array({ 2, 3 }, 0);
    array.setElementAt({ 0, 0 }, 1);
    array.setElementAt({ 0, 1 }, 2);
    array.setElementAt({ 0, 2 }, 3);
    array.setElementAt({ 1, 0 }, 4);
    array.setElementAt({ 1, 1 }, 5);
    array.setElementAt({ 1, 2 }, 6);

    // Test mean without axis
    auto mean_all = mean(array);
    if (!(approx_equal(mean_all.getElementAt({ 0 }), 3.5, 1e-10))) {
        std::string description = std::string("testBasicStatistics():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(approx_equal(mean_all.getElementAt({ 0 }), 3.5, 1e-10))";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    // std::cout << "[OK] mean (all elements) works correctly\n";

    // Test mean along axis 0
    auto mean_axis0 = mean(array, 0);
    if (!(mean_axis0.getShape()[0] == 3)) {

sum (np_test_1_all.cpp:11766)

        throw std::runtime_error(description);
    }
    if (!(approx_equal(mean_axis1.getElementAt({ 1 }), 5.0, 1e-10))) {
        std::string description = std::string("testBasicStatistics():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(approx_equal(mean_axis1.getElementAt({ 1 }), 5.0, 1e-10))";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    // std::cout << "[OK] mean along axis 1 works correctly\n";

    // Test sum
    auto sum_all = sum(array);
    if (!(sum_all.getElementAt({ 0 }) == 21)) {
        std::string description = std::string("testBasicStatistics():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(sum_all.getElementAt({ 0 }) == 21)";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    // std::cout << "[OK] sum works correctly\n";

    // Test min and max
    auto min_all = min(array);
    auto max_all = max(array);

argsort (np_test_1_all.cpp:16841)

    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;

logical_and (np_test_1_all.cpp:901)

    a.setElementAt({0}, true);
    a.setElementAt({1}, false);
    a.setElementAt({2}, true);

    auto b = NDArray<bool>({3});
    b.setElementAt({0}, false);
    b.setElementAt({1}, false);
    b.setElementAt({2}, true);

    // Test logical_and
    auto and_result = logical_and(a, b);
    bool and_0 = and_result.getElementAt({0});
    if (and_0 != false) { // true && false = false
        std::cout << "[FAIL] in testLogicalOperations(): logical_and[0] = " << and_0 << ", expected false" << std::endl;
        throw std::runtime_error("testLogicalOperations(): logical_and [0] failed");
    }
    bool and_1 = and_result.getElementAt({1});
    if (and_1 != false) { // false && false = false
        std::cout << "[FAIL] in testLogicalOperations(): logical_and[1] = " << and_1 << ", expected false" << std::endl;
        throw std::runtime_error("testLogicalOperations(): logical_and [1] failed");
    }

logical_not (np_test_1_all.cpp:939)

        throw std::runtime_error("testLogicalOperations(): logical_or [1] failed");
    }
    bool or_2 = or_result.getElementAt({2});
    if (or_2 != true) { // true || true = true
        std::cout << "[FAIL] in testLogicalOperations(): logical_or[2] = " << or_2 << ", expected true" << std::endl;
        throw std::runtime_error("testLogicalOperations(): logical_or [2] failed");
    }
    // std::cout << "[OK] logical_or function";

    // Test logical_not
    auto not_result = logical_not(a);
    bool not_0 = not_result.getElementAt({0});
    if (not_0 != false) { // !true = false
        std::cout << "[FAIL] in testLogicalOperations(): logical_not[0] = " << not_0 << ", expected false" << std::endl;
        throw std::runtime_error("testLogicalOperations(): logical_not [0] failed");
    }
    bool not_1 = not_result.getElementAt({1});
    if (not_1 != true) { // !false = true
        std::cout << "[FAIL] in testLogicalOperations(): logical_not[1] = " << not_1 << ", expected true" << std::endl;
        throw std::runtime_error("testLogicalOperations(): logical_not [1] failed");
    }

logical_or (np_test_1_all.cpp:920)

        throw std::runtime_error("testLogicalOperations(): logical_and [1] failed");
    }
    bool and_2 = and_result.getElementAt({2});
    if (and_2 != true) { // true && true = true
        std::cout << "[FAIL] in testLogicalOperations(): logical_and[2] = " << and_2 << ", expected true" << std::endl;
        throw std::runtime_error("testLogicalOperations(): logical_and [2] failed");
    }
    // std::cout << "[OK] logical_and function";

    // Test logical_or
    auto or_result = logical_or(a, b);
    bool or_0 = or_result.getElementAt({0});
    if (or_0 != true) { // true || false = true
        std::cout << "[FAIL] in testLogicalOperations(): logical_or[0] = " << or_0 << ", expected true" << std::endl;
        throw std::runtime_error("testLogicalOperations(): logical_or [0] failed");
    }
    bool or_1 = or_result.getElementAt({1});
    if (or_1 != false) { // false || false = false
        std::cout << "[FAIL] in testLogicalOperations(): logical_or[1] = " << or_1 << ", expected false" << std::endl;
        throw std::runtime_error("testLogicalOperations(): logical_or [1] failed");
    }

logical_xor (np_test_1_all.cpp:958)

        throw std::runtime_error("testLogicalOperations(): logical_not [1] failed");
    }
    bool not_2 = not_result.getElementAt({2});
    if (not_2 != false) { // !true = false
        std::cout << "[FAIL] in testLogicalOperations(): logical_not[2] = " << not_2 << ", expected false" << std::endl;
        throw std::runtime_error("testLogicalOperations(): logical_not [2] failed");
    }
    // std::cout << "[OK] logical_not function";

    // Test logical_xor
    auto xor_result = logical_xor(a, b);
    bool xor_0 = xor_result.getElementAt({0});
    if (xor_0 != true) { // true XOR false = true
        std::cout << "[FAIL] in testLogicalOperations(): logical_xor[0] = " << xor_0 << ", expected true" << std::endl;
        throw std::runtime_error("testLogicalOperations(): logical_xor [0] failed");
    }
    bool xor_1 = xor_result.getElementAt({1});
    if (xor_1 != false) { // false XOR false = false
        std::cout << "[FAIL] in testLogicalOperations(): logical_xor[1] = " << xor_1 << ", expected false" << std::endl;
        throw std::runtime_error("testLogicalOperations(): logical_xor [1] failed");
    }

all (np_test_4_all.cpp:23928)

                        }
                    }
                }

                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
            {

any (np_test_2_all.cpp:16758)

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

unique (np_test_1_all.cpp:6259)

    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;

to_numpy (np_test_5_all.cpp:21373)

    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;

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;

count (np_test_1_all.cpp:3616)

    // Create larger arrays for performance testing
    auto large_arr = NDArray<double>::createOnes({100, 100});
    auto broadcast_arr = NDArray<double>::createOnes({1, 100});

    // Time the operation (basic timing)
    auto start = std::chrono::high_resolution_clock::now();
    auto result = large_arr.addArrays(broadcast_arr);
    auto end = std::chrono::high_resolution_clock::now();

    auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
    // std::cout << "Large array broadcasting took " << duration.count() << " microseconds" << std::endl;

    // Verify result shape
    if (!((result.getShape() == std::vector<size_t>{100, 100}))) {
        std::string description = std::string("test_broadcasting_performance():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !((result.getShape() == std::vector<size_t>{100, 100}))";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    if (!(result.getElementAt({50, 50}) == 2.0)) {
        std::string description = std::string("test_broadcasting_performance():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(result.getElementAt({50, 50}) == 2.0)";
        std::cout << std::string("[FAIL] ") + description << std::endl;

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

dtype (np_test_3_all.cpp:7942)

  if (info.max != expected_max) {
    std::cerr << "[FAIL] IInfo<uint64_t>::max mismatch";
    throw std::runtime_error("IInfo uint64 max test failed");
  }
  // std::cout << "[OK] IInfo<uint64_t>::max = " << info.max << std::endl;

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

// ============================================================================
// dtype() Tests - DType descriptor creation
// ============================================================================

void np_test_dtype_from_string_integers() {
  std::cout << "========= np_test_dtype_from_string_integers =======================";

  // Test integer type strings
  if (dtype("int8") != DType::INT8) {
    std::cerr << "[FAIL] dtype(\"int8\") should return INT8";
    throw std::runtime_error("dtype string test failed");
  }

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

nbytes (np_test_2_all.cpp:3547)

      }

      // Test itemsize
      if (!(itemsize(arr) == sizeof(double))) {
          std::string description = std::string("testArrayInfo():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(itemsize(arr) == sizeof(double))";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);
      }

      // Test nbytes
      if (!(nbytes(arr) == 24 * sizeof(double))) {
          std::string description = std::string("testArrayInfo():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(nbytes(arr) == 24 * sizeof(double))";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);
      }

      // Test flags
      auto flags_info = flags(arr);
      if (!(flags_info.owndata == true)) {
          std::string description = std::string("testArrayInfo():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(flags_info.owndata == true)";
          std::cout << std::string("[FAIL] ") + description << std::endl;

ndim (np_test_2_all.cpp:3526)

    void testArrayInfo() {
      std::cout << "Testing array information functions...\n";

      // Test basic info functions
      auto arr = createFloat64Array({ 2, 3, 4 });
      for (size_t i = 0; i < arr.getSize(); ++i) {
        arr.setElementAt({ i / 12, (i / 4) % 3, i % 4 }, static_cast<double>(i));
      }

      // Test ndim
      if (!(ndim(arr) == 3)) {
          std::string description = std::string("testArrayInfo():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(ndim(arr) == 3)";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);
      }

      // Test size
      if (!(size(arr) == 24)) {
          std::string description = std::string("testArrayInfo():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(size(arr) == 24)";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);

shape (np_test_1_all.cpp:3751)

    }

    for (size_t j = 0; j < 3; ++j) {
        arr3.setElementAt({0, j}, static_cast<double>((j + 1) * 100));  // [100, 200, 300]
    }

    // Broadcast all arrays together
    std::vector<NDArray<double>> arrays = {arr1, arr2, arr3};
    auto broadcasted = broadcast_arrays(arrays);

    // All should have shape (2, 3)
    for (const auto& arr : broadcasted) {
        if (!((arr.getShape() == std::vector<size_t>{2, 3}))) {
            std::string description = std::string("test_broadcast_arrays():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !((arr.getShape() == std::vector<size_t>{2, 3}))";
            std::cout << std::string("[FAIL] ") + description << std::endl;
            throw std::runtime_error(description);
        }
    }

    // Check values
    if (!(broadcasted[0].getElementAt({0, 1}) == 2.0)) {

size (np_test_1_all.cpp:47)

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