Utiliser i et j comme variables dans Matlab
i et j sont 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
Comme indices dans la matrice:
mat( i, j ) = 4;
Pourquoi ne devraient-ils pas être utilisés comme noms de variables dans Matlab?
Parce que i et j sont les deux fonctions désignant l'unité imaginaire :
Ainsi, une variable appelée i ou j les remplacera, cassant potentiellement silencieusement du code qui fait des calculs complexes.
Les solutions possibles incluent l'utilisation de ii et jj comme variables de boucle à la place, ou l'utilisation de 1i chaque fois que i est requis pour représenter l'unité imaginaire.
Il est recommandé d'éviter les variables i et j pour éviter qu'elles ne soient des variables ou l'unité imaginaire.
Personnellement, cependant, j'utilise i et j comme variables assez souvent comme index de boucles courtes. Pour éviter les problèmes dans mon propre code, je suis une autre bonne pratique concernant i et j: ne pas utiliser les pour désigner des nombres imaginaires. En fait, la propre documentation de Matlab indique :
Pour accélérer et améliorer la robustesse, vous pouvez remplacer les complexes
ietjpar1i.
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 qu'il représente sqrt(-1) car il ne peut pas être une variable.
Dans les anciennes versions de MATLAB, il y avait une bonne raison d'éviter d'utiliser i et j comme noms de variable - les premières versions de MATLAB JIT n'étaient pas assez intelligentes pour dire si vous étiez les utiliser comme variables ou comme unités imaginaires, et désactiverait donc de nombreuses optimisations autrement possibles.
Votre code deviendrait donc plus lent simplement par la présence même de i et j en tant que variables, et accélérerait si vous les changiez pour autre chose. C'est pourquoi, si vous lisez beaucoup de code MathWorks, vous verrez ii et jj assez largement utilisés comme index 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 mouvante pour chaque version).
Mais c'est il y a assez longtemps, et de nos jours, c'est un peu un problème de "zombie" qui est vraiment beaucoup moins important qu'on ne le pense encore, mais refuse de mourir.
Dans toute version récente, c'est vraiment une préférence personnelle que ce soit d'utiliser i et j comme noms de variable ou non. Si vous travaillez beaucoup avec des nombres complexes, vous voudrez peut-être éviter i et j en tant que variables, pour éviter tout petit risque potentiel de confusion (bien que vous puissiez également/à la place ne vouloir que utilisation 1i ou 1j pour encore moins de confusion et des performances un peu meilleures).
D'un autre côté, dans mon travail typique, je ne traite jamais de nombres complexes et je trouve mon code plus lisible si je me sens libre d'utiliser i et j comme index de boucle.
Je vois beaucoup de réponses ici qui disent Ce n'est pas recommandé ... sans dire qui fait cela en recommandant. Voici l'étendue des recommandations réelles de MathWorks, à partir de la documentation de la version actuelle de 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 variable si vous avez l'intention de les utiliser en arithmétique complexe. [...] Pour plus de rapidité et de robustesse, vous pouvez remplacer les complexes i et j par 1i.
Comme décrit dans d'autres réponses, l'utilisation de i dans le code général n'est pas recommandée pour deux raisons:
- Si vous souhaitez utiliser le nombre imaginaire, il peut être confondu avec ou écrasé par un index
- Si vous l'utilisez comme index, il peut remplacer ou être confondu avec le nombre imaginaire
Comme suggéré: 1i et ii sont recommandés. Cependant, bien qu'il s'agisse de deux déviations fines 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
On ne sera pas facilement mal lu pour deux ou trois, mais deux et trois se ressemblent.
Par conséquent, ma recommandation personnelle serait la suivante: au cas où vous travaillez parfois avec du code complexe, utilisez toujours 1i combiné avec une variable de boucle différente.
Exemples d'index à une seule lettre qui, si vous n'utilisez pas de nombreuses variables et lettres de boucle, suffisent: t, u, k et p
Exemple d'indices plus longs: i_loop, step, walk et t_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 un sens clair sans se développer trop longtemps.
Il a été souligné que 1i Est une manière acceptable et non ambiguë d'écrire sqrt(-1), et qu'en tant que tel, il n'est pas nécessaire d'éviter d'utiliser i. Là encore, comme l'a souligné Dennis ( https://stackoverflow.com/a/14893729/1967396 ), il peut être difficile de voir la différence entre 1i Et ii. Ma suggestion: utilisez 1j Comme constante imaginaire dans la mesure du possible. C'est la même astuce que les ingénieurs électriciens utilisent - ils utilisent j pour sqrt(-1) parce que i est déjà pris pour actuel .
Personnellement, je n'utilise jamais i et j; J'utilise ii et jj comme variables d'indexation abrégées, (et kk, ll, mm, ...) et 1j Lorsque j'ai besoin d'utiliser des nombres complexes.
La confusion avec l'unité imaginaire a été bien couverte ici, mais il existe d'autres raisons plus prosaïques pour lesquelles ces noms de variables à une seule lettre et d'autres sont parfois découragés.
MATLAB en particulier: 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.
Généralement, et selon votre IDE, un nom de variable à une seule lettre peut causer des ravages avec les surligneurs et la recherche/remplacement. MATLAB ne souffre pas de cela 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 conseiller.
Pour ma part, j'évite toutes les variables à une seule lettre, malgré les avantages évidents pour la mise en œuvre directe de sources mathématiques. Cela prend 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 lisez votre code sont légion.
Tout code non trivial contient plusieurs boucles for, et les meilleures pratiques recommandent d'utiliser un nom descriptif indiquant son objectif et sa portée. Depuis des temps immémoriaux (et à moins que son script de 5 à 10 lignes que je ne vais pas enregistrer), j'utilise toujours des noms de variables comme idxTask, idxAnotherTask et idxSubTask etc. .
Ou au moins doubler la première lettre du tableau qu'il indexe, par exemple ss pour indexer subjectList, tt pour indexer taskList, mais pas ii ou jj ce qui n'aide pas moi identifier sans effort quel tableau ils indexent sur mes multiples boucles.
Par défaut, i et j représentent l'unité imaginaire. Donc, du point de vue de MATLAB, utiliser i comme variable est en quelque sorte comme utiliser 1 en tant que variable.
À moins que vous ne soyez un utilisateur très confus, je pense qu'il y a très peu de risques à utiliser des noms de variables i et j et je les utilise régulièrement. Je n'ai vu aucune indication officielle que cette pratique devrait être évitée.
S'il est vrai que l'observation de l'unité imaginaire peut provoquer une certaine confusion dans un certain contexte, comme mentionné dans d'autres articles, dans l'ensemble, je ne vois tout simplement pas cela comme un problème majeur. Il y a des choses beaucoup plus confuses que vous pouvez faire dans MATLAB, prenez par exemple la définition de false=true
À mon avis, la seule fois où vous devriez probablement les éviter est si votre code traite spécifiquement des nombres imaginaires.
Parce que i et j sont par défaut des unités imaginaires. Si vous affectez i et j d'autres valeurs, la valeur par défaut sera remplacée. Cela peut être source de confusion. Cependant, un bon moyen de l'éviter est d'utiliser 1i et 1j comme unités imaginaires. En général, vous pouvez utiliser ni et nj pour représenter des nombres imaginaires.
Par exemple:
>> i
ans =
0.0000 + 1.0000i
>> i=2
i =
2
>> 1i
ans =
0.0000 + 1.0000i