एक जटिल नंबर पर रीमैन जेटा फंक्शन का मूल्यांकन करें

Question

परिचय

मुझे यह सवाल मिला जो बंद था क्योंकि यह अस्पष्ट था, फिर भी यह एक अच्छा विचार था। मैं इसे स्पष्ट चुनौती देने की पूरी कोशिश करूंगा।

Riemann जीटा समारोह में एक विशेष समारोह है कि के विश्लेषणात्मक निरंतरता के रूप में परिभाषित किया जाता है

जटिल विमान के लिए। इसके लिए कई समकक्ष सूत्र हैं जो कोड गोल्फ के लिए इसे दिलचस्प बनाता है।

चुनौती

एक प्रोग्राम लिखें जो इनपुट (एक जटिल संख्या का वास्तविक और काल्पनिक हिस्सा) के रूप में 2 फ़्लोट्स लेता है और उस बिंदु पर रीमैन ज़ेटा फ़ंक्शन का मूल्यांकन करता है।

नियम

• कंसोल या फ़ंक्शन इनपुट और रिटर्न वैल्यू के माध्यम से इनपुट और आउटपुट
• निर्मित जटिल संख्याओं की अनुमति नहीं है, फ़्लोट्स का उपयोग करें (संख्या, डबल, ...)
• कोई भी गणितीय कार्य नहीं है + - * / pow logऔर वास्तविक मूल्यवान ट्रिगर फ़ंक्शंस (यदि आप एकीकृत करना चाहते हैं, तो गामा फ़ंक्शन का उपयोग करें, ... आपको इस फ़ंक्शन को कोड में परिभाषा में शामिल करना होगा)
• इनपुट: 2 फ्लोट्स
• आउटपुट: 2 फ़्लोट्स
• आपके कोड में वह मान होना चाहिए जो मनमाना बड़े / छोटे होने पर सैद्धांतिक रूप से मनमानी परिशुद्धता देता है
• इनपुट 1 पर व्यवहार महत्वपूर्ण नहीं है (यह इस फ़ंक्शन का एकमात्र पोल है)

बाइट्स जीत में सबसे छोटा कोड!

उदाहरण इनपुट और आउटपुट

इनपुट:

२, ०

आउटपुट:

1.6449340668482266, 0

इनपुट:

1 1

आउटपुट:

0.5821580597520037, -0.9268485643308071

इनपुट:

-1, 0

आउटपुट:

-0.08333333333333559, 0

Comments

आवश्यक आउटपुट परिशुद्धता क्या है? मुझे यकीन नहीं है कि मैं समझता हूं कि आपके कोड में मूल्य होना चाहिए जो सैद्धांतिक रूप से मनमाना सटीक देता है जब मनमाना बड़ा / छोटा किया जाता है । क्या आप का मतलब है कि लूप की तुलना में अधिकतम मूल्य से अधिक है जब बाध्य के बिना वृद्धि हुई सटीक वृद्धि होती है? क्या उस मूल्य को हार्ड-कोड किया जा सकता है?

— लुइस मेंडो

@DonMuesli का मतलब यह है कि सटीकता एक पैरामीटर पर निर्भर करती है, एन का कहना है, जिसे आप अपनी पसंद का कोई भी मूल्य दे सकते हैं, लेकिन किसी भी सटीक सटीकता के लिए, आप उस सटीकता को प्राप्त करने के लिए एन को छोटा या बड़ा बना सकते हैं। शब्द सैद्धांतिक रूप से वहाँ है क्योंकि आपको मशीन या भाषा की सीमित शुद्धता के बारे में चिंता नहीं करनी चाहिए।

— जेन्स रेंडर्स

एन को और स्पष्ट करने के लिए: क्या यह पर्याप्त है कि किसी भी बाउंड epsऔर इनपुट के लिए xमौजूद है Nजो zeta(x)भीतर की गणना करता है eps; या वहां मौजूद होना चाहिए Nजो केवल इस बात पर निर्भर करता है epsऔर गारंटी देता है कि किसी भी x(या शायद पोल से xदिए गए फ़ंक्शन से अधिक के लिए eps) यह बाध्यता को प्राप्त करता है; या Nपर निर्भर हो सकता है x, लेकिन जवाब देना चाहिए कि कैसे Nदिया xऔर गणना करने के लिए eps? (मेरा विश्लेषणात्मक संख्या सिद्धांत बहुत ऊपर नहीं है, लेकिन मुझे संदेह है कि विकल्प 2 और 3 सभी या एक या दो नियमित पोस्टरों से परे होने जा रहे हैं)।

— पीटर टेलर

@PeterTaylor N काफी बड़ा: किसी भी xऔर किसी के लिए भी epsऐसा मौजूद होना चाहिए Pकि सभी N>Pआउटपुट epsसटीक मान की तुलना में करीब हों । क्या यह स्पष्ट है? क्या मुझे एन छोटे के साथ मामले के लिए इसे स्पष्ट करने की आवश्यकता है?

— जेन्स रेंडर्स

नहीं, यह काफी स्पष्ट है।

— पीटर टेलर

Answer 1

अजगर - 385

यह http://mathworld.wolfram.com/RiemannZetaFunction.html से समीकरण 21 का सीधा कार्यान्वयन है। यह वैकल्पिक तर्क के लिए पायथन के सम्मेलन का उपयोग करता है; यदि आप एक सटीक निर्दिष्ट करना चाहते हैं, तो आप फ़ंक्शन के लिए तीसरा तर्क पास कर सकते हैं, अन्यथा यह डिफ़ॉल्ट रूप से 1e-24 का उपयोग करता है।

import numpy as N
def z(r,i,E=1e-24):
 R=0;I=0;n=0;
 while(True):
  a=0;b=0;m=2**(-n-1)
  for k in range(0,n+1):
   M=(-1)**k*N.product([x/(x-(n-k))for x in range(n-k+1,n+1)]);A=(k+1)**-r;t=-i*N.log(k+1);a+=M*A*N.cos(t);b+=M*A*N.sin(t)
  a*=m;b*=m;R+=a;I+=b;n+=1
  if a*a+b*b<E:break
 A=2**(1-r);t=-i*N.log(2);a=1-A*N.cos(t);b=-A*N.sin(t);d=a*a+b*b;a=a/d;b=-b/d
 print(R*a-I*b,R*b+I*a)

Comments

z(2,0)गलत मान देता है, pi ^ 2/6 होना चाहिए।

— GuillaumeDufay

Answer 2

पायथन 3 , 303 297 बाइट्स

यह उत्तर कई संशोधनों के साथ RT के पायथन उत्तर पर आधारित है :

• सबसे पहले, Binomial(n, k)परिभाषित किया गया है p = p * (n-k) / (k+1)जो लूप के प्रत्येक पास के साथ बदलता Binomial(n,k)है Binomial(n,k+1)।
• दूसरा, (-1)**k * Binomial(n,k)बन गया p = p * (k-n) / (k+1)जो लूप के लिए हर कदम पर संकेत प्रवाहित करता है।
• तीसरा, whileलूप को तुरंत बदल दिया गया है अगर जाँच करें a*a + b*b < E।
• चौथा, बिटवाइज़ नहीं ऑपरेटर ~कई स्थानों में प्रयोग किया जाता है, जहां वे गोल्फ में मदद करेगा, जैसे पहचान का उपयोग -n-1 == ~n, n+1 == -~nऔर n-1 == ~-n।

बेहतर गोल्फिंग के लिए कई अन्य छोटे संशोधन किए गए थे, जैसे कि forलूप को एक लाइन पर रखना और printउससे पहले कोड के साथ एक लाइन पर कॉल करना ।

गोल्फ सुझाव का स्वागत करते हैं। इसे ऑनलाइन आज़माएं!

संपादित करें: -6 छोटे बदलावों की संख्या से बाइट्स।

import math as N
def z(r,i,E=1e-40):
 R=I=n=0;a=b=1
 while a*a+b*b>E:
  a=b=0;p=1;m=2**~n
  for k in range(1,n+2):M=p/k**r;p*=(k-1-n)/k;t=-i*N.log(k);a+=M*N.cos(t);b+=M*N.sin(t)
  a*=m;b*=m;R+=a;I+=b;n+=1
 A=2**-~-r;t=-i*N.log(2);x=1-A*N.cos(t);y=A*N.sin(t);d=x*x+y*y;return(R*x-I*y)/d,(R*y+I*x)/d

Answer 3

Axiom, 413 315 292 बाइट्स

p(n,a,b)==(x:=log(n^b);y:=n^a;[y*cos(x),y*sin(x)]);z(a,b)==(r:=[0.,0.];e:=10^-digits();t:=p(2,1-a,-b);y:=(1-t.1)^2+t.2^2;y=0=>[];m:=(1-t.1)/y;q:=t.2/y;n:=0;repeat(w:=2^(-n-1);abs(w)<e=>break;r:=r+w*reduce(+,[(-1)^k*binomial(n,k)*p(k+1,-a,-b) for k in 0..n]);n:=n+1);[r.1*m-q*r.2,m*r.2+r.1*q])

यह http://mathworld.wolfram.com/RiemannZetaFunction.html से समीकरण 21 को भी लागू करेगा । उपरोक्त एआईटॉम फ़ंक्शन z (a, b) का एक होना चाहिए, यहाँ 16x धीमी गति से यह फ़ंक्शन ज़ेटा (a, b) से कम है। यह एक संकलित होना चाहिए] सभी असंयमित और टिप्पणी की गई [1 सेकंड के लिए ज़ेटा () जेड के लिए 16 सेकंड के खिलाफ () के लिए 20 अंकों के एक मान के लिए फ्लोट बिंदु]। अंकों के प्रश्न के लिए, कोई अंक () कहकर सटीक का चयन करेगा; फ़ंक्शन, उदाहरण के लिए अंक (10); z (1,1) बिंदु के बाद 10 अंकों को प्रिंट करना चाहिए, लेकिन अंक (50); z (1,1) को बिंदु के बाद 50 अंकों को प्रिंट करना चाहिए।

-- elevImm(n,a,b)=n^(a+i*b)=r+i*v=[r,v]
elevImm(n:INT,a:Float,b:Float):Vector Float==(x:=log(n^b);y:=n^a;[y*cos(x),y*sin(x)]::Vector Float);

--                      +oo               n
--                      ---              ---
--             1        \       1        \            n 
--zeta(s)= ---------- * /     ------  *  /    (-1)^k(   )(k+1)^(-s)
--          1-2^(1-s)   ---n  2^(n+1)    ---k         k  
--                       0                0


Zeta(a:Float,b:Float):List Float==
  r:Vector Float:=[0.,0.]; e:=10^-digits()

  -- 1/(1-2^(1-s))=1/(1-x-i*y)=(1-x+iy)/((1-x)^2+y^2)=(1-x)/((1-x)^2+y^2)+i*y/((1-x)^2+y^2)    

  t:=elevImm(2,1-a,-b);
  y:=(1-t.1)^2+t.2^2;
  y=0=>[] 
  m:=(1-t.1)/y; 
  q:=t.2/y
  n:=0
  repeat
     w:=2^(-n-1)
     abs(w)<e=>break  --- this always terminate because n increase
     r:=r+w*reduce(+,[(-1)^k*binomial(n,k)*elevImm(k+1,-a,-b) for k in 0..n])
     n:=n+1
  -- (m+iq)(r1+ir2)=(m*r1-q*r2)+i(m*r2+q*r1)
  [r.1*m-q*r.2,m*r.2+r.1*q]

this is one test for the z(a,b) function above:

(10) -> z(2,0)
   (10)  [1.6449340668 482264365,0.0]
                                              Type: List Expression Float
(11) -> z(1,1)
   (11)  [0.5821580597 520036482,- 0.9268485643 3080707654]
                                              Type: List Expression Float
(12) -> z(-1,0)
   (12)  [- 0.0833333333 3333333333 3,0.0]
                                              Type: List Expression Float
(13) -> z(1,0)
   (13)  []