Bạn đang xem: Floating Point Number Là Gì ? Một Số Dấu Phẩy Động Bất Thường Là Gì Tại DongnaiArt

xác định xem đối số dấu phẩy động đã cho là bình thường, không phải là 0, nhỏ hơn, vô cùng hay nan.

bạn đang xem: số dấu phẩy động là gì

một số bằng 0, vô cùng hoặc nan là điều hiển nhiên. nhưng nó cũng nói về điều huyền bí. khi nào là một con số không xác định?

trong tiêu chuẩn ieee754, số dấu phẩy động được biểu diễn dưới dạng ký hiệu khoa học nhị phân, x = m × 2 e. ở đây m là phần định trị và e là số mũ. về mặt toán học, bạn luôn có thể chọn số mũ sao cho 1 ≤ m e min. những con số này là không bình thường hoặc không bình thường.

Trên thực tế, phần định trị được lưu trữ mà không có số 1 đứng đầu, vì luôn có số 1 đứng đầu, ngoại trừ các số siêu thường (và số không). do đó, cách giải thích là nếu số mũ không nhỏ nhất, thì có một ẩn số nguyên tố là 1, và nếu số mũ nhỏ nhất, thì không có và số là một hàm

*) nói chung là 1 m

kiến ​​thức cơ bản về ieee 754

Trước tiên, hãy xem xét những điều cơ bản về các số IEEE 754 có tổ chức.

Chúng tôi sẽ tập trung vào độ chính xác duy nhất (32 bit), nhưng mọi thứ có thể được tổng quát hóa ngay lập tức cho các phần nhỏ khác.

định dạng là:

hoặc nếu bạn thích hình ảnh:

nguồn.

dấu hiệu rất đơn giản: 0 là tích cực và 1 là tiêu cực, kết thúc câu chuyện.

số mũ dài 8 bit và do đó nằm trong khoảng từ 0 đến 255.

số mũ được cho là bị lệch vì nó có phần bù là -127, ví dụ:

0 == trường hợp đặc biệt: số không hoặc hàm dưới, được giải thích bên dưới 1 == 2 ^ -126 … 125 == 2 ^ -2126 == 2 ^ -1127 == 2 ^ 0128 == 2 ^ 1129 = = 2 ^ 2 … 254 == 2 ^ 127255 == trường hợp đặc biệt: infinity và nan quy ước bit cao

trong khi thiết kế ieee 754, các kỹ sư nhận thấy rằng tất cả các số ngoại trừ số 0,0 đều có số nhị phân 1 là chữ số đầu tiên. ví dụ:

25.0 == (nhị phân) 11001 == 1.1001 * 2 ^ 4 0.625 == (nhị phân) 0.101 == 1.01 * 2 ^ -1 cả hai đều bắt đầu bằng 1. phần khó chịu đó.

vì vậy sẽ rất lãng phí nếu để chữ số đó chiếm một chút độ chính xác trong hầu hết các số.

vì lý do này, họ đã tạo ra “quy ước bit cao”:

luôn giả sử số bắt đầu bằng

nhưng sau đó làm thế nào để đối phó với 0,0? tốt, họ đã quyết định tạo một ngoại lệ:

vì vậy các byte 00 00 00 00 cũng đại diện cho 0,0, có vẻ tốt.

Nếu chúng tôi chỉ xem xét những quy tắc này, số khác 0 nhỏ nhất có thể được biểu diễn sẽ là:

trông giống như thế này dưới dạng phân số thập lục phân do quy ước bit đứng đầu:

1.000002 * 2 ^ (-127) trong đó .000002 là 22 số không có dấu 1.

chúng ta không thể lấy fraction = 0, nếu không số sẽ là 0.0.

nhưng sau đó các kỹ sư, những người cũng có óc thẩm mỹ tuyệt vời, đã nghĩ: điều đó không tệ phải không? mà chúng ta nhảy trực tiếp từ 0,0 đến một thứ gì đó thậm chí không phải là lũy thừa thích hợp của 2? bằng cách nào đó, chúng ta không thể biểu diễn những con số thậm chí còn nhỏ hơn?

số bất thường

Các kỹ sư vò đầu bứt tai một lúc và trở lại, như thường lệ, với một ý tưởng hay khác. điều gì sẽ xảy ra nếu chúng tôi tạo quy tắc mới:

nếu số mũ là 0, thì:

Những con số như vậy được gọi là số siêu thường (hoặc số không bình thường là từ đồng nghĩa).

quy tắc này ngay lập tức ngụ ý rằng một số như vậy:

Xem Thêm : Lỗi 408 Request Timeout là gì? Cách khắc phục lỗi Request Time out

vẫn là 0,0, điều này hơi nhã nhặn vì nó có nghĩa là phải tuân theo một quy tắc ít hơn.

vì vậy 0,0 thực sự là một số siêu thường theo định nghĩa của chúng tôi!

vì vậy, với quy tắc mới này, số không chuẩn nhỏ nhất là:

đại diện:

1,0 * 2 ^ (-126) nên số khối lớn nhất là:

bằng:

0.fffffe * 2 ^ (-126) trong đó .fffffe lại là 23 bit ở bên phải dấu chấm.

con số này khá gần với con số bất thường nhỏ nhất, nghe có vẻ hợp lý.

và số con khác không nhỏ nhất là:

bằng:

0,000002 * 2 ^ (-126) cũng khá gần với 0,0!

Không thể tìm thấy bất kỳ cách hợp lý nào để biểu diễn những con số nhỏ hơn thế, các kỹ sư đã rất vui và quay trở lại xem ảnh những con mèo trên mạng hoặc bất cứ điều gì họ đã làm vào những năm 70.

Như bạn có thể thấy, siêu số thường có sự cân bằng giữa độ chính xác và độ dài biểu diễn.

Như một ví dụ điển hình hơn, hàm con nhỏ nhất là hàm số khác:

0,000002 * 2 ^ (- 126) về cơ bản có độ chính xác là một bit thay vì 32 bit. ví dụ: nếu chúng ta chia nó cho hai:

0,000002 * 2 ^ (-126) / 2, chúng tôi thực sự gần chính xác là 0,0!

tưởng tượng

Bạn nên có trực giác hình học về những gì chúng ta học được, vì vậy hãy tiếp tục.

nếu chúng tôi vẽ biểu đồ 754 số dấu phẩy động trên mỗi dòng cho mỗi số mũ đã cho, nó sẽ giống như sau:

+ – + – + – + – + số mũ | 126 | 127 | 128 | 129 | + – + – + – + – + | | | | | v v v v v v -floats ***** * * * * * * * * * * * * * – ^ ^ ^ ^ | | | | | 0,5 1,0 2,0 4,0 8,0 từ đó chúng ta có thể thấy rằng:

bây giờ chúng ta sẽ giảm nó xuống số mũ 0.

nếu không có kẻ ngốc, theo giả thuyết, nó sẽ trông như thế này:

+ – + – + – + – + – + số mũ | ? | 0 | 1 | 2 | 3 | + – + – + – + – + – + | | | | | | v v v v v v v -floats * **** * * * * * * * * * * * * * – ^ ^ ^ ^ ^ ^ | | | | | | 0 | 2 ^ -126 2 ^ -125 2 ^ -124 2 ^ -123 | 2 ^ -127 với lũ ngu, nó trông như thế này:

+ – + – + – + – + số mũ | 0 | 1 | 2 | 3 | + – + – + – + – + | | | | | v v v v v -floats * * * * * * * * * * * * * * * * * * * – ^ ^ ^ ^ ^ ^ | | | | | | 0 | 2 ^ -126 2 ^ -125 2 ^ -124 2 ^ -123 | 2 ^ -127 So sánh hai biểu đồ, chúng tôi thấy rằng:

các số bổ sung nhân đôi độ dài của dải số mũ 0, từ & lt; 2 ^ -127, 2 ^ -126) đến & lt; 0, 2 ^ -126)

khoảng cách giữa các dấu nổi trong miền công cộng thường giống như cho & lt; 0, 2 ^ -126).

xem thêm: tiếng anh cũng là gì? cũng sử dụng đúng cách

dải ô & lt; 2 ^ -127, 2 ^ -126) có một nửa số điểm mà nó sẽ có nếu không có các phụ tố.

một nửa trong số đó sẽ lấp đầy nửa còn lại của phạm vi.

dải ô & lt; 0, 2 ^ -127) có một số điểm có các chỉ số con, nhưng không có điểm nào không có.

cái này

thiếu điểm & lt; 0, 2 ^ -127) không được thanh lịch cho lắm và là lý do chính khiến những kẻ ngu ngốc tồn tại!

vì các dấu chấm cách đều nhau:

Đây là ý của chúng tôi khi nói rằng subnormals là sự cân bằng giữa kích thước và độ chính xác.

Xem Thêm : Giải nghĩa câu ngạn ngữ: Một lần bất tín, vạn lần bất tin

ví dụ có thể thực thi c

Bây giờ, hãy chơi với một số mã thực để xác minh lý thuyết của chúng tôi.

Trên hầu hết các máy hiện tại và máy tính để bàn, c float đại diện cho các số dấu phẩy động IEEE 754 chính xác một lần.

điều này dành riêng cho máy tính xách tay lenovo p51 chạy ubuntu 18.04 amd64 của tôi.

với giả định đó, tất cả các xác nhận được chuyển đến chương trình sau:

subnormal.c

#if __stdc_version__ #error c11 started # endif # ifndef __stdc_iec_559 __ # ieee error 754 not implement # endif # include #include / * flt_has_subnorm * / # include #include / * is normal * / # include #include #if flt_has_subnorm! = 1 # lỗi float không có số bất thường # endiftypedef struct {uint32_t sign, exponent, fraction;} float32; float32 float32_from_float (float f) {uint32_t byte; float32 float32; byte = * (uint32_t *) & f; float32.fraction = byte & amp; 0x007ffff; byte & gt; & gt; = 23; float32.exponent = byte & amp; 0x000000ff; byte & gt; & gt; = 8; float32.sign = byte & amp; 0x000000001; byte & gt; & gt; = 1; trả về float32;} float float_from_bytes (dấu uint32_t, số mũ uint32_t, phân số uint32_t) {uint32_t byte; byte = 0; byte dấu | =; byte 8; byte | = số mũ; byte 23; byte | = fraction; return * (float *) & amp; byte;} int float32_equal (float f, dấu hiệu uint32_t, số mũ uint32_t, phân số uint32_t) {float32 float32; float32 = float32_from_float (f); return (dấu float32.sign ==) & amp; & amp; (float32.exponent == exponent) & amp; & amp; (float32.fraction == fraction);} void float32_print (float f) {float32 float32 = float32_from_float (f); printf (“%” priu32 “%” priu32 “%” priu32 ” n”, float32.sign, float32.exponent, float32.fraction);} int main (void) {/ * các ví dụ cơ bản. * / khẳng định (float32_equal (0.5f, 0, 126, 0); khẳng định (float32_equal (1.0f, 0, 127, 0); khẳng định (float32_equal (2.0f, 0, 128, 0); khẳng định (là bình thường (0.5 f)); khẳng định (là bình thường (1.0f)); khẳng định (bình thường (2.0f)); / * kiểm tra nhanh các ký tự dấu phẩy động hex c. * / khẳng định (0.5f == 0x1.0p-1f); khẳng định (1.0f == 0x1.0p0f); khẳng định (2.0f == 0x1.0p1f); / * bit dấu. * / khẳng định (float32_equal (-0.5f, 1, 126, 0)); khẳng định (float32_equal (- 1.0f, 1, 127, 0); khẳng định (float32_equal (-2.0f, 1, 128, 0); khẳng định (là bình thường (-0.5f)); khẳng định (là bình thường (-1.0f)); khẳng định (là normal (-2.0f)); / * trường hợp đặc biệt của 0.0 và -0.0. * / khẳng định (float32_equal (0.0f, 0, 0, 0); khẳng định (float32_equal (-0.0f, 1, 0, 0); khẳng định (! là bình thường (0.0f)); khẳng định (! là bình thường (-0.0f)); khẳng định (0.0f == -0.0f); / * ansi c định nghĩa flt_min là số không chuẩn nhỏ nhất. * / khẳng định (flt_min == 0x1.0p-126f); khẳng định (float32_equal (flt_min, 0, 1, 0); khẳng định (là bình thường (flt_min)); / * số subnorm anh ấy lớn nhất. * / float large_subnormal = float_from_bytes (0, 0, 0x7fffff); khẳng định (big_subnormal == 0x0.ffffpep-126f); khẳng định (lớn nhất không bình thường / * số phụ nhỏ nhất khác 0. * / float small_subnormal = float_from_bytes (0, 0, 1); khẳng định (small_subnormal == 0x0.000002p-126f);

biên dịch và chạy với:

gcc -ggdb3 -o0 -std = c11 -wall -wextra -wpedantic -werror -o subnormal.out subnormal.c./subnormal.out<…c++

ngoài việc hiển thị tất cả các c api, c ++ cũng hiển thị một số hàm con liên quan đến các hàm con không có sẵn trong c, ví dụ:

trong c ++, toàn bộ api có một mẫu cho mỗi loại dấu phẩy động và đẹp hơn nhiều.

triển khai

x86_64 và armv8 nhúng ieee 754 trực tiếp vào phần cứng, mã c được dịch sang.

subnormals dường như chậm hơn bình thường trên một số triển khai nhất định – tại sao việc thay đổi 0,1f thành 0 lại làm chậm hiệu suất gấp 10 lần? điều này được đề cập trong hướng dẫn sử dụng cánh tay, hãy xem phần “chi tiết armv8” của câu trả lời này.

chi tiết armv8

Cẩm nang tham khảo kiến ​​trúc cánh tay a1.5.4 armv8 ddi 0487c.a a1.5.4, hướng dẫn sử dụng “zero dump” mô tả chế độ có thể định cấu hình trong đó súng tiểu liên được làm tròn thành 0 để cải thiện hiệu suất:

Hiệu suất xử lý dấu phẩy động có thể giảm khi thực hiện các phép tính liên quan đến các số không chuẩn hóa và các giá trị ngoại lệ lưu lượng thấp. trong nhiều thuật toán, hiệu suất này có thể được phục hồi mà không ảnh hưởng đáng kể đến độ chính xác của kết quả cuối cùng, bằng cách thay thế các toán hạng không chuẩn hóa và kết quả trung gian bằng các số không. Để kích hoạt tính năng tối ưu hóa này, nhánh triển khai dấu phẩy động cho phép sử dụng chế độ zero flush cho các định dạng dấu chấm động khác nhau như sau:

cho aarch64:

nếu fpcr.fz == 1, thì chế độ xả bằng không được sử dụng cho tất cả các I / O chính xác đơn và chính xác kép của tất cả các lệnh.

nếu fpcr.fz16 == 1, thì chế độ cấp 0 được sử dụng cho tất cả các đầu vào và đầu ra nửa chính xác của lệnh dấu phẩy động, ngoại trừ: —chuyển đổi giữa số chính xác nửa và số chính xác đơn. – chuyển đổi giữa số chính xác một nửa và số chính xác kép.

a1.5.2 “Tiêu chuẩn và thuật ngữ dấu chấm động” Bảng a1-3 “Thuật ngữ dấu chấm động” xác nhận rằng ký hiệu con và ký hiệu đồng nghĩa:

sổ tay hướng dẫn này, ieee 754-2008- – & lt; … & gt; bất thường hoặc không chuẩn hóa dưới c5.2.7 “fpcr, thanh ghi điều khiển dấu chấm động” mô tả cách armv8 có thể ném ngoại lệ hoặc đặt các bit cờ mỗi lần đầu vào của hoạt động dấu phẩy động không bình thường:

fpcr.ide, bit & lt; 15 & gt; đầu vào kích hoạt bẫy ngoại lệ dấu chấm động bất thường. các giá trị có thể là:

0b0 xử lý ngoại lệ không được đóng gói đã được chọn. nếu một ngoại lệ dấu chấm động xảy ra, bit fpsr.idc được đặt thành 1.

Đã chọn xử lý ngoại lệ 0b1. nếu một ngoại lệ dấu chấm động xảy ra, ví dụ: không cập nhật bit fpsr.idc. phần mềm xử lý gian lận có thể quyết định có đặt bit fpsr.idc thành 1.

d12.2.88 “mvfr1_el1, aarch32 media and vfp feature register 1” cho thấy rằng hỗ trợ bất thường trên thực tế là hoàn toàn tùy chọn và cung cấp một cách để phát hiện xem có hỗ trợ không:

p>

fpftz, bit

chuyển sang chế độ không. chỉ ra rằng việc triển khai dấu phẩy động chỉ cung cấp hỗ trợ cho chế độ hoạt động zero-flush. giá trị được chỉ định là:

0b0000 không được triển khai hoặc phần cứng chỉ hỗ trợ chế độ hoạt động không tải xuống.

Phần cứng 0b0001 hỗ trợ số học không chuẩn hóa hoàn toàn.

tất cả các giá trị khác đều được bảo lưu.

trong armv8-a, các giá trị được phép là 0b0000 và 0b0001.

Điều này cho thấy rằng khi các toán tử phụ không được triển khai, các triển khai chỉ đơn giản trở về 0.