def nonuniform_random_number_generation_wrapper(executor, values, probabilities): def nonuniform_random_number_generation_runner(executor, values, probabilities): N = 10**6 result = executor.run(lambda: [ nonuniform_random_number_generation(values, probabilities) for _ in range(N) ]) counts = collections.Counter(result) for v, p in zip(values, probabilities): if N * p < 50 or N * (1.0 - p) < 50: continue sigma = math.sqrt(N * p * (1.0 - p)) if abs(float(counts[v]) - (p * N)) > 5 * sigma: return False return True run_func_with_retries( functools.partial( nonuniform_random_number_generation_runner, executor, values, probabilities, ))
def random_sampling_wrapper(executor, k, A): def random_sampling_runner(executor, k, A): result = [] def populate_random_sampling_result(): for _ in range(100000): random_sampling(k, A) result.append(A[:k]) executor.run(populate_random_sampling_result) total_possible_outcomes = binomial_coefficient(len(A), k) A = sorted(A) comb_to_idx = { tuple(compute_combination_idx(A, len(A), k, i)): i for i in range(binomial_coefficient(len(A), k)) } return check_sequence_is_uniformly_random( [comb_to_idx[tuple(sorted(a))] for a in result], total_possible_outcomes, 0.01, ) run_func_with_retries( functools.partial(random_sampling_runner, executor, k, A))
def compute_random_permutation_wrapper(executor, n): def compute_random_permutation_runner(executor, n): def permutation_index(perm): p = copy.deepcopy(perm) idx = 0 n = len(p) while p: a = p.pop(0) idx += a * math.factorial(n - 1) for i, b in enumerate(p): if b > a: p[i] -= 1 n -= 1 return idx result = executor.run( lambda: [compute_random_permutation(n) for _ in range(1000000)]) return check_sequence_is_uniformly_random( [permutation_index(perm) for perm in result], math.factorial(n), 0.01, ) run_func_with_retries( functools.partial(compute_random_permutation_runner, executor, n))
def uniform_random_wrapper(executor, lower_bound, upper_bound): def uniform_random_runner(executor, lower_bound, upper_bound): result = executor.run(lambda : [uniform_random(lower_bound, upper_bound) for _ in range(100000)]) return check_sequence_is_uniformly_random( [a - lower_bound for a in result], upper_bound - lower_bound + 1, 0.01) run_func_with_retries( functools.partial(uniform_random_runner, executor, lower_bound, upper_bound))
def uniform_random_wrapper(executor, lower_bound, upper_bound): def uniform_random_runner(executor, lower_bound, upper_bound): result = executor.run(lambda : [uniform_random(lower_bound, upper_bound) for _ in range(100000)]) return check_sequence_is_uniformly_random( [a - lower_bound for a in result], upper_bound - lower_bound + 1, 0.01) run_func_with_retries( functools.partial(uniform_random_runner, executor, lower_bound, upper_bound))
def random_subset_wrapper(executor, n, k): def random_subset_runner(executor, n, k): results = executor.run( lambda: [random_subset(n, k) for _ in range(100000)]) total_possible_outcomes = binomial_coefficient(n, k) comb_to_idx = { tuple(compute_combination_idx(list(range(n)), n, k, i)): i for i in range(binomial_coefficient(n, k)) } return check_sequence_is_uniformly_random( [comb_to_idx.get(tuple(sorted(result)), 0) for result in results], total_possible_outcomes, 0.01) run_func_with_retries( functools.partial(random_subset_runner, executor, n, k))
def uniform_random_wrapper(timer, lower_bound, upper_bound): def uniform_random_runner(timer, lower_bound, upper_bound): timer.start() result = [ uniform_random(lower_bound, upper_bound) for _ in range(100000) ] timer.stop() return check_sequence_is_uniformly_random( [a - lower_bound for a in result], upper_bound - lower_bound + 1, 0.01) run_func_with_retries( functools.partial(uniform_random_runner, timer, lower_bound, upper_bound))
def online_random_sample_wrapper(executor, stream, k): def online_random_sample_runner(executor, stream, k): results = executor.run(lambda : [online_random_sample(iter(stream), k) for _ in range(100000)]) total_possible_outcomes = binomial_coefficient(len(stream), k) stream = sorted(stream) comb_to_idx = { tuple(compute_combination_idx(stream, len(stream), k, i)): i for i in range(binomial_coefficient(len(stream), k)) } return check_sequence_is_uniformly_random( [comb_to_idx.get(tuple(sorted(result)), 0) for result in results], total_possible_outcomes, 0.01) run_func_with_retries( functools.partial(online_random_sample_runner, executor, stream, k))
def random_subset_wrapper(executor, n, k): def random_subset_runner(executor, n, k): results = executor.run( lambda: [random_subset(n, k) for _ in range(100000)]) total_possible_outcomes = binomial_coefficient(n, k) comb_to_idx = { tuple(compute_combination_idx(list(range(n)), n, k, i)): i for i in range(binomial_coefficient(n, k)) } return check_sequence_is_uniformly_random( [comb_to_idx.get(tuple(sorted(result)), 0) for result in results], total_possible_outcomes, 0.01) run_func_with_retries( functools.partial(random_subset_runner, executor, n, k))
def online_random_sample_wrapper(executor, stream, k): def online_random_sample_runner(executor, stream, k): results = executor.run(lambda : [online_random_sample(iter(stream), k) for _ in range(100000)]) total_possible_outcomes = binomial_coefficient(len(stream), k) stream = sorted(stream) comb_to_idx = { tuple(compute_combination_idx(stream, len(stream), k, i)): i for i in range(binomial_coefficient(len(stream), k)) } return check_sequence_is_uniformly_random( [comb_to_idx.get(tuple(sorted(result)), 0) for result in results], total_possible_outcomes, 0.01) run_func_with_retries( functools.partial(online_random_sample_runner, executor, stream, k))
def random_subset_wrapper(timer, n, k): def random_subset_runner(timer, n, k): timer.start() result = [random_subset(n, k) for _ in range(100000)] timer.stop() total_possible_outcomes = binomial_coefficient(n, k) comb_to_idx = { tuple(compute_combination_idx(list(range(n)), n, k, i)): i for i in range(binomial_coefficient(n, k)) } return check_sequence_is_uniformly_random( [comb_to_idx[tuple(sorted(a))] for a in result], total_possible_outcomes, 0.01) run_func_with_retries(functools.partial(random_subset_runner, timer, n, k))
def online_random_sample_wrapper(timer, stream, k): def online_random_sample_runner(timer, stream, k): timer.start() result = [online_random_sample(iter(stream), k) for _ in range(100000)] timer.stop() total_possible_outcomes = binomial_coefficient(len(stream), k) stream = sorted(stream) comb_to_idx = { tuple(compute_combination_idx(stream, len(stream), k, i)): i for i in range(binomial_coefficient(len(stream), k)) } return check_sequence_is_uniformly_random( [comb_to_idx[tuple(sorted(a))] for a in result], total_possible_outcomes, 0.01) run_func_with_retries( functools.partial(online_random_sample_runner, timer, stream, k))
def nonuniform_random_number_generation_wrapper(executor, values, probabilities): def nonuniform_random_number_generation_runner(executor, values, probabilities): N = 10**6 result = executor.run(lambda : [nonuniform_random_number_generation(values, probabilities) for _ in range(N)]) counts = collections.Counter(result) for v, p in zip(values, probabilities): if N * p < 50 or N * (1.0 - p) < 50: continue sigma = math.sqrt(N * p * (1.0 - p)) if abs(float(counts[v]) - (p * N)) > 5 * sigma: return False return True run_func_with_retries( functools.partial(nonuniform_random_number_generation_runner, executor, values, probabilities))
def nonuniform_random_number_generation_wrapper(timer, values, probabilities): def nonuniform_random_number_generation_runner(timer, values, probabilities): n = 10**6 timer.start() result = [ nonuniform_random_number_generation(values, probabilities) for _ in range(n) ] timer.stop() counts = collections.Counter(result) for v, p in zip(values, probabilities): if n * p < 50 or n * (1.0 - p) < 50: continue sigma = math.sqrt(n * p * (1.0 - p)) if abs(float(counts[v]) - (p * n)) > 5 * sigma: return False return True run_func_with_retries( functools.partial(nonuniform_random_number_generation_runner, timer, values, probabilities))
def compute_random_permutation_wrapper(executor, n): def compute_random_permutation_runner(executor, n): def permutation_index(perm): p = copy.deepcopy(perm) idx = 0 n = len(p) while p: a = p.pop(0) idx += a * math.factorial(n - 1) for i, b in enumerate(p): if b > a: p[i] -= 1 n -= 1 return idx result = executor.run( lambda: [compute_random_permutation(n) for _ in range(1000000)]) return check_sequence_is_uniformly_random( [permutation_index(perm) for perm in result], math.factorial(n), 0.01) run_func_with_retries( functools.partial(compute_random_permutation_runner, executor, n))
def random_sampling_wrapper(executor, k, A): def random_sampling_runner(executor, k, A): result = [] def populate_random_sampling_result(): for _ in range(100000): random_sampling(k, A) result.append(A[:k]) executor.run(populate_random_sampling_result) total_possible_outcomes = binomial_coefficient(len(A), k) A = sorted(A) comb_to_idx = { tuple(compute_combination_idx(A, len(A), k, i)): i for i in range(binomial_coefficient(len(A), k)) } return check_sequence_is_uniformly_random( [comb_to_idx[tuple(sorted(a))] for a in result], total_possible_outcomes, 0.01) run_func_with_retries( functools.partial(random_sampling_runner, executor, k, A))