MATLAB Answers

## How do I make a series of variables A1, A2, A3, ... A10?

Asked by Doug Hull

### Doug Hull (view profile)

on 18 Jan 2011
Latest activity Edited by Stephen Cobeldick

### Stephen Cobeldick (view profile)

on 16 Oct 2017
Accepted Answer by Doug Hull

### Doug Hull (view profile)

How do I make variables like this in a loop?

#### 0 Comments

Log in to comment.

## 2 Answers

### Doug Hull (view profile)

Answer by Doug Hull

### Doug Hull (view profile)

on 18 Jan 2011
Accepted Answer

Please don't do this! You will find that MATLAB arrays (either numeric or cell) will let you do the same thing in a much faster, much more readable way. For example, if A1 through A10 contain scalars, use:

```A = zeros(1,10);        % Not necessary, just much faster
for i=1:10
A(i) = % some equation
end
```

Now refer to A(i) whenever you mean Ai. In case each Ai contains a vector or matrix, each with a different size, you want to use cell arrays, which are intended exactly for this:

```for i=1:10
A{i} = 1:i;
end
```

Note that each A{i} contains a different size matrix. And be careful to use the curly braces for the subscript!

Another way to have your cake and eat it too is to use structures instead of cell arrays. The fields of the structure can be the variable names you want. And you can index into them with dynamic field references. For example:

```names = {'fred' 'sam' 'al'};
for ind = 1:length(names)
s.(names{ind}) = magic(length(names{ind}));
end
```

In this case, you end up with the variable s, a structure, containing fields specified by the strings stored in the cell array names.

Now, if you still really want to create variables with dynamically generated names, you need to use EVAL. With EVAL, you use MATLAB commands to generate the string that will perform the operation you intend. For example, eval('A=10') has the same effect as A=10, and eval(['A' 'B' '=10']) has the same effect as AB=10, only the EVAL method executes much more slowly. So in a loop, you could use:

```for i=1:10
eval(sprintf('A%d = [1:i]', i));
end
```

Notice how much more obfuscated this is. In addition, this can cause difficult-to-troubleshoot problems in your code, particularly if you try to dynamically create a variable with the same name as a function:

```function y = mysin(x)
eval('sin = 5;');
y = sin(x);
```

Calling this function with "y = mysin(1)" will not return y = 5 (the first element of the sin variable created by EVAL) -- it will return the sine of 1, because when the function was parsed there was no variable named sin and so the usage of sin on the last line was parsed as a call to the built-in SIN function. The fact that a variable named sin existed at runtime is irrelevant; the parsetime "decision" takes precedence.

Repeat: don't create variables at runtime using EVAL unless you have a very good reason, such as someone gives you a MAT file with 2000 variables named A1428, for example. Even in that case, you can avoid EVAL:

```% Assume the MAT-file example1.mat contains 2000 variables, A1 through A2000
S = load('example1.mat');
% S is now a struct array with 2000 fields, S.A1 through S.A2000.
% To access A1428, use:
x1 = S.A1428;
% If the "index" of the variable you want to access is stored in a variable:
k = 1428;
x2 = S.(sprintf('A%d', k));
x3 = S.(['A', num2str(k)]);
```

[From the MATLAB FAQ of Ancient Times]

#### 4 Comments

Show 1 older comment
Walter Roberson

### Walter Roberson (view profile)

on 30 Dec 2011

You have used mat2cell in the past, http://www.mathworks.com/matlabcentral/answers/23537-converting-a-cell-array-into-numeric-arrays
You could continue to use that, or you could use blockproc() or (if your system is older) blkproc()

You could probably also do it using permute() and reshape()

yasmine

### yasmine (view profile)

on 31 Dec 2011

yes i divided the images already in cell arrays and numeric arrays but now i want to access the first layer of every block (:,:,1) in an iterative manner
i will post a new question with code

Matthew

### Matthew (view profile)

on 19 Jul 2013

Omg thanks so much. The structure did it nicely for me :)

Log in to comment.

### Pedro Inácio (view profile)

Answer by Pedro Inácio

### Pedro Inácio (view profile)

on 14 Oct 2017

Dear all, After read in different threads in Matlab forums, I found different solutions, which I believe they do not provide the real answer to: "Is possible to dynamically change variables names?"

The answer is Yes, and it does not need the use of eval.

I'm posting a solution to solve the question with comments step-by-step (It can be integrated in a for loop).

```% NEW VARIABLE NAME
ID = 'new_NIF';
% FISCAL NUMBER SAVED IN MATLAB WORKSPACE
old_NIF = 555888222;
% CREATE A NEW PROVISORY STUCTURE
provisory_struct.(ID) = old_NIF;
% CREATE A NEW PROVISORY MAT FILE NAME
provisory_file_name = fullfile(pwd,'save_provisory_data.mat');
% SAVE THE PROVISORY STRUCTURE FIELDS AT THE
% PROVISORY MAT FILE
save(provisory_file_name,'-struct','provisory_struct');
% DELETE PROVISORY STRUCTURE VARIABLE
clear('provisory_struct');
% LOAD OUR NEW VARIABLE NAME
load(provisory_file_name,ID);
% DISPLAY NEW VARIABLE CONTENT
fprintf(1,'OLD NIF: %d\nNEW NIF: %d\n',old_NIF,new_NIF);
% DELETE PROVISORY FILE
delete(provisory_file_name);
```

I hope it was helpful.

Image Analyst

### Image Analyst (view profile)

on 14 Oct 2017

I'm not sure how this is different than the solution Doug Hull gave

```x2 = S.(sprintf('A%d', k));
```

and that the FAQ http://matlab.wikia.com/wiki/FAQ#How_can_I_create_variables_A1.2C_A2.2C....2CA10_in_a_loop.3F gives at the end (same as Doug's code) -- they both use dynamic field names, just like you did when you did:

```provisory_struct.(ID) = old_NIF;
```
Stephen Cobeldick

### Stephen Cobeldick (view profile)

on 14 Oct 2017

The function eval is not the problem, no matter how much you think it is.

The problem is creating or accessing dynamically named variables, because doing so causes code to be slow, buggy, obfuscated, hard to debug, insecure, etc, etc.

What you have proposed is a well known solution, and it shares all of the same problems as eval, evalin, assignin, because of what it does: it dynamically creates variables. It does not matter what function you use to magically create variables with, doing so will always cause the same problems. The method that you have proposed is incredibly slow (much slower than eval), because it copies all data from memory onto the drive, and then from the drive back into memory. Totally inefficient, a total waste of time.

You should read Steve Lord's comment on load-ing straight into the workspace:

https://www.mathworks.com/matlabcentral/newsreader/view_thread/244639#628669

A discussion on the disadvantages of loading directly into the workspace:

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

And how it is better to load directly into an output variable:

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

Summary do not magically "poof" variables into existence: Always load into a structure, and never create variable names dynamically.

Jan Simon

### Jan Simon (view profile)

on 14 Oct 2017

@Perdro: Saving the data to a file and relaoding them directly into the workspace has exactly the same drawbacks as eval'ing it directly, but in addition a massive delay due to the slow disk access. Of course, it "works", as eval does also. But it causes more troubles than it solves.

This topic has been discussed frequently and exhaustively in many forums. Your idea, that these discussions "do not provide the real answer", is off track.

Log in to comment.

### Discover what MATLAB® can do for your career.

Opportunities for recent engineering grads.

Apply Today