यह सी # कोड मेरे द्वारा निर्दिष्ट लंबाई तक पीआई की गणना करेगा। मैं उस बिंदु पर पुनर्गणना किए बिना किसी दिए गए इंडेक्स पर शुरू करने में सक्षम होना चाहता हूं। प्रेसिजन एक बड़ी चिंता नहीं है क्योंकि यह एक पहेली परियोजना है लेकिन मुझे एक ही परिणाम को बार-बार पुन: पेश करने के लिए इस कोड की आवश्यकता है। यह ठीक काम करता है लेकिन मैं यह समझने में सक्षम नहीं हूं कि शुरुआती बिंदु के लिए कैसे संशोधित किया जाए।

//Looking to pass BigInteger to specify a starting index for continuation of calculating Pi

    public static BigInteger GetPi(int digits, int iterations)
    {
        return 16 * ArcTan1OverX(5, digits).ElementAt(iterations)
            - 4 * ArcTan1OverX(239, digits).ElementAt(iterations);
    }

    public static IEnumerable<BigInteger> ArcTan1OverX(int x, int digits)
    {
        var mag = BigInteger.Pow(10, digits);
        var sum = BigInteger.Zero;
        bool sign = true;
        for (int i = 1; true; i += 2)
        {
            var cur = mag / (BigInteger.Pow(x, i) * i);
            if (sign)
            {
                sum += cur;
            }
            else
            {
                sum -= cur;
            }
            yield return sum;
            sign = !sign;
        }
    }
c# pi
0
MarcSuther 5 फरवरी 2021, 17:58
क्या आप कुछ नमूना इनपुट और आउटपुट प्रदान कर सकते हैं?
 – 
Chetan
5 फरवरी 2021, 18:00
गेटपी(3,1) = 314
 – 
MarcSuther
5 फरवरी 2021, 18:05
या अधिक विशिष्ट: GetPi(2,1,2) = 14
 – 
MarcSuther
5 फरवरी 2021, 18:17

1 उत्तर

सबसे बढ़िया उत्तर

आप Arctan के टेलर सीरी विस्तार के साथ Machin सूत्र का उपयोग कर रहे हैं। यह आपको प्रत्येक "चक्र" के लिए सटीकता के लगभग 1.4 अंक देगा (देखें यहां)। आप टेलर श्रृंखला की गणना को "शॉर्टकट" नहीं कर सकते। आप IEnumerable<BigInteger> भाग को हटाकर और केवल nth पुनरावृत्ति (yield निर्देश की लागत है) को वापस करने और BigInteger.Pow को एक निश्चित गुणन के साथ बदलकर कार्यक्रम को थोड़ा तेज कर सकते हैं। लेकिन गणना अभी भी पुनरावृत्त रूप से की जाएगी। O(1) समय में n अंकों की शुद्धता के साथ PI की गणना करने का कोई ज्ञात तरीका नहीं है।

ध्यान दें कि एल्गोरिदम हैं (देखें wiki) जो कम संख्या में चक्रों में अभिसरण करते हैं , लेकिन मुझे यकीन नहीं है कि क्या वे कम संख्या में संचालन में जुटे हैं (उनके चक्र बहुत अधिक जटिल हैं)।

कोड का एक अनुकूलित संस्करण:

public static BigInteger GetPi2(int digits, int iterations)
{
    return 16 * ArcTan1OverX2(5, digits, iterations)
        - 4 * ArcTan1OverX2(239, digits, iterations);
}

public static BigInteger ArcTan1OverX2(int x, int digits, int iterations)
{
    var mag = BigInteger.Pow(10, digits);
    var sum = BigInteger.Zero;
    bool sign = true;

    int imax = 1 + (2 * iterations);

    int xsquared = x * x;
    BigInteger pow = x;

    for (int i = 1; i <= imax; i += 2)
    {
        if (i != 1)
        {
            pow *= xsquared;
        }

        var cur = mag / (pow * i);

        if (sign)
        {
            sum += cur;
        }
        else
        {
            sum -= cur;
        }

        sign = !sign;
    }

    return sum;
}
0
xanatos 5 फरवरी 2021, 19:48
मुझे ऐसा होने का डर था। मुझे प्रदर्शन बढ़ाने के लिए उपज छोड़ने का आपका विचार पसंद है। धन्यवाद!
 – 
MarcSuther
5 फरवरी 2021, 19:22
मैं यह भी कहूंगा कि आप BigInteger.Pow(x, i) को एक पुनरावृत्त powPrev * xsquared से बदल सकते हैं (जहां xsquared पहले से संगणित है)। एक एकल गुणन Pow से कम खर्चीला होना चाहिए। कोड का एक उदाहरण लिखा।
 – 
xanatos
5 फरवरी 2021, 19:52