소개

나는 발견 이 질문 이 불분명했기 때문에 폐쇄되었다, 그러나 그것은 좋은 생각이었다. 나는 이것을 분명한 도전으로 만들기 위해 최선을 다할 것입니다.

리만 제타 함수 의 분석 연속으로 정의되는 특수 기능입니다

복잡한 비행기로. 코드 골프에 흥미를 유발하는 많은 수식이 있습니다.

도전

2 개의 실수를 입력 (복소수의 실수 부와 허수 부)으로 사용하고 그 시점에서 Riemann Zeta 함수를 평가하는 프로그램을 작성하십시오.

규칙

• 콘솔 OR 기능 입력 및 반환 값을 통한 입력 및 출력
• 복소수 내장은 허용되지 않습니다. float (number, double, ...)를 사용하십시오.
• + - * / pow log실제 삼각 함수를 제외한 수학적 함수가 없습니다 (통합하려면 감마 함수를 사용하십시오.이 함수 정의를 코드에 포함시켜야합니다)
• 입력 : 2 개의 수레
• 출력 : 2 개의 수레
• 코드에는 임의의 크거나 작은 경우 이론적으로 임의의 정밀도를 제공하는 값이 포함되어야합니다
• 입력 1에서의 동작은 중요하지 않습니다 (이 기능의 유일한 극입니다).

바이트 단위의 최단 코드가 승리합니다!

입력 및 출력 예

입력:

2, 0

산출:

1.6449340668482266, 0

입력:

1, 1

산출:

0.5821580597520037, -0.9268485643308071

입력:

-1, 0

산출:

-0.08333333333333559, 0

파이썬-385

이것은에서 식 (21)의 간단한 구현 http://mathworld.wolfram.com/RiemannZetaFunction.html 이 선택적 인수를위한 파이썬의 규칙을 사용합니다; 정밀도를 지정하려면 세 번째 인수를 함수에 전달할 수 있습니다. 그렇지 않으면 기본적으로 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)

파이썬 3 , 303 297 바이트

이 답변은 RT의 Python 답변 을 기반으로 여러 수정되었습니다.

• 첫째 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)for 루프의 모든 단계에서 기호를 뒤집는.
• 셋째, while루프가 즉시 확인하도록 변경되었습니다 a*a + b*b < E.
• 넷째는 비트 NOT 연산자 ~가 골프에 도움을 것입니다 경우 같은 ID를 사용하여, 여러 곳에서 사용되는 -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

공리, 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])

이것으로부터도 식 (21)를 구현하는 것이 http://mathworld.wolfram.com/RiemannZetaFunction.html 하나 여기 공리 함수 Z (a, b) 느린 함수 제타 (A, B)이 이하보다 16 배를 iterpreted되어야 위 그것은 컴파일 된 것이어야합니다] 모두 ungolfed하고 주석을 달았습니다. [Zeta ()의 경우 1 초, 부동 소수점 중 하나의 20 자리의 z ()의 경우 16 초) 숫자 질문의 경우 numeric ()을 호출하여 정밀도를 선택합니다. 예를 들어, numeric (10); z (1,1)은 점 뒤에 10 자리를 인쇄해야하지만 numeric (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)  []