মূল্য পেতে দ্রুততম উপায় কি ??

সমাধান কোন ভাষায় স্বাগত হয়। :-) আমি একটি ব্যক্তিগত চ্যালেঞ্জ হিসাবে, মান অর্জন করার দ্রুততম উপায় খুঁজছেন? আরো স্পষ্টভাবে আমি এমন উপায়ে ব্যবহার করছি যেগুলি #define d সংশোধনগুলি যেমন M_PI , বা হার্ড-কোডিং এর সংখ্যা ব্যবহার করে ব্যবহার করে না।

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

এখানে প্রধান পরীক্ষার প্রোগ্রাম ( pitimes.c ):

#include 
#include 
#include 

#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

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

0
যোগ সম্পাদিত
মতামত: 13
@ জিউস এই নির্দিষ্ট ক্ষেত্রে, আমার প্রশ্ন আসলে "মজাদার" মাইক্রো-অপ্টিমাইজেশান প্রশ্ন করার উদ্দেশ্যে ছিল (যা, এই দিনগুলি সম্ভবত প্রোগ্রামিং ধাঁধা এবং কোড গল্ফ ), কিন্তু" পিআই গণনা করার সবচেয়ে দ্রুততম উপায় "এর সাধারণ প্রেক্ষাপটে এই প্রশ্নটি এখানে রাখা যথেষ্ট উপযোগী বলে মনে করা হয়। তাই, কিছু পর্যায়ে, আমি সম্ভবত পুনর্বিবেচনা করব কিনা তা সম্পর্কে ভাল অ্যালগরিদম উত্তর গ্রহণ করা উচিত (সম্ভবত এনএলক্যারোনির এক), এটি মাইক্রো-অপ্টিমাইজেশনের সাথে সম্পর্কিত কিনা তা নিয়ে।
যোগ লেখক Chris Jester-Young, উৎস
@ হঠাৎ N00b ইংরেজির উপভাষাতে আমি কথা বলি, "অপ্টিমাইজেশান" বানানটি " গুলি ", না" z "(যা" zed "হিসাবে বলা হয়, বিটিডব্লিউ, না" জি ";-))। (এই প্রথমবারের মতো আমি এই ধরনের সম্পাদনাটি ফিরিয়ে আনতে পারিনি, যদি আপনি রিভিউ ইতিহাসটি দেখেন।)
যোগ লেখক Chris Jester-Young, উৎস
এনলুকারোনির উত্তরটি 100 টি আপভোট (অভিনন্দন) -এ পৌঁছেছে, তাই সম্ভবত এটি সবুজ টিক্টিকের একটি ভাল বিন্দু। উপভোগ করুন! (যদিও, এটি সম্প্রদায় উইক এবং সব থেকে, এটি কোন প্রতিনিধি তৈরি করা হয় না, তাই এনলুকারোনি এমনকি এই বিজ্ঞপ্তি এমনকি যদি নিশ্চিত না।)
যোগ লেখক Chris Jester-Young, উৎস
@ প্যাসিফার দেখুন en.wiktionary.org/wiki/boggle এবং en.wiktionary.org/wiki/mindboggling
যোগ লেখক Chris Jester-Young, উৎস
@েরিক: সব কোডে একটি বিল্ট-ইন ধ্রুবক আছে যেমন M_PI । আমি পিআই এর একটি (ভাসমান পয়েন্ট) মান (তত্ত্ব) বিভিন্ন ভাষা (এবং / অথবা তাদের অন্তর্নির্মিত লাইব্রেরি) জুড়ে কাজ করার জন্য একটি "প্রামাণিক" উপায় খুঁজে বের করার চেষ্টা করছে। আমার বর্তমান পছন্দসই পদ্ধতিটি এএনএন 2 (0, -1) </ কোড> ব্যবহার করছে, তবে সম্ভবত আরও ভাল উপায় রয়েছে।
যোগ লেখক Chris Jester-Young, উৎস
@ সাইননসরির না, আমরা কেবল গণনা পদ্ধতির কথা বলছি যা সঠিক কোডটি M_PI হিসাবে দেয় যখন ডবল স্পষ্টতাতে ছেদ করা হয়।
যোগ লেখক Chris Jester-Young, উৎস
C ++ Metaprogramming এ এটি করার একটি উপায় হতে হবে। রান সময় সত্যিই ভাল হবে, কিন্তু কম্পাইল সময় হবে না।
যোগ লেখক David Thornley, উৎস
শুধুমাত্র এক সমাধান যা পূর্ব-গণনা করা ধ্রুবক PI- এর তুলনায় দ্রুততর হয়: সূত্রগুলিতে প্রদর্শিত সমস্ত মানগুলি প্রাক-হিসাব করা, উদাহরণস্বরূপ। যখন পরিধি প্রয়োজন হয়, আপনি রিকভারি মধ্যে 2 দ্বারা পিআই দ্বারা 2 গুণ বাড়ানোর পরিবর্তে 2 * PI প্রাক গণনা করতে পারেন।
যোগ লেখক ern0, উৎস
প্রশ্ন হল: কেন আপনি না একটি ধ্রুবক ব্যবহার করতে চান? উদাহরণস্বরূপ কোন লাইব্রেরী বা নিজের দ্বারা সংজ্ঞায়িত? কম্পিউটিং পাইটি CPU চক্রের বর্জ্য, কারণ এই সমস্যাটি দৈনিক কম্পিউটেশনগুলির জন্য প্রয়োজনের তুলনায় অনেক বেশি গুরুত্বপূর্ণ সংখ্যার উপর ও বারবার সমাধান করা হয়েছে
যোগ লেখক Tilo, উৎস
কেন আপনি এন্টান (1) M_PI ব্যবহার থেকে ভিন্ন ব্যবহার বিবেচনা করবেন? আমি বুঝতে পারছি আপনি কেন এটি করতে চান যদি আপনি শুধুমাত্র গাণিতিক অপারেশন ব্যবহার করেন তবে এথান দিয়ে আমি পয়েন্টটি দেখেন না।
যোগ লেখক erikkallen, উৎস
এটি মস্তিসিকের মনোযোগ আকর্ষণ করতে হবে, যেহেতু তিনি সর্বনিম্ন সংখ্যা গণনা করার জন্য গণনীয় গণিতের বিশ্ব রেকর্ড হোল্ডার। stackoverflow.com/questions/14283270/…
যোগ লেখক Team Upvote, উৎস
@ ক্রিস জেস্টার-ইয়াং নওপ এটাই উদ্দেশ্য নয় .. আমি সম্প্রতি নিয়মগুলোতে আরও পড়তে শুরু করেছি এবং মনে করেছি যে আমি যে থ্রেডগুলি ব্যবহার করছি সেগুলি আমি ব্যবহারকারীদের মনে করিয়ে দিচ্ছি যারা হয়তো দীর্ঘমেয়াদি ফ্রেমের ভুলে গিয়েছে। আমি এখানে কোনও পুলিশে আছি বলে চেষ্টা করছি না। আমি অদ্ভুত জুড়ে এসেছি যদি ক্ষমা
যোগ লেখক Zeus, উৎস
9801 / (1103? 8) .. ছয়টি দশমিক স্থান দেয়। পিআই গণনা করার সবচেয়ে দ্রুত উপায় কি? = 3.14159273
যোগ লেখক signonsridhar, উৎস
@ ক্রিস জেটার-ইয়ং ওয়েল আমি রামানুজনকে একটি ভিডিও দেখেছি যা পিআই এর গণনা করার উপায় দিয়েছে। তাই আমি এটা ভাগ:>
যোগ লেখক signonsridhar, উৎস

20 উত্তর

এখানে হাই এর স্কুলে আমি শিখেছি Pi গণনা করার জন্য একটি কৌশল একটি সাধারণ বিবরণ।

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

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

এখন বর্গক্ষেত্রের একটি ডার্ট নিক্ষেপ করুন, এবং যেখানে এটি ভূমিতে রেকর্ড - যে, বর্গক্ষেত্রের ভিতরে কোথাও র্যান্ডম বিন্দু নির্বাচন করুন। অবশ্যই, এটি বর্গক্ষেত্রের ভিতরে প্রবেশ করেছে, কিন্তু কি সেটি অর্ধ-বৃত্তের ভিতরে? এই সত্য রেকর্ড করুন

এই প্রক্রিয়াটি অনেক বার পুনরাবৃত্তি করুন - এবং আপনি খুঁজে পাবেন যে সংখ্যাটি নিখুঁত সংখ্যা বনাম বামদিকের ভিতরের পয়েন্টের একটি অনুপাত, এই অনুপাত X এ কল করুন।

যেহেতু বর্গক্ষেত্রের ক্ষেত্রটি R এর গুণফল হয়, আপনি সেগুলি বের করতে পারেন যে আধা-বৃত্তের এলাকা x বার বার বার r (অর্থাৎ, x বার r squared)। তাই x বার 4 আপনাকে পাই দেবে

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

0
যোগ
এই পদ্ধতিটি আমরা স্কুলে একটি জাভা প্রকল্পে পাই হিসাব করতে ব্যবহৃত। শুধু একটি র্যান্ডমাইজার ব্যবহার করে x, y coordinates এবং আরো 'ডার্ট' নিয়ে আসার পর আমরা পাই এর কাছাকাছি ছুঁড়েছিলাম আমরা এসেছি।
যোগ লেখক Jeff Keslinke, উৎস

যদি দ্রুততম দ্বারা আপনি দ্রুত কোডটি টাইপ করতে চান, এখানে golfscript সমাধান রয়েছে:

;''6666,-2%{2+.2/@*\/10.3??2*+}*`1000<~\;
0
যোগ

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

এখানে একটি পদ্ধতি যা অবিলম্বে (~ 14 প্রতি পুনরাবৃত্তির সময় সংজ্ঞায়িত) converges। বর্তমান দ্রুততম আবেদন, PiFast , এই সূত্রটি ব্যবহার করে FFT এর সাথে। আমি শুধু সূত্র লিখবো, যেহেতু কোডটি সোজা এগিয়ে। এই সূত্র প্রায় দ্বারা পাওয়া যায় রামানুজন এবং Chudnovsky দ্বারা আবিষ্কৃত । এটি সংখ্যাটির কয়েক বিলিয়ন সংখ্যা গণনা করে আসলে - তাই এটি উপেক্ষা করার একটি পদ্ধতি নয়। আমরা ফ্যাক্টরিয়ালগুলি ভাগ করে নেবার পর সূত্রটি দ্রুতগতিতে প্রবাহিত হবে, শর্তাবলী সরাতে ক্যালকুলেশন করার জন্য এটি বিলম্বিত হবে।

এখানে ইমেজ বর্ণনা লিখুন

এখানে ইমেজ বর্ণনা লিখুন

কোথায়,

এখানে ইমেজ বর্ণনা লিখুন

নীচে ব্রেন্ট? সালামিন আলগোরিদম । উইকিপিডিয়া উল্লেখ করে যে যখন a এবং b 'close enough' তখন (a + b) ^ 2 / 4t pi এর একটি পরিমাপ হবে। আমি নিশ্চিত নই যে 'কী যথেষ্ট' মানে, কিন্তু আমার পরীক্ষাগুলি থেকে, এক পুনরাবৃত্তিতে ২ ডিজিট করা হয়েছে, দুইটি 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);}
0
যোগ
আপনি প্রথম এক নিজেকে বাস্তবায়ন করার চেষ্টা করছেন, sqr (k3) একটি সমস্যা হবে না? আমি পুরোপুরি নিশ্চিত যে এটি একটি অযৌক্তিক সংখ্যা শেষ করবে যা আপনাকে অনুমান করতে হবে (IIRC, সমস্ত শিকড় যা পুরো সংখ্যার নয়, অযৌক্তিক)। যদি আপনি অসীম স্পষ্টতা গাণিতিক ব্যবহার করছেন অন্য সবকিছু সুন্দর সোজা অগ্রদূত দেখায় কিন্তু যে বর্গমূল একটি চুক্তি breaker হয়। দ্বিতীয়টি একটি sqrt হিসাবে ভাল অন্তর্ভুক্ত।
যোগ লেখক Bill K, উৎস
আমার অভিজ্ঞতা, 'বন্ধ যথেষ্ট' সাধারণত জড়িত একটি টেলর সিরিজ নিছক আছে মানে।
যোগ লেখক Stephen, উৎস

আমি সত্যিই এই প্রোগ্রাম পছন্দ, যা নিজস্ব এলাকা এ খুঁজছেন দ্বারা Pi ​​approximates :-)

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

#define _ -F<00||--F-OO--;
int F=00,OO=00;main(){F_OO();printf("%1.3f\n",4.*-F/OO/OO);}F_OO()
{
            _-_-_-_
       _-_-_-_-_-_-_-_-_
    _-_-_-_-_-_-_-_-_-_-_-_
  _-_-_-_-_-_-_-_-_-_-_-_-_-_
 _-_-_-_-_-_-_-_-_-_-_-_-_-_-_
 _-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
 _-_-_-_-_-_-_-_-_-_-_-_-_-_-_
 _-_-_-_-_-_-_-_-_-_-_-_-_-_-_
  _-_-_-_-_-_-_-_-_-_-_-_-_-_
    _-_-_-_-_-_-_-_-_-_-_-_
        _-_-_-_-_-_-_-_
            _-_-_-_
}
0
যোগ
যদি আপনি _ এর সাথে _ প্রতিস্থাপন করেন তবে <00 || - F-OO-- এটি অনুসরণ করা সহজ হবে :-)
যোগ লেখক Pat, উৎস
এই প্রোগ্রাম 1998 সালে মহান ছিল, কিন্তু আধুনিক preprocessors কাজ থেকে এই মত জিনিস প্রতিরোধ করার জন্য ম্যাক্রো বিস্তার কাছাকাছি স্থান ফাঁকা স্থান সঙ্গে আরো উদার হয়, কারণ ভাঙ্গা ছিল। এটি একটি অবলুপ্তি, দুর্ভাগ্যবশত।
যোগ লেখক Chris Lutz, উৎস
এটা এখানে 0.25 প্রিন্ট -.-
যোগ লেখক Johannes Schaub - litb, উৎস
@ পেট যদি আপনি আহত হন তবে কেন আমি এটি সম্পাদনা করেছি কারণ আমি এই উত্তরটি এলকিপি লাইনের মধ্যে দেখেছি stackoverflow.com/review/low -কুটিটি-পোস্ট / 16750528 , তাই মুছে ফেলার এড়াতে আমি উত্তরটির লিঙ্কটিতে কোড যুক্ত করেছি।
যোগ লেখক Petter Friberg, উৎস
যথোপযুক্ত পদক্ষেপ গ্রহণের জন্য - প্রথাগত- cpp cpp পাস করুন
যোগ লেখক Nietzche-jou, উৎস
অথবা, যদি আপনি _ এর পরিবর্তে _ (যদি পূর্ববর্তী অক্ষরটি '-') {OO--;} F--;
যোগ লেখক FryGuy, উৎস

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

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

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

0
যোগ
আরও নির্ভুলতার জন্য 355/113 ব্যবহার করুন অন্তর্ভুক্ত সংখ্যা সংখ্যা জন্য খুব সঠিক।
যোগ লেখক David Thornley, উৎস
শুধু কৌতূহল থেকে: 22/7 হল 3 + 1/7
যোগ লেখক Agnius Vasiliauskas, উৎস

BBP সূত্র আপনাকে nth ডিজিট গণনা করতে দেয় - বেস 2 (বা 16) ) - এমনকি প্রথম n -1 অঙ্কের সাথে বিরক্ত ছাড়াও প্রথম :)

0
যোগ
0
যোগ
বেলার্ড অনেক ক্ষেত্রে অগ্রগামী ... বেশিরভাগ ক্ষেত্রে প্রথম এলজেক্সএক্সই ছিল, সম্ভবত বেশিরভাগই এক্সিকিউটেবল কম্প্রেসার (মনে হয় ইউপিএক্স কি করে, তারপর '80 এর দশকে আবার ফিরে যায়) এবং এখন অবশ্যই QEMU এবং FFMPEG উভয়ই ব্যাপকভাবে ব্যবহৃত হয় । ওহ, এবং তার আইওসিসিসি এন্ট্রি .... :- পি
যোগ লেখক Chris Jester-Young, উৎস

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

0
যোগ

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

#include 

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

template
struct pi_calc
{
    inline static double value ()
    {
        return (pi_calc::value() + pi_calc::value ()) / 2.0;
    }
};

template
struct pi_calc<0, J>
{
    inline static double value ()
    {
        return (sign::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
struct pi
{
    inline static double value ()
    {
        return pi_calc::value ();
    }
};

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

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

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

    return 0;
}

Note for I > 10, optimised builds can be slow, likewise for non-optimised runs. For 12 iterations I believe there are around 80k calls to value() (in the absence of memoisation).

0
যোগ
@ সেবাসস্টিও-মিরান্ডা লিবিনিজ এর সূত্র , একটি গড় গতিবেগ সংশ্লেষণের উন্নতি করে। pi_calc <0, J> সূত্র থেকে প্রতিটি ধারাবাহিক শব্দ গণনা করে এবং অ-বিশেষজ্ঞ pi_calc গড় হিসাব করে
যোগ লেখক jon-hanson, উৎস
ভাল, 9 ডিপি এর সঠিক। আপনি কিছু অজুহাত বা শুধু একটি পর্যবেক্ষণ করা হয়?
যোগ লেখক jon-hanson, উৎস
আমি এই চালা এবং "পাই ~ 3.14159265383" পেতে
যোগ লেখক maxwellb, উৎস
পিআই গণনা করার জন্য এখানে ব্যবহৃত অ্যালগরিদম এর নাম কি?
যোগ লেখক Sebastião Miranda, উৎস

গণনা করা হচ্ছে? বৃত্ত এলাকা থেকে :-)

<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false"> <div class="snippet-code">

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

<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 += " " } 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 = "

Generating circle...

";
    setTimeout(function() {
        var circ = generateCircle(width);
        e.innerHTML  = "
" + "? = " + circ[1].toFixed(2) + "\n" + circ[0] +"
";
    }, 200);
}
calcPi();
</script>
</div> </div>

0
যোগ

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

পাই এর মান পেতে দ্রুততম উপায়ে হল:

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

যদি আপনার হাতে একটি গণিত গ্রন্থাগার না থাকে ..

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

ইন্টারনেটে Pi সন্ধান করুন, যেমন এখানে:

http://www.eveandersson.com/pi/digits/1000000 (1 million digits .. what's your floating point precision? )

বা এখানে:

http://3.141592653589793238462643383279502884197169399375105820974944592.com/

বা এখানে:

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

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

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

প্রিয় পরিচালক: অনুগ্রহ করে লক্ষ্য করুন যে ওপি জিজ্ঞাসা করে: "দ্রুততম উপায়ে পিআইটির মান পেতে"

0
যোগ

আপনি যদি গণনা করতে চান মান একটি আনুমানিক? (কিছু কারণে), আপনি একটি বাইনারি নিষ্কাশন অ্যালগরিদম চেষ্টা করা উচিত। বেলার্ড এর BBP O তে পিআই দেয় (N ^ 2)।


যদি আপনি প্রাপ্ত করতে মূল্যের একটি আনুমানিক চান? গণনা করতে, তারপর:

PI = 3.141592654

মঞ্জুর, এটি শুধুমাত্র একটি পরিমাপ, এবং না সম্পূর্ণ সঠিক। এটি 0.00000000004102 এর চেয়ে একটু বেশি করে বন্ধ। (চার দশ-ট্রিলিয়নপন্থী, প্রায় 4 / <�উপ> 10,000,000,000 )।


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

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

? = - i ln (-1)

0
যোগ
আপনার সূত্র জটিল প্লেনে আপনি কিভাবে LN সংজ্ঞায়িত করে তার উপর নির্ভর করে। জটিল প্লেনের মধ্যে একটি লাইনের মধ্যে অ-সংলগ্ন হতে হবে এবং এটি লাইনটি নেগেটিভ রিয়েল অক্ষ হতে বেশ সাধারণ।
যোগ লেখক erikkallen, উৎস

শুধু এই এক জুড়ে যে পূর্ণতা জন্য এখানে থাকা উচিত:

পিআইতে পিআই গণনা

এটা বরং সুন্দর সম্পত্তি যে স্পষ্টতা উন্নত করা যেতে পারে প্রোগ্রামটি বড় বড়।

Here's some insight into the language itself

0
যোগ

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

( DSource.org থেকে অনুলিপি করা হয়েছে)

/** 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))) );
0
যোগ
দুর্ভাগ্যবশত, ট্যানজেন্টগুলি আর্কট্যান্টগুলি পিআই ভিত্তিক, কিছুটা এই গণনাকে অবৈধ করে।
যোগ লেখক Grant Johnson, উৎস

প্রকৃতপক্ষে একটি পুঙ্খানুপুঙ্খ বইটি (অন্য বিষয়গুলির মধ্যে) দ্রুত "পিআই এবং এজিএম" এর গণনাের পদ্ধতিগুলি, যোনাথন এবং পিটার Borwein ( Amazon এ উপলব্ধ )।

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

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

সেরা অ্যালগরিদমগুলির সময়-জটিলতাটি O (M (n) log (n)) তে থাকে, যেখানে M (n) হল দুটি এন-বিট ইন্টিজারের গুণন (M (n) = O (n লগ (এন) লগ (লগ (এন))) FFT- ভিত্তিক অ্যালগরিদম ব্যবহার করে, যা সাধারণত \ pi এর সংখ্যার সমীকরণ করার সময় প্রয়োজন হয় এবং যেমন একটি এলগরিদম জিএমপিতে প্রয়োগ করা হয়)।

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

0
যোগ

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

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 "Costant 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

এখানে gmpy pi পদ্ধতির জন্য উত্স টুকরা হয়, আমি কোড এই ক্ষেত্রে মন্তব্য হিসাবে যতটা দরকারী মনে হয় না:

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;
}

EDIT: I had some problem with cut and paste and identation, anyway you can find the source here.

0
যোগ

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

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

0
যোগ
ব্রেন্ট পদ্ধতি আমার দ্বারা পোস্ট করা হয় নি; এটা Andrea দ্বারা পোস্ট করা হয়েছে, এবং আমি ঠিক পোস্ট সম্পাদনা যারা শেষ ব্যক্তি হতে ঘটেছে। :-) কিন্তু আমি সম্মত, যে পোস্ট একটি upvote প্রাপ্য।
যোগ লেখক Chris Jester-Young, উৎস

দ্বিগুণ সঙ্গে:

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

এই 14 দশমিক স্থান সঠিক হবে, একটি ডবল পূরণ করতে যথেষ্ট (অযৌণি সম্ভবত কারণ চাপ টাংগিনের বাকি দশমিক হয় ছাঁটা হয়)।

এছাড়াও শেঠ, এটি 3.14159265358979323846 3 , 64 না।

0
যোগ

Machin- মত সূত্র ব্যবহার করুন

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 (আন্যান (1/57)) (* 28 (আন্যান (1 / ২3 9))) * (* 48 (আন (/ 1 68২))) * (* 96) (আণান (/ 1 1২943)))

0
যোগ