도전

벡터 길이의 어떠한 입력을 필요하지 않고 출력하는 프로그램이나 함수 작성 $1$ A의 이론적 균일 임의의 방향.

이것은 x 2 + y 2 + z 2 = 1로 설명되는 구의 임의의 점과 같습니다.

그런 분포를 초래

산출

방정식 $x^2+y^2+z^2=1$ 이 이론적으로 균일 한 랜덤 분포에서 3 개의 부동 소수점 을 정밀한 한계까지 유지합니다.

도전 비고

• 랜덤 분포는 이론적으로 균일 해야합니다 . 즉, 의사 난수 생성기가 실수 의 실제 RNG로 대체 되는 경우 구에서 점의 균일 한 무작위 분포가 발생합니다.
• 균일 분포에서 3 개의 난수를 생성하고 정규화하는 것은 유효하지 않습니다. 3 차원 공간의 모서리를 향한 편향이 있습니다.
• 마찬가지로 균일 분포에서 두 개의 난수를 생성하고이를 구형 좌표로 사용하는 것은 유효하지 않습니다. 구의 극점으로 편향됩니다.
• 다음을 포함하지만 이에 국한되지 않는 알고리즘으로 적절한 균일 성을 달성 할 수 있습니다.
  • 0 주위 의 정규 (가우스) 분포 에서 3 개의 난수 $x$ , $y$ 및 $z$ 를 생성 하고 정규화합니다. $0$
    • 구현 예
  • 세 난수 생성 $x$ , $y$ 및 $z$ A로부터 균일 한 범위의 분포 $(-1,1)$ . l = √로 벡터의 길이를 계산합니다$l=\sqrt{x^2+y^2+z^2}$ . 그런 다음$l>1$인 경우 벡터를 거부하고 새 숫자 세트를 생성하십시오. 그렇지 않으면$l \leq 1$인 경우 벡터를 정규화하고 결과를 반환합니다.
    • 구현 예
  • 두 난수 생성 $i$ 및 $j$ (A)로부터 균일 한 범위의 분포 $(0,1)$ 와 구면 좌표로 변환 정도로 같은 $$\begin{align}\theta &= 2 \times \pi \times i\\\\\phi &= \cos^{-1}(2\times j -1)\end{align}$$ $x$,$y$및$z$를 x 로 계산할 수있도록 = cos − 1 ( 2 × j − 1 ) $$\begin{align}x &= \cos(\theta) \times \sin(\phi)\\\\y &= \sin(\theta) \times \sin(\phi)\\\\z &= \cos(\phi)\end{align}$$
    • 구현 예
• 답에 사용중인 알고리즘에 대한 간단한 설명을 제공하십시오.
• MathWorld의 구면 점 따기에 대해 자세히 알아보십시오 .

출력 예

[ 0.72422852 -0.58643067  0.36275628]
[-0.79158628 -0.17595886  0.58517488]
[-0.16428481 -0.90804027  0.38532243]
[ 0.61238768  0.75123833 -0.24621596]
[-0.81111161 -0.46269121  0.35779156]

총론

• 이것은 code-golf 이므로 각 언어에서 가장 적은 바이트를 사용하는 답이 이깁니다.
• 표준 규칙 , I / O 규칙 및 허점 규칙 적용됩니다.
• 온라인 사용해보기를 포함 하십시오 코드의 작업을 보여 -link 또는 이에 상응하는.
• 코드에 대한 설명으로 답변에 동기를 부여하십시오.

Wolfram Language (Mathematica) , 20 바이트

RandomPoint@Sphere[]

온라인으로 사용해보십시오!

틴에 대해 정확히 말하십시오.

R , 23 바이트

x=rnorm(3)
x/(x%*%x)^.5

온라인으로 사용해보십시오!

$\mathcal N(0,1)$ 분포 의 3 가지 실현을 생성 하고 결과 벡터를 정규화합니다.

1000 개의 실현 도표 :

x86-64 기계 코드 -63 62 55 49 바이트

6A 4F                push        4Fh  
68 00 00 80 3F       push        3F800000h  
C4 E2 79 18 4C 24 05 vbroadcastss xmm1,dword ptr [rsp+5]  
rand:
0F C7 F0             rdrand      eax  
73 FB                jnc         rand  
66 0F 6E C0          movd        xmm0,eax  
greaterThanOne:
66 0F 38 DC C0       aesenc      xmm0,xmm0  
0F 5B C0             cvtdq2ps    xmm0,xmm0  
0F 5E C1             divps       xmm0,xmm1  
C4 E3 79 40 D0 7F    vdpps       xmm2,xmm0,xmm0,7Fh  
0F 2F 14 24          comiss      xmm2,dword ptr [rsp]  
75 E9                jne         greaterThanOne
58                   pop         rax  
58                   pop         rax  
C3                   ret  

수정 된 두 번째 알고리즘을 사용합니다. 의 벡터를 반환[x, y, z, 0]xmm0의 .

설명:

push 4Fh
push 3f800000h

스택에 부동 소수점으로 1 및 2 ^ 31의 값을 푸시합니다. 부호 확장으로 인해 데이터가 겹치므로 몇 바이트가 절약됩니다.

vbroadcastss xmm1,dword ptr [rsp+5] 2 ^ 31의 값을 xmm1의 4 개 위치에로드합니다.

rdrand      eax  
jnc         rand  
movd        xmm0,eax

임의의 32 비트 정수를 생성하여 xmm0의 맨 아래로로드합니다.

aesenc      xmm0,xmm0  
cvtdq2ps    xmm0,xmm0  
divps       xmm0,xmm1 

임의의 32 비트 정수를 생성하고이를 부동 (부호)으로 변환 한 후 2 ^ 31로 나누어 -1과 1 사이의 숫자를 얻습니다.

vdpps xmm2,xmm0,xmm0,7Fh내적을 사용하여 하단 3 개의 부동 소수점의 제곱을 추가하고 상단 부동을 마스킹합니다. 이것은 길이를 제공합니다

comiss      xmm2,dword ptr [rsp]  
jne          rand+9h (07FF7A1DE1C9Eh)

길이의 제곱을 1과 비교하고 값이 1이 아닌 경우 값을 거부합니다. 길이의 제곱이 1이면 길이도 1입니다. 즉, 벡터가 이미 정규화되어 있고 제곱근을 나누고 나눕니다.

pop         rax  
pop         rax 

스택을 복원하십시오.

ret xmm0의 값을 반환

온라인으로 사용해보십시오 .

파이썬 2 , 86 바이트

from random import*;R=random
z=R()*2-1
a=(1-z*z)**.5*1j**(4*R())
print a.real,a.imag,z

온라인으로 사용해보십시오!

-1에서 1까지의 z 좌표를 균일하게 생성합니다. 그러면 x 및 y 좌표가 반경 원에서 균일하게 샘플링 (1-z*z)**.5됩니다.

구면 분포가 z 좌표에서 (그리고 모든 좌표에서) 인자로 균일하다는 것은 분명하지 않을 수 있습니다. 이것은 차원 3에 특별한 것입니다. 이 증거를보십시오 입니다. 구의 수평 슬라이스의 표면적이 높이에 비례한다는 를 . 적도 부근의 조각은 반지름이 더 크지 만 기둥 근처의 조각은 안쪽으로 더 많은 제목이 붙어 있으며이 두 가지 효과가 정확하게 취소됩니다.

이 원에 임의의 각도를 생성하기 위해 가상 단위 1j를 0에서 4 사이의 균일 한 임의의 제곱으로 올립니다. 이로 인해 삼각 함수, pi 또는 e가 필요하지 않으며 가져 오기가 필요합니다. 그런 다음 실제 허수 부분을 추출합니다. 두 좌표에 대해 복소수를 출력 할 수 있다면 마지막 줄은 그냥됩니다 print a,z.

86 바이트

from random import*
a,b,c=map(gauss,[0]*3,[1]*3)
R=(a*a+b*b+c*c)**.5
print a/R,b/R,c/R

온라인으로 사용해보십시오!

3 개의 법선을 생성하고 결과를 스케일링합니다.

numpy, 57 바이트의 Python 2

from numpy import*
a=random.randn(3)
print a/sum(a*a)**.5

온라인으로 사용해보십시오!

sum(a*a)**.5보다 짧습니다 linalg.norm(a). 우리는 또한 dot(a,a)같은 길이로 할 수 있습니다 sum(a*a). Python 3에서는 a@anew 연산자 를 사용하여 단축 할 수 있습니다 @.

옥타브 , 40 33 22 바이트

We sample form a 3d standard normal distribution and normalize the vector:

(x=randn(1,3))/norm(x)

Try it online!

Unity C#, 34 bytes

f=>UnityEngine.Random.onUnitSphere

Unity has a builtin for unit sphere random values, so I thought I'd post it.

MATL, 10 bytes

1&3Xrt2&|/

Try it online!

Explanation

This uses the first approach described in the challenge.

1&3Xr  % Generate a 1×3 vector of i.i.d standard Gaussian variables
t      % Duplicate
2&|    % Compute the 2-norm
/      % Divide, element-wise. Implicitly display

루비 , 34 50 49 바이트

->{[z=rand*2-1]+((1-z*z)**0.5*1i**(rand*4)).rect}

온라인으로 사용해보십시오!

3 개의 숫자 배열을 반환합니다 [z,y,x].

x및 y상승에 의해 발생되는 i임의의 전력 10-0 내지 4.이 복소수 필요에 따라 적절하게 스케일링 될 (-1의 제곱근) z피타고라스 정리에 따른 값 :(x**2 + y**2) + z**2 = 1.

는 z사이 -1과 1 비록되지 즉시 (DA) / 구를 통해 슬라이스 DZ 상수 명백 균일 분포 수가 단순히 (제 1 생성되는) 좌표 (동일 반경의 원으로의 둘레와 동일 전체 구).

이것은 매우 미적분법과 같은 방식으로 묘사 한 아르키메데스에 의해 발견되었으며, 아르키메데스 모자-박스 정리로 알려져 있습니다. https://brilliant.org/wiki/surface-area-sphere/를 참조 하십시오

xnor의 답변에 대한 의견에서 또 다른 참조. 놀랍도록 간단한 공식을 설명하는 놀랍도록 짧은 URL : http://mathworld.wolfram.com/Zone.html

05AB1E , 23 22 바이트

[тε5°x<Ýs/<Ω}DnOtDî#}/

두 번째 알고리즘을 구현합니다.

온라인으로 시도 하거나 더 많은 무작위 출력을 얻으십시오 .

설명:

참고 : 05AB1E에는 범위의 임의의 10 진수 값을 얻을 수있는 내장 기능이 없습니다 $[0,1)$. 대신, 나는 증분으로 목록을 만듭니다$0.00001$해당 목록에서 임의의 값을 선택하십시오. 이 증분은$0.000000001$코드 에서 5~ 9를 변경하여 (느리게 진행되지만).

[            # Start an infinite loop:
 тε          #  Push 100, and map (basically, create a list with 3 values):
   5°        #   Push 100,000 (10**5)
     x       #   Double it to 200,000 (without popping)
      <      #   Decrease it by 1 to 199,999
       Ý     #   Create a list in the range [0, 199,999]
        s/   #   Swap to get 100,000 again, and divide each value in the list by this
          <  #   And then decrease by 1 to change the range [0,2) to [-1,1)
           Ω #   And pop and push a random value from this list
  }          #  After the map, we have our three random values
   D         #   Duplicate this list
    n        #   Square each inner value
     O       #   Take the sum of these squares
      t      #   Take the square-root of that
       D     #   Duplicate that as well
        î    #   Ceil it, and if it's now exactly 1:
         #   #    Stop the infinite loop
}/           # After the infinite loop: normalize by dividing
             # (after which the result is output implicitly)

TI-BASIC, 15 바이트 ^*

:randNorm(0,1,3
:Ans/√(sum(Ans²

알고리즘을 사용하여 "3 개의 정규 분포 값을 생성하고 해당 벡터를 정규화"합니다.

표현식을 사용하여 프로그램을 종료하면 프로그램이 종료 된 후 홈 화면에 결과가 자동으로 인쇄되므로 결과가 생성 및 블랙홀되지 않고 실제로 표시됩니다.

* randNorm(A는 2 바이트 토큰 , 나머지는 1 바이트 토큰 . 나는 :14 바이트가 아닌 초기 (피할 수없는)를 세었다 . 한글자 이름의 프로그램으로 저장하면 24 바이트의 메모리가 필요하며 여기에는 9 바이트의 파일 시스템 오버 헤드가 포함됩니다.

자바 스크립트 (ES7),  77 76  75 바이트

다음을 사용하여 3 ^차 알고리즘을 구현합니다.$\sin(\phi)=\sin(\cos^{-1}(z))=\sqrt{1-z^2}$.

with(Math)f=_=>[z=2*(r=random)()-1,cos(t=2*PI*r(q=(1-z*z)**.5))*q,sin(t)*q]

온라인으로 사용해보십시오!

댓글

with(Math)                       // use Math
f = _ =>                         //
  [ z = 2 * (r = random)() - 1,  // z = 2 * j - 1
    cos(                         //
      t =                        // θ =
        2 * PI *                 //   2 * π * i
        r(q = (1 - z * z) ** .5) // q = sin(ɸ) = sin(arccos(z)) = √(1 - z²)
                                 // NB: it is safe to compute q here because
                                 //     Math.random ignores its parameter(s)
    ) * q,                       // x = cos(θ) * sin(ɸ)
    sin(t) * q                   // y = sin(θ) * sin(ɸ)
  ]                              //

자바 스크립트 (ES6), 79 바이트

두 ^번째 알고리즘을 구현합니다 .

f=_=>(n=Math.hypot(...v=[0,0,0].map(_=>Math.random()*2-1)))>1?f():v.map(x=>x/n)

온라인으로 사용해보십시오!

댓글

f = _ =>                         // f is a recursive function taking no parameter
  ( n = Math.hypot(...           // n is the Euclidean norm of
      v =                        // the vector v consisting of:
        [0, 0, 0].map(_ =>       //
          Math.random() * 2 - 1  //   3 uniform random values in [-1, 1]
        )                        //
  )) > 1 ?                       // if n is greater than 1:
    f()                          //   try again until it's not
  :                              // else:
    v.map(x => x / n)            //   return the normalized vector

26 바이트 처리

전체 프로그램

print(PVector.random3D());

이것은 https://github.com/processing/processing/blob/master/core/src/processing/core/PVector.java 구현입니다.

  static public PVector random3D(PVector target, PApplet parent) {
    float angle;
    float vz;
    if (parent == null) {
      angle = (float) (Math.random()*Math.PI*2);
      vz    = (float) (Math.random()*2-1);
    } else {
      angle = parent.random(PConstants.TWO_PI);
      vz    = parent.random(-1,1);
    }
    float vx = (float) (Math.sqrt(1-vz*vz)*Math.cos(angle));
    float vy = (float) (Math.sqrt(1-vz*vz)*Math.sin(angle));
    if (target == null) {
      target = new PVector(vx, vy, vz);
      //target.normalize(); // Should be unnecessary
    } else {
      target.set(vx,vy,vz);
    }
    return target;
  }

파이썬 2 , 86 바이트

from random import*
x,y,z=map(gauss,[0]*3,[1]*3);l=(x*x+y*y+z*z)**.5
print x/l,y/l,z/l

온라인으로 사용해보십시오!

첫 번째 알고리즘을 구현합니다.

파이썬 2 , 107103 바이트

from random import*
l=2
while l>1:x,y,z=map(uniform,[-1]*3,[1]*3);l=(x*x+y*y+z*z)**.5
print x/l,y/l,z/l

온라인으로 사용해보십시오!

두 번째 알고리즘을 구현합니다.

하스켈 , 125 123 119 118 바이트

import System.Random
f=mapM(\_->randomRIO(-1,1))"lol">>= \a->last$f:[pure$(/n)<$>a|n<-[sqrt.sum$map(^2)a::Double],n<1]

온라인으로 사용해보십시오!

3 개의 유니폼 랜덤 및 거부 샘플링을 수행합니다.

자바 스크립트, 95 바이트

f=(a=[x,y,z]=[0,0,0].map(e=>Math.random()*2-1))=>(s=Math.sqrt(x*x+y*y+z*z))>1?f():a.map(e=>e/s)

당신은 하지 않습니다 필요 하지 입력 a.

Julia 1.0 , 24 바이트

x=randn(3)
x/hypot(x...)

온라인으로 사용해보십시오!

표준 편차 1을 사용하여 0 주위의 정규 분포에서 가져온 3 개의 값으로 구성된 벡터를 그립니다.

MathGolf , 21 19 18 바이트

{╘3Ƀ∞(ß_²Σ√_1>}▲/

두 번째 알고리즘의 구현.

온라인으로 시도 하거나 동시에 더 많은 출력을 보십시오 .

설명:

{              }▲   # Do-while true by popping the value:
 ╘                  #  Discard everything on the stack to clean up previous iterations
  3É                #  Loop 3 times, executing the following three operations:
    ƒ               #   Push a random value in the range [0,1]
     ∞              #   Double it to make the range [0,2]
      (             #   Decrease it by 1 to make the range [-1,1]
       ß            #  Wrap these three values into a list
        _           #  Duplicate the list of random values
         ²          #  Square each value in the list
          Σ         #  Sum them
           √        #  And take the square-root of that
            _       #  Duplicate it as well
             1>     #  And check if it's larger than 1
                 /  # After the do-while, divide to normalize
                    # (after which the entire stack joined together is output implicitly,
                    #  which is why we need the `╘` to cleanup after every iteration)

자바 8 ( @Arnauld 의 변형 알고리즘 3) 131 126 119 111 109 바이트

v->{double k=2*M.random()-1,t=M.sqrt(1-k*k),r[]={k,M.cos(k=2*M.PI*M.random())*t,M.sin(k)*t};return r;}

@Arnauld 의 JavaScript 답변 포트이므로 그를 투표 하십시오! @ OlivierGrégoire
덕분에 -2 바이트 .

이것은 다음과 같이 구현됩니다.

$k = N\cap[-1,1)$
$t=\sqrt{1-k^2}$
$u=2\pi×(N\cap[0,1))$
$x,y,z = \{k, \cos(u)×t, \sin(u)×t\}$

온라인으로 사용해보십시오.

이전 3 알고리즘의 구현 ( 131 126 119 바이트)

Math M;v->{double k=2*M.random()-1,t=2*M.PI*M.random();return k+","+M.cos(t)*M.sin(k=M.acos(k))+","+M.sin(t)*M.sin(k);}

다음과 같이 구현됩니다.

$k = N\cap[-1,1)$
$t=2\pi×(N\cap[0,1))$
$x,y,z = \{k, \cos(t)×\sin(\arccos(k)), \sin(t)×\sin(\arccos(k))\}$

온라인으로 사용해보십시오.

설명:

Math M;                         // Math on class-level to use for static calls to save bytes
v->{                            // Method with empty unused parameter & double-array return
  double k=2*M.random()-1,      //  Get a random value in the range [-1,1)
         t=M.sqrt(1-k*k),       //  Calculate the square-root of 1-k^2
    r[]={                       //  Create the result-array, containing:
         k,                     //   X: the random value `k`
         M.cos(k=2*M.PI         //   Y: first change `k` to TAU (2*PI)
                     *M.random()//       multiplied by a random [0,1) value
                )               //      Take the cosine of that
                 *t,            //      and multiply it by `t`
         M.sin(k)               //   Z: Also take the sine of the new `k` (TAU * random)
                  *t};          //      And multiply it by `t` as well
  return r;}                    //  Return this array as result

Java 8 (2 차 알고리즘), 153143 바이트

v->{double x=2,y=2,z=2,l;for(;(l=Math.sqrt(x*x+y*y+z*z))>1;y=m(),z=m())x=m();return x/l+","+y/l+","+z/l;};double m(){return Math.random()*2-1;}

온라인으로 사용해보십시오.

두 번째 알고리즘 :

v->{                              // Method with empty unused parameter & String return-type
  double x=2,y=2,z=2,l;           //  Start results a,b,c all at 2
  for(;(l=Math.sqrt(x*x+y*y+z*z)) //  Loop as long as the hypotenuse of x,y,z
       >1;                        //  is larger than 1
    y=m(),z=m())x=m();            //   Calculate a new x, y, and z
  return x/l+","+y/l+","+z/l;}    //  And return the normalized x,y,z as result
double m(){                       // Separated method to reduce bytes, which will:
  return Math.random()*2-1;}      //  Return a random value in the range [-1,1)

Japt , 20 바이트

포트 Arnauld의 구현 2 알고리즘.

MhV=3ÆMrJ1
>1?ß:V®/U

그것을 테스트

MhV=3ÆMrJ1
Mh             :Get the hypotenuse of
  V=           :  Assign to V
    3Æ         :  Map the range [0,3)
      Mr       :    Random float
        J1     :    In range [-1,1)
>1?ß:V®/U      :Assign result to U
>1?            :If U is greater than 1
   ß           :  Run the programme again
    :V®/U      :Else map V, dividing all elements by U

Pyth , 24 바이트

W<1Ks^R2JmtO2.0 3;cR@K2J

온라인으로 사용해보십시오!

알고리즘 # 2 사용

W                         # while 
 <1                       #   1 < 
   Ks                     #       K := sum(
     ^R2                  #               map(lambda x:x**2,
        Jm      3         #                    J := map(                            , range(3))
          tO2.0           #                             lambda x: random(0, 2.0) - 1           )):
                 ;        #   pass
                   R   J  # [return] map(lambda x:            , J)
                  c @K2   #                        x / sqrt(K)

OCaml , 110 99 95 바이트

(fun f a c s->let t,p=f 4.*.a 0.,a(f 2.-.1.)in[c t*.s p;s t*.s p;c p])Random.float acos cos sin

편집 : 인라인하여 일부 바이트를 줄였습니다. $i$ 과 $j$, 첫 번째를 let ... in로 바꾸고 fun연산자의 연관성을 활용하여 일부 parens를 피하십시오 ().

온라인으로 사용해보십시오

독창적 인 솔루션 :

Random.(let a,c,s,i,j=acos,cos,sin,float 4.,float 2. in let t,p=i*.(a 0.),a (j-.1.) in[c t*.s p;s t*.s p;c p])

먼저 다음을 정의합니다.

OCaml의 Random.float기능 에는 범위가 포함됩니다. 그때,

이것은 세 번째 예제 구현과 매우 유사합니다. $\phi = p$ 과 $\theta = t$) $-$ 내가 고르는 것을 제외하고 $i$ 과 $j$ 나중에 (2로) 곱셈을 피하기 위해 더 큰 간격으로.