aturan bilangan pecahan

Direct3D mendukung beberapa representasi floating-point. Semua komputasi floating-point dilakukan sesuai dengan subset yang telah ditentukan oleh aturan floating-point presisi tunggal 32-bit IEEE 754.

aturan 32-bit floating-point

Ada dua set aturan: yang sesuai dengan IEEE-754, dan yang menyimpang dari standar.

mengikuti aturan IEEE-754

Beberapa aturan ini adalah satu opsi di mana IEEE-754 menawarkan pilihan.

  • Dibagi dengan 0 menghasilkan +/- INF, kecuali 0/0 yang menghasilkan NaN.

  • Logaritma (+/-) 0 hasilnya adalah -INF.  

    logaritma dari nilai negatif (selain nilai -0) menghasilkan NaN.

  • Akar kuadrat timbal balik (rsq) atau akar kuadrat (sqrt) dari angka negatif akan menghasilkan NaN.  

    Pengecualiannya adalah -0; sqrt(-0) menghasilkan -0, dan rsq(-0) menghasilkan -INF.

  • INF - INF = NaN

  • (+/-)INF / (+/-)INF = NaN

  • (+/-)INF * 0 = NaN

  • NaN (OP apa pun) nilai apa pun = NaN

  • Perbandingan EQ, GT, GE, LT, dan LE, ketika satu atau kedua operan merupakan NaN, akan mengembalikan FALSE.

  • Perbandingan mengabaikan tanda 0 (sehingga +0 sama dengan -0).

  • Perbandingan NE, ketika salah satu atau kedua operan adalah NaN, mengembalikan TRUE.

  • Perbandingan nilai non-NaN terhadap +/- INF mengembalikan hasil yang benar.

Penyimpangan atau persyaratan tambahan dari aturan IEEE-754

  • IEEE-754 memerlukan operasi floating-point untuk menghasilkan hasil yang merupakan nilai terdekat yang dapat diwakili dengan hasil yang memiliki ketelitian tak terbatas, yang dikenal sebagai pembulatan ke genap terdekat.

    Direct3D 11 dan versi lebih baru menentukan persyaratan yang sama dengan IEEE-754: operasi floating-point 32-bit menghasilkan hasil yang berada dalam 0,5 unit-ke-tempat terakhir (ULP) dari hasil yang sangat presisi. Ini berarti bahwa, misalnya, perangkat keras diizinkan untuk memotong hasil menjadi 32-bit daripada melakukan round-to-nearest-even, karena akan mengakibatkan kesalahan paling banyak 0,5 ULP. Aturan ini hanya berlaku untuk penambahan, pengurangan, dan perkalian.

    Versi Direct3D yang lebih lama menentukan persyaratan yang lebih longgar daripada IEEE-754: operasi floating-point 32-bit menghasilkan hasil yang berada dalam satu unit terakhir (1 ULP) dari hasil yang tepat tak terhingga. Ini berarti bahwa, misalnya, perangkat keras diizinkan untuk memotong hasil menjadi 32-bit daripada melakukan round-to-nearest-even, karena itu akan mengakibatkan kesalahan paling banyak satu ULP.

  • Tidak ada dukungan untuk pengecualian floating-point, bit status, atau perangkap.

  • Angka denormal diubah menjadi nol dengan mempertahankan tanda pada input dan output dari setiap operasi matematika floating-point. Pengecualian dibuat untuk setiap I/O atau operasi pergerakan data yang tidak memanipulasi data.

  • Status yang berisi nilai floating-point, seperti nilai Viewport MinDepth/MaxDepth atau BorderColor, dapat disediakan sebagai nilai denorm dan mungkin atau mungkin tidak dihapus sebelum perangkat keras menggunakannya.

  • Operasi min atau maks membersihkan bilangan denormal untuk perbandingan, tetapi hasilnya mungkin atau mungkin tidak dibersihkan dari bilangan denormal.

  • Input NaN ke operasi selalu menghasilkan NaN pada output. Tetapi pola bit yang tepat dari NaN tidak harus tetap sama (kecuali operasinya adalah instruksi pemindahan langsung - yang tidak mengubah data.)

  • Operasi minimum atau maksimum yang hanya memiliki satu operand sebagai NaN akan mengembalikan operand lainnya sebagai hasilnya (bertentangan dengan aturan perbandingan yang kita lihat sebelumnya). Ini adalah aturan IEEE 754R.

    Spesifikasi IEEE-754R untuk operasi floating point min dan max menyatakan bahwa jika salah satu input ke min atau maks adalah nilai QNaN yang tenang, hasil operasi adalah parameter lainnya. Contohnya:

    min(x,QNaN) == min(QNaN,x) == x (same for max)

    Revisi spesifikasi IEEE-754R mengadopsi perilaku yang berbeda untuk fungsi min dan max ketika satu input adalah nilai SNaN "sinyal" dibandingkan dengan nilai QNaN.

    min(x,SNaN) == min(SNaN,x) == QNaN (same for max)

    Umumnya, Direct3D mengikuti standar untuk aritmatika: IEEE-754 dan IEEE-754R. Tapi dalam hal ini, kita memiliki penyimpangan.

    Aturan aritmatika dalam Direct3D 10 dan yang lebih baru tidak membuat perbedaan antara nilai NaN yang tenang dan memberi sinyal (QNaN versus SNaN). Semua nilai NaN ditangani dengan cara yang sama. Dalam kasus min dan maks, perilaku Direct3D untuk nilai NaN apa pun seperti bagaimana QNaN ditangani dalam definisi IEEE-754R. (Untuk kelengkapan - jika kedua input adalah NaN, nilai NaN apa pun dikembalikan.)

  • Aturan IEEE 754R lainnya adalah min(-0,+0) == min(+0,-0) == -0, dan max(-0,+0) == max(+0,-0) == +0, yang menghormati tanda, berbeda dengan aturan perbandingan untuk nol yang ditandatangani (seperti yang kita lihat sebelumnya). Direct3D merekomendasikan perilaku IEEE 754R di sini, tetapi tidak memberlakukannya; diizinkan untuk hasil perbandingan nol yang bergantung pada urutan parameter, menggunakan perbandingan yang mengabaikan tanda.

  • x*1.0f selalu menghasilkan x (kecuali jika denormal dibuang).

  • x/1.0f selalu menghasilkan x (kecuali denorm yang dibersihkan).

  • x +/- 0,0f selalu menghasilkan x (kecuali denormal dikonversi ke nol). Namun -0 + 0 = +0.

  • Operasi gabungan (seperti mad, dp3) menghasilkan hasil yang tidak kurang akurat dibandingkan dengan urutan evaluasi serial terburuk dari pengembangan yang tidak digabung dari operasi tersebut. Definisi pengurutan terburuk yang mungkin terjadi, untuk keperluan toleransi, bukanlah definisi tetap untuk operasi kombinasi tertentu; hal ini tergantung pada nilai spesifik dari input. Langkah-langkah individu dalam ekspansi yang tidak disatukan masing-masing diberikan toleransi 1 ULP (atau untuk instruksi mana pun yang dipanggil Direct3D dengan toleransi yang lebih laks daripada 1 ULP, toleransi yang lebih laks tersebut diperbolehkan).

  • Operasi terfusi mengikuti aturan NaN yang sama seperti operasi yang tidak terfusi.

  • sqrt dan rcp memiliki toleransi 1 ULP. Instruksi timbal balik dan akar kuadrat terbalik, rcp dan rsq, memiliki persyaratan presisi relaksasi yang terpisah dan spesifik.

  • Operasi perkalian dan pembagian masing-masing dilakukan pada tingkat presisi floating-point 32-bit (akurasi hingga 0,5 ULP untuk mengalikan, 1,0 ULP untuk pembagian). Jika x/y diimplementasikan secara langsung, hasil harus lebih besar atau sama akurasinya daripada metode dua langkah.

Aturan titik mengambang 64-bit (presisi ganda)

Driver perangkat keras dan tampilan mendukung floating-point presisi ganda secara opsional. Untuk menunjukkan dukungan, ketika Anda memanggil ID3D11Device::CheckFeatureSupport dengan D3D11_FEATURE_DOUBLES, driver akan mengatur DoublePrecisionFloatShaderOps dari D3D11_FEATURE_DATA_DOUBLES ke TRUE. Driver dan perangkat keras perlu mendukung semua instruksi floating-point dengan presisi ganda.

Instruksi presisi ganda mengikuti persyaratan perilaku IEEE 754R.

Dukungan untuk pembuatan nilai denormalisasi diperlukan untuk data presisi ganda (tanpa perilaku flush-to-zero). Demikian juga, instruksi tidak membaca data denormalisasi sebagai nol bertanda, melainkan menghormati nilai denorm.

aturan floating-point 16-bit

Direct3D juga mendukung representasi angka floating-point 16-bit.

Format (tata letak):

  • 1 bit tanda (s) pada posisi bit MSB
  • 5 bits eksponen yang bias (e)
  • 10 bit pecahan (f), dengan tambahan bit tersembunyi

Nilai float16 (v) mengikuti aturan berikut:

  • jika e == 31 dan f != 0, maka v adalah NaN terlepas dari s
  • jika e == 31 dan f == 0, maka v = (-1)s*infinity (tak terbatas yang ditandatangani)
  • jika e adalah antara 0 dan 31, maka v = (-1)s*2(e-15)*(1.f)
  • jika e == 0 dan f != 0, maka v = (-1)s*2(e-14)*(0.f) (angka denormalisasi)
  • jika e == 0 dan f == 0, maka v = (-1)s*0 (nol bertanda)

Aturan floating-point 32-bit juga berlaku untuk angka floating-point 16-bit, disesuaikan untuk tata letak bit yang telah dijelaskan sebelumnya. Pengecualian untuk ini meliputi:

  • Presisi: Operasi yang tidak digabungkan pada angka floating-point 16-bit menghasilkan nilai yang dapat diwakili terdekat dengan hasil yang berpresisi tak terhingga (dibulatkan ke terdekat genap, sesuai standar IEEE-754, diterapkan pada nilai 16-bit). Aturan floating-point 32-bit mematuhi toleransi 1 ULP, aturan floating-point 16-bit mematuhi 0.5 ULP untuk operasi yang tidak menyatu, dan 0.6 ULP untuk operasi yang menyatu.
  • Angka titik mengambang 16-bit mempertahankan nilai tak normal.

aturan 11-bit dan 10-bit floating-point

Direct3D juga mendukung format floating-point 11-bit dan 10-bit.

Format (tata letak):

  • Tidak ada bit tanda
  • 5 bits eksponen yang bias (e)
  • 6 bit pecahan (f) untuk format 11-bit, 5 bit pecahan (f) untuk format 10-bit, dengan bit tersembunyi tambahan dalam kedua kasus.

Nilai float11/float10 (v) mengikuti aturan berikut:

  • jika e == 31 dan f != 0, maka v adalah NaN
  • jika e == 31 dan f == 0, maka v = +infinity
  • jika e adalah antara 0 dan 31, maka v = 2(e-15)*(1.f)
  • jika e == 0 dan f != 0, maka v = *2(e-14)*(0.f) (angka denormalisasi)
  • jika e == 0 dan f == 0, maka v = 0 (nol)

Aturan floating-point 32-bit juga berlaku untuk angka floating-point 11-bit dan 10-bit, yang disesuaikan dengan tata letak bit yang dijelaskan sebelumnya. Pengecualian meliputi:

  • Presisi: Aturan floating-point 32-bit mengikuti 0,5 ULP.
  • Angka floating-point 10/11-bit mempertahankan angka denormal.
  • Setiap operasi yang akan menghasilkan angka kurang dari nol dibatasi menjadi nol.

Lampiran-lampiran

Sumber Daya

Tekstur

 

 

  • Last updated on