How to build a function fun that takes as input the matrix A and as output provides the matrix B which is produced out of A in the following ways.
Show older comments
First A, which is of dimension n, is split into four submatrices of dimension n/2 times n/2. Then the sub matrix in the bottom right coner is switched with the submatrix in the top left corner, whereas the submatrix in the bottom left coner is switched with the submatrix in the top right coner. This is the B matrix.
Accepted Answer
Hi Omorodion Solomon,
I understand that you want to build a function that takes matrix A as input and gives matrix B as output , where B is formed after arranging A.
You can solve this as given below:
a=[1 2 3 4;5 6 7 8;9 10 11 12; 13 14 15 16]
n=length(a);
halfn=round(n/2);
a1=a(1:halfn,1:halfn);
a2=a(1:halfn,halfn+1:n);
a3=a(halfn+1:n,1:halfn);
a4=a(halfn+1:n,halfn+1:n);
b=[a4,a3;a2,a1]
More Answers (3)
Dyuman Joshi
on 20 Mar 2023
Edited: Dyuman Joshi
on 20 Mar 2023
A much simpler way -
a=[1 2 3 4;5 6 7 8;9 10 11 12; 13 14 15 16]
s=size(a)/2;
b=circshift(a,s)
5 Comments
John D'Errico
on 20 Mar 2023
Cute. I had never thought about that capability of circshift. And, on a 5kx5k matrix, it is 3 times faster than my solution, which used a block sparse matrix pre and post multiply.
Dyuman Joshi
on 20 Mar 2023
Edited: Dyuman Joshi
on 20 Mar 2023
I read on a thread here that MATLAB is quite efficient with operations involving shifting/moving the elements of matrix around (with that particular comment being about reshape() ) and as it struck to me, I tried a few things out and found this solution.
Though I am pleasantly surprised to know this particular factoid.
"I read on a thread here that MATLAB is quite efficient with operations involving shifting/moving the elements of matrix around (with that particular comment being about reshape() ) and as it struck to me,"
Correction: RESHAPE is very fast precisely because it does not move any data around in memory, it just modifies the very small property header that is attached to the array. That is why RESHAPE specifically is very efficient:
In contrast, all(?) other functions (like CIRCSHIFT) do move data around in memory, which takes (relatively speaking) much more time. So the comment that you read likely only applies to RESHAPE, not to any other function. Moving data around always takes more time than not moving any data around.
Still a very neat answer (which I also voted for).
Dyuman Joshi
on 24 Mar 2023
I remember going through the last thread you linked. Did you find an answer to your question posted as a comment on the same question?
Additionally, Is there any information about how exactly the header works or how the modification happens?
Stephen23
on 24 Mar 2023
"Is there any information about how exactly the header works or how the modification happens? "
I suspect that the behavior and content of the array header is rather proprietary and subject to change. Usually TMW advises to avoid writing code that relies on such implementation details.
With that in mind, you can find a few clues in the MATLAB documentation:
You can probably find more information in the MXARRAY documentation somewhere.
You can use this FEX download,
Example:
>> A=reshape(1:16,4,4), n=length(A)/2;
A =
1 5 9 13
2 6 10 14
3 7 11 15
4 8 12 16
>> B=blkReshape(A,[n,n],1,1,[]);
>> B=blkReshape(B(:,:,[4,3,2,1]),[2,2],[2,2])
B =
11 15 3 7
12 16 4 8
9 13 1 5
10 14 2 6
1 Comment
Omorodion Solomon
on 20 Mar 2023
John D'Errico
on 20 Mar 2023
Edited: John D'Errico
on 20 Mar 2023
Possibly homework. (I never trust simple problems like this, where the goal is simply to move thigns around in a matrix. They are almost always homework assignments.) But you already have two answers, and you have accepted one. So I might as well show the pretty way to solve the problem. You can do it via matrix multiplies. I've built it to perform the swaps using sparse matrices, to make it efficient for large matrices.
The trick is to pre-multiply and post-multiply by a sparsely constructed permutation matrix.
A = reshape(1:16,4,4)'
A = swapblocks(A)
A = rand(5000);
timeit(@() swapblocks(A))
And that seems reasonably fast for a 5kx5k matrix permutation.
Do you see how it works? For the 4x4 mtrix, here is how it works. Constriuct a 4x4 transformation matrix, that looks like this:
T = [zeros(2),eye(2);eye(2),zeros(2)]
See what happens when we multiply T*A.
A = reshape(1:16,4,4)'
T*A
As you can see, that swaps the blocks from top to bottom. Essentially, it swaps the rows to go from [1 2 3 4] to [3 4 1 2]. Next, when we post multiply by T, it swaps the columns, in the same blockwise fashion.
T*A*T
But of course, swapblocks was written to use a sparse matrix T. That maks the matrix multiplies far more efficient when A is large.
function Aswap = swapblocks(A)
% swaps the 4 corner n by n blocks of a 2*n by 2*n matrix from [1 2;3 4] to [4 3;2 1]
% usage: Aswap = swapblocks(A)
%
% arguments:
% A - any 2n x 2n matrix
% what size is A?
[N,M] = size(A);
if (N~=M) || (mod(N,2)==1)
error('A must be a square matrix with an even number of rows and columns')
end
% build the tranform matrix
n = N/2;
T = speye(n);
S = spalloc(n,n,0);
T = [S,T;T,S];
% the transformation is a simple one
Aswap = T*A*T;
end
Anyway, if this was homework, your teacher will never believe you solved it yourself like this.
Categories
Find more on Logical in Help Center and File Exchange
Community Treasure Hunt
Find the treasures in MATLAB Central and discover how the community can help you!
Start Hunting!
