Services & ResourcesWolfram ForumsMathGroup Archive

[Date Index] [Thread Index] [Author Index]

Re: Timing runs for the last part of my previous post

• To: mathgroup at smc.vnet.net
• Subject: [mg62056] Re: Timing runs for the last part of my previous post
• From: Peter Pein <petsie at dordos.net>
• Date: Thu, 10 Nov 2005 02:50:41 -0500 (EST)
• References: <dkshq9$jei$1@smc.vnet.net>
• Sender: owner-wri-mathgroup at wolfram.com

Matt schrieb:
> OK,
>   After I posted my earlier message (the one entitled "'Good' or
> 'Proper' Mathematica coding habits question"), I decided to try some
> timings for the last code sample I had a question on (the one trying to
> extract all sublists where each element of a sublist had to be
> negative).  Here's what I found:
> 
> This table was generated, then used for all the approaches:
> values = Table[{Random[Real, {-2, 2}] i, Random[Real, {-2, 2}] i}, {i,
> 1, 2000}];
> 
> Approach #1:

I modified the testFunc slightly (see below)

> And the test run was:
> 
> Timing[Do[testFuncOne[], {10^3}]][[1]]
> Timing[Do[testFuncTwo[], {10^3}]][[1]]
> Timing[Do[testFuncThree[], {10^3}]][[1]]
> 
> The results obtained were 13.625, 12.812, and 19.11 Seconds.  So, it
> appears that of the methods I tried, that Approach 2 is marginally
> better than Approach 1, and both Approach 1 and Approach 2 are better
> than Approach 3.  Is it correct to assume from this that Fold will
> almost always be better than Map, given that other potential variants
> are kept similar?  Or, because the difference is so small, that for
> most applications, I should go with whatever approach is quicker to
> 'code up'?
> 
> Thanks,
> 
> Matt
> 
> 

Hi Matt,

one has to keep in mind that there's no compiler, which could alter loop 
handling. It is possible to use a While-loop as efficient as the Fold 
approach for this task. But nothing beats built-in kernel functions:

values = Table[i*(4 Random[] - 2), {i, 2000}, {2}];

testFunc[1][] :=
   Module[{negElems = {}},
    (If[Negative[First[#1]] && Negative[Last[#1]],
        negElems = {negElems, #1}] & ) /@ values;
     Partition[Flatten[negElems], 2]]

testFunc[2][] :=
   Module[{negElems = {}},
     Fold[
       If[Negative[First[#2]] && Negative[Last[#2]],
         negElems = {negElems, #2}] & ,
       {1, 1}, values];
     Partition[Flatten[negElems], 2]]

testFunc[3][] :=
   Module[{negElems = {}, ii = 1 + Length[values]},
     While[--ii > 0,
       If[Negative[values[[ii, 1]]] && Negative[values[[ii, 2]]],
         negElems = {values[[ii]], negElems}]];
     Partition[Flatten[negElems], 2]]

testFunc[4][] :=
    Cases[values, {x_?Negative, y_?Negative}];

The test run is:

In[6]:=
First /@ (res = Timing[Do[testFunc[#1][], {1000}]]& /@ Range[4])
Out[6]=
{11.39 *Second,
  11.141*Second,
  11.172*Second,
   4.375*Second}

In[7]:=
SameQ @@ Last /@ res
Out[7]=
True

The difference between the first three methods is so small that a 
garbage collection _could_ be responsible (I think). But with the kernel 
function Cases you don't have to pick elements, build a very nested 
list, flatten and partition it. And it is faster to 'code up' too.

Have fun discovering Mathematica,
Peter

• Follow-Ups:
  • Re: Re: Timing runs for the last part of my previous post
    • From: "Oyvind Tafjord" <tafjord@wolfram.com>