Cara kerja penyimpanan angka desimal

Mari kita bedah cara kerja penyimpanan angka desimal (seperti float atau double) di memori komputer. Ini memang sedikit rumit pada awalnya, tetapi dengan contoh, konsepnya akan menjadi jauh lebih jelas.

Standar yang paling umum digunakan untuk ini adalah IEEE 754. Bayangkan ini seperti "aturan main" universal agar semua komputer mengerti cara membaca dan menulis angka desimal dengan cara yang sama.

Konsep utamanya adalah menyimpan angka dalam bentuk notasi ilmiah biner, mirip seperti notasi ilmiah desimal yang mungkin Anda kenal (contoh: 6.022 x 10²³).

Setiap angka float (32-bit) atau double (64-bit) dipecah menjadi tiga bagian utama:

  1. Sign (Tanda): Bagian paling sederhana. Menentukan apakah angka itu positif atau negatif.

  2. Exponent (Pangkat): Menentukan seberapa besar atau kecil angka tersebut (pangkat dari 2).

  3. Fraction / Mantissa (Pecahan): Merepresentasikan digit-digit presisi dari angka tersebut.

Anatomi float (Single Precision - 32 bit)

Kita akan fokus pada float karena lebih mudah dihitung. Sebuah float memiliki 32 bit yang dialokasikan sebagai berikut:

[S] [EEEEEEEE] [FFFFFFFFFFFFFFFFFFFFFFF]

  • Sign (S): 1 bit.

    • 0 = Positif (+)

    • 1 = Negatif (-)

  • Exponent (E): 8 bit.

    • Bagian ini tidak menyimpan nilai pangkat secara langsung. Ia menyimpan nilai pangkat yang sudah ditambah bias (biasa). Untuk float, nilai biasnya adalah 127.

    • Jadi, rumusnya: Exponent yang Disimpan = Exponent Sebenarnya + 127. Tujuannya agar bisa merepresentasikan pangkat positif dan negatif tanpa memerlukan bit tanda tambahan untuk exponent.

  • Fraction (F) / Mantissa: 23 bit.

    • Ini adalah bagian desimal dari notasi ilmiah biner (angka di belakang 1,...). Ada "bit tersembunyi" (hidden bit) yaitu angka 1 di depan koma yang tidak perlu disimpan untuk efisiensi.

🧑‍💻 Studi Kasus: Menyimpan Angka -13.625 dalam Memori

Mari kita ubah angka desimal -13.625 menjadi representasi float 32-bit langkah demi langkah.

Langkah 1: Tentukan Bit Tanda (Sign)

Angka kita adalah -13.625, berarti negatif.

  • Sign (S) = 1

Langkah 2: Konversi Angka ke Biner

Kita perlu mengubah bagian bulat (13) dan bagian pecahan (0.625) secara terpisah.

  • Bagian Bulat (13):

    • 13 / 2 = 6 sisa 1

    • 6 / 2 = 3 sisa 0

    • 3 / 2 = 1 sisa 1

    • 1 / 2 = 0 sisa 1

    • Baca dari bawah ke atas: 1101

  • Bagian Pecahan (0.625):

    • 0.625 x 2 = 1.25 (ambil 1)

    • 0.25 x 2 = 0.5 (ambil 0)

    • 0.5 x 2 = 1.0 (ambil 1)

    • Baca dari atas ke bawah: 101

Jadi, 13.625 dalam biner adalah 1101.101.

Langkah 3: Normalisasi Biner

Sekarang, kita ubah biner tadi ke dalam bentuk notasi ilmiah (bentuk 1.xxxxx * 2^pangkat). Kita geser titik desimalnya sampai hanya ada satu angka 1 di depan.

  • 1101.101

  • Geser titik ke kiri sebanyak 3 kali: 1.101101

  • Karena kita geser ke kiri 3 kali, pangkatnya menjadi 3.

  • Hasil normalisasi: 1.101101 * 2³

Dari sini kita mendapatkan dua informasi penting:

  • Exponent Sebenarnya = 3

  • Fraction/Mantissa = 101101 (semua digit setelah 1.)

Langkah 4: Hitung Exponent yang Disimpan

Kita gunakan rumus Exponent Sebenarnya + Bias.

  • 3 + 127 = 130

  • Sekarang, konversi 130 ke biner 8-bit: 10000010

  • Exponent (E) = 10000010

Langkah 5: Tentukan Fraction yang Disimpan

Fraction adalah 23 bit. Kita sudah punya 101101 dari langkah 3. Kita tinggal tambahkan angka 0 di belakangnya sampai total menjadi 23 digit.

  • Fraction (F) = 10110100000000000000000

Langkah 6: Gabungkan Semuanya!

Sekarang kita satukan ketiga bagian tersebut sesuai urutan: S-E-F.

  • Sign (S): 1

  • Exponent (E): 10000010

  • Fraction (F): 10110100000000000000000

Maka, representasi 32-bit dari -13.625 di memori adalah:

1 10000010 10110100000000000000000

Jika dikelompokkan per 4 bit (untuk diubah ke heksadesimal), menjadi:

1100 0001 0101 1010 0000 0000 0000 0000

C 1 5 A 0 0 0 0

Jadi, dalam heksadesimal, -13.625 direpresentasikan sebagai 0xC15A0000.

Bagaimana Cara Komputer Membacanya Kembali?

Komputer melakukan proses sebaliknya:

  1. Lihat bit pertama: 1 -> Oh, ini angka negatif.

  2. Lihat 8 bit berikutnya: 10000010 -> Ini adalah 130 dalam desimal. Karena ada bias 127, maka 130 - 127 = 3. Pangkatnya adalah 2³.

  3. Lihat 23 bit terakhir: 101101... -> Ini adalah pecahannya. Komputer menambahkan "bit tersembunyi" 1. di depannya, menjadi 1.101101.

  4. Gabungkan: (-1) * 1.101101 * 2³

  5. Geser titik desimal ke kanan 3 kali: (-1) * 1101.101

  6. Ubah ke desimal: 1101 adalah 13, dan 0.101 adalah 0.625.

  7. Hasil akhir: -13.625. Cocok!

Bagaimana dengan double (Double Precision - 64 bit)?

Prinsipnya sama persis, hanya alokasi bitnya yang berbeda dan lebih besar, sehingga presisinya jauh lebih tinggi.

  • Sign: 1 bit

  • Exponent: 11 bit (dengan bias 1023)

  • Fraction: 52 bit

Mari kita lanjutkan dengan beberapa studi kasus lagi agar semakin terbiasa.

Studi Kasus 2: Angka Desimal Kecil (9.2)

Mari kita representasikan 9.2 sebagai float 32-bit.

1. Tanda (Sign)

Angka 9.2 adalah positif.

  • Sign (S) = 0

2. Konversi ke Biner

  • Bagian Bulat (9): 1001

  • Bagian Pecahan (0.2):

    • 0.2 x 2 = 0.4

    • 0.4 x 2 = 0.8

    • 0.8 x 2 = 1.6

    • 0.6 x 2 = 1.2

    • 0.2 x 2 = 0.4 (Mulai berulang: 0110...)

    • Hasilnya adalah biner berulang: 0.001100110...

Jadi, 9.2 dalam biner adalah 1001.001100110...

3. Normalisasi Biner

Kita geser titik desimal ke kiri sebanyak 3 kali.

  • 1.001001100110... * 2³

Dari sini kita dapatkan:

  • Exponent Sebenarnya = 3

  • Fraction = 001001100110...

4. Hitung Exponent

  • Exponent Sebenarnya + Bias = 3 + 127 = 130

  • 130 dalam biner 8-bit adalah 10000010.

  • Exponent (E) = 10000010

5. Tentukan Fraction

Kita ambil 23 bit dari hasil normalisasi 00100110011001100110011...

  • Fraction (F) = 00100110011001100110011

6. Gabungkan

  • S: 0

  • E: 10000010

  • F: 00100110011001100110011

0 10000010 00100110011001100110011

Perhatikan bahwa karena 0.2 tidak dapat direpresentasikan secara sempurna dalam biner, hasil ini adalah sebuah aproksimasi (pembulatan). Inilah alasan mengapa operasi dengan float terkadang bisa menghasilkan galat presisi kecil.

Studi Kasus 3: Angka Bulat Sederhana (10.0)

Mari kita representasikan 10.0 sebagai float 32-bit.

1. Tanda (Sign)

Angka 10.0 adalah positif.

  • Sign (S) = 0

2. Konversi ke Biner

  • Bagian Bulat (10): 1010

  • Bagian Pecahan (0.0): 0

  • Hasilnya adalah 1010.0

3. Normalisasi Biner

Kita geser titik desimal ke kiri sebanyak 3 kali.

  • 1.010 * 2³

Dari sini kita dapatkan:

  • Exponent Sebenarnya = 3

  • Fraction = 010`

4. Hitung Exponent

  • Exponent Sebenarnya + Bias = 3 + 127 = 130

  • 130 dalam biner 8-bit adalah 10000010.

  • Exponent (E) = 10000010

5. Tentukan Fraction

Kita ambil 010 dan tambahkan nol di belakangnya hingga 23 bit.

  • Fraction (F) = 01000000000000000000000

6. Gabungkan

  • S: 0

  • E: 10000010

  • F: 01000000000000000000000

0 10000010 01000000000000000000000

➕ Studi Kasus Perhitungan: Pertambahan (0.5 + 0.75)

Komputer tidak bisa langsung menjumlahkan dua representasi float. Ada beberapa langkah yang harus dilakukan.

Hasil yang kita harapkan: 0.5 + 0.75 = 1.25

1. Konversi Kedua Angka ke Format Float

  • Untuk 0.5:

    • Biner: 0.1

    • Normalisasi: 1.0 * 2⁻¹

    • Sign: 0

    • Exponent: -1 + 127 = 126 (biner 01111110)

    • Fraction: 000...

    • Float A (0.5): 0 01111110 00000000000000000000000

  • Untuk 0.75:

    • Biner: 0.11

    • Normalisasi: 1.1 * 2⁻¹

    • Sign: 0

    • Exponent: -1 + 127 = 126 (biner 01111110)

    • Fraction: 100...

    • Float B (0.75): 0 01111110 10000000000000000000000

2. Samakan Exponent

Sebelum dijumlahkan, pangkat (exponent) kedua angka harus sama. Dalam kasus ini, exponentnya sudah sama (126), jadi kita tidak perlu melakukan apa-apa.

Jika berbeda, angka dengan exponent lebih kecil akan "digeser" (denormalisasi) hingga exponentnya sama dengan yang lebih besar.

3. Tambahkan Mantissa

Sekarang kita tambahkan mantissanya. Ingat, ada "bit tersembunyi" 1. di depan.

  • Mantissa A (0.5): 1.000...

  • Mantissa B (0.75): 1.100...

  • Penjumlahan:

      1.000
  1.100
+ -----
 10.100

  • Hasilnya adalah 10.1 (dengan exponent 2⁻¹ yang sama).

4. Normalisasi Hasil

Hasil penjumlahan 10.1 * 2⁻¹ belum ternormalisasi (karena ada dua digit di depan koma). Kita normalkan lagi.

  • Geser titik ke kiri 1 kali: 1.01 * 2⁰

  • Sekarang kita punya hasil akhir yang sudah ternormalisasi.

5. Ubah Hasil ke Format Float

  • Sign: Positif, jadi 0

  • Exponent Sebenarnya: 0. Maka Exponent tersimpan: 0 + 127 = 127 (biner 01111111)

  • Fraction: 01 (diikuti 21 angka nol)

Hasil akhir 1.25 dalam format float:

0 01111111 01000000000000000000000

Proses ini menunjukkan mengapa operasi floating-point lebih "mahal" (membutuhkan lebih banyak siklus komputasi) dibandingkan operasi integer, karena ada langkah-langkah tambahan seperti penyamaan exponent dan normalisasi ulang.

PreviousObserver PatternNextBitmap

Last updated