rng.c

Go to the documentation of this file.

#include <math.h>
const float  TWOPI  = 6.283185307179586;



__device__ 
unsigned int TausStep( unsigned int * seed, 
                       int            S1, 
                       int            S2, 
                       int            S3, 
                       unsigned int   M )  
{  
    unsigned int b=(((*seed << S1) ^ *seed) >> S2);  
    return *seed = (((*seed & M) << S3) ^ b);  
}  


__device__ 
unsigned int LCGStep( unsigned int * seed, 
                      unsigned int   A, 
                      unsigned int   C )  
{  
    return *seed = ( A * *seed + C );  
}  



__device__ 
float hybrid_tausworth_rng( unsigned int * seed1, 
                            unsigned int * seed2, 
                            unsigned int * seed3, 
                            unsigned int * seed4 )  
{                                                              // Periods  
      unsigned int  u =
                TausStep( seed1, 13, 19, 12, 4294967294UL )    // p1=2^31-1  
              ^ TausStep( seed2,  2, 25,  4, 4294967288UL )    // p2=2^30-1  
              ^ TausStep( seed3,  3, 11, 17, 4294967280UL )    // p3=2^28-1  
              ^ LCGStep(  seed4, 1664525, 1013904223UL);       // p4=2^32  
     return  u*2.3283064365387e-10; 
}  




__device__ __host__ 
unsigned int mult_with_carry_rng( unsigned int * seed1, 
                                  unsigned int * seed2 )
{
    *seed1 = 36969u * ( *seed1 & 65535u ) + ( *seed1 >> 16 );
    *seed2 = 18000u * ( *seed2 & 65535u ) + ( *seed2 >> 16 );
    return (( *seed1 << 16 ) + *seed2 );
}



void initialize_rng_seeds( unsigned int * seeds,       
                           unsigned int * meta_seed,   
                           int            n )          
{
    unsigned int seed1 = meta_seed[0];
    unsigned int seed2 = meta_seed[1];
    for (int i=0;i<n*4;i++){ 
        do {
            seeds[i] = mult_with_carry_rng( &seed1, &seed2 );
        } while (seeds[i]<128);       // seeds should be greater than 128 for Tausworth generator.
        }                                                                               
    meta_seed[0] = seed1;
    meta_seed[1] = seed2;
}



__device__ 
void get_seed( unsigned int * seed, 
               unsigned int * rng_state, 
               int i, 
               int n )
{
    for (int k=0;k<4;k++)
        seed[k] = rng_state[k*n+i];
}



__device__ 
void put_seed( unsigned int * seed, 
               unsigned int * rng_state, 
               int i, 
               int n )
{
    for (int k=0;k<4;k++)
        rng_state[k*n+i] = seed[k];
}




__device__
float random_uniform( unsigned int * seed )
{
    return hybrid_tausworth_rng( &seed[0], &seed[1], &seed[2], &seed[3] );
}




__device__ 
float random_uniform_positive( unsigned int * seed )
{
    float u=-1.0;
    do {
        u = random_uniform( seed );
    } while (u<=0);
    return u;
}



template <typename T>
__device__ 
void random_normal( T            * z1, 
                    T            * z2, 
                    unsigned int * seed ) 
{
    T u0 = random_uniform_positive( seed );
    T u1 = random_uniform( seed );
    T r  = sqrt( -2.0 * log( u0 ));
    T theta = TWOPI*u1;
    *z1 = r * sin( theta );
    *z2 = r * cos( theta ); 
}