Ví dụ tối thiểu có thể chạy được
Điều đầu tiên bạn phải biết, đó là khái niệm NaN được thực hiện trực tiếp trên phần cứng CPU.
Tất cả các CPU hiện đại chính dường như tuân theo IEEE 754 chỉ định các định dạng dấu chấm động và NaN, chỉ là các giá trị float đặc biệt, là một phần của tiêu chuẩn đó.
Do đó, khái niệm này sẽ rất giống nhau trên bất kỳ ngôn ngữ nào, bao gồm cả Java chỉ phát ra mã dấu phẩy động trực tiếp đến CPU.
Trước khi tiếp tục, trước tiên bạn có thể muốn đọc các câu trả lời tôi đã viết sau đây:
Bây giờ cho một số hành động Java. Hầu hết các chức năng quan tâm không có trong ngôn ngữ cốt lõi đều nằm bên trong 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 ngược dòng .
Chạy với:
javac Nan.java && java -ea Nan
Đầu ra:
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
Vì vậy, từ điều này, chúng tôi học được một số điều:
Các phép toán trôi nổi kỳ lạ không có bất kỳ kết quả hợp lý nào cho NaN:
0.0f / 0.0fsqrt(-1.0f)log(-1.0f)
tạo ra một NaN.
Trong C, thực sự có thể yêu cầu các tín hiệu được nâng lên trên các hoạt động như vậy feenableexceptđể phát hiện chúng, nhưng tôi không nghĩ rằng nó được hiển thị trong Java: Tại sao phép chia số nguyên cho 0 1/0 lại cho lỗi nhưng dấu phẩy động 1 / 0,0 trả về "Inf"?
các phép toán kỳ lạ nằm trong giới hạn của cộng hoặc trừ vô cùng tuy nhiên lại cho + - vô cực thay vì NaN
0.0 gần như thuộc loại này, nhưng có thể vấn đề là nó có thể đi đến cộng hoặc trừ vô cùng, vì vậy nó được để là NaN.
nếu NaN là đầu vào của một hoạt động thả nổi, thì đầu ra cũng có xu hướng là NaN
có một số giá trị có thể cho NaN 0x7fc00000, 0x7fc00001, 0x7fc00002, mặc dù x86_64 dường như chỉ tạo ra 0x7fc00000.
NaN và vô cùng có biểu diễn nhị phân tương tự.
Hãy chia nhỏ một vài trong số chúng:
nan = 0x7fc00000 = 0 11111111 10000000000000000000000
positive_inf = 0x7f800000 = 0 11111111 00000000000000000000000
negative_inf = 0xff800000 = 1 11111111 00000000000000000000000
| | |
| | mantissa
| exponent
|
sign
Từ đó, chúng tôi xác nhận những gì IEEE754 chỉ định:
- cả NaN và số nguyên đều có số mũ == 255 (tất cả các số đều)
- các số nguyên có định trị == 0. Do đó chỉ có hai số nguyên có thể có: + và -, được phân biệt bằng bit dấu
- NaN có phần định trị! = 0. Do đó có một số khả năng xảy ra, ngoại trừ phần định trị == 0 là vô cùng
NaN có thể là tích cực hoặc tiêu cực (bit trên cùng), mặc dù nó không ảnh hưởng đến hoạt động bình thường
Đã thử nghiệm trong Ubuntu 18.10 amd64, OpenJDK 1.8.0_191.