पाई अभी भी गलत है [बंद]


27

पाई गलत है

कंप्यूटिंग पी की एक सामान्य विधि 1x1 बॉक्स में "डार्ट्स" को फेंकने और कुल फेंक की तुलना में यूनिट सर्कल में कौन सी भूमि है:

loop
   x = rand()
   y = rand()
   if(sqrt(x*x + y*y) <= 1) n++
   t++
pi = 4.0*(n/t)

एक प्रोग्राम लिखें जो ऐसा लगता है कि इसे सही ढंग से pi (कम्प्यूटिंग पाई के अन्य सामान्य तरीकों का उपयोग करके) करना चाहिए, लेकिन इसके बजाय tau (tau = 2 * pi = 6.283185307179586 ...) की गणना करता है । आपके कोड को कम से कम पहले 6 दशमलव स्थानों का उत्पादन करना होगा: 6.283185

विजेता को 6 जून (आज से एक सप्ताह) का ताज पहनाया गया है।


43
विजेता को 28 जून को ताज क्यों नहीं पहनाया गया ??
corsiKa

9
मुझे यकीन नहीं है कि क्यों एक विजेता को लोकप्रियता प्रतियोगिता में ताज पहनाया जाना चाहिए।
टिम एस।

1
मुझे नहीं मिला। यह ऐसे फ़ंक्शन के लिए पूछ रहा है जो वापस लौटने के लिए प्रकट होता है 1लेकिन वापस लौटता है 2। हम यहाँ किसको बेवकूफ बना रहे हैं?
ja72

3
@ ja72 कोड की :) पाठक
tomsmeding

8
सभी जानते हैं कि पाव सही है । : पी
जस्टिन क्रेजाचा

जवाबों:


57

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

alert(Math.atan2(0, -0) - Math.atan2(-0, -0) + Math.atan2(0, 0))

मदद, मैं एक ब्रह्मांड कारखाने में फंस गया हूं , और मुझे यकीन नहीं है कि मैं क्या कर रहा हूं। Math.atan2अच्छे मूल्यों के साथ पाई वापस करने के लिए माना जाता है, है ना? Math.atan2(0, -0)पीआई देता है, इसलिए यदि मैं इसे घटाता हूं, और इसे जोड़ता हूं, तो मुझे अभी भी पीआई होना चाहिए।


14
मुझे लगता है कि मैं बस लेट जाऊंगा और रोऊंगा। गोड्डामनिट, जावास्क्रिप्ट।
जैक एम

3
स्पष्टीकरण कृपया? :)
जा-सी

2
एक्स अक्ष और बिंदु (Y, X) के बीच रेडियन में वामावर्त कोण। Y बिंदु का संकेत यह निर्धारित करता है कि यह एक सकारात्मक या नकारात्मक कोण है, और यह बन जाता हैπ - (-π)

8
0_o >>> 0 === -0 ;true ;>>> Math.atan2(0, 0) ;0 ;>>> Math.atan2(0, -0) ;3.141592653589793
इज़्काटा

5
@JackM, यह कथन हमेशा कहने के लिए उपयुक्त है :) हालांकि इस मामले में, यह IEEE मानक के कारण है, और कई भाषाओं (न केवल JS) में शून्य बनाम नकारात्मक शून्य समस्या है।
पॉल ड्रेपर

40

बेसिक

(विशेष रूप से, चिपमंक बेसिक )

यह 15 वीं शताब्दी में नीलकंठ सोमयाजी द्वारा खोजी गई अनंत श्रृंखला का उपयोग करता है :

' Calculate pi using the Nilakantha series:
'               4       4       4       4
'  pi  =  3 + ----- - ----- + ----- - ------ + ...
'             2x3x4   4x5x6   6x7x8   8x9x10
i = pi = 0
numerator = -4
while i<10000
  i = i + 2
  numerator = -numerator
  pi = pi + numerator / (i * (i+1) * (i+2))
wend
pi = pi + 3
print using "#.##########";pi

उत्पादन

6.2831853072

यदि आप यह पता नहीं लगा सकते हैं कि क्या हो रहा है, तो यहां कुछ संकेत हैं:

चिपमंक बेसिक में, जब प्रोग्राम चलना शुरू होता है तो चर p , के मान पर पूर्व निर्धारित होता है।

तथा

BASIC में, समान चिन्ह का उपयोग चर को असाइन करने और समानता के परीक्षण के लिए दोनों के लिए किया जाता है। अतः a = b = c की व्याख्या = (b == c) के रूप में की जाती है


रुको मैं नहीं मिलता है, तो iबराबर है false? और फिर आप 2इसे जोड़ते हैं? और यह काम करता है ???
डुनो

2
@ डननो: ज़रूर, छोरों की शुरुआत i == falseउसी के समान होती है i == 0। मुद्दा यह है कि संचायक के लिए प्रारंभिक मान pi0 नहीं है ...
बर्गी

1
@Bergi हाँ, मैं इस तथ्य के आसपास अपना सिर नहीं लपेट सकता कि false + 2 == 2: D
Dunno

@ डूनो डायनामिक टाइपिंग आदि: मिथ्या का अर्थ अंकगणित करते समय 0 में बदल दिया जाता है। आपके पास C में एक ही स्पष्ट व्यवहार है जिसमें एक boolप्रकार का अभाव है , 0और गैर-शून्य का प्रतिनिधित्व करने falseऔर trueपुनरावृत्ति करने के लिए गैर-शून्य है । ऐसा नहीं है कि यह सुरुचिपूर्ण है, लेकिन हे, कि यह कैसे काम करता है।
सुजैन डुपरॉन

15

सी - आधा एक इकाई चक्र की लंबाई

एक तरीका यह गणना करने के लिए π बस दूरी बिंदु को मापने के लिए है (1, 0)यात्रा जब चारों और घूमती मूल के (-1, 0)बाद से यह एक के आधे परिधि हो जाएगा इकाई चक्र (जो )।

यहाँ छवि विवरण दर्ज करें

हालांकि, कोई sin(x)या cos(x)इस के बाद से की जरूरत है द्वारा किया जा सकता कदम के आसपास सभी तरह मूल और दूरी बिंदु प्रत्येक चरण के लिए यात्रा करता है जोड़ने । प्रत्येक चरण के लिए छोटे आकार के और अधिक सटीक π आप मिल जाएगा।

नोट: वाई के शून्य से नीचे होने पर कदम समाप्त हो जाएगा (जो बस गुजरता है (-1, 0))।

#include <stdio.h>                          // for printf
#define length(y, x) ((x * x) + (y * y))
int main()
{
    double x, y;
    double pi, tau, step;
    // start at (2, 0) which actually calculates tau
    x  = 2;
    y  = 0;
    // the step needs to be very low for high accuracy
    step = 0.00000001;  
    tau = 0;
    while (y >= 0)
    {   // the derivate of (x, y) is itself rotated 90 degrees
        double dx = -y;
        double dy = x;

        tau += length(dx, dy) * step; // add the distance for each step to tau
        // add the distance to the point (make a tiny rotation)
        x += dx * step;
        y += dy * step;
    }
    pi = tau / 2;   // divide tau with 2 to get pi

    /* ignore this line *\                      pi *= 2;    /* secret multiply ^-^ */

    // print the value of pi
    printf("Value of pi is %f", pi); getchar(); 
    return 0;
}

यह निम्नलिखित आउटपुट देता है:

Value of pi is 6.283185

3
वैध लगता है ... निश्चित रूप से।
bjb568

1
आपका lengthमैक्रो एक sqrt याद कर रहा है। क्या यह इरादा है? xऔर yपरिभाषा और कॉल के बीच अदला-बदली भी की जाती है (बिना किसी प्रभाव के)
बेन वायगेट

@BenVoigt Shhh! चाल को खराब मत करो, लेकिन हाँ। गलती से छोड़ दिया sqrtगया था ताकि पाई का मूल्य 6,28 के रूप में मुद्रित हो ... नोटिंग के लिए +1 और जो मैंने नहीं किया था! xy
Thism2

1
ओह, अब मैं देख रहा हूं कि आप एक इकाई वृत्त नहीं, बल्कि त्रिज्या 2 के साथ अनुगमन कर रहे हैं।
बेन वोइग्ट

7
मुझे यह स्वीकार करना चाहिए कि यह समझने से पहले कि यह कैसे काम करता है मैंने उस पंक्ति को नजरअंदाज न करके कुछ मिनट बर्बाद कर दिए ...
loreb

10

सी

(यह अभी तक की तुलना में लंबा किया जा रहा है, लेकिन मैं इसे वैसे भी पोस्ट करूँगा ...)

17 वीं शताब्दी में, वालिस ने पाई के लिए एक अनंत श्रृंखला प्रकाशित की:

यहाँ छवि विवरण दर्ज करें

( नई वालिस देखें और अधिक के लिए +, e, और 2 (2 + information2) के लिए कैटलन-टाइप अनंत उत्पाद देखें)

अब, पाई की गणना करने के लिए, हमें सबसे पहले हर को गुणनखंडन से दो गुणा गुणा करना चाहिए:

यहाँ छवि विवरण दर्ज करें

मेरा समाधान तब पीआई / 2 और दो के लिए अनंत श्रृंखला की गणना करता है और फिर दोनों मूल्यों को एक साथ गुणा करता है। ध्यान दें कि अनंत उत्पाद अंतिम मूल्यों की गणना करते समय अभिसरण करने के लिए अविश्वसनीय रूप से धीमा हैं।

उत्पादन:

pi: 6.283182
#include "stdio.h"
#include "stdint.h"

#define ITERATIONS 10000000
#define one 1

#define IEEE_MANTISSA_MASK 0xFFFFFFFFFFFFFULL

#define IEEE_EXPONENT_POSITION 52
#define IEEE_EXPONENT_BIAS 1023

// want to get an exact as possible result, so convert
// to integers and do custom 64-bit multiplication.
double multiply(double aa, double bb)
{
    // the input values will be between 1.0 and 2.0
    // so drop these to less than 1.0 so as not to deal 
    // with the double exponents.
    aa /= 2;
    bb /= 2;

    // extract fractional part of double, ignoring exponent and sign
    uint64_t a = *(uint64_t*)&aa & IEEE_MANTISSA_MASK;
    uint64_t b = *(uint64_t*)&bb & IEEE_MANTISSA_MASK;

    uint64_t result = 0x0ULL;

    // multiplying two 64-bit numbers is a little tricky, this is done in two parts,
    // taking the upper 32 bits of each number and multiplying them, then
    // then doing the same for the lower 32 bits.
    uint64_t a_lsb = (a & 0xFFFFFFFFUL);
    uint64_t b_lsb = (b & 0xFFFFFFFFUL);

    uint64_t a_msb = ((a >> 32) & 0xFFFFFFFFUL);
    uint64_t b_msb = ((b >> 32) & 0xFFFFFFFFUL);

    uint64_t lsb_result = 0;
    uint64_t msb_result = 0;

    // very helpful link explaining how to multiply two integers
    // http://stackoverflow.com/questions/4456442/interview-multiplication-of-2-integers-using-bitwise-operators
    while(b_lsb != 0)
    {
        if (b_lsb & 01)
        {
            lsb_result = lsb_result + a_lsb;
        }
        a_lsb <<= 1;
        b_lsb >>= 1;
    }
    while(b_msb != 0)
    {
        if (b_msb & 01)
        {
            msb_result = msb_result + a_msb;
        }
        a_msb <<= 1;
        b_msb >>= 1;
    }

    // find the bit position of the most significant bit in the higher 32-bit product (msb_answer)
    uint64_t x2 = msb_result;
    int bit_pos = 0;
    while (x2 >>= 1)
    {
        bit_pos++;
    }

    // stuff bits from the upper 32-bit product into the result, starting at bit 51 (MSB of mantissa)
    int result_position = IEEE_EXPONENT_POSITION - 1;
    for(;result_position > 0 && bit_pos > 0; result_position--, bit_pos--)
    {
        result |= ((msb_result >> bit_pos) & 0x01) << result_position;
    }

    // find the bit position of the most significant bit in the lower 32-bit product (lsb_answer)
    x2 = lsb_result;
    bit_pos = 0;
    while (x2 >>= 1)
    {
        bit_pos++;
    }

    // stuff bits from the lowre 32-bit product into the result, starting at whatever position
    // left off at from above.
    for(;result_position > 0 && bit_pos > 0; result_position--, bit_pos--)
    {
        result |= ((lsb_result >> bit_pos) & 0x01) << result_position;
    }

    // create hex representation of the answer
    uint64_t r = (uint64_t)(/* exponent */ (uint64_t)IEEE_EXPONENT_BIAS << IEEE_EXPONENT_POSITION) |
            (uint64_t)( /* fraction */ (uint64_t)result & IEEE_MANTISSA_MASK);

    // stuff hex into double
    double d = *(double*)&r;

    // since the two input values were divided by two,
    // need to multiply by four to fix the result.
    d *= 4;

   return d;
}

int main()
{
    double pi_over_two = one;
    double two = one;

    double num = one + one;
    double dem = one;

    int i=0;

    i=ITERATIONS;
    while(i--)
    {
        // pi = 2 2 4 4 6 6 8 8 ...
        // 2    1 3 3 5 5 7 7 9
        pi_over_two *= num / dem;

        dem += one + one;

        pi_over_two *= num / dem;

        num += one + one;
    }

    num = one + one;
    dem = one;

    i=ITERATIONS;
    while(i--)
    {
        // 2 = 2 4 4 6   10 12 12 14
        //     1 3 5 7    9 11 13 15
        two *= num / dem;

        dem += one + one;
        num += one + one;

        two *= num / dem;

        dem += one + one;

        two *= num / dem;

        dem += one + one;
        num += one + one;

        two *= num / dem;

        dem += one + one;
        num += one + one + one + one;
    }

    printf("pi: %f\n", multiply(pi_over_two, two));

    return 0;
}

दोहरे रूपांतरण में प्रतिपादक को वास्तव में नजरअंदाज नहीं किया जा सकता है। यदि यह एकमात्र परिवर्तन है (2 के द्वारा विभाजन को छोड़ दें, 4 से गुणा करें, पूर्णांक गुणा) सब कुछ आश्चर्यजनक रूप से काम करता है।


8

जावा - नीलकंठ श्रृंखला

नीलकंठ श्रृंखला इस प्रकार है:

pi = 3 + 4/(2*3*4) - 4/(4*5*6) + 4/(6*7*8) - 4/(8*9*10) ...

तो प्रत्येक पद के लिए, हर एक पूर्णांक को 2 गुणा बढ़ाकर, प्रत्येक पूर्णांक को गुणा करके, भाजक का निर्माण किया जाता है। ध्यान दें कि आप वैकल्पिक शब्दों को जोड़ते / घटाते हैं।

public class NilakanthaPi {
    public static void main(String[] args) {
        double pi = 0;
        // five hundred terms
        for(int t=1;t<500;t++){
            // each i is 2*term
            int i=t*2;
            double part = 4.0 / ((i*i*t)+(3*i*t)+(2*t));
            // flip sign for alternating terms
            if(t%2==0)
                pi -= part;
            else
                pi += part;
            // add 3 for first term
            if(t<=2)
                pi += 3;
        }
        System.out.println(pi);
    }
}

पाँच सौ शब्दों के बाद, हमें पाई का उचित अनुमान मिलता है:

6.283185311179568

4

सी ++: संगमग्राम के माधव

इस अनंत श्रृंखला को अब माधव-लीबनीज के रूप में जाना जाता है :

शृंखला

48 के वर्गमूल से शुरू करें और (-3) -k / (2k + 1) के योग के परिणाम से इसे गुणा करें । लागू करने के लिए बहुत सरल और सरल:

long double findPi(int iterations)
{
    long double value = 0.0;

    for (int i = 0; i < iterations; i++) {
        value += powl(-3.0, -i) / (2 * i + 1);
    }

    return sqrtl(48.0) * value;
}

int main(int argc, char* argv[])
{
    std::cout << "my pi: " << std::setprecision(16) << findPi(1000) << std::endl;

    return 0;
}

आउटपुट:

my pi: 6.283185307179588

3

अजगर - एक वैकल्पिक नीलकंठ श्रृंखला के लिए

पाई की गणना करने के लिए यह एक और अनंत श्रृंखला है जिसे समझना काफी आसान है।

यहाँ छवि विवरण दर्ज करें

इस सूत्र के लिए, 6 को लें और 2 के अंशों के साथ अंशों को जोड़ने और घटाने के बीच बारी-बारी से शुरू करें और हर दो पूर्णांक और उनके योग के गुणनफल हैं। प्रत्येक बाद का अंश 1 से बढ़ने वाले पूर्णांक के अपने सेट को शुरू करता है। इसे कुछ बार भी बाहर ले जाएं और परिणाम पी के काफी करीब पहुंचते हैं।

pi = 6
sign = 1
for t in range(1,500):
i = t+1
   part = 2.0 / (i*t*(i+t))
   pi = pi + sign * part
   sign = - sign # flip sign for alternating terms  
print(pi)

जो 6.283185 देता है।


-1
#include "Math.h"
#include <iostream>
int main(){
    std::cout<<PI;
    return 0;
}

math.h:

#include <Math.h>
#undef PI
#define PI 6.28

आउटपुट: 6.28

#include "Math.h" #include के समान नहीं है, लेकिन सिर्फ मुख्य फ़ाइल को देखकर, लगभग कोई भी जांचने के लिए नहीं सोचेगा। स्पष्ट रूप से शायद, लेकिन एक ऐसी ही समस्या एक परियोजना में दिखाई दी, जिस पर मैं काम कर रहा था, और लंबे समय तक अनिश्चित रहा।


फिर भी एक चतुर समाधान।
BobTheAwesome
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.