#include <stdint.h>

#include <stdlib.h>

#include <stdio.h>

#include <errno.h>

#include <unistd.h>

static uint64_t seed = -1;

static uint32_t rand32(void)

{

	seed = 6364136223846793005ull*seed + 1;

	return seed >> 32;

}

static uint64_t rand64(void)

{

	uint64_t u = rand32();

	return u<<32 | rand32();

}

static double frand(){return rand64() * 0x1p-64;}

static float frandf(){return rand32() * 0x1p-32f;}

static long double frandl(){return rand64() * 0x1p-64L;}

/* uniform random in [0,n), n > 0 must hold */

uint64_t randn(uint64_t n)

{

	uint64_t r, m;

	/* m is the largest multiple of n */

	m = -1;

	m -= m%n;

	while ((r = rand64()) >= m);

	return r%n;

}

/* uniform on [a,b] */

uint64_t randint(uint64_t a, uint64_t b)

{

	if (b < a) {

		uint64_t t = b;

		b = a;

		a = t;

	}

	return a + randn(b - a + 1);

}

int insert(uint64_t *tab, size_t len, uint64_t v)

{

	size_t i = v & (len-1);

	size_t j = 1;

	/* 0 means empty, v > 0 must hold */

	while (tab[i]) {

		if (tab[i] == v)

			return -1;

		i += j++;

		i &= len-1;

	}

	tab[i] = v;

	return 0;

}

static void shuffle2(uint64_t *p, uint64_t *q, size_t np, size_t nq)

{

	size_t i,r,t;

	i = np+nq;

	while (i > np) {

		r = randn(i);

		i--;

		t = q[i-np];

		if (r < np) {

			q[i-np] = p[r];

			p[r] = t;

		} else {

			q[i-np] = q[r-np];

			q[r-np] = t;

		}

	}

}

/* choose k unique numbers from [0,n), k <= n */

int choose(uint64_t n, size_t k, uint64_t *p)

{

	uint64_t *tab;

	size_t i, j, len;

	if (n < k)

		return -1;

	if (n < 16) {

		/* no alloc */

		while (k)

			if (randn(n--) < k)

				p[--k] = n;

		return 0;

	}

	if (k < 8) {

		/* no alloc, n > 15 > 2*k */

		for (i = 0; i < k;) {

			p[i] = randn(n);

			for (j = 0; p[j] != p[i]; j++);

			if (j == i)

				i++;

		}

		return 0;

	}

	if (n < 5*k && (n-k)*sizeof *tab < (size_t)-1) {

		/* allocation is < 4*k */

		tab = malloc((n-k) * sizeof *tab);

		if (!tab)

			return -1;

		for (i = 0; i < k; i++)

			p[i] = i;

		for (; i < n; i++)

			tab[i-k] = i;

		if (n-k < k)

			shuffle2(p, tab, k, n-k);

		else

			shuffle2(tab, p, n-k, k);

		free(tab);

		return 0;

	}

	/* allocation is < 4*k */

	for (len = 16; len <= 2*k; len *= 2);

	tab = calloc(len, sizeof *tab);

	if (!tab)

		return -1;

	for (i = 0; i < k; i++)

		while (insert(tab, len, randn(n)+1));

	for (i = 0; i < len; i++)

		if (tab[i])

			*p++ = tab[i]-1;

	free(tab);

	return 0;

}

static int cmp64(const void *a, const void *b)

{

	const uint64_t *ua = a, *ub = b;

	return *ua < *ub ? -1 : (*ua > *ub ? 1 : 0);

}

// todo: in place flip problem

/* choose k unique uint64_t numbers */

int choose64(size_t k, uint64_t *p)

{

	size_t i, c;

	/* no alloc, collisions should be very rare */

	for (i = 0; i < k; i++)

		p[i] = rand64();

	do {

		c = 0;

		qsort(p, k, sizeof *p, cmp64);

		for (i = 1; i < k; i++)

			if (p[i] == p[i-1]) {

				p[i-1] = rand64();

				c = 1;

			}

	} while (c);

	return 0;

}

/* equidistant sampling with some randomness */

int sample(uint64_t n, size_t k, uint64_t *p)

{

	uint64_t a = 0;

	uint64_t d = n/k;

	size_t m = n%k;

	size_t i, j;

	uint64_t *q;

	if (!d)

		return -1;

	q = malloc((m+1) * sizeof *q);

	if (!q)

		return -1;

	if (choose(k, m, q))

		return -1;

	qsort(q, m, sizeof *q, cmp64);

	q[m] = k;

	for (i = j = 0; i < k; i++) {

		uint64_t t;

		while (q[j] < i)

			j++;

		if (q[j] == i)

			t = d+1;

		else

			t = d;

		p[i] = a + randn(t);

		a += t;

	}

	free(q);

	return 0;

}

/* [-inf,inf] uniform on representation */

int genall(size_t k, uint64_t *p)

{

	size_t i;

	uint64_t n, d;

	d = 1;

	d <<= 52;

	if (sample(-2*d, k, p))

		return -1;

	n = 0x7ff;

	n <<= 52;

	for (i = 0; i < k; i++)

		if (p[i] > n)

			p[i] += d-1;

	return 0;

}

/* [a,b) uniform on representation, 0 <= a <= b */

int genab(size_t k, uint64_t a, uint64_t b, uint64_t *p)

{

	size_t i;

	if (sample(b-a, k, p))

		return -1;

	for (i = 0; i < k; i++)

		p[i] += a;

	return 0;

}

#define asfloat(x) ((union{uint64_t af_i; double af_f;}){.af_i=x}.af_f)

#define asint(x)   ((union{uint64_t af_i; double af_f;}){.af_f=x}.af_i)

int main(int argc, char *argv[])

{

	uint64_t k, i;

	uint64_t *p;

	double a,b,m;

	char *e;

	int opt;

	k = 1000;

	a = 0;

	b = 1;

	m = 1;

	while ((opt = getopt(argc, argv, "n:a:b:m:s:")) != -1) {

		switch(opt) {

		case 'n':

			k = strtoull(optarg,&e,0);

			break;

		case 'a':

			a = strtod(optarg,&e);

			if (a < 0)

				goto usage;

			break;

		case 'b':

			b = strtod(optarg,&e);

			if (b < 0)

				goto usage;

			break;

		case 'm':

			m = strtod(optarg,&e);

			break;

		case 's':

			seed = strtoull(optarg,&e,0);

			break;

		default:

usage:

			fprintf(stderr, "usage: %s -n num -a absmin -b absmax -m mult -s seed\n", argv[0]);

			return -1;

		}

		if (*e || errno)

			goto usage;

	}

	if (!(a <= b))

		goto usage;

	p = malloc(k * sizeof *p);

	if (!p)

		return -1;

	if (genab(k, asint(a), asint(b), p))

//	if (genall(k,p))

		return -1;

	for (i = 0; i < k; i++)

//		printf("0x%016llx\n", p[i]);

		printf("%a\n", m*asfloat(p[i]));

	return 0;

}