El reto

Escriba un programa o función que no tome entrada y genere un vector de longitud en una dirección aleatoria teóricamente uniforme .$1$

Esto es equivalente a un punto aleatorio en la esfera descrita por

resultando en una distribución como tal

Salida

Tres flotadores de una distribución aleatoria teóricamente uniforme para la cual la ecuación mantiene fiel a los límites de precisión.$x^2+y^2+z^2=1$

Observaciones de desafío

• La distribución aleatoria debe ser teóricamente uniforme . Es decir, si el generador de números pseudoaleatorios fuera reemplazado por un RNG verdadero de los números reales , daría como resultado una distribución aleatoria uniforme de puntos en la esfera.
• Generar tres números aleatorios a partir de una distribución uniforme y normalizarlos no es válido: habrá un sesgo hacia las esquinas del espacio tridimensional.
• Del mismo modo, generar dos números aleatorios a partir de una distribución uniforme y usarlos como coordenadas esféricas no es válido: habrá un sesgo hacia los polos de la esfera.
• La uniformidad adecuada se puede lograr mediante algoritmos que incluyen, entre otros:
  • Genere tres números aleatorios , y partir de una distribución normal (gaussiana) alrededor de y normalícelos. $x$$y$$z$0$0$
    • Ejemplo de implementación
  • Genere tres números aleatorios , y partir de una distribución uniforme en el rango . Calcule la longitud del vector por . Entonces, si , rechaza el vector y genera un nuevo conjunto de números. De lo contrario, si , normalice el vector y devuelva el resultado. $x$$y$$z$( - 1 , 1 ) l = √$(-1,1)$$l=\sqrt{x^2+y^2+z^2}$$l>1$$l \leq 1$
    • Ejemplo de implementación
  • Genere dos números aleatorios y de una distribución uniforme en el rango y conviértalos a coordenadas esféricas de la siguiente manera: para que , y puedan calcularse mediante$i$$j$( 0 , 1 ) θ$(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}$$
    • Ejemplo de implementación
• Proporcione en su respuesta una breve descripción del algoritmo que está utilizando.
• Lea más sobre la selección de puntos de esfera en MathWorld .

Ejemplos de salida

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

Observaciones generales

• Este es el código de golf , por lo que gana la respuesta con la menor cantidad de bytes en cada idioma.
• Se aplican reglas estándar , reglas de E / S y reglas de escapatoria .
• Incluya un enlace Probar en línea o equivalente para demostrar que su código funciona.
• Motive su respuesta con una explicación de su código.

Wolfram Language (Mathematica) , 20 bytes

RandomPoint@Sphere[]

Pruébalo en línea!

Hace exactamente lo que dice en la lata.

R , 23 bytes

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

Pruébalo en línea!

Genera 3 realizaciones de la distribución $\mathcal N(0,1)$ y normaliza el vector resultante.

Parcela de 1000 realizaciones:

Código de máquina x86-64 - 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  

Utiliza el segundo algoritmo, modificado. Devuelve el vector de [x, y, z, 0]en xmm0.

Explicación:

push 4Fh
push 3f800000h

Empuja el valor de 1 y 2 ^ 31 como flotante a la pila. Los datos se superponen debido a la extensión del signo, ahorrando unos pocos bytes.

vbroadcastss xmm1,dword ptr [rsp+5] Carga el valor de 2 ^ 31 en 4 posiciones de xmm1.

rdrand      eax  
jnc         rand  
movd        xmm0,eax

Genera un entero aleatorio de 32 bits y lo carga en la parte inferior de xmm0.

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

Genera un entero aleatorio de 32 bits, conviértalo en flotante (con signo) y divídalo entre 2 ^ 31 para obtener números entre -1 y 1.

vdpps xmm2,xmm0,xmm0,7Fhagrega los cuadrados de los 3 flotadores inferiores usando un producto de punto por sí mismo, enmascarando el flotador superior. Esto le da la longitud

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

Compara la longitud al cuadrado con 1 y rechaza los valores si no es igual a 1. Si la longitud al cuadrado es uno, entonces la longitud también es uno. Eso significa que el vector ya está normalizado y guarda una raíz cuadrada y divide.

pop         rax  
pop         rax 

Restaurar la pila.

ret devuelve valor en xmm0

Pruébalo en línea .

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

Pruébalo en línea!

Genera la coordenada z uniformemente de -1 a 1. Luego, las coordenadas xey se muestrean uniformemente en un círculo de radio (1-z*z)**.5.

Puede que no sea obvio que la distribución esférica es uniforme en factor sobre la coordenada z (y así sobre cada coordenada). Esto es algo especial para la dimensión 3. Vea esta prueba de que el área de superficie de un corte horizontal de una esfera es proporcional a su altura. Aunque las rebanadas cercanas al ecuador tienen un radio mayor, las rebanadas cercanas al polo se titulan más hacia adentro, y resulta que estos dos efectos se cancelan exactamente.

Para generar un ángulo aleatorio en este círculo, elevamos la unidad imaginaria 1ja una potencia aleatoria uniforme entre 0 y 4, lo que nos ahorra la necesidad de necesitar funciones trigonométricas, pi o e, cualquiera de las cuales necesitaría una importación. Luego extraemos la parte imaginaria real. Si podemos generar un número complejo para dos de las coordenadas, la última línea podría ser 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

Pruébalo en línea!

Genera tres normales y escala el resultado.

Python 2 con numpy, 57 bytes

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

Pruébalo en línea!

sum(a*a)**.5es más corto que linalg.norm(a). También podríamos hacer dot(a,a)lo mismo que sum(a*a). En Python 3, esto se puede acortar para a@ausar el nuevo operador @.

Octava , 40 33 22 bytes

Muestramos una distribución normal estándar 3d y normalizamos el vector:

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

Pruébalo en línea!

Unidad C # , 34 bytes

f=>UnityEngine.Random.onUnitSphere

La unidad tiene un valor incorporado para los valores aleatorios de la esfera de la unidad, así que pensé en publicarlo.

MATL , 10 bytes

1&3Xrt2&|/

Pruébalo en línea!

Explicación

Esto utiliza el primer enfoque descrito en el desafío.

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}

Pruébalo en línea!

Devuelve una matriz de 3 números [z,y,x].

xy yse generan al elevar i(raíz cuadrada de -1) a una potencia aleatoria entre 0 y 4. Este número complejo debe escalarse adecuadamente de acuerdo con el zvalor de acuerdo con el teorema de Pitágoras:(x**2 + y**2) + z**2 = 1.

La zcoordenada (que se genera primero) es simplemente un número distribuido uniformemente entre -1 y 1. Aunque no es inmediatamente obvio, dA / dz para un corte a través de una esfera es constante (e igual al perímetro de un círculo del mismo radio que toda la esfera).

Aparentemente, esto fue descubierto por Arquímedes, quien lo describió de una manera muy poco parecida al cálculo, y se conoce como el teorema de la Arqueta de Arquímedes. Ver https://brilliant.org/wiki/surface-area-sphere/

Otra referencia de los comentarios sobre la respuesta de xnor. Una URL sorprendentemente corta, que describe una fórmula sorprendentemente simple: http://mathworld.wolfram.com/Zone.html

05AB1E , 23 22 bytes

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

Implementa el segundo algoritmo.

Pruébelo en línea u obtenga algunas salidas aleatorias más .

Explicación:

$[0,1)$$0.00001$$0.000000001$59

[            # 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²

Usando el algoritmo "genera 3 valores normalmente distribuidos y normaliza ese vector".

Al finalizar un programa con una expresión, se imprime automáticamente el resultado en la pantalla de inicio después de que el programa finaliza, por lo que el resultado se muestra, no solo se genera y se oculta.

*: randNorm(es un token de dos bytes , el resto son tokens de un byte . He contado el inicial (inevitable) :, sin eso serían 14 bytes. Guardado como un programa con un nombre de una letra, ocupa 24 bytes de memoria, que incluye los 9 bytes de sobrecarga del sistema de archivos.

JavaScript (ES7),  77 76  75 bytes

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

Pruébalo en línea!

Comentado

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

Implementa el ^2º algoritmo.

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

Pruébalo en línea!

Comentado

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

Procesando 26 bytes

Programa completo

print(PVector.random3D());

Esta es la implementación 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

Pruébalo en línea!

Implementa el primer algoritmo.

Python 2 , 107103 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

Pruébalo en línea!

Implementa el segundo algoritmo.

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]

Pruébalo en línea!

Hace tres uniformes randoms y muestras de rechazo.

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)

Usted no necesita no a la entrada a.

Julia 1.0 , 24 bytes

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

Pruébalo en línea!

Dibuja un vector de 3 valores, extraídos de una distribución normal alrededor de 0 con desviación estándar 1. Luego, simplemente los normaliza.

MathGolf , 21 19 18 bytes

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

Implementación del segundo algoritmo.

Pruébelo en línea o vea algunas salidas más al mismo tiempo .

Explicación:

{              }▲   # 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 tercera algoritmo modificado), 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;}

Puerto de la respuesta de JavaScript de @Arnauld , ¡así que asegúrese de votarlo!
-2 bytes gracias a @ OlivierGrégoire .

Esto se implementa como:

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

Pruébalo en línea.

Implementación previa del 3er algoritmo ( 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);}

Implementado como:

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

Pruébalo en línea.

Explicación:

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 (segundo algoritmo), 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;}

Pruébalo en línea.

2do algoritmo:

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

Implementación del puerto de Arnauld del segundo algoritmo.

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

Pruébalo

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

Pruébalo en línea!

Utiliza el algoritmo n. ° 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

$i$$j$let ... infun()

Pruébalo en línea

Solución original:

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

Primero defino:

La Random.floatfunción de OCaml incluye los límites. Luego,

$\phi = p$$\theta = t$$-$$i$$j$