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))
