Cfxtrjtrk

My goal is to find such properties of a sparse matrix as the maximum/average number of non-zero elements per row.

The brute-force way of doing this is via converting the sparse array into a regular one:

MaxSpar[matr_] := Module[{curr, ms = 0},

   Do[

    curr = Length[Cases[matr[[k]], 0]];

    If[curr > ms, ms = curr];

    , {k, 1, Length[matr]}

    ];

   Return[ms];

   ];



MaxSpar[Normal[SomeSparseMatrix]]

How can we do the same without using Normal?

To obtain the number of nonzero entry of the row with fewest zeros:

Max[Length /@ SomeSparseMatrix["AdjacencyLists"]]

There are other useful strings. "Methods" shows which are availble:

SomeSparseMatrix["Methods"]

{"AdjacencyLists", "Background", "ColumnIndices", "Density",
"MatrixColumns", "MethodInformation", "Methods", "NonzeroPositions",
"NonzeroValues", "PatternArray", "PatternValues", "Properties",
"RowPointers"}

maxNonZero = Max[Length /@ #["MatrixColumns"]] &;

aveNonZero = Mean[Length /@ #["MatrixColumns"] ] &

SeedRandom[1]

sa = SparseArray[RandomInteger[3, {7, 10}]];

sa // MatrixForm // TeXForm

$left(
begin{array}{cccccccccc}
3 & 1 & 0 & 1 & 1 & 0 & 0 & 0 & 1 & 3 \
0 & 0 & 0 & 0 & 2 & 0 & 1 & 2 & 0 & 0 \
3 & 3 & 3 & 1 & 1 & 0 & 0 & 1 & 3 & 0 \
2 & 0 & 1 & 1 & 3 & 3 & 3 & 2 & 3 & 2 \
0 & 1 & 3 & 3 & 0 & 1 & 0 & 1 & 0 & 3 \
0 & 2 & 3 & 0 & 2 & 2 & 0 & 1 & 3 & 2 \
1 & 2 & 0 & 0 & 0 & 2 & 1 & 2 & 1 & 0 \
end{array}
right)$

maxNonZero[sa]

9

N @ aveNonZero[sa]

6.285714285714

A couple of ways using "NonzeroPositions", using @kglr's example:

SeedRandom[1]

sa = SparseArray[RandomInteger[3, {7, 10}]];

Using associations:

rowlens = Merge[Rule @@@ sa@"NonzeroPositions", Length]

Query[{Mean, Max}]@rowlens

(*

<|1 -> 6, 2 -> 3, 3 -> 7, 4 -> 9, 5 -> 6, 6 -> 7, 7 -> 6|> 

{44/7, 9}  

*)

Using GatherBy:

rowlens = Length /@ GatherBy[sa@"NonzeroPositions", First]

{Mean[#], Max[#]} &[rowlens]

(*

{6, 3, 7, 9, 6, 7, 6}

{44/7, 9}

*)

Large example, with timings:

SeedRandom[1];

sa = SparseArray@RandomChoice[{0, 0, 0, 0, 0, 1, 2, 3}, {50, 1000}];

GatherBy is quite a bit faster (and more so as the size of sa grows).

(rowlens = Merge[Rule @@@ sa@"NonzeroPositions", Length];

  Query[{Mean, Max}]@rowlens;) // RepeatedTiming

(*  {0.024, Null}  *)



(rowlens = Length /@ GatherBy[sa@"NonzeroPositions", First];

 {Mean[#], Max[#]} &[rowlens];) // RepeatedTiming

(*  {0.00075, Null}  *)

m = 100000;

n = 2000000;

A = SparseArray[

   RandomInteger[{1, m}, {n, 2}] -> RandomReal[{-1, 1}, n],

   {m, m}, 0.

   ];

Maximum number of nonempty elements per row:

a = Max[Unitize[A].ConstantArray[1, Dimensions[A][[2]]]]; // RepeatedTiming // First

b = Max[Length /@ A["AdjacencyLists"]]; // RepeatedTiming // First

0.122

0.053

A faster way (that works only for rows) is

c = Max[Differences[A["RowPointers"]]]; // RepeatedTiming // First

a == b == c

0.000642

True

Analogously, the mean of the numbers of nonempty elements per row can be obtain as follows:

Mean[N[Differences[A["RowPointers"]]]]