The following code is from a book about Mathematica.

colMean[col_, str_String] := col /. str :> Mean[Cases[col, _?NumberQ]]

ReplaceString[matrix_, str_String] := 
 Transpose[Map[colMean[#, str] &, Transpose[matrix]]]

Giving a matrix with numeric and string entries in a column it replaces the string entries by the mean average of the remaing numeric elements of the column. Here is a test of its efficiency.

With[{size = 1000}, mat = RandomReal[1, {size, size}]; 
  rmat = ReplacePart[mat, 
    RandomInteger[{1, size}, {size, 2}] :> "non"]];
Timing[ReplaceString[rmat, "non"];]

{3.296875, Null}

Here is the respective time performance that appears in the book: 0.877081

So far everything sounds normal. The author may have a faster computer than mine. However, in order to check the efficiency of its code, the author compares it with the performance of some of the highly optimized built-in linear algebra functions.

mat = RandomReal[1, {1000, 1000}];
{Timing[Inverse[mat];], Timing[Det[mat];]}

The times are about, respectively, 0.4 and 0.14 sec.

The strange thing, at least to me, is that my machine has the same time performance. In particular:

 mat = RandomReal[1, {1000, 1000}];
{Timing[Inverse[mat];], Timing[Det[mat];]}

 {{0.453125, Null}, {0.093750, Null}}

So, here comes my first question:

How is it possible to be such a big difference in the performance of the user-defined code and almost identical timings in the performances of relevant built-in functions? What issues affect the performance of such codes?

My second query now.

In order to increase the efficiency of ReplaceString I tried to use parallel computing.

ReplaceString[matrix_, str_String] := 
     Transpose[ParallelMap[colMean[#, str] &, Transpose[matrix]]]

Nevertheless, I did not get any change in the perfomance of the function ReplaceString.

In[6]:= $ProcessorCount
Out[6]= 4

The machine on which this computation was performed has two processors on which Mathematica can run kernels. (Actually, my machine has two physical processors and two virtual ones and so $ProcessorCount returns 4.)

Why there is not an increase in the efficiency of the function? What am I missing here?


Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Browse other questions tagged or ask your own question.