Π এর মান পাওয়ার দ্রুততম উপায় কী?


322

আমি ব্যক্তিগত চ্যালেঞ্জ হিসাবে π এর মান অর্জনের দ্রুততম উপায়টি সন্ধান করছি। আরও সুনির্দিষ্টভাবে, আমি এমন উপায়গুলি ব্যবহার করছি যা #defineধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে M_PIকাটানো হয় না।

নীচের প্রোগ্রামটি আমার জানা বিভিন্ন উপায়ে পরীক্ষা করে। তাত্ত্বিকভাবে ইনলাইন অ্যাসেম্বলি সংস্করণটি হ'ল দ্রুততম বিকল্প, যদিও এটি স্পষ্টভাবে বহনযোগ্য নয়। অন্যান্য সংস্করণগুলির সাথে তুলনা করার জন্য আমি এটিকে বেসলাইন হিসাবে অন্তর্ভুক্ত করেছি। আমার পরীক্ষাগুলিতে, বিল্ট-ইনগুলির সাথে, 4 * atan(1)সংস্করণটি জিসিসি ৪.২-তে দ্রুততম হয় কারণ এটি atan(1)একটি ধ্রুবককে স্বয়ংক্রিয়ভাবে ভাঁজ করে । সঙ্গে -fno-builtinনির্দিষ্ট atan2(0, -1)সংস্করণ দ্রুততম হয়।

এখানে মূল পরীক্ষার প্রোগ্রাম ( pitimes.c) রয়েছে:

#include <math.h>
#include <stdio.h>
#include <time.h>

#define ITERS 10000000
#define TESTWITH(x) {                                                       \
    diff = 0.0;                                                             \
    time1 = clock();                                                        \
    for (i = 0; i < ITERS; ++i)                                             \
        diff += (x) - M_PI;                                                 \
    time2 = clock();                                                        \
    printf("%s\t=> %e, time => %f\n", #x, diff, diffclock(time2, time1));   \
}

static inline double
diffclock(clock_t time1, clock_t time0)
{
    return (double) (time1 - time0) / CLOCKS_PER_SEC;
}

int
main()
{
    int i;
    clock_t time1, time2;
    double diff;

    /* Warmup. The atan2 case catches GCC's atan folding (which would
     * optimise the ``4 * atan(1) - M_PI'' to a no-op), if -fno-builtin
     * is not used. */
    TESTWITH(4 * atan(1))
    TESTWITH(4 * atan2(1, 1))

#if defined(__GNUC__) && (defined(__i386__) || defined(__amd64__))
    extern double fldpi();
    TESTWITH(fldpi())
#endif

    /* Actual tests start here. */
    TESTWITH(atan2(0, -1))
    TESTWITH(acos(-1))
    TESTWITH(2 * asin(1))
    TESTWITH(4 * atan2(1, 1))
    TESTWITH(4 * atan(1))

    return 0;
}

এবং ইনলাইন সমাবেশের জিনিসগুলি ( fldpi.c) যা কেবল x86 এবং x64 সিস্টেমের জন্য কাজ করবে:

double
fldpi()
{
    double pi;
    asm("fldpi" : "=t" (pi));
    return pi;
}

এবং একটি বিল্ড স্ক্রিপ্ট যা আমি যা পরীক্ষা করে যাচ্ছি সমস্ত কনফিগারেশন তৈরি করে ( build.sh):

#!/bin/sh
gcc -O3 -Wall -c           -m32 -o fldpi-32.o fldpi.c
gcc -O3 -Wall -c           -m64 -o fldpi-64.o fldpi.c

gcc -O3 -Wall -ffast-math  -m32 -o pitimes1-32 pitimes.c fldpi-32.o
gcc -O3 -Wall              -m32 -o pitimes2-32 pitimes.c fldpi-32.o -lm
gcc -O3 -Wall -fno-builtin -m32 -o pitimes3-32 pitimes.c fldpi-32.o -lm
gcc -O3 -Wall -ffast-math  -m64 -o pitimes1-64 pitimes.c fldpi-64.o -lm
gcc -O3 -Wall              -m64 -o pitimes2-64 pitimes.c fldpi-64.o -lm
gcc -O3 -Wall -fno-builtin -m64 -o pitimes3-64 pitimes.c fldpi-64.o -lm

বিভিন্ন সংকলক পতাকাগুলির মধ্যে পরীক্ষা করা ছাড়াও (iz৪-বিটের তুলনায় আমি 32-বিটের তুলনাও করেছি কারণ অপটিমাইজেশন আলাদা)), আমিও পরীক্ষার ক্রমটি স্যুইচ করার চেষ্টা করেছি। কিন্তু তবুও, atan2(0, -1)সংস্করণটি প্রতিবার শীর্ষে আসে।


38
সি ++ রূপকবিদ্যায় এটি করার একটি উপায় থাকতে হবে। রান সময় সত্যিই ভাল হবে, কিন্তু সংকলন সময় হবে না।
ডেভিড থর্নলি

1
আপনি কেন এমএনআইআই ব্যবহারের চেয়ে আতান (1) ব্যবহারের বিবেচনা করবেন? আমি যদি বুঝতে পারি যে আপনি কেন এটি করতে চান তবে আপনি যদি গাণিতিক ক্রিয়াকলাপগুলি ব্যবহার করেন তবে আতানের সাথে আমি বিষয়টিটি দেখতে পাচ্ছি না।
এরিক্ক্যালেন

9
প্রশ্নটি হল: আপনি কেন ধ্রুবক ব্যবহার করতে চান না ? যেমন হয় কোনও গ্রন্থাগার দ্বারা সংজ্ঞায়িত করা হয় বা নিজের দ্বারা নির্ধারিত? কম্পিউটিং পাই হ'ল সিপিইউ চক্রের অপচয়, কারণ এই সমস্যাটি বারবার এবং বার বার সমাধান করা হয়েছে প্রতিদিনের গণনার জন্য প্রয়োজনের চেয়ে অনেক বেশি উল্লেখযোগ্য অঙ্কগুলিতে
Tilo

2
@ হোপলেস এন00 বি ইংরাজির উপভাষায় আমি বলি, "অপ্টিমাইজেশন" একটি "এস" দিয়ে বানান , একটি "জেড" নয় (যা "জেড" হিসাবে পরিচিত, বিটিডাব্লু, "জি" নয় ;-))। (আপনি যদি পর্যালোচনার ইতিহাসের দিকে তাকান তবে এই ধরণের সম্পাদনাটিও আমার প্রথমবারের মতো ফিরে আসতে হবে না))
ক্রিস জেস্টার-ইয়ং

উত্তর:


205

উল্লিখিত মোন্ট কার্লো পদ্ধতিটি কয়েকটি দুর্দান্ত ধারণা প্রয়োগ করে তবে এটি স্পষ্টতই দ্রুততম নয়, দীর্ঘ শট দ্বারা নয়, কোনও যুক্তিসঙ্গত ব্যবস্থা দ্বারা নয়। এছাড়াও, আপনি কী ধরণের নির্ভুলতার সন্ধান করছেন তার উপরও এটি নির্ভর করে। দ্রুততম test আমি জানি যেগুলি হার্ড কোডাঙ্কিত অঙ্কগুলির সাথে একটি। পাই এবং পাই [পিডিএফ] এর দিকে তাকালে অনেকগুলি সূত্র রয়েছে।

এখানে এমন একটি পদ্ধতি যা দ্রুত রূপান্তরিত হয় - পুনরাবৃত্তির জন্য প্রায় 14 অঙ্ক। পাইফাস্ট , বর্তমানের দ্রুততম অ্যাপ্লিকেশন, এফএফটি সহ এই সূত্রটি ব্যবহার করে। কোডটি সোজা বলে আমি কেবল সূত্রটি লিখব। এই সূত্রটি প্রায় রামানুজন খুঁজে পেয়েছিলেন এবং চুদনভস্কি আবিষ্কার করেছিলেন । প্রকৃতপক্ষে তিনি কীভাবে সংখ্যার কয়েক বিলিয়ন অঙ্ক গণনা করেছিলেন - তাই এটি উপেক্ষা করার কোনও পদ্ধতি নয়। সূত্রটি দ্রুত উপচে পড়বে এবং যেহেতু আমরা ফ্যাক্টরিওরিয়ালগুলি বিভক্ত করছি তাই পদক্ষেপগুলি অপসারণ করতে এই জাতীয় গণনাগুলিকে বিলম্ব করা তখন সুবিধাজনক হবে।

এখানে চিত্র বর্ণনা লিখুন

এখানে চিত্র বর্ণনা লিখুন

কোথায়,

এখানে চিত্র বর্ণনা লিখুন

নীচে ব্রেন্ট – সালামিন অ্যালগরিদম রয়েছে । উইকিপিডিয়া উল্লেখ করেছে যে যখন a এবং b "পর্যাপ্ত কাছাকাছি" থাকবে তখন (a + b) ² / 4t হবে π এর একটি অনুমান π আমি নিশ্চিত "যথেষ্ট ঘনিষ্ঠ" এর অর্থ কী, তবে আমার পরীক্ষাগুলি থেকে একটি পুনরাবৃত্তির 2 ডিজিট পেয়েছিল, দুটি পেয়েছিল 7 পেয়েছে এবং তিনটিতে 15 রয়েছে, অবশ্যই এটি দ্বিগুণ সহ, সুতরাং এর প্রতিনিধিত্বের ভিত্তিতে এটির একটি ত্রুটি থাকতে পারে এবং সত্য হিসাব আরো সঠিক হতে পারে।

let pi_2 iters =
    let rec loop_ a b t p i =
        if i = 0 then a,b,t,p
        else
            let a_n = (a +. b) /. 2.0 
            and b_n = sqrt (a*.b)
            and p_n = 2.0 *. p in
            let t_n = t -. (p *. (a -. a_n) *. (a -. a_n)) in
            loop_ a_n b_n t_n p_n (i - 1)
    in 
    let a,b,t,p = loop_ (1.0) (1.0 /. (sqrt 2.0)) (1.0/.4.0) (1.0) iters in
    (a +. b) *. (a +. b) /. (4.0 *. t)

শেষ অবধি, কিছু পাই গল্ফ (800 ডিজিট) কেমন? 160 অক্ষর!

int a=10000,b,c=2800,d,e,f[2801],g;main(){for(;b-c;)f[b++]=a/5;for(;d=0,g=c*2;c-=14,printf("%.4d",e+d/a),e=d%a)for(b=c;d+=f[b]*a,f[b]=d%--g,d/=g--,--b;d*=b);}

1
ধরে নিই যে আপনি প্রথমটিকে নিজে প্রয়োগ করার চেষ্টা করছেন, sqr (k3) সমস্যা হবে না? আমি নিশ্চিত যে এটি একটি অযৌক্তিক সংখ্যার সমাপ্ত হবে যা আপনার অনুমান করতে হবে (আইআইআরসি, সমস্ত শিকড় যা পুরো সংখ্যা নয় অযৌক্তিক)। আপনি যদি অসীম নির্ভুলতা পাটিগণিত ব্যবহার করে তবে অন্য বর্গমূলটি ডিল ব্রেকার হয় তবে অন্য সমস্ত কিছু দেখতে বেশ সোজা-এগিয়ে দেখায়। দ্বিতীয়টিতে একটি স্কয়ার্টও অন্তর্ভুক্ত রয়েছে।
বিল কে

2
আমার অভিজ্ঞতায়, 'যথেষ্ট কাছাকাছি থাকা' এর অর্থ সাধারণত একটি টেলর সিরিজের প্রায় জড়িত।
স্টিফেন

117

আমি এই প্রোগ্রামটি সত্যিই পছন্দ করি কারণ এটি তার নিজের অঞ্চলটি দেখে x

আইওসিসি 1988: ওয়েস্টলি.সি

#define _ -F<00||--F-OO--;
int F=00,OO=00;main(){F_OO();printf("%1.3f\n",4.*-F/OO/OO);}F_OO()
{
            _-_-_-_
       _-_-_-_-_-_-_-_-_
    _-_-_-_-_-_-_-_-_-_-_-_
  _-_-_-_-_-_-_-_-_-_-_-_-_-_
 _-_-_-_-_-_-_-_-_-_-_-_-_-_-_
 _-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
 _-_-_-_-_-_-_-_-_-_-_-_-_-_-_
 _-_-_-_-_-_-_-_-_-_-_-_-_-_-_
  _-_-_-_-_-_-_-_-_-_-_-_-_-_
    _-_-_-_-_-_-_-_-_-_-_-_
        _-_-_-_-_-_-_-_
            _-_-_-_
}

1
যদি আপনি _F-00 <FF_00- এর সাথে _- এ প্রতিস্থাপন করেন - তবে এটি অনুসরণ করা আরও সহজ হওয়া উচিত :-)
প্যাট

1
বা, যদি আপনি _ এর সাথে প্রতিস্থাপন করেন "যদি (পূর্ববর্তী অক্ষরটি '-')) OO--;} F--;"
ফ্রাইগ্যু

6
এটি 0.25 এখানে মুদ্রণ করে
জোহানেস স্কাউব -

8
এই প্রোগ্রামটি 1998 সালে দুর্দান্ত ছিল, তবে এটি ভেঙে গিয়েছিল কারণ আধুনিক প্রিপ্রসেসরগুলি ম্যাক্রো বিস্তারের চারপাশে স্পেস সন্নিবেশ করাতে আরও উদার হয় যাতে এই জাতীয় জিনিসগুলি কাজ করা থেকে বিরত থাকে। দুর্ভাগ্যক্রমে এটি একটি ধ্বংসাবশেষ।
ক্রিস লুৎজ

38
পাশ --traditional-cppথেকে CPP অভিপ্রেত আচরণ জন্য।
নিটেচে-জোউ 6'10

78

আমি উচ্চ বিদ্যালয়ে শিখেছি পাই পাই গণনা করার জন্য একটি কৌশলটির একটি সাধারণ বিবরণ এখানে।

আমি কেবল এটি ভাগ করেছি কারণ আমি মনে করি এটি যথেষ্ট সহজ যে কেউ এটিকে অনির্দিষ্টকালের জন্য মনে রাখতে পারে, পাশাপাশি এটি আপনাকে "মন্টি-কার্লো" পদ্ধতিগুলির ধারণা দেয় - যা উত্তরগুলি পৌঁছানোর পরিসংখ্যানগত পদ্ধতি যা তা অবিলম্বে উপস্থিত হয় না বলে মনে হয় are এলোমেলো প্রক্রিয়াগুলির মাধ্যমে ছাড়যোগ্য।

একটি বর্গক্ষেত্র আঁকুন এবং সেই বর্গাকারের ভিতরে একটি চতুর্ভুজ (অর্ধবৃত্তের এক চতুর্থাংশ) অনুলিপি করুন (বর্গাকার পার্শ্বের সমান ব্যাসার্ধ সহ একটি চতুর্ভুজ, তাই এটি যথাসম্ভব বর্গক্ষেত্রটি পূর্ণ করে তোলে)

এখন স্কয়ারের একটি ডার্ট ফেলে দিন এবং এটি কোথায় পৌঁছেছে তা রেকর্ড করুন - এটি, স্কোয়ারের অভ্যন্তরে যে কোনও জায়গা এলোমেলো পয়েন্ট চয়ন করুন। অবশ্যই এটি স্কোয়ারের অভ্যন্তরে অবতীর্ণ হয়েছিল তবে এটি কি আধা-বৃত্তের ভিতরে রয়েছে? এই ঘটনাটি রেকর্ড করুন।

এই প্রক্রিয়াটি বহুবার পুনরাবৃত্তি করুন - এবং আপনি দেখতে পাবেন যে অর্ধবৃত্তের ভিতরে পয়েন্টের সংখ্যার অনুপাত রয়েছে সম্পূর্ণ নিক্ষেপিত সংখ্যাটির তুলনায়, এই অনুপাতটি x বলুন।

যেহেতু বর্গক্ষেত্রের ক্ষেত্রফল r গুণ r, তাই আপনি অনুমান করতে পারেন যে আধা বৃত্তের ক্ষেত্রফল x গুণ r বার r (অর্থাত্ x বার r স্কোয়ার)। সুতরাং x বার 4 আপনি পাই দিতে হবে।

এটি ব্যবহারের জন্য দ্রুত পদ্ধতি নয়। তবে এটি মন্টি কার্লো পদ্ধতির একটি দুর্দান্ত উদাহরণ। এবং যদি আপনি চারপাশে তাকান, আপনি দেখতে পাবেন যে অন্যথায় আপনার গণনা দক্ষতার বাইরে অনেকগুলি সমস্যা এই জাতীয় পদ্ধতিগুলির দ্বারা সমাধান করা যেতে পারে।


2
স্কুলে জাভা প্রকল্পে পাইটি গণনা করার জন্য আমরা এই পদ্ধতিটি ব্যবহার করি। এক্স, ওয়াই স্থানাঙ্ক এবং আরও 'ডার্ট' নিয়ে আসার জন্য সবেমাত্র একটি র্যান্ডমাইজার ব্যবহার করেছি আমরা যে পাই এর কাছাকাছি পৌঁছে দিয়েছিলাম।
জেফ ক্যাসলিনেকে

55

সম্পূর্ণতার স্বার্থে, একটি সি ++ টেম্পলেট সংস্করণ, যা একটি অনুকূলিত বিল্ডের জন্য, সংকলন সময়ে পিআইয়ের একটি অনুমানের গণনা করবে এবং একক মানকে ইনলাইন করবে।

#include <iostream>

template<int I>
struct sign
{
    enum {value = (I % 2) == 0 ? 1 : -1};
};

template<int I, int J>
struct pi_calc
{
    inline static double value ()
    {
        return (pi_calc<I-1, J>::value () + pi_calc<I-1, J+1>::value ()) / 2.0;
    }
};

template<int J>
struct pi_calc<0, J>
{
    inline static double value ()
    {
        return (sign<J>::value * 4.0) / (2.0 * J + 1.0) + pi_calc<0, J-1>::value ();
    }
};


template<>
struct pi_calc<0, 0>
{
    inline static double value ()
    {
        return 4.0;
    }
};

template<int I>
struct pi
{
    inline static double value ()
    {
        return pi_calc<I, I>::value ();
    }
};

int main ()
{
    std::cout.precision (12);

    const double pi_value = pi<10>::value ();

    std::cout << "pi ~ " << pi_value << std::endl;

    return 0;
}

আই> 10 এর জন্য দ্রষ্টব্য, অনুকূলিত বিল্ডগুলি ধীর হতে পারে, একইভাবে অ-অপটিমাইজড রানের জন্যও। 12 পুনরাবৃত্তির জন্য আমি বিশ্বাস করি যে মান () (স্মৃতিচারণের অনুপস্থিতিতে) প্রায় 80k কল রয়েছে।


আমি এটি চালিয়েছি এবং "পাই ~ 3.14159265383"
ম্যাক্সওয়েলব

5
ওয়েল, এটি 9 ডিপি-র সঠিক। আপনি কি কিছু আপত্তি বা শুধুমাত্র একটি পর্যবেক্ষণ করছেন?
জন-হ্যানসন

পিআই গণনা করতে এখানে ব্যবহৃত অ্যালগরিদমের নাম কী?
সেবাস্তিও মিরান্ডা

1
@ সেবাস্তিও-মিরান্ডা লাইবনিজের সূত্র , গড় ত্বরণ সহ অভিব্যক্তির উন্নতি ঘটায়। pi_calc<0, J>সূত্র থেকে প্রতিটি ধারাবাহিক শব্দ গণনা করে এবং অ- pi_calc<I, J>বিশেষকৃত গড় গণনা করে।
জন-হ্যানসন

43

জোনাথন এবং পিটার বোরউইনের ( অ্যামাজনে উপলভ্য ) 'পাই:' পাই এবং এজিএম 'র গণনা করার জন্য দ্রুত পদ্ধতিগুলিতে উত্সর্গীকৃত (অন্যান্য জিনিসের মধ্যে) একটি সম্পূর্ণ বই রয়েছে ।

আমি এজিএম এবং সম্পর্কিত অ্যালগরিদমগুলি কিছুটা অধ্যয়ন করেছি: এটি বেশ আকর্ষণীয় (যদিও কখনও কখনও অ-তুচ্ছ)।

নোট করুন যে modern পাই গণনা করার জন্য বেশিরভাগ আধুনিক অ্যালগরিদমগুলি প্রয়োগ করতে আপনার একটি মাল্টিপ্রেসিশন পাটিগণিত গ্রন্থাগার ( GMP বেশ ভাল পছন্দ, যদিও আমি এটি শেষ বার ব্যবহার করেছি)।

সেরা অ্যালগরিদমের সময়-জটিলতা হল ও (এম (এন) লগ (এন)) এ, যেখানে এম (এন) দুটি এন-বিট পূর্ণসংখ্যার (এম (এন) = ও (এন) এর গুণনের সময়-জটিলতা where লগ (এন) লগ (লগ (এন))) এফএফটি-ভিত্তিক অ্যালগরিদম ব্যবহার করে, যা সাধারণত \ পাই এর অঙ্কগুলি গণনা করার সময় প্রয়োজন হয়, এবং এই জাতীয় একটি অ্যালগরিদম জিএমপিতে প্রয়োগ করা হয়)।

দ্রষ্টব্য যে যদিও অ্যালগরিদমের পিছনে গণিতটি তুচ্ছ নাও হতে পারে, তবে অ্যালগোরিদমগুলি সাধারণত ছদ্ম-কোডের কয়েকটি লাইন হয় এবং তাদের প্রয়োগ সাধারণত খুব সোজা হয় (যদি আপনি নিজের মাল্টিপ্রেসিশন গাণিতিক :-) না লিখেন তবে)।


42

নিম্নতম কমপিউটিং প্রচেষ্টা সহ - দ্রুততম উপায়ে কীভাবে এটি করবেন তা নীচের উত্তরগুলি সুনির্দিষ্টভাবে দেয় । এমনকি যদি আপনি উত্তরটি পছন্দ না করেন তবে আপনাকে স্বীকার করতে হবে যে এটি অবশ্যই পিআইয়ের মান পাওয়ার দ্রুততম উপায়।

সবচেয়ে দ্রুততায় পথ Pi এর মান পেতে হয়:

1) আপনার পছন্দসই প্রোগ্রামিং ভাষাটি বেছে নিয়েছে 2) এর গণিত লাইব্রেরিটি লোড করুন 3) এবং পাইটি ইতিমধ্যে সেখানে সংজ্ঞায়িত করা আছে - ব্যবহারের জন্য প্রস্তুত!

যদি আপনার হাতে ম্যাথ লাইব্রেরি না থাকে ..

দ্বিতীয় দ্রুততম উপায় (আরও সার্বজনীন সমাধান) হল:

ইন্টারনেটে পাই দেখুন, যেমন এখানে:

http://www.eveandersson.com/pi/digits/1000000 (1 মিলিয়ন অঙ্ক .. আপনার ভাসমান পয়েন্ট যথার্থতা কি?)

বা এখানে:

http://3.141592653589793238462643383279502884197169399375105820974944592.com/

বা এখানে:

http://en.wikipedia.org/wiki/Pi

আপনি যে যথার্থ পাটিগণিতটি ব্যবহার করতে চান তার জন্য প্রয়োজনীয় অঙ্কগুলি সন্ধান করা দ্রুত এবং আপনি একটি ধ্রুবককে সংজ্ঞায়িত করে নিশ্চিত করতে পারেন যে আপনি মূল্যবান সিপিইউ সময় নষ্ট করবেন না।

এটি কেবল একটি আংশিক কৌতুকপূর্ণ উত্তরই নয়, তবে বাস্তবে যদি কেউ এগিয়ে যায় এবং সত্যিকারের অ্যাপ্লিকেশনটিতে পাইয়ের মান গণনা করে .. তবে এটি সিপিইউর সময়ের বেশ বড় অপচয় হবে, তাই না? কমপক্ষে আমি এটি পুনরায় গণনা করার চেষ্টা করার জন্য সত্যিকারের অ্যাপ্লিকেশন দেখছি না।

প্রিয় মডারেটর: দয়া করে নোট করুন যে ওপি জিজ্ঞাসা করেছিল: "পিআইয়ের মান পাওয়ার দ্রুততম উপায়"


প্রিয় টিলো: দয়া করে নোট করুন যে ওপি বলেছেন: "আমি ব্যক্তিগত চ্যালেঞ্জ হিসাবে π এর মান অর্জনের দ্রুততম উপায়টি খুঁজছি More আরও সুনির্দিষ্টভাবে, আমি এমপিআইআই এর মতো # ডেফাইন কনস্ট্যান্ট ব্যবহার না করার উপায়গুলি ব্যবহার করছি , বা সংখ্যাটি হার্ড-কোডিং
সর্বোচ্চ

প্রিয় @ ম্যাক্স: দয়া করে মনে রাখবেন যে আমি উত্তর দেওয়ার পরে ওপি তাদের মূল প্রশ্নটি সম্পাদনা করেছে - এটিই আমার দোষ খুব কমই;) আমার সমাধানটি এখনও সবচেয়ে দ্রুততম উপায় এবং কোনও পছন্দসই ভাসমান পয়েন্ট যথার্থতা এবং কোনও সিপিইউ চক্রটি মার্জিতভাবে সমাধান করে না :)
টিলো

ওহ দুঃখিত, আমি বুঝতে পারি নি। কেবল একটি চিন্তা, হার্ড কোডিং ধ্রুবকগুলির পাই পাই গণনা করার চেয়ে কম নির্ভুলতা থাকবে না? আমি অনুমান করি যে এটি কোন ভাষাটি এবং স্রষ্টা সমস্ত সংখ্যায় :-) রাখার জন্য স্রষ্টাকে কতটা আগ্রহী তার উপর নির্ভর করে
সর্বোচ্চ

1
অভিপ্রায় আমি প্রিয় টিলো
ম্যাক্স

27

BBP সূত্র বেস 2 (বা 16) মধ্যে - - যদি আপনি n তম অঙ্ক গনা করতে পারবেন এমনকি প্রথম পূর্ববর্তী এন -1 সংখ্যায় বিরক্ত না করেও :)


23

পাইটিকে ধ্রুবক হিসাবে সংজ্ঞায়িত করার পরিবর্তে আমি সর্বদা ব্যবহার করি acos(-1)


2
কোস (-1), বা অ্যাকোস (-1)? :-P সেই (পরের )টি আমার আসল কোডের একটি পরীক্ষার কেস। এটি আমার পছন্দের মধ্যে রয়েছে (আতান 2 (0, -1 সহ), যা আসলে অ্যাকোস (-1) এর সমান হয়, ব্যতীত যে অ্যাকোস সাধারণত আতান 2 এর ক্ষেত্রে প্রয়োগ করা হয়) তবে কিছু সংকলক 4 * আতান (1) এর জন্য অনুকূলিত হন !
ক্রিস জেস্টার-ইয়াং

21

এটি একটি "ক্লাসিক" পদ্ধতি, প্রয়োগ করা খুব সহজ। পাইথনের এই বাস্তবায়ন (দ্রুততম ভাষা নয়) এটি করে:

from math import pi
from time import time


precision = 10**6 # higher value -> higher precision
                  # lower  value -> higher speed

t = time()

calc = 0
for k in xrange(0, precision):
    calc += ((-1)**k) / (2*k+1.)
calc *= 4. # this is just a little optimization

t = time()-t

print "Calculated: %.40f" % calc
print "Constant pi: %.40f" % pi
print "Difference: %.40f" % abs(calc-pi)
print "Time elapsed: %s" % repr(t)

আপনি এখানে আরও তথ্য পেতে পারেন ।

যাইহোক, পাইথনের পাইয়ের মান হিসাবে যতটা চান তার সুনির্দিষ্ট হওয়ার দ্রুততম উপায় হ'ল:

from gmpy import pi
print pi(3000) # the rule is the same as 
               # the precision on the previous code

জিম্পি পাই পদ্ধতির উত্সের অংশটি এখানে দেওয়া হয়েছে, আমি মনে করি না যে কোডটি এই ক্ষেত্রে মন্তব্যের মতো কার্যকর:

static char doc_pi[]="\
pi(n): returns pi with n bits of precision in an mpf object\n\
";

/* This function was originally from netlib, package bmp, by
 * Richard P. Brent. Paulo Cesar Pereira de Andrade converted
 * it to C and used it in his LISP interpreter.
 *
 * Original comments:
 * 
 *   sets mp pi = 3.14159... to the available precision.
 *   uses the gauss-legendre algorithm.
 *   this method requires time o(ln(t)m(t)), so it is slower
 *   than mppi if m(t) = o(t**2), but would be faster for
 *   large t if a faster multiplication algorithm were used
 *   (see comments in mpmul).
 *   for a description of the method, see - multiple-precision
 *   zero-finding and the complexity of elementary function
 *   evaluation (by r. p. brent), in analytic computational
 *   complexity (edited by j. f. traub), academic press, 1976, 151-176.
 *   rounding options not implemented, no guard digits used.
*/
static PyObject *
Pygmpy_pi(PyObject *self, PyObject *args)
{
    PympfObject *pi;
    int precision;
    mpf_t r_i2, r_i3, r_i4;
    mpf_t ix;

    ONE_ARG("pi", "i", &precision);
    if(!(pi = Pympf_new(precision))) {
        return NULL;
    }

    mpf_set_si(pi->f, 1);

    mpf_init(ix);
    mpf_set_ui(ix, 1);

    mpf_init2(r_i2, precision);

    mpf_init2(r_i3, precision);
    mpf_set_d(r_i3, 0.25);

    mpf_init2(r_i4, precision);
    mpf_set_d(r_i4, 0.5);
    mpf_sqrt(r_i4, r_i4);

    for (;;) {
        mpf_set(r_i2, pi->f);
        mpf_add(pi->f, pi->f, r_i4);
        mpf_div_ui(pi->f, pi->f, 2);
        mpf_mul(r_i4, r_i2, r_i4);
        mpf_sub(r_i2, pi->f, r_i2);
        mpf_mul(r_i2, r_i2, r_i2);
        mpf_mul(r_i2, r_i2, ix);
        mpf_sub(r_i3, r_i3, r_i2);
        mpf_sqrt(r_i4, r_i4);
        mpf_mul_ui(ix, ix, 2);
        /* Check for convergence */
        if (!(mpf_cmp_si(r_i2, 0) && 
              mpf_get_prec(r_i2) >= (unsigned)precision)) {
            mpf_mul(pi->f, pi->f, r_i4);
            mpf_div(pi->f, pi->f, r_i3);
            break;
        }
    }

    mpf_clear(ix);
    mpf_clear(r_i2);
    mpf_clear(r_i3);
    mpf_clear(r_i4);

    return (PyObject*)pi;
}

সম্পাদনা: কাটা এবং পেস্ট এবং ইন্ডেন্টেশন নিয়ে আমার কিছু সমস্যা হয়েছিল, আপনি উত্সটি এখানে খুঁজে পেতে পারেন ।



18

আপনি যদি কোনও আনুমানিক ব্যবহার করতে ইচ্ছুক হন তবে 355 / 1136 দশমিক সংখ্যার জন্য ভাল এবং পূর্ণসংখ্যার ভাবের সাথে ব্যবহারযোগ্য হওয়ার অতিরিক্ত সুবিধা রয়েছে। এটি আজকাল ততটা গুরুত্বপূর্ণ নয়, কারণ "ফ্লোটিং পয়েন্ট ম্যাথ কো-প্রসেসর" এর কোনও অর্থ বন্ধ হয়ে যায় তবে এটি একবারে বেশ গুরুত্বপূর্ণ ছিল।


18

মেশিনের মতো সূত্র ব্যবহার করুন

176 * arctan (1/57) + 28 * arctan (1/239) - 48 * arctan (1/682) + 96 * arctan(1/12943) 

[; \left( 176 \arctan \frac{1}{57} + 28 \arctan \frac{1}{239} - 48 \arctan \frac{1}{682} + 96 \arctan \frac{1}{12943}\right) ;], for you TeX the World people.

প্রকল্পে প্রয়োগ করা হয়েছে, উদাহরণস্বরূপ:

(+ (- (+ (* 176 (atan (/ 1 57))) (* 28 (atan (/ 1 239)))) (* 48 (atan (/ 1 682)))) (* 96 (atan (/ 1 12943))))


16

দ্বিগুণ সহ:

4.0 * (4.0 * Math.Atan(0.2) - Math.Atan(1.0 / 239.0))

এটি 14 দশমিক স্থানে সঠিক হবে, যা দ্বিগুণ পূরণের জন্য যথেষ্ট (ত্রুটির কারণ সম্ভবত আর্ক ট্যানজেন্টের দশমিক দশকগুলি কাটা হয়েছে)।

শেঠ, এটি 3.14159265358979323846 3 , 64 নয়।


16

পাই ঠিক 3! [প্রফেসর ফ্রিংক (সিম্পসনস)]

রসিকতা, তবে এখানে সি # তে একটি। (নেট নেট ফ্রেমওয়ার্ক প্রয়োজন)।

using System;
using System.Text;

class Program {
    static void Main(string[] args) {
        int Digits = 100;

        BigNumber x = new BigNumber(Digits);
        BigNumber y = new BigNumber(Digits);
        x.ArcTan(16, 5);
        y.ArcTan(4, 239);
        x.Subtract(y);
        string pi = x.ToString();
        Console.WriteLine(pi);
    }
}

public class BigNumber {
    private UInt32[] number;
    private int size;
    private int maxDigits;

    public BigNumber(int maxDigits) {
        this.maxDigits = maxDigits;
        this.size = (int)Math.Ceiling((float)maxDigits * 0.104) + 2;
        number = new UInt32[size];
    }
    public BigNumber(int maxDigits, UInt32 intPart)
        : this(maxDigits) {
        number[0] = intPart;
        for (int i = 1; i < size; i++) {
            number[i] = 0;
        }
    }
    private void VerifySameSize(BigNumber value) {
        if (Object.ReferenceEquals(this, value))
            throw new Exception("BigNumbers cannot operate on themselves");
        if (value.size != this.size)
            throw new Exception("BigNumbers must have the same size");
    }

    public void Add(BigNumber value) {
        VerifySameSize(value);

        int index = size - 1;
        while (index >= 0 && value.number[index] == 0)
            index--;

        UInt32 carry = 0;
        while (index >= 0) {
            UInt64 result = (UInt64)number[index] +
                            value.number[index] + carry;
            number[index] = (UInt32)result;
            if (result >= 0x100000000U)
                carry = 1;
            else
                carry = 0;
            index--;
        }
    }
    public void Subtract(BigNumber value) {
        VerifySameSize(value);

        int index = size - 1;
        while (index >= 0 && value.number[index] == 0)
            index--;

        UInt32 borrow = 0;
        while (index >= 0) {
            UInt64 result = 0x100000000U + (UInt64)number[index] -
                            value.number[index] - borrow;
            number[index] = (UInt32)result;
            if (result >= 0x100000000U)
                borrow = 0;
            else
                borrow = 1;
            index--;
        }
    }
    public void Multiply(UInt32 value) {
        int index = size - 1;
        while (index >= 0 && number[index] == 0)
            index--;

        UInt32 carry = 0;
        while (index >= 0) {
            UInt64 result = (UInt64)number[index] * value + carry;
            number[index] = (UInt32)result;
            carry = (UInt32)(result >> 32);
            index--;
        }
    }
    public void Divide(UInt32 value) {
        int index = 0;
        while (index < size && number[index] == 0)
            index++;

        UInt32 carry = 0;
        while (index < size) {
            UInt64 result = number[index] + ((UInt64)carry << 32);
            number[index] = (UInt32)(result / (UInt64)value);
            carry = (UInt32)(result % (UInt64)value);
            index++;
        }
    }
    public void Assign(BigNumber value) {
        VerifySameSize(value);
        for (int i = 0; i < size; i++) {
            number[i] = value.number[i];
        }
    }

    public override string ToString() {
        BigNumber temp = new BigNumber(maxDigits);
        temp.Assign(this);

        StringBuilder sb = new StringBuilder();
        sb.Append(temp.number[0]);
        sb.Append(System.Globalization.CultureInfo.CurrentCulture.NumberFormat.CurrencyDecimalSeparator);

        int digitCount = 0;
        while (digitCount < maxDigits) {
            temp.number[0] = 0;
            temp.Multiply(100000);
            sb.AppendFormat("{0:D5}", temp.number[0]);
            digitCount += 5;
        }

        return sb.ToString();
    }
    public bool IsZero() {
        foreach (UInt32 item in number) {
            if (item != 0)
                return false;
        }
        return true;
    }

    public void ArcTan(UInt32 multiplicand, UInt32 reciprocal) {
        BigNumber X = new BigNumber(maxDigits, multiplicand);
        X.Divide(reciprocal);
        reciprocal *= reciprocal;

        this.Assign(X);

        BigNumber term = new BigNumber(maxDigits);
        UInt32 divisor = 1;
        bool subtractTerm = true;
        while (true) {
            X.Divide(reciprocal);
            term.Assign(X);
            divisor += 2;
            term.Divide(divisor);
            if (term.IsZero())
                break;

            if (subtractTerm)
                this.Subtract(term);
            else
                this.Add(term);
            subtractTerm = !subtractTerm;
        }
    }
}

15

ডি সঙ্গে সংকলন সময়ে পিআই গণনা করুন

( ডিএসোর্স.অর্গ থেকে অনুলিপি করা হয়েছে )

/** Calculate pi at compile time
 *
 * Compile with dmd -c pi.d
 */
module calcpi;

import meta.math;
import meta.conv;

/** real evaluateSeries!(real x, real metafunction!(real y, int n) term)
 *
 * Evaluate a power series at compile time.
 *
 * Given a metafunction of the form
 *  real term!(real y, int n),
 * which gives the nth term of a convergent series at the point y
 * (where the first term is n==1), and a real number x,
 * this metafunction calculates the infinite sum at the point x
 * by adding terms until the sum doesn't change any more.
 */
template evaluateSeries(real x, alias term, int n=1, real sumsofar=0.0)
{
  static if (n>1 && sumsofar == sumsofar + term!(x, n+1)) {
     const real evaluateSeries = sumsofar;
  } else {
     const real evaluateSeries = evaluateSeries!(x, term, n+1, sumsofar + term!(x, n));
  }
}

/*** Calculate atan(x) at compile time.
 *
 * Uses the Maclaurin formula
 *  atan(z) = z - z^3/3 + Z^5/5 - Z^7/7 + ...
 */
template atan(real z)
{
    const real atan = evaluateSeries!(z, atanTerm);
}

template atanTerm(real x, int n)
{
    const real atanTerm =  (n & 1 ? 1 : -1) * pow!(x, 2*n-1)/(2*n-1);
}

/// Machin's formula for pi
/// pi/4 = 4 atan(1/5) - atan(1/239).
pragma(msg, "PI = " ~ fcvt!(4.0 * (4*atan!(1/5.0) - atan!(1/239.0))) );

2
দুর্ভাগ্যক্রমে, স্পর্শকাগুলি আর্কট্যানজেন্টগুলি পাইয়ের উপর ভিত্তি করে কিছুটা এই গণনাটিকে অবৈধ করে দেয়।
গ্রান্ট জনসন

14

(ডেল্ফী মধ্যে) এই সংস্করণ বিশেষ কিছুই, কিন্তু এটা যতো তাড়াতাড়ি অন্তত হয় সংস্করণ নিক হজ তার ব্লগে পোস্ট :)। আমার মেশিনে, বিলিয়ন পুনরাবৃত্তি করতে প্রায় 16 সেকেন্ড সময় লাগে, 3.14159265 25879 এর মান দেয় (সঠিক অংশটি সাহসী হয়)।

program calcpi;

{$APPTYPE CONSOLE}

uses
  SysUtils;

var
  start, finish: TDateTime;

function CalculatePi(iterations: integer): double;
var
  numerator, denominator, i: integer;
  sum: double;
begin
  {
  PI may be approximated with this formula:
  4 * (1 - 1/3 + 1/5 - 1/7 + 1/9 - 1/11 .......)
  //}
  numerator := 1;
  denominator := 1;
  sum := 0;
  for i := 1 to iterations do begin
    sum := sum + (numerator/denominator);
    denominator := denominator + 2;
    numerator := -numerator;
  end;
  Result := 4 * sum;
end;

begin
  try
    start := Now;
    WriteLn(FloatToStr(CalculatePi(StrToInt(ParamStr(1)))));
    finish := Now;
    WriteLn('Seconds:' + FormatDateTime('hh:mm:ss.zz',finish-start));
  except
    on E:Exception do
      Writeln(E.Classname, ': ', E.Message);
  end;
end.

13

পুরানো দিনগুলিতে, ছোট শব্দের আকার এবং ধীর বা অস্তিত্বের ফ্লোটিং-পয়েন্ট অপারেশন সহ আমরা এই জাতীয় জিনিসগুলি ব্যবহার করতাম:

/* Return approximation of n * PI; n is integer */
#define pi_times(n) (((n) * 22) / 7)

যে অ্যাপ্লিকেশনগুলিতে অনেক নির্ভুলতার প্রয়োজন হয় না (উদাহরণস্বরূপ ভিডিও গেমস), এটি খুব দ্রুত এবং যথেষ্ট পরিমাণে সঠিক।


11
আরও নির্ভুলতার জন্য ব্যবহার করুন 355 / 113। জড়িত সংখ্যার আকারের জন্য খুব সঠিক।
ডেভিড থর্নলি

: শুধু আউট কৌতুহল 22/7 হয়3 + 1/7
Agnius Vasiliauskas

13

যদি আপনি some (কোনও কারণে) এর মানটির একটি অনুমানের গণনা করতে চান তবে আপনার বাইনারি নিষ্কাশন অ্যালগরিদম চেষ্টা করা উচিত। বিবিপি- র বেলার্ডের উন্নতি ওকে পিআই দেয় (এন ^ 2)।


আপনি যদি গণনা করতে π এর মানের একটি অনুমান পেতে চান তবে:

PI = 3.141592654

মঞ্জুর, এটি কেবল একটি আনুমানিক এবং সম্পূর্ণ নির্ভুল নয়। এটি 0.00000000004102 এর কিছুটা বেশি বন্ধ রয়েছে। (চার দশ কোটি কোটি, প্রায় 4 / 10,000,000,000 )।


আপনি যদি গণিত করতে চান π দিয়ে , তবে নিজেকে একটি পেন্সিল এবং কাগজ বা একটি কম্পিউটার বীজগণিত প্যাকেজ পান এবং exact এর সঠিক মান, use ব্যবহার করুন π

আপনি যদি সত্যই কোনও সূত্র চান তবে এটি মজাদার:

π = - আমি ln (-1)


আপনার সূত্রটি নির্ভর করে আপনি কীভাবে জটিল বিমানে এলএনকে সংজ্ঞায়িত করেন। জটিল প্লেনের এক লাইনের সাথে এটি অ-সামঞ্জস্যপূর্ণ হতে হবে এবং এই লাইনটি নেতিবাচক আসল অক্ষ হিসাবে দেখা বেশ সাধারণ।
এরিক্ক্যালেন

12

ক্রিস দ্বারা উপরে পোস্ট করা ব্রেন্টের পদ্ধতিটি খুব ভাল; ব্রেন্ট সাধারণত স্বেচ্ছাচারিতা-নির্ভুলতা পাটিগণিতের ক্ষেত্রে একটি দৈত্য।

যদি আপনি চান তবে নবম ডিজিট, বিখ্যাত বিবিপি সূত্রটি হেক্সে কার্যকর useful


1
ব্রেন্ট পদ্ধতিটি আমার দ্বারা পোস্ট করা হয়নি; এটি আন্দ্রেয়া পোস্ট করেছিলেন এবং আমি পোস্টের সম্পাদনা শেষ ব্যক্তি হিসাবেই হয়েছিলাম। :-) তবে আমি একমত, এই পোস্টটি একটি উত্থাপণের দাবিদার।
ক্রিস জেস্টার-ইয়াং

1

বৃত্ত অঞ্চল থেকে π গণনা করা হচ্ছে :-)

<input id="range" type="range" min="10" max="960" value="10" step="50" oninput="calcPi()">
<br>
<div id="cont"></div>

<script>
function generateCircle(width) {
    var c = width/2;
    var delta = 1.0;
    var str = "";
    var xCount = 0;
    for (var x=0; x <= width; x++) {
        for (var y = 0; y <= width; y++) {
            var d = Math.sqrt((x-c)*(x-c) + (y-c)*(y-c));
            if (d > (width-1)/2) {
                str += '.';
            }
            else {
                xCount++;
                str += 'o';
            }
            str += "&nbsp;" 
        }
        str += "\n";
    }
    var pi = (xCount * 4) / (width * width);
    return [str, pi];
}

function calcPi() {
    var e = document.getElementById("cont");
    var width = document.getElementById("range").value;
    e.innerHTML = "<h4>Generating circle...</h4>";
    setTimeout(function() {
        var circ = generateCircle(width);
        e.innerHTML  = "<pre>" + "π = " + circ[1].toFixed(2) + "\n" + circ[0] +"</pre>";
    }, 200);
}
calcPi();
</script>


0

স্কোয়ার রুট এবং দু'টি বিপরীত কাজ করতে যদি আপনার আপত্তি না মনে হয় তবে চুদনভস্কি অ্যালগরিদমটি খুব দ্রুত। এটি মাত্র 2 পুনরাবৃত্তিতে ডাবল নির্ভুলতায় রূপান্তরিত হয়।

/*
    Chudnovsky algorithm for computing PI
*/

#include <iostream>
#include <cmath>
using namespace std;

double calc_PI(int K=2) {

    static const int A = 545140134;
    static const int B = 13591409;
    static const int D = 640320;

    const double ID3 = 1./ (double(D)*double(D)*double(D));

    double sum = 0.;
    double b   = sqrt(ID3);
    long long int p = 1;
    long long int a = B;

    sum += double(p) * double(a)* b;

    // 2 iterations enough for double convergence
    for (int k=1; k<K; ++k) {
        // A*k + B
        a += A;
        // update denominator
        b *= ID3;
        // p = (-1)^k 6k! / 3k! k!^3
        p *= (6*k)*(6*k-1)*(6*k-2)*(6*k-3)*(6*k-4)*(6*k-5);
        p /= (3*k)*(3*k-1)*(3*k-2) * k*k*k;
        p = -p;

        sum += double(p) * double(a)* b;
    }

    return 1./(12*sum);
}

int main() {

    cout.precision(16);
    cout.setf(ios::fixed);

    for (int k=1; k<=5; ++k) cout << "k = " << k << "   PI = " << calc_PI(k) << endl;

    return 0;
}

ফলাফল:

k = 1   PI = 3.1415926535897341
k = 2   PI = 3.1415926535897931
k = 3   PI = 3.1415926535897931
k = 4   PI = 3.1415926535897931
k = 5   PI = 3.1415926535897931

0

আরও ভাল পদ্ধতির

পাই বা স্ট্যান্ডার্ড ধারণাগুলির মতো স্ট্যান্ডার্ড ধ্রুবকগুলির আউটপুট পেতে, আপনার প্রথমে আপনি যে ভাষাটি ব্যবহার করছেন সেটি উপলভ্য বিল্টিন পদ্ধতিগুলি ব্যবহার করা উচিত। এটি দ্রুত এবং সর্বোত্তম উপায়ে একটি মান ফেরত দেবে। পাই এর মান পেতে দ্রুততম উপায় চালানোর জন্য আমি পাইথন ব্যবহার করছি।

  • গণিত লাইব্রেরির পাই ভেরিয়েবল । গণিতের গ্রন্থাগারটি একটি ধ্রুবক হিসাবে পরিবর্তনশীল পাই সংরক্ষণ করে।

math_pi.py

import math
print math.pi

লিনাক্সের সময় উপযোগ সহ স্ক্রিপ্টটি চালান /usr/bin/time -v python math_pi.py

আউটপুট:

Command being timed: "python math_pi.py"
User time (seconds): 0.01
System time (seconds): 0.01
Percent of CPU this job got: 91%
Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.03
  • গণিতের অর্ক কোস পদ্ধতি ব্যবহার করুন

acos_pi.py

import math
print math.acos(-1)

লিনাক্সের সময় উপযোগ সহ স্ক্রিপ্টটি চালান /usr/bin/time -v python acos_pi.py

আউটপুট:

Command being timed: "python acos_pi.py"
User time (seconds): 0.02
System time (seconds): 0.01
Percent of CPU this job got: 94%
Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.03

bbp_pi.py

from decimal import Decimal, getcontext
getcontext().prec=100
print sum(1/Decimal(16)**k * 
          (Decimal(4)/(8*k+1) - 
           Decimal(2)/(8*k+4) - 
           Decimal(1)/(8*k+5) -
           Decimal(1)/(8*k+6)) for k in range(100))

লিনাক্সের সময় উপযোগ সহ স্ক্রিপ্টটি চালান /usr/bin/time -v python bbp_pi.py

আউটপুট:

Command being timed: "python c.py"
User time (seconds): 0.05
System time (seconds): 0.01
Percent of CPU this job got: 98%
Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.06

সুতরাং সর্বোত্তম উপায় হ'ল ভাষা দ্বারা প্রদত্ত বিল্টিন পদ্ধতিগুলি ব্যবহার করা কারণ সেগুলি আউটপুট পাওয়ার জন্য দ্রুত এবং সর্বোত্তম। পাইথনে ম্যাথ.পিআই ব্যবহার করুন

আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.