I've been working on a stronger "random" generator, but it's still pretty predictable. Does anyone have any suggestions for less static things that I could add into the algorithm?
Code:
Code:
#include <stdio.h>
#include <stdlib.h>
#include <sys/sysinfo.h>
#include <sys/time.h>
#include <stdint.h>
#define RP_POOL_MAX 10
#define rp_ins_pool(v, p) \
while ( *p != 0) \
p++; \
*p = v;
struct rand_pool {
int64_t rp_mem_sum;
int64_t rp_ram_sum;
int32_t rp_sys_time;
int64_t rp_top_limit;
int64_t rp_btm_limit;
int64_t *rp_pool;
};
static int64_t rp_parse_time() {
struct timeval *tv = malloc(sizeof *tv);
gettimeofday(tv, NULL);
int32_t l_s = (int32_t)(tv->tv_sec / 1000);
int32_t l_u = (int32_t)(tv->tv_usec * 1000);
int64_t l_r = (l_s + l_u);
free(tv);
return (l_r ? l_r : l_u * l_s);
}
static int64_t rp_parse_mem() {
struct sysinfo *sf = malloc(sizeof *sf);
sysinfo(sf);
int32_t l_s = sf->loads[0] + sf->loads[1] + sf->loads[2];
int16_t l_d = (l_s | (sf->procs % 2 ? 0x6 : 0x2));
int64_t l_q = (int64_t)(sf->uptime * sf->freeram) / l_d;
int64_t l_r = (sf->totalswap << (l_q / 1000));
free(sf);
return (l_r ? l_r : l_s * l_d);
}
static int64_t rp_parse_ram() {
struct sysinfo *sf = malloc(sizeof *sf);
sysinfo(sf);
int64_t l_r = (sf->totalram * sf->bufferram) >> 32;
int64_t l_c = (int64_t)(int32_t)(l_r * sf->freeram);
free(sf);
return (l_c ? l_c : l_r * l_r);
}
static struct rand_pool *rp_init_pool() {
struct rand_pool *rp;
rp = calloc(1, sizeof *rp);
rp->rp_pool = calloc(1, RP_POOL_MAX + 1);
rp->rp_sys_time = rp_parse_time();
rp->rp_ram_sum = rp_parse_ram();
rp->rp_mem_sum = rp_parse_mem();
rp_ins_pool(rp->rp_sys_time, rp->rp_pool);
rp_ins_pool(rp->rp_ram_sum, rp->rp_pool);
rp_ins_pool(rp->rp_mem_sum, rp->rp_pool);
return rp;
}
static int64_t rp_synth_pool(struct rand_pool *rp) {
int64_t ret;
int64_t l_m = (rp->rp_mem_sum < rp->rp_ram_sum ?
rp->rp_ram_sum : rp->rp_mem_sum);
int64_t l_t = (l_m > 1073741824 ?
l_m / 1073741824 :
(int64_t)((float)l_m * 1.25));
int64_t l_f = (l_t * (rp->rp_sys_time / 1000));
int64_t l_mod_top = rp->rp_top_limit - rp->rp_btm_limit;
int64_t l_ret = ( (l_f + rp->rp_btm_limit) % l_mod_top);
if ((0 > rp->rp_btm_limit) && (l_ret % 2 || l_ret % 3))
return 0-l_ret;
else
return l_ret;
}
static int64_t rp_rand(int64_t top, int64_t btm) {
struct rand_pool *rp;
rp = rp_init_pool();
rp->rp_top_limit = top;
rp->rp_btm_limit = btm;
int64_t rp_final;
rp_final = rp_synth_pool(rp);
free(rp);
return rp_final;
}
int main() {
int64_t prnt;
int64_t top = 10000000;
int64_t btm = -10000000;
for (;;) {
prnt = rp_rand(top, btm);
printf("Random between %ld and %ld: %ld\n", btm, top, prnt);
sleep(1);
}
}