ความท้าทาย

เขียนโปรแกรมหรือฟังก์ชั่นที่ไม่มีอินพุตและเอาต์พุตเวกเตอร์ที่มีความยาว$1$ในทิศทางสุ่มแบบตามหลักทฤษฏี

นี่เทียบเท่ากับจุดสุ่มบนทรงกลมที่อธิบายโดย

ส่งผลให้เกิดการกระจายเช่นนี้

เอาท์พุต

ทุ่นลอยสามอันจากการแจกแจงแบบสุ่มในทางทฤษฎีซึ่งสมการ$x^2+y^2+z^2=1$มีค่าเป็นจริงถึงขีด จำกัด ที่แม่นยำ

คำพูดที่ท้าทาย

• การกระจายแบบสุ่มจะต้องมีเครื่องแบบในทางทฤษฎี นั่นคือถ้าตัวสร้างตัวเลขสุ่มหลอกถูกแทนที่ด้วย RNG จริงจากตัวเลขจริงมันจะส่งผลให้มีการกระจายจุดสุ่มบนทรงกลมอย่างสม่ำเสมอ
• การสร้างตัวเลขสุ่มสามตัวจากการแจกแจงเครื่องแบบและการทำให้เป็นมาตรฐานนั้นไม่ถูกต้อง: จะมีอคติต่อมุมของพื้นที่สามมิติ
• ในทำนองเดียวกันการสร้างตัวเลขสุ่มสองตัวจากการแจกแจงเครื่องแบบและใช้พวกมันเป็นพิกัดทรงกลมนั้นไม่ถูกต้อง: จะมีอคติต่อขั้วของทรงกลม
• ความสม่ำเสมอที่เหมาะสมสามารถทำได้โดยอัลกอริทึมรวมถึง แต่ไม่ จำกัด เพียง:
  • สร้างตัวเลขสุ่มสามตัว$x$ , $y$และ$z$จากการแจกแจงแบบปกติ (เกาส์เซียน) ประมาณ$0$และทำให้เป็นมาตรฐาน
    • ตัวอย่างการนำไปปฏิบัติ
  • สร้างสามตัวเลขสุ่ม$x$ , $y$และ$z$จากเครื่องแบบกระจายอยู่ในช่วง$(-1,1)$ ) คำนวณความยาวของเวคเตอร์โดย$l=\sqrt{x^2+y^2+z^2}$ 2 จากนั้นถ้า$l>1$ให้ปฏิเสธเวกเตอร์และสร้างชุดตัวเลขใหม่ มิฉะนั้นถ้า$l \leq 1$ให้เวกเตอร์เป็นปกติและกลับผลลัพธ์
    • ตัวอย่างการนำไปปฏิบัติ
  • สร้างตัวเลขสุ่มสองตัวที่$i$และ$j$จากการแจกแจงเครื่องแบบในช่วง$(0,1)$และแปลงให้เป็นพิกัดทรงกลมดังนี้: $$\begin{align}\theta &= 2 \times \pi \times i\\\\\phi &= \cos^{-1}(2\times j -1)\end{align}$$ เพื่อให้$x$,$y$และ$z$สามารถคำนวณได้โดย $$\begin{align}x &= \cos(\theta) \times \sin(\phi)\\\\y &= \sin(\theta) \times \sin(\phi)\\\\z &= \cos(\phi)\end{align}$$
    • ตัวอย่างการนำไปปฏิบัติ
• ระบุคำอธิบายสั้น ๆ ของอัลกอริทึมที่คุณใช้
• อ่านเพิ่มเติมเกี่ยวกับการเลือกจุดทรงกลมในแม ธ เวิลด์

ตัวอย่างผลลัพธ์

[ 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]

ข้อสังเกตทั่วไป

• นี่คือรหัสกอล์ฟดังนั้นคำตอบที่ใช้จำนวนไบต์น้อยที่สุดในแต่ละภาษาจะเป็นผู้ชนะ
• กฎระเบียบมาตรฐาน , I / O กฎระเบียบและกฎหนีใช้
• โปรดรวมลิงค์ลองออนไลน์หรือเทียบเท่าเพื่อแสดงให้เห็นว่าโค้ดของคุณใช้งานได้
• โปรดกระตุ้นคำตอบด้วยคำอธิบายรหัสของคุณ

ภาษา Wolfram (Mathematica)ขนาด 20 ไบต์

RandomPoint@Sphere[]

ลองออนไลน์!

ทำสิ่งที่พูดบนกระป๋องอย่างแน่นอน

R , 23 ไบต์

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

ลองออนไลน์!

สร้าง 3 การรับรู้ของ$\mathcal N(0,1)$แจกแจงและทำให้เวกเตอร์ผลลัพธ์เป็นปกติ

พล็อตของการรับรู้ 1000 รายการ:

x86-64 Machine Code - 63 62 55 49 bytes

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 เป็น 4 ตำแหน่งของ xmm1

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 หากความยาวยกกำลังสองเท่ากับความยาวก็เท่ากับหนึ่ง นั่นหมายความว่าเวกเตอร์ได้รับการทำให้เป็นมาตรฐานแล้วและบันทึกสแควร์รูทและหาร

pop         rax  
pop         rax 

เรียกคืนสแต็ก

ret ส่งคืนค่าใน xmm0

Try it Online.

Python 2, 86 bytes

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

Try it online!

Generates the z-coordinate uniformly from -1 to 1. Then the x and y coordinates are sampled uniformly on a circle of radius (1-z*z)**.5.

It might not be obvious that the spherical distribution is in factor uniform over the z coordinate (and so over every coordinate). This is something special for dimension 3. See this proof that the surface area of a horizontal slice of a sphere is proportional to its height. Although slices near the equator have a bigger radius, slices near the pole are titled inward more, and it turns out these two effects exactly cancel.

To generate a random angle on this circle, we raise the imaginary unit 1j to a uniformly random power between 0 and 4, which saves us from needing trig functions, pi, or e, any of which would need an import. We then extract the real imaginary part. If we can output a complex number for two of the coordinates, the last line could just be print a,z.

86 bytes

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

Try it online!

Generates three normals and scales the result.

Python 2 with numpy, 57 bytes

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

Try it online!

sum(a*a)**.5 is shorter than linalg.norm(a). We could also do dot(a,a) for the same length as sum(a*a). In Python 3, this can be shortened to a@a using the new operator @.

Octave, 40 33 22 bytes

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

Ruby, 34 50 49 bytes

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

Try it online!

Returns an array of 3 numbers [z,y,x].

x and y are generated by raising i (square root of -1) to a random power between 0 and 4. This complex number needs to be scaled appropriately according to the z value in accordance with Pythagoras theorem: (x**2 + y**2) + z**2 = 1.

The z coordinate (which is generated first) is simply a uniformly distributed number between -1 and 1. Though not immediately obvious, dA/dz for a slice through a sphere is constant (and equal to the perimeter of a circle of the same radius as the whole sphere.) .

This was apparently discovered by Archimedes who described it in a very non-calculus-like way, and it is known as Archimedes Hat-Box theorem. See https://brilliant.org/wiki/surface-area-sphere/

Another reference from comments on xnor's answer. A surprisingly short URL, describing a surprisingly simple formula: http://mathworld.wolfram.com/Zone.html

05AB1E, 23 22 bytes

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

Implements the 2nd algorithm.

Try it online or get a few more random outputs.

Explanation:

NOTE: 05AB1E doesn't have a builtin to get a random decimal value in the range $[0,1)$. Instead, I create a list in increments of $0.00001$, and pick random values from that list. This increment could be changed to $0.000000001$ by changing the 5 to 9 in the code (although it would become rather slow..).

[            # 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 bytes ^*

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

Using the algorithm "generate 3 normally distributed values and normalize that vector".

Ending a program with an expression automatically prints the result on the Homescreen after the program terminates, so the result is actually shown, not just generated and blackholed.

*: randNorm( is a two-byte token, the rest are one-byte tokens. I've counted the initial (unavoidable) :, without that it would be 14 bytes. Saved as a program with a one-letter name, it takes 24 bytes of memory, which includes the 9 bytes of file-system overhead.

JavaScript (ES7),  77 76  75 bytes

Implements the 3^rd algorithm, using $\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]

Try it online!

Commented

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(ɸ)
  ]                              //

JavaScript (ES6), 79 bytes

Implements the 2^nd algorithm.

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

Try it online!

Commented

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

Processing 26 bytes

Full program

print(PVector.random3D());

This is the implementation 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;
  }

Python 2, 86 bytes

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

Try it online!

Implements the first algorithm.

Python 2, 107 103 bytes

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

Try it online!

Implements the second algorithm.

Haskell, 125 123 119 118 bytes

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

Try it online!

Does three uniforms randoms and rejection sampling.

JavaScript, 95 bytes

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)

You don't need not to input a.

Julia 1.0, 24 bytes

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

Try it online!

Draws a vector of 3 values, drawn from a normal distribution around 0 with standard deviation 1. Then just normalizes them.

MathGolf, 21 19 18 bytes

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

Implementation of the 2nd algorithm.

Try it online or see a few more outputs at the same time.

Explanation:

{              }▲   # 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)

Java 8 (@Arnauld's modified 3rd algorithm), 131 126 119 111 109 bytes

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

Port of @Arnauld's JavaScript answer, so make sure to upvote him!
-2 bytes thanks to @OlivierGrégoire.

This is implemented as:

$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\}$

Try it online.

Previous 3rd algorithm implementation (131 126 119 bytes):

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

Implemented as:

$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))\}$

Try it online.

Explanation:

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 (2nd algorithm), 153 143 bytes

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

Try it online.

2nd algorithm:

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 bytes

Port of Arnauld's implementation of the 2nd algorithm.

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

Test it

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 bytes

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

Try it online!

Uses algorithm #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 bytes

(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

EDIT: Shaved off some bytes by inlining $i$ and $j$, replacing the first let ... in with a fun, and taking advantage of operator associativity to avoid some parens ().

Try it online

Original solution:

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])

First I define:

OCaml's Random.float function includes the bounds. Then,

This is very similar to the 3rd example implementation (with $\phi = p$ and $\theta = t$) $-$ except that I pick $i$ and $j$ within larger intervals to avoid multiplication (with 2) later on.