Minimal lauffähiges Beispiel
Das erste, was Sie wissen müssen, ist, dass das Konzept von NaN direkt auf der CPU-Hardware implementiert ist.
Alle wichtigen modernen CPUs scheinen IEEE 754 zu folgen, das Gleitkommaformate spezifiziert, und NaNs, die nur spezielle Gleitkommawerte sind, sind Teil dieses Standards.
Daher ist das Konzept in jeder Sprache sehr ähnlich, einschließlich Java, das nur Gleitkomma-Code direkt an die CPU ausgibt.
Bevor Sie fortfahren, sollten Sie zunächst die folgenden Antworten lesen, die ich geschrieben habe:
Nun zu einer Java-Aktion. Die meisten Funktionen von Interesse, die nicht in der Kernsprache enthalten sind, leben im Inneren java.lang.Float.
Nan.java
import java.lang.Float;
import java.lang.Math;
public class Nan {
public static void main(String[] args) {
// Generate some NaNs.
float nan = Float.NaN;
float zero_div_zero = 0.0f / 0.0f;
float sqrt_negative = (float)Math.sqrt(-1.0);
float log_negative = (float)Math.log(-1.0);
float inf_minus_inf = Float.POSITIVE_INFINITY - Float.POSITIVE_INFINITY;
float inf_times_zero = Float.POSITIVE_INFINITY * 0.0f;
float quiet_nan1 = Float.intBitsToFloat(0x7fc00001);
float quiet_nan2 = Float.intBitsToFloat(0x7fc00002);
float signaling_nan1 = Float.intBitsToFloat(0x7fa00001);
float signaling_nan2 = Float.intBitsToFloat(0x7fa00002);
float nan_minus = -nan;
// Generate some infinities.
float positive_inf = Float.POSITIVE_INFINITY;
float negative_inf = Float.NEGATIVE_INFINITY;
float one_div_zero = 1.0f / 0.0f;
float log_zero = (float)Math.log(0.0);
// Double check that they are actually NaNs.
assert Float.isNaN(nan);
assert Float.isNaN(zero_div_zero);
assert Float.isNaN(sqrt_negative);
assert Float.isNaN(inf_minus_inf);
assert Float.isNaN(inf_times_zero);
assert Float.isNaN(quiet_nan1);
assert Float.isNaN(quiet_nan2);
assert Float.isNaN(signaling_nan1);
assert Float.isNaN(signaling_nan2);
assert Float.isNaN(nan_minus);
assert Float.isNaN(log_negative);
// Double check that they are infinities.
assert Float.isInfinite(positive_inf);
assert Float.isInfinite(negative_inf);
assert !Float.isNaN(positive_inf);
assert !Float.isNaN(negative_inf);
assert one_div_zero == positive_inf;
assert log_zero == negative_inf;
// Double check infinities.
// See what they look like.
System.out.printf("nan 0x%08x %f\n", Float.floatToRawIntBits(nan ), nan );
System.out.printf("zero_div_zero 0x%08x %f\n", Float.floatToRawIntBits(zero_div_zero ), zero_div_zero );
System.out.printf("sqrt_negative 0x%08x %f\n", Float.floatToRawIntBits(sqrt_negative ), sqrt_negative );
System.out.printf("log_negative 0x%08x %f\n", Float.floatToRawIntBits(log_negative ), log_negative );
System.out.printf("inf_minus_inf 0x%08x %f\n", Float.floatToRawIntBits(inf_minus_inf ), inf_minus_inf );
System.out.printf("inf_times_zero 0x%08x %f\n", Float.floatToRawIntBits(inf_times_zero), inf_times_zero);
System.out.printf("quiet_nan1 0x%08x %f\n", Float.floatToRawIntBits(quiet_nan1 ), quiet_nan1 );
System.out.printf("quiet_nan2 0x%08x %f\n", Float.floatToRawIntBits(quiet_nan2 ), quiet_nan2 );
System.out.printf("signaling_nan1 0x%08x %f\n", Float.floatToRawIntBits(signaling_nan1), signaling_nan1);
System.out.printf("signaling_nan2 0x%08x %f\n", Float.floatToRawIntBits(signaling_nan2), signaling_nan2);
System.out.printf("nan_minus 0x%08x %f\n", Float.floatToRawIntBits(nan_minus ), nan_minus );
System.out.printf("positive_inf 0x%08x %f\n", Float.floatToRawIntBits(positive_inf ), positive_inf );
System.out.printf("negative_inf 0x%08x %f\n", Float.floatToRawIntBits(negative_inf ), negative_inf );
System.out.printf("one_div_zero 0x%08x %f\n", Float.floatToRawIntBits(one_div_zero ), one_div_zero );
System.out.printf("log_zero 0x%08x %f\n", Float.floatToRawIntBits(log_zero ), log_zero );
// NaN comparisons always fail.
// Therefore, all tests that we will do afterwards will be just isNaN.
assert !(1.0f < nan);
assert !(1.0f == nan);
assert !(1.0f > nan);
assert !(nan == nan);
// NaN propagate through most operations.
assert Float.isNaN(nan + 1.0f);
assert Float.isNaN(1.0f + nan);
assert Float.isNaN(nan + nan);
assert Float.isNaN(nan / 1.0f);
assert Float.isNaN(1.0f / nan);
assert Float.isNaN((float)Math.sqrt((double)nan));
}
}
GitHub stromaufwärts .
Laufen Sie mit:
javac Nan.java && java -ea Nan
Ausgabe:
nan 0x7fc00000 NaN
zero_div_zero 0x7fc00000 NaN
sqrt_negative 0xffc00000 NaN
log_negative 0xffc00000 NaN
inf_minus_inf 0x7fc00000 NaN
inf_times_zero 0x7fc00000 NaN
quiet_nan1 0x7fc00001 NaN
quiet_nan2 0x7fc00002 NaN
signaling_nan1 0x7fa00001 NaN
signaling_nan2 0x7fa00002 NaN
nan_minus 0xffc00000 NaN
positive_inf 0x7f800000 Infinity
negative_inf 0xff800000 -Infinity
one_div_zero 0x7f800000 Infinity
log_zero 0xff800000 -Infinity
Daraus lernen wir ein paar Dinge:
seltsame schwebende Operationen, die kein vernünftiges Ergebnis haben, geben NaN:
0.0f / 0.0fsqrt(-1.0f)log(-1.0f)
generieren a NaN.
In C ist es tatsächlich möglich, Signale anzufordern, die bei solchen Operationen feenableexceptausgelöst werden sollen, um sie zu erkennen, aber ich glaube nicht, dass sie in Java verfügbar sind: Warum ergibt die Ganzzahldivision durch Null 1/0 einen Fehler, aber einen Gleitkomma-Wert von 1/0 gibt "Inf" zurück?
Seltsame Operationen, die an der Grenze von plus oder minus unendlich liegen, ergeben jedoch + - unendlich anstelle von NaN
0.0 fällt fast in diese Kategorie, aber wahrscheinlich ist das Problem, dass es entweder auf plus oder minus unendlich gehen könnte, so dass es als NaN belassen wurde.
Wenn NaN der Eingang einer Floating-Operation ist, ist der Ausgang tendenziell auch NaN
mehrere mögliche Werte für NaN gibt es 0x7fc00000, 0x7fc00001, 0x7fc00002, obwohl x86_64 scheint nur dann zu erzeugen 0x7fc00000.
NaN und unendlich haben eine ähnliche binäre Darstellung.
Lassen Sie uns einige davon aufschlüsseln:
nan = 0x7fc00000 = 0 11111111 10000000000000000000000
positive_inf = 0x7f800000 = 0 11111111 00000000000000000000000
negative_inf = 0xff800000 = 1 11111111 00000000000000000000000
| | |
| | mantissa
| exponent
|
sign
Daraus bestätigen wir, was IEEE754 spezifiziert:
- Sowohl NaN als auch Unendlichkeiten haben Exponenten == 255 (alle)
- Unendlichkeiten haben Mantisse == 0. Es gibt daher nur zwei mögliche Unendlichkeiten: + und -, unterschieden durch das Vorzeichenbit
- NaN hat Mantisse! = 0. Es gibt daher mehrere Möglichkeiten, außer Mantisse == 0, die unendlich ist
NaNs können entweder positiv oder negativ sein (oberes Bit), obwohl dies keinen Einfluss auf den normalen Betrieb hat
Getestet in Ubuntu 18.10 amd64, OpenJDK 1.8.0_191.