SparseArray

class numpy::SparseArray

numpy C++ class.

Example

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

// Use SparseArray
SparseArray obj;
// ... operations ...

Constructors

Signature	Location	Example
SparseArray(const numpy::NDArray<T>& dense, T fill_value)	df_sparse_array.h:79
explicit SparseArray(const numpy::NDArray<T>& dense)	df_sparse_array.h:92
SparseArray(const numpy::NDArray<T>& sp_values, const numpy::NDArray<numpy::int64>& sp_index, T fill_value, size_t length)	df_sparse_array.h:108
SparseArray(const std::vector<T>& values, T fill_value)	df_sparse_array.h:123

Construction

Signature	Return Type	Location	Example
static SparseArray<T> from_dense(const numpy::NDArray<T>& dense, T fill_value)	static SparseArray<T>	df_sparse_array.h:806	View
static SparseArray<T> from_dense(const numpy::NDArray<T>& dense)	static SparseArray<T>	df_sparse_array.h:813	View

Array Creation

Signature	Return Type	Location	Example
bool empty() const	bool	df_sparse_array.h:186	View

Indexing / Selection

Signature	Return Type	Location	Example
T at(size_t index) const	T	df_sparse_array.h:267	View

Statistics

Signature	Return Type	Location	Example
std::optional<T> max() const	std::optional<T>	df_sparse_array.h:665	View
double mean() const	double	df_sparse_array.h:593	View
std::optional<T> min() const	std::optional<T>	df_sparse_array.h:628	View
std::optional<double> std(int ddof = 1) const	std::optional<double>	df_sparse_array.h:702	View
\* Optimized: sum(sp_values) + fill_count \* fill_value	* Optimized:	df_sparse_array.h:566	View
T sum() const	T	df_sparse_array.h:568	View
std::optional<double> var(int ddof = 1) const	std::optional<double>	df_sparse_array.h:711	View

Logical

Signature	Return Type	Location	Example
bool all() const	bool	df_sparse_array.h:776	View
bool any() const	bool	df_sparse_array.h:750	View

I/O

Signature	Return Type	Location	Example
numpy::NDArray<T> to_dense() const	numpy::NDArray<T>	df_sparse_array.h:296	View
std::string to_string() const	std::string	df_sparse_array.h:866	View

Type Handling

Signature	Return Type	Location	Example
SparseArray<T> copy() const	SparseArray<T>	df_sparse_array.h:316	View

Type Checking

Signature	Return Type	Location	Example
bool is_fill(size_t index) const	bool	df_sparse_array.h:274
bool is_fill_value(T val) const	bool	df_sparse_array.h:46

Other Methods

Signature	Return Type	Location	Example
SparseArray<T> binary_op(const SparseArray<T>& other, Op op) const	SparseArray<T>	df_sparse_array.h:973
build_from_dense(dense)		df_sparse_array.h:85
build_from_dense(dense)		df_sparse_array.h:98
build_from_dense(dense)		df_sparse_array.h:133
void build_from_dense(const numpy::NDArray<T>& dense)	void	df_sparse_array.h:910
numpy::NDArray<numpy::bool\_> compare_op(const SparseArray<T>& other, Op op) const	numpy::NDArray<numpy::bool_>	df_sparse_array.h:1006
static SparseArray<T> concat(const std::vector<SparseArray<T>>& arrays)	static SparseArray<T>	df_sparse_array.h:820
size_t count() const	size_t	df_sparse_array.h:423	View
numpy::NDArray<T> dense(std::vector<size_t>	numpy::NDArray<T>	df_sparse_array.h:129	View
double density() const	double	df_sparse_array.h:233
dtype_type dtype() const	dtype_type	df_sparse_array.h:143	View
T fill_value() const	T	df_sparse_array.h:218	View
SparseArray<T> fillna(T value) const	SparseArray<T>	df_sparse_array.h:376
T find_value_at(size_t index) const	T	df_sparse_array.h:951
numpy::NDArray<numpy::bool\_> isna() const	numpy::NDArray<numpy::bool_>	df_sparse_array.h:332
size_t len() const	size_t	df_sparse_array.h:193
size_t nbytes() const	size_t	df_sparse_array.h:157	View
size_t nbytes_dense() const	size_t	df_sparse_array.h:165
constexpr int ndim() const	constexpr int	df_sparse_array.h:172	View
numpy::NDArray<numpy::int64> new_sp_index(std::vector<size_t>	numpy::NDArray<numpy::int64>	df_sparse_array.h:410
numpy::NDArray<T> new_sp_values(std::vector<size_t>	numpy::NDArray<T>	df_sparse_array.h:409
numpy::NDArray<numpy::bool\_> notna() const	numpy::NDArray<numpy::bool_>	df_sparse_array.h:363
size_t npoints() const	size_t	df_sparse_array.h:225
op(dense1.getElementAt(		df_sparse_array.h:985
op(fill_value\_, scalar), length\_)		df_sparse_array.h:1002
std::string repr() const	std::string	df_sparse_array.h:897
numpy::NDArray<T> result_dense(std::vector<size_t>	numpy::NDArray<T>	df_sparse_array.h:982
numpy::NDArray<numpy::bool\_> scalar_compare(T scalar, Op op) const	numpy::NDArray<numpy::bool_>	df_sparse_array.h:1023
SparseArray<T> scalar_op(T scalar, Op op) const	SparseArray<T>	df_sparse_array.h:994
std::vector<size_t> shape() const	std::vector<size_t>	df_sparse_array.h:179	View
size_t size() const	size_t	df_sparse_array.h:150	View
const numpy::NDArray<numpy::int64>& sp_index() const	const numpy::NDArray<numpy::int64>&	df_sparse_array.h:211
numpy::NDArray<numpy::int64> sp_index(std::vector<size_t>	numpy::NDArray<numpy::int64>	df_sparse_array.h:852
const numpy::NDArray<T>& sp_values() const	const numpy::NDArray<T>&	df_sparse_array.h:204
numpy::NDArray<T> sp_values(std::vector<size_t>	numpy::NDArray<T>	df_sparse_array.h:851
double sparsity() const	double	df_sparse_array.h:242
void validate_sparse_data()	void	df_sparse_array.h:931

Code Examples

The following examples are extracted from the test suite.

from_dense (np_test_3_all.cpp:19939)

      std::cout << "========= CSR Matrix - basic functionality =======================";

      numpy::NDArray<double> dense({ 4, 4 });
      dense.setElementAt({ 0, 0 }, 1.0);
      dense.setElementAt({ 0, 3 }, 2.0);
      dense.setElementAt({ 1, 1 }, 3.0);
      dense.setElementAt({ 2, 2 }, 4.0);
      dense.setElementAt({ 3, 0 }, 5.0);
      dense.setElementAt({ 3, 3 }, 6.0);

      auto csr = numpy::sparse::CSRMatrix<double>::from_dense(dense);

      if (csr.rows() != 4 || csr.cols() != 4 || csr.nnz() != 6) {
        std::cout << "  [FAIL] : in np_test_sparse_csr_basic() : Incorrect matrix dimensions";
        throw std::runtime_error("np_test_sparse_csr_basic failed: dimension mismatch");
      }

      if (!csr.check_format()) {
        std::cout << "  [FAIL] : in np_test_sparse_csr_basic() : CSR format validation failed";
        throw std::runtime_error("np_test_sparse_csr_basic failed: invalid format");
      }

from_dense (np_test_3_all.cpp:19939)

      std::cout << "========= CSR Matrix - basic functionality =======================";

      numpy::NDArray<double> dense({ 4, 4 });
      dense.setElementAt({ 0, 0 }, 1.0);
      dense.setElementAt({ 0, 3 }, 2.0);
      dense.setElementAt({ 1, 1 }, 3.0);
      dense.setElementAt({ 2, 2 }, 4.0);
      dense.setElementAt({ 3, 0 }, 5.0);
      dense.setElementAt({ 3, 3 }, 6.0);

      auto csr = numpy::sparse::CSRMatrix<double>::from_dense(dense);

      if (csr.rows() != 4 || csr.cols() != 4 || csr.nnz() != 6) {
        std::cout << "  [FAIL] : in np_test_sparse_csr_basic() : Incorrect matrix dimensions";
        throw std::runtime_error("np_test_sparse_csr_basic failed: dimension mismatch");
      }

      if (!csr.check_format()) {
        std::cout << "  [FAIL] : in np_test_sparse_csr_basic() : CSR format validation failed";
        throw std::runtime_error("np_test_sparse_csr_basic failed: invalid format");
      }

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

max (np_test_1_all.cpp:7274)

    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

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

min (np_test_1_all.cpp:2350)

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

std (np_test_1_all.cpp:11836)

    auto var_sample = var(array, std::nullopt, 1);  // ddof=1 for sample variance
    double expected_sample_var = 1.25 * 4.0 / 3.0;  // Bessel's correction
    if (!(approx_equal(var_sample.getElementAt({ 0 }), expected_sample_var, 1e-10))) {
        std::string description = std::string("testVarianceAndStandardDeviation():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(approx_equal(var_sample.getElementAt({ 0 }), expected_sample_var, 1e-10))";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    // std::cout << "[OK] Sample variance works correctly\n";

    // Test standard deviation
    auto std_result = numpy::std(array, std::nullopt, 0);
    if (!(approx_equal(std_result.getElementAt({ 0 }), std::sqrt(expected_var), 1e-10))) {
        std::string description = std::string("testVarianceAndStandardDeviation():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(approx_equal(std_result.getElementAt({ 0 }), std::sqrt(expected_var), 1e-10))";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    // std::cout << "[OK] Standard deviation works correctly\n";

    // Test along axis
    auto array2d = createFloat64Array({ 2, 2 }, 0);
    array2d.setElementAt({ 0, 0 }, 1.0);

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

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

var (np_test_1_all.cpp:11816)

    std::cout << "========= testVarianceAndStandardDeviation =======================";

    // Create test array with known variance
    auto array = createFloat64Array({ 4 }, 0);
    array.setElementAt({ 0 }, 1.0);
    array.setElementAt({ 1 }, 2.0);
    array.setElementAt({ 2 }, 3.0);
    array.setElementAt({ 3 }, 4.0);

    // Test variance (population)
    auto var_result = var(array, std::nullopt, 0);  // ddof=0 for population variance
    double expected_var = 1.25;  // Known variance for [1,2,3,4]
    if (!(approx_equal(var_result.getElementAt({ 0 }), expected_var, 1e-10))) {
        std::string description = std::string("testVarianceAndStandardDeviation():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(approx_equal(var_result.getElementAt({ 0 }), expected_var, 1e-10))";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    // std::cout << "[OK] Population variance works correctly\n";

    // Test variance (sample)
    auto var_sample = var(array, std::nullopt, 1);  // ddof=1 for sample variance

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

to_dense (np_test_3_all.cpp:19951)

      if (csr.rows() != 4 || csr.cols() != 4 || csr.nnz() != 6) {
        std::cout << "  [FAIL] : in np_test_sparse_csr_basic() : Incorrect matrix dimensions";
        throw std::runtime_error("np_test_sparse_csr_basic failed: dimension mismatch");
      }

      if (!csr.check_format()) {
        std::cout << "  [FAIL] : in np_test_sparse_csr_basic() : CSR format validation failed";
        throw std::runtime_error("np_test_sparse_csr_basic failed: invalid format");
      }

      auto reconstructed = csr.to_dense();
      for (size_t i = 0; i < 4; ++i) {
        for (size_t j = 0; j < 4; ++j) {
          if (std::abs(dense.getElementAt({ i, j }) - reconstructed.getElementAt({ i, j })) > 1e-12) {
            std::cout << "  [FAIL] : in np_test_sparse_csr_basic() : Roundtrip conversion mismatch";
            throw std::runtime_error("np_test_sparse_csr_basic failed");
          }
        }
      }

      std::cout << " -> tests passed" << 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;

dense (np_test_3_all.cpp:19931)

  namespace numpy_tests_sparse {

    // ============================================================================
    // CSR MATRIX TESTS
    // ============================================================================

    void np_test_sparse_csr_basic() {
      std::cout << "========= CSR Matrix - basic functionality =======================";

      numpy::NDArray<double> dense({ 4, 4 });
      dense.setElementAt({ 0, 0 }, 1.0);
      dense.setElementAt({ 0, 3 }, 2.0);
      dense.setElementAt({ 1, 1 }, 3.0);
      dense.setElementAt({ 2, 2 }, 4.0);
      dense.setElementAt({ 3, 0 }, 5.0);
      dense.setElementAt({ 3, 3 }, 6.0);

      auto csr = numpy::sparse::CSRMatrix<double>::from_dense(dense);

      if (csr.rows() != 4 || csr.cols() != 4 || csr.nnz() != 6) {

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

fill_value (np_test_4_all.cpp:20577)

        }

        // std::cout << "OK: masked_all_like(NDArray) test passed" << std::endl;
    }

    // Test with custom fill value
    {
        NDArray<int> data({2, 2});
        auto masked = ma::masked_all_like(data, 999);

        if (!(masked.fill_value() == 999)) {
            std::string description = std::string("np_test_phase6_ma_masked_all_like():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(masked.fill_value() == 999)";
            std::cout << std::string("[FAIL] ") + description << std::endl;
            throw std::runtime_error(description);
        }

        // All elements should have fill_value
        for (size_t i = 0; i < 2; ++i) {
            for (size_t j = 0; j < 2; ++j) {
                if (!(masked.data().getElementAt({i, j}) == 999)) {
                    std::string description = std::string("np_test_phase6_ma_masked_all_like():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(masked.data().getElementAt({i, j}) == 999)";

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