महत्वपूर्ण अंकों की एक मनमानी संख्या के लिए गोलाई

Question 1

आप किसी भी संख्या (न केवल पूर्णांकों> 0) को एन महत्वपूर्ण अंकों में कैसे गोल कर सकते हैं ?

उदाहरण के लिए, यदि मैं तीन महत्वपूर्ण अंकों के लिए चक्कर लगाना चाहता हूं, तो मुझे एक ऐसे फार्मूले की तलाश है जो ले सके:

1,239,451 और वापसी 1,240,000

12.1257 और वापसी 12.1

.0681 और वापसी .0681

५ और वापसी ५

स्वाभाविक रूप से एल्गोरिथ्म केवल 3 के एन को संभालने के लिए हार्ड-कोडेड नहीं होना चाहिए, हालांकि यह एक शुरुआत होगी।

Question 2

यहाँ 12.100000000000001 बग अन्य उत्तर के बिना जावा में एक ही कोड है

मैंने दोहराए गए कोड को भी हटा दिया, powerजब चल रहे मुद्दों को रोकने के लिए एक प्रकार के पूर्णांक में बदल दिया n - d, और लंबे मध्यवर्ती को अधिक स्पष्ट कर दिया

बग एक छोटी संख्या के साथ बड़ी संख्या को गुणा करने के कारण हुआ था। इसके बजाय मैं समान आकार की दो संख्याओं को विभाजित करता हूं।

संपादित करें
और अधिक बग फिक्स्ड। जोड़ा 0 के लिए जाँच के रूप में यह NaN में परिणाम होगा। फ़ंक्शन वास्तव में नकारात्मक संख्याओं के साथ काम करता है (मूल कोड नकारात्मक संख्याओं को संभालता नहीं है क्योंकि नकारात्मक संख्या का लॉग एक जटिल संख्या है)

public static double roundToSignificantFigures(double num, int n) {
    if(num == 0) {
        return 0;
    }

    final double d = Math.ceil(Math.log10(num < 0 ? -num: num));
    final int power = n - (int) d;

    final double magnitude = Math.pow(10, power);
    final long shifted = Math.round(num*magnitude);
    return shifted/magnitude;
}

Question 3

यहाँ एक छोटा और मीठा जावास्क्रिप्ट कार्यान्वयन है:

function sigFigs(n, sig) {
    var mult = Math.pow(10, sig - Math.floor(Math.log(n) / Math.LN10) - 1);
    return Math.round(n * mult) / mult;
}

alert(sigFigs(1234567, 3)); // Gives 1230000
alert(sigFigs(0.06805, 3)); // Gives 0.0681
alert(sigFigs(5, 3)); // Gives 5

Question 4

सारांश:

double roundit(double num, double N)
{
    double d = log10(num);
    double power;
    if (num > 0)
    {
        d = ceil(d);
        power = -(d-N);
    }
    else
    {
        d = floor(d); 
        power = -(d-N);
    }

    return (int)(num * pow(10.0, power) + 0.5) * pow(10.0, -power);
}

तो आपको पहले गैर-शून्य अंक के दशमलव स्थान को खोजने की आवश्यकता है, फिर अगले एन -1 अंकों को सहेजें, फिर बाकी के आधार पर एनटी अंक को गोल करें।

हम पहले करने के लिए लॉग का उपयोग कर सकते हैं।

log 1239451 = 6.09
log 12.1257 = 1.08
log 0.0681  = -1.16

तो संख्या> 0 के लिए, लॉग के छत को लें। संख्या <0 के लिए, लॉग का फर्श लें।

अब हमारे पास अंक है d: 7 पहले मामले में, 2 में 2, -2 में 3।

हमें (d-N)वें अंक को राउंड करना होगा । कुछ इस तरह:

double roundedrest = num * pow(10, -(d-N));

pow(1239451, -4) = 123.9451
pow(12.1257, 1)  = 121.257
pow(0.0681, 4)   = 681

फिर मानक गोलाई की बात करें:

roundedrest = (int)(roundedrest + 0.5);

और पूर्ववत करें।

roundednum = pow(roundedrest, -(power))

बिजली कहाँ ऊपर गणना शक्ति है।

सटीकता के बारे में: वास्तव में प्योरोलॉजिकल का जवाब वास्तविक परिणाम के करीब है। लेकिन ध्यान दें कि आप किसी भी मामले में ठीक 12.1 का प्रतिनिधित्व नहीं कर सकते हैं। यदि आप उत्तर इस प्रकार हैं:

System.out.println(new BigDecimal(n));

उत्तर हैं:

Pyro's: 12.0999999999999996447286321199499070644378662109375
Mine: 12.10000000000000142108547152020037174224853515625
Printing 12.1 directly: 12.0999999999999996447286321199499070644378662109375

तो, पाइरो के जवाब का उपयोग करें!

Question 5

"लघु और मधुर" जावास्क्रिप्ट कार्यान्वयन नहीं है

Number(n).toPrecision(sig)

जैसे

alert(Number(12345).toPrecision(3)

?

क्षमा करें, मैं यहां मुखर नहीं हो रहा हूं, यह सिर्फ इतना है कि जावास्क्रिप्ट में क्लाउडीयू और .toPreults से "राउंडिट" फ़ंक्शन का उपयोग करने से मुझे अलग-अलग परिणाम मिलते हैं लेकिन केवल अंतिम अंक के चक्कर में।

जावास्क्रिप्ट:

Number(8.14301).toPrecision(4) == 8.143

नेट

roundit(8.14301,4) == 8.144

Question 6

प्योरोलॉजिकल (बहुत अच्छा!) समाधान में अभी भी एक मुद्दा है। जावा में अधिकतम दोहरा मूल्य 10 ^ 308 के आदेश पर है, जबकि न्यूनतम मूल्य 10 ^ -324 के आदेश पर है। इसलिए, जब आप roundToSignificantFiguresदस में से कुछ शक्तियों के भीतर फ़ंक्शन को लागू करते हैं, तो आप परेशानी में पड़ सकते हैं Double.MIN_VALUE। उदाहरण के लिए, जब आप कॉल करते हैं

roundToSignificantFigures(1.234E-310, 3);

तब चर powerका मान 3 - (-309) = 312 magnitudeहोगा । नतीजतन, चर बन जाएगा Infinity, और यह तब से सभी कचरा है। सौभाग्य से, यह एक दुर्गम समस्या नहीं है: यह केवल कारक है magnitude जो अतिप्रवाह है। उत्पाद वास्तव में क्या मायने रखता है num * magnitude, और यह अतिप्रवाह नहीं है। इसे हल करने का एक तरीका कारक द्वारा गुणन magintudeको दो चरणों में तोड़ना है :


 public static double roundToNumberOfSignificantDigits(double num, int n) {

    final double maxPowerOfTen = Math.floor(Math.log10(Double.MAX_VALUE));

    if(num == 0) {
        return 0;
    }

    final double d = Math.ceil(Math.log10(num < 0 ? -num: num));
    final int power = n - (int) d;

    double firstMagnitudeFactor = 1.0;
    double secondMagnitudeFactor = 1.0;
    if (power > maxPowerOfTen) {
        firstMagnitudeFactor = Math.pow(10.0, maxPowerOfTen);
        secondMagnitudeFactor = Math.pow(10.0, (double) power - maxPowerOfTen);
    } else {
        firstMagnitudeFactor = Math.pow(10.0, (double) power);
    }

    double toBeRounded = num * firstMagnitudeFactor;
    toBeRounded *= secondMagnitudeFactor;

    final long shifted = Math.round(toBeRounded);
    double rounded = ((double) shifted) / firstMagnitudeFactor;
    rounded /= secondMagnitudeFactor;
    return rounded;
}

Question 7

इस जावा समाधान के बारे में कैसे:

डबल राउंडटेसिफिकंटफिगर (डबल संख्या, इंट सटीक) {
 नया BigDecimal (संख्या) वापस करें
            । आसपास
            .doubleValue (); 
}

Question 8

यहां Ates 'जावास्क्रिप्ट का एक संशोधित संस्करण है जो नकारात्मक संख्याओं को संभालता है।

function sigFigs(n, sig) {
    if ( n === 0 )
        return 0
    var mult = Math.pow(10,
        sig - Math.floor(Math.log(n < 0 ? -n: n) / Math.LN10) - 1);
    return Math.round(n * mult) / mult;
 }

Question 9

यह 5 साल देर से आया, लेकिन हालांकि मैं अभी भी उसी मुद्दे वाले अन्य लोगों के लिए साझा करूंगा। मुझे यह पसंद है क्योंकि यह सरल है और कोड पक्ष पर कोई गणना नहीं है। अधिक जानकारी के लिए महत्वपूर्ण आंकड़े प्रदर्शित करने के लिए निर्मित विधियों को देखें ।

यदि आप इसे प्रिंट करना चाहते हैं तो यह है।

public String toSignificantFiguresString(BigDecimal bd, int significantFigures){
    return String.format("%."+significantFigures+"G", bd);
}

यह है यदि आप इसे बदलना चाहते हैं:

public BigDecimal toSignificantFigures(BigDecimal bd, int significantFigures){
    String s = String.format("%."+significantFigures+"G", bd);
    BigDecimal result = new BigDecimal(s);
    return result;
}

यहां इसका एक उदाहरण कार्रवाई में है:

BigDecimal bd = toSignificantFigures(BigDecimal.valueOf(0.0681), 2);

Question 10

जावास्क्रिप्ट:

Number( my_number.toPrecision(3) );

Numberफंक्शन फॉर्म के उत्पादन में बदल जाएगा "8.143e+5"करने के लिए "814300"।

Question 11

क्या आपने इसे हाथ से करने के तरीके को ठीक से कोड करने की कोशिश की है?

संख्या को एक स्ट्रिंग में बदलें
स्ट्रिंग की शुरुआत में, अंकों की गणना करें - अग्रणी शून्य महत्वपूर्ण नहीं हैं, बाकी सब कुछ है।
जब आप "nth" अंक पर पहुँचते हैं, तो अगले अंक पर आगे बढ़ते हैं और यदि यह 5 या उससे अधिक है, तो राउंड अप करें।
शून्य से सभी अनुगामी अंकों को बदलें।

Question 12

[सही, 2009-10-26]

अनिवार्य रूप से, एन महत्वपूर्ण आंशिक अंकों के लिए:

• संख्या को 10 ^{N से} गुणा करें।
0.5 जोड़ें
• अंश अंकों को काटें (अर्थात परिणाम को पूर्णांक में काटें)
• 10 ^{N से} विभाजित करें

एन महत्वपूर्ण अभिन्न (गैर-भिन्नात्मक) अंकों के लिए:

• संख्या को 10 ^{N से} विभाजित करें
• 0.5 जोड़ें
। अंश अंकों को काटें (यानी परिणाम को पूर्णांक में काटें)
• 10 ^{N से} गुणा करें

आप इसे किसी भी कैलकुलेटर पर कर सकते हैं, उदाहरण के लिए, जिसमें "INT" (पूर्णांक ट्रंकेशन) ऑपरेटर है।

Question 13

/**
 * Set Significant Digits.
 * @param value value
 * @param digits digits
 * @return
 */
public static BigDecimal setSignificantDigits(BigDecimal value, int digits) {
    //# Start with the leftmost non-zero digit (e.g. the "1" in 1200, or the "2" in 0.0256).
    //# Keep n digits. Replace the rest with zeros.
    //# Round up by one if appropriate.
    int p = value.precision();
    int s = value.scale();
    if (p < digits) {
        value = value.setScale(s + digits - p); //, RoundingMode.HALF_UP
    }
    value = value.movePointRight(s).movePointLeft(p - digits).setScale(0, RoundingMode.HALF_UP)
        .movePointRight(p - digits).movePointLeft(s);
    s = (s > (p - digits)) ? (s - (p - digits)) : 0;
    return value.setScale(s);
}

Question 14

यहाँ Visual Basic.NET में प्योरोलॉजिकल (वर्तमान में शीर्ष उत्तर) कोड है, किसी को भी इसकी आवश्यकता होनी चाहिए:

Public Shared Function roundToSignificantDigits(ByVal num As Double, ByVal n As Integer) As Double
    If (num = 0) Then
        Return 0
    End If

    Dim d As Double = Math.Ceiling(Math.Log10(If(num < 0, -num, num)))
    Dim power As Integer = n - CInt(d)
    Dim magnitude As Double = Math.Pow(10, power)
    Dim shifted As Double = Math.Round(num * magnitude)
    Return shifted / magnitude
End Function

Question 15

यह एक है जो मैं VB में आया था:

Function SF(n As Double, SigFigs As Integer)
    Dim l As Integer = n.ToString.Length
    n = n / 10 ^ (l - SigFigs)
    n = Math.Round(n)
    n = n * 10 ^ (l - SigFigs)
    Return n
End Function

Question 16

return new BigDecimal(value, new MathContext(significantFigures, RoundingMode.HALF_UP)).doubleValue();

Question 17

मुझे गो में इसकी आवश्यकता थी, जो कि गो मानक पुस्तकालय की कमी math.Round()(go1.10 से पहले) से थोड़ा जटिल था । इसलिए मुझे भी कोड़ा मारना पड़ा। यहाँ मेरा अनुवाद है प्योरोलॉजिकल का उत्कृष्ट उत्तर :

// TODO: replace in go1.10 with math.Round()
func round(x float64) float64 {
    return float64(int64(x + 0.5))
}

// SignificantDigits rounds a float64 to digits significant digits.
// Translated from Java at https://stackoverflow.com/a/1581007/1068283
func SignificantDigits(x float64, digits int) float64 {
    if x == 0 {
        return 0
    }

    power := digits - int(math.Ceil(math.Log10(math.Abs(x))))
    magnitude := math.Pow(10, float64(power))
    shifted := round(x * magnitude)
    return shifted / magnitude
}

Question 18

आप इन सभी गणनाओं को 10 की शक्तियों के साथ करने से बच सकते हैं।

FloatToStrF आपको (अन्य चीजों के बीच) आउटपुट वैल्यू में सटीक (महत्वपूर्ण संख्याओं की संख्या) चुनने की अनुमति देता है (जो एक स्ट्रिंग होगी)। बेशक, आप इसके बाद StrToFloat को एक फ्लोट के रूप में अपने गोल मूल्य को प्राप्त करने के लिए आवेदन कर सकते हैं।

यहाँ देखें:

http://docs.embarcadero.com/products/rad_studio/delphiAndcpp2009/HelpUpdate2/EN/html/delphivclwin32/SysUtils_FloatToStrF@Extended@TFloatFormat@Integer@Integer.html

Question 19

public static double roundToSignificantDigits(double num, int n) {
    return Double.parseDouble(new java.util.Formatter().format("%." + (n - 1) + "e", num).toString());
}

यह कोड इनबिल्ट फॉर्मेटिंग फंक्शन का उपयोग करता है जो एक राउंडिंग फंक्शन में बदल जाता है