MATLAB: How to efficiently convert from uniquely ordered cell array back to 1-D vector

cell arrayscomplex-valued vectorconversion

I am initially given a very large complex-valued vector cV of a size mx1. Then, I convert this vector into a cell array I call rings. Each row in the cell array represents a unique particular magnitude value (corresponds to complex-valued column entries) sorted in an ascending order. Both the rows of the cell array and the entries in each row (i.e., columns) are sorted in an ascending order. The following code just do this (Thanks to Walter Roberson for his help on accumarray).

[sorted_Vc, ind_sorted_Vc]=sort(cV);
% Magnitude of sorted vector 
abs_sorted_Vc = abs(sorted_Vc);
[tt, tt_a, tt_b] = unique(abs_sorted_Vc);
% rings is a cell array where elements (columns) represent magnitudes in a ascending order
rings = accumarray(tt_b(:), sorted_Vc(:), [], @(x) {x(:)});
% Do the same for the vector indices
ind=accumarray(tt_b(:), ind_sorted_Vc(:), [], @(x) {x(:)});

Besides the sorted rings, this code keeps track of the indices in each element in the cell array and stores them in ind.

My question is, using only rings, and ind, I would like to convert the data back to its original 1-D format and order as given in cV above. What is the most efficient way to do this in Matlab given that I am dealing with very large vector length cV on the order of millions.

Thanks in advance.

Best Answer

why? What is to gain from this?

To extract from a cell:

vertcat(C{:})

or

cell2mat(C)

Related Solutions

MATLAB: Convert complex-valued sorted vector with absolute-value repetitions into a cell array

abs_sorted_Vc = abs(sorted_Vc);
[tt, tt_a, tt_b] = unique(abs_sorted_Vc);
Q = accumarray(tt_b(:), sorted_Vc(:), [], @(x) {length(x); x(:)});

This returns a cell array, each element of which is a column vector, the first element of which is the length of the vector, and the remaining elements are the complex values. The length does not really need to be stored as it can be reconstructed via cellfun(@length,Q) but I decided to leave it in anyhow for illustrative purposes.

The index values found in tt_b could also be stored during the accumarray operation, requiring extra complexity. For example,

Q = accumarray([tt_b(:); tt_b(:)], [tt_b(:); sorted_Vc(:)], [], @(x) {x(:)});

Then the first half of the elements in each cell would be indices and the second half would be corresponding values.

MATLAB: Finding the exact coordinates of the minimum value in a cell array

Unless you have good reasons to use cell arrays, then the simplest answer is to store your data in one numeric array and use the standard MATLAB command min . If the data is of different lengths, you can pad the rows/columns/etc with NaN's, and use nanmin . Both of these will be a million times faster and neater than playing around with cell arrays.

Previous questions you have asked on MATLAB Answers have shown an over-reliance on cell arrays, when using numeric arrays would make your own life so much easier. Cell arrays are not mandatory for MATLAB coding, and MATLAB works best when using vectorized code directly on numeric arrays. Please consider this carefully!

As I understand it, you are wanting to locate the minimum positive value of all numeric arrays that are contained in one cell array, and to know its indices. This is just an exercise in keeping track of indices:

A = num2cell(reshape(randperm(12)-6,[],2),2);
% Indices of positive values:
V = cellfun(@(a)find(a>0), A, 'UniformOutput',false);
% Exclude cells with all(<0):
W = find(~cellfun('isempty',V));
% Locate minimum for each cell, then of all cells:
[X,Y] = cellfun(@(a,v)min(a(v)), A,V, 'UniformOutput',false);
[a1,Z] = min([X{W}]);
% Index of the cell containing the minimum:
x1 = W(Z);
% Index of the minimum in the numeric array in that cell:
c1 = V{x1}(Y{x1});
% The extracted value should be the same as <a1>:
A{x1}(c1)

As you are not very specific about the exact problem, I have assumed that A is a vector, that the minimum positive value occurs only once, and that there is always at least one positive value in at least one numeric array.

Of course doing this with a simple numeric array makes your life much easier, as you could do something like this:

% Merge fake data into one numeric array:
E = vertcat(A{:});
% Locate minimum:
F = find(E>0);
[a2,G] = min(E(F));
[r2,c2] = ind2sub(size(E),F(G));

Note that the indices are the same: c1==c2, x1==r2, and a1==a2.

Related Question