Namespaces
Variants

std::subtract_with_carry_engine<UIntType,w,s,r>:: subtract_with_carry_engine

From cppreference.net
C++
Numerics library
Pseudo-random number generation
Random number distributions
Uniform distributions
(C++11)
(C++11)
(C++11)
Bernoulli distributions
(C++11)
(C++11)
(C++11)
(C++11)
Poisson distributions
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Normal distributions
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Sampling distributions
(C++11)
(C++11)
(C++11)
std::subtract_with_carry_engine
Member functions
subtract_with_carry_engine::subtract_with_carry_engine
Generation
Characteristics
Non-member functions
(C++11) (C++11) (until C++20)
(C++11) (C++11)
subtract_with_carry_engine ( ) : subtract_with_carry_engine ( 0u ) { }
(1) (seit C++11)
explicit subtract_with_carry_engine ( result_type value ) ;
(2) (seit C++11)
template < class SeedSeq >
explicit subtract_with_carry_engine ( SeedSeq & seq ) ;
(3) (seit C++11)
subtract_with_carry_engine ( const subtract_with_carry_engine & other ) ;
(4) (seit C++11)
(implizit deklariert)

Konstruiert die Pseudo-Zufallszahlen-Engine.

1) Der Standardkonstruktor.
  • Wenn die standardmäßig konstruierte Engine vom Typ std::ranlux24_base ist, erzeugt der 10000. aufeinanderfolgende Aufruf davon den Wert 7937952 .
  • Wenn die standardmäßig konstruierte Engine vom Typ std::ranlux48_base ist, erzeugt der 10000. aufeinanderfolgende Aufruf davon den Wert 61839128582725 .
2) Konstruiert die Engine mit einem Seed-Wert value . Die Sequenz X des initialen Zustands der Engine wird wie folgt bestimmt:
  1. Konstruiert ein std:: linear_congruential_engine < std:: uint_least32_t , 40014u, 0u, 2147483563u > Objekt e mit dem Argument value == 0u ? default_seed : static_cast < std:: uint_least32_t > ( value % 2147483563u ) .
  2. Sei n gleich std:: size_t ( w / 32 ) + 1 .
  3. Setzt die Werte von X -r , ..., X -1 in dieser Reihenfolge. Jeder Wert X i wird wie folgt gesetzt:
  1. Ruft e sukzessive n Mal auf, die Rückgabewerte werden als z 0 ... z n-1 bezeichnet.
  2. Setzt X i auf (∑ n-1
    j=0     z j ·2 32j
    ) mod m     .
Falls X -1 gleich ​ 0 ​ ist, setzt den Carry-Wert c des Anfangszustands der Engine auf 1 . Andernfalls wird c auf ​ 0 ​ gesetzt.
3) Konstruiert die Engine mit einer Seed-Sequenz seq . Mit std:: size_t ( w / 32 ) + 1 als k wird die Sequenz X des initialen Zustands der Engine wie folgt bestimmt:
  1. Erzeugt ein virtuelles Array-Objekt a der Länge r * k .
  2. Ruft seq. generate ( a + 0 , a + r * k ) auf.
  3. Setzt für jede ganze Zahl i in [ - r , - 1 ] den Wert X i auf (∑ k-1
    j=0     a k(i+r)+j ·2 32j
    ) mod m     .
Falls X -1 gleich ​ 0 ​ ist, setzt den Carry-Wert c des Anfangszustands der Engine auf 1 . Andernfalls wird c auf ​ 0 ​ gesetzt.
Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn SeedSeq die Anforderungen von SeedSequence erfüllt.
4) Der Kopierkonstruktor. Bei der Konstruktion gilt, * this == other ist true .

Inhaltsverzeichnis

Parameter

value - Startwert für die Initialisierung des internen Zustands
seq - Startsequenz für die Initialisierung des internen Zustands

Komplexität

1,2) ( std:: size_t ( w / 32 ) + 1 ) * r Aufrufe von e .
3) Gleich wie die Komplexität des seq.generate Aufrufs.
4) O(r) .

Ausnahmen

3) Wenn SeedSeq nicht std::seed_seq ist, werden die Ausnahmen ausgelöst, die durch den seq.generate -Aufruf geworfen werden.

Beispiel

Dieser Abschnitt ist unvollständig
Grund: Demos für Überladungen (2-4) benötigt

Diesen Code ausführen 
#include <cassert>
#include <random>
int main()
{
    std::ranlux24_base gen24; // overload (1)
    std::ranlux48_base gen48; // overload (1)
    gen24.discard(10000 - 1);
    gen48.discard(10000 - 1);
    assert(gen24() == 7'937'952);
    assert(gen48() == 61'839'128'582'725);
}

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
LWG 2181 C++11 Überladung ( 3 ) würde nicht werfen, selbst wenn der seq.generate Aufruf wirft leitet die Exception weiter
LWG 3809 C++11 e konnte nicht konstruiert werden, wenn result_type std::uint16_t ist kann in diesem Fall konstruiert werden
LWG 4014 C++11 die Lösung von LWG Issue 3809 verursachte, dass der Initialseed
der intermediären std::linear_congruential_engine
einen anderen Typ als den result_type der Engine hatte 		schneidet ab und
konvertiert value
P0935R0 C++11 der Standardkonstruktor war explizit implizit gemacht

Siehe auch

setzt den aktuellen Zustand der Engine
(öffentliche Elementfunktion)