# 15. Aritmatika Pecahan Floating Point: Masalah dan Keterbatasan

Floating-point numbers are represented in computer hardware as base 2 (binary) fractions. For example, the decimal fraction `0.125` has value 1/10 + 2/100 + 5/1000, and in the same way the binary fraction `0.001` has value 0/2 + 0/4 + 1/8. These two fractions have identical values, the only real difference being that the first is written in base 10 fractional notation, and the second in base 2.

Sayangnya, sebagian besar pecahan desimal tidak dapat direpresentasikan persis dengan pecahan biner. Konsekuensinya adalah bahwa, secara umum, angka pecahan floating-point desimal yang Anda masukkan hanya didekati oleh angka-angka pecahan floating-point biner yang sebenarnya disimpan dalam mesin.

Masalahnya lebih mudah dipahami pada awalnya di basis 10. Pertimbangkan fraksi 1/3. Anda dapat memperkirakannya sebagai pecahan basis 10:

    0.3

atau, lebih baik,

    0.33

atau, lebih baik,

    0.333

dan seterusnya. Tidak peduli berapa banyak digit yang Anda ingin tulis, hasilnya tidak akan pernah benar-benar 1/3, tetapi akan menjadi perkiraan yang semakin baik dari 1/3.

Dengan cara yang sama, tidak peduli berapa banyak digit basis 2 yang ingin Anda gunakan, nilai desimal 0.1 tidak dapat direpresentasikan persis sebagai fraksi basis 2. Dalam basis 2, 1/10 adalah percahan berulang yang tak terhingga

    0.0001100110011001100110011001100110011001100110011...

Berhenti pada jumlah bit yang terbatas, dan Anda mendapatkan perkiraan. Pada kebanyakan mesin saat ini, float diperkirakan menggunakan percahan biner dengan pembilang menggunakan 53 bit pertama dimulai dengan bit paling signifikan dan dengan penyebut sebagai pangkat dua. Dalam kasus 1/10, fraksi biner adalah `3602879701896397 / 2 ** 55` yang dekat dengan tetapi tidak persis sama dengan nilai sebenarnya dari 1/10.

Banyak pengguna tidak menyadari pendekatan tentang bagaimana cara nilai ditampilkan. Python hanya mencetak perkiraan desimal ke nilai desimal sebenarnya dari perkiraan biner yang disimpan oleh mesin. Pada kebanyakan mesin, jika Python mencetak nilai desimal sebenarnya dari perkiraan biner yang disimpan untuk 0.1, ia harus menampilkan

    >>> 0.1
    0.1000000000000000055511151231257827021181583404541015625

Itu lebih banyak angka daripada yang dianggap berguna oleh kebanyakan orang, jadi Python menjaga jumlah angka tetap dapat dikelola dengan menampilkan nilai bulat sebagai gantinya

    >>> 1 / 10
    0.1

Hanya ingat, meskipun hasil cetakannya terlihat seperti nilai tepat 1/10, nilai sebenarnya yang disimpan adalah pecahan biner terdekat yang dapat direpresentasikan.

Menariknya, ada banyak angka desimal berbeda yang memiliki pecahan biner perkiraan terdekat yang sama. Misalnya, angka `0.1` dan `0.10000000000000001` dan `0.1000000000000000055511151231257827021181583404541015625` semuanya didekati oleh `3602879701896397 / 2 ** 55`. Karena semua nilai desimal ini memiliki perkiraan yang sama, salah satu dari nilai tersebut dapat ditampilkan sambil tetap mempertahankan invarian lainnya `eval(repr(x)) == x`.

Secara historis, Python prompt dan fungsi bawaan `repr()` akan memilih satu dengan 17 digit signifikan, `0.10000000000000001`. Dimulai dengan Python 3.1, Python (pada kebanyakan sistem) sekarang dapat memilih yang paling pendek dan hanya menampilkan `0.1`.

Perhatikan bahwa ini adalah sifat dasar dari pecahan floating-point biner: ini bukan bug di Python, dan ini juga bukan bug dalam kode Anda. Anda akan melihat hal yang sama dalam semua bahasa yang mendukung aritmatika pecahan floating-point perangkat keras Anda (meskipun beberapa bahasa mungkin tidak display perbedaan secara default, atau dalam semua mode keluaran).

Untuk hasil yang lebih menyenangkan, Anda mungkin ingin menggunakan pemformatan string untuk menghasilkan jumlah digit signifikan yang terbatas:

    >>> format(math.pi, '.12g')  # give 12 significant digits
    '3.14159265359'

    >>> format(math.pi, '.2f')   # give 2 digits after the point
    '3.14'

    >>> repr(math.pi)
    '3.141592653589793'

Sangat penting untuk menyadari bahwa ini adalah, dalam arti sebenarnya, sebuah ilusi: Anda hanya membulatkan display dari nilai mesin yang sebenarnya.

Satu ilusi mungkin melahirkan yang lain. Misalnya, karena 0.1 tidak tepat 1/10, menjumlahkan tiga nilai 0.1 mungkin tidak menghasilkan tepat 0.3, baik:

    >>> .1 + .1 + .1 == .3
    False

Juga, karena 0.1 tidak bisa mendekati nilai tepat 1/10 dan 0.3 tidak bisa mendekati nilai tepat 3/10, maka pra-pembulatan dengan fungsi `round()` tidak dapat membantu:

    >>> round(.1, 1) + round(.1, 1) + round(.1, 1) == round(.3, 1)
    False

Meskipun angka tidak dapat dibuat lebih dekat dengan nilai pastinya, fungsi `round()` dapat berguna untuk post-rounding sehingga hasil dengan nilai yang tidak tepat menjadi sebanding satu sama lain:

    >>> round(.1 + .1 + .1, 10) == round(.3, 10)
    True

Binary floating-point arithmetic holds many surprises like this. The problem with "0.1" is explained in precise detail below, in the "Representation Error" section. See Examples of Floating Point Problems for a pleasant summary of how binary floating-point works and the kinds of problems commonly encountered in practice. Also see The Perils of Floating Point for a more complete account of other common surprises.

Seperti yang dikatakan menjelang akhir, "tidak ada jawaban yang mudah." Namun, jangan terlalu waspada terhadap pecahan floating point! Kesalahan dalam operasi float Python diwarisi dari pecahan floating point perangkat keras, dan pada kebanyakan mesin ada di urutan tidak lebih dari 1 bagian dalam 2**53 per operasi. Itu lebih dari cukup untuk sebagian besar tugas, tetapi Anda perlu ingat bahwa itu bukan aritmatika desimal dan bahwa setiap operasi float dapat mengalami kesalahan pembulatan baru.

Sementara kasus patologis memang ada, untuk sebagian besar penggunaan aritmatika floating-point yang santai Anda akan melihat hasil yang Anda harapkan pada akhirnya jika Anda hanya membulatkan tampilan hasil akhir Anda ke jumlah angka desimal yang Anda harapkan. `str()` biasanya mencukupi, dan untuk kontrol yang lebih baik lihat format `str.format()` penentu format di Format String Syntax.

Untuk kasus penggunaan yang memerlukan representasi desimal yang tepat, coba gunakan modul `decimal` yang mengimplementasikan aritmatika desimal yang cocok untuk aplikasi akuntansi dan aplikasi presisi tinggi.

Bentuk lain dari aritmatika yang tepat didukung oleh modul `fractions` yang mengimplementasikan aritmatika berdasarkan bilangan rasional (sehingga angka seperti 1/3 dapat direpresentasikan secara tepat).

If you are a heavy user of floating-point operations you should take a look at the NumPy package and many other packages for mathematical and statistical operations supplied by the SciPy project. See <https://scipy.org>.

Python menyediakan alat yang dapat membantu pada saat-saat langka ketika Anda benar-benar do ingin tahu nilai pasti float. Metode `float.as_integer_ratio()` menyatakan nilai float sebagai pecahan:

    >>> x = 3.14159
    >>> x.as_integer_ratio()
    (3537115888337719, 1125899906842624)

Karena rasio ini tepat, dapat digunakan untuk membuat ulang nilai asli tanpa berkurang lossless:

    >>> x == 3537115888337719 / 1125899906842624
    True

Metode `float.hex()` mengekspresikan float dalam heksadesimal (basis 16), sekali lagi memberikan nilai tepat yang disimpan oleh komputer Anda:

    >>> x.hex()
    '0x1.921f9f01b866ep+1'

Representasi heksadesimal yang tepat ini dapat digunakan untuk merekonstruksi nilai float dengan tepat:

    >>> x == float.fromhex('0x1.921f9f01b866ep+1')
    True

Karena representasinya tepat, maka berguna untuk porting nilai secara andal di berbagai versi Python (platform independensi) dan pertukaran data dengan bahasa lain yang mendukung format yang sama (seperti Java dan C99).

Alat lain yang bermanfaat adalah fungsi `math.fsum()` yang membantu mengurangi kehilangan presisi selama penjumlahan. Ini melacak "lost digits" karena nilai ditambahkan ke total yang sedang berlangsung. Itu dapat membuat perbedaan dalam akurasi keseluruhan sehingga kesalahan tidak terakumulasi ke titik di mana mereka mempengaruhi total akhir:

    >>> sum([0.1] * 10) == 1.0
    False
    >>> math.fsum([0.1] * 10) == 1.0
    True

## 15.1. Kesalahan Representasi

Bagian ini menjelaskan contoh "0.1" secara terperinci, dan menunjukkan bagaimana Anda dapat melakukan analisis yang tepat atas kasus-kasus seperti ini sendiri. Diasumsikan terbiasa secara mendasar dengan representasi pecahan floating point biner.

Representation error mengacu pada fakta bahwa beberapa pecahan desimal (sebagian besar, sebenarnya) tidak dapat direpresentasikan persis sebagai pecahan biner (basis 2). Ini adalah alasan utama mengapa Python (atau Perl, C, C++, Java, Fortran, dan banyak lainnya) sering tidak akan menampilkan angka desimal tepat yang Anda harapkan.

Why is that? 1/10 is not exactly representable as a binary fraction. Since at least 2000, almost all machines use IEEE 754 binary floating-point arithmetic, and almost all platforms map Python floats to IEEE 754 binary64 "double precision" values. IEEE 754 binary64 values 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

    1 / 10 ~= J / (2**N)

sebagai

    J ~= 2**N / 10

dan mengingat bahwa J memiliki tepat 53 bit (adalah `>= 2**52` tetapi `< 2**53`), nilai terbaik untuk N adalah 56:

    >>> 2**52 <=  2**56 // 10  < 2**53
    True

Artinya, 56 adalah satu-satunya nilai untuk N yang meninggalkan J dengan tepat 53 bit. Nilai terbaik untuk J adalah bahwa hasil bagi dibulatkan:

    >>> q, r = divmod(2**56, 10)
    >>> r
    6

Karena sisanya lebih dari setengah dari 10, perkiraan terbaik diperoleh dengan membulatkan ke atas:

    >>> q+1
    7205759403792794

Therefore the best possible approximation to 1/10 in IEEE 754 double precision is:

    7205759403792794 / 2 ** 56

Membagi pembilang dan penyebut dengan dua mengurangi pecahan menjadi:

    3602879701896397 / 2 ** 55

Perhatikan bahwa sejak kami mengumpulkan, ini sebenarnya sedikit lebih besar dari 1/10; jika kita belum mengumpulkan, hasil bagi akan sedikit lebih kecil dari 1/10. Tetapi tidak dapatkah hal itu exactly 1/10!

So the computer never "sees" 1/10: what it sees is the exact fraction given above, the best IEEE 754 double approximation it can get:

    >>> 0.1 * 2 ** 55
    3602879701896397.0

Jika kita mengalikan pecahan itu dengan 10**55, kita bisa melihat nilainya menjadi 55 angka desimal:

    >>> 3602879701896397 * 10 ** 55 // 2 ** 55
    1000000000000000055511151231257827021181583404541015625

artinya angka persis yang disimpan di komputer sama dengan nilai desimal 0.1000000000000000055511151231257827021181583404541015625. Alih-alih menampilkan nilai desimal penuh, banyak bahasa (termasuk versi Python yang lebih lama), bulatkan hasilnya menjadi 17 digit signifikan

    >>> format(0.1, '.17f')
    '0.10000000000000001'

Modul `fractions` dan `desimal` membuat perhitungan ini mudah:

    >>> from decimal import Decimal
    >>> from fractions import Fraction

    >>> Fraction.from_float(0.1)
    Fraction(3602879701896397, 36028797018963968)

    >>> (0.1).as_integer_ratio()
    (3602879701896397, 36028797018963968)

    >>> Decimal.from_float(0.1)
    Decimal('0.1000000000000000055511151231257827021181583404541015625')

    >>> format(Decimal.from_float(0.1), '.17')
    '0.10000000000000001'