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











up vote
4
down vote

favorite












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


























    up vote
    4
    down vote

    favorite












    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
























      up vote
      4
      down vote

      favorite









      up vote
      4
      down vote

      favorite











      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 at 19:13









      mavzolej

      38019




      38019






















          3 Answers
          3






          active

          oldest

          votes

















          up vote
          6
          down vote



          accepted










          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




























            up vote
            3
            down vote













            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






























              up vote
              1
              down vote













              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',
                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








                up vote
                6
                down vote



                accepted










                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

























                  up vote
                  6
                  down vote



                  accepted










                  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























                    up vote
                    6
                    down vote



                    accepted







                    up vote
                    6
                    down vote



                    accepted






                    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 at 19:18









                    Coolwater

                    14.4k32452




                    14.4k32452






















                        up vote
                        3
                        down vote













                        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



























                          up vote
                          3
                          down vote













                          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

























                            up vote
                            3
                            down vote










                            up vote
                            3
                            down vote









                            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 at 19:35

























                            answered Nov 27 at 19:22









                            kglr

                            174k8196401




                            174k8196401






















                                up vote
                                1
                                down vote













                                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



























                                  up vote
                                  1
                                  down vote













                                  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

























                                    up vote
                                    1
                                    down vote










                                    up vote
                                    1
                                    down vote









                                    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 at 20:13

























                                    answered Nov 27 at 19:51









                                    Henrik Schumacher

                                    46k466132




                                    46k466132






























                                        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

                                        AnyDesk - Fatal Program Failure

                                        How to calibrate 16:9 built-in touch-screen to a 4:3 resolution?

                                        QoS: MAC-Priority for clients behind a repeater