Соревнование

Напишите программу или функцию, которая не требует ввода и выводит вектор длины в теоретически однородном случайном направлении.$1$

Это эквивалентно случайной точке на сфере, описываемой

в результате чего такое распределение

Выход

Три числа с плавающей точкой из теоретически однородного случайного распределения, для которого уравнение выполняется в пределах точности.$x^2+y^2+z^2=1$

Вызов замечания

• Случайное распределение должно быть теоретически однородным . То есть, если генератор псевдослучайных чисел заменить истинным ГСЧ из действительных чисел, это приведет к равномерному случайному распределению точек на сфере.
• Генерирование трех случайных чисел из равномерного распределения и их нормализация недопустимы: будет смещение в сторону углов трехмерного пространства.
• Аналогично, создание двух случайных чисел из равномерного распределения и использование их в качестве сферических координат недопустимо: будет иметь место смещение к полюсам сферы.
• Надлежащее единообразие может быть достигнуто с помощью алгоритмов, включая, но не ограничиваясь:
  • Генерация трех случайных чисел , и из нормального (гауссовского) распределения около и нормализация их. $x$$y$$z$$0$
    • Пример реализации
  • Генерация трех случайных чисел , и из равномерного распределения в диапазоне . Вычислить длину вектора с помощью . Затем, если , отбросим вектор и сгенерируем новый набор чисел. Иначе, если , нормализовать вектор и вернуть результат. $x$$y$$z$$(-1,1)$$l=\sqrt{x^2+y^2+z^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}$$
    • Пример реализации
• Предоставьте в своем ответе краткое описание используемого вами алгоритма.
• Узнайте больше о выборе точек на 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]

Основные пометки

• Это код-гольф , поэтому ответ, использующий наименьшее количество байтов на каждом языке, выигрывает.
• Применяются стандартные правила , правила ввода / вывода и лазейки .
• Пожалуйста, включите ссылку Try it Online или эквивалентную, чтобы продемонстрировать, как работает ваш код.
• Пожалуйста, мотивируйте ваш ответ объяснением вашего кода.

Wolfram Language (Mathematica) , 20 байтов

RandomPoint@Sphere[]

Попробуйте онлайн!

Делает именно то, что говорит на жестяной банке.

R , 23 байта

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

Попробуйте онлайн!

Генерирует 3 реализации распределения $\mathcal N(0,1)$ и нормализует результирующий вектор.

Участок 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 в 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

Попробуйте онлайн .

Python 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

Попробуйте онлайн!

Генерирует z-координату равномерно от -1 до 1. Затем координаты 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

Попробуйте онлайн!

Создает три нормали и масштабирует результат.

Python 2 с NumPy, 57 байтов

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@aиспользования оператора new @.

Октава , 40 33 22 байта

Мы выбираем форму стандартного нормального распределения 3d и нормализуем вектор:

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

Попробуйте онлайн!

Unity C # , 34 байта

f=>UnityEngine.Random.onUnitSphere

Unity имеет встроенную функцию для случайных значений сфер, поэтому я решил опубликовать ее.

MATL , 10 байт

1&3Xrt2&|/

Попробуйте онлайн!

объяснение

При этом используется первый подход, описанный в задаче.

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(квадратный корень из -1) до случайной степени между 0 и 4. Это комплексное число должно быть соответствующим образом масштабировано в соответствии со zзначением в соответствии с теоремой Пифагора:(x**2 + y**2) + z**2 = 1.

zКоординат (который генерируется первая) просто равномерно распределено число между -1 и 1. Хотя это и не сразу видно, дА / дг для среза через сферу постоянна (и равна периметру окружности того же радиуса, вся сфера.).

Это, по-видимому, было обнаружено Архимедом, который описал его очень не в форме исчисления, и это известно как теорема Архимеда о шляпной коробке. Смотрите https://brilliant.org/wiki/surface-area-sphere/

Еще одна ссылка из комментариев на ответ xnor. Удивительно короткий URL, описывающий удивительно простую формулу: http://mathworld.wolfram.com/Zone.html

05AB1E , 23 22 байта

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

Реализует 2-й алгоритм.

Попробуйте онлайн или получите еще несколько случайных результатов .

Объяснение:

ПРИМЕЧАНИЕ: 05AB1E не имеет встроенной функции для получения случайного десятичного значения в диапазоне $[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(это двухбайтовый токен , остальные - однобайтовые токены . Я посчитал начальный (неизбежный) :, без этого это было бы 14 байтов. Сохраненный как программа с однобуквенным именем, он занимает 24 байта памяти, что включает 9 байтов служебной информации файловой системы.

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

JavaScript (ES6), 79 байт

Реализует 2- ^й алгоритм.

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

Python 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

Попробуйте онлайн!

Реализует первый алгоритм.

Python 2 , 107 103 байта

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

Попробуйте онлайн!

Реализует второй алгоритм.

Haskell , 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]

Попробуйте онлайн!

Делает три униформы случайных и бракованных выборок.

JavaScript, 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.

Юлия 1,0 , 24 байта

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

Попробуйте онлайн!

Рисует вектор из 3 значений, взятый из нормального распределения около 0 со стандартным отклонением 1. Затем просто нормализует их.

MathGolf , 21 19 18 байт

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

Реализация 2-го алгоритма.

Попробуйте онлайн или посмотрите несколько выходов одновременно .

Объяснение:

{              }▲   # 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 ( модифицированный 3-й алгоритм @Arnauld ), 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 's JavaScript answer , так что обязательно проголосуйте за него!
-2 байта благодаря @ OlivierGrégoire .

Это реализовано как:

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

Попробуйте онлайн.

Предыдущая реализация третьего алгоритма ( 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-й алгоритм), 153 143 байта

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

Попробуйте онлайн.

2-й алгоритм:

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 байт

Порт Арнаулда по реализации 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на a fun, и используя ассоциативность операторов, чтобы избежать некоторых слов ().

Попробуйте онлайн

Оригинальное решение:

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

Сначала я определяю:

Random.floatФункция OCaml включает в себя границы. Затем,

Это очень похоже на реализацию третьего примера (с $\phi = p$ а также $\theta = t$) $-$ кроме того, что я выбираю $i$ а также $j$ в больших интервалах, чтобы избежать умножения (с 2) позже.