Faut-il éviter <= et> = lors de l'utilisation d'entiers, comme dans une boucle For? [fermé]

J'ai expliqué à mes élèves que le test égal à n'est pas fiable pour les variables flottantes, mais convient pour les entiers. Le manuel que j'utilise dit qu'il est plus facile de lire> et <que> = et <=. Je suis d'accord dans une certaine mesure, mais dans une boucle For? N'est-il pas plus clair que la boucle spécifie les valeurs de début et de fin?

Suis-je en train de manquer quelque chose dont l'auteur du manuel a raison?

Un autre exemple est dans les tests de gamme comme:

si score> 89 grade = 'A'
sinon si score> 79 grade = 'B' ...

Pourquoi ne pas simplement dire: si score> = 90?

Dans les langages de programmation à accolades avec des tableaux à base zéro , il est habituel d'écrire des forboucles comme ceci:

for (int i = 0; i < array.Length, i++) { }

Cela traverse tous les éléments du tableau et est de loin le cas le plus courant. Il évite l'utilisation de <=ou >=.

La seule fois que cela devrait changer, c'est quand vous devez ignorer le premier ou le dernier élément, ou le traverser dans la direction opposée, ou le traverser depuis un point de départ différent ou vers un point d'arrivée différent.

Pour les collections, dans les langues qui prennent en charge les itérateurs, il est plus courant de voir ceci:

foreach (var item in list) { }

Ce qui évite complètement les comparaisons.

Si vous cherchez une règle stricte et rapide quant à l'utilisation de <=vs <, il n'y en a pas; utilisez ce qui exprime le mieux votre intention. Si votre code doit exprimer le concept «inférieur ou égal à 55 miles par heure», il doit dire <=non <.

Répondre à votre question sur les gammes de notes est >= 90plus logique, car 90 est la valeur limite réelle, pas 89.

Ça n'a pas d'importance.

Mais pour le bien de l'argument, nous allons analyser les deux options: a > bvs a >= b.

Attendre! Ce ne sont pas équivalents!
OK, puis a >= b -1vs a > bou a > bvs a >= b +1.

Hm, a >bet les a >= bdeux sont meilleurs que a >= b - 1et a >= b +1. Quels sont tous ces 1s de toute façon? Je dirais donc que tout avantage d'avoir à la >place >=ou vice-versa est éliminé en devant ajouter ou soustraire des 1s aléatoires .

Et si c'est un chiffre? Vaut-il mieux dire a > 7ou a >= 6? Attends une seconde. Sommes-nous sérieusement en train de nous demander s'il est préférable d'utiliser >vs >=et d'ignorer les variables codées en dur? Donc, cela devient vraiment une question de savoir si a > DAYS_OF_WEEKc'est mieux que a >= DAYS_OF_WEEK_MINUS_ONE... ou est-ce a > NUMBER_OF_LEGS_IN_INSECT_PLUS_ONEvs a >= NUMBER_OF_LEGS_IN_INSECT? Et nous revenons à l'ajout / la soustraction de 1s, mais cette fois dans les noms de variables. Ou peut-être débattre s'il est préférable d'utiliser le seuil, la limite, le maximum.

Et il semble qu'il n'y ait pas de règle générale: cela dépend de ce qui est comparé

Mais vraiment, il y a des choses beaucoup plus importantes à améliorer dans son code et des directives beaucoup plus objectives et raisonnables (par exemple, la limite de caractères X par ligne) qui ont encore des exceptions.

Calculativement, il n'y a pas de différence de coût lors de l'utilisation <ou >par rapport à <=ou >=. Il est calculé aussi rapidement.

Cependant, la plupart des boucles compteront à partir de 0 (car de nombreuses langues utilisent l'indexation 0 pour leurs tableaux). Donc, la boucle canonique pour dans ces langues est

for(int i = 0; i < length; i++){
   array[i] = //...
   //...
}

faire cela avec un <=vous obligerait à ajouter un -1 quelque part pour éviter l'erreur off-by one

for(int i = 1; i <= length; i++){
   array[i-1] = //...
   //...
}

ou

for(int i = 0; i <= length-1; i++){
   array[i] = //...
   //...
}

Bien sûr, si le langage utilise une indexation basée sur 1, vous utiliserez <= comme condition limite.

La clé est que les valeurs exprimées dans la condition sont celles de la description du problème. C'est plus propre à lire

if(x >= 10 && x < 20){

} else if(x >= 20 && x < 30){

}

pour un intervalle semi-ouvert que

if(x >= 10 && x <= 19){

} else if(x >= 20 && x <= 29){

}

et doivent faire le calcul pour savoir qu'il n'y a pas de valeur possible entre 19 et 20

Je dirais que le point n'est pas de savoir si vous devez utiliser> ou> =. Le but est d'utiliser tout ce qui vous permet d'écrire du code expressif.

Si vous trouvez que vous devez ajouter / soustraire un, envisagez d'utiliser l'autre opérateur. Je trouve que de bonnes choses se produisent lorsque vous commencez avec un bon modèle de votre domaine. Ensuite, la logique s'écrit.

bool IsSpeeding(int kilometersPerHour)
{
    const int speedLimit = 90;
    return kilometersPerHour > speedLimit;
}

C'est beaucoup plus expressif que

bool IsSpeeding(int kilometersPerHour)
{
    const int speedLimit = 90;
    return kilometersPerHour >= (speedLimit + 1);
}

Dans d'autres cas, l'autre voie est préférable:

bool CanAfford(decimal price, decimal balance)
{
    return balance >= price;
}

Beaucoup mieux que

bool CanAfford(decimal price, decimal balance)
{
    const decimal epsilon = 0e-10m;
    return balance > (price - epsilon);
}

Veuillez excuser "l'obsession primitive". Évidemment, vous voudriez utiliser respectivement un type Velocity et Money, mais je les ai omis pour des raisons de concision. Le point est le suivant: utilisez une version plus concise et qui vous permet de vous concentrer sur le problème commercial que vous souhaitez résoudre.

Comme vous l'avez souligné dans votre question, le test d'égalité sur les variables flottantes n'est pas fiable.

Il en va de même pour <=et >=.

Cependant, il n'y a pas un tel problème de fiabilité pour les types entiers. À mon avis, l'auteur exprimait son opinion sur ce qui est plus lisible.

Que vous soyez d'accord ou non avec lui, c'est bien sûr votre opinion.

Chacune des relations <, <=, >=, >et aussi == et !=ont leur cas d' utilisation pour comparer deux valeurs à virgule flottante. Chacun a un sens spécifique et celui qui convient doit être choisi.

Je vais donner des exemples de cas où vous voulez exactement cet opérateur pour chacun d'eux. (Soyez conscient des NaN, cependant.)

• Vous avez une fonction pure coûteuse fqui prend en entrée une valeur à virgule flottante. Afin d'accélérer vos calculs, vous décidez d'ajouter un cache des valeurs les plus récemment calculées, qui est, un mappage de table de recherche xpour f(x). Vous aurez vraiment besoin d'utiliser ==pour comparer les arguments.
• Vous voulez savoir si vous pouvez vraiment diviser par un certain nombre x? Vous voulez probablement utiliser x != 0.0.
• Vous voulez savoir si une valeur xest dans l'intervalle unitaire? (x >= 0.0) && (x < 1.0)est la bonne condition.
• Vous avez calculé le déterminant dd'une matrice et vous voulez savoir s'il est défini positif? Il n'y a aucune raison d'utiliser autre chose que d > 0.0.
• Vous voulez savoir si Σ _{n = 1,…, ∞} n ^−α diverge? Je testerais alpha <= 1.0.

Les mathématiques à virgule flottante (en général) ne sont pas exactes. Mais cela ne signifie pas que vous devez le craindre, le traiter comme de la magie et certainement pas toujours traiter deux quantités à virgule flottante égales si elles sont à l'intérieur 1.0E-10. Cela cassera vraiment vos calculs et provoquera toutes les choses étranges.

• Par exemple, si vous utilisez une comparaison floue avec le cache mentionné ci-dessus, vous introduirez des erreurs hilarantes. Mais pire encore, la fonction ne sera plus pure et l'erreur dépendra des résultats précédemment calculés!
• Oui, même si x != 0.0et yest une valeur à virgule flottante finie, il y / xn'est pas nécessaire qu'elle soit finie. Mais il pourrait être pertinent de savoir si ce y / xn'est pas fini à cause d'un débordement ou parce que l'opération n'était pas mathématiquement bien définie pour commencer.
• Si vous avez une fonction qui a comme condition préalable qu'un paramètre d'entrée xdoit être dans l'intervalle unitaire [0, 1), je serais vraiment contrarié s'il tirait un échec d'assertion lorsqu'il était appelé avec x == 0.0ou x == 1.0 - 1.0E-14.
• Le déterminant que vous avez calculé n'est peut-être pas précis. Mais si vous allez prétendre que la matrice n'est pas définie positive lorsque le déterminant calculé l'est 1.0E-30, rien n'est gagné. Tout ce que vous avez fait, c'est augmenter la probabilité de donner la mauvaise réponse.
• Oui, votre argument alphapeut être affecté par des erreurs d'arrondi et alpha <= 1.0peut donc être vrai même si la véritable valeur mathématique de l'expression a alphaété calculée à partir de peut-être était vraiment supérieure à 1. Mais vous ne pouvez rien faire à ce stade.

Comme toujours en génie logiciel, traitez les erreurs au niveau approprié et ne les gérez qu'une seule fois. Si vous ajoutez des erreurs d'arrondi dans l'ordre de 1.0E-10(cela semble être la valeur magique que la plupart des gens utilisent, je ne sais pas pourquoi) chaque fois que vous comparez des quantités à virgule flottante, vous serez bientôt en erreur dans l'ordre de 1.0E+10…

Le type de conditionnel utilisé dans une boucle peut limiter les types d'optimisations qu'un compilateur peut effectuer, pour le meilleur ou pour le pire. Par exemple, étant donné:

uint16_t n = ...;
for (uint16_t i=1; i<=n; i++)
  ...  [loop doesn't modify i]

un compilateur pourrait supposer que la condition ci-dessus devrait entraîner la sortie de la boucle après la nième boucle de passage, à moins que n ne puisse 65535 et que la boucle puisse se terminer d'une autre manière que si i dépasse n. Si ces conditions s'appliquent, le compilateur doit générer du code qui entraînerait l'exécution de la boucle jusqu'à ce que quelque chose d'autre que la condition ci-dessus provoque sa fermeture.

Si la boucle avait plutôt été écrite comme suit:

uint16_t n = ...;
for (uint16_t ctr=0; ctr<n; ctr++)
{
  uint16_t i = ctr+1;
  ... [loop doesn't modify ctr]
}

alors un compilateur pourrait supposer en toute sécurité que la boucle n'aurait jamais besoin de s'exécuter plus de n fois et pourrait ainsi générer du code plus efficace.

Notez que tout débordement avec des types signés peut avoir des conséquences désagréables. Donné:

int total=0;
int start,lim,mult; // Initialize values somehow...
for (int i=start; i<=lim; i++)
  total+=i*mult;

Un compilateur pourrait réécrire cela comme:

int total=0;
int start,lim,mult; // Initialize values somehow...
int loop_top = lim*mult;
for (int i=start; i<=loop_top; i+=mult)
  total+=i;

Une telle boucle se comporterait de manière identique à l'original si aucun débordement ne se produit dans les calculs, mais pourrait s'exécuter indéfiniment, même sur les plates-formes matérielles où le débordement d'entier aurait normalement une sémantique d'encapsulation cohérente.