It is a circuit that can produce a pseudo-random sequence with a period of 2^n numbers, where n is the numbers of registers. The general and low resource approach to produce a pseudo-random sequence in hardware is to use Fibonacci or Galois linear-feedback shift register (LFSR) but the period of the generated ... More on forum.allaboutcircuits.com

For another project I was working on I needed a free-running random number generator. Maybe others might find it useful. Image !blueprint: https://pastebin.com/sTsVp7iU The main PRNG is marked by green in the above image, with the output block in white. The output block comes configured to output positive values, but can be changed (to X+0) to output negatives too. (The output block could actually be removed in that case. Make sure to use a green wire to connect if you do that.) The PRNG needs to be seeded with some initial values and that is what the block in red accomplishes it. Change the A,B,C,D,E and F values in the constant combinator to something random. Then turn the constant combinator to On to start the PRNG running. The seeder block can be deleted after this. As an alternative to using new seed values every time, you can also use a source of entropy to cause the random sequence to diverge over time. The block marked in orange serves this purpose. Connect some intermittently varying signal (a good example would be a rail signal) to the block and configure the comparison operation appropriately. Do not change the output settings. This block is purely optional, remove it if you don't need the functionality. --- The above is (loosely) based on the Xorshift class of PRNG. I used the simplest variant because I didn't see any need to be paranoid about the quality of the random numbers. (One thing to note, this RNG cannot generate a value of exactly 0, if that is important to you.) If you want to play around with it, here is my development version: Image !blueprint: https://pastebin.com/yUhrXjDQ On the right is the version based on the original algorithm. The plus blocks are (X+0), and serve as delay blocks the so the xor uses the same input value as the preceding shift. This is needed because inputs and outputs of combinators are processed once per update. Without the delay, we would not be xoring the original value with it's shifted value, as the algorithm requires. As a consequence of the timing, we are actually running 6 PRNGs in parallel, pipelined (it takes six updates for the input to cycle through all blocks and loop back around). This is why the seeder needs 6 seed values and a timer to feed them in sequence. That said, I optimized the process by removing those delays. Even though this violates the original algorithm, I don't believe it should affect the result significantly. Basically, the 6 parallel RNGs are now being mixed together rather than being entirely separate. As they mix together their results should maintain their desirable random properties. My (limited) tests bear this out. For testing, I took the two most common cases I expect this will be used. Bernoulli random variables can be most easily generated with just a comparison against a constant. I tested this and checked that the mean matched the expected value. The other common case I see is needing discrete uniform values, most easily implemented using a modulus operation (with possibly an offset via constant combinator). I tested this as well, counting the output values and verifying the distribution appeared uniform. The point where the entropy injector connects was also selected based on the above. Bernoulli random variables generated in that way use the high-order bits, while the above discrete uniform uses low-order bits. As such, I elected to insert into the middle-order bits so that it would take some time to mix into the more important parts of the output. Side note: If anyone is wondering about the pattern of concrete and hazard concrete, I use this when designing dynamic circuits, where the timing is important. Each strip of hazard concrete marks an update. Except for loops, connections only move sideways or upwards. Loops are marked by power poles so they are always obvious (except for well known single block loopbacks like counters, SR latches, etc). Organizing this way helps me keep straight when exactly operations happen so that I can keep outputs synchronized where needed. --- Edit 2020/12/22: It appears pastebin has deleted the original links, so I will post the full blueprint string below for posterity. XORShift PseudoRNG: 0eNrtmltvmzAUx7+LX0cnfAMSbZN63ds29anVNEU0cTdLCUTGVKuqfPfZIUtIwsWHkcvDXloF7GN8fudvDsd+Q0/TXMyVTDQaviE5TpMMDb+/oUz+TOKpvaZf5wIN0YtUOjdXPJTEM3uhaHHxDS08JJOJ+I2GeOEBet6XehJQzy+lnhTU83OpJ1v88JBItNRSFJNe/ngdJfnsSSgznXXvWEn9aya0HF+M09mTTGKdKmN8nmamd5rYkY3FC+KhV/OPvedmGONLrdLp6En8il+kaW8abQyNzO3JsnNmbzxLlemR8zwe7DwyYW1YQ5mOLUCCWcgiGrDQQ+lcqLh4NnT55cZYSHM9z2FjLIppJGK8flBs//xUQiRll8mJGd20lWqcS138XPyw/fe8SsBepe954VfDGk2kKp6mGPBIPnbu9Gg7lX3/8PW+X98rMdn1PN32PLaBXYmI7iPyEKmxyl2t4r2GleBpd/BkG3xwCnFhvg32w4cOXB9BXMmuY72t26yWpos+6zAxMCZ8ekznrc/AVUkBRJ/UjSfvzvN0621JdvTUsiM7sgubVYkxTJahG8YAitE/q8VzJyP59OngFFkzphBGqcVa5Jb7hJ0h/k99/jFJ4ZClNXDTZLR+9okYy4lQjSyB2czK5A7IjaR82202j9VyNLMwdlOUtTJ/NaPkiR49q3Q2komxgYbP8TQTFSTqNRK4iWAAfiGxpd/8g39VXVauXf52VL87eExjfz/86mN1t3Wd2207aP59JL9fnYffB7AXezOWQXMSUZUlVFLrWoQ4PLXrc1XLjqfJv6nJa37fNA9WixVeBcFHwnpzJlhxi6dpy/0I8sLfl2PzaLVcwUUO/0hYb88Ea0tNAzOQWls+1TBzxAYuehxLjXdngo2CsLiqhYMS6FUeSGqdXp0yAz3uFznx+st1J83+2MHXlw1ptla5AJXZcQBC4ZiU4wCGgp4ABekBxVWvKNqygRCEircsZqEjyhCGkpwAJe0B5fVhVdWcTkBV156cVKKEVRhWOeJxUbIeUN70irKtQNvynUcIKHMMW1AT2NPUhsIAFAr+CSKB9xAJt71GQtRCGlZoiZpJE8dCDPFBJE+h6aAHkne9khyASDlqimyKK3/n7pL1sBoSz3KqhQKen1nlhrl1+wVn3A8p57zjkZqrLWM0ijDDdjnrdMrmumQsYngwICzqeOzmpmQqCCgPOQui0kEciK3b8hwjGuBoENrvt5UxDjJ2VzIWBpwx82Ab5wcgW0XgbuzhDcQQZMivNhLZvQ2ZjWw4FsV5yOEcx91/QoAZx2pTgzntT/WyVpX8XLcX0mV30e9zvSIthQmC2w5rEHg+ulgGiBYzM6nNsT4PvZhFqdhpikKCjWR8yhaLP74Tps0= (Unfortunately, the development version is too long to post here.) More on reddit.com