แปลง float เป็นสองเท่าโดยไม่สูญเสียความแม่นยำ

ฉันมีลูกลอยดั้งเดิมและฉันต้องการเป็นคู่ดั้งเดิม เพียงแค่การลอยตัวเป็นสองเท่าทำให้ฉันมีความแม่นยำเป็นพิเศษ ตัวอย่างเช่น:

float temp = 14009.35F;
System.out.println(Float.toString(temp)); // Prints 14009.35
System.out.println(Double.toString((double)temp)); // Prints 14009.349609375

อย่างไรก็ตามหากแทนที่จะทำการแคสต์ฉันจะส่งออก float เป็นสตริงและแยกวิเคราะห์สตริงเป็นคู่ฉันจะได้สิ่งที่ต้องการ

System.out.println(Double.toString(Double.parseDouble(Float.toString(temp))));
// Prints 14009.35

มีวิธีที่ดีกว่าการไปที่ String และย้อนกลับหรือไม่?

มันไม่ใช่ว่าคุณจริงได้รับความแม่นยำเป็นพิเศษ - มันเป็นเรื่องที่ลอยไม่ต้องเป็นตัวแทนของหมายเลขที่คุณกำลังเล็งสำหรับเดิม คู่เป็นตัวแทนของการลอยตัวเดิมอย่างถูกต้อง toStringกำลังแสดงข้อมูล "พิเศษ" ซึ่งมีอยู่แล้ว

ตัวอย่างเช่น (และตัวเลขเหล่านี้ไม่ถูกต้องฉันแค่สร้างขึ้น) สมมติว่าคุณมี:

float f = 0.1F;
double d = f;

จากนั้นค่าfอาจเท่ากับ 0.100000234523 dจะมีค่าเท่ากันทุกประการ แต่เมื่อคุณแปลงเป็นสตริงมันจะ "เชื่อ" ว่ามันถูกต้องเป็นความแม่นยำที่สูงขึ้นดังนั้นจะไม่ปัดเศษทิ้งตั้งแต่เนิ่นๆและคุณจะเห็น "หลักพิเศษ" ซึ่งมีอยู่แล้ว ที่นั่น แต่ซ่อนตัวจากคุณ

เมื่อคุณแปลงเป็นสตริงและย้อนกลับคุณจะได้ค่าสองเท่าซึ่งใกล้เคียงกับค่าสตริงมากกว่าค่าโฟลตเดิม แต่จะดีก็ต่อเมื่อคุณเชื่อจริงๆว่าค่าสตริงเป็นสิ่งที่คุณต้องการจริงๆ

แน่ใจหรือว่า float / double เป็นประเภทที่เหมาะสมที่จะใช้แทนBigDecimal? หากคุณกำลังพยายามใช้ตัวเลขที่มีค่าทศนิยมที่แม่นยำ (เช่นเงิน) BigDecimalIMO เป็นประเภทที่เหมาะสมกว่า

ฉันพบว่าการแปลงเป็นการแสดงไบนารีนั้นง่ายกว่าที่จะเข้าใจปัญหานี้

float f = 0.27f;
double d2 = (double) f;
double d3 = 0.27d;

System.out.println(Integer.toBinaryString(Float.floatToRawIntBits(f)));
System.out.println(Long.toBinaryString(Double.doubleToRawLongBits(d2)));
System.out.println(Long.toBinaryString(Double.doubleToRawLongBits(d3)));

คุณสามารถเห็นการลอยตัวถูกขยายเป็นสองเท่าโดยการเพิ่ม 0s ต่อท้าย แต่การแทนค่าสองเท่าของ 0.27 นั้น 'ถูกต้องกว่า' ดังนั้นปัญหา

   111110100010100011110101110001
11111111010001010001111010111000100000000000000000000000000000
11111111010001010001111010111000010100011110101110000101001000

เพราะนี่คือสัญญาของFloat.toString(float),ที่กล่าวว่าในส่วน:

ต้องพิมพ์กี่หลักสำหรับส่วนที่เป็นเศษส่วน […]? ต้องมีอย่างน้อยหนึ่งหลักในการแสดงส่วนที่เป็นเศษส่วนและนอกเหนือจากนั้นให้มากแต่ต้องมีจำนวน หลักมากขึ้นเท่านั้นเพื่อแยกความแตกต่างของค่าอาร์กิวเมนต์จากค่าที่อยู่ติดกันของประเภท float นั่นคือสมมติว่า x เป็นค่าทางคณิตศาสตร์ที่แน่นอนที่แสดงโดยการแทนค่าทศนิยมที่สร้างโดยวิธีนี้สำหรับอาร์กิวเมนต์ที่ไม่ใช่ศูนย์ จำกัด f จากนั้น f ต้องเป็นค่าลอยที่ใกล้ x ที่สุด หรือถ้าค่า float สองค่าใกล้เคียงกับ x เท่า ๆ กันดังนั้น f จะต้องเป็นค่าใดค่าหนึ่งและค่านัยสำคัญน้อยที่สุดของ f ต้องเป็น 0

ฉันพบปัญหานี้ในวันนี้และไม่สามารถใช้ refactor กับ BigDecimal ได้เนื่องจากโครงการมีขนาดใหญ่มาก อย่างไรก็ตามฉันพบวิธีแก้ปัญหาโดยใช้ไฟล์

Float result = new Float(5623.23)
Double doubleResult = new FloatingDecimal(result.floatValue()).doubleValue()

และใช้งานได้

โปรดสังเกตว่าการเรียก result.doubleValue () ส่งกลับ 5623.22998046875

แต่การเรียก doubleResult.doubleValue () กลับ 5623.23 อย่างถูกต้อง

แต่ฉันไม่แน่ใจว่ามันเป็นวิธีที่ถูกต้องหรือไม่

ฉันพบวิธีแก้ไขปัญหาต่อไปนี้:

public static Double getFloatAsDouble(Float fValue) {
    return Double.valueOf(fValue.toString());
}

หากคุณใช้floatและdoubleแทนFloatและDouble ให้ใช้ดังต่อไปนี้:

public static double getFloatAsDouble(float value) {
    return Double.valueOf(Float.valueOf(value).toString()).doubleValue();
}

ใช้BigDecimalแทนfloat/ double. มีตัวเลขจำนวนมากที่ไม่สามารถแสดงเป็นจุดลอยตัวไบนารี (ตัวอย่างเช่น0.1) ดังนั้นคุณต้องปัดเศษผลลัพธ์ให้มีความแม่นยำที่ทราบหรือใช้BigDecimalเสมอ

ดูข้อมูลเพิ่มเติมได้ที่http://en.wikipedia.org/wiki/Floating_point

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

ใช่การลอยตัวจะเร็วกว่าทศนิยมในเชิงคำนวณเนื่องจากการสนับสนุนบนโปรเซสเซอร์ อย่างไรก็ตามคุณต้องการความรวดเร็วหรือแม่นยำ?

สำหรับข้อมูลนี้อยู่ภายใต้ Item 48 - หลีกเลี่ยงการลอยตัวและเพิ่มเป็นสองเท่าเมื่อต้องการค่าที่แน่นอนของ Effective Java 2nd edition โดย Joshua Bloch หนังสือเล่มนี้อัดแน่นไปด้วยสาระดีๆและคุ้มค่าแก่การดูแน่นอน

มันใช้ได้ไหม?

float flt = 145.664454;

Double dbl = 0.0;
dbl += flt;

วิธีง่ายๆที่ใช้งานได้ดีคือการแยกวิเคราะห์คู่จากการแสดงสตริงของการลอย:

double val = Double.valueOf(String.valueOf(yourFloat));

ไม่ค่อยมีประสิทธิภาพ แต่ใช้งานได้!