правильный рандом на си

#include <stdlib.h>
#include <stdio.h>

#define _RAND_MAX 7

unsigned int myrand(void) {
    return rand() % (_RAND_MAX + 1);
}

unsigned int xrand(unsigned int limit)
{
   unsigned int rand_limit = (_RAND_MAX / limit) * limit;
   unsigned int result = myrand();
   while (result > rand_limit)
      result = myrand();

   return result % limit;
}

int main(void) {
    unsigned count[8] = {};

    for (int k = 0; k < 100 * 1000 * 1000; k++) {
        count[xrand(3)] += 1;
        // count[myrand()] += 1;
    }

    for (int k = 0; k < 8; k++)
        printf("%u\n", count[k]);

    return 0;
}

12493877
12496457
12499627
12500440
12502970
12503696
12500913
12502020

42857004
28570166
28572830
0
0
0
0
0

asm volatile ("rdrand %0" : "=r" (*rand));

int get_random(int g_rand_max)
{
    return (int) ((g_rand_max + 1.0) * rand() / (RAND_MAX + 1.0));
}

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <sysexits.h>
#include <time.h>

#define X_PRIME         1021
#define X_NONPRIME      (1 << 16)
#define BASE            10
#define ITERS           100000000

static volatile uint64_t r = 0;

static uint64_t rnd()
{
        r ^= (r << 21);
        r ^= (r >> 35);
        r ^= (r << 4);

        return r;
}

int main(int _argc, char** _argv)
{
        (void)_argc;
        (void)_argv;
        size_t p_basket[BASE] = {0,};
        size_t q_basket[BASE] = {0,};

        srand(time(NULL));
        r = rand();

        for (size_t i = 0; i < ITERS; i++)
        {
//              int p = rnd() % X_PRIME;
//              int q = rnd() % X_NONPRIME;
                int p = rand() % X_PRIME;
                int q = rand() % X_NONPRIME;

                p_basket[p % BASE]++;
                q_basket[q % BASE]++;
        }

        printf("%s", "# p q\n");
        for (size_t i = 0; i < BASE; i++)
        {
                printf("%zu %zu %zu\n", i, p_basket[i], q_basket[i]);
        }

        exit(EX_OK);
}

$ icc test.c -O3 -o test

$ ./test | column -t    
#  p         q
0  10089663  9999205
1  9990400   10005347
2  9989107   9997447
3  9993000   10004499
4  9986341   10001433
5  9992309   9997622
6  9989316   9995989
7  9989636   9998124
8  9990691   9997104
9  9989537   10003230

- while (result > rand_limit)
+ while (result >= rand_limit)

#include <stdio.h>

int random_data(void* data, size_t size);

int main(void)
{
    int i;
    unsigned int x;
    for(i = 0; i<5; ++i)
    {
        random_data(&x, sizeof(x));
        printf("%u\n", x);
    }
    return 0;
}

#ifdef _WIN32

#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <wincrypt.h>

int random_data(void* data, size_t size)
{
    HCRYPTPROV hProv;
    BOOL rv;
    rv = CryptAcquireContextW(&hProv, NULL, NULL, PROV_RSA_FULL, CRYPT_SILENT | CRYPT_VERIFYCONTEXT);
    if(!rv) return 0;
    rv = CryptGenRandom(hProv, (DWORD)size, data);
    CryptReleaseContext(hProv, 0);
    return rv ? 1 : 0;
}

#else

int random_data(void* data, size_t size)
{
    FILE* f;
    if(size < 1 || !data)
    {
        return 0;
    }
    f = fopen("/dev/urandom", "r");
    if(!f)
    {
        return 0;
    }
    size = fread(data, size, 1, f);
    fclose(f);
    return size ? 1 : 0;
}

#endif // _WIN32

user@host $ apt-file find gsl/gsl_rng.h
libgsl-dev: /usr/include/gsl/gsl_rng.h

long throw_random_seed(){
	long r_ini;
	int fail = 0;
	int fd = open("/dev/random", O_RDONLY);
	do{
		if(-1 == fd){
			perror(_("Can't open /dev/random"));
			fail = 1; break;
		}
		if(sizeof(long) != read(fd, &r_ini, sizeof(long))){
			perror(_("Can't read /dev/random"));
			fail = 1;
		}
		close(fd);
	}while(0);
	if(fail){
		double tt = dtime() * 1e6;
		double mx = (double)LONG_MAX;
		r_ini = (long)(tt - mx * floor(tt/mx));
	}
	return (r_ini);
}