Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.soft-sys.math.mathematica > #8517 > unrolled thread
| Started by | "Eric Michielssen" <emichiel@eecs.umich.edu> |
|---|---|
| First post | 2012-02-13 08:45 +0000 |
| Last post | 2012-02-14 11:44 +0000 |
| Articles | 2 — 2 participants |
Back to article view | Back to comp.soft-sys.math.mathematica
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
| From | "Eric Michielssen" <emichiel@eecs.umich.edu> |
|---|---|
| Date | 2012-02-13 08:45 +0000 |
| Subject | surprising 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]
| From | danl@wolfram.com |
|---|---|
| Date | 2012-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