Anda tampaknya cocok dengan manfaat menggunakan tipe floating point. Saya cenderung mendesain desimal dalam semua kasus, dan mengandalkan profiler untuk memberi tahu saya jika operasi pada desimal menyebabkan kemacetan atau perlambatan. Dalam kasus-kasus itu, saya akan "menurunkan casting" menjadi dua kali lipat atau mengambang, tetapi hanya melakukannya secara internal, dan dengan hati-hati mencoba mengelola kehilangan presisi dengan membatasi jumlah digit signifikan dalam operasi matematika yang sedang dilakukan.
Secara umum, jika nilai Anda bersifat sementara (tidak digunakan kembali), Anda aman untuk menggunakan tipe floating point. Masalah sebenarnya dengan tipe floating point adalah tiga skenario berikut.
- Anda mengumpulkan nilai floating point (dalam hal ini senyawa kesalahan presisi)
- Anda membangun nilai berdasarkan nilai floating point (misalnya dalam algoritma rekursif)
- Anda melakukan matematika dengan jumlah digit signifikan yang sangat luas (misalnya,
123456789.1 * .000000000000000987654321)
EDIT
Menurut dokumentasi referensi pada desimal C # :
Kata kunci desimal menunjukkan tipe data 128-bit. Dibandingkan dengan tipe floating-point, tipe desimal memiliki presisi yang lebih besar dan rentang yang lebih kecil, yang membuatnya cocok untuk perhitungan keuangan dan moneter.
Jadi untuk memperjelas pernyataan saya di atas:
Saya cenderung mendesain desimal dalam semua kasus, dan mengandalkan profiler untuk memberi tahu saya jika operasi pada desimal menyebabkan kemacetan atau perlambatan.
Saya hanya pernah bekerja di industri di mana desimal menguntungkan. Jika Anda bekerja pada mesin phsyics atau grafis, mungkin jauh lebih bermanfaat untuk mendesain tipe floating point (float atau double).
Desimal tidak akurat tanpa batas (tidak mungkin untuk merepresentasikan ketelitian tak terbatas untuk non-integral dalam tipe data primitif), tetapi desimal jauh lebih tepat daripada ganda:
- desimal = 28-29 angka signifikan
- dobel = 15-16 digit signifikan
- float = 7 digit signifikan
EDIT 2
Menanggapi komentar Konrad Rudolph , item # 1 (di atas) sudah pasti benar. Agregasi ketidaktepatan memang bertambah. Lihat kode di bawah ini untuk contoh:
private const float THREE_FIFTHS = 3f / 5f;
private const int ONE_MILLION = 1000000;
public static void Main(string[] args)
{
Console.WriteLine("Three Fifths: {0}", THREE_FIFTHS.ToString("F10"));
float asSingle = 0f;
double asDouble = 0d;
decimal asDecimal = 0M;
for (int i = 0; i < ONE_MILLION; i++)
{
asSingle += THREE_FIFTHS;
asDouble += THREE_FIFTHS;
asDecimal += (decimal) THREE_FIFTHS;
}
Console.WriteLine("Six Hundred Thousand: {0:F10}", THREE_FIFTHS * ONE_MILLION);
Console.WriteLine("Single: {0}", asSingle.ToString("F10"));
Console.WriteLine("Double: {0}", asDouble.ToString("F10"));
Console.WriteLine("Decimal: {0}", asDecimal.ToString("F10"));
Console.ReadLine();
}
Ini menghasilkan sebagai berikut:
Three Fifths: 0.6000000000
Six Hundred Thousand: 600000.0000000000
Single: 599093.4000000000
Double: 599999.9999886850
Decimal: 600000.0000000000
Seperti yang Anda lihat, meskipun kami menambahkan dari konstanta sumber yang sama, hasil dari gandanya kurang tepat (meskipun mungkin akan membulat dengan benar), dan float jauh lebih tidak tepat, ke titik di mana ia telah direduksi menjadi hanya dua digit signifikan.