Sparsity of a sparse array without converting it to a regular one












4














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?










share|improve this question



























    4














    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?










    share|improve this question

























      4












      4








      4







      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?










      share|improve this question













      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?







      sparse-arrays






      share|improve this question













      share|improve this question











      share|improve this question




      share|improve this question










      asked Nov 27 '18 at 19:13









      mavzolej

      38019




      38019






















          3 Answers
          3






          active

          oldest

          votes


















          6














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







          share|improve this answer





























            3














            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







            share|improve this answer































              1














              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"]]]]





              share|improve this answer























                Your Answer





                StackExchange.ifUsing("editor", function () {
                return StackExchange.using("mathjaxEditing", function () {
                StackExchange.MarkdownEditor.creationCallbacks.add(function (editor, postfix) {
                StackExchange.mathjaxEditing.prepareWmdForMathJax(editor, postfix, [["$", "$"], ["\\(","\\)"]]);
                });
                });
                }, "mathjax-editing");

                StackExchange.ready(function() {
                var channelOptions = {
                tags: "".split(" "),
                id: "387"
                };
                initTagRenderer("".split(" "), "".split(" "), channelOptions);

                StackExchange.using("externalEditor", function() {
                // Have to fire editor after snippets, if snippets enabled
                if (StackExchange.settings.snippets.snippetsEnabled) {
                StackExchange.using("snippets", function() {
                createEditor();
                });
                }
                else {
                createEditor();
                }
                });

                function createEditor() {
                StackExchange.prepareEditor({
                heartbeatType: 'answer',
                autoActivateHeartbeat: false,
                convertImagesToLinks: false,
                noModals: true,
                showLowRepImageUploadWarning: true,
                reputationToPostImages: null,
                bindNavPrevention: true,
                postfix: "",
                imageUploader: {
                brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
                contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
                allowUrls: true
                },
                onDemand: true,
                discardSelector: ".discard-answer"
                ,immediatelyShowMarkdownHelp:true
                });


                }
                });














                draft saved

                draft discarded


















                StackExchange.ready(
                function () {
                StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fmathematica.stackexchange.com%2fquestions%2f186810%2fsparsity-of-a-sparse-array-without-converting-it-to-a-regular-one%23new-answer', 'question_page');
                }
                );

                Post as a guest















                Required, but never shown

























                3 Answers
                3






                active

                oldest

                votes








                3 Answers
                3






                active

                oldest

                votes









                active

                oldest

                votes






                active

                oldest

                votes









                6














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







                share|improve this answer


























                  6














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







                  share|improve this answer
























                    6












                    6








                    6






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







                    share|improve this answer












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








                    share|improve this answer












                    share|improve this answer



                    share|improve this answer










                    answered Nov 27 '18 at 19:18









                    Coolwater

                    14.7k32553




                    14.7k32553























                        3














                        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







                        share|improve this answer




























                          3














                          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







                          share|improve this answer


























                            3












                            3








                            3






                            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







                            share|improve this answer














                            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








                            share|improve this answer














                            share|improve this answer



                            share|improve this answer








                            edited Nov 27 '18 at 19:35

























                            answered Nov 27 '18 at 19:22









                            kglr

                            177k9198406




                            177k9198406























                                1














                                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"]]]]





                                share|improve this answer




























                                  1














                                  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"]]]]





                                  share|improve this answer


























                                    1












                                    1








                                    1






                                    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"]]]]





                                    share|improve this answer














                                    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"]]]]






                                    share|improve this answer














                                    share|improve this answer



                                    share|improve this answer








                                    edited Nov 27 '18 at 20:13

























                                    answered Nov 27 '18 at 19:51









                                    Henrik Schumacher

                                    49.2k467139




                                    49.2k467139






























                                        draft saved

                                        draft discarded




















































                                        Thanks for contributing an answer to Mathematica Stack Exchange!


                                        • Please be sure to answer the question. Provide details and share your research!

                                        But avoid



                                        • Asking for help, clarification, or responding to other answers.

                                        • Making statements based on opinion; back them up with references or personal experience.


                                        Use MathJax to format equations. MathJax reference.


                                        To learn more, see our tips on writing great answers.





                                        Some of your past answers have not been well-received, and you're in danger of being blocked from answering.


                                        Please pay close attention to the following guidance:


                                        • Please be sure to answer the question. Provide details and share your research!

                                        But avoid



                                        • Asking for help, clarification, or responding to other answers.

                                        • Making statements based on opinion; back them up with references or personal experience.


                                        To learn more, see our tips on writing great answers.




                                        draft saved


                                        draft discarded














                                        StackExchange.ready(
                                        function () {
                                        StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fmathematica.stackexchange.com%2fquestions%2f186810%2fsparsity-of-a-sparse-array-without-converting-it-to-a-regular-one%23new-answer', 'question_page');
                                        }
                                        );

                                        Post as a guest















                                        Required, but never shown





















































                                        Required, but never shown














                                        Required, but never shown












                                        Required, but never shown







                                        Required, but never shown

































                                        Required, but never shown














                                        Required, but never shown












                                        Required, but never shown







                                        Required, but never shown







                                        Popular posts from this blog

                                        Ellipse (mathématiques)

                                        Quarter-circle Tiles

                                        Mont Emei