Hello everyone,

I'm currently working on a generative piece of music in Pd and have a lovely array of MIDI notes. I find that every time I open the patch, I get the exact series of pitches, despite the patch's supposed "randomness." I do recall reading something about this way back when, but can't seem to find the specifics. My questions are:

1. How does one set a new random seed?
2. Is there a way to save a random seed? (I find that at times, when I edit the patch, it alters the random seed and I get different results. I want to be able to improve the patch while retaining the same pre-assigned note sequence.)
3. Where can I learn more about the way random seed is utilized in Pd?

Apologies if I'm asking a question that's already been asked. I searched the forums but couldn't quite find the answer I am looking. Thank you for your time!

@Maks often the suggested way to get a random seed is to use the [date] and [time] objects from zexy.
you can send a [seed $1( message to the [random] objects (see the help file). By default a single global seed is used, and incremented for every [random] object loaded. That means that the sequence of any given [random] will change depending on the load order of the individual objects. (which depends on their creation order within the patch as well as how many [random] objects have already been loaded in the pd session when other patches were loaded)
as for #3, do you mean "utilized" or "implemented"? if it's the former, I would just look at a lot of generative patches and libraries. If the latter, I would look at the x_misc.c file in the pure data source code, and read about using multiplying and adding primes & modulo arithmetic as a way to generate random distributions if you want to get into the details.

@Maks https://en.wikipedia.org/wiki/Linear_congruential_generator

@seb-harmonik.ar Thanks for the response! Just so I'm understanding – each time a [random]
object is added to the patch, it modifies the seed? Is there a way to pull that number out or "save" it in a text document or something of the sort?

As for #3, I just meant any Pd-specific documentation for random seed. Thanks for the Wikipedia article – I think it's WAAYY over my head though. I'll still take a peek though. Thanks!

@Maks not just added to a patch, but loaded into the pd session. So that means every time you load a [random]: every time you create a new [random], or open another patch that has [random]s that load, or close and re-open the patch. Every time a [random] object is instantiated it will increment the global seed within the pd session (until you quit and re-open pd).

due to limitations of precision I don't think it's possible to get the global seed of an object, unfortunately. If we could represent 64-bit doubles you might be able to take the 1st value output, divide it by the range, and then multiply by 2^32 in order to get the 32-bit int it was seeded with. But even then there might be some round-off error, I'm not sure.
edit: actually since bangs increment the prng, you'd need to find the Modular multiplicative inverse too I think..
edit2: I also forgot other issues with this: [random] can only output integers, and pd can only represent significand up to 24 bits, and it can't store multiple digits easily.

I think the easiest/most consistent way to do what you want would be to have some method for generating some 24-bit seed, like with some manipulated [date] and/or [time] values from zexy. Then add some fixed value to that seed for each [random] object, and send it to that object using the [seed( message. If you like the sequence a specific seed generates, save that number in a text file or message box. Then whenever you want to replicate the patch's sequences you just have to send that number through the same network of additions before running the patch.

@Maks As @seb-harmonik.ar says, you can force [random] to a set series with a [seed( message.
So although each instance of [random] will be assigned a new seed value dependant on the order in which they are created you can change that.
I don't think you are likely to be able to recover the original seed that you liked, but if you can you will be able to fix it.
seeds.pd
Open the patch as many times as you like....... all the series will be identical....... proof that you can fix the [random] series no matter how many [random] objects you have created or the order of their creation.
David.

But looking in random.c this.....

static int makeseed(void)
{
    static unsigned int random_nextseed = 1489853723;
    random_nextseed = random_nextseed * 435898247 + 938284287;
    return (random_nextseed & 0x7fffffff);
}

So maybe your original global seed is recoverable ????

@whale-av no, unfortunately the precision of pd/the prng doesn't permit it within pd. See the above reasons
the modular multiplicative inverse alone would take a bit of thought, but the fact that pd can only represent a 24 bit significand is also an issue.

@Maks Then your only hope is to re-generate the series and store it as a list in a text file to be played back in your sequencer with bangs in the same manner as [random].
This might help........... Nth seed.zip
Don't save [generate] and restart Pd completely before opening [Nth_seed] with your saved settings.
It doesn't yet save the text file but that will be a simple add-on....... and either don't run it again once you have the series or write protect the text file.
[initbang] is available again on Deken (Find Externals)
David.

@whale-av Thank you SO much for including this and helping me to answer my questions. I think this should certainly be useful for my project. Thank you!

re: getting seed into vanilla (linux): I have the following in my pd-start-wrapper

-send "seed `date +%N | cut -c -3` "

this seeds random in a patch:

[ r seed ]
|
[ seed $1 (
|
[ random ]

@Maks The easiest way to later recreate the series produced by [random] is to always use random with a seed and to store that seed within a message or a [text] object. To recreate the series just use the same seed again.