CSRMatrix

class numpy::CSRMatrix

numpy C++ class.

Example

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

// Use CSRMatrix
CSRMatrix obj;
// ... operations ...

Constructors

Signature	Location	Example
CSRMatrix(size_trows, size_tcols)	NP_SPARSE_CSR.H:58
CSRMatrix(size_trows, size_tcols, std::vector<T>&&values, std::vector<sparse_index_t>&&col_indices, std::vector<sparse_index_t>&&row_ptr)	NP_SPARSE_CSR.H:66

Operators

Signature	Return Type	Location	Example
T operator()(size_ti, size_tj)	T	NP_SPARSE_CSR.H:196

Construction

Signature	Return Type	Location	Example
CSRMatrix from_dense(const NDArray<T>&dense, Ttol = T{1e-10})	CSRMatrix	NP_SPARSE_CSR.H:91	View

Array Creation

Signature	Return Type	Location	Example
CSRMatrix diagonal(const std::vector<T>&diag)	CSRMatrix	NP_SPARSE_CSR.H:147	View
CSRMatrix identity(size_tn)	CSRMatrix	NP_SPARSE_CSR.H:127	View

Indexing / Selection

Signature	Return Type	Location	Example
T get(size_ti, size_tj)	T	NP_SPARSE_CSR.H:221	View
std::vector<std::pair<sparse_index_t,T>> get_col(size_tj)	std::vector<std::pair<sparse_index_t,T>>	NP_SPARSE_CSR.H:280
std::vector<std::pair<sparse_index_t,T>> get_row(size_ti)	std::vector<std::pair<sparse_index_t,T>>	NP_SPARSE_CSR.H:260

Shape Manipulation

Signature	Return Type	Location	Example
CSRMatrix<T> transpose()	CSRMatrix<T>	NP_SPARSE_CSR.H:381	View

Sorting

Signature	Return Type	Location	Example
void sort_indices()	void	NP_SPARSE_CSR.H:310

Type Checking

Signature	Return Type	Location	Example
bool is_square()	bool	NP_SPARSE_CSR.H:238

Other Methods

Signature	Return Type	Location	Example
bool check_format()	bool	NP_SPARSE_CSR.H:433	View
CSRMatrix<T> clone()	CSRMatrix<T>	NP_SPARSE_CSR.H:419	View
const sparse_index_t \* col_indices()	const sparse_index_t *	NP_SPARSE_CSR.H:247
sparse_index_t \* col_indices()	sparse_index_t *	NP_SPARSE_CSR.H:248
size_t cols()	size_t	NP_SPARSE_CSR.H:230	View
double density()	double	NP_SPARSE_CSR.H:233
size_t nnz()	size_t	NP_SPARSE_CSR.H:231	View
void print(std::ostream &os = std::cout)	void	NP_SPARSE_CSR.H:515	View
void print_structure(std::ostream &os = std::cout)	void	NP_SPARSE_CSR.H:493
void prune(Ttol)	void	NP_SPARSE_CSR.H:374
void remove_zeros(Ttol = T{0})	void	NP_SPARSE_CSR.H:346
const sparse_index_t \* row_ptr()	const sparse_index_t *	NP_SPARSE_CSR.H:250
sparse_index_t \* row_ptr()	sparse_index_t *	NP_SPARSE_CSR.H:251
size_t rows()	size_t	NP_SPARSE_CSR.H:229	View
std::string toString()	std::string	NP_SPARSE_CSR.H:500	View
std::string toString_structure()	std::string	NP_SPARSE_CSR.H:481	View
const T \* values()	const T *	NP_SPARSE_CSR.H:244	View
T \* values()	T *	NP_SPARSE_CSR.H:245	View

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

diagonal (np_test_2_all.cpp:11408)

    void np_test_linalg_missing_diagonal() {
      std::cout << "========= diagonal: extract diagonal from matrix =======================";

      numpy::NDArray<double> mat({ 3, 4 });
      for (size_t i = 0; i < 3; ++i) {
        for (size_t j = 0; j < 4; ++j) {
          mat.setElementAt({ i, j }, static_cast<double>(i * 4 + j));
        }
      }

      auto diag = numpy::diagonal(mat);
      if (diag.getShape()[0] != 3) {
        std::cout << "  [FAIL] : diagonal shape incorrect";
        throw std::runtime_error("diagonal test failed: wrong shape");
      }

      // Check diagonal values (0, 5, 10)
      if (std::abs(diag.getElementAt({ 0 }) - 0.0) > 1e-10 ||
        std::abs(diag.getElementAt({ 1 }) - 5.0) > 1e-10 ||
        std::abs(diag.getElementAt({ 2 }) - 10.0) > 1e-10) {
        std::cout << "  [FAIL] : diagonal values incorrect";

identity (np_test_1_all.cpp:24002)

          throw std::runtime_error(description);
      }
      if (!((eye_offset.getShape() == std::vector<size_t>{3, 4}))) {
          std::string description = std::string("testArrayCreationSignatures():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !((eye_offset.getShape() == std::vector<size_t>{3, 4}))";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);
      }
      // std::cout << "[OK] eye function with optional parameters works correctly\n";

      // Test identity
      auto identity_result = identity<int>(4);
      if (!((identity_result.getShape() == std::vector<size_t>{4, 4}))) {
          std::string description = std::string("testArrayCreationSignatures():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !((identity_result.getShape() == std::vector<size_t>{4, 4}))";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);
      }
      // std::cout << "[OK] identity function has correct signature\n";

      // Test diag with different use cases
      auto vector1d = createInt32Array({ 3 }, 5);
      auto matrix2d = createInt32Array({ 3, 3 }, 0);

get (np_test_1_all.cpp:28526)

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

    void np_test_indexing_mask_indices() {
      std::cout << "========= mask_indices: triangular mask indices =======================";

      // Get upper triangular indices for 3x3 matrix
      auto triu_idx = numpy::mask_indices(3, "triu", 0);

      // Should return tuple of 2 arrays
      bool passed = (std::get<0>(triu_idx).getSize() > 0);
      passed = passed && (std::get<1>(triu_idx).getSize() > 0);
      passed = passed && (std::get<0>(triu_idx).getSize() == std::get<1>(triu_idx).getSize());

      // Get lower triangular indices
      auto tril_idx = numpy::mask_indices(3, "tril", 0);
      passed = passed && (std::get<0>(tril_idx).getSize() > 0);
      passed = passed && (std::get<1>(tril_idx).getSize() > 0);

      if (!passed) {
        std::cout << "  [FAIL] : in np_test_indexing_mask_indices() : Mask indices incorrect";

transpose (np_test_2_all.cpp:4973)

    }

    /**
     * Test matrix properties and methods
     */
    void testMatrixProperties() {
      std::cout << "========= testMatrixProperties =======================";

      // Test transpose
      numpy::Matrix<double> m("1 2 3; 4 5 6");
      auto mt = m.transpose();
      assert_test(mt.rows() == 3, "Transpose rows");
      assert_test(mt.cols() == 2, "Transpose cols");
      assert_test(std::abs(mt(0, 1) - 4.0) < 1e-10, "Transpose element");
      assert_test(std::abs(mt(2, 0) - 3.0) < 1e-10, "Transpose element");

      // Test trace for square matrix
      numpy::Matrix<double> square("1 2; 3 4");
      double tr = square.trace();
      assert_test(std::abs(tr - 5.0) < 1e-10, "Matrix trace");

check_format (np_test_3_all.cpp:19946)

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

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

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

cols (np_test_2_all.cpp:4911)

    /**
     * Test basic matrix construction and properties
     */
    void testMatrixBasics() {
      std::cout << "========= testMatrixBasics =======================";

      // Test construction from dimensions
      numpy::Matrix<double> m1(3, 3);
      assert_test(m1.rows() == 3, "Matrix rows");
      assert_test(m1.cols() == 3, "Matrix cols");
      assert_test(m1.isSquare(), "Matrix is square");

      // Test construction from 2D vector
      std::vector<std::vector<int>> data = { {1, 2, 3}, {4, 5, 6} };
      numpy::Matrix<int> m2(data);
      assert_test(m2.rows() == 2, "Matrix from vector rows");
      assert_test(m2.cols() == 3, "Matrix from vector cols");
      assert_test(m2(0, 0) == 1, "Matrix element access");
      assert_test(m2(1, 2) == 6, "Matrix element access");

nnz (np_test_3_all.cpp:19941)

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

      auto reconstructed = csr.to_dense();

print (np_test_1_all.cpp:6395)

    std::vector<std::string> strings = {"Alice", "Bob", "Charlie"};
    auto arr2 = array<32>(strings);
    // std::cout << "Created from strings vector:" << std::endl;
    for (size_t i = 0; i < arr2.size(); ++i) {
        // std::cout << "arr2[" << i << "] = '" << arr2[i] << "'";
    }

    // Test 2D array creation
    chararray16 arr_2d({2, 3}, "test");
    // std::cout << "Created 2D chararray16 with shape {2, 3}:";
    // arr_2d.print();

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

void testCharArrayStringOperationsCharArray() {
    std::cout << "========= testStringOperations =======================";

    // Test string concatenation
    std::vector<std::string> words1 = {"Hello", "Good", "Nice"};
    std::vector<std::string> words2 = {" World", " Day", " Work"};

rows (np_test_2_all.cpp:4910)

  namespace test_matrix {

    /**
     * Test basic matrix construction and properties
     */
    void testMatrixBasics() {
      std::cout << "========= testMatrixBasics =======================";

      // Test construction from dimensions
      numpy::Matrix<double> m1(3, 3);
      assert_test(m1.rows() == 3, "Matrix rows");
      assert_test(m1.cols() == 3, "Matrix cols");
      assert_test(m1.isSquare(), "Matrix is square");

      // Test construction from 2D vector
      std::vector<std::vector<int>> data = { {1, 2, 3}, {4, 5, 6} };
      numpy::Matrix<int> m2(data);
      assert_test(m2.rows() == 2, "Matrix from vector rows");
      assert_test(m2.cols() == 3, "Matrix from vector cols");
      assert_test(m2(0, 0) == 1, "Matrix element access");
      assert_test(m2(1, 2) == 6, "Matrix element access");

toString (np_test_1_all.cpp:6826)

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

    // Test default constructor
    datetime64 default_dt;
    if (!(default_dt.isNaT())) {
        std::string description = std::string("testDatetime64CreationDateTime():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(default_dt.isNaT())";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    // std::cout << "Default datetime64 is NaT: " << default_dt.toString() << std::endl;

    // Test value constructor
    datetime64 epoch_day(0, DateTimeUnit::Day);
    // std::cout << "Epoch day: " << epoch_day.toString() << std::endl;

    // Test string constructor
    datetime64 date_from_string("2024-01-15");
    // std::cout << "Date from string '2024-01-15': " << date_from_string.toString() << std::endl;

    datetime64 datetime_from_string("2024-01-15T10:30:45");

toString_structure (np_test_5_all.cpp:8652)

    }

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

  // ===========================
  // Sparse CSR Tests
  // ===========================

  void np_test_toString_sparse_structure() {
    std::cout << "========= CSRMatrix::toString_structure() =======================";

    // Create a sparse matrix using from_dense
    numpy::NDArray<double> dense({ 100, 100 });
    dense.setElementAt({ 10, 10 }, 3.14);
    dense.setElementAt({ 20, 30 }, 2.71);
    numpy::sparse::CSRMatrix<double> sparse_matrix = numpy::sparse::CSRMatrix<double>::from_dense(dense);

    std::string result = sparse_matrix.toString_structure();

    // std::cout << "Result:\n" << result << std::endl;

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

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