Movatterモバイル変換


[0]ホーム

URL:


cppreference.com
Namespaces
Variants
    Actions

      std::philox_engine

      From cppreference.com
      <cpp‎ |numeric‎ |random
       
       
       
      Pseudo-random number generation
       
       
      Defined in header<random>
      template<

         class UIntType,std::size_t w,std::size_t n,std::size_t r,
          UIntType...consts
      >

      class philox_engine;
      (since C++26)

      std::philox_engine is a counter-based random number engine.

      Contents

      [edit]Template parameters

      UIntType - The result type generated by the generator. The effect is undefined if this is not one ofunsignedshort,unsignedint,unsignedlong, orunsignedlonglong.
      w - the word size in bits
      n - the word count
      r - the round count
      consts - the sequence of multipliers and round constants used for generating random numbers

      If any of the following values is nottrue, the program is ill-formed:

      [edit]Generator properties

      In the following description, let\(\scriptsize Q_i \)Qi denote theith element of sequenceQ, where the subscript starts from zero.

      Thesize of the states ofphilox_engine is\(\scriptsize O(n)\)O(n), each of them consists of four parts:

      • A sequenceX ofn integer values, where each value is in[02w
        )
        .
      • This sequence represents a large unsigned integer counter value\(\scriptsize Z=\sum_{j=0}^{n-1} X \cdot 2^{wj} \)Z=∑n-1
        j=0
        X⋅2wj
        of\(\scriptsize n \cdot w \)n⋅w bits.
      • A sequenceK ofn/2 keys of typeUIntType.
      • A bufferY ofn produced values of typeUIntType.
      • An indexj inY buffer.

      Thetransition algorithm ofphilox_engine (\(\scriptsize TA(X_i) \)TA(Xi)) is defined as follows:

      • Ifj is notn-1, incrementsj by1.[1]
      • Ifj isn-1, performs the following operations:[2]
      1. Generates a new sequence ofn random values (see below) and stores them inY.
      2. Increments the counterZ by1.
      3. Resetsj to0.

      Thegeneration algorithm ofphilox_engine is\(\scriptsize GA(X_i)=Y_j \)GA(Xi)=Yj.

      1. In this case, the next generation algorithm call returns the next generated value in the buffer.
      2. In this case, the buffer is refreshed, and the next generation algorithm call returns the first value in the new buffer.

      [edit]Generating random values

      Random values are generated from the following parameters:

      • the number of roundsr
      • the current counter sequenceX
      • the key sequenceK
      • the multiplier sequenceM
      • the round constant sequenceC

      The sequencesM andC are formed from the values from template parameter packconsts, which represents the\(\scriptsize M_k \)Mk and\(\scriptsize C_k \)Ck constants as[\(\scriptsize M_0 \)M0, \(\scriptsize C_0 \)C0, \(\scriptsize M_1 \)M1, \(\scriptsize C_1 \)C1,... , ..., \(\scriptsize M_{n/2-1} \)Mn/2-1, \(\scriptsize C_{n/2-1} \)Cn/2-1].

      Random numbers are generated by the following process:

      1. Initializes the output sequenceS with the elements ofX.
      2. Updates the elements ofS forr rounds.
      3. Replaces the values in the bufferY with the values inS.

      [edit]Updating the output sequence

      For each round of update, an intermediate sequenceV is initialized with the elements ofS in a specified order:

       n  \(\scriptsize V_{0} \)V0  \(\scriptsize V_{1} \)V1  \(\scriptsize V_{2} \)V2  \(\scriptsize V_{3} \)V3 
      2\(\scriptsize S_0 \)S0\(\scriptsize S_1 \)S1N/A
      4\(\scriptsize S_2 \)S2\(\scriptsize S_1 \)S1\(\scriptsize S_0 \)S0\(\scriptsize S_3 \)S3

      Given the following operation notations:

      • \(\scriptsize \mathsf{xor} \)xor, built-inbitwise XOR.
      • \(\scriptsize \mathsf{mullo} \)mullo, it calcuates the low half of modular multiplication and is defined as\(\scriptsize \mathsf{mullo}(a,b,w)=(a \cdot b) \mod 2^w \)mullo(a,b,w)=(a⋅b) mod 2w
        .
      • \(\scriptsize \mathsf{mulhi} \)mulhi, it calcuates the high half of multiplication and is defined as\(\scriptsize \mathsf{mulhi}(a,b,w)=\left\lfloor (a \cdot b)/2^w \right\rfloor \)mulhi(a,b,w)=⌊(a⋅b)/2w
        .

      Letq be the current round number (starting from zero), for each integerk in[0n/2), the elements of the output sequenceS are updated as follows:

      • \(\scriptsize X_{2 \cdot k}=\mathsf{mulhi}(V_{2 \cdot k},M_k,w)\ \mathsf{xor}\ ((K_k+q \cdot C_k) \mod 2^w)\ \mathsf{xor}\ V_{2 \cdot k+1} \)X2⋅k=mulhi(V2⋅k,Mk,w) xor ((Kk+q⋅Ck) mod 2w
        ) xor V2⋅k+1
      • \(\scriptsize X_{2 \cdot k+1}=\mathsf{mullo}(V_{2 \cdot k},M_k,w) \)X2⋅k+1=mullo(V2⋅k,Mk,w)

      [edit]Predefined specializations

      The following specializations define the random number engine with two commonly used parameter sets:

      Defined in header<random>
      Type Definition
      philox4x32(C++26)std::philox_engine<std::uint_fast32_t,32,4,10,
                         0xCD9E8D57,0x9E3779B9,
                         0xD2511F53,0xBB67AE85>[edit]
      philox4x64(C++26)std::philox_engine<std::uint_fast64_t,64,4,10,
                         0xCA5A826395121157,0x9E3779B97F4A7C15,
                         0xD2E7470EE14C6C93,0xBB67AE8584CAA73B>[edit]

      [edit]Nested types

      Type Definition
      result_typeUIntType

      [edit]Data members

      constexprstd::size_t word_size
      [static]
      w
      (public static member constant)
      constexprstd::size_t word_count
      [static]
      n
      (public static member constant)
      constexprstd::size_t round_count
      [static]
      r
      (public static member constant)
      constexprstd::array<result_type, word_count/2> multipliers
      [static]
      themultiplier sequenceM
      (public static member constant)
      constexprstd::array<result_type, word_count/2> round_consts
      [static]
      theround constant sequenceC
      (public static member constant)
      constexprstd::uint_least32_t default_seed
      [static]
      20111115u
      (public static member constant)

      [edit]Member functions

      Construction and Seeding
      constructs the engine
      (public member function)[edit]
      sets the current state of the engine
      (public member function)[edit]
      sets the current counter of the engine
      (public member function)[edit]
      Generation
      advances the engine's state and returns the generated value
      (public member function)[edit]
      advances the engine's state by a specified amount
      (public member function)[edit]
      Characteristics
      [static]
      gets the smallest possible value in the output range
      (public static member function)[edit]
      [static]
      gets the largest possible value in the output range
      (public static member function)[edit]

      [edit]Non-member functions

      (C++26)
      compares the internal states of two pseudo-random number engines
      (function)[edit]
      performs stream input and output on pseudo-random number engine
      (function template)[edit]

      [edit]Notes

      Feature-test macroValueStdFeature
      __cpp_lib_philox_engine202406L(C++26)std::philox_engine

      [edit]Example

      This section is incomplete
      Reason: no example
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/numeric/random/philox_engine&oldid=180391"

      [8]ページ先頭

      ©2009-2025 Movatter.jp