ObjectArrayIterator

class numpy::ObjectArrayIterator

numpy C++ class.

Example

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

// Use ObjectArrayIterator
NDArray<double> arr = np::arange<double>(12).reshape({3, 4});
for (auto it = arr.begin(); it != arr.end(); ++it) {
    // ... process elements ...
}

Constructors

Signature	Location	Example
ObjectArrayIterator(NDArray<T>\*arr, boolat_end = false)	NP_NESTED_ARRAY.H:27

Operators

Signature	Return Type	Location	Example
T operator\*()	T	NP_NESTED_ARRAY.H:35
T \* operator->()	T *	NP_NESTED_ARRAY.H:43
ObjectArrayIterator & operator++()	ObjectArrayIterator &	NP_NESTED_ARRAY.H:54
ObjectArrayIterator operator++(int)	ObjectArrayIterator	NP_NESTED_ARRAY.H:61
bool operator==(const ObjectArrayIterator &other)	bool	NP_NESTED_ARRAY.H:68
bool operator!=(const ObjectArrayIterator &other)	bool	NP_NESTED_ARRAY.H:74

Other Methods

Signature	Return Type	Location	Example
size_t flatIndex()	size_t	NP_NESTED_ARRAY.H:82	View
bool incrementIndices()	bool	NP_NESTED_ARRAY.H:108	View
const std::vector<size_t>& indices()	const std::vector<size_t>&	NP_NESTED_ARRAY.H:79	View
void reset()	void	NP_NESTED_ARRAY.H:97	View
bool valid()	bool	NP_NESTED_ARRAY.H:94	View

Code Examples

The following examples are extracted from the test suite.

flatIndex (np_test_3_all.cpp:20906)

    // After increment, should be at [0, 1]
    ++it2;
    const auto& indices2 = it2.indices();
    if (indices2.size() != 2 || indices2[0] != 0 || indices2[1] != 1) {
        std::cout << "  [FAIL] : iterator incorrect indices after increment" << std::endl;
        throw std::runtime_error("np_test_extract_iterator failed: incorrect indices after increment");
    }

    // Test flat index
    if (it2.flatIndex() != 1) {
        std::cout << "  [FAIL] : iterator incorrect flat index" << std::endl;
        throw std::runtime_error("np_test_extract_iterator failed: incorrect flat index");
    }

    // Test range-based for loop
    iteration_count = 0;
    for (auto obj : numpy::iterate(arr)) {
        int* val = obj.get_as<int>();
        if (val && *val == iteration_count) {
            ++iteration_count;

incrementIndices (np_test_1_all.cpp:52)

// 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);
        do {
            if (arr.getElementAt(indices)) {
                return false;
            }
        } while (incrementIndices(indices, arr.getShape()));

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

reset (np_test_2_all.cpp:22610)

      // Count iterations
      size_t outer_count = 0;
      size_t total_inner_count = 0;
      for (; !outer.is_finished(); ++outer) {
        size_t inner_count = 0;
        for (; !inner.is_finished(); ++inner) {
          inner_count++;
          total_inner_count++;
        }
        outer_count++;
        inner.reset();
      }

      if (outer_count != 3 || total_inner_count != 12) {
        std::cout << "  [FAIL] : Iteration counts incorrect";
        throw std::runtime_error("np_test_nested_iters_basic failed");
      }

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

valid (np_test_2_all.cpp:6221)

      data.setElementAt({ 1 }, 20.0);
      data.setElementAt({ 2 }, 30.0);

      auto mask = createBoolArray({ 3 }, false);
      mask.setElementAt({ 1 }, true);  // mask middle element

      MaskedArray<double> ma(data, mask, -999.0);

      // Test equality comparison - skip for now as it needs scalar comparison support
      // auto eq_result = ma == 20.0;
      // assert(eq_result.is_masked_at({0}));  // 10 != 20, but result should be valid (False)
      // assert(eq_result.is_masked_at({1}));  // masked element propagates mask
      // assert(eq_result.is_masked_at({2}));  // 30 != 20, but result should be valid (False)
      // std::cout << "[OK] Equality comparison with mask propagation\n";

      // Test greater than - skip for now as it needs scalar comparison support
      // auto gt_result = ma > 15.0;
      // assert(gt_result.is_masked_at({1}));  // masked element propagates
      // Note: comparison results for valid elements would depend on implementation
      // std::cout << "[OK] Greater than comparison with mask propagation\n";