finished translating...

Some words I do think that leave it in English is better than translate it into Vietnamese

Author: nhatnm0612

Diff for: 15.-floating-point-arithmetic-issues-and-limitations.md

@@ -156,80 +156,80 @@ True
 
 ## 15.1. Lỗi sai số
 
-This section explains the “0.1” example in detail, and shows how you can perform an exact analysis of cases like this yourself. Basic familiarity with binary floating-point representation is assumed.
+Đây là phần diễn giải về “0.1” và chỉ ra cho bạn cách làm những trường hợp tương tự. Phần này đòi hỏi những kiến thức cơ bản về số hữu tỉ được biểu diễn dưới dạng phân số nhị phân.
 
-_Representation error_ refers to the fact that some \(most, actually\) decimal fractions cannot be represented exactly as binary \(base 2\) fractions. This is the chief reason why Python \(or Perl, C, C++, Java, Fortran, and many others\) often won’t display the exact decimal number you expect.
+_Lỗi sai số_ dùng để chỉ về vấn đề rằng có một số \(hoặc thực tế là gần hết\) các số hữu tỉ thập phân không thể thể hiện chính xác ở dạng số hữu tỉ nhị phân. Đây là nguyên nhân chính vì sao Python \(hay Perl, C, C++, Java, Fortran, cùng rất nhiều ngôn ngữ lập trình khác\) thường không thể hiện chính xác được con số hữu tỉ mà bạn đang mong muốn.
 
-Why is that? 1/10 is not exactly representable as a binary fraction. Almost all machines today \(November 2000\) use IEEE-754 floating point arithmetic, and almost all platforms map Python floats to IEEE-754 “double precision”. 754 doubles contain 53 bits of precision, so on input the computer strives to convert 0.1 to the closest fraction it can of the form _J_/2\*\*_N_ where _J_ is an integer containing exactly 53 bits. Rewriting
+Vì sao lại thế? 1/10 không được thể hiện chính xác dưới dạng số hữu tỉ nhị phân. Hầu hết tất cả các máy tính ngày nay \(tính đến tháng 11 năm 2000\) sử dụng thuật toán số hữu tỉ IEEE-754, mà hầu hết hệ thống có sử dụng Python đều sử dụng chuẩn IEEE-754 “double precision” cho số hữu tỉ. 754 double precision bao gồm 53 bit thể hiện độ chính xác, và hướng máy tính đạt được con số 0.1 bằng một phân số nhị phân gần nhất dạng _J_/2\*\*_N_ trong đó _J_ là một số tự nhiên được thể hiện chính xác bằng 53 bit. Ta có thể viết:
 
 ```text
 1 / 10 ~= J / (2**N)
 ```
 
-as
+lại là:
 
 ```text
 J ~= 2**N / 10
 ```
 
-and recalling that _J_ has exactly 53 bits \(is `>= 2**52` but `< 2**53`\), the best value for _N_ is 56:&gt;&gt;&gt;
+đừng quên là ta sử dụng chính xác 53 bit để biểu diễn _J_ \(`>= 2**52` nhưng `< 2**53`\), nên giá trị tốt nhất cho _N_ là 56:&gt;&gt;&gt;
 
 ```text
 >>> 2**52 <=  2**56 // 10  < 2**53
 True
 ```
 
-That is, 56 is the only value for _N_ that leaves _J_ with exactly 53 bits. The best possible value for _J_ is then that quotient rounded:&gt;&gt;&gt;
+Thế nên, 56 là giá trị tốt nhất với _N_ để có thể biểu diễn _J_ với chính xác 53 bit. Giá trị tốt nhất cho _J_ được làm tròn:&gt;&gt;&gt;
 
 ```text
 >>> q, r = divmod(2**56, 10)
 >>> r
 6
 ```
 
-Since the remainder is more than half of 10, the best approximation is obtained by rounding up:&gt;&gt;&gt;
+Vì phần dư lớn hơn 5, cách làm tròn tốt nhất là làm tròn lên:&gt;&gt;&gt;
 
 ```text
 >>> q+1
 7205759403792794
 ```
 
-Therefore the best possible approximation to 1/10 in 754 double precision is:
+Vì thế, giá trị gần đúng nhất với 1/10 theo chuẩn 754 double precision là:
 
 ```text
 7205759403792794 / 2 ** 56
 ```
 
-Dividing both the numerator and denominator by two reduces the fraction to:
+Chia cả tử số và mẫu số cho 2 ta có được một phân số:
 
 ```text
 3602879701896397 / 2 ** 55
 ```
 
-Note that since we rounded up, this is actually a little bit larger than 1/10; if we had not rounded up, the quotient would have been a little bit smaller than 1/10. But in no case can it be _exactly_ 1/10!
+Lưu ý là vì chúng ta làm tròn nó, con số này có thể hơi lớn hơn 1/10; nếu ta không làm tròn, con số đó có thể hơi nhỏ hơn 1/10. Nhưng không có cách nào để nó _chính xác_ là 1/10 cả!
 
-So the computer never “sees” 1/10: what it sees is the exact fraction given above, the best 754 double approximation it can get:&gt;&gt;&gt;
+Thế nên máy tính không bao giờ hiểu 1/10: những gì máy tính biết là phân số nhị phân được viết bên trên, giá trị gần đúng nhất mà nó có thể đạt được:&gt;&gt;&gt;
 
 ```text
 >>> 0.1 * 2 ** 55
 3602879701896397.0
 ```
 
-If we multiply that fraction by 10\*\*55, we can see the value out to 55 decimal digits:&gt;&gt;&gt;
+Nếu ta nhân con số trên với 10\*\*55, ta có thể thấy kết quả bao gồm 55 chữ số:&gt;&gt;&gt;
 
 ```text
 >>> 3602879701896397 * 10 ** 55 // 2 ** 55
 1000000000000000055511151231257827021181583404541015625
 ```
 
-meaning that the exact number stored in the computer is equal to the decimal value 0.1000000000000000055511151231257827021181583404541015625. Instead of displaying the full decimal value, many languages \(including older versions of Python\), round the result to 17 significant digits:&gt;&gt;&gt;
+điều này có nghĩa là con số thực tế được máy tính lưu trữ là 0.1000000000000000055511151231257827021181583404541015625. Thay vì việc hiển thị toàn bộ giá trị này, rất nhiều ngôn ngữ lập trình \(bao gồm cả các phiên bản cũ của Python\), làm tròn con số này về một số có 17 chữ số:&gt;&gt;&gt;
 
 ```text
 >>> format(0.1, '.17f')
 '0.10000000000000001'
 ```
 
-The [`fractions`](https://docs.python.org/3/library/fractions.html#module-fractions) and [`decimal`](https://docs.python.org/3/library/decimal.html#module-decimal) modules make these calculations easy:&gt;&gt;&gt;
+Module [`fractions`](https://docs.python.org/3/library/fractions.html#module-fractions) và [`decimal`](https://docs.python.org/3/library/decimal.html#module-decimal) khiến việc tính toán này trở nên dễ dàng hơn:&gt;&gt;&gt;
 
 ```text
 >>> from decimal import Decimal