Как преобразовать количество псевдослучайных битов в статистически случайное значение с плавающей запятой от 0 до 1?

(Редактировать: как указано в комментариях к моему вопросу, это не лучший способ делать что-то, но если у кого-то есть веская причина делать такие вещи, я оставлю это здесь.)

Я думаю, что понял это после некоторых экспериментов.

Поле экспоненты использует значение 1023 для представления 0 — большие значения являются положительными, меньшие — отрицательными. Таким образом, значение 1023 в показателе степени позволяет интерпретировать остальную часть поля мантиссы "как есть", т.е. - все после десятичной точки в числе.

Это приводит к тому, что UInt64.MaxValue сопоставляется с ~ 1,999, что почти равно 2 (и оно будет напечатано как 2, если вы используете Console.WriteLine() без установки количества отображаемых цифр). UInt64.MaxValue / 2 сопоставляется с 1.5, UInt64.MaxValue / 4 сопоставляется с 1.25.

Это здорово, за исключением того факта, что ко всем этим значениям прибавлено 1,0. К счастью, похоже, что я могу избавиться от этого, просто вычитая 1,0 из окончательного результата. На первый взгляд кажется, что это работает (UInt64.MaxValue / 4 теперь соответствует 0,25). Я не уверен, что это вызовет ошибки с меньшими значениями, но, надеюсь, этого не произойдет.

Окончательный, я думаю, рабочий код:

public static double DoubleFromRand(ulong rand) {
    ulong resultUL = rand >> 12;
    resultUL += ((ulong)1023 << 52);
    return BitConverter.ToDouble(BitConverter.GetBytes(resultUL), 0) - 1.0;
}

Обратите внимание, что этот беспорядок, вероятно, не переносим на все процессоры - согласно Википедии (где я получил всю информацию о математике с плавающей запятой IEEE754), некоторые процессоры делают действительно странные вещи с порядком байтов при работе с числами с плавающей запятой, поэтому в зависимости от вашего процессора, это может дать вам серьезно зашифрованные результаты. Но пока на моем конкретном 64-битном процессоре ARM это работает.

Общий подход к преобразованию «битов в статистически случайное значение с плавающей запятой от 0 до 1?» начинается с преобразования таких битов в значение между [1,0 ... 2,0) и последующего вычитания 1,0.

Числа с плавающей запятой распределяются линейно между последовательными степенями двойки.

При обычном кодировании double существует 2 ⁵² значений между большинством степеней 2. Итак, возьмите 64-битные случайные данные и уменьшите до 52 и сформируйте случайное число [1.0... 2.0) (код OP делает это с различные битовые манипуляции), затем вычтите 1,0.

Это подход OP к самоответу .

Когда все сделано правильно, он обеспечивает быстрый подход, но имеет дополнительные проблемы с переносимостью по сравнению со следующим.

Другой подход заключается в использовании 52 из 64 предоставленных случайных битов, формировании значения [0...2⁵²-1] и делении на 2⁵². Ожидается, что сдвиг, преобразование из ulong в double и деление будут точными и не зависят от режима округления. Таким образом, мы предотвращаем появление статистической погрешности, но формируем только 2⁵² разных значения.

// Something like
double DoubleFromRand(ulong rand) { 
  return (double)(rand >> 12)/(1ul << 52);
}

Мы можем даже использовать на 1 бит больше @dan04 и по-прежнему иметь «сдвиг, преобразование из ulong в double и деление, как ожидается, будут точными и не зависят от режима округления». Использование более 53 бит теряет это свойство.

double DoubleFromRand53(ulong rand) {
  return (double)(rand >> 11)/(1ul << 53);
}

Другой подход, не показанный, будет использовать 64 из 64 бит и формировать значение [0...2⁶⁴-1] и делить на 2⁶⁴. К сожалению, это влечет за собой округление целого числа для преобразования и большее округление при делении, что приводит к нежелательному смещению и диапазону (может быть возвращено 1,0), но дает ближе к 2⁶⁴ различным значениям.