An n-by-n square logical matrix can be represented by a cell vector of n elements where the kth element corresponds to the kth row of the matrix. Each element of the cell vector is a row vector of positive integers in increasing order representing th

I don't exactly understand what the question is asking here, despite reading it over and over multiple times. Is the input the nxn matrix, or the cell row vector with logical values? Would this simply contain 0's and 1's? If someone could please explain the overall goal of the question that would be great. Thanks in advance!

[Walter Roberson]

You tried to put the entire question into the title, but the title has a limited length. We are missing important information about what is being asked.

[Image Analyst]

It's saying that if, for some weird reason, you wanted to, you could use a column vector of cells -- a cell array See the FAQ -- where each cell (what they call "element of the cell vector") contains a row vector which is a 1-by-n list of the values in the corresponding row of a regular square logical matrix. But like Walter said, the question about that fact is missing. In other words

logicalMatrix = [false, false, true; false, true, false];

You could have, if you wanted to complicate your life, a cell array like this:

ca = cell(size(logicalMatrix, 1), 1);  % Initialize a column vector of cells.
ca{1} = logicalMatrix(1, :); % element 1 contains row 1 of logicalMatrix 
ca{2} = logicalMatrix(2, :); % element 2 contains row 2 of logicalMatrix

[champions2015]

Sorry about that, didnt realise! This is the complete question:

An n-by-n square logical matrix can be represented by a cell vector of n elements where the kth element corresponds to the kth row of the matrix. Each element of the cell vector is a row vector of positive integers in increasing order representing the column indexes of the logical true values in the given row of the matrix. All other elements in the given row of the logical matrix are false. Write a function called logiunpack that takes such a cell vector as its only input and returns the corresponding square logical matrix. For example, such a cell vector representation of a 100-by-100 logical matrix with the only true elements at indexes (10,20) and (10,75) would have only one non-empty element of the cell vector at index 10. That element is the vector [20 75].

[James Tursa]

What have you done so far? What specific problems are you having with your code?

[Guillaume]

Considering that it can be done with exactly 3 lines of code (1st line: initialise the matrix, 2nd line: repelem the rows indices using a cellfun(@numel), 3rd line: allocate true to the matrix using sub2ind, the row indices from line 2 and the cell array converted to a vector), I have to concur with James: show us what you've done.

Answer 1

[Stephen23]

The question introduces the idea that data can be compressed by storing meta-data about the data: in this case, rather than storing a whole large logical array, the indices of any true elements are stored. There are many possible ways that the indices could be achieved (e.g. linear indexing, row+column indexing, etc), but the question's author decided to encode the logical array by storing only the columns explicitly and the rows implicitly.

As an aside, note that the MATLAB sparse data class does something similar, by storing non-zero locations. It is only efficient if the number of elements being encoded is relatively small.

You can solve your task quite simply:

>> C = cell(1,100);
>> C(10) = [20,75];
>> M = logiunpack(C);
>> [row,col] = find(M)
row =
   10
   10
col =
   20
   75
>>

Where the function is:

function X = logiunpack(C)
X = false(numel(C));
for k = 1:numel(C)
    X(k,C{k}) = true;
end
end

[James Tursa]

this is homework ...

[Paul Murphy]

Can you please explain why this loop accesses the matrix in row major order, instead of column major?

I really struggled with this one. After I established the logical matrix, I then applied the input from each cell to the matrix but it was applied in column major order and i couldnt figure out how to do it in row major as this solution demonstrates.

[Stephen23]

"Can you please explain why this loop accesses the matrix in row major order, instead of column major?"

The code I gave in my answer uses subscript indexing to specify the locations of true in the output matrix:

https://www.mathworks.com/help/matlab/math/matrix-indexing.html

https://www.mathworks.com/company/newsletters/articles/matrix-indexing-in-matlab.html

and so the order is explicitly specified by the sequence of the loop variable which is used as the row subscript index. Note the task was specified by its author so that each cell represents another row of the output matrix, so this code is a trivial interpretation of that.

Also the order of the indices returned by find is totally unrelated to how the matrix was created (i.e. the code that I gave in my answer, or any other possible way that can produce the same matrix). In all cases it returns indices following the order of their linear indices (i.e. down columns first, column major), and this cannot be changed (for that reason transpose is often very convenient).

"...i couldnt figure out how to do it in row major as this solution demonstrates."

There isn't anything to figure out: it is a complete working solution already.

[Paul Murphy]

Thanks Stephen, just trying to pick up some coding in my spare time, can leave one a bit brain dead some days :)

[Paul Murphy]

I wonder if you could off any suggestion on another problem I am having.

The next homework question is the inverse of this one and states: Write a function that takes a square logical matrix as its input argument and returns its cell vector representation as specified in the previous assignment (as states above). Note that empty array elements of the cell vector corresponding to rows with all false values must have a size 0x0. I Have written the following:

 function x = logipack(y)

 Y = transpose(y)

 emptycell = {};

 for i = Y

     emptycell = [emptycell,{transpose(find(i))}]

     x = emptycell

 end

My problem is that my empty array elements are [1x0 double] when I need them to [] (i.e. 0x0). Any suggestions on how I can scan my cell array to locate and change them?

Thanks P.

[Stephen23]

@Paul Murphy: Expanding an array within a loop is usually quite inefficient, and it is highly recommended to preallocate the cell array before the loop, exactly in the same way that you should always preallcoate a numeric array before a loop. Given that you know how big the cell array will be (it has as many cells as the input matrix has rows) this is trivial to do.

Your use of for to loop over the columns of Y is innovative... but personally I would avoid this "feature" as its behavior changes unexpectedly depending on the dimensions of the input array. It would be more robust to specify the row index explicitly.

So with that in mind, all you need is this:

M = false(100);
M(10,[20,75]) = true; % our sample matrix

C = cell(1,size(M,1));
for k = 1:size(M,1)
    C{k} = find(M(k,:));
end

>> C{10}
ans =
   20   75

Note that a 1x0 array is empty according to MATLAB (e.g. when tested by isempty), so this fulfills the specification according to the original question posted above. If you really want to exclude those 1x0 arrays then use a temporary variable and check it:

C = cell(1,size(M,1));
for k = 1:size(M,1)
    tmp = find(M(k,:));
    if tmp % if all values in tmp>0
        C{k} = tmp;
    end
end

[Paul Murphy]

Hi Stephen, thank you for the reply! I am going to take some time to go over this in detail as a lot of my codes are very slow due to inefficient use of loops.

Answer 2

[champions2015]

Thanks Stephen! I applied your code which helped me understand what the function was doing, and what the question was asking! I tried making my own code from there so it's not exactly the same as yours! Thanks again!