ฉันสามารถตั้งชื่อข้อดีสามข้อให้กับการใช้double(หรือfloat) แทนdecimal:

1. ใช้หน่วยความจำน้อยลง
2. เร็วขึ้นเนื่องจากการดำเนินการทางคณิตศาสตร์ของจุดลอยตัวได้รับการสนับสนุนโดยตัวประมวลผล
3. สามารถแสดงช่วงของตัวเลขที่มากขึ้น

แต่ข้อดีเหล่านี้ดูเหมือนจะใช้เฉพาะกับการคำนวณการดำเนินการที่เข้มข้นเช่นที่พบในซอฟต์แวร์การสร้างแบบจำลอง แน่นอนไม่ควรใช้คู่ผสมเมื่อต้องการความแม่นยำเช่นการคำนวณทางการเงิน ดังนั้นมีเหตุผลเชิงปฏิบัติใดที่เคยเลือกdouble(หรือfloat) แทนที่จะdecimalใช้แอปพลิเคชัน "ปกติ"

แก้ไขเพื่อเพิ่ม: ขอบคุณสำหรับคำตอบที่ยอดเยี่ยมทั้งหมดฉันเรียนรู้จากพวกเขา

คำถามอีกข้อหนึ่ง: มีคนเพียงไม่กี่คนที่ชี้ให้เห็นว่าการเป็นตัวแทนจำนวนจริงนั้นแม่นยำยิ่งขึ้น เมื่อประกาศฉันจะคิดว่าพวกเขามักจะเป็นตัวแทนของพวกเขาอย่างถูกต้องเช่นกัน แต่มันเป็นความจริงหรือไม่ที่ความแม่นยำอาจลดลง (บางครั้งมีนัยสำคัญ) เมื่อดำเนินการกับจุดลอยตัว?

ฉันคิดว่าคุณสรุปข้อดีได้ค่อนข้างดี อย่างไรก็ตามคุณพลาดจุดหนึ่ง decimalประเภทเป็นเพียงความถูกต้องแม่นยำมากขึ้นในการเป็นตัวแทนของ10 ฐานตัวเลข (เช่นที่ใช้ในสกุลเงิน / การคำนวณทางการเงิน) โดยทั่วไปแล้ว doubleประเภทจะให้ความแม่นยำอย่างน้อยที่สุด (บางคนแก้ไขให้ฉันถ้าฉันผิด) และความเร็วที่มากขึ้นสำหรับจำนวนจริงโดยพลการ ข้อสรุปง่ายๆคือ: เมื่อพิจารณาว่าจะใช้แบบใดให้ใช้งานเสมอdoubleเว้นแต่ว่าคุณต้องการbase 10ความแม่นยำที่decimalเสนอ

แก้ไข:

เกี่ยวกับคำถามเพิ่มเติมของคุณเกี่ยวกับการลดลงของความแม่นยำของตัวเลขทศนิยมหลังจากการดำเนินการนี่เป็นปัญหาที่ละเอียดกว่าเล็กน้อย แน่นอนความแม่นยำ (ฉันใช้คำแทนกันเพื่อความถูกต้องที่นี่) จะลดลงอย่างต่อเนื่องหลังจากดำเนินการแต่ละครั้ง นี่คือสาเหตุสองประการ:

1. ความจริงที่ว่าตัวเลขบางตัว (ทศนิยมชัดเจนที่สุด) ไม่สามารถแสดงในรูปแบบของจุดลอยตัวได้อย่างแท้จริง
2. เกิดข้อผิดพลาดในการปัดเศษราวกับว่าคุณกำลังทำการคำนวณด้วยมือ ขึ้นอยู่กับบริบทอย่างมาก (จำนวนการดำเนินการที่คุณกำลังดำเนินการ) ว่าข้อผิดพลาดเหล่านี้มีความสำคัญพอที่จะรับประกันได้อย่างไร

ในทุกกรณีหากคุณต้องการเปรียบเทียบจำนวนจุดลอยตัวที่ควรจะเท่ากันในทางทฤษฎี (แต่ได้มาจากการคำนวณที่แตกต่างกัน) คุณต้องยอมให้มีความอดทนในระดับหนึ่ง (แตกต่างกันมาก แต่โดยทั่วไปจะเล็กมาก) .

สำหรับภาพรวมรายละเอียดเพิ่มเติมของโดยเฉพาะกรณีที่ความผิดพลาดในความถูกต้องสามารถนำให้ดูที่ส่วนความแม่นยำของบทความวิกิพีเดีย สุดท้ายหากคุณต้องการการอภิปรายอย่างจริงจังในเชิงลึก (และคณิตศาสตร์) ของจำนวนจุดลอยตัว / การดำเนินงานในระดับเครื่องลองอ่านบทความอ้างบ่อยอะไรทุกนักวิทยาศาสตร์คอมพิวเตอร์ควรรู้เกี่ยวกับจุดลอยเลขคณิต

ดูเหมือนว่าคุณจะเห็นประโยชน์ของการใช้ชนิดจุดลอยตัว ฉันมักจะออกแบบสำหรับทศนิยมในทุกกรณีและพึ่งพา profiler เพื่อแจ้งให้เราทราบหากการดำเนินการกับทศนิยมนั้นทำให้เกิดปัญหาคอขวดหรือช้าลง ในกรณีเหล่านั้นฉันจะ "ลดระดับลง" เป็นสองเท่าหรือลอย แต่จะทำภายในเท่านั้นและพยายามจัดการการสูญเสียที่แม่นยำด้วยความระมัดระวังโดย จำกัด จำนวนตัวเลขที่สำคัญในการดำเนินการทางคณิตศาสตร์

โดยทั่วไปหากค่าของคุณเป็นแบบชั่วคราว (ไม่ได้นำมาใช้ซ้ำ) คุณจะปลอดภัยในการใช้ชนิดจุดลอย ปัญหาที่แท้จริงของประเภทจุดลอยตัวเป็นสามสถานการณ์

1. คุณกำลังรวมค่าจุดลอยตัว (ซึ่งในกรณีนี้คือสารประกอบข้อผิดพลาดความแม่นยำ)
2. คุณสร้างค่าตามค่าของจุดลอยตัว (ตัวอย่างเช่นในอัลกอริทึมแบบเรียกซ้ำ)
3. คุณกำลังทำคณิตศาสตร์ด้วยตัวเลขจำนวนมาก (ตัวอย่างเช่น123456789.1 * .000000000000000987654321)

แก้ไข

ตามเอกสารอ้างอิงใน C # ทศนิยม :

ทศนิยมคำหลักหมายถึง 128 บิตชนิดข้อมูล เมื่อเปรียบเทียบกับทศนิยมประเภททศนิยมมีความแม่นยำมากขึ้นและช่วงที่เล็กลงซึ่งเหมาะสำหรับการคำนวณทางการเงินและการเงิน

ดังนั้นเพื่อชี้แจงงบข้างต้นของฉัน:

ฉันมักจะออกแบบสำหรับทศนิยมในทุกกรณีและพึ่งพา profiler เพื่อแจ้งให้เราทราบหากการดำเนินการกับทศนิยมนั้นทำให้เกิดปัญหาคอขวดหรือช้าลง

ฉันเคยทำงานในอุตสาหกรรมที่มีตำแหน่งเป็นทศนิยม หากคุณกำลังทำงานกับ phsyics หรือเอ็นจิ้นกราฟิกมันน่าจะมีประโยชน์มากกว่าสำหรับการออกแบบสำหรับประเภทจุดลอยตัว (float หรือ double)

ทศนิยมไม่แม่นยำอย่างแน่นอน (เป็นไปไม่ได้ที่จะแสดงความแม่นยำไม่สิ้นสุดสำหรับการไม่รวมในประเภทข้อมูลดั้งเดิม) แต่มันแม่นยำกว่าสองเท่า:

• ทศนิยม = 28-29 ตัวเลขที่สำคัญ
• double = 15-16 เลขนัยสำคัญ
• float = 7 ตัวเลขนัยสำคัญ

แก้ไข 2

เพื่อตอบสนองต่อความคิดเห็นของKonrad Rudolphรายการ # 1 (ด้านบน) นั้นถูกต้องแน่นอน การรวมกันของความไม่แน่นอนจะรวมกันแน่นอน ดูรหัสด้านล่างสำหรับตัวอย่าง:

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();
}

ผลลัพธ์นี้ต่อไปนี้:

Three Fifths: 0.6000000000
Six Hundred Thousand: 600000.0000000000
Single: 599093.4000000000
Double: 599999.9999886850
Decimal: 600000.0000000000

อย่างที่คุณเห็นแม้ว่าเราจะเพิ่มจากค่าคงที่ของแหล่งเดียวกันผลลัพธ์ของ double นั้นมีความแม่นยำน้อยกว่า (แม้ว่าอาจจะเป็นรอบที่ถูกต้อง) และการลอยนั้นมีความแม่นยำน้อยกว่าจนถึงจุดที่ลดลงเหลือเพียง ตัวเลขสองหลักที่สำคัญ

ใช้ทศนิยมสำหรับค่าฐาน 10 เช่นการคำนวณทางการเงินตามที่คนอื่นแนะนำ

แต่โดยทั่วไปแล้ว double จะมีความแม่นยำมากกว่าสำหรับค่าที่คำนวณได้

ตัวอย่างเช่นหากคุณต้องการคำนวณน้ำหนักของแต่ละบรรทัดในพอร์ตโฟลิโอใช้สองเท่าเพราะผลลัพธ์จะเพิ่มขึ้นเกือบ 100%

ในตัวอย่างต่อไปนี้ doubleResult นั้นใกล้กับ 1 มากกว่า decimalResult:

// Add one third + one third + one third with decimal
decimal decimalValue = 1M / 3M;
decimal decimalResult = decimalValue + decimalValue + decimalValue;
// Add one third + one third + one third with double
double doubleValue = 1D / 3D;
double doubleResult = doubleValue + doubleValue + doubleValue;

ดังนั้นอีกครั้งนำตัวอย่างของผลงาน:

• มูลค่าตลาดของแต่ละบรรทัดในพอร์ทการลงทุนเป็นค่าเงินและอาจจะแสดงได้ดีที่สุดในรูปทศนิยม

• น้ำหนักของแต่ละบรรทัดในพอร์ตการลงทุน (= มูลค่าตลาด / SUM (มูลค่าตลาด)) มักจะแสดงได้ดีกว่าเป็นสองเท่า

ใช้ double หรือ float เมื่อคุณไม่ต้องการความแม่นยำตัวอย่างเช่นในเกม platformer ที่ผมเขียนผมใช้ float เพื่อเก็บความเร็วผู้เล่น เห็นได้ชัดว่าฉันไม่ต้องการความแม่นยำสูงที่นี่เพราะในที่สุดฉันก็ถึง Int สำหรับการวาดภาพบนหน้าจอ

ในการบัญชีบางบัญชีพิจารณาความเป็นไปได้ของการใช้ชนิดอินทิกรัลแทนหรือร่วมกัน ตัวอย่างเช่นสมมติว่ากฎที่คุณดำเนินการภายใต้กำหนดให้ทุกผลลัพธ์การคำนวณมีทศนิยมอย่างน้อย 6 ตำแหน่งและผลลัพธ์สุดท้ายจะถูกปัดเศษเป็นเงินที่ใกล้ที่สุด

การคำนวณ 1 / 6th ของ $ 100 ให้ผลตอบแทน $ 16.66666666666666 ... ดังนั้นค่าที่ดำเนินการในแผ่นงานจะเท่ากับ $ 16.666667 ทั้งสองและทศนิยมควรให้ผลลัพธ์ที่แม่นยำถึง 6 ตำแหน่งทศนิยม อย่างไรก็ตามเราสามารถหลีกเลี่ยงข้อผิดพลาดสะสมโดยดำเนินการส่งผลเป็นจำนวนเต็ม 16666667 การคำนวณแต่ละครั้งสามารถทำด้วยความแม่นยำเดียวกันและดำเนินการไปข้างหน้าในทำนองเดียวกัน ต่อจากตัวอย่างฉันคำนวณภาษีการขายของเท็กซัสในจำนวนนั้น (16666667 * .0825 = 1375000) การเพิ่มทั้งสอง (เป็นแผ่นงานสั้น ๆ ) 1666667 + 1375000 = 18041667 การย้ายจุดทศนิยมกลับมาให้เรา 18.041667 หรือ $ 18.04

ในขณะที่ตัวอย่างสั้น ๆ นี้จะไม่ทำให้เกิดข้อผิดพลาดสะสมโดยใช้ double หรือ decimal มันค่อนข้างง่ายที่จะแสดงกรณีที่เพียงแค่การคำนวณ double หรือ decimal และการดำเนินการต่อไป หากกฎที่คุณดำเนินการภายใต้กำหนดให้มีจำนวนทศนิยม จำกัด ให้จัดเก็บแต่ละค่าเป็นจำนวนเต็มโดยคูณด้วย 10 ^ (ต้องระบุจำนวนทศนิยม #) แล้วหารด้วย 10 ^ (จำเป็นต้องใช้ทศนิยม # ตำแหน่ง) เพื่อให้ได้ค่าจริง ค่าจะหลีกเลี่ยงข้อผิดพลาดสะสม

ในสถานการณ์ที่เศษส่วนของเพนนีไม่เกิดขึ้น (ตัวอย่างเช่นเครื่องขายแสตมป์อัตโนมัติ) ไม่มีเหตุผลที่จะใช้ประเภทที่ไม่มีส่วนประกอบใด ๆ เลย คิดเพียงว่าเป็นการนับเหรียญไม่ใช่ดอลลาร์ ฉันเห็นโค้ดที่การคำนวณทุกครั้งเกี่ยวข้องกับเพนนีทั้งหมดเท่านั้น แต่การใช้ double ทำให้เกิดข้อผิดพลาด! คณิตศาสตร์เพียงจำนวนเต็มลบปัญหา ดังนั้นคำตอบที่ไม่เป็นทางการของฉันคือถ้าเป็นไปได้ให้ปัดทั้งสองและทศนิยม

หากคุณต้องการที่จะทำงานร่วมกันระหว่างไบนารีกับภาษาหรือแพลตฟอร์มอื่น ๆ คุณอาจต้องใช้ float หรือ double ซึ่งเป็นมาตรฐาน

หมายเหตุ: โพสต์นี้อ้างอิงจากข้อมูลความสามารถของประเภททศนิยมจากhttp://csharpindepth.com/Articles/General/Decimal.aspxและการตีความของฉันเองเกี่ยวกับความหมายนั้น ฉันจะถือว่า Double เป็นเรื่องปกติ IEEE double precision

Note2: เล็กที่สุดและใหญ่ที่สุดในการโพสต์นี้ถึงขนาดของจำนวน

ข้อดีของ "ทศนิยม"

• "ทศนิยม" สามารถแสดงตัวเลขที่แน่นอนซึ่งสามารถเขียนเป็นเศษส่วนทศนิยม (สั้นพอ) สองเท่าไม่สามารถ นี่เป็นสิ่งสำคัญในบัญชีแยกประเภททางการเงินและคล้ายกันซึ่งเป็นสิ่งสำคัญที่ผลลัพธ์ตรงกับสิ่งที่มนุษย์ทำการคำนวณ
• "ฐานสิบ" มีขนาดที่ใหญ่กว่า "สองเท่า" นั่นหมายความว่าสำหรับค่าภายในช่วง "ทศนิยม" ที่ปรับให้เป็นมาตรฐานจะมีความแม่นยำสูงกว่าสองเท่า

ข้อเสียของทศนิยม

• มันจะช้ากว่ามาก (ฉันไม่มีการวัดประสิทธิภาพ แต่ฉันเดาว่าอย่างน้อยลำดับความสำคัญอาจมากกว่า) ทศนิยมจะไม่ได้รับประโยชน์จากการเร่งด้วยฮาร์ดแวร์ใด ๆ ซึ่งมีราคาแพงกว่าการคูณและการหารด้วยพลังของ 2) เพื่อให้ตรงกับเลขชี้กำลังก่อนบวก / ลบและนำเลขชี้กำลังกลับมาเป็นระยะหลังจากการคูณ / การหาร
• ทศนิยมจะล้นก่อนหน้านี้สองเท่าจะ ทศนิยมสามารถแสดงตัวเลขได้สูงสุดถึง± 2 ⁹⁶ -1 โดยการเปรียบเทียบ double สามารถแสดงตัวเลขได้สูงถึง± 2 ¹⁰²⁴
• ทศนิยมจะต่ำกว่าก่อนหน้านี้ ตัวเลขที่เล็กที่สุดซึ่งแสดงในทศนิยมเป็น± 10 -28 โดยการเปรียบเทียบสองครั้งสามารถเป็นตัวแทนของค่าลงไป^2-149 (ประมาณ 10 ^-45 ) ถ้าสนับสนุนตัวเลข subnromal และ 2 ^-126 (ประมาณ 10 ^-38 ) ถ้าพวกเขาไม่ได้
• ทศนิยมใช้หน่วยความจำมากขึ้นเป็นสองเท่า

ความคิดเห็นของฉันคือคุณควรเริ่มต้นด้วยการใช้ "ทศนิยม" สำหรับงานเงินและกรณีอื่น ๆ ที่การจับคู่การคำนวณของมนุษย์เป็นสิ่งสำคัญและคุณควรใช้ double เป็นตัวเลือกเริ่มต้นของคุณตลอดเวลา

ขึ้นอยู่กับสิ่งที่คุณต้องการ

เพราะลอยและดับเบิลเป็นชนิดข้อมูลไบนารีคุณมีบาง diifculties และ errrors ในทางในจำนวนรอบดังนั้นสำหรับตัวอย่างเช่นคู่จะรอบ .1-.100000001490116 สองครั้งก็จะรอบที่ 1 / 3-.33333334326441 เพียงแค่ใส่ตัวเลขจริงไม่ได้ทั้งหมดที่มีการแสดงที่ถูกต้องในสองประเภท

โชคดีที่ C # ยังรองรับการคำนวณทศนิยมทศนิยมที่เรียกว่าตัวเลขที่แสดงผ่านระบบตัวเลขทศนิยมมากกว่าระบบเลขฐานสอง ดังนั้นทศนิยมทศนิยมไม่ได้สูญเสียความแม่นยำเมื่อจัดเก็บและประมวลผลตัวเลขจุดลอย สิ่งนี้ทำให้มันเหมาะอย่างยิ่งกับการคำนวณที่ต้องการความแม่นยำระดับสูง

ใช้คะแนนลอยถ้าคุณให้ความสำคัญกับประสิทธิภาพมากกว่าความถูกต้อง

เลือกประเภทฟังก์ชั่นของแอปพลิเคชันของคุณ หากคุณต้องการความแม่นยำในการวิเคราะห์ทางการเงินคุณได้ตอบคำถามของคุณแล้ว แต่ถ้าใบสมัครของคุณสามารถชำระด้วยการประมาณของคุณตกลงกับคู่

ใบสมัครของคุณต้องการการคำนวณที่รวดเร็วหรือว่าเขาจะมีเวลาทั้งหมดในโลกที่จะให้คำตอบกับคุณ? ขึ้นอยู่กับประเภทของแอปพลิเคชัน

กราฟิคหิวไหม? ลอยหรือสองครั้งก็เพียงพอ การวิเคราะห์ข้อมูลทางการเงินอุกกาบาตโดดเด่นด้วยความแม่นยำระดับโลก? สิ่งเหล่านั้นต้องการความแม่นยำเล็กน้อย :)

ทศนิยมมีไบต์ที่กว้างขึ้นสนับสนุน CPU เป็นสองเท่า ทศนิยมคือฐาน -10 ดังนั้นการแปลงทศนิยมเป็นสองเท่าจะเกิดขึ้นขณะคำนวณทศนิยม

For accounting - decimal
For finance - double
For heavy computation - double

โปรดทราบว่า. NET CLR รองรับเฉพาะ Math.Pow (สองเท่า) ไม่รองรับทศนิยม

.NET Framework 4

[SecuritySafeCritical]
public static extern double Pow(double x, double y);

ค่าสองเท่าจะทำให้อนุกรมเป็นสัญลักษณ์ทางวิทยาศาสตร์ตามค่าเริ่มต้นหากสัญกรณ์นั้นสั้นกว่าการแสดงทศนิยม (เช่น .00000003 จะเป็น 3e-8) ค่าทศนิยมจะไม่เรียงลำดับเป็นสัญลักษณ์ทางวิทยาศาสตร์ เมื่อซีเรียลไลซ์เพื่อการบริโภคโดยบุคคลภายนอกนี่อาจเป็นข้อพิจารณา