Приклад мінімальної експлуатації
Перше, що вам потрібно знати, - це те, що концепція NaN реалізована безпосередньо на апаратному забезпеченні процесора.
Усі основні сучасні процесори, схоже, дотримуються IEEE 754, який визначає формати з плаваючою комою, а NaN, які є лише спеціальними значеннями поплавця, є частиною цього стандарту.
Тому концепція буде дуже схожою на будь-якій мові, включаючи Java, яка просто випромінює код з плаваючою комою безпосередньо в процесор.
Перш ніж продовжувати, ви можете спершу прочитати такі відповіді, які я написав:
Тепер для деяких дій Java. Більшість функцій, що представляють інтерес, не є основними мовами, живуть всередині 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 вище за течією .
Виконати з:
javac Nan.java && java -ea Nan
Вихід:
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
Отже, з цього ми дізнаємось кілька речей:
дивні плаваючі операції, які не мають жодного розумного результату, дають NaN:
0.0f / 0.0fsqrt(-1.0f)log(-1.0f)
генерувати a NaN.
В C, насправді, можна попросити підняти сигнали для таких операцій, feenableexceptщоб виявити їх, але я не думаю, що це піддається впливу в Java: Чому ціле ділення на нуль 1/0 дає помилку, але плаваюча точка 1 / 0,0 повертає "Інф"?
дивні операції, які знаходяться на межі плюс або мінус нескінченності, однак дають + - нескінченність замість NaN
0.0 майже належить до цієї категорії, але, ймовірно, проблема полягає в тому, що вона може перейти до плюс-мінус нескінченності, тому вона залишилася як NaN.
якщо NaN є входом плаваючої операції, вихід також має тенденцію бути NaN
Є кілька можливих значень для NaN 0x7fc00000, 0x7fc00001, 0x7fc00002, хоча x86_64 здається генерувати тільки 0x7fc00000.
NaN і нескінченність мають подібне бінарне представлення.
Розбимо декілька з них:
nan = 0x7fc00000 = 0 11111111 10000000000000000000000
positive_inf = 0x7f800000 = 0 11111111 00000000000000000000000
negative_inf = 0xff800000 = 1 11111111 00000000000000000000000
| | |
| | mantissa
| exponent
|
sign
З цього ми підтверджуємо, що IEEE754 вказує:
- і NaN, і нескінченність мають показник == 255 (усі)
- нескінченності мають мантісу == 0. Тому існує лише дві можливі нескінченності: + і -, диференційовані знаком біта
- NaN має мантісу! = 0. Тому існує кілька можливостей, крім мантіси == 0, що є нескінченним
NaN можуть бути як позитивними, так і негативними (верхній біт), хоча це не впливає на звичайні операції
Тестовано в Ubuntu 18.10 amd64, OpenJDK 1.8.0_191.