How to concatenate variables from the workspace with a constant part in their name?

I´d like to find some variables and concatenate their values in a single array. These variables share the start of their name (false_onsets_). Things get complicated because for each subject in my experiment, the variables may or may not exist. So I want to concatenate all variables that exist.

To create the variables (false_onsets_), I use the following code:

if ~isempty(listen_false_index)
      for ii=1:length(listen_false_index)
          false_onsets_lis (1,ii)=onsets{1,1} (1,listen_false_index(ii));
      end
      false_duration_lis=zeros(1,length(listen_false_index));
  end

    if ~isempty(sing_along_false_index)
        for jj=1:length(sing_along_false_index)
            false_onsets_singa(1,jj)=onsets{1,1} (1,sing_along_false_index(jj));
        end
         false_duration_singa=zeros(1,length(sing_along_false_index));
    end
    if ~isempty(sing_memo_false_index)
        for kk=1:length(sing_memo_false_index)
            false_onsets_singm(1,kk)=onsets{1,1} (1,sing_memo_false_index(kk));
        end
        false_duration_singm=zeros(1,length(sing_memo_false_index));
    end
    if ~isempty(baseline_false_index)
        for ll=1:length(baseline_false_index)
            false_onsets_base(1,ll)=onsets{1,1} (1,baseline_false_index(ll));
        end
        false_duration_base=zeros(1,length(baseline_false_index));
    end

I tried using who but this just creates a cell with the names of the variables and not its value.

Any alternative idea for how this could be achieved?

Thank you in advance.

Best, Noelia

[James Tursa]

What is it exactly you want for a result? The false_onsets_singa and false_onsets_singm and false_onsets_base all concatenated together? Vertically or horizontally? Could you maybe give us some pseudo-code to show us exactly what you would like to do, and what variables/results you want to end up with?

Answer 1

[Stephen23]

"Any alternative idea for how this could be achieved?"

Yes: simply avoid getting into the situation where you need to access variable names dynamically. Accessing variable names is slow, complex, buggy, and hard to debug. Beginners access variable names dynamically in order to force themselves into writing slow, complex code. Read this to know why:

https://www.mathworks.com/matlabcentral/answers/304528-tutorial-why-variables-should-not-be-named-dynamically-eval

There are two main ways that beginners want to access variable names dynamically, i.e. how they get lots of variables into the workspace:

1. creating variables in a loop or from user input.
2. loading variables from a .mat file or similar.

You do not describe which of these you used to get that data into the workspace, but I suspect that it you loaded them from a .mat file. If this is the case, then you can trivially load into an output variable (which is a scalar structure) and avoid the whole problem:

S = load(...);
N = fieldnames(S);
idx = strncmp(N,'false_onsets_',13);
for k = find(idx)
    S.(N{k})
end

Or you could load only those variables in the first place by using the optional argument regular expression:

S = load(...,'-regexp','^false_onsets_')

Simpler, neater, more efficient code through better code design: do NOT access variable names dynamically.

[Noelia Martínez]

Thanks Stephen for providing this solution and warning against the use of eval function. I actually created the false_onsets variables with a loop for each participant. As I told you, not all participants have all false_onsets variables. This is how I ended up storing the onsets for the existing false_onsets variables using a structure:

if ~isempty(listen_false_index)
    for ii=1:length(listen_false_index)
        false_onsets_lis (1,ii)=onsets{1,1} (1,listen_false_index(ii));
    end
    false_duration_lis=zeros(1,length(listen_false_index));
    s.false_onsets_lis= false_onsets_lis;
end

if ~isempty(sing_along_false_index)
    for jj=1:length(sing_along_false_index)
        false_onsets_singa(1,jj)=onsets{1,1} (1,sing_along_false_index(jj));
    end
     false_duration_singa=zeros(1,length(sing_along_false_index));
    s.false_onsets_singa=false_onsets_singa;
end
if ~isempty(sing_memo_false_index)
    for kk=1:length(sing_memo_false_index)
        false_onsets_singm(1,kk)=onsets{1,1} (1,sing_memo_false_index(kk));
    end
    false_duration_singm=zeros(1,length(sing_memo_false_index));
    s.false_onsets_singm=false_onsets_singm;
end
if ~isempty(baseline_false_index)
    for ll=1:length(baseline_false_index)
        false_onsets_base(1,ll)=onsets{1,1} (1,baseline_false_index(ll));
    end
    false_duration_base=zeros(1,length(baseline_false_index));
    field='false_onsets_base';
    s.false_onsets_base=false_onsets_base;
end

ss=struct2cell(s);
for i=1:size(ss,1)
ss{i,1}=ss{i,1}';
end
false_onsets_all=vertcat(ss{1:end,1});

Kind regards, Noelia

[Jan]

+1. Thanks, Stephen.

[Stephen23]

@Noelia Martinez: I am glad that you found a solution that works for you. Two other ways of storing data in a similar way, that you might like to have a look at:

• tables: very convenient for lots of participants having the same measured variables, particularly for statistical analyses.
• non-scalar structure: easy to define and access the fields of:

S(1).data = ...
S(1).name = ...
S(2).data = ...
S(2).name = ...

and then, for example, to get all of the names in one cell array:

{S.name}

Non-scalar structures also supported indexing, so you can filter, sort, etc.

Answer 2

[Benjamin Großmann]

You can use the cell returned by the who command and pass it to the "eval" function to get the values of the variables. You could also pass the whole cell through cellfun to eval.

[Benjamin Großmann]

Some Code for explanation....

clearvars, clc

% generate some test data
false_onsets_A = [1:100]';
false_onsets_B = [20:140]';

% search for variables containing *false_onsets*
varNameCell = who('*false_onsets*');
% get data in cell
dataCell = cellfun(@eval,varNameCell,'UniformOutput',false);
% concatenate the cell data in a single array
dataArray = cat(1,dataCell{:});

[Stephen23]

Do NOT follow this answer!

Using eval is how beginners force themselves into writing slow, buggy, complex code that is hard to debug. The MATLAB documentation specifically recommends against what this answer tells you to do: "A frequent use of the eval function is to create sets of variables such as A1, A2, ..., An, but this approach does not use the array processing power of MATLAB and is not recommended. The preferred method is to store related data in a single array"

Source: https://www.mathworks.com/help/matlab/matlab_prog/string-evaluation.html

@Noelia Martínez: Advice to use eval should be ignored, unless you want to learn bad programming habits that force you into writing slow, complex buggy code. There is likely no reason why you need to access variable names dynamically, because it is trivially easy to avoid the situation in the first place: see my answer to know how simple this can be.

[Benjamin Großmann]

I totally agree not use eval to define variables dynamically. But, the problem here seemed to me, that the author of the question has got some mat-files with differently named data. If he is able to recreate the data properly, I would also advice him to do so.

I thought that here, eval is not used to create a set of data, as mentioned in the documentation. It is reading the value of variables and writing them in a cell array. Do you agree?

[Stephen23]

"that the author of the question has got some mat-files with differently named data"

That is what I though too. In which case it is trivial to load those .mat files into output varaibles and avoid the whole problem.

"I thought that here, eval is not used to create a set of data, as mentioned in the documentation..."

The problems of eval, evalin, assignin, load (without an output argument), etc are not specific to just creating variables, but also to accessing them. This is simply inherenet in how the JIT engine works. Regardless of what tool or method, whether creating or accessing, all of them will make code slow, complex, and buggy. If you are not sure why, then read all of the linked threads in my tutorial: the more you understand about the MATLAB JIT engine, the more you will understand why both creating and accessing are equally bad. If you spend a few hours reading those links and still have any question, please ask.

Note to others: Do NOT use eval to solve trivial tasks like this that can be easily avoided using simpler, more efficient code.

[Benjamin Großmann]

Thanks for the explanation. What do you think of using getfield if you process over many mat-files containing arrays with unknown variable names?

S = load('data.mat');
fNames = fieldnames(S);

dataCell = cellfun(@(x) getfield(S,x),fNames,'UniformOutput',false);
dataArray = cat(1,dataCell{:});

[Stephen23]

"What do you think of using getfield if you process over many mat-files containing arrays with unknown variable names?"

It would be simpler and faster to use struct2cell:

S = load(...);
C = struct2cell(S);
...