उलटा पाई समारोह

Question

Pi फ़ंक्शन वास्तविक (या यहां तक ​​कि जटिल संख्या) पर फैक्टरियल का एक विस्तार है। पूर्णांकों के लिए n , Π (n) = n! , लेकिन हम एक अभिन्न का उपयोग करके इसे परिभाषित करने वाले यथार्थ पर एक परिभाषा प्राप्त करने के लिए:

इस चुनौती में हम Π फ़ंक्शन को उल्टा करेंगे ।

वास्तविक संख्या z , 1 को देखते हुए , धनात्मक x को ऐसे खोजें जैसे कि x (x) = z । आपका उत्तर कम से कम 5 दशमलव अंकों के लिए सटीक होना चाहिए।

---

उदाहरण:

120 -> 5.0000
10 -> 3.39008
3.14 -> 2.44815
2017 -> 6.53847
1.5 -> 1.66277

Comments

ध्यान दें कि अधिक बार लोग गामा (more) फ़ंक्शन का उपयोग करते हैं। = (X) = Γ (x + 1) । लेकिन IMO and एक स्थानांतरित अपभ्रंश है, और Γ तथ्य का वास्तविक विस्तार है।

— orlp

वेल्प, वह श्रृंखला विस्तार मुझे डराने के लिए पर्याप्त है ... i.imgur.com/ttgzDSJ.gif

— मैजिक ऑक्टोपस Urn

आपके द्वारा दिए गए सभी उदाहरणों के साथ ही अन्य समाधान भी हैं 120 -> -0.991706। ऐसा इसलिए है क्योंकि x (x) अनंत तक जाता है क्योंकि x दाईं ओर से -1 तक जाता है। शायद आप का मतलब है कि x> 0 के रूप में अच्छी तरह से जोर देते हैं।

— ग्रेग मार्टिन

@GregMartin साथ ही जोड़ा गया।

— orlp

स्थानांतरित संस्करण को पसंद करने के कुछ कारण हैं, इसके बावजूद यह अप्राकृतिक लगता है। उदाहरण के लिए इस उत्तर को MathOverflow पर और साथ ही उस पृष्ठ पर अन्य देखें।

— रुस्लान

Answer 1

गणितज्ञ, १ 27 १५ २ 17 बाइट्स

FindInstance[#==x!&&x>0,x]&

आउटपुट ऐसा दिखता है {{x -> n}}, जहां nसमाधान है, जिसकी अनुमति नहीं दी जा सकती है।

Answer 2

अजगर, 4 बाइट्स

.I.!

एक प्रोग्राम जो किसी संख्या का इनपुट लेता है और परिणाम प्रिंट करता है।

परीक्षण सूट

यह काम किस प्रकार करता है

.I.!    Program. Input: Q
.I.!GQ  Implicit variable fill
.I      Find x such that:
  .!G    gamma(x+1)
     Q   == Q
        Implicitly print

Answer 3

MATL , 13 बाइट्स

1`1e-5+tQYgG<

यह 1e-5शुरू करने के चरणों में रैखिक सीच का उपयोग करता है 1। तो यह बहुत धीमा है, और ऑनलाइन कंपाइलर में कई बार बाहर है।

इसका परीक्षण करने के लिए, निम्न लिंक 1e-5सटीकता की आवश्यकता को बदल देता है 1e-2। इसे ऑनलाइन आज़माएं!

व्याख्या

1        % Push 1 (initial value)
`        % Do...while
  1e-5   %   Push 1e-5
  +      %   Add
  t      %   Duplicate
  QYg    %   Pi function (increase by 1, apply gamma function)
  G<     %   Is it less than the input? If so: next iteration
         % End (implicit)
         % Display (implicit)

Answer 4

जियोजेब्रा , 25 बाइट्स

NSolve[Gamma(x+1)=A1,x=1]

कैस इनपुट में दर्ज किया गया है, और स्प्रेडशीट सेल में एक नंबर के इनपुट की उम्मीद है A1 । प्रपत्र का एक-तत्व सरणी देता है {x = <result>}।

यहाँ निष्पादन की एक झलक है:

यह काम किस प्रकार करता है

Numerically Solveनिम्नलिखित समीकरण:, Gamma(x+1)=A1प्रारंभिक मूल्य के साथ x=1।

Comments

क्या यह एक सकारात्मक संख्या लौटने की गारंटी है, और क्या यह 1.5 के लिए काम करता है, जिसने कई उत्तर तोड़ दिए हैं?

— पावेल २

@ फावेल मैं पुष्टि कर सकता हूं कि यह काम करता है 1.5। मैं यह पता लगाने में सक्षम नहीं हूं कि संख्यात्मक हल के लिए कौन सा एल्गोरिथ्म जिप का उपयोग करता है, लेकिन शुरुआती मूल्य x=1ने मेरे द्वारा आजमाए गए हर मूल्य के लिए विशुद्ध रूप से सकारात्मक उत्तर दिए हैं।

— बाइकिंग बाइकिंग

Answer 5

MATLAB, 59 बाइट्स

@(x)fminsearch(@(t)(gamma(t+1)-x)^2,1,optimset('TolF',eps))

यह एक अनाम फ़ंक्शन है जो वांछित अंतर को प्राप्त करने के लिए 1बहुत छोटे सहिष्णुता (दिए गए eps) के साथ शुरू होने वाले पाई फ़ंक्शन और इसके इनपुट के न्यूनतम अंतर को कम करता है ।

परीक्षण मामले (मतलाब R2015b पर चलाएं):

>> @(x)fminsearch(@(t)(gamma(t+1)-x)^2,1,optimset('TolF',eps))
ans = 
    @(x)fminsearch(@(t)(gamma(t+1)-x)^2,1,optimset('TolF',eps))
>> f = ans; format long; f(120), f(10), f(3.14), f(2017)
ans =
   5.000000000000008
ans =
   3.390077650547032
ans =
   2.448151165246967
ans =
   6.538472664321318

आप इसे ऑक्टेव में ऑनलाइन आज़मा सकते हैं , लेकिन दुर्भाग्य से कुछ परिणामों में आवश्यक सटीकता की कमी है।

Answer 6

जे, 86 33 बाइट्स

((]-(-~^.@!)%[:^.@!D.1])^:_>:)@^.

अतिप्रवाह से बचने के लिए लॉग पाई के साथ न्यूटन की विधि का उपयोग करता है।

यह पिछले संस्करण है जो स्टर्लिंग के सन्निकटन का उपयोग करके लॉग गामा की गणना करता है। प्रदर्शन की लागत पर संभवतः उच्च सटीकता के लिए लॉग गामा (3) में चरण आकार (1e3) और शब्दों की संख्या बढ़ाई जा सकती है।

3 :'(-(k-~g)%%&1e3(g=:((%~12 _360 1260 p.&:%*:)+-+^~-&^.%:@%&2p1)@>:)D:1])^:_>:k=:^.y'

एक और संस्करण जो मक्खी पर गुणांक की गणना करता है

3 :'(-((-^.y)+g)%%&1e3(g=:((%~(((%1-^@-)t:%]*<:)+:>:i.3)p.%@*:)+(*^.)-]+-:@^.@%&2p1)@>:)D:1])^:_>:^.y'

इसे ऑनलाइन आज़माएं! और शब्दों को देखने के अभिसरण ।

व्याख्या

((]-(-~^.@!)%[:^.@!D.1])^:_>:)@^.  Input: float y
(                            )@^.  Operate on log(y)
                           >:        Increment, the initial guess is log(y)+1
 (                     )^:_          Repeat until convergence starting with x = log(y)+1
                      ]                Get x
               ^.@!                    The log Pi verb
             [:    D.1                 Approximate its first derivative at x
       ^.@!                            Apply log Pi to x
     -~                                Subtract log(y) from it
            %                          Divide it by the derivative
  ]-                                   Subtract it from x and use as next value of x

Answer 7

गणितज्ञ, 21 बाइट्स

FindRoot[#-x!,{x,1}]&

FindRoot प्रारंभिक मूल्य होने पर आंतरिक रूप से न्यूटन की विधि को लागू करता है।

नीचे दिए गए दो तरीके सीधे न्यूटन की विधि को लागू करते हैं।

फिक्स्डपॉइंट 45 बाइट्स का उपयोग करके वैकल्पिक

FixedPoint[#-(#!-y)/Gamma'[#+1]&,Log[y=#]+1]&

गणितज्ञ द्वारा इसे हल करने के लिए न्यूटन की विधि का अधिक सटीक कार्यान्वयन इसे व्युत्पन्न करने के बजाय सीधे व्युत्पन्न की गणना कर सकता है।

बार-बार बदलने के लिए नियमों का उपयोग करना कम होगा, लेकिन इसकी सीमा (65536) है कि यह कितने पुनरावृत्तियों कर सकता है जो हिट हो सकता है जबकि FixedPointइसकी सीमा नहीं है।

नियमों का उपयोग करके वैकल्पिक, 38 बाइट्स

Log[y=#]+1//.x_->x-(x!-y)/Gamma'[x+1]&

Answer 8

जेली , 34 बाइट्स

Ḋ!Æl_®
ȷİ‘×;µ!ÆlI÷I÷@Ç_@ḊḢ
Æl©‘ÇÐĿ

इसे ऑनलाइन आज़माएं! या मध्यवर्ती मूल्यों को देखें जैसे वे अभिसरण करते हैं ।

न्यूटन की विधि और व्युत्पन्न सन्निकटन (छेदक विधि) की जम्मू के संयोजन के एक कार्यान्वयन के व्युत्क्रम की गणना करने के Π ( एन )।

यह अतिप्रवाह से बचने के लिए लॉग ( ves ( n )) के व्युत्क्रम के लिए हल करता है ।

यह एक प्रारंभिक अनुमान के साथ शुरू होता एक्स ₀ = y +1 जहां y = लॉग ( Π ( एन ))। तो यह तक का उपयोग कर अभिसरण iterates एक्स _{n +1} = एक्स _एन (लॉग (- Π ( एक्स _एन )) - y ) / (लॉग (( Π (1.001 * एक्स _एन )) - लॉग ( Π ( एक्स _एन ))) / (0.001 * x _n ))।

Comments

मुझे इनपुट के साथ एक त्रुटि मिलती है1.5

— लुइस मेंडो

@LuisMendo वाह कि एक अच्छी पकड़ है! यह तब होता है जब मध्यवर्ती मूल्यों में से एक ~ 65807 है जो गामा लागू होने के बाद एक बहुत बड़ा मूल्य है, और पायथन ओवरफ्लो होता है। वही J में होता है क्योंकि यह एक ही संगणना पर निर्भर करता है।

— मील

Answer 9

PARI / GP, 30 बाइट्स

x->solve(t=1,x+1,gamma(t+1)-x)

1और के बीच समाधान ढूँढता है x+1। दुर्भाग्य से, xइनपुट के लिए ऊपरी बाध्य जितना बड़ा नहीं है 1.5।

Answer 10

गणितज्ञ, 26 बाइट्स

फिर भी एक और गणितज्ञ समाधान!

समीकरण को हल करना हमेशा कम से कम समस्या में बदल सकता है।

NArgMin[{(#-x!)^2,x>0},x]&

उस तर्क को ढूँढता है जो समीकरण के बाएँ और दाएँ पक्षों के बीच अंतर को कम करता है।

NMinimize की बजाय NArgMin का उपयोग करने से सामान्य वर्बोज़ नियम-आधारित आउटपुट के बजाय आउटपुट केवल वांछित परिणाम के लिए बाध्य होता है (और यह बाइट बचाता है!)

Answer 11

सी, परिवाद के साथ, 111

अद्यतन - इनपुट 1.5 के लिए तय किया गया।

f(double *z){double u=2**z,l=0,g=u,p=0;for(;log(fabs(g-p))>-14;)p=g,g=(u+l)/2,u=tgamma(g+1)>*z?g:(l=g,u);*z=g;}

gamma(x+1)सवाल में सीमा पर एक नीरस रूप से बढ़ रहा कार्य है, शीस सिर्फ एक द्विआधारी खोज है जब तक क्रमिक मूल्यों के बीच का अंतर छोटा नहीं होता। शुरुआती निचला बाउंड है 0और शुरुआती ऊपरी बाउंड है 2*x।

इनपुट और आउटपुट एक पॉइंटर के माध्यम से फ़ंक्शन के लिए एक डबल पास है।

मुझे पूरा यकीन है कि इसे और गहरा किया जा सकता है - विशेष रूप से मुझे नहीं लगता कि मुझे 4 स्थानीय युगल चाहिए, लेकिन अभी तक मैं इसे कम करने का आसान तरीका नहीं देख रहा हूं।

इसे ऑनलाइन आज़माएं - बिल्ड (लिबम के साथ लिंक करना) और बैश स्क्रिप्ट में चलता है।

सौम्य:

f(double *z){
    double u=2**z,l=0,g=u,p=0;
    for(;log(fabs(g-p))>-14;){
        p=g;
        g=(u+l)/2;
        u=tgamma(g+1)>*z?g:(l=g,u);*z=g;
    }
}