C++: Get state of linear congruential generator

Question

It seems that if I write

#include <random>
std::minstd_rand engine(1);

std::cout << engine;

then this prints out the internal state of the engine (which is a linear congruential generator). Right now the state equals the seed (1), but if I call a random number and print out engine, it returns some large number, which is probably the state.

How do I actually get the state, in a variable?

Answer 1

Use a string stream instead of stdout. Example:

#include <sstream> ... std::ostringstream os; os << engine; string mystate = os.str();

The o in ostringstream is for output.

The state should be last random number generated, which is why there is not an easier way to do this. It's not as ideal as something like int a; a << engine, but it'll have to do. If you need it that often, make the stringstream operation a function (Including perhaps a conversion from string to integer). You can also typedef a pair of engine/integer with the integer being the state, and make a couple of methods so it's autoset every generation call if you need the performance.

If you don't care about the state, and just want it for the future, do

int engineState = engine();

Now you have the state. Though it's not the same as what it was before, it might not matter depending on your use case.

Answer 2

Output from linear congruential RNG is the state. Or, as alreadynoted, use operator<< to output and convert state

Code

#include <random>
#include <iostream>
#include <sstream>

int main() {
    auto engine = std::minstd_rand{ 1 };

    auto q = engine();

    auto os = std::ostringstream{};

    os << engine;
    auto r = std::stoul(os.str()); // use ul to fit output

    std::cout << q << "   " << os.str() << "   " << r << '\n';

    return 0;
}

prints

48271   48271   48271

Alternative might be if particular implementation implements discard properly in O(log₂(N)) time, according to paper by F.Brown https://laws.lanl.gov/vhosts/mcnp.lanl.gov/pdf_files/anl-rn-arb-stride.pdf. In such case you could move one position back, call RNG again and get your state as output.

Compiler and library I use - Visual C++ 2017 15.7 - has not implemented discard in such way, and useless for moving back.

Answer 3

LCGs consist of a simple state that is represented by a single integer.
This means you can treat this pointer as a pointer to an integer.
Below, I have provided an example of a template function that gets
the state (seed) of an engine and even works for classes deriving LCGs.

#include <random>
template <class T, T... v>
T getSeed(std::linear_congruential_engine<T, v...>& rand) {
    static_assert(sizeof(rand) == sizeof(T));
    return *reinterpret_cast<T*>(&rand);
}

#include <iostream>
int main() {
    std::minstd_rand engine(19937);
    auto seed = getSeed(engine);
    std::cout << sizeof(engine); 
    std::cout << '\t' << seed;
}

^ This method is way more efficient (x320 times) than serializing through a stream,
or by creating a dummy ostream and specializing std::operator<< for every case.

template<class T, T... v>
using LCG = std::linear_congruential_engine<T, v...>;
#define DummyRandSpec32 uint_fast32_t, 0xDEADBEEF, 0xCAFE, 0xFFFFFFFF
typedef LCG<DummyRandSpec32> DummyRand32; // the same engine type

template<class T, class R>
T* getSeed(R& rand) // getSeed 70:1 nextInt
{   // creating stream is heavy operation
    // return rand._M_x; // cannot access private
    __dummy_ostream<T> dumdum; // workaround
    auto& didey = *reinterpret_cast<DummyRand32*>(&rand);
    std::operator<<(dumdum, didey); // specialized
    return dumdum.retrieve(); // pointer to state
}

int main() {
    std::minstd_rand engine(19937);
    std::cout << *getSeed<uint_fast32_t>(engine); 
    std::cout << std::endl << engine << std::endl;
}

^ Here is ill-coded my first attempt at a solution, if you want to compare.
It is worth mentioning that a field name of the state is implementation-specific.
Purposefully left out std::operator<< and __dummy_ostream.