Le défi

Écrivez un programme ou une fonction qui ne prend aucune entrée et génère un vecteur de longueur $1$ dans une direction aléatoire théoriquement uniforme .

Cela équivaut à un point aléatoire sur la sphère décrit par

résultant en une distribution comme celle-ci

Sortie

Trois flotteurs d'une distribution aléatoire théoriquement uniforme pour laquelle l'équation $x^2+y^2+z^2=1$ est fidèle aux limites de précision.

Remarques du challenge

• La distribution aléatoire doit être théoriquement uniforme . Autrement dit, si le générateur de nombres pseudo-aléatoires devait être remplacé par un vrai RNG à partir des nombres réels, il en résulterait une distribution aléatoire uniforme des points sur la sphère.
• Générer trois nombres aléatoires à partir d'une distribution uniforme et les normaliser n'est pas valide: il y aura un biais vers les coins de l'espace tridimensionnel.
• De même, générer deux nombres aléatoires à partir d'une distribution uniforme et les utiliser comme coordonnées sphériques n'est pas valide: il y aura un biais vers les pôles de la sphère.
• Une bonne uniformité peut être obtenue par des algorithmes comprenant, mais sans s'y limiter:
  • Générez trois nombres aléatoires $x$ , $y$ et $z$ partir d'une distribution normale (gaussienne) autour de $0$ et normalisez-les.
    • Exemple d'implémentation
  • Générez trois nombres aléatoires $x$ , $y$ et $z$ partir d'une distribution uniforme dans la plage $(-1,1)$ . Calculez la longueur du vecteur par $l=\sqrt{x^2+y^2+z^2}$ . Ensuite, si$l>1$, rejetez le vecteur et générez un nouvel ensemble de nombres. Sinon, si$l \leq 1$, normalisez le vecteur et retournez le résultat.
    • Exemple d'implémentation
  • Générez deux nombres aléatoires $i$ et $j$ partir d'une distribution uniforme dans la plage $(0,1)$ et convertissez-les en coordonnées sphériques comme suit: $$\begin{align}\theta &= 2 \times \pi \times i\\\\\phi &= \cos^{-1}(2\times j -1)\end{align}$$ pour que$x$,$y$et$z$puissent être calculés par $$\begin{align}x &= \cos(\theta) \times \sin(\phi)\\\\y &= \sin(\theta) \times \sin(\phi)\\\\z &= \cos(\phi)\end{align}$$
    • Exemple d'implémentation
• Fournissez dans votre réponse une brève description de l'algorithme que vous utilisez.
• En savoir plus sur la sélection de points de sphère sur MathWorld .

Exemples de sortie

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

Remarques générales

• C'est du code-golf , donc la réponse utilisant le moins d'octets dans chaque langue gagne.
• Règles standard , les règles d' E / S et les règles échappatoire applicables.
• Veuillez inclure un lien Essayez-le en ligne ou équivalent pour montrer que votre code fonctionne.
• S'il vous plaît motiver votre réponse avec une explication de votre code.

Wolfram Language (Mathematica) , 20 octets

RandomPoint@Sphere[]

Essayez-le en ligne!

Est-ce exactement ce qu'il dit sur l'étain.

R , 23 octets

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

Essayez-le en ligne!

Génère 3 réalisations de la distribution $\mathcal N(0,1)$ et normalise le vecteur résultant.

Parcelle de 1000 réalisations:

Code machine x86-64 - 63 62 55 49 octets

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  

Utilise le deuxième algorithme, modifié. Renvoie le vecteur de [x, y, z, 0]dans xmm0.

Explication:

push 4Fh
push 3f800000h

Pousse la valeur de 1 et 2 ^ 31 en tant que flottant à la pile. Les données se chevauchent en raison de l'extension de signe, économisant quelques octets.

vbroadcastss xmm1,dword ptr [rsp+5] Charge la valeur de 2 ^ 31 dans 4 positions de xmm1.

rdrand      eax  
jnc         rand  
movd        xmm0,eax

Génère un entier 32 bits aléatoire et le charge au bas de xmm0.

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

Génère un entier aléatoire de 32 bits, le convertit en float (signé) et divise par 2 ^ 31 pour obtenir des nombres entre -1 et 1.

vdpps xmm2,xmm0,xmm0,7Fhajoute les carrés des 3 flotteurs inférieurs en utilisant lui-même un produit scalaire, masquant le flotteur supérieur. Cela donne la longueur

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

Compare la longueur au carré avec 1 et rejette les valeurs si elle n'est pas égale à 1. Si la longueur au carré est un, alors la longueur est également un. Cela signifie que le vecteur est déjà normalisé et enregistre une racine carrée et divise.

pop         rax  
pop         rax 

Restaurez la pile.

ret renvoie la valeur en xmm0

Essayez-le en ligne .

Python 2 , 86 octets

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

Essayez-le en ligne!

Génère uniformément la coordonnée z de -1 à 1. Ensuite, les coordonnées x et y sont échantillonnées uniformément sur un cercle de rayon (1-z*z)**.5.

Il n'est peut-être pas évident que la distribution sphérique soit en facteur uniforme sur la coordonnée z (et donc sur chaque coordonnée). C'est quelque chose de spécial pour la dimension 3. Voyez cette preuve que la surface d'une tranche horizontale d'une sphère est proportionnelle à sa hauteur. Bien que les tranches près de l'équateur aient un rayon plus grand, les tranches près du pôle sont plus orientées vers l'intérieur et il s'avère que ces deux effets s'annulent exactement.

Pour générer un angle aléatoire sur ce cercle, nous élevons l'unité imaginaire 1jà une puissance uniformément aléatoire entre 0 et 4, ce qui nous évite d'avoir besoin de fonctions trigonométriques, pi ou e, dont chacune aurait besoin d'une importation. Nous extrayons ensuite la partie réelle imaginaire. Si nous pouvons sortir un nombre complexe pour deux des coordonnées, la dernière ligne pourrait être print a,z.

86 octets

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

Essayez-le en ligne!

Génère trois normales et met le résultat à l'échelle.

Python 2 avec numpy, 57 octets

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

Essayez-le en ligne!

sum(a*a)**.5est plus court que linalg.norm(a). On pourrait aussi faire dot(a,a)pour la même durée que sum(a*a). En Python 3, cela peut être raccourci en a@autilisant le nouvel opérateur @.

Octave , 40 33 22 octets

Nous échantillonnons une distribution normale standard 3D et normalisons le vecteur:

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

Essayez-le en ligne!

Unity C # , 34 octets

f=>UnityEngine.Random.onUnitSphere

Unity a une fonction intégrée pour les valeurs aléatoires de la sphère unitaire, j'ai donc pensé la publier.

MATL , 10 octets

1&3Xrt2&|/

Essayez-le en ligne!

Explication

Cela utilise la première approche décrite dans le défi.

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

Rubis , 34 50 49 octets

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

Essayez-le en ligne!

Renvoie un tableau de 3 nombres [z,y,x].

xet ysont générés en augmentant i(racine carrée de -1) à une puissance aléatoire entre 0 et 4. Ce nombre complexe doit être mis à l'échelle de manière appropriée en fonction de la zvaleur conformément au théorème de Pythagore:(x**2 + y**2) + z**2 = 1.

La zcoordonnée (qui est générée en premier) est simplement un nombre uniformément réparti entre -1 et 1. Bien que cela ne soit pas immédiatement évident, dA / dz pour une tranche à travers une sphère est constant (et égal au périmètre d'un cercle de même rayon que toute la sphère.).

Cela a apparemment été découvert par Archimède qui l'a décrit d'une manière très peu semblable au calcul, et il est connu sous le nom de théorème d'Archimède Hat-Box. Voir https://brilliant.org/wiki/surface-area-sphere/

Une autre référence des commentaires sur la réponse de xnor. Une URL étonnamment courte, décrivant une formule étonnamment simple: http://mathworld.wolfram.com/Zone.html

05AB1E , 23 22 octets

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

Implémente le 2ème algorithme.

Essayez-le en ligne ou obtenez quelques sorties aléatoires supplémentaires .

Explication:

REMARQUE: 05AB1E n'a pas de fonction intégrée pour obtenir une valeur décimale aléatoire dans la plage . Au lieu de cela, je crée une liste par incréments de et je choisis des valeurs aléatoires dans cette liste. Cette augmentation pourrait être modifiée pour en changeant le pour dans le code (bien qu'il deviendrait plutôt lent ..).$[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 octets ^*

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

En utilisant l'algorithme "générer 3 valeurs normalement distribuées et normaliser ce vecteur".

La fin d'un programme avec une expression imprime automatiquement le résultat sur l'écran d'accueil une fois le programme terminé, de sorte que le résultat est réellement affiché, pas seulement généré et noirci.

*: randNorm(est un jeton de deux octets , les autres sont des jetons d'un octet . J'ai compté l'initiale (inévitable) :, sans que ce soit 14 octets. Enregistré en tant que programme avec un nom à une lettre, il prend 24 octets de mémoire, ce qui inclut les 9 octets de surcharge du système de fichiers.

JavaScript (ES7),  77 76  75 octets

Implémente le 3 ^ème algorithme, en utilisant .$\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]

Essayez-le en ligne!

Commenté

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 octets

Implémente le 2 ^ème algorithme.

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

Essayez-le en ligne!

Commenté

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

Traitement de 26 octets

Programme complet

print(PVector.random3D());

Il s'agit de la mise en œuvre 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 octets

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

Essayez-le en ligne!

Implémente le premier algorithme.

Python 2 , 107 103 octets

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

Essayez-le en ligne!

Implémente le deuxième algorithme.

Haskell , 125 123 119 118 octets

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

Essayez-le en ligne!

Fait trois uniformes aléatoires et échantillonnage de rejet.

JavaScript, 95 octets

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)

Vous n'avez pas besoin de ne pas entrer a.

Julia 1.0 , 24 octets

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

Essayez-le en ligne!

Dessine un vecteur de 3 valeurs, tiré d'une distribution normale autour de 0 avec l'écart-type 1. Il suffit ensuite de les normaliser.

MathGolf , 21 19 18 octets

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

Implémentation du 2ème algorithme.

Essayez-le en ligne ou voyez quelques sorties supplémentaires en même temps .

Explication:

{              }▲   # 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 ( 3e algorithme modifié @Arnauld ), 131 126 119 111 111 109 octets

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 de la réponse JavaScript de @Arnauld , alors assurez-vous de voter pour lui!
-2 octets grâce à @ OlivierGrégoire .

Ceci est implémenté comme:

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

Essayez-le en ligne.

Ancienne implémentation du 3ème algorithme ( 131 126 119 octets):

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

Mis en œuvre en tant que:

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

Essayez-le en ligne.

Explication:

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ème algorithme), 153 143 octets

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

Essayez-le en ligne.

2ème algorithme:

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 octets

Port d' implémentation d' Arnauld du 2ème algorithme.

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

Essaye-le

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 octets

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

Essayez-le en ligne!

Utilise l'algorithme # 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 octets

(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: a réduit certains octets en insérant et , en remplaçant le premier par a , et en profitant de l'associativité des opérateurs pour éviter certaines parens .$i$$j$let ... infun()

Essayez-le en ligne

Solution originale:

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

Je définis d'abord:

La Random.floatfonction d'OCaml inclut les limites. Ensuite,

Ceci est très similaire à l'implémentation du 3ème exemple (avec et ) sauf que je choisis et dans des intervalles plus grands pour éviter la multiplication (avec 2) plus tard.$\phi = p$$\theta = t$$-$$i$$j$