std.random

import std.algorithm.comparison : among, equal;
import std.range : iota;

// 定数を乱数ジェネレータにシードする
auto rnd = Random(42);

// 範囲[0, 14]で一様分布する整数を生成する
// 乱数ジェネレータが渡されない場合は、グローバル変数`rndGen`が使用される
auto i = uniform(0, 15, rnd);
assert(i >= 0 && i < 15);

// 範囲[0, 100]で一様分布する実数を生成する
auto r = uniform(0.0L, 100.0L, rnd);
assert(r >= 0 && r < 100);

// カスタム型からのサンプル
enum Fruit { apple, mango, pear }
auto f = rnd.uniform!Fruit;
with(Fruit)
assert(f.among(apple, mango, pear));

// 32ビットの乱数を生成する
auto u = uniform!uint(rnd);
static assert(is(typeof(u) == uint));

// [0, 1]の範囲で乱数を生成する
auto u2 = uniform01(rnd);
assert(u2 >= 0 && u2 < 1);

// ランダムに要素を選択する
auto el = 10.iota.choice(rnd);
assert(0 <= el && el < 10);

// カスタム比率でサイコロを振る
// 0: 20%, 1: 10%, 2: 60%
auto val = rnd.dice(0.2, 0.1, 0.6);
assert(0 <= val && val <= 2);

auto rnd2 = MinstdRand0(42);

// 範囲からランダムなサブサンプルを選択する
assert(10.iota.randomSample(3, rnd2).equal([7, 8, 9]));

// 配列内のすべての要素をランダムな順序でカバーする
version (D_LP64) // https://issues.dlang.org/show_bug.cgi?id=15147
    assert(10.iota.randomCover(rnd2).equal([7, 4, 2, 0, 1, 6, 8, 3, 9, 5]));
else
    assert(10.iota.randomCover(rnd2).equal([4, 8, 7, 3, 5, 9, 2, 6, 0, 1]));

// 配列をシャッフルする
version (D_LP64) // https://issues.dlang.org/show_bug.cgi?id=15147
    assert([0, 1, 2, 4, 5].randomShuffle(rnd2).equal([2, 0, 4, 5, 1]));
else
    assert([0, 1, 2, 4, 5].randomShuffle(rnd2).equal([4, 2, 5, 0, 1]));

enum bool isUniformRNG(Rng, ElementType);

enum bool isUniformRNG(Rng);

Rngが乱数生成器かどうかをテストする。オーバーロード は、Rngがその型の値を生成することも確認する。 がその型の値を生成することも確認する。

乱数ジェネレータは少なくとも以下の機能を持つ:

• InputRangeである。
• CTFEで読み取り可能な'bool isUniformRandom'フィールドを持つ。

Examples:

struct NoRng
{
    @property uint front() {return 0;}
    @property bool empty() {return false;}
    void popFront() {}
}
static assert(!isUniformRNG!(NoRng));

struct validRng
{
    @property uint front() {return 0;}
    @property bool empty() {return false;}
    void popFront() {}

    enum isUniformRandom = true;
}
static assert(isUniformRNG!(validRng, uint));
static assert(isUniformRNG!(validRng));

enum bool isSeedable(Rng, SeedType);

enum bool isSeedable(Rng);

Rngがシード可能かどうかをテストする。オーバーロード は SeedType を取り、Rng が SeedType でシード可能であることも確認する。

シード可能な乱数生成器には、以下の追加機能がある:

• seed(ElementType)」関数がある。

Examples:

struct validRng
{
    @property uint front() {return 0;}
    @property bool empty() {return false;}
    void popFront() {}

    enum isUniformRandom = true;
}
static assert(!isSeedable!(validRng, uint));
static assert(!isSeedable!(validRng));

struct seedRng
{
    @property uint front() {return 0;}
    @property bool empty() {return false;}
    void popFront() {}
    void seed(uint val){}
    enum isUniformRandom = true;
}
static assert(isSeedable!(seedRng, uint));
static assert(!isSeedable!(seedRng, ulong));
static assert(isSeedable!(seedRng));

struct LinearCongruentialEngine(UIntType, UIntType a, UIntType c, UIntType m) if (isUnsigned!UIntType);

線形合同生成器。m = 0のとき、モジュラスは使われない。

Examples:

独自の線形合同エンジンを宣言する

alias CPP11LCG = LinearCongruentialEngine!(uint, 48271, 0, 2_147_483_647);

// 定数のシード
auto rnd = CPP11LCG(42);
auto n = rnd.front; // 実行ごとに同じ
writeln(n); // 2027382

Examples:

独自の線形合同エンジンを宣言する

// glibcのLCG
alias GLibcLCG = LinearCongruentialEngine!(uint, 1103515245, 12345, 2_147_483_648);

// 予測不可能な値を持つシード
auto rnd = GLibcLCG(unpredictableSeed);
auto n = rnd.front; // 実行ごとに異なる

Examples:

独自の線形合同エンジンを宣言する

// Visual C++のLCG
alias MSVCLCG = LinearCongruentialEngine!(uint, 214013, 2531011, 0);

// 定数のシード
auto rnd = MSVCLCG(1);
auto n = rnd.front; // 実行ごとに同じ
writeln(n); // 2745024

enum bool isUniformRandom;

Rngとしてマークする

enum bool hasFixedRange;

このジェネレータは固定範囲を持つか?(true)。

enum UIntType min;

最も低い生成値(c == 0 の場合は1 、それ以外の場合は0 )。

enum UIntType max;

最高生成値 (modulus - 1).

enum UIntType multiplier;

enum UIntType increment;

enum UIntType modulus;

この分布のパラメータ。乱数はx = (x * multipler + increment) % modulus である。

pure nothrow @nogc @safe this(UIntType x0);

でシードされたLinearCongruentialEngineジェネレータを構築する。 x0.

pure nothrow @nogc @safe void seed(UIntType x0 = 1);

ジェネレータを(再)シードする。

pure nothrow @nogc @safe void popFront();

乱数列を進める。

const pure nothrow @nogc @property @safe UIntType front();

乱数列の現在の番号を返す。

const pure nothrow @nogc @property @safe typeof(this) save();

enum bool empty;

常にfalse (ランダムジェネレータは無限範囲である)。

alias MinstdRand0 = LinearCongruentialEngine!(uint, 16807u, 0u, 2147483647u).LinearCongruentialEngine;

alias MinstdRand = LinearCongruentialEngine!(uint, 48271u, 0u, 2147483647u).LinearCongruentialEngine;

よく選ばれたパラメータでLinearCongruentialEngineジェネレータを定義する。 パラメータを定義する。 MinstdRand0パークとミラーの「最小標準」ジェネレータを実装する。 標準 "ジェネレータを実装している。 MinstdRand 乗算器48271を使用することで、スペクトルの挙動をわずかに改善した変種を実装する。 乗算器48271を使用する。どちらのジェネレーターもかなり単純化されている。

Examples:

// 定数のシード
auto rnd0 = MinstdRand0(1);
auto n = rnd0.front;
 // 実行ごとに同じ
writeln(n); // 16807

// 予測不可能な値を持つシード
rnd0.seed(unpredictableSeed);
n = rnd0.front; // 実行ごとに異なる

struct MersenneTwisterEngine(UIntType, size_t w, size_t n, size_t m, size_t r, UIntType a, size_t u, UIntType d, size_t s, UIntType b, size_t t, UIntType c, size_t l, UIntType f) if (isUnsigned!UIntType);

メルセンヌ・ツイスター・ジェネレーター

Examples:

// 定数のシード
Mt19937 gen;
auto n = gen.front; // 実行ごとに同じ
writeln(n); // 3499211612

// 予測不可能な値を持つシード
gen.seed(unpredictableSeed);
n = gen.front; // 実行ごとに異なる

enum bool isUniformRandom;

これをRngとしてマークする。

enum size_t wordSize;

enum size_t stateSize;

enum size_t shiftSize;

enum size_t maskBits;

enum UIntType xorMask;

enum size_t temperingU;

enum UIntType temperingD;

enum size_t temperingS;

enum UIntType temperingB;

enum size_t temperingT;

enum UIntType temperingC;

enum size_t temperingL;

enum UIntType initializationMultiplier;

ジェネレータのパラメータ。

enum UIntType min;

最も小さい生成値(0)。

enum UIntType max;

生成される最大の値。

enum UIntType defaultSeed;

デフォルトのシード値。

pure nothrow @nogc @safe this(UIntType value);

MersenneTwisterEngine オブジェクトを構築する。

pure nothrow @nogc @safe void seed()(UIntType value = defaultSeed);

MersenneTwisterEngine オブジェクトにシードを設定する。

注釈 このシード関数は 2^w の開始点を与える (指定された値の下位 w ビットが使用される)。 が使用される)。RNGを任意の内部状態 RNGの内部状態のいずれかで開始できるようにするには、seedオーバーロードを使用する。 入力範囲。

void seed(T)(T range)
if (isInputRange!T && is(immutable(ElementType!T) == immutable(UIntType)));

InputRange を用いて MersenneTwisterEngine オブジェクトにシードを与える。

Throws:

Exception InputRangeがジェネレータの播種に十分な要素を提供しなかった場合。 必要な要素数は MersenneTwisterEngine 構造体のテンプレート・パラメータ 'n' である。

pure nothrow @nogc @safe void popFront();

ジェネレータを進める。

const pure nothrow @nogc @property @safe UIntType front();

現在の乱数値を返す。

const pure nothrow @nogc @property @safe typeof(this) save();

enum bool empty;

常にfalse 。

alias Mt19937 = MersenneTwisterEngine!(uint, 32LU, 624LU, 397LU, 31LU, 2567483615u, 11LU, 4294967295u, 7LU, 2636928640u, 15LU, 4022730752u, 18LU, 1812433253u).MersenneTwisterEngine;

のパラメータでインスタンス化されたMersenneTwisterEngine である。 のパラメータでインスタンス化したものである。 を生成する。乱数生成に推奨される。 メモリが著しく制限されている場合を除き、乱数生成に推奨される。 LinearCongruentialEngineが選択されるだろう。

Examples:

// 定数のシード
Mt19937 gen;
auto n = gen.front; // 実行ごとに同じ
writeln(n); // 3499211612

// 予測不可能な値を持つシード
gen.seed(unpredictableSeed);
n = gen.front; // 実行ごとに異なる

alias Mt19937_64 = MersenneTwisterEngine!(ulong, 64LU, 312LU, 156LU, 31LU, 13043109905998158313LU, 29LU, 6148914691236517205LU, 17LU, 8202884508482404352LU, 37LU, 18444473444759240704LU, 43LU, 6364136223846793005LU).MersenneTwisterEngine;

オリジナルのエンジンMT19937-64のパラメータでインスタンス化されたMersenneTwisterEngine 。 オリジナルのエンジンMT19937-64のパラメータでインスタンス化され、2の19937乗の周期を持つ一様分布の64ビット数を生成する。 を生成する。

Examples:

// 定数のシード
auto gen = Mt19937_64(12345);
auto n = gen.front; // 実行ごとに同じ
writeln(n); // 6597103971274460346

// 予測不可能な値を持つシード
gen.seed(unpredictableSeed!ulong);
n = gen.front; // 実行ごとに異なる

struct XorshiftEngine(UIntType, uint nbits, int sa, int sb, int sc) if (isUnsigned!UIntType && !(sa > 0 && (sb > 0) && (sc > 0)));

template XorshiftEngine(UIntType, int bits, int a, int b, int c) if (isUnsigned!UIntType && (a > 0) && (b > 0) && (c > 0))

Xorshiftジェネレータ。 サイズが小さい場合はXorshift RNGs (Marsaglia, 2003)に従って実装されている。サイズが大きい場合は は、内部配列の回転を避けるためにインデックスを使用するという Sebastino Vignaの最適化を使用している。 を使用する。

周期は、レガシーな192ビットuintバージョンを除き、2 ^^ nbits - 1 (下記注参照)である。 を参照のこと)。

Parameters:

UIntType	xorshiftジェネレーターのワードサイズと戻り値の型。 opCall を返す。
nbits	このジェネレーターの状態のビット数。これは UIntTypeのビット・サイズの正の倍数でなければならない。もし nbitsが大きい場合、この構造体はこれよりも若干多くのメモリを占有するかもしれない。 配列全体をシフトする代わりに循環カウンタを使うことができる。 配列全体をシフトする代わりに循環カウンタを使用することができる。
sa	1回目のシフトの方向と大きさ。正の は左、負は右を意味する。
sb	2回目のシフトの方向と大きさ。正 は左、負は右を意味する。
sc	第3シフトの方向と大きさ。正 は左、負は右を意味する。

注釈: 歴史的な互換性のために、nbits == 192 およびUIntType がuint の場合、160ビットのxorshiftと32ビットのカウンターを組み合わせたレガシーハイブリッドPRNGが使用される。 と32ビットカウンタから構成される。この複合ジェネレータは、周期が と の最小公倍数に等しい。 2^^160 - 1 2^^32の最小公倍数に等しい。

以前のバージョンの XorshiftEngineの以前のバージョンは は、シフトの方向を指定する機構を提供せず、各シフトを符号なしの大きさとみなしていた。 後方互換性のために、同じ方向の3つのシフトは全周期のXorshiftEngineにならないので は全周期のXorshiftEngineにならないため、sa,sb 、 sc, are positive XorshiftEngine` はこれらを符号なしマグニチュードとして扱い、シフト方向を旧来の動作と一致させる。 の古い動作と一致するようにシフト方向を使用する。 XorshiftEngine.

シフトのすべてのセットが全周期の xorshift ジェネレーターになるわけではない。 現在のところ、テンプレートはコンパイル時に最大周期のチェックを行わない。 しかし将来のバージョンでは、より短い周期をもたらすパラメータ を拒否するかもしれない。

Examples:

alias Xorshift96  = XorshiftEngine!(uint, 96,  10, 5,  26);
auto rnd = Xorshift96(42);
auto num = rnd.front;  // 実行ごとに同じ
writeln(num); // 2704588748

enum bool isUniformRandom;

これを Rng としてマークする。

enum auto empty;

常にfalse (ランダムジェネレータは無限の範囲である)。

enum UIntType min;

最も小さい生成値。

enum UIntType max;

最大生成値。

pure nothrow @nogc @safe this()(UIntType x0);

x0 をシードとするXorshiftEngine ジェネレータを構築する。

Parameters:

UIntType x0

内部状態を決定論的に初期化するために使用される値。

pure nothrow @nogc @safe void seed()(UIntType x0);

ジェネレータを(再)シードする。

Parameters:

UIntType x0

内部状態を決定論的に初期化するために使用される値

const pure nothrow @nogc @property @safe UIntType front();

乱数列の現在の番号を返す。

pure nothrow @nogc @safe void popFront();

乱数列を進める。

const pure nothrow @nogc @property @safe typeof(this) save();

範囲の状態をキャプチャする。

alias Xorshift32 = XorshiftEngine!(uint, 32u, 13, -17, 15).XorshiftEngine;

alias Xorshift64 = XorshiftEngine!(uint, 64u, 10, -13, -10).XorshiftEngine;

alias Xorshift96 = XorshiftEngine!(uint, 96u, 10, -5, -26).XorshiftEngine;

alias Xorshift128 = XorshiftEngine!(uint, 128u, 11, -8, -19).XorshiftEngine;

alias Xorshift160 = XorshiftEngine!(uint, 160u, 2, -1, -4).XorshiftEngine;

alias Xorshift192 = XorshiftEngine!(uint, 192u, -2, 1, 4).XorshiftEngine;

alias Xorshift = XorshiftEngine!(uint, 128u, 11, -8, -19).XorshiftEngine;

よく選ばれたパラメータでXorshiftEngine ジェネレータを定義する。Xorshift RNG」の各ビットの例を参照のこと。 XorshiftはXorshift128のエイリアスで、128ビットの実装が主に使われているからである。

Examples:

// 定数のシード
auto rnd = Xorshift(1);
auto num = rnd.front;  // 実行ごとに同じ
writeln(num); // 1405313047

// 予測不可能な値をシードする
rnd.seed(unpredictableSeed);
num = rnd.front; // rndごとに異なる

nothrow @nogc @property @trusted uint unpredictableSeed();

template unpredictableSeed(UIntType) if (isUnsigned!UIntType)

乱数エンジンを初期化するための「良い」シードである。を初期化する。 で初期化すると、エンジンは実行ごとに異なる乱数列を生成する。 を生成させる。

Returns:

符号なし整数のシード値を1つ指定する。

注釈 一般的にPRNGを定期的に「再シード」しても、その品質は向上しない。 場合によっては害になることもある。極端な例としてMersenneがある。 ツイスターは2 ^^ 19937 - 1 の状態を持っているが、seed(uint) が呼び出された後は、 の状態のいずれかにしかなれない。 が呼び出された後では、エントロピーの源がいかに優れていても、2 ^^ 32 のうちの1つの状態にしかならない。 いかにエントロピーの源が優れていてもである。

Examples:

auto rnd = Random(unpredictableSeed);
auto n = rnd.front;
static assert(is(typeof(n) == uint));

alias Random = MersenneTwisterEngine!(uint, 32LU, 624LU, 397LU, 31LU, 2567483615u, 11LU, 4294967295u, 7LU, 2636928640u, 15LU, 4022730752u, 18LU, 1812433253u).MersenneTwisterEngine;

現在のプラットフォームにおける "デフォルト"、"お気に入り"、"推奨"乱数発生器の型。 である。これは、以前に定義された ジェネレータの別名である。(1)素敵な乱数を生成する必要があり、(2) (2)使用されている乱数生成方法の細かいことは気にしない。 メソッドが使われている。

nothrow @nogc @property ref @safe Random rndGen();

このモジュールの様々な関数で使用されるグローバル乱数生成器である。 モジュールのさまざまな関数で使用されるグローバル乱数ジェネレータである。スレッドごとに割り当てられ スレッドごとに割り当てられ、スレッドごとに予測できない値に初期化される。

Returns:

デフォルトの乱数生成器である

Examples:

import std.algorithm.iteration : sum;
import std.range : take;
auto rnd = rndGen;
assert(rnd.take(3).sum > 0);

auto uniform(string boundaries = "[)", T1, T2)(T1 a, T2 b)
if (!is(CommonType!(T1, T2) == void));

auto uniform(string boundaries = "[)", T1, T2, UniformRandomNumberGenerator)(T1 a, T2 b, ref UniformRandomNumberGenerator urng)
if (isFloatingPoint!(CommonType!(T1, T2)) && isUniformRNG!UniformRandomNumberGenerator);

から aと b.の間の数値を生成する。boundaries パラメータは区間の形状を制御する。 )を制御する。boundaries の有効な値は、"[]" 、"(]" 、"[)" 、"()" である。デフォルトの区間 は左が閉じ、右が開いている。を取らないバージョンは を取らないバージョンは urngを取らないバージョンは、デフォルトのジェネレーターrndGen を使用する。

Parameters:

T1 a	一様分布の下界
T2 b	一様分布の上界
UniformRandomNumberGenerator urng	(オプション) 使用する乱数生成器; 指定しない場合、デフォルトはrndGen

Returns:

一様分布から引かれた単一の乱数変量 と aと bの共通型である。 の共通型である。

Examples:

auto rnd = Random(unpredictableSeed);

// [0, 1023]の整数を生成
auto a = uniform(0, 1024, rnd);
assert(0 <= a && a < 1024);

// [0, 1]のfloatを生成
auto b = uniform(0.0f, 1.0f, rnd);
assert(0 <= b && b < 1);

// [0, 1]のfloatを生成
b = uniform!"[]"(0.0f, 1.0f, rnd);
assert(0 <= b && b <= 1);

// (0, 1)のfloatを生成
b = uniform!"()"(0.0f, 1.0f, rnd);
assert(0 < b && b < 1);

Examples:

範囲関数とUFCSを使用して乱数の配列を作成する。

import std.array : array;
import std.range : generate, takeExactly;

int[] arr = generate!(() => uniform(0, 100)).takeExactly(10).array;
writeln(arr.length); // 10
assert(arr[0] >= 0 && arr[0] < 100);

auto uniform(T, UniformRandomNumberGenerator)(ref UniformRandomNumberGenerator urng)
if (!is(T == enum) && (isIntegral!T || isSomeChar!T) && isUniformRNG!UniformRandomNumberGenerator);

auto uniform(T)()
if (!is(T == enum) && (isIntegral!T || isSomeChar!T));

auto uniform(E, UniformRandomNumberGenerator)(ref UniformRandomNumberGenerator urng)
if (is(E == enum) && isUniformRNG!UniformRandomNumberGenerator);

auto uniform(E)()
if (is(E == enum));

任意の整数型または文字型T に対して、[T.min, T.max] の範囲で一様に分布した数値を生成する。乱数生成器が渡されない場合 乱数生成器が渡されない場合、デフォルトのrndGen を使用する。

型としてenum が使用された場合、乱数変量は以下のいずれかの値から等確率で抽選される。 列挙型"E の取り得る値から等確率で抽選される。

Parameters:

UniformRandomNumberGenerator urng

(オプション) 使用する乱数生成器; 指定しない場合のデフォルトはrndGen

Returns:

をデフォルトとする。 T 。

Examples:

auto rnd = MinstdRand0(42);

writeln(rnd.uniform!ubyte); // 102
writeln(rnd.uniform!ulong); // 4838462006927449017

enum Fruit { apple, mango, pear }
version (D_LP64) // https://issues.dlang.org/show_bug.cgi?id=15147
writeln(rnd.uniform!Fruit); // Fruit.mango

T uniform01(T = double)()
if (isFloatingPoint!T);

T uniform01(T = double, UniformRNG)(ref UniformRNG rng)
if (isFloatingPoint!T && isUniformRNG!UniformRNG);

型の一様分布浮動小数点数を生成する。 T を生成する。 乱数生成器が指定されていない場合 が指定されていない場合、デフォルトのRNGrndGen が乱数発生源として使用される。 が使用される。

uniform01よりも高速に乱数を生成できる。 uniform!"[)"(0.0, 1.0) よりも高速に乱数変数を生成できる。 よりも高速に生成される。

Parameters:

UniformRNG rng

(オプション) 使用する乱数生成器; 指定しない場合のデフォルトはrndGen

Returns:

一様分布[0, 1]から引かれたT 型の浮動小数点乱数変量。 である。

Examples:

import std.math.operations : feqrel;

auto rnd = MinstdRand0(42);

// [0, 1] の範囲で乱数を生成する
auto u1 = uniform01(rnd);
assert(u1 >= 0 && u1 < 1);

auto u2 = rnd.uniform01!float;
assert(u2 >= 0 && u2 < 1);

// 初期シード42の乱数値が0.000328707と0.524587であることを確認する
assert(u1.feqrel(0.000328707) > 20);
assert(u2.feqrel(0.524587) > 20);

F[] uniformDistribution(F = double)(size_t n, F[] useThis = null)
if (isFloatingPoint!F);

の一様確率分布を生成する。 nすなわち の配列である。 nF の配列である。 1.もし useThisが与えられた場合、それがストレージとして使われる。

Examples:

import std.algorithm.iteration : reduce;
import std.math.operations : isClose;

auto a = uniformDistribution(5);
writeln(a.length); // 5
assert(isClose(reduce!"a + b"(a), 1));

a = uniformDistribution(10, a);
writeln(a.length); // 10
assert(isClose(reduce!"a + b"(a), 1));

ref auto choice(Range, RandomGen = Random)(Range range, ref RandomGen urng)
if (isRandomAccessRange!Range && hasLength!Range && isUniformRNG!RandomGen);

ref auto choice(Range)(Range range);

ref auto choice(Range, RandomGen = Random)(ref Range range, ref RandomGen urng)
if (isRandomAccessRange!Range && hasLength!Range && isUniformRNG!RandomGen);

ref auto choice(Range)(ref Range range);

e 一様に選ばれたランダムな要素を返す。 Range range.乱数生成器が渡されない場合は、デフォルトの rndGen が使われる。

Parameters:

Range range	length プロパティが定義されているランダムアクセス範囲。
RandomGen urng	(オプション) 使用する乱数生成器; 指定しない場合、デフォルトはrndGen

Returns:

から引かれた単一のランダム要素。 range.もしそれができれば range element にref を返す。 のコピーを返す。

Examples:

auto rnd = MinstdRand0(42);

auto elem  = [1, 2, 3, 4, 5].choice(rnd);
version (D_LP64) // https://issues.dlang.org/show_bug.cgi?id=15147
writeln(elem); // 3

Range randomShuffle(Range, RandomGen)(Range r, ref RandomGen gen)
if (isRandomAccessRange!Range && isUniformRNG!RandomGen);

Range randomShuffle(Range)(Range r)
if (isRandomAccessRange!Range);

の要素をシャッフルする。 rの要素をシャッフルする。 genをシャフラーとして使う。 rの要素をシャッフルする。 でなければならない。 RNGが指定されていない場合はrndGen が使われる。

Parameters:

Range r	要素がシャッフルされるランダムアクセス範囲
RandomGen gen	(オプション) 使用する乱数生成器。 指定されない場合、デフォルトはrndGen

Returns:

シャッフルされたランダムアクセス範囲。

Examples:

auto rnd = MinstdRand0(42);

auto arr = [1, 2, 3, 4, 5].randomShuffle(rnd);
version (D_LP64) // https://issues.dlang.org/show_bug.cgi?id=15147
writeln(arr); // [3, 5, 2, 4, 1]

Range partialShuffle(Range, RandomGen)(Range r, in size_t n, ref RandomGen gen)
if (isRandomAccessRange!Range && isUniformRNG!RandomGen);

Range partialShuffle(Range)(Range r, in size_t n)
if (isRandomAccessRange!Range);

の要素を部分的にシャッフルする。 rの要素を部分的にシャッフルする。r[0 .. n] のランダムな部分集合であり rのランダムな部分集合であり、ランダムに順序付けられる。 r[n .. r.length] にはr[0 .. n] にない要素が含まれる。 にない要素が含まれる。 の後の順序という意味ではランダムではない。 partialShuffleを返す前の順序に依存しないという意味で、ランダムではない。 partialShuffleが呼ばれる前の順序とは無関係になるという意味で、ランダムではない。

rは長さを持つランダムアクセス範囲でなければならない。 n以下でなければならない。 以下でなければならない。 r.length. RNGが指定されていない場合は、rndGen 。

Parameters:

Range r	要素がシャッフルされるランダムアクセス範囲
size_t n	シャッフルする rの要素数 (先頭から数えて); よりも小さくなければならない。 r.length
RandomGen gen	(オプション) 使用する乱数生成器。 よりも小さくなければならない。rndGen

Returns:

シャッフルされたランダムアクセス範囲。

Examples:

auto rnd = MinstdRand0(42);

auto arr = [1, 2, 3, 4, 5, 6];
arr = arr.dup.partialShuffle(1, rnd);

version (D_LP64) // https://issues.dlang.org/show_bug.cgi?id=15147
assert(arr == [2, 1, 3, 4, 5, 6]); // 1<->2

arr = arr.dup.partialShuffle(2, rnd);
version (D_LP64) // https://issues.dlang.org/show_bug.cgi?id=15147
assert(arr == [1, 4, 3, 2, 5, 6]); // 1<->2, 2<->4

arr = arr.dup.partialShuffle(3, rnd);
version (D_LP64) // https://issues.dlang.org/show_bug.cgi?id=15147
assert(arr == [5, 4, 6, 2, 1, 3]); // 1<->5, 2<->4, 3<->6

size_t dice(Rng, Num)(ref Rng rnd, Num[] proportions...)
if (isNumeric!Num && isForwardRange!Rng);

size_t dice(R, Range)(ref R rnd, Range proportions)
if (isForwardRange!Range && isNumeric!(ElementType!Range) && !isArray!Range);

size_t dice(Range)(Range proportions)
if (isForwardRange!Range && isNumeric!(ElementType!Range) && !isArray!Range);

size_t dice(Num)(Num[] proportions...)
if (isNumeric!Num);

各インデックスに対応する重みのリストにランダムなインデックスを取得する。

に格納された相対確率でダイスを振るのと似ている。 proportions. のインデックスを返す。 proportionsのインデックスを返す。

注釈 通常、サイコロは「公平」である。 である。その場合、1 + uniform(0, 6) を単純に使うことができる。 将来のバージョンでは、この関数は混乱を避けるために次のような名前に変更されるかもしれない。 weightedChoice などに改名されるかもしれない。

Parameters:

Rng rnd	(オプション) 使用する乱数生成器。 指定されない場合、デフォルトはrndGen
Num[] proportions	をデフォルトとする。 その要素は確率に対応する に対応する。 値

Returns:

インデックス値から無作為に変量を引く [0, ... proportions.length - 1]から選ばれたランダム変量である。 i の確率に比例する。 proportions[i].

Examples:

auto d6  = 1 + dice(1, 1, 1, 1, 1, 1); // 公平なサイコロの目
auto d6b = 1 + dice(2, 1, 1, 1, 1, 1); // '1'がでる確率が2倍になる

auto x = dice(0.5, 0.5);   // xは同じ割合で0か1である
auto y = dice(50, 50);     // yは同じ割合で0か1である
auto z = dice(70, 20, 10); // zは70％の確率で0、20％の確率で1、
                           // 10％の確率で2である

Examples:

auto rnd = MinstdRand0(42);
auto z = rnd.dice(70, 20, 10);
writeln(z); // 0
z = rnd.dice(30, 20, 40, 10);
writeln(z); // 2

struct RandomCover(Range, UniformRNG = void) if (isRandomAccessRange!Range && (isUniformRNG!UniformRNG || is(UniformRNG == void)));

auto randomCover(Range, UniformRNG)(Range r, auto ref UniformRNG rng)
if (isRandomAccessRange!Range && isUniformRNG!UniformRNG);

auto randomCover(Range)(Range r)
if (isRandomAccessRange!Range);

与えられた範囲をカバーする rをランダムにカバーする。 の各要素を無作為に通過する。 rの各要素を一度だけ、ランダムな順序で通過する。 r はランダムアクセス可能な長さの範囲でなければならない。

乱数発生器が randomCoverに乱数発生器が渡されなければ スレッドグローバルRNG rndGenが内部的に使用される。

Parameters:

Range r	ランダムアクセス範囲
UniformRNG rng	(オプション) 使用する乱数生成器; 指定がない場合のデフォルトはrndGen

Returns:

の要素で構成される範囲。 r, の要素をランダムな順序で持つ。 と rと rngがともに前方範囲であれば前方範囲となり、そうでなければ 入力範囲となる。

Examples:

import std.algorithm.comparison : equal;
import std.range : iota;
auto rnd = MinstdRand0(42);

version (D_LP64) // https://issues.dlang.org/show_bug.cgi?id=15147
assert(10.iota.randomCover(rnd).equal([7, 4, 2, 0, 1, 6, 8, 3, 9, 5]));

struct RandomSample(Range, UniformRNG = void) if (isInputRange!Range && (isUniformRNG!UniformRNG || is(UniformRNG == void)));

auto randomSample(Range)(Range r, size_t n, size_t total)
if (isInputRange!Range);

auto randomSample(Range)(Range r, size_t n)
if (isInputRange!Range && hasLength!Range);

auto randomSample(Range, UniformRNG)(Range r, size_t n, size_t total, auto ref UniformRNG rng)
if (isInputRange!Range && isUniformRNG!UniformRNG);

auto randomSample(Range, UniformRNG)(Range r, size_t n, auto ref UniformRNG rng)
if (isInputRange!Range && hasLength!Range && isUniformRNG!UniformRNG);

から無作為な部分標本を選択する。 rの中から無作為な部分標本を選ぶ。 n 要素を含む。要素の順序は、元の の範囲と同じである。の全長は既知でなければならない。 rの全長は既知でなければならない。もし totalが が渡された場合、サンプルの総数はtotal とみなされる。そうでない場合は RandomSampleが使われる。 r.length.

Parameters:

Range r	サンプルの範囲
size_t n	サンプルに含める要素の数; の要素の総数以下でなければならない。 でなければならない。 rパラメータ total(提供されている場合)
size_t total	(半オプション)の要素数以下でなければならない。 r の要素数(先頭から数えて 以下でなければならない。 の要素の総数以下でなければならない。 rの要素の総数以下でなければならない。 以下の場合は省略できる。 rが.length プロパティを持ち、サンプルが のすべての要素から抽出される r.
UniformRNG rng	(オプション) 使用する乱数生成器; 指定しない場合、デフォルトはrndGen

Returns:

の要素から無作為に選択された部分集合で構成される範囲。 の要素の部分集合で構成される。 rの要素からランダムに選ばれた部分集合で構成される。 の要素の無作為に選択された部分集合で構成される rに現れるのと同じ順番である。 の両方が揃えば前方範囲となる。 r と rngが前方範囲であれば前方範囲となり、そうでなければ入力範囲となる。

RandomSampleはJeffrey Scott VitterのアルゴリズムDを実装している。 (Vitter1984,1987参照)を実装している。 を選択する。 nO(n)ステップで、O(n)個のランダム変量が必要である、 を実装している。 例外は この例外は、入力範囲上のk個の要素を走査すること自体がO(k)演算である場合である。 O(k)演算である場合である(入力ファイルから行をサンプリングする場合など)、 この場合、サンプリング計算は必然的に O(total)となる。

RandomSampleは例外をスローする。 totalが が入力で利用可能な要素の総数より少ない場合は例外がスローされる、 またはn > total.

に乱数生成器が渡されない場合、乱数生成器は randomSampleに乱数発生器が渡されない場合は スレッドグローバルRNG rndGenが内部的に使用される。

Examples:

import std.algorithm.comparison : equal;
import std.range : iota;
auto rnd = MinstdRand0(42);
assert(10.iota.randomSample(3, rnd).equal([7, 8, 9]));

const @property bool empty();

@property ref auto front();

void popFront();

const @property typeof(this) save();

const @property size_t length();

範囲プリミティブ。

@property size_t index();

訪問したレコードのインデックスを返す。