Mathematica SparseArray Access Non-Default Values

  • Context: Mathematica 
  • Thread starter Thread starter wima
  • Start date Start date
  • Tags Tags
    Mathematica
Click For Summary

Discussion Overview

The discussion revolves around accessing the number of non-default (non-zero) values in each row of a large sparse matrix using Mathematica's SparseArray functionality. Participants explore various methods to achieve this without converting the entire matrix into a normal array due to its size.

Discussion Character

  • Technical explanation
  • Debate/contested
  • Mathematical reasoning

Main Points Raised

  • One participant describes the challenge of reading the number of non-default values in each row of a SparseArray, specifically for a matrix of size ~80,000 x 80,000.
  • Another participant suggests using Normal[test[[1]]] to access the values, indicating it would not be too large.
  • A different participant proposes that test[[1]][[5]] returns the value in row 1 and column 5, questioning if this is the correct approach.
  • One participant emphasizes the need to construct a vector storing the number of non-zero values in each row, providing an example vector based on their SparseArray.
  • Another participant points out that the values in the display format (e.g., SparseArray[<2>, {5}]) are not stored as real values and suggests using ToString and string manipulation to extract the number.
  • A participant mentions that using Length[ArrayRules[test[[1]]]] - 1 can provide the number of non-zero elements, although it may not be efficient for large matrices.
  • One participant expresses gratitude for the responses and notes they are evaluating the efficiency of the suggested methods.

Areas of Agreement / Disagreement

Participants generally agree on the challenge of accessing non-zero values in large sparse matrices and propose various methods to address it. However, there is no consensus on the most efficient approach, as participants are still evaluating the suggested solutions.

Contextual Notes

Participants acknowledge the limitations of their approaches, particularly regarding performance and the size of the matrices involved. There are unresolved questions about the efficiency of different methods for accessing non-zero values.

wima
Messages
3
Reaction score
0
Hi,

I am currently dealing with really huge (~ 80,000 x 80,000) sparse matrices. I this context I need to read the number of non-default values in each row.
When Accessing the i-th row of a SparseArray, this information is given.
E.g.
test = SparseArray[{{1, 1} -> 3, {1, 5} -> 2, {5, 3} -> 1}];
test[[1]]
returns SparseArray[<2>, {5}]
However, I fail to access the number of entries (here 2) to assign it to a variable.
I did not find any information in the documentation so far.
Does anyone have an idea?

Thx
 
Physics news on Phys.org
You can use Normal[test[[1]]]
 
I could be wrong but is it :
test[[1]][[5]] in this case? its the only index that returns "2"
 
@DaleSpam:
The problem is, that my matrices are too large to convert them into normal arrays. However, about only 1% of the matrix entries have non-zero values. For my computations, I need to construct a vector that stores the number of non-zero values that are in each row of the matrix. For the example I posted, that vector would be {2,0,0,0,1} because there are two entries in the first row and one in the fifth row. Iterating over all 80,000 x 80,000 = 6,400,000,000 values of the sparse matrix will not work...

@Hepth:
test[[1]][[5]] returns the value of the matrix in row 1 and column 5. That entry is 2. What I need to access is the number of nonzero values in every row.

It's really bothering, because it's obvious that the number of entries is easily accessible as you can see here:
test[[1]]
test[[2]]
test[[5]]
returns
SparseArray[<2>, {5}]
SparseArray[<0>, {5}]
SparseArray[<1>, {5}]
namely 2, 0 and 1. However, it's not sufficient for me to read the values manually, but I need to assign them to a variable for storing them in the vector of size 80,000. So the probelm is to access the values in <>.

Anyway, thanks for your replies so far!
 
Yes, I understand that it is too big to convert the whole matrix into a normal array. That is why I suggest Normal[test[[1]]] rather than Normal[test][[1]]. For your matrix that will be a vector with 80k entries, so not too big.

The values in the <> are not real values stored anywhere, they are just for display. If you really want those the only way to get them would be to use ToString[test[[1]]] and then use some string manipulation to pull out the number between the <>.
 
Length[ArrayRules[test[[1]]]] - 1

will give you the number of nonzero elements. But Array Rules itself might not be fast for something that large, it gives the list of all non zero components.
 
Thank you for your replies! All of the suggested methods work. I am currently about to figure out, which of them are most efficient.
 

Similar threads

  • · Replies 2 ·
Replies
2
Views
3K
  • · Replies 4 ·
Replies
4
Views
5K
  • · Replies 9 ·
Replies
9
Views
4K
  • · Replies 6 ·
Replies
6
Views
5K
  • · Replies 2 ·
Replies
2
Views
2K
  • · Replies 2 ·
Replies
2
Views
2K
  • · Replies 1 ·
Replies
1
Views
3K
  • · Replies 5 ·
Replies
5
Views
3K
  • · Replies 3 ·
Replies
3
Views
3K
  • · Replies 3 ·
Replies
3
Views
2K