Contoh minimal runnable
Hal pertama yang harus Anda ketahui, adalah bahwa konsep NaN diterapkan langsung pada perangkat keras CPU.
Semua CPU modern utama tampaknya mengikuti IEEE 754 yang menentukan format floating point, dan NaN, yang hanya nilai float khusus, adalah bagian dari standar itu.
Oleh karena itu, konsepnya akan sangat mirip di semua bahasa, termasuk Java yang hanya memancarkan kode floating point langsung ke CPU.
Sebelum melanjutkan, Anda mungkin ingin membaca terlebih dahulu jawaban yang saya tulis berikut ini:
Sekarang untuk beberapa tindakan Java. Sebagian besar fungsi minat yang tidak ada dalam bahasa inti ada di dalamnya 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 upstream .
Jalankan dengan:
javac Nan.java && java -ea Nan
Keluaran:
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
Jadi dari sini kita belajar beberapa hal:
operasi mengambang aneh yang tidak memiliki hasil yang masuk akal memberi NaN:
0.0f / 0.0fsqrt(-1.0f)log(-1.0f)
menghasilkan NaN.
Di C, sebenarnya mungkin untuk meminta sinyal untuk dimunculkan pada operasi semacam itu dengan feenableexceptuntuk mendeteksinya, tetapi saya tidak berpikir itu terekspos di Jawa: Mengapa pembagian integer dengan nol 1/0 memberikan kesalahan tetapi floating point 1 / 0.0 mengembalikan "Inf"?
operasi aneh yang berada di batas baik plus atau minus tak terhingga namun memberikan + - tak terhingga, bukan NaN
0.0 hampir termasuk dalam kategori ini, tetapi kemungkinan masalahnya adalah bahwa itu bisa menjadi plus atau minus infinity, jadi itu dibiarkan sebagai NaN.
jika NaN adalah masukan dari operasi mengambang, keluarannya juga cenderung menjadi NaN
ada beberapa nilai yang mungkin untuk NaN 0x7fc00000, 0x7fc00001, 0x7fc00002, meskipun x86_64 tampaknya hanya menghasilkan 0x7fc00000.
NaN dan infinity memiliki representasi biner yang serupa.
Mari kita uraikan beberapa di antaranya:
nan = 0x7fc00000 = 0 11111111 10000000000000000000000
positive_inf = 0x7f800000 = 0 11111111 00000000000000000000000
negative_inf = 0xff800000 = 1 11111111 00000000000000000000000
| | |
| | mantissa
| exponent
|
sign
Dari sini kami mengkonfirmasi apa yang ditentukan IEEE754:
- baik NaN dan infinitas memiliki eksponen == 255 (semua satu)
- infinitas memiliki mantissa == 0. Oleh karena itu hanya ada dua kemungkinan infinitas: + dan -, dibedakan oleh bit tanda
- NaN memiliki mantissa! = 0. Oleh karena itu ada beberapa kemungkinan, kecuali mantissa == 0 yang tak terhingga
NaN dapat berupa positif atau negatif (bit atas), meskipun hal ini tidak berpengaruh pada operasi normal
Diuji di Ubuntu 18.10 amd64, OpenJDK 1.8.0_191.