I would like to ask how to improve the speed of sparse matrix computation in python by calling the following code. However, the following error occurred

[Knight1357]

Error message:

---------------------------------------------------------------------------
PanicException                            Traceback (most recent call last)
Cell In[3], line 49
     45         print(diff)
     47 if __name__ == "__main__":
     48     # Run the test case
---> 49     test_csr_matrix_multiply_with_random_matrices()

Cell In[3], line 26, in test_csr_matrix_multiply_with_random_matrices()
     23 print("Matrix B shape:", matrix_b.shape)
     25 # Call Rust function for CSR matrix multiplication
---> 26 rust_result = multiply_csr_matrices(matrix_a, matrix_b)
     28 # Compute the expected result using SciPy's dot method
     29 python_result = matrix_a.dot(matrix_b)

PanicException: called `Result::unwrap()` on an `Err` value: IllegalArguments("Indptr length does not match dimension")

rust Sparse matrix computation acceleration code:

#![cfg_attr(
    all(not(debug_assertions), target_os = "windows"),
    windows_subsystem = "windows"
)]

// Import required libraries
use pyo3::prelude::*; // Import pre-defined items from the PyO3 module
use pyo3::types::PyDict; // Import PyDict type, used for creating Python dictionaries
use sprs::CsMat; // Import the definition for sparse matrix CsMat
use pyo3::Py; // Import Py type
use pyo3::PyAny; // Import PyAny type, representing any Python object
use pyo3::PyResult; // Import PyResult type, used to represent potential errors
use pyo3::Python; // Import Python type, used to obtain the Python GIL (Global Interpreter Lock)

/// Matrix multiplication function that takes two sparse matrices as input and returns their product
///
/// # Parameters
///
/// * `a`: The first sparse matrix
/// * `b`: The second sparse matrix
///
/// # Returns
///
/// Returns the resulting sparse matrix
fn csr_matrix_multiply(a: &CsMat<f64>, b: &CsMat<f64>) -> CsMat<f64> {
    // Assert that the dimensions of the two matrices are compatible for multiplication
    assert_eq!(a.cols(), b.rows(), "Incompatible matrix dimensions for multiplication.");
    
    // Get the dimensions of the resulting matrix
    let (m, n) = (a.rows(), b.cols());

    // Used to store non-zero values and their row and column indices for the sparse matrix multiplication
    let mut values = Vec::new();
    let mut row_indices = Vec::new();
    let mut col_indices = Vec::new();

    // Iterate through each row of the first matrix
    for i in 0..m {
        let a_row = a.outer_view(i).unwrap(); // Get the outer view of the current row (sparse matrix row)
        // Iterate through each column of the second matrix
        for j in 0..n {
            let b_col = b.outer_view(j).unwrap(); // Get the outer view of the current column
            let value = a_row.dot(&b_col); // Compute the dot product of this row and column
            if value != 0.0 {
                // If the dot product result is non-zero, record the non-zero value and its row and column indices
                row_indices.push(i);
                col_indices.push(j);
                values.push(value);
            }
        }
    }

    // Create and return the resulting sparse matrix
    CsMat::new_csc((m, n), row_indices, col_indices, values)
}

/// Python interface function for multiplication
///
/// # Parameters
///
/// * `matrix_a`: The first sparse matrix
/// * `matrix_b`: The second sparse matrix
///
/// # Returns
///
/// Returns a Python dictionary containing the multiplication result
#[pyfunction]
fn multiply_csr_matrices(
    matrix_a: Py<PyAny>, // The first matrix, using PyAny type to accept any Python object
    matrix_b: Py<PyAny>, // The second matrix
) -> PyResult<Py<PyAny>> {
    // Obtain the Python GIL
    Python::with_gil(|py| {
        // Extract relevant data from the first matrix
        let data_a: Vec<f64> = matrix_a.getattr(py, "data")?.extract(py)?;
        let indices_a: Vec<usize> = matrix_a.getattr(py, "indices")?.extract(py)?;
        let indptr_a: Vec<usize> = matrix_a.getattr(py, "indptr")?.extract(py)?;
        let shape_a: (usize, usize) = matrix_a.getattr(py, "shape")?.extract(py)?;

        // Check if the length of indptr_a matches the expected value
        assert_eq!(indptr_a.len(), shape_a.0 + 1, "Indptr length does not match dimension for matrix A.");

        // Print debug information
        println!("Matrix A: Data length: {}, Indices length: {}, Indptr length: {}", 
                  data_a.len(), indices_a.len(), indptr_a.len());
        println!("Shape A: {:?}", shape_a);

        // Extract relevant data from the second matrix
        let data_b: Vec<f64> = matrix_b.getattr(py, "data")?.extract(py)?;
        let indices_b: Vec<usize> = matrix_b.getattr(py, "indices")?.extract(py)?;
        let indptr_b: Vec<usize> = matrix_b.getattr(py, "indptr")?.extract(py)?;
        let shape_b: (usize, usize) = matrix_b.getattr(py, "shape")?.extract(py)?;

        // Construct sparse matrices from the extracted data
        let csr_a = CsMat::new_csc((shape_a.0, shape_a.1), indptr_a, indices_a, data_a);
        let csr_b = CsMat::new_csc((shape_b.0, shape_b.1), indptr_b, indices_b, data_b);
        
        // Call the matrix multiplication function to get the result
        let csr_c = csr_matrix_multiply(&csr_a, &csr_b);

        // Extract data from the multiplication result
        let (data_c, indices_c, indptr_c) = (csr_c.data().to_vec(), csr_c.indices().to_vec(), csr_c.indptr().to_vec());
        let shape_c = (csr_c.rows(), csr_c.cols());

        // Create a Python dictionary to store the result
        let result = PyDict::new(py);
        result.set_item("data", data_c)?;
        result.set_item("indices", indices_c)?;
        result.set_item("indptr", indptr_c)?;
        result.set_item("shape", shape_c)?;

        // Return the Python dictionary
        Ok(result.into())
    })
}

// Define the Python module
#[pymodule]
fn sparse_module(_py: Python, m: &PyModule) -> PyResult<()> {
    // Add the multiplication function to the module
    m.add_function(wrap_pyfunction!(multiply_csr_matrices, m)?)?;
    Ok(())
}

[mulimoen]

I don't think the indptr is constructed properly. I also fail to see why you are doing the matrix multiplication by hand. You can multiply the matrices