Random-Number-Generator | simple random number generator for Android | DevOps library

Add the seed before the loop:

The Godot developers are warning you that they might decide to change RandomNumberGenerator for a future version (also and some changes happened already).

And no, you can't insert a custom random number generator for OpenSimplexNoise.

Anyway, OpenSimplexNoise does not use RandomNumberGenerator or rand. Instead it takes this library as a git module: smcameron/open-simplex-noise-in-c.

Does OpenSimplexNoise change? Rarely. However, there is a breaking change in OpenSimplexNoise for Godot 4 and 3.4: the axis has been swaped (this is a fix).

So that leads us to add a custom noise solution. Which could be a port of OpenSimplex noise to C# or GDScript.

See open-simplex-noise.c from Godot source and digitalshadow/OpenSimplexNoise.cs (which is a port to C#, there are some other ports linked in the comments there too).

And for the texture, there are a couple options:

• You can create a script that draws the image (I suggest using lockbits) and set it.
• Or you can extend Viewport (which entains adding a Viewport to the scene and attaching a script). Then you take advantage of ViewportTexture, and you can take advantage of shaders to create the texture you want. Take BastiaanOlij/godot-noise-texture-asset for reference.

I don't understand why you have ctypes in there at all. The issue is that Javascript integers are limited to 32 bits, whereas Python has infinite precision. This does what you want:

It seems my attempt was correct with the exception of one detail:

Instead of:

If you want a function that performs exactly the same then I think that looks like this:

Observable.Defer is your friend if you want per-subscriber state.

Try this:

Given a function BinaryRandom() which returns 0 or 1
create a function int MyRandom(int) which creates a random number less or equal to the given input

Why the Python code is 100 times slower than C code?

Because there's a lot to do when calling the function. The function call itself is expensive.

How can I improve the performance of the Python code?

If you want a huge list of random numbers, then you can write a C function that returns a huge list, thus minimizing the number of calls.

You could for example implemement a queue in python that stores 10000 random numbers. You initialize it with the C function mentioned above. Then the queue automatically calls the function every time you pop the last number from the queue. If that's also too slow, then maybe you should code functions using the random numbers in C too. Creating a huge list is quite expensive in Python.

An example of something that would benefit quite much from writing as a C function is an is_prime(x) function, that is, a function that returns true if x is a prime and false otherwise. Especially if we're talking about very large numbers. This case has these two key properties:

• There is very little data sent to and from the is_prime(x) function. You send it a simple integer and return a boolean.
• For large x this is a very heavy operation

My example with creating a queue fails on the first point. There would be quite a lot of data sent between C and Python.

Your function fails on the second point. The calculation is very lightweight compared to the function call overhead.

Accessing the bit generator through rg is the same as declaring pg = PCG64() and then accessing pg.state. There's nothing wrong with accessing via rg.bit_generator. The docs are a bit scarce but the docs for BitGenerator state that accessing BitGenerator.state allows you to get and set the state if you chose BitGenerator.

https://numpy.org/doc/stable/reference/random/bit_generators/generated/numpy.random.PCG64.state.html?highlight=pcg64