Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]


Groups > comp.soft-sys.math.mathematica > #8517 > unrolled thread

surprising timings for multiplication of diagonalmatrix and full matrix

Started by"Eric Michielssen" <emichiel@eecs.umich.edu>
First post2012-02-13 08:45 +0000
Last post2012-02-14 11:44 +0000
Articles 2 — 2 participants

Back to article view | Back to comp.soft-sys.math.mathematica


Contents

  surprising timings for multiplication of diagonalmatrix and full matrix "Eric Michielssen" <emichiel@eecs.umich.edu> - 2012-02-13 08:45 +0000
    Re: surprising timings for multiplication of diagonalmatrix and full matrix danl@wolfram.com - 2012-02-14 11:44 +0000

#8517 — surprising timings for multiplication of diagonalmatrix and full matrix

From"Eric Michielssen" <emichiel@eecs.umich.edu>
Date2012-02-13 08:45 +0000
Subjectsurprising timings for multiplication of diagonalmatrix and full matrix
Message-ID<jhaiip$56k$1@smc.vnet.net>
Hi,

I'd like to right multiply an n x n diagonal matrix (specified by a vector)
by an n x n full matrix.

I tried 3 ways

A. Brute force

B. Using my own routine in which I was hoping to avoid the (supposedly) n^3
cost of A.

diagtimesmat[diag_, mat_] := MapThread[Times, {diag, mat}];

C. The compiled version of B.

cdiagtimesmat = 
  Compile[{{diag, _Real, 1}, {mat, _Real, 2}}, 
   Module[{}, MapThread[Times, {diag, mat}]], 
   CompilationTarget -> "C"];

I get weird timings.  For n=250:

n=250;nj=100;
asd=Table[RandomReal[],{n},{n}];
bsd=Table[RandomReal[],{n}];
x=Timing[Do[ed=DiagonalMatrix[bsd].asd,{nj}]][[1]]
y=Timing[Do[ed=diagtimesmat[bsd,asd],{nj}]][[1]]
z=Timing[Do[ed=cdiagtimesmat[bsd,asd],{nj}]][[1]]

Out[415]= 0.359
Out[416]= 6.037
Out[417]= 0.141

My own uncompiled routine is superslow!!!  There are warnings about arrays
being unpacked that I did not copy.

For n=500:

In[418]:= n = 500; nj = 100;
asd = Table[RandomReal[], {n}, {n}];
bsd = Table[RandomReal[], {n}];
x = Timing[Do[ed = DiagonalMatrix[bsd].asd, {nj}]][[1]]
y = Timing[Do[ed = diagtimesmat[bsd, asd], {nj}]][[1]]
z = Timing[Do[ed = cdiagtimesmat[bsd, asd], {nj}]][[1]]

Out[421]= 2.777
Out[422]= 1.31
Out[423]= 1.014

This is more reasonable. It remains a bit surprising that the routine that
only touches n^2 numbers is only twice as fast as the one that supposedly
touches n^3 ones.  Also, the compiled routine still does not achieve 100
MFlops on my laptop.

How can this behavior be explained?  What is the fastest way of doing this?
And how about multiplying a full matrix by a diagonal one?

Thanks!
Eric

Eric Michielssen
Radiation Laboratory
Department of Electrical Engineering and Computer Science
University of Michigan
1301 Beal Avenue
Ann Arbor, MI 48109
Ph: (734) 647 1793 -- Fax: (734) 647 2106


[toc] | [next] | [standalone]


#8537

Fromdanl@wolfram.com
Date2012-02-14 11:44 +0000
Message-ID<jhdheg$hem$1@smc.vnet.net>
In reply to#8517
I suspect Dot packs first when it can. So when you are under the threshold of packed array size (250, in this case), your various functions are working with unpacked inputs. The ones that "know" to pack first come out ahead.

Fastest would  (well, should) be to use Times:

w = Timing[Do[fd = bsd*asd, {nj}]][[1]] 


Daniel Lichtblau
Wolfram Research

[toc] | [prev] | [standalone]


Back to top | Article view | comp.soft-sys.math.mathematica


csiph-web