floatingpoint.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2019, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
# 
# Translators:
# oon arfiandwi <oon.arfiandwi@gmail.com>, 2019
# 
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.8\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2019-09-01 14:24+0000\n"
"PO-Revision-Date: 2017-02-16 23:40+0000\n"
"Last-Translator: oon arfiandwi <oon.arfiandwi@gmail.com>, 2019\n"
"Language-Team: Indonesian (https://www.transifex.com/python-doc/teams/5390/id/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: id\n"
"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../tutorial/floatingpoint.rst:9
msgid "Floating Point Arithmetic:  Issues and Limitations"
msgstr "Aritmatika Pecahan *Floating Point*: Masalah dan Keterbatasan"

#: ../../tutorial/floatingpoint.rst:14
msgid ""
"Floating-point numbers are represented in computer hardware as base 2 "
"(binary) fractions.  For example, the decimal fraction ::"
msgstr ""
"Angka pecahan *floating point* diwakili dalam perangkat keras komputer "
"sebagai pecahan basis 2 (biner). Misalnya, pecahan desimal::"

#: ../../tutorial/floatingpoint.rst:19
msgid ""
"has value 1/10 + 2/100 + 5/1000, and in the same way the binary fraction ::"
msgstr ""
"memiliki nilai 1/10 + 2/100 + 5/1000, dan dengan cara yang sama pecahan "
"biner ::"

#: ../../tutorial/floatingpoint.rst:23
msgid ""
"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."
msgstr ""
"memiliki nilai 0/2 + 0/4 + 1/8. Dua pecahan ini memiliki nilai yang identik,"
" satu-satunya perbedaan nyata adalah bahwa yang pertama ditulis dalam notasi"
" fraksi basis 10, dan yang kedua dalam basis 2."

#: ../../tutorial/floatingpoint.rst:27
msgid ""
"Unfortunately, most decimal fractions cannot be represented exactly as "
"binary fractions.  A consequence is that, in general, the decimal floating-"
"point numbers you enter are only approximated by the binary floating-point "
"numbers actually stored in the machine."
msgstr ""
"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."

#: ../../tutorial/floatingpoint.rst:32
msgid ""
"The problem is easier to understand at first in base 10.  Consider the "
"fraction 1/3.  You can approximate that as a base 10 fraction::"
msgstr ""
"Masalahnya lebih mudah dipahami pada awalnya di basis 10. Pertimbangkan "
"fraksi 1/3. Anda dapat memperkirakannya sebagai pecahan basis 10::"

#: ../../tutorial/floatingpoint.rst:37 ../../tutorial/floatingpoint.rst:41
msgid "or, better, ::"
msgstr "atau, lebih baik, ::"

#: ../../tutorial/floatingpoint.rst:45
msgid ""
"and so on.  No matter how many digits you're willing to write down, the "
"result will never be exactly 1/3, but will be an increasingly better "
"approximation of 1/3."
msgstr ""
"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."

#: ../../tutorial/floatingpoint.rst:49
msgid ""
"In the same way, no matter how many base 2 digits you're willing to use, the"
" decimal value 0.1 cannot be represented exactly as a base 2 fraction.  In "
"base 2, 1/10 is the infinitely repeating fraction ::"
msgstr ""
"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 ::"

#: ../../tutorial/floatingpoint.rst:55
msgid ""
"Stop at any finite number of bits, and you get an approximation.  On most "
"machines today, floats are approximated using a binary fraction with the "
"numerator using the first 53 bits starting with the most significant bit and"
" with the denominator as a power of two.  In the case of 1/10, the binary "
"fraction is ``3602879701896397 / 2 ** 55`` which is close to but not exactly"
" equal to the true value of 1/10."
msgstr ""
"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."

#: ../../tutorial/floatingpoint.rst:62
msgid ""
"Many users are not aware of the approximation because of the way values are "
"displayed.  Python only prints a decimal approximation to the true decimal "
"value of the binary approximation stored by the machine.  On most machines, "
"if Python were to print the true decimal value of the binary approximation "
"stored for 0.1, it would have to display ::"
msgstr ""
"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 ::"

#: ../../tutorial/floatingpoint.rst:71
msgid ""
"That is more digits than most people find useful, so Python keeps the number"
" of digits manageable by displaying a rounded value instead ::"
msgstr ""
"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 ::"

#: ../../tutorial/floatingpoint.rst:77
msgid ""
"Just remember, even though the printed result looks like the exact value of "
"1/10, the actual stored value is the nearest representable binary fraction."
msgstr ""
"Hanya ingat, meskipun hasil cetakannya terlihat seperti nilai tepat 1/10, "
"nilai sebenarnya yang disimpan adalah pecahan biner terdekat yang dapat "
"direpresentasikan."

#: ../../tutorial/floatingpoint.rst:80
msgid ""
"Interestingly, there are many different decimal numbers that share the same "
"nearest approximate binary fraction.  For example, the numbers ``0.1`` and "
"``0.10000000000000001`` and "
"``0.1000000000000000055511151231257827021181583404541015625`` are all "
"approximated by ``3602879701896397 / 2 ** 55``.  Since all of these decimal "
"values share the same approximation, any one of them could be displayed "
"while still preserving the invariant ``eval(repr(x)) == x``."
msgstr ""
"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``."

#: ../../tutorial/floatingpoint.rst:88
msgid ""
"Historically, the Python prompt and built-in :func:`repr` function would "
"choose the one with 17 significant digits, ``0.10000000000000001``.   "
"Starting with Python 3.1, Python (on most systems) is now able to choose the"
" shortest of these and simply display ``0.1``."
msgstr ""
"Secara historis, Python prompt dan fungsi bawaan :func:`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``."

#: ../../tutorial/floatingpoint.rst:93
msgid ""
"Note that this is in the very nature of binary floating-point: this is not a"
" bug in Python, and it is not a bug in your code either.  You'll see the "
"same kind of thing in all languages that support your hardware's floating-"
"point arithmetic (although some languages may not *display* the difference "
"by default, or in all output modes)."
msgstr ""
"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)."

#: ../../tutorial/floatingpoint.rst:99
msgid ""
"For more pleasant output, you may wish to use string formatting to produce a"
" limited number of significant digits::"
msgstr ""
"Untuk hasil yang lebih menyenangkan, Anda mungkin ingin menggunakan "
"pemformatan string untuk menghasilkan jumlah digit signifikan yang "
"terbatas::"

#: ../../tutorial/floatingpoint.rst:111
msgid ""
"It's important to realize that this is, in a real sense, an illusion: you're"
" simply rounding the *display* of the true machine value."
msgstr ""
"Sangat penting untuk menyadari bahwa ini adalah, dalam arti sebenarnya, "
"sebuah ilusi: Anda hanya membulatkan *display* dari nilai mesin yang "
"sebenarnya."

#: ../../tutorial/floatingpoint.rst:114
msgid ""
"One illusion may beget another.  For example, since 0.1 is not exactly 1/10,"
" summing three values of 0.1 may not yield exactly 0.3, either::"
msgstr ""
"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::"

#: ../../tutorial/floatingpoint.rst:120
msgid ""
"Also, since the 0.1 cannot get any closer to the exact value of 1/10 and 0.3"
" cannot get any closer to the exact value of 3/10, then pre-rounding with "
":func:`round` function cannot help::"
msgstr ""
"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 :func:`round` "
"tidak dapat membantu::"

#: ../../tutorial/floatingpoint.rst:127
msgid ""
"Though the numbers cannot be made closer to their intended exact values, the"
" :func:`round` function can be useful for post-rounding so that results with"
" inexact values become comparable to one another::"
msgstr ""
"Meskipun angka tidak dapat dibuat lebih dekat dengan nilai pastinya, fungsi "
":func:`round` dapat berguna untuk *post-rounding* sehingga hasil dengan "
"nilai yang tidak tepat menjadi sebanding satu sama lain::"

#: ../../tutorial/floatingpoint.rst:134
msgid ""
"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 `The Perils of Floating Point "
"<http://www.lahey.com/float.htm>`_ for a more complete account of other "
"common surprises."
msgstr ""
"Aritmatika pecahan *floating-point* biner memiliki banyak kejutan seperti "
"ini. Masalah dengan \"0.1\" dijelaskan secara rinci di bawah ini, di bagian "
"\"Representation Error\". Lihat `Perils of Floating Point "
"<http://www.lahey.com/float.htm>`_ untuk penjelasan lebih lengkap tentang "
"kejutan umum lainnya."

#: ../../tutorial/floatingpoint.rst:139
msgid ""
"As that says near the end, \"there are no easy answers.\"  Still, don't be "
"unduly wary of floating-point!  The errors in Python float operations are "
"inherited from the floating-point hardware, and on most machines are on the "
"order of no more than 1 part in 2\\*\\*53 per operation.  That's more than "
"adequate for most tasks, but you do need to keep in mind that it's not "
"decimal arithmetic and that every float operation can suffer a new rounding "
"error."
msgstr ""
"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."

#: ../../tutorial/floatingpoint.rst:146
msgid ""
"While pathological cases do exist, for most casual use of floating-point "
"arithmetic you'll see the result you expect in the end if you simply round "
"the display of your final results to the number of decimal digits you "
"expect. :func:`str` usually suffices, and for finer control see the "
":meth:`str.format` method's format specifiers in :ref:`formatstrings`."
msgstr ""
"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. :func:`str` biasanya mencukupi,"
" dan untuk kontrol yang lebih baik lihat format :meth:`str.format` penentu "
"format di :ref:`formatstrings`."

#: ../../tutorial/floatingpoint.rst:152
msgid ""
"For use cases which require exact decimal representation, try using the "
":mod:`decimal` module which implements decimal arithmetic suitable for "
"accounting applications and high-precision applications."
msgstr ""
"Untuk kasus penggunaan yang memerlukan representasi desimal yang tepat, coba"
" gunakan modul :mod:`decimal` yang mengimplementasikan aritmatika desimal "
"yang cocok untuk aplikasi akuntansi dan aplikasi presisi tinggi."

#: ../../tutorial/floatingpoint.rst:156
msgid ""
"Another form of exact arithmetic is supported by the :mod:`fractions` module"
" which implements arithmetic based on rational numbers (so the numbers like "
"1/3 can be represented exactly)."
msgstr ""
"Bentuk lain dari aritmatika yang tepat didukung oleh modul :mod:`fractions` "
"yang mengimplementasikan aritmatika berdasarkan bilangan rasional (sehingga "
"angka seperti 1/3 dapat direpresentasikan secara tepat)."

#: ../../tutorial/floatingpoint.rst:160
msgid ""
"If you are a heavy user of floating point operations you should take a look "
"at the Numerical Python package and many other packages for mathematical and"
" statistical operations supplied by the SciPy project. See "
"<https://scipy.org>."
msgstr ""
"Jika Anda adalah pengguna berat operasi floating point, Anda harus melihat "
"pada paket *Numerical Python* dan banyak paket lainnya untuk operasi "
"matematika dan statistik yang disediakan oleh proyek SciPy. Lihat "
"<https://scipy.org>."

#: ../../tutorial/floatingpoint.rst:164
msgid ""
"Python provides tools that may help on those rare occasions when you really "
"*do* want to know the exact value of a float.  The "
":meth:`float.as_integer_ratio` method expresses the value of a float as a "
"fraction::"
msgstr ""
"Python menyediakan alat yang dapat membantu pada saat-saat langka ketika "
"Anda benar-benar *do* ingin tahu nilai pasti float. Metode "
":meth:`float.as_integer_ratio` menyatakan nilai *float* sebagai pecahan::"

#: ../../tutorial/floatingpoint.rst:173
msgid ""
"Since the ratio is exact, it can be used to losslessly recreate the original"
" value::"
msgstr ""
"Karena rasio ini tepat, dapat digunakan untuk membuat ulang nilai asli tanpa"
" berkurang *lossless*::"

#: ../../tutorial/floatingpoint.rst:179
msgid ""
"The :meth:`float.hex` method expresses a float in hexadecimal (base 16), "
"again giving the exact value stored by your computer::"
msgstr ""
"Metode :meth:`float.hex` mengekspresikan float dalam heksadesimal (basis "
"16), sekali lagi memberikan nilai tepat yang disimpan oleh komputer Anda::"

#: ../../tutorial/floatingpoint.rst:185
msgid ""
"This precise hexadecimal representation can be used to reconstruct the float"
" value exactly::"
msgstr ""
"Representasi heksadesimal yang tepat ini dapat digunakan untuk "
"merekonstruksi nilai *float* dengan tepat::"

#: ../../tutorial/floatingpoint.rst:191
msgid ""
"Since the representation is exact, it is useful for reliably porting values "
"across different versions of Python (platform independence) and exchanging "
"data with other languages that support the same format (such as Java and "
"C99)."
msgstr ""
"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)."

#: ../../tutorial/floatingpoint.rst:195
msgid ""
"Another helpful tool is the :func:`math.fsum` function which helps mitigate "
"loss-of-precision during summation.  It tracks \"lost digits\" as values are"
" added onto a running total.  That can make a difference in overall accuracy"
" so that the errors do not accumulate to the point where they affect the "
"final total:"
msgstr ""
"Alat lain yang bermanfaat adalah fungsi :func:`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:"

#: ../../tutorial/floatingpoint.rst:209
msgid "Representation Error"
msgstr "Kesalahan Representasi"

#: ../../tutorial/floatingpoint.rst:211
msgid ""
"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."
msgstr ""
"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."

#: ../../tutorial/floatingpoint.rst:215
msgid ""
":dfn:`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."
msgstr ""
":dfn:`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."

#: ../../tutorial/floatingpoint.rst:220
msgid ""
"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 ::"
msgstr ""
"Mengapa demikian? 1/10 tidak tepat direpresentasikan sebagai pecahan biner. "
"Hampir semua mesin saat ini (November 2000) menggunakan aritmetika pecahan "
"*floating point* IEEE-754, dan hampir semua platform memetakan *float* "
"Python ke IEEE-754 \"double precision\". 754 *double* mengandung 53 bit "
"presisi, sehingga pada input komputer berusaha untuk mengkonversi 0.1 ke "
"fraksi terdekat dari bentuk *J*/2**\\*N* di mana *J* adalah bilangan bulat "
"yang mengandung persis 53 bit. Menulis ulang ::"

#: ../../tutorial/floatingpoint.rst:229
msgid "as ::"
msgstr "sebagai ::"

#: ../../tutorial/floatingpoint.rst:233
msgid ""
"and recalling that *J* has exactly 53 bits (is ``>= 2**52`` but ``< "
"2**53``), the best value for *N* is 56::"
msgstr ""
"dan mengingat bahwa *J* memiliki tepat 53 bit (adalah ``>= 2**52`` tetapi "
"``< 2**53``), nilai terbaik untuk *N* adalah 56::"

#: ../../tutorial/floatingpoint.rst:239
msgid ""
"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::"
msgstr ""
"Artinya, 56 adalah satu-satunya nilai untuk *N* yang meninggalkan *J* dengan"
" tepat 53 bit. Nilai terbaik untuk *J* adalah bahwa hasil bagi dibulatkan::"

#: ../../tutorial/floatingpoint.rst:246
msgid ""
"Since the remainder is more than half of 10, the best approximation is "
"obtained by rounding up::"
msgstr ""
"Karena sisanya lebih dari setengah dari 10, perkiraan terbaik diperoleh "
"dengan membulatkan ke atas::"

#: ../../tutorial/floatingpoint.rst:252
msgid ""
"Therefore the best possible approximation to 1/10 in 754 double precision "
"is::"
msgstr ""
"Oleh karena itu perkiraan terbaik untuk 1/10 dalam 754 presisi *double* "
"adalah ::"

#: ../../tutorial/floatingpoint.rst:256
msgid ""
"Dividing both the numerator and denominator by two reduces the fraction to::"
msgstr ""
"Membagi pembilang dan penyebut dengan dua mengurangi pecahan menjadi::"

#: ../../tutorial/floatingpoint.rst:260
msgid ""
"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!"
msgstr ""
"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!"

#: ../../tutorial/floatingpoint.rst:264
msgid ""
"So the computer never \"sees\" 1/10:  what it sees is the exact fraction "
"given above, the best 754 double approximation it can get::"
msgstr ""
"Jadi komputer tidak pernah \"sees\" 1/10: apa yang dilihatnya adalah pecahan"
" tepat yang diberikan di atas, perkiraan 754 *double* terbaik yang bisa "
"didapatnya:"

#: ../../tutorial/floatingpoint.rst:270
msgid ""
"If we multiply that fraction by 10\\*\\*55, we can see the value out to 55 "
"decimal digits::"
msgstr ""
"Jika kita mengalikan pecahan itu dengan 10\\*\\*55, kita bisa melihat "
"nilainya menjadi 55 angka desimal::"

#: ../../tutorial/floatingpoint.rst:276
msgid ""
"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::"
msgstr ""
"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 ::"

#: ../../tutorial/floatingpoint.rst:284
msgid ""
"The :mod:`fractions` and :mod:`decimal` modules make these calculations "
"easy::"
msgstr ""
"Modul :mod:`fractions` dan :mod:`desimal` membuat perhitungan ini mudah::"