Câu trả lời của tôi khá dài, vì vậy tôi đã chia nó thành ba phần. Vì câu hỏi là về toán học dấu phẩy động, tôi đã nhấn mạnh vào những gì máy thực sự làm. Tôi cũng đã làm cho nó cụ thể với độ chính xác gấp đôi (64 bit), nhưng đối số áp dụng như nhau cho bất kỳ số học dấu phẩy động nào.
Lời nói đầu
Số định dạng dấu phẩy động nhị phân (binary64) chính xác kép của IEEE 754 đại diện cho một số dạng
giá trị = (-1) ^ s * (1.m 51 m 50 ... m 2 m 1 m 0 ) 2 * 2 e-1023
trong 64 bit:
- Bit đầu tiên là bit dấu :
1nếu số âm, 0nếu không thì 1 .
- 11 bit tiếp theo là số mũ , được bù 1023. Nói cách khác, sau khi đọc các bit số mũ từ một số chính xác kép, 1023 phải được trừ để có được công suất của hai.
- 52 bit còn lại là có ý nghĩa (hoặc mantissa). Trong lớp phủ, một 'hàm ý'
1.luôn bị bỏ qua 2 vì bit quan trọng nhất của bất kỳ giá trị nhị phân nào là 1.
1 - IEEE 754 cho phép khái niệm về số 0 đã ký - +0và -0được đối xử khác nhau: 1 / (+0)là vô cực dương; 1 / (-0)là vô cực âm. Đối với các giá trị 0, các bit mantissa và lũy thừa đều bằng không. Lưu ý: giá trị 0 (+0 và -0) rõ ràng không được phân loại là không bình thường 2 .
2 - Đây không phải là trường hợp cho các số bất thường , có số mũ bù bằng 0 (và ngụ ý 0.). Phạm vi của các số chính xác kép bất thường là d min x | x | Max d max , trong đó d min (số khác không đại diện nhỏ nhất) là 2 -1023 - 51 (≈ 4,94 * 10 -324 ) và d max (số bất thường lớn nhất, trong đó mantissa bao gồm toàn bộ 1s) là 2 -1023 + 1 - 2 -1023 - 51 (≈ 2.225 * 10 -308 ).
Biến một số chính xác kép thành nhị phân
Nhiều bộ chuyển đổi trực tuyến tồn tại để chuyển đổi số dấu phẩy động chính xác kép thành nhị phân (ví dụ tại binaryconvert.com ), nhưng đây là một số mã C # mẫu để có được đại diện của IEEE 754 cho một số chính xác kép (tôi tách ba phần bằng dấu hai chấm ( :) :
public static string BinaryRepresentation(double value)
{
long valueInLongType = BitConverter.DoubleToInt64Bits(value);
string bits = Convert.ToString(valueInLongType, 2);
string leadingZeros = new string('0', 64 - bits.Length);
string binaryRepresentation = leadingZeros + bits;
string sign = binaryRepresentation[0].ToString();
string exponent = binaryRepresentation.Substring(1, 11);
string mantissa = binaryRepresentation.Substring(12);
return string.Format("{0}:{1}:{2}", sign, exponent, mantissa);
}
Đến điểm: câu hỏi ban đầu
(Bỏ qua phía dưới cho phiên bản TL; DR)
Cato Johnston (người hỏi) hỏi tại sao 0,1 + 0,2! = 0,3.
Được viết dưới dạng nhị phân (với các dấu hai chấm phân tách ba phần), các biểu diễn của IEEE 754 của các giá trị là:
0.1 => 0:01111111011:1001100110011001100110011001100110011001100110011010
0.2 => 0:01111111100:1001100110011001100110011001100110011001100110011010
Lưu ý rằng lớp phủ bao gồm các chữ số định kỳ của 0011. Đây là chìa khóa lý do tại sao có bất kỳ lỗi nào đối với các phép tính - 0,1, 0,2 và 0,3 không thể được biểu diễn chính xác trong nhị phân trong một số hữu hạn các bit nhị phân bất kỳ có thể vượt quá 1/9, 1/3 hoặc 1/7 chữ số thập phân .
Cũng lưu ý rằng chúng ta có thể giảm công suất theo số mũ xuống 52 và dịch chuyển điểm trong biểu diễn nhị phân sang phải 52 vị trí (giống như 10 -3 * 1.23 == 10 -5 * 123). Điều này sau đó cho phép chúng ta biểu diễn biểu diễn nhị phân dưới dạng giá trị chính xác mà nó biểu thị dưới dạng * 2 p . trong đó 'a' là một số nguyên.
Chuyển đổi số mũ thành số thập phân, loại bỏ phần bù và thêm lại hàm ý 1(trong ngoặc vuông), 0,1 và 0,2 là:
0.1 => 2^-4 * [1].1001100110011001100110011001100110011001100110011010
0.2 => 2^-3 * [1].1001100110011001100110011001100110011001100110011010
or
0.1 => 2^-56 * 7205759403792794 = 0.1000000000000000055511151231257827021181583404541015625
0.2 => 2^-55 * 7205759403792794 = 0.200000000000000011102230246251565404236316680908203125
Để thêm hai số, số mũ cần phải giống nhau, nghĩa là:
0.1 => 2^-3 * 0.1100110011001100110011001100110011001100110011001101(0)
0.2 => 2^-3 * 1.1001100110011001100110011001100110011001100110011010
sum = 2^-3 * 10.0110011001100110011001100110011001100110011001100111
or
0.1 => 2^-55 * 3602879701896397 = 0.1000000000000000055511151231257827021181583404541015625
0.2 => 2^-55 * 7205759403792794 = 0.200000000000000011102230246251565404236316680908203125
sum = 2^-55 * 10808639105689191 = 0.3000000000000000166533453693773481063544750213623046875
Vì tổng không có dạng 2 n * 1. {bbb}, chúng tôi tăng số mũ lên một và thay đổi điểm thập phân ( nhị phân ) để có được:
sum = 2^-2 * 1.0011001100110011001100110011001100110011001100110011(1)
= 2^-54 * 5404319552844595.5 = 0.3000000000000000166533453693773481063544750213623046875
Hiện tại có 53 bit trong lớp phủ (thứ 53 nằm trong dấu ngoặc vuông ở dòng trên). Chế độ làm tròn mặc định cho IEEE 754 là 'Làm tròn đến gần nhất ' - tức là nếu một số x nằm giữa hai giá trị a và b , thì giá trị trong đó bit có ý nghĩa nhỏ nhất bằng 0 được chọn.
a = 2^-54 * 5404319552844595 = 0.299999999999999988897769753748434595763683319091796875
= 2^-2 * 1.0011001100110011001100110011001100110011001100110011
x = 2^-2 * 1.0011001100110011001100110011001100110011001100110011(1)
b = 2^-2 * 1.0011001100110011001100110011001100110011001100110100
= 2^-54 * 5404319552844596 = 0.3000000000000000444089209850062616169452667236328125
Lưu ý rằng a và b chỉ khác nhau ở bit cuối cùng; ...0011+ 1= ...0100. Trong trường hợp này, giá trị có bit có ý nghĩa nhỏ nhất bằng 0 là b , vì vậy tổng là:
sum = 2^-2 * 1.0011001100110011001100110011001100110011001100110100
= 2^-54 * 5404319552844596 = 0.3000000000000000444089209850062616169452667236328125
trong khi biểu diễn nhị phân của 0,3 là:
0.3 => 2^-2 * 1.0011001100110011001100110011001100110011001100110011
= 2^-54 * 5404319552844595 = 0.299999999999999988897769753748434595763683319091796875
chỉ khác với biểu diễn nhị phân của tổng 0,1 và 0,2 bằng 2 -54 .
Biểu diễn nhị phân 0,1 và 0,2 là biểu diễn chính xác nhất của các số được phép bởi IEEE 754. Việc thêm các biểu diễn này, do chế độ làm tròn mặc định, dẫn đến một giá trị chỉ khác nhau ở bit có ý nghĩa nhỏ nhất.
TL; DR
Viết 0.1 + 0.2một biểu diễn nhị phân của IEEE 754 (với các dấu hai chấm tách ba phần) và so sánh nó với 0.3, đây là (Tôi đã đặt các bit riêng biệt trong dấu ngoặc vuông):
0.1 + 0.2 => 0:01111111101:0011001100110011001100110011001100110011001100110[100]
0.3 => 0:01111111101:0011001100110011001100110011001100110011001100110[011]
Chuyển đổi trở lại thập phân, các giá trị này là:
0.1 + 0.2 => 0.300000000000000044408920985006...
0.3 => 0.299999999999999988897769753748...
Sự khác biệt chính xác là 2 -54 , tức là ~ 5,5511151231258 × 10 -17 - không đáng kể (đối với nhiều ứng dụng) khi so sánh với các giá trị ban đầu.
So sánh một vài bit cuối của số dấu phẩy động vốn đã nguy hiểm, vì bất kỳ ai đọc " Điều mà mọi nhà khoa học máy tính nên biết về Số học dấu phẩy động " (bao gồm tất cả các phần chính của câu trả lời này) sẽ biết.
Hầu hết các máy tính sử dụng các chữ số bảo vệ bổ sung để khắc phục vấn đề này, đó là cách 0.1 + 0.2cung cấp 0.3: một vài bit cuối cùng được làm tròn.
