Using i and j as variables in MATLAB

i and j are very popular variable names (see e.g., this question and this one).

For example, in loops:

for i=1:10,
    % Do something...
end

As indices into a matrix:

mat(i, j) = 4;

Why shouldn't they be used as variable names in MATLAB?

Solution 1:

Because i and j are both functions denoting the imaginary unit:

• http://www.mathworks.co.uk/help/matlab/ref/i.html
• http://www.mathworks.co.uk/help/matlab/ref/j.html

So a variable called i or j will override them, potentially silently breaking code that does complex maths.

Possible solutions include using ii and jj as loop variables instead, or using 1i whenever i is required to represent the imaginary unit.

Solution 2:

It is good practice to avoid i and j variables to prevent confusion about them being variables or the imaginary unit.

Personally, however, I use i and j as variables quite often as the index of short loops. To avoid problems in my own code, I follow another good practice regarding i and j: don't use them to denote imaginary numbers. In fact, MATLAB's own documentation states:

For speed and improved robustness, you can replace complex i and j by 1i.

So rather than avoiding two very commonly used variable names because of a potential conflict, I'm explicit about imaginary numbers. It also makes my code more clear. Anytime I see 1i, I know that it represents sqrt(-1) because it could not possibly be a variable.

Solution 3:

In old versions of MATLAB, there used to be a good reason to avoid the use of i and j as variable names - early versions of the MATLAB JIT were not clever enough to tell whether you were using them as variables or as imaginary units, and would therefore turn off many otherwise possible optimizations.

Your code would therefore get slower just by the very presence of i and j as variables, and would speed up if you changed them to something else. That's why, if you read through much MathWorks code, you'll see ii and jj used fairly widely as loop indices. For a while, MathWorks might even have unofficially advised people to do that themselves (although they always officially advise people to program for elegance/maintainability rather than to whatever the current JIT does, as it's a moving target each version).

But that's rather a long time ago, and nowadays it's a bit of a "zombie" issue that is really much less important than many people still think, but refuses to die.

In any recent version, it's really a personal preference whether to use i and j as variable names or not. If you do a lot of work with complex numbers, you may want to avoid i and j as variables, to avoid any small potential risk of confusion (although you may also/instead want to only use 1i or 1j for even less confusion, and a little better performance).

On the other hand, in my typical work I never deal with complex numbers, and I find my code more readable if I feel free to use i and j as loop indices.

I see a lot of answers here that say It is not recommended... without saying who's doing that recommending. Here's the extent of MathWorks' actual recommendations, from the current release documentation for i:

Since i is a function, it can be overridden and used as a variable. However, it is best to avoid using i and j for variable names if you intend to use them in complex arithmetic. [...] For speed and improved robustness, you can replace complex i and j by 1i.

Solution 4:

As described in other answers, the use of i in general code is not recommended for two reasons:

• If you want to use the imaginary number, it can be confused with or overwritten by an index
• If you use it as an index it can overwrite or be confused with the imaginary number

As suggested: 1i and ii are recommended. However, though these are both fine deviations from i, it is not very nice to use both of these alternatives together.

Here is an example why (personally) I don't like it:

val2 = val + i  % 1
val2 = val + ii % 2
val2 = val + 1i % 3

One will not easily be misread for two or three, but two and three resemble each other.

Therefore my personal recommendation would be: In case you sometimes work with complex code, always use 1i combined with a different loop variable.

Examples of single letter indices that for if you don't use many loop variables and letters suffice: t,u,k and p

Example of longer indices: i_loop,step,walk, and t_now

Of course this is a matter of personal taste as well, but it should not be hard to find indices to use that have a clear meaning without growing too long.