Utilisation de i et j comme variables dans Matlab

iet jsont des noms de variables très populaires (voir par exemple cette question et celle-ci ).

Par exemple, en boucles:

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

En tant qu'indices dans la matrice:

mat( i, j ) = 4;

Pourquoi ne devraient- ils pas être utilisés comme noms de variables dans Matlab?

Parce que iet jsont les deux fonctions désignant l' unité imaginaire :

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

Ainsi, une variable appelée iou jles remplacera, cassant potentiellement silencieusement du code qui effectue des calculs complexes.

Les solutions possibles incluent l'utilisation de iiet jjcomme variables de boucle à la place, ou l'utilisation de 1ichaque fois que cela iest nécessaire pour représenter l'unité imaginaire.

Il est recommandé d'éviter les variables iet jd'éviter toute confusion sur le fait qu'elles soient des variables ou l'unité imaginaire.

Personnellement, cependant, j'utilise iet jcomme variables assez souvent comme index des boucles courtes. Pour éviter les problèmes dans mon propre code, je suis une autre bonne pratique concernant iet j: ne les utilisez pas pour désigner des nombres imaginaires. En fait, la propre documentation de Matlab déclare :

Pour une rapidité et une robustesse améliorées, vous pouvez remplacer les complexes iet jpar 1i.

Donc, plutôt que d'éviter deux noms de variables très couramment utilisés en raison d'un conflit potentiel, je suis explicite sur les nombres imaginaires. Cela rend également mon code plus clair. Chaque fois que je vois 1i, je sais que cela représente sqrt(-1)parce qu'il ne pourrait pas être une variable.

Dans les anciennes versions de MATLAB, il y avait une bonne raison d'éviter l'utilisation de iet jcomme noms de variables - les premières versions de MATLAB JIT n'étaient pas assez intelligentes pour dire si vous les utilisiez comme variables ou comme unités imaginaires, et désactiver de nombreuses optimisations autrement possibles.

Votre code deviendrait donc plus lent simplement par la présence même de iet en jtant que variables, et accélérerait si vous les changiez en autre chose. C'est pourquoi, si vous lisez beaucoup de code MathWorks, vous verrez iiet vous l' jjutiliserez assez largement comme indices de boucle. Pendant un certain temps, MathWorks pourrait même avoir officieusement conseillé aux gens de le faire eux-mêmes (bien qu'ils conseillent toujours officiellement aux gens de programmer pour l'élégance / la maintenabilité plutôt que pour tout ce que fait le JIT actuel, car c'est une cible mobile à chaque version).

Mais c'était il y a assez longtemps, et de nos jours c'est un peu un problème de «zombie» qui est vraiment beaucoup moins important que beaucoup de gens ne le pensent encore, mais qui refuse de mourir.

Dans n'importe quelle version récente, c'est vraiment une préférence personnelle d'utiliser iet jcomme noms de variables ou non. Si vous travaillez beaucoup avec des nombres complexes, vous voudrez peut-être éviter iet en jtant que variables, pour éviter tout petit risque potentiel de confusion (bien que vous puissiez également / plutôt vouloir utiliser uniquement 1iou 1jpour encore moins de confusion, et un peu mieux les performances ).

D'un autre côté, dans mon travail typique, je ne m'occupe jamais de nombres complexes, et je trouve mon code plus lisible si je me sens libre d'utiliser iet jcomme index de boucle.

Je vois beaucoup de réponses ici qui disent que ce n'est pas recommandé ... sans dire qui fait cela en recommandant. Voici l'étendue des recommandations réelles de MathWorks, tirées de la documentation de la version actuelle pour i:

Puisque i est une fonction, elle peut être remplacée et utilisée comme variable. Cependant, il est préférable d'éviter d'utiliser i et j pour les noms de variables si vous avez l'intention de les utiliser en arithmétique complexe. [...] Pour plus de rapidité et une meilleure robustesse, vous pouvez remplacer les complexes i et j par 1i.

Comme décrit dans d'autres réponses, l'utilisation du icode en général n'est pas recommandée pour deux raisons:

• Si vous souhaitez utiliser le nombre imaginaire, il peut être confondu ou écrasé par un index
• Si vous l'utilisez comme index, il peut être superposé ou confondu avec le nombre imaginaire

Comme suggéré: 1iet iisont recommandés. Cependant, bien qu'il s'agisse de très bons écarts par rapport à i, il n'est pas très agréable d'utiliser ces deux alternatives ensemble.

Voici un exemple pourquoi (personnellement) je ne l'aime pas:

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

Un ne sera pas facilement mal lu pendant deux ou trois, mais deux et trois se ressemblent.

Par conséquent, ma recommandation personnelle serait: au cas où vous travaillez parfois avec du code complexe, utilisez toujours 1icombiné avec une variable de boucle différente.

Exemples d'indices à une lettre que pour si vous n'utilisez pas beaucoup de variables de boucle et lettres suffisent: t, u, ketp

Exemple d'indices plus: i_loop, step, walkett_now

Bien sûr, c'est aussi une question de goût personnel, mais il ne devrait pas être difficile de trouver des indices à utiliser qui ont une signification claire sans devenir trop longs.

Il a été souligné que 1ic'est une manière d'écrire acceptable et sans ambiguïté sqrt(-1)et qu'en tant que telle, il n'est pas nécessaire d'éviter d'utiliser i. Là encore, comme Dennis l'a souligné ( https://stackoverflow.com/a/14893729/1967396 ), il peut être difficile de voir la différence entre 1iet ii. Ma suggestion: utiliser 1jcomme constante imaginaire si possible. Il est le même tour que les ingénieurs électriciens emploient - ils utilisent jpour sqrt(-1)cause iest déjà pris pour courant .

Personnellement, je n'utilise jamais iet j; J'utilise iiet jjcomme variables d'indexation abrégées, (et kk, ll, mm, ...) et 1jlorsque j'ai besoin d'utiliser des nombres complexes.

La confusion avec l'unité imaginaire a été bien couverte ici, mais il y a d'autres raisons plus prosaïques pour lesquelles ces noms de variables à une seule lettre sont parfois découragés.

1. MATLAB spécifiquement: si vous utilisez un codeur pour générer une source C ++ à partir de votre code MATLAB (ne le faites pas, c'est horrible), vous êtes explicitement averti de ne pas réutiliser les variables en raison de conflits de frappe potentiels.

2. En général, et en fonction de votre IDE, un nom de variable à une seule lettre peut causer des ravages avec les surligneurs et la recherche / remplacement. MATLAB n'en souffre pas et je pense que Visual Studio n'a pas eu de problème depuis un certain temps, mais les normes de codage C / C ++ comme MISRA etc. ont tendance à les déconseiller.

Pour ma part, j'évite toutes les variables à une seule lettre, malgré les avantages évidents à implémenter directement des sources mathématiques. Cela demande un peu d'effort supplémentaire les premières centaines de fois que vous le faites, mais après cela, vous arrêtez de le remarquer, et les avantages lorsque vous ou une autre pauvre âme venez lire votre code sont légion.

Tout code non trivial contient plusieurs forboucles, et les meilleures pratiques vous recommandent d'utiliser un nom descriptif indiquant son objectif et sa portée. Pour des temps immémoriaux (et à moins que son script 5-10 lignes que je ne vais pas sauver), je l' ai toujours été en utilisant des noms de variables comme idxTask, idxAnotherTasket idxSubTasketc.

Ou au moins doubler la première lettre du tableau qu'il indexe, par exemple sspour indexer subjectList, ttindexer taskList, mais pas iiou jjqui ne m'aide pas à identifier sans effort le tableau qu'ils indexent parmi mes multiples boucles for.

Par défaut iet jreprésente l'unité imaginaire. Donc, du point de vue de MATLAB, utiliser icomme variable équivaut en quelque sorte à utiliser 1comme variable.

Sauf si vous êtes un utilisateur très confus, je pense qu'il y a très peu de risque à utiliser les noms de variables i et j et je les utilise régulièrement. Je n'ai vu aucune indication officielle selon laquelle cette pratique devrait être évitée.

S'il est vrai que l'observation de l'unité imaginaire pourrait causer une certaine confusion dans certains contextes, comme mentionné dans d'autres articles, dans l'ensemble, je ne le vois tout simplement pas comme un problème majeur. Il y a des choses beaucoup plus déroutantes que vous pouvez faire dans MATLAB, prenez par exemple la définitionfalse=true

À mon avis, le seul moment où vous devriez probablement les éviter est si votre code traite spécifiquement des nombres imaginaires.