Sollten <= und> = vermieden werden, wenn Ganzzahlen verwendet werden, z. B. in einer For-Schleife? [geschlossen]

Ich habe meinen Schülern erklärt, dass Gleichheitstests für Float-Variablen nicht zuverlässig sind, aber für ganze Zahlen in Ordnung sind. Das Lehrbuch, das ich benutze, besagt, dass es einfacher ist,> und <als> = und <= zu lesen. Ich stimme einigermaßen zu, aber in einer For-Schleife? Ist es nicht klarer, wenn die Schleife den Start- und den Endwert angibt?

Vermisse ich etwas, worüber der Autor des Lehrbuchs korrekt ist?

Ein weiteres Beispiel sind Reichweitentests wie:

wenn Punktzahl> 89 Note = 'A'
sonst wenn Punktzahl> 79 Note = 'B' ...

Warum nicht einfach sagen: wenn Score> = 90?

In geschweiften Programmiersprachen mit nullbasierten Arrays ist es üblich, forSchleifen wie folgt zu schreiben :

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

Dies durchläuft alle Elemente im Array und ist bei weitem der häufigste Fall. Es vermeidet die Verwendung von <=oder >=.

Dies müsste sich nur ändern, wenn Sie das erste oder letzte Element überspringen oder in die entgegengesetzte Richtung oder von einem anderen Startpunkt zu einem anderen Endpunkt bewegen müssen.

Für Sammlungen in Sprachen, die Iteratoren unterstützen, ist Folgendes üblicher:

foreach (var item in list) { }

Das vermeidet die Vergleiche gänzlich.

Wenn Sie nach einer festen Regel für die Verwendung von <=vs suchen <, gibt es keine. Verwenden Sie, was Ihre Absicht am besten ausdrückt. Wenn Ihr Code das Konzept "Weniger als oder gleich 55 Meilen pro Stunde" ausdrücken muss, <=muss dies nicht heißen <.

Die Beantwortung Ihrer Frage zu den Notenbereichen >= 90ist sinnvoller, da 90 der tatsächliche Grenzwert ist und nicht 89.

Es spielt keine Rolle.

Aber aus Gründen der Argumentation, lassen Sie sich die beiden Optionen analysiert: a > bvs a >= b.

Abwarten! Das sind nicht gleichbedeutend!
OK, dann a >= b -1vs a > boder a > bvs a >= b +1.

Hm, a >bund a >= bbeide sehen besser aus als a >= b - 1und a >= b +1. Was sind das für alles 1? Also würde ich , dass jeder Vorteil argumentieren aus, die >statt >=durch, die addieren oder subtrahieren Zufalls- oder umgekehrt eliminiert 1s.

Aber was ist, wenn es eine Zahl ist? Ist es besser zu sagen a > 7oder a >= 6? Warte eine Sekunde. Überlegen wir ernsthaft, ob es besser ist , die hartcodierten Variablen mit >vs zu vergleichen >=und zu ignorieren? Es wird also wirklich eine Frage, ob a > DAYS_OF_WEEKes besser ist als a >= DAYS_OF_WEEK_MINUS_ONE... oder ob es a > NUMBER_OF_LEGS_IN_INSECT_PLUS_ONEvs ist a >= NUMBER_OF_LEGS_IN_INSECT? Und wir werden wieder 1s addieren / subtrahieren , nur diesmal in Variablennamen. Oder vielleicht darüber nachdenken, ob es am besten ist, Schwelle, Grenze, Maximum zu verwenden.

Und es sieht so aus, als gäbe es keine allgemeine Regel: Es kommt darauf an, was verglichen wird

In der Tat gibt es viel wichtigere Dinge, die im eigenen Code verbessert werden müssen, und viel objektivere und vernünftigere Richtlinien (z. B. Begrenzung der X-Zeichen pro Zeile), für die es noch Ausnahmen gibt.

Rechnerisch gibt es keinen Unterschied in den Kosten bei der Verwendung <oder im >Vergleich zu <=oder >=. Es wird genauso schnell berechnet.

Die meisten for-Schleifen werden jedoch von 0 an gezählt (da viele Sprachen für ihre Arrays die Indexierung 0 verwenden). Die kanonische for-Schleife in diesen Sprachen lautet also

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

Wenn Sie dies mit einem tun, <=müssen Sie irgendwo ein -1 hinzufügen, um den Fehler zu vermeiden, bei dem die Abweichung um eins auftritt

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

oder

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

Wenn die Sprache eine 1-basierte Indizierung verwendet, würden Sie natürlich <= als einschränkende Bedingung verwenden.

Der Schlüssel ist, dass die in der Bedingung ausgedrückten Werte diejenigen aus der Problembeschreibung sind. Es ist sauberer zu lesen

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

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

}

für ein halboffenes Intervall als

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

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

}

und muss rechnen, um zu wissen, dass es keinen möglichen Wert zwischen 19 und 20 gibt

Ich würde sagen, es geht nicht darum, ob Sie> oder> = verwenden sollten. Es geht darum, alles zu verwenden, was Sie zum Schreiben von aussagekräftigem Code benötigen.

Wenn Sie feststellen, dass Sie einen addieren / subtrahieren müssen, sollten Sie den anderen Operator verwenden. Ich finde, dass gute Dinge passieren, wenn Sie mit einem guten Modell Ihrer Domain beginnen. Dann schreibt sich die Logik von selbst.

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

Das ist viel ausdrucksvoller als

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

In anderen Fällen ist der andere Weg vorzuziehen:

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

Viel besser als

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

Bitte entschuldigen Sie die "primitive Besessenheit". Natürlich möchten Sie hier einen Velocity- und einen Money-Typ verwenden, aber der Kürze halber habe ich sie weggelassen. Der Punkt ist: Verwenden Sie eine präzisere Version, mit der Sie sich auf das Geschäftsproblem konzentrieren können, das Sie lösen möchten.

Wie Sie in Ihrer Frage ausgeführt haben, ist das Testen auf Gleichheit mit Float-Variablen nicht zuverlässig.

Gleiches gilt für <=und>= .

Für ganzzahlige Typen gibt es jedoch keine derartigen Zuverlässigkeitsprobleme. Meiner Meinung nach drückte der Autor sie aus Meinung zum , welche lesbarer ist.

Ob Sie ihm zustimmen oder nicht, ist natürlich Ihre Meinung.

Jede der Beziehungen <, <=, >=, >und auch == und !=haben ihre Anwendungsfälle für den Vergleich zweier Gleitkommazahlen. Jedes hat eine bestimmte Bedeutung und die entsprechende sollte ausgewählt werden.

Ich gebe Beispiele für Fälle, in denen Sie genau diesen Operator für jeden von ihnen möchten. (Beachten Sie jedoch die NaNs.)

• Sie haben eine teure reine Funktion f, die einen Gleitkommawert als Eingabe verwendet. Um Ihre Berechnungen zu beschleunigen, fügen Sie einen Cache mit den zuletzt berechneten Werten hinzu, dh eine Zuordnung xzu einer Nachschlagetabelle f(x). Sie wollen wirklich verwenden ==, um die Argumente zu vergleichen.
• Sie möchten wissen, ob Sie durch eine Zahl sinnvoll dividieren können x? Sie möchten wahrscheinlich verwenden x != 0.0.
• Sie möchten wissen, ob ein Wert xim Einheitsintervall liegt? (x >= 0.0) && (x < 1.0)ist der richtige Zustand.
• Sie haben die Determinante deiner Matrix berechnet und möchten feststellen, ob sie eindeutig ist? Es gibt keinen Grund, etwas anderes als zu verwenden d > 0.0.
• Sie möchten wissen, ob Σ _{n = 1,…, ∞} n ^−α divergiert? Ich würde testen alpha <= 1.0.

Gleitkomma-Mathematik (im Allgemeinen) ist nicht genau. Das heißt aber nicht, dass Sie es fürchten, als Magie behandeln und zwei Fließkommazahlen nicht immer gleich behandeln sollten, wenn sie innerhalb liegen 1.0E-10. Wenn Sie dies tun, wird Ihre Mathematik wirklich durchbrochen und es werden alle seltsamen Dinge passieren.

• Wenn Sie zum Beispiel den Fuzzy-Vergleich mit dem oben genannten Cache verwenden, treten urkomische Fehler auf. Schlimmer noch, die Funktion ist nicht mehr rein und der Fehler hängt von den zuvor berechneten Ergebnissen ab!
• Ja, auch wenn x != 0.0und yein endlicher Gleitkommawert ist, y / xmuss er nicht endlich sein. Es kann jedoch von Bedeutung sein, zu wissen, ob y / xdie Operation aufgrund eines Überlaufs nicht endlich ist oder ob sie anfangs mathematisch nicht gut definiert war.
• Wenn Sie eine Funktion haben, die voraussetzt, dass ein Eingabeparameter xim Einheitsintervall [0, 1) liegt, wäre ich wirklich verärgert, wenn er beim Aufruf mit x == 0.0oder einen Assertionsfehler auslösen würde x == 1.0 - 1.0E-14.
• Die von Ihnen berechnete Determinante ist möglicherweise nicht genau. Wenn Sie jedoch so tun, als sei die Matrix nicht positiv bestimmt, wenn die berechnete Determinante ist 1.0E-30, wird nichts gewonnen. Alles, was Sie getan haben, war die Wahrscheinlichkeit zu erhöhen , die falsche Antwort zu geben.
• Ja, Ihr Argument ist alphamöglicherweise von Rundungsfehlern betroffen und daher alpha <= 1.0möglicherweise richtig, obwohl der wahre mathematische Wert für den Ausdruck, aus dem er alphaberechnet wurde, möglicherweise größer als 1 war. Sie können derzeit jedoch möglicherweise nichts dagegen unternehmen.

Behandeln Sie Fehler wie immer in der Softwareentwicklung auf der entsprechenden Ebene und nur einmal. Wenn Sie Rundungsfehler in der Reihenfolge hinzufügen 1.0E-10(dies scheint der magische Wert zu sein, den die meisten Leute verwenden, ich weiß nicht warum), werden Sie bei jedem Vergleich von Gleitkommazahlen bald Fehler in der Reihenfolge von finden 1.0E+10…

Die Art der in einer Schleife verwendeten Bedingung kann die Art der Optimierungen einschränken, die ein Compiler zum Guten oder Schlechten ausführen kann. Zum Beispiel gegeben:

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

Ein Compiler könnte annehmen, dass die obige Bedingung dazu führen sollte, dass die Schleife nach der n-ten Durchgangsschleife beendet wird, es sei denn, n würde 65535 und die Schleife könnte auf eine andere Weise als um i, das n überschreitet, beendet werden. Wenn diese Bedingungen zutreffen, muss der Compiler Code generieren, der dazu führen würde, dass die Schleife ausgeführt wird, bis etwas anderes als die obige Bedingung dazu führt, dass sie beendet wird.

Wenn die Schleife stattdessen wie folgt geschrieben worden wäre:

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

Dann könnte ein Compiler sicher davon ausgehen, dass die Schleife niemals mehr als n-mal ausgeführt werden muss und somit effizienteren Code generieren kann.

Beachten Sie, dass ein Überlauf mit signierten Typen unangenehme Folgen haben kann. Gegeben:

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

Ein Compiler könnte dies folgendermaßen umschreiben:

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;

Eine solche Schleife würde sich identisch zum Original verhalten, wenn in den Berechnungen kein Überlauf auftritt. Sie könnte jedoch auch auf Hardwareplattformen für immer ausgeführt werden, auf denen ein Ganzzahlüberlauf normalerweise eine konsistente Umbruchssemantik aufweist.