एक फ्लोट को 2 दशमलव तक गोल करने का सबसे अच्छा अभ्यास क्या है?

Question

मैं ग्रहण + एंड्रॉइड एसडीके का उपयोग कर रहा हूं।

मुझे एक फ्लोट वैल्यू को 2 दशमलव तक गोल करने की आवश्यकता है। मैं आमतौर पर गणित पुस्तकालय का उपयोग कर अगले "चाल" का उपयोग करता हूं।

float accelerometerX = accelerometerX * 100; 
    accelerometerX = round(accelerometerX); 
    Log.d("Test","" + accelerometerX/100); 

लेकिन मुझे लगता है यह यह करने के लिए सबसे अच्छा तरीका नहीं है।

क्या इस तरह के संचालन करने के लिए कोई पुस्तकालय है?

अग्रिम धन्यवाद।

Answer 1

मैं 2 साल पहले जावा में आँकड़ों के साथ काम कर रहा था और मैं अभी भी एक समारोह है कि आप दशमलव कि आप चाहते हैं की संख्या की एक संख्या दौर के लिए अनुमति देता का कोड मिला है। अब आपको दो की जरूरत है, लेकिन शायद आप परिणामों की तुलना करने के लिए 3 के साथ प्रयास करना चाहेंगे, और यह फ़ंक्शन आपको यह स्वतंत्रता देता है।

/** 
    * Round to certain number of decimals 
    * 
    * @param d 
    * @param decimalPlace 
    * @return 
    */ 
    public static float round(float d, int decimalPlace) { 
     BigDecimal bd = new BigDecimal(Float.toString(d)); 
     bd = bd.setScale(decimalPlace, BigDecimal.ROUND_HALF_UP); 
     return bd.floatValue(); 
    } 

आपको यह तय करने की आवश्यकता है कि आप ऊपर या नीचे जाना चाहते हैं या नहीं। मेरे नमूना कोड में मैं गोल कर रहा हूँ।

उम्मीद है कि यह मदद करता है।

संपादित

आप दशमलव की संख्या बनाए रखने के लिए जब वे शून्य हैं (मुझे लगता है कि यह सिर्फ उपयोगकर्ता को प्रदर्शित करने के लिए है) आप बस, नाव से BigDecimal के लिए समारोह प्रकार बदलने के लिए की तरह चाहते हैं इस:

public static BigDecimal round(float d, int decimalPlace) { 
     BigDecimal bd = new BigDecimal(Float.toString(d)); 
     bd = bd.setScale(decimalPlace, BigDecimal.ROUND_HALF_UP);  
     return bd; 
    } 

और फिर समारोह इस तरह से कहते हैं:

  float x = 2.3f; 
     BigDecimal result; 
     result=round(x,2); 
     System.out.println(result); 

यह प्रिंट होगा:

2.30 

Answer 2

double roundTwoDecimals(double d) { 
    DecimalFormat twoDForm = new DecimalFormat("#.##"); 
    return Double.valueOf(twoDForm.format(d)); 
} 

Answer 3

//by importing Decimal format we can do... 

import java.util.Scanner; 
import java.text.DecimalFormat; 
public class Average 
{ 
public static void main(String[] args) 
{ 
int sub1,sub2,sub3,total; 
Scanner in = new Scanner(System.in); 
System.out.print("Enter Subject 1 Marks : "); 
sub1 = in.nextInt(); 
System.out.print("Enter Subject 2 Marks : "); 
sub2 = in.nextInt(); 
System.out.print("Enter Subject 3 Marks : "); 
sub3 = in.nextInt(); 
total = sub1 + sub2 + sub3; 
System.out.println("Total Marks of Subjects = " + total); 
res = (float)total; 
average = res/3; 
System.out.println("Before Rounding Decimal.. Average = " +average +"%"); 
DecimalFormat df = new DecimalFormat("###.##"); 
System.out.println("After Rounding Decimal.. Average = " +df.format(average)+"%"); 
} 
} 
/* Output 
Enter Subject 1 Marks : 72 
Enter Subject 2 Marks : 42 
Enter Subject 3 Marks : 52 
Total Marks of Subjects = 166 
Before Rounding Decimal.. Average = 55.333332% 
After Rounding Decimal.. Average = 55.33% 
*/ 

/* Output 
Enter Subject 1 Marks : 98 
Enter Subject 2 Marks : 88 
Enter Subject 3 Marks : 78 
Total Marks of Subjects = 264 
Before Rounding Decimal.. Average = 88.0% 
After Rounding Decimal.. Average = 88% 
*/ 

/* You can Find Avrerage values in two ouputs before rounding average 
And After rounding Average..*/ 

Answer 4

यहाँ एक छोटा कार्यान्वयन @ Jav_Rock के

/** 
    * Round to certain number of decimals 
    * 
    * @param d 
    * @param decimalPlace the numbers of decimals 
    * @return 
    */ 

    public static float round(float d, int decimalPlace) { 
     return BigDecimal.valueOf(d).setScale(decimalPlace,BigDecimal.ROUND_HALF_UP).floatValue(); 
    } 



    System.out.println(round(2.345f,2));//two decimal digits, //2.35 

Answer 5

आइए परीक्षण 3 तरीकों की तुलना कर रहा है:
1)

public static double round1(double value, int scale) { 
    return Math.round(value * Math.pow(10, scale))/Math.pow(10, scale); 
} 

2)

public static float round2(float number, int scale) { 
    int pow = 10; 
    for (int i = 1; i < scale; i++) 
     pow *= 10; 
    float tmp = number * pow; 
    return ((float) ((int) ((tmp - (int) tmp) >= 0.5f ? tmp + 1 : tmp)))/pow; 
} 

3)

public static float round3(float d, int decimalPlace) { 
    return BigDecimal.valueOf(d).setScale(decimalPlace, BigDecimal.ROUND_HALF_UP).floatValue(); 
} 

संख्या 0.23453f
हम 100,000 पुनरावृत्तियों प्रत्येक विधि का परीक्षण करेंगे है।

परिणाम:
समय 1 - 18 एमएस
समय 2 - 1 एमएस
समय 3 - 378 एमएस


लैपटॉप
इंटेल i3-3310M सीपीयू 2.4GHz

पर परीक्षण किया गया

Answer 6

मैंने @Ivan Stin उत्कृष्ट 2 विधि के लिए -व मानों का समर्थन करने का प्रयास किया है।

public static float round(float value, int scale) { 
    int pow = 10; 
    for (int i = 1; i < scale; i++) { 
     pow *= 10; 
    } 
    float tmp = value * pow; 
    float tmpSub = tmp - (int) tmp; 

    return ((float) ((int) (
      value >= 0 
      ? (tmpSub >= 0.5f ? tmp + 1 : tmp) 
      : (tmpSub >= -0.5f ? tmp : tmp - 1) 
      )))/pow; 

    // Below will only handles +ve values 
    // return ((float) ((int) ((tmp - (int) tmp) >= 0.5f ? tmp + 1 : tmp)))/pow; 
} 

नीचे परीक्षण मामलों मैं कोशिश की है कर रहे हैं (प्रमुख क्रेडिट उसकी विधि के लिए Stin @Ivan को जाता है)। अगर यह किसी अन्य मामले को संबोधित नहीं कर रहा है तो कृपया मुझे बताएं।

@Test 
public void testFloatRound() { 
    // +ve values 
    Assert.assertEquals(0F, NumberUtils.round(0F), 0); 
    Assert.assertEquals(1F, NumberUtils.round(1F), 0); 
    Assert.assertEquals(23.46F, NumberUtils.round(23.4567F), 0); 
    Assert.assertEquals(23.45F, NumberUtils.round(23.4547F), 0D); 
    Assert.assertEquals(1.00F, NumberUtils.round(0.49999999999999994F + 0.5F), 0); 
    Assert.assertEquals(123.12F, NumberUtils.round(123.123F), 0); 
    Assert.assertEquals(0.12F, NumberUtils.round(0.123F), 0); 
    Assert.assertEquals(0.55F, NumberUtils.round(0.55F), 0); 
    Assert.assertEquals(0.55F, NumberUtils.round(0.554F), 0); 
    Assert.assertEquals(0.56F, NumberUtils.round(0.556F), 0); 
    Assert.assertEquals(123.13F, NumberUtils.round(123.126F), 0); 
    Assert.assertEquals(123.15F, NumberUtils.round(123.15F), 0); 
    Assert.assertEquals(123.17F, NumberUtils.round(123.1666F), 0); 
    Assert.assertEquals(123.46F, NumberUtils.round(123.4567F), 0); 
    Assert.assertEquals(123.87F, NumberUtils.round(123.8711F), 0); 
    Assert.assertEquals(123.15F, NumberUtils.round(123.15123F), 0); 
    Assert.assertEquals(123.89F, NumberUtils.round(123.8909F), 0); 
    Assert.assertEquals(124.00F, NumberUtils.round(123.9999F), 0); 
    Assert.assertEquals(123.70F, NumberUtils.round(123.7F), 0); 
    Assert.assertEquals(123.56F, NumberUtils.round(123.555F), 0); 
    Assert.assertEquals(123.00F, NumberUtils.round(123.00F), 0); 
    Assert.assertEquals(123.50F, NumberUtils.round(123.50F), 0); 
    Assert.assertEquals(123.93F, NumberUtils.round(123.93F), 0); 
    Assert.assertEquals(123.93F, NumberUtils.round(123.9312F), 0); 
    Assert.assertEquals(123.94F, NumberUtils.round(123.9351F), 0); 
    Assert.assertEquals(123.94F, NumberUtils.round(123.9350F), 0); 
    Assert.assertEquals(123.94F, NumberUtils.round(123.93501F), 0); 
    Assert.assertEquals(99.99F, NumberUtils.round(99.99F), 0); 
    Assert.assertEquals(100.00F, NumberUtils.round(99.999F), 0); 
    Assert.assertEquals(100.00F, NumberUtils.round(99.9999F), 0); 

    // -ve values 
    Assert.assertEquals(-123.94F, NumberUtils.round(-123.93501F), 0); 
    Assert.assertEquals(-123.00F, NumberUtils.round(-123.001F), 0); 
    Assert.assertEquals(-0.94F, NumberUtils.round(-0.93501F), 0); 
    Assert.assertEquals(-1F, NumberUtils.round(-1F), 0); 
    Assert.assertEquals(-0.50F, NumberUtils.round(-0.50F), 0); 
    Assert.assertEquals(-0.55F, NumberUtils.round(-0.55F), 0); 
    Assert.assertEquals(-0.55F, NumberUtils.round(-0.554F), 0); 
    Assert.assertEquals(-0.56F, NumberUtils.round(-0.556F), 0); 
    Assert.assertEquals(-0.12F, NumberUtils.round(-0.1234F), 0); 
    Assert.assertEquals(-0.12F, NumberUtils.round(-0.123456789F), 0); 
    Assert.assertEquals(-0.13F, NumberUtils.round(-0.129F), 0); 
    Assert.assertEquals(-99.99F, NumberUtils.round(-99.99F), 0); 
    Assert.assertEquals(-100.00F, NumberUtils.round(-99.999F), 0); 
    Assert.assertEquals(-100.00F, NumberUtils.round(-99.9999F), 0); 
} 

Answer 7

यहाँ एक सरल एक पंक्ति का समाधान

((int) ((value + 0.005f) * 100))/100f