For the usual, 32-bit, version of the Mersenne Twister algo, the dimensionality is 623.
What is the dimensionality of a MWC random generator?
Related
Is there a specific algorithm or method of calculating the speed of a pseudo random number generator?
I've recently made a PRNG, and for my last question here I learned that the Big-O analysis is not suitable in my situation.
I want to compare my program's speed to a well known pseudo random number generator, but I can't find any valuable information related to it.
Evolution algorithm is highly dependent on good randomness. Unfortunately, good randomness sources are slow (and hence the AI).
Question is, if I take one highest quality number and use it as a seed for poor quality (but fast) random generator, how much 'random' will be result?
I have conducted some research into this area previously. Evolutionary algorithms are part of a family of meta heuristic algorithms of which the particle swarm algorithm also belongs. A study has been conducted into the effectiveness of random number generators on the particle swarm algorithm here: Impact of the quality of random numbers generators on the performance of particle swarm optimization. It should directly apply to your evolutionary algorithm.
I've read about factorization of integers into the prime factors and did a proof of concept implementation of Pollard's rho algorithm:
https://en.wikipedia.org/wiki/Pollard%27s_rho_algorithm
The algorithm is easy to implement, works so far. However it may (and does) fail for certain numbers. The Wikipedia page suggest to restart the algorithm using a different start condition or pick a random generator function.
That does not sound very deterministic to me. Is there an approach that guarantees that the algorithm will eventually terminate?
I know that the state of the art is the elliptic curve integer factorization, and I plan to implement it for laughs and giggles later. To do so I first need a prime factorization algorithm for small numbers though, that is why I have to deal with something like Pollards rho algorithm first.
Can any one tell me the number of seeds in lagged fibonacci random number generator as a function of typical lagged fibonacci parameters, I would really appreciate a diagram to illustrate the working of the random number generator
The design and properties of Fibonacci generators are discussed in the widely cited paper by Brent, and it includes an overview of implementation on a vector supercomputer of the time. This paper forms the basis of the boost::random Fibonacci generators, so you can see what a modern implementation looks like by inspecting the boost source.
I am not quite sure what this question has to do with cuda or parallel programming, though.
My problem is the following:
I need to generate lot of random numbers in parallel using Binomial Distribution on CUDA. All the Random Number Generators on CUDA are based on the Uniform Distribution (as far I know), what is also useful since all the algorithms for Binomial Distribution needs to use Uniform variates.
Is there any library or implementation for binomial random variate generation on CUDA? I see that there are for JAVA in http://acs.lbl.gov/~hoschek/colt/ , but it uses a very complicated algorithm to be parallelized. However, given a binomial variate following B(N,p), there are simpler algorithms with order of complexity O(N), but it is bad for me because N can be large (around 2^32, maximum for a Integer).
I would appreciate any help. Thanks a lot.
Miguel
P.S.: sorry for my bad english :)
That's an interesting problem, I would attack the problem by using a previous solution and adapting it to the way CUDA works..
CiteSeerX is where you can get hold of pdf's for research that might help..
http://citeseerx.ist.psu.edu/
Did you take a look at MDGPU? It was suggested in another question in SO
http://www-old.amolf.nl/~vanmeel/mdgpu/licence.html
Also NAG have a library which may help:
http://www.nag.co.uk/numeric/gpus/