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 15 hours ago









      mavzolej

      37819




      37819






















          3 Answers
          3






          active

          oldest

          votes

















          up vote
          4
          down vote













          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
                4
                down vote













                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
                  4
                  down vote













                  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
                    4
                    down vote










                    up vote
                    4
                    down vote









                    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 15 hours ago









                    Coolwater

                    14.3k32452




                    14.3k32452






















                        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 14 hours ago

























                            answered 15 hours ago









                            kglr

                            173k8195400




                            173k8195400






















                                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 14 hours ago

























                                    answered 14 hours ago









                                    Henrik Schumacher

                                    45.7k466132




                                    45.7k466132






























                                         

                                        draft saved


                                        draft discarded



















































                                         


                                        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

                                        Котор

                                        Потомский, Вадим Владимирович

                                        Бедствия войны