add extensibility feature for longer periods?

[listx]

I noticed that the CPP version (line 1617 in pcg_random.hpp) of this library has extended generation schemes allowing arbitrary periods (section 7.1 in the paper). Could we add this to this C version as well?

[imneme]

You can get almost the same effect by just ganging together several generators (with distinct streams) as shown in the example code.

But, if someone wants to port the extended generation scheme from C++ to C (probably better to start from scratch than try to remove the C++-isms in the code), I'd certainly be open to merging their changes.

[Andersama]

Well 12 years on is probably a bit late to contribute something but I came up with this approach after I wanted to extend pcg's but didn't want to massively increase the code size.

I nicked named this the layered pcg, bad name, it's not exactly very layered and this implementation's not ideal, but the concept is this. Use one pcg's state to seed an arbitrary number of other pcgs, then by keeping track of how many were initialized and a call count, step / iterate through that array of pcgs to generate random numbers. All the properties of the PCG are retained because all of the generated pcg's will eventually cycle through their entire output, multiplying the period by the number of seeded pcgs. The call count then behaves similarly to an increment / selected stream.

#pragma once
#include <cstdint>
// *Really* minimal PCG32 code / (c) 2014 M.E. O'Neill / pcg-random.org
// Licensed under Apache License 2.0 (NO WARRANTY, etc. see website)

typedef struct { uint64_t state;  uint64_t inc; } pcg32_random_t;

uint32_t pcg32_random_r(pcg32_random_t* rng)
{
    uint64_t oldstate = rng->state;
    // Advance internal state
    rng->state = oldstate * 6364136223846793005ULL + (rng->inc | 1);
    // Calculate output function (XSH RR), uses old state for max ILP
    uint32_t xorshifted = ((oldstate >> 18u) ^ oldstate) >> 27u;
    uint32_t rot = oldstate >> 59u;
    return (xorshifted >> rot) | (xorshifted << ((-rot) & 31));
}

typedef struct {
    pcg32_random_t rng; uint32_t call_count; uint32_t block_count;
} lpcg_random_t;

void pcg32_random_fill(pcg32_random_t* rng, uint32_t* start, uint32_t* end) {
    for (; start < end; ++start) {
        *start = pcg32_random_r(rng);
    }
}

// Uses rng to seed values into an arbitrarily sized pcg32_random_t[rng_block_count]
void lpcg32_random_init(lpcg_random_t* rng, pcg32_random_t* rng_block, uint32_t rng_block_count) {
    if (rng->block_count != rng_block_count) {
        pcg32_random_t* end = rng_block + rng_block_count;
        uint32_t* rngs = (uint32_t*)rng_block;
        uint32_t* rngs_end = (uint32_t*)end;
        pcg32_random_fill(&(rng->rng), rngs, rngs_end);
    }
    rng->block_count = rng_block_count;
}

uint32_t lpcg32_random_r(lpcg_random_t* rng, pcg32_random_t* rng_block)
{
    uint32_t c = rng->call_count;
    rng->call_count = (rng->call_count + 1) % rng->block_count;
    uint32_t r = pcg32_random_r(rng_block + c);
    return r;
}

// Picks a pcg32_random_t from an array and uses that to generate a value
uint32_t lpcg32_random(lpcg_random_t* rng, pcg32_random_t* rng_block, uint32_t rng_block_count)
{
    if (rng->block_count != rng_block_count)
        lpcg32_random_init(rng, rng_block, rng_block_count);

    return lpcg32_random_r(rng, rng_block);
}

The idea is this, because the pcg can be arbitrarily jumped forward in it's stream, this mess can be written using only the original struct's state*, we don't need the extra memory...the extra memory's just to make the thing faster, if we've got enough for it. This is because the result of the 256 bits is entirely predictable based off of two arbitrary advances, one to determine which "PCG" was used, and the other to jump to that pcg's would be state.