I have matrix and and i want to do increment in a do loop and and i want to store in list using append to. It works fine for less values, But when i want to do it for values around 1 million the program is slow.

 x = {{0.1},{0.2}};xm = {{0.4},{0.5}};
Do[datax[i] = {}; dataxm[i] = {};, {i, 1, 2}]

Do[
 x = x + t;
xm = xm + t;
 Do[AppendTo[datax[i], Flatten[{t, x[[i]]}]];, {i, 1, 2}];
Do[AppendTo[dataxm[i], Flatten[{t, xm[[i]]}]];, {i, 1, 2}], {t, 0, 1, 0.1}]


 datax[1]

 {{0., 0.1}, {0.1, 0.2}, {0.2, 0.4}, {0.3, 0.7}, {0.4, 1.1}, {0.5, 1.6}, {0.6, 2.2}, {0.7, 2.9}, {0.8, 3.7}, {0.9, 4.6}, {1., 5.6}}

datax[2]

{{0., 0.2}, {0.1, 0.3}, {0.2, 0.5}, {0.3, 0.8}, {0.4, 1.2}, {0.5, 
  1.7}, {0.6, 2.3}, {0.7, 3.}, {0.8, 3.8}, {0.9, 4.7}, {1., 5.7}}

dataxm[1]

 {{0., 0.4}, {0.1, 0.5}, {0.2, 0.7}, {0.3, 1.}, {0.4, 
  1.4}, {0.5, 1.9}, {0.6, 2.5}, {0.7, 3.2}, {0.8, 4.}, {0.9, 
  4.9}, {1., 5.9}}

 dataxm[2]

 {{0., 0.5}, {0.1, 0.6}, {0.2, 0.8}, {0.3, 1.1}, {0.4, 
  1.5}, {0.5, 2.}, {0.6, 2.6}, {0.7, 3.3}, {0.8, 4.1}, {0.9, 5.}, {1.,
   6.}}

Similar to the above I want to use reap and sow functions to speed it up but i can store only the last value. Why?

 x = {{0.1},{0.2}};xm = {{0.4},{0.5}};


Do[
x = x + t;xm = xm + t;

Do[datax[i] = Reap[Sow[{t, x[[i]]}]][[2, 1]], {i, 1, 2}];

Do[dataxm[i] = Reap[Sow[{t, xm[[i]]}]][[2, 1]], {i, 1, 2}];


, {t, 0, 1, 0.1}]

datax[1]
{{1., {5.6}}}

 datax[2]
{{1., {5.7}}}


datax[1]
{{1., {5.9}}}

datax[2]
{{1., {6.0}}

Can anyone help in fixing this issue? Thanks in advance

up vote 7 down vote accepted

You need olny one Reap for all Sows -- that's primarily the advantage of using them.

Moreover, you may use tags to obtain datax[1] and datax[2]:

x = {{0.1}, {0.2}};
ClearAll[datax];
datax = Association@Reap[
    Do[
     x = x + t;
     Do[
      Sow[
       Flatten[{t, x[[tag]]}], 
       tag
       ],
      {tag, 1, 2}],
     {t, 0, 1, 0.1}],
    _, Rule][[2]]

<|1 -> {{0., 0.1}, {0.1, 0.2}, {0.2, 0.4}, {0.3, 0.7}, {0.4, 1.1}, {0.5, 1.6}, {0.6, 2.2}, {0.7, 2.9}, {0.8, 3.7}, {0.9, 4.6}, {1., 5.6}}, 2 -> {{0., 0.2}, {0.1, 0.3}, {0.2, 0.5}, {0.3, 0.8}, {0.4, 1.2}, {0.5, 1.7}, {0.6, 2.3}, {0.7, 3.}, {0.8, 3.8}, {0.9, 4.7}, {1., 5.7}}|>

Now you can access datax[1] and datax[2] as before.

Edit:

Because the question changed: This should allow you to assemble more than one list in one go:

data = Merge[
   Reap[
     Do[
      x = x + t;
      xm = xm + t;
      Do[
       Sow[Flatten[{t, x[[i]]}], "datax" -> i];
       Sow[Flatten[{t, xm[[i]]}], "dataxm" -> i]
       ,
       {i, 1, 2}], {t, 0, 1, 0.1}],
     _, #1[[1]] -> Association[#1[[2]] -> #2] &][[2]]
   , Association
   ];

Now data["datax"] and data["dataxm"] should behave like datax and dataxm.

Edit 2

You can obtain essentially the same result much more efficiently with arrays produced by Table:

x = {0.1, 0.2};
xm = {0.4, 0.5};
{datax, dataxm} = Transpose[
   Table[{{{t, t}, x += t}, {{t, t}, xm += t}}, {t, 0, 1, 0.1}], 
   {3, 1, 4, 2}];

Now you have (notice the double brackets):

datax[[1]]
datax[[2]]
dataxm[[1]]
dataxm[[2]]

Speed considerations

Even faster for this particular problem is to avoid cursive addition and to use vectorized operations.

The Reap/Sow method from above:

n = 1000000;

x = {0.1, 0.2};
xm = {0.4, 0.5};
First@AbsoluteTiming[
  data = Merge[
     Reap[
       Do[
        x = x + t;
        xm = xm + t;
        Do[
         Sow[Flatten[{t, x[[i]]}], "datax" -> i];
         Sow[Flatten[{t, xm[[i]]}], "dataxm" -> i]
         ,
         {i, 1, 2}], {t, 0., 1., 1./n}],
       _, #1[[1]] -> Association[#1[[2]] -> #2] &][[2]]
     , Association
     ];
  ]

11.4845

The Table method from above:

x = {0.1, 0.2};
xm = {0.4, 0.5};
First@AbsoluteTiming[
  {datax, dataxm} = 
    Transpose[
     Table[{{{t, t}, x += t}, {{t, t}, xm += t}}, {t, 0., 1., 
       1./n}], {3, 1, 4, 2}];
  ]

2.74062

Vectorized version:

x = {0.1, 0.2};
xm = {0.4, 0.5};
First@AbsoluteTiming[
  tlist = Subdivide[0., 1., n];
  slist = Accumulate[tlist];
  datax2 = {
    Transpose[{tlist, x[[1]] + slist}],
    Transpose[{tlist, x[[2]] + slist}]
    };
  dataxm2 = {
    Transpose[{tlist, xm[[1]] + slist}],
    Transpose[{tlist, xm[[2]] + slist}]
    };
  ]

0.061355

So, the latter is 44/187 time faster than the other methods. So you should take these considerations into account when using Reap and Sow.

Errors:

Max[Abs[data["datax"][1] - datax[[1]]]]
Max[Abs[data["datax"][2] - datax[[2]]]]
Max[Abs[data["dataxm"][1] - dataxm[[1]]]]
Max[Abs[data["dataxm"][2] - dataxm[[2]]]]
Max[Abs[datax - datax2]]
Max[Abs[dataxm - dataxm2]]

0.

0.

0.

0.

5.82077*10^-11

5.82077*10^-11

  • Sir Thanks for the reply. The method which you provided above works fine if i can i have only one list. Actually i edited the post can you fix the problem with above example. I wanted to store x and xm in different list is it possible . If cannot how can i extract the values with same tag for x and xm – revanth roy Nov 9 at 9:34

Your Answer

 
discard

By clicking "Post Your Answer", you acknowledge that you have read our updated terms of service, privacy policy and cookie policy, and that your continued use of the website is subject to these policies.

Not the answer you're looking for? Browse other questions tagged or ask your own question.