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

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