list = RandomReal[{-10, 10}, 1000000];

List of codes

ta = Table[taList = {
     (*  1 *)(Total[Abs[list]] + Total[list])/2 // AbsoluteTiming,
     (*  2 *) Total@Ramp@list // AbsoluteTiming,
     (*  3 *) Total@Clip[list, {0, \[Infinity]}] // AbsoluteTiming,
     (*  4 *) Plus @@ Ramp@list // AbsoluteTiming,
     (*  5 *) Plus @@ Clip[list, {0, \[Infinity]}] // AbsoluteTiming,
     (*  6 *) Total@Select[list, Positive] // AbsoluteTiming,
     (*  7 *) Total@Cases[list, _?Positive] // AbsoluteTiming,
     (*  8 *) Plus @@ Cases[list, _?Positive] // AbsoluteTiming,
     (*  9 *) Total@Cases[list, x_ /; x > 0] // AbsoluteTiming,
     (* 10 *) Plus @@ Cases[list, x_ /; x > 0] // AbsoluteTiming,
     (* 11 *) Plus @@ Select[list, # > 0 &] // AbsoluteTiming,
     (* 12 *) Total[list /. b_?Negative -> 0] // AbsoluteTiming,
     (* 13 *) Total[list /. x_ /; x < 0 -> 0] // AbsoluteTiming,
     (* 14 *) Total@Map[If[# < 0, 0, #] &, list] // AbsoluteTiming,
     (* 15 *) Plus @@ Map[If[# < 0, 0, #] &, list] // AbsoluteTiming,
     (* 16 *)(s = 0; l = Length[list]; 
       Do[If[list[[i]] > 0, s += list[[i]], s], {i, l}]; s) // 
      AbsoluteTiming,
     (* 17 *)(s = 0; l = Length[list]; 
       Table[If[list[[i]] > 0, s += list[[i]], s], {i, l}][[l]]) // 
      AbsoluteTiming,
     (* 18 *)(pcf = Function[x, Piecewise[{{x, x > 0}}, 0], Listable];
        Total[pcf[list]]) // AbsoluteTiming,
     (* 19 *)(s = 0; l = Length[list]; 
       For[i = 0, i <= l, i++, If[list[[i]] > 0, s += list[[i]], s]]; 
       s) // AbsoluteTiming,
     (* 20 *)(s = 0; i = 1; l = Length[list]; 
       While[i <= l, If[list[[i]] > 0, s += list[[i]], s]; i++]; s) //
       AbsoluteTiming
     };
   BarChart[taList[[All, 1]], PlotRange -> {{-.01, 20.5}, {0, 4}}]
   , {48}];

Test Results for a list with 1mln elements

List generation:

list = RandomReal[{-10, 10}, 1000000];

Animation includes the results of 48 tests made both with AbsoluteTiming and RepeatedTiming. The first BarChart is for AbsoluteTiming.

Numerically, we can conclude that the best code is the newest:

Comparing results

In[102]:= absTiming = taList[[All, 1]]

Out[102]= {0.00687931, 0.00704303, 0.015065, 0.359983, 0.321751, 0.683816, 0.779643, \
0.887773, 1.03672, 1.0153, 1.14582, 1.31585, 1.45897, 1.83022, 1.79794, \
2.67337, 2.94904, 3.10739, 3.46186, 3.73936}

In[103]:= absTiming/absTiming[[1]]

Out[103]= {1., 1.0238, 2.1899, 52.3284, 46.7708, 99.4018, 113.332, 129.05, 150.701, \
147.587, 166.561, 191.277, 212.081, 266.048, 261.355, 388.611, 428.682, \
451.701, 503.228, 543.567}

In[108]:= repTiming = trList[[All, 1]]

Out[108]= {0.00618, 0.00703, 0.0147, 0.27, 0.271, 0.638, 0.7696, 0.775, 0.9548, 0.9669, \
1.09, 1.20, 1.368, 1.73, 1.75, 2.60, 2.86, 3.06, 3.5, 3.74}

In[109]:= repTiming/repTiming[[1]]

Out[109]= {1.00, 1.14, 2.38, 44., 43.9, 103., 125., 125., 155., 157., 176., 194., 222., \
280., 283., 421., 463., 495., 5.6*10^2, 6.1*10^2}

Test Results for a list with 20 elements

List generation:

list = RandomReal[{-10, 10}, 20];

Animation includes the results of 60 tests made both with AbsoluteTiming and RepeatedTiming. The first BarChart is for AbsoluteTiming.

Comparing results

In[95]:= abs20Timing = taList20[[All, 1]]

Out[95]= {0.0000166167, 
 4.39853*10^-6, 0.0000151505, 0.0000131956, 0.0000146618, 0.0000244363, \
0.0000268799, 0.0000219927, 0.0000298123, 0.0000254138, 0.0000268799, \
0.0000508275, 0.0000478952, 0.0000444741, 0.0000390981, 0.0000669555, \
0.0000645118, 0.0000772187, 0.0000825947, 0.0000796623}

In[96]:= abs20Timing/abs20Timing[[1]]

Out[96]= {1., 0.264706, 0.911765, 0.794118, 0.882353, 1.47059, 1.61765, 1.32353, \
1.79412, 1.52941, 1.61765, 3.05882, 2.88235, 2.67647, 2.35294, 4.02941, \
3.88235, 4.64706, 4.97059, 4.79412}

In[97]:= rep20Timing = trList20[[All, 1]]

Out[97]= {4.761*10^-6, 2.2*10^-6, 5.53*10^-6, 
 7.6*10^-6, 0.000011419, 0.0000173, 0.000026, 0.00002, 0.000030, 0.000026, \
0.000028, 0.000044, 0.000048, 0.000047, 0.0000413, 0.000073, 0.000069, 0.003, \
0.0001, 0.0000795}

In[98]:= rep20Timing/rep20Timing[[1]]

Out[98]= {1.000, 0.45, 1.16, 1.6, 2.398, 3.62, 5.5, 5., 6.3, 5.5, 5.9, 9.2, 10., 
 1.*10^1, 8.67, 15., 14., 7.*10^2, 2.*10^1, 16.7}

For the short list the code with Total[] and Ramp[] functions is the fastest.

Readability is subject to Mathematica syntax, but if one understands the plan it seems clear. (and doesn't require M11)

Testing on HP5820, Windows 7 -

In[72]:= list = RandomReal[{-10, 10}, 1000000];
Total@Ramp@list // RepeatedTiming
(Total[Abs[list]] + Total[list])/2 // RepeatedTiming

Out[73]= {0.0026, 2.49858*10^6}

Out[74]= {0.00248, 2.49858*10^6}

Smart! Very nice find! Though compromises readability...

Thank you all for your contributions!

To be more specific:

Version 11 will feature Ramp that slices the timings of Clip in half:

http://reference.wolfram.com/language/ref/Ramp.html

Sorry 'bout that; I've edited the post. I seem to have pasted the wrong snippet.

Repeatedly matching the entire list is indeed very likely to be slow, so why do that here? You could do Total[list /. b_?Negative -> 0] if you wish to take the replacement route.

I have used RepeatedTiming[] instead of AbsoluteTiming[] and I have repeated summations 120 times for a list with 20 elements. A have used a fixed PlotRange[]. So, the results are these

With RepeatedTiming[] the fastest is still Total[Clip[list, {0, [Infinity]}]], but the difference is not so essential.

For the list with 1 mln elements, I have done 10 summations

Bingo?

I found that for small lists the code Total[Clip[list, {0, [Infinity]}]] is not more the fastest. The fastest is a new piece of code

Plus @@ Clip[list, {0, \[Infinity]}]

but only for lists with small dimensions ( = 20). I have done experiments with the following pieces of code

In[428]:= tList = {
  (* 1*) Total[Clip[list, {0, \[Infinity]}]] // AbsoluteTiming,
  (* 2*) Plus @@ Clip[list, {0, \[Infinity]}] // AbsoluteTiming,
  (* 3*) Total[Select[list, Positive]] // AbsoluteTiming,
  (* 4*) Total[Cases[list, x_ /; x > 0]] // AbsoluteTiming,
  (* 5*) Plus @@ Cases[list, x_ /; x > 0] // AbsoluteTiming,
  (* 6*) Plus @@ Select[list, # > 0 &] // AbsoluteTiming,
  (* 7*) Total[list /. x_ /; x < 0 -> 0] // AbsoluteTiming,
  (* 8*) Total@Map[If[# < 0, 0, #] &, list] // AbsoluteTiming,
  (* 9*) Plus @@ Map[If[# < 0, 0, #] &, list] // AbsoluteTiming,
  (*10*)(s = 0; l = Length[list]; 
    Do[If[list[[i]] > 0, s += list[[i]], s], {i, l}]; s) // 
   AbsoluteTiming,
  (*11*)(s = 0; l = Length[list]; 
    Table[If[list[[i]] > 0, s += list[[i]], s], {i, l}][[l]]) // 
   AbsoluteTiming,
  (*12*)(pcf = Function[x, Piecewise[{{x, x > 0}}, 0], Listable]; 
    Total[pcf[list]]) // AbsoluteTiming,
  (*13*)(s = 0; l = Length[list]; 
    For[i = 0, i <= l, i++, If[list[[i]] > 0, s += list[[i]], s]]; 
    s) // AbsoluteTiming,
  (*14*)(s = 0; i = 1; l = Length[list]; 
    While[i <= l, If[list[[i]] > 0, s += list[[i]], s]; i++]; s) // 
   AbsoluteTiming
  }

Out[428]= {{0.0000371432, 64.4051}, {0.0000244363, 
  64.4051}, {0.0000288349, 64.4051}, {0.0000483839, 
  64.4051}, {0.0000317672, 64.4051}, {0.0000288349, 
  64.4051}, {0.0000562036, 64.4051}, {0.0000498501, 
  64.4051}, {0.0000381207, 64.4051}, {0.0000659781, 
  64.4051}, {0.0000596246, 64.4051}, {0.0000850384, 
  64.4051}, {0.0000762413, 64.4051}, {0.0000772188, 64.4051}}

I observed that if the experiments are repeated, the time results are not the same. You can view this fact in the following animation, which includes 120 repetitions of the same summations on the same list.

A question appears: why the times are different if the code and the list remain unchanged?

I have done the same experiment on the list with 1 mln elements, but providing repetitions only 32 times. The results may be seen in the following GIF

For the large lists, the time behavior of the pieces of code are more stable.

Nevertheless, one more question appears: what is the worst correct piece of code?

May be the following code a pretender to such denomination?

Total[list //. {a___, b_, c___} /; b < 0 -> {a, 0, 
     c}] // AbsoluteTiming

For small lists it works perfect! But for lists with length more than 1000 it requires very long time.

Yes! Simple and Clear!

Sure, I can do it, but for our goals it's not so important! It's just for principles and ideas.

You are right, I copied the wrong stuff from my test-notebook... But fixed by JM.. thanks

Thanks a lot, J.M.

As you asked me, J.M., about the summation, we can imagine an improvement of the function Total[] that will include the criterion according to which the summation is done, i.e.

Total[list, crit, {Subscript[n, 1],Subscript[n, 2]}]

crit means criterion and it may be, e.g., Reals, Complex, Integers, and so on...

We can examine it as special case, i.e.in our case such numbers are not summed.

It's very impressive for me!

@Sander The code contains errors! Try it on a small list!

After J.M. improvement

In[32]:= list = RandomReal[{-10, 10}, 1000000];

In[33]:= tList = {
  Plus @@ Map[If[# < 0, 0, #] &, list] // AbsoluteTiming,
  Total@Map[If[# < 0, 0, #] &, list] // AbsoluteTiming,
  Total[list /. x_ /; x < 0 -> 0] // AbsoluteTiming,
  Plus @@ Select[list, # > 0 &] // AbsoluteTiming,
  Total[Clip[list, {0, \[Infinity]}]] // AbsoluteTiming,
  AbsoluteTiming[
   pcf = Function[x, Piecewise[{{x, x > 0}}, 0], Listable]; 
   Total[pcf[list]]]
  }

Out[33]= {{1.71495, 2.50376*10^6}, {1.70818, 2.50376*10^6}, {1.3847, 
  2.50376*10^6}, {1.03566, 2.50376*10^6}, {0.0151026, 
  2.50376*10^6}, {3.1214, 2.50376*10^6}}

In[34]:= BarChart@tList[[All, 1]]

That wasn't an answer to my question. :) If you have a list like {1, 2, x, -1, -4}, should x be added to the sum, or removed from the list before summing? Same question for {1, 2, I, -1, -4}.

Another approach is:

AbsoluteTiming[pcf = Piecewise[{{x, x > 0}, {0, True}}]; Total[pcf /@ list];]

But it is slower (at least on my computer).

Then how do you know if they're positive? How do you wish them to be dealt with?

Yes, it is the fastest! It is the lowest bar in the precedent BarChart!

Thanks!

In[6]:= list = RandomReal[{-10, 10}, 1000000];

In[10]:= tList = {
Plus @@ Map[If[# < 0, 0, #] &, list] // AbsoluteTiming,
Total@Map[If[# < 0, 0, #] &, list] // AbsoluteTiming,
Total[list /. x_ /; x < 0 -> 0] // AbsoluteTiming,
Plus @@ Select[list, # > 0 &] // AbsoluteTiming,
Total[Clip[list, {0, \[Infinity]}]] // AbsoluteTiming
}

Out[10]= {{1.76125, 2.49895*10^6}, {1.78087, 2.49895*10^6}, {1.42525,  2.49895*10^6},
{1.07893, 2.49895*10^6}, {0.0146056, 2.49895*10^6}}

In[11]:= BarChart@tList[[All, 1]]

Unbelievable fast!

In[4]:= tList = {Plus @@ Map[If[# < 0, 0, #] &, list] // 
   AbsoluteTiming, 
  Total@Map[If[# < 0, 0, #] &, list] // AbsoluteTiming, 
  Total[list /. x_ /; x < 0 -> 0] // AbsoluteTiming,
  Plus @@ Select[list, # > 0 &] // AbsoluteTiming }

Out[4]= {{0.942527, 2.49442*10^6}, {0.977524, 
  2.49442*10^6}, {0.778662, 2.49442*10^6}, {0.595495, 2.49442*10^6}}