Matrix Multiplication Along Pages of Multidimensional Matrix

What is the most efficient way of matrix-multiplying along a page (2d plane) of a multidimensional matrix. Speed is important here as this operation will be in the objective-function of a calibration.

Specifically I have a 4d matrix of dimension [m,n,p,2], and I want to matrix-multiply it by a [2x1] vector

So conceptually I need

b*y0'

Taking for example:

    b = rand(5,3,4,2); %
    y0 = [0.1;0.2]; y0 = reshape(y0,[1,1,1,2]); %

I should end up with a 3d matrix of size [5,3,4]

I could, of course, dot-multiply by a repmatted y0 and then sum along the 4d but is this really the most efficient?

y0 = y0(ones(5,1,1),ones(1,3,1),ones(1,1,4),:);
sum(b.*y0,4);

All the best

Answer 1

[Matt J]

If size(b,4)=2 all the time, it would probably be best just to generate two separate 3D arrays b1 and b2

result=b1*y0(1)+b2*y0(2);

[Matt J]

Note, this is different from (and faster than)

result=b(:,:,:,1)*y0(1)+b(:,:,:,2)*y0(2);

[Mark Whirdy]

you're right - talk about overengineering :-D

thanks!

Answer 2

[Matt J]

I could, of course, dot-multiply by a repmatted y0 and then sum along the 4d but is this really the most efficient?

Probably, if you're stuck with b in the shape you describe. However, it is better to use bsxfun, rather than repmat;

    y0 = [0.1;0.2]; y0 = reshape(y0,[1,1,1,2]); %

    result = sum( bsxfun(@times, b,y0) , 4)

[Mark Whirdy]

bsxfun is slower actually

>> tic
    for i = 1:1e5
        y0 = y0(ones(5,1,1),ones(1,3,1),ones(1,1,4),:);
result = sum(b.*y0,4);
    end
    toc
Elapsed time is 0.741447 seconds.
>> tic
    for i = 1:1e5

       result = sum( bsxfun(@times, b,y0) , 4);
      end
      toc
  Elapsed time is 0.948352 seconds.

[Matt J]

It's not a meaningful test with m,n,p that small. If your dimensions are truly that size, you should be thinking about vectorizing across the different batches of b.

[Mark Whirdy]

[4000,10,2,2] is the real size

Answer 3

[Matt J]

If you can re-organize the code that generates b so that, without using permute() , it is instead 2 x m x n x p , that would be ideal. You can then do it all by straight matrix multiplication

result=squeeze( y0.'*reshape(b,2,[]) );