def test_shanks_middle(numOfTests: int,
numOfBits: list,
randSeed=0,
centered=True):
import matplotlib.pyplot as plt
seed(randSeed)
giant_steps_class_list, times_clasic = [], []
giant_steps_centered_list, times_centered = [], []
for bits in numOfBits:
time_clas, time_cent = [], []
giant_clas, giant_cent = [], []
for iter in range(numOfTests):
p, g, exp, h = gnp.logarithm_test_numbers(bits, centered)
# print("iter:", iter)
t = timer()
x_c, _, giant_steps_c, _ = shanks_classic(g, h, p, p - 1)
giant_clas.append(giant_steps_c)
passed_time = (timer() - t) * 1000
time_clas.append(passed_time)
# print(f"C_passed x:{x_c}, exp:{exp}, sm:{small_steps_c}, gs:{giant_steps_c} time:{passed_time:.3f}")
t = timer()
x_m, _, giant_steps_m = shanks_centered(g, h, p, p - 1)
giant_cent.append(giant_steps_m)
passed_time = (timer() - t) * 1000
time_cent.append(passed_time)
# print(f"M_passed x:{x_c}, exp:{exp}, sm:{small_steps_m}, gs:{giant_steps_m} time:{passed_time:.3f} \n")
print()
giant_steps_class_list.append(avg(giant_clas))
giant_steps_centered_list.append(avg(giant_cent))
times_clasic.append(avg(time_clas))
times_centered.append(avg(time_cent))
def test_shanks_same_p(numOfTests: int, numOfBits: int, rs=[2], radn_seed=0):
seed(radn_seed)
times_g, smalls_g, giants_g, memsizes_g = [], [], [], []
p, g, exps, hs = gnp.logarithm_test_numbers_same_p(numOfTests, numOfBits)
l, m = optim_factors(p - 1)
r_opt = r_optim(p - 1, numOfTests)
print(f"r optim:{r_opt:.2f}")
print("General started!")
t_start_c = timer()
x_cs, small_steps_c, giant_steps_c, memsize_c = shanks_classic_with_memory(
g, hs, p, p - 1)
time_c = (timer() - t_start_c) * 1000
print("General finished!")
print("Factor started!")
t_start_f = timer()
x_fs, small_steps_f, giant_steps_f, memsize_f = shanks_factor_with_memory(
g, hs, p, l, m)
time_f = (timer() - t_start_f) * 1000
print("Factor finished!")
rs += [r_opt]
for r in rs:
print(f"Gen {r:.3f} started!")
t_start_g = timer()
x_gs, small_steps_g, giant_steps_g, memsize_g = shanks_general_with_memory(
g, hs, p, p - 1, r)
times_g.append((timer() - t_start_g) * 1000)
smalls_g.append(small_steps_g)
giants_g.append(avg(giant_steps_g))
memsizes_g.append(memsize_g)
print(f"Gen {r:.3f} finished!")
print(
f"t_c: {time_c/numOfTests:.3f} ms, t_f: {time_f/numOfTests:.3f} ms, t_g:",
end=' ')
for r, t in zip(rs, times_g):
print(f"r= {r}: {t/numOfTests:0.3f} ms", end=" ")
print(
f"\n\nsm_c: {small_steps_c/ceil(sqrt(p)):.3f}, sm_f: {small_steps_f/ceil(sqrt(p)):.3f}, sm_g:",
end=' ')
for r, s in zip(rs, smalls_g):
print(f"r= {r}: {s/ceil(sqrt(p)):.3f}", end=" ")
print(
f"\n\ngc_avg: {avg(giant_steps_c)/ceil(sqrt(p)):.3f}, gf_avg: {avg(giant_steps_f)/ceil(sqrt(p)):.3f}, gg_avg:",
end=' ')
for r, g in zip(rs, giants_g):
print(f"r= {r}: {g/ceil(sqrt(p)):.3f}", end=" ")
print(
f"\n\nsize_c: {memsize_c/ceil(sqrt(p)):.3f} bytes, size_f: {memsize_f/ceil(sqrt(p)):.3f} bytes, size_g:",
end=' ')
for r, m in zip(rs, memsizes_g):
print(f"r= {r}: {m/ceil(sqrt(p)):.3f} bytes", end=" ")
def shanks_worst_tests(numOfTests: int, numOfBits: list, randSeed=0):
seed(randSeed)
total_steps_class_list, times_clasic_list, total_memory_clasic = [], [], []
total_steps_grumpy_list, times_grumpy_list, total_memory_grumpy = [], [], []
for bits in numOfBits:
time_clas, time_grumpy = [], []
steps_clas, steps_grumpy = [], []
mem_clas, mem_grumpy = [], []
print("Started: ", bits)
if bits >= 50:
numOfTests = 50
elif bits >= 40:
numOfTests = 100
for iter in range(numOfTests):
p, g, exp, h = gnp.worst_shanks_numbers(bits)
t = timer()
x_c, small_clas, giant_clas, mem_c = shanks_classic(g, h, p, p - 1)
steps_clas.append(small_clas + giant_clas)
mem_clas.append(mem_c)
passed_time = (timer() - t) * 1000
time_clas.append(passed_time)
t = timer()
x_c, oper, mem_c = shanks_two_grumpys_one_baby(g, h, p, p - 1)
if x_c != exp:
print("NG")
steps_grumpy.append(oper)
mem_grumpy.append(mem_c)
passed_time = (timer() - t) * 1000
time_grumpy.append(passed_time)
print(
f"Avg steps clasic:{avg(steps_clas) / ceil(sqrt(p)):.4f} -- Avg steps grumpy:{avg(steps_grumpy) / ceil(sqrt(p)):.4f}"
)
print(
f"Avg memory clasic:{avg(mem_clas) / ceil(sqrt(p)):.4f} -- Avg memory grumpy:{avg(mem_grumpy) / ceil(sqrt(p)):.4f}"
)
print(
f"Avg time clasic:{avg(time_clas):.4f} -- Avg time grumpy:{avg(time_grumpy):.4f}"
)
total_steps_class_list.append(avg(steps_clas) / ceil(sqrt(p)))
total_steps_grumpy_list.append(avg(steps_grumpy) / ceil(sqrt(p)))
times_clasic_list.append(avg(time_clas))
times_grumpy_list.append(avg(time_grumpy))
total_memory_clasic.append(avg(mem_clas) / ceil(sqrt(p)))
total_memory_grumpy.append(avg(mem_grumpy) / ceil(sqrt(p)))
print(f"Finished: {bits}\n")
print(
f"Avg steps clasic:{avg(total_steps_class_list):.4f} -- Avg steps grumpy:{avg(total_steps_grumpy_list):.4f}"
)
print(
f"Avg memory clasic:{avg(total_memory_clasic):.4f} -- Avg memory grumpy:{avg(total_memory_grumpy):.4f}"
)
print(
f"Avg time clasic:{avg(times_clasic_list):.4f} -- Avg time grumpy:{avg(times_grumpy_list):.4f}"
)
def test_pollard(numOfTests: int,
listOfBits: list,
contests: dict,
img_path: str,
rand_seeds=[0]):
import matplotlib.pyplot as plt
from matplotlib.lines import Line2D
from itertools import cycle
marker = cycle(rand.sample(Line2D.markers.keys(), len(contests)))
plt.tight_layout(pad=0.05)
times = [[[0 for _ in rand_seeds] for _ in contests] for _ in listOfBits]
times_avg = [[0 for _ in contests] for _ in listOfBits]
iterations = [[[0 for _ in rand_seeds] for _ in contests]
for _ in listOfBits]
iterations_avg = [[0 for _ in contests] for _ in listOfBits]
for ind_b, bits in enumerate(listOfBits):
print("Bits: ", bits)
tests = num_of_tests(bits, numOfTests)
print("Nr of tests: ", tests)
p_set = set()
print("Seed: ", end='')
for ind_s, seed in enumerate(rand_seeds):
rand.seed(seed)
print(seed, end=', ')
distinct_primes = number_of_distinct_primes(bits)
for _ in range(tests):
p, g, exp, h = logarithm_test_numbers(bits, safe=False)
p_iter = 0
while p in p_set and len(
p_set) < distinct_primes - 1 and p_iter < 10**2:
p, g, exp, h = logarithm_test_numbers(bits, safe=False)
p_iter += 1
p_set.add(p)
bit_seed = rand.randint(1, seed)
for ind_c, c in enumerate(contests):
t = timer()
x, iter = pollard_rho(g,
h,
p,
cycle=c[0],
func=c[1],
rand_seed=bit_seed)
if x != exp:
print("WRONG " + c[0] + " " + c[1])
times[ind_b][ind_c][ind_s] += (timer() - t) * 1000
iterations[ind_b][ind_c][ind_s] += iter
for ind_c, c in enumerate(contests):
iterations[ind_b][ind_c][ind_s] /= tests
times[ind_b][ind_c][ind_s] /= tests
print()
for ind_c, c in enumerate(contests):
iterations_avg[ind_b][ind_c] = avg(
iterations[ind_b][ind_c]) / ceil(sqrt(p))
times_avg[ind_b][ind_c] = avg(times[ind_b][ind_c])
print(
f"Cycle: {c[0]}, function: {c[1]}, itertions: {iterations_avg[ind_b][ind_c]:.4f}, time: {times_avg[ind_b][ind_c]:.3f}"
)
print()
plt.figure(0)
for ind_c, c in enumerate(contests):
the_times = [t[ind_c] for t in times_avg]
plt.plot(listOfBits,
the_times,
marker=next(marker),
label=c[0] + '_' + c[1])
plt.legend()
plt.ylabel("Milisecunde")
plt.xlabel("biti")
# plt.ticklabel_format(style='sci', axis='y', scilimits=(0, 0))
plt.yscale('log')
plt.savefig(img_path + '/pollard_time.png', bbox_inches='tight')
plt.figure(1)
print("The avg number of iterations: ", end='')
avgits = []
for ind_c, c in enumerate(contests):
the_iterations = [it[ind_c] for it in iterations_avg]
avg_c = avg(the_iterations)
print(c[0] + '-' + c[1] + f": {avg_c:.4f}", end=' ')
avgits.append(avg_c)
plt.plot(listOfBits,
the_iterations,
marker=next(marker),
label=c[0] + '_' + c[1])
plt.legend()
plt.ylabel("Iteratii")
plt.xlabel("biti")
# plt.ticklabel_format(style='sci', axis='y', scilimits=(0, 0))
plt.yscale('log')
plt.savefig(img_path + '/pollard_iter.png', bbox_inches='tight')
plt.show()
return avgits
def test_pollard_dellays(numOfTests: int,
listOfBits: list,
contests: dict,
img_path: str,
rand_seeds=[0]):
iterations = [[[0 for _ in rand_seeds] for _ in contests]
for _ in listOfBits]
iterations_avg = [[0 for _ in contests] for _ in listOfBits]
lambs = [[[0 for _ in rand_seeds] for _ in contests] for _ in listOfBits]
lambs_avg = [[0 for _ in contests] for _ in listOfBits]
mus = [[[0 for _ in rand_seeds] for _ in contests] for _ in listOfBits]
mus_avg = [[0 for _ in contests] for _ in listOfBits]
for ind_b, bits in enumerate(listOfBits):
print("Bits: ", bits)
tests = num_of_tests(bits, numOfTests)
print("Nr of tests: ", tests)
p_set = set()
print("Seed: ", end='')
for ind_s, seed in enumerate(rand_seeds):
rand.seed(seed)
print(seed, end=', ')
distinct_primes = number_of_distinct_primes(bits)
for _ in range(tests):
p, g, exp, h = logarithm_test_numbers(bits, safe=False)
p_iter = 0
while p in p_set and len(
p_set) < distinct_primes - 1 and p_iter < 10**2:
p, g, exp, h = logarithm_test_numbers(bits, safe=False)
p_iter += 1
p_set.add(p)
bit_seed = rand.randint(1, seed)
for ind_c, c in enumerate(contests):
x, iter, lamb, mu = pollard_rho(g,
h,
p,
cycle=c[0],
func=c[1],
rand_seed=bit_seed)
if x != exp:
print("WRONG " + c[0] + " " + c[1])
iterations[ind_b][ind_c][ind_s] += iter
lambs[ind_b][ind_c][ind_s] += lamb
mus[ind_b][ind_c][ind_s] += mu
for ind_c, c in enumerate(contests):
iterations[ind_b][ind_c][ind_s] /= tests
lambs[ind_b][ind_c][ind_s] /= tests
mus[ind_b][ind_c][ind_s] /= tests
print()
for ind_c, c in enumerate(contests):
iterations_avg[ind_b][ind_c] = avg(
iterations[ind_b][ind_c]) / ceil(sqrt(p))
lambs_avg[ind_b][ind_c] = avg(lambs[ind_b][ind_c]) / ceil(sqrt(p))
mus_avg[ind_b][ind_c] = avg(mus[ind_b][ind_c]) / ceil(sqrt(p))
print(
f"Cycle: {c[0]}, function: {c[1]}, itertions: {iterations_avg[ind_b][ind_c]:.4f}, lambs: {lambs_avg[ind_b][ind_c]:.4f} mus: {mus_avg[ind_b][ind_c]:.4f}, "
f"rho: {lambs_avg[ind_b][ind_c] + mus_avg[ind_b][ind_c]:.4f} delay: {iterations_avg[ind_b][ind_c]/(lambs_avg[ind_b][ind_c] + mus_avg[ind_b][ind_c]):.4f}"
)
print()
for ind_c, c in enumerate(contests):
the_iterations = avg([it[ind_c] for it in iterations_avg])
the_lambs = [lamb[ind_c] for lamb in lambs_avg]
the_mus = [mu[ind_c] for mu in mus_avg]
the_rhos = avg([x + y for x, y in zip(the_lambs, the_mus)])
print(
f"Cycle: {c[0]}, function: {c[1]}, itertions_avg: {the_iterations:.4f}, rho: {the_rhos:.4f}, delays {the_iterations/the_rhos:.4f}"
)
def test_qe_solver(listOfBits: list,
numOfTests: int,
contests: list,
rand_seeds=[0]):
n = len(contests)
times = [[[0 for _ in rand_seeds] for _ in range(n)] for _ in listOfBits]
# iterations = [[[0 for _ in rand_seeds] for _ in range(n)] for _ in listOfBits]
# iterations_avg = [[0 for _ in range(n)] for _ in listOfBits]
times_avg = [[0 for _ in range(n)] for _ in listOfBits]
for ind_b, bits in enumerate(listOfBits):
tests = num_of_tests(bits, numOfTests)
p_set = set()
print("\nStarted bits: ", bits)
print("Number of tests: ", tests)
print("Seeds:", end=' ')
for ind_s, s in enumerate(rand_seeds):
print(s, end=', ')
seed(s)
i = 0
distinct_primes = number_of_distinct_primes(bits)
last_sum = 0
while i < tests:
p, g, exp, h = logarithm_test_numbers(bits, safe=False)
p_iter = 0
while (p in p_set or ceil(sqrt(p)) > 30000000
) and len(p_set) < distinct_primes and p_iter < 10**2:
p, g, exp, h = logarithm_test_numbers(bits, safe=False)
p_iter += 1
p_set.add(p)
bit_seed = randint(1, s)
for ind_c, c in enumerate(contests):
if c[0] == 'shoup':
qeAlg = partial(shoup_alg)
else:
qeAlg = partial(pohlig_hellman_alg)
if c[1] == 'shanks':
Solver = partial(Shanks, type=c[2], r=2.25)
else:
Solver = partial(pollard_rho,
cycle=c[2],
func=c[3],
rand_seed=bit_seed)
t = timer()
x = silver_pohlig_hellman_alg(g,
h,
p,
fact=factorint,
qeAlg=qeAlg,
solver=Solver)
if x != exp:
print("WRONG " + c[0] + " " + c[1] + ' ' + c[2] + ' ' +
c[3])
times[ind_b][ind_c][ind_s] += (timer() - t) * 1000
# iterations[ind_b][ind_c][ind_s] += iter
i += 1
for ind_c, c in enumerate(contests):
# iterations[ind_b][ind_c][ind_s] /= tests * ceil(sqrt(p))
times[ind_b][ind_c][ind_s] /= tests
print()
for ind_c, c in enumerate(contests):
# iterations_avg[ind_b][ind_c] = avg([it for it in iterations[ind_b][ind_c]]) {iterations_avg[ind_b][ind_c]:.4f},
times_avg[ind_b][ind_c] = avg([it for it in times[ind_b][ind_c]])
print(
f"Qe_alg: {c[0]}, solver: {c[1]}: type: {c[2]}, function: {c[3]}, time: {times_avg[ind_b][ind_c]:.3f}"
)
def test_shanks_vs_pollard(numOfTests: int,
listOfBits: list,
contests: list,
rand_seeds=[0]):
n = len(contests) + 2
times = [[[0 for _ in rand_seeds] for _ in range(n)] for _ in listOfBits]
iterations = [[[0 for _ in rand_seeds] for _ in range(n)]
for _ in listOfBits]
iterations_avg = [[0 for _ in range(n)] for _ in listOfBits]
times_avg = [[0 for _ in range(n)] for _ in listOfBits]
for ind_b, bits in enumerate(listOfBits):
tests = num_of_tests(bits, numOfTests)
p_set = set()
print("\nStarted bits: ", bits)
print("Number of tests: ", tests)
print("Seeds:", end=' ')
for ind_s, s in enumerate(rand_seeds):
print(s, end=',\n')
seed(s)
i = 0
distinct_primes = number_of_distinct_primes(bits)
last_sum = 0
while i < tests:
p, g, exp, h = logarithm_test_numbers(bits, safe=False)
p_iter = 0
while (p in p_set or ceil(sqrt(p)) > 30000000
) and len(p_set) < distinct_primes and p_iter < 10**2:
p, g, exp, h = logarithm_test_numbers(bits, safe=False)
p_iter += 1
p_set.add(p)
bit_seed = randint(1, s)
print(f"sqrt(p): {ceil(sqrt(p))}")
t = timer()
x, iter = poll.pollard_simple(g, h, p, rand_seed=bit_seed)
if x != exp:
if x == None:
continue
print("WRONG Pollard simplu")
times[ind_b][n - 2][ind_s] += (timer() - t) * 1000
iterations[ind_b][n - 2][ind_s] += iter
# print("Poll simplu Done!:", (timer() - t) * 1000)
t = timer()
x, sm, gs, _ = shanks.shanks_classic(g, h, p, p - 1)
if x != exp:
if x == None:
continue
print("WRONG Shanks clasic")
times[ind_b][n - 1][ind_s] += (timer() - t) * 1000
iterations[ind_b][n - 1][ind_s] += sm + gs
# print("Shanks Done!", (timer() - t) * 1000)
for ind_c, c in enumerate(contests):
t = timer()
x, iter = poll.pollard_rho(g,
h,
p,
cycle=c[0],
func=c[1],
rand_seed=bit_seed)
if x != exp:
print("WRONG " + c[0] + " " + c[1])
times[ind_b][ind_c][ind_s] += (timer() - t) * 1000
iterations[ind_b][ind_c][ind_s] += iter
new_sum = sum([t[0] for t in times[ind_b][:]])
print(f"Test {i} done, time: {new_sum - last_sum:.4f}")
last_sum = new_sum
i += 1
# t = timer()
# x, op, _ = shanks.shanks_two_grumpys_one_baby(g, h, p, p - 1)
# if x != exp:
# print("WRONG Shanks clasic")
# times[ind_b][n - 1][ind_s] += (timer() - t) * 1000
# iterations[ind_b][n - 1][ind_s] += op
for ind_c, c in enumerate(contests):
iterations[ind_b][ind_c][ind_s] /= tests * ceil(sqrt(p))
times[ind_b][ind_c][ind_s] /= tests
iterations[ind_b][n - 2][ind_s] /= tests * ceil(sqrt(p))
times[ind_b][n - 2][ind_s] /= tests
iterations[ind_b][n - 1][ind_s] /= tests * ceil(sqrt(p))
times[ind_b][n - 1][ind_s] /= tests
# iterations[ind_b][n - 1][ind_s] /= tests * ceil(sqrt(p)); times[ind_b][n - 1][ind_s] /= tests
print()
for ind_c, c in enumerate(contests):
iterations_avg[ind_b][ind_c] = avg(
[it for it in iterations[ind_b][ind_c]])
times_avg[ind_b][ind_c] = avg([it for it in times[ind_b][ind_c]])
print(
f"Cycle: {c[0]}, function: {c[1]}: itertions: {iterations_avg[ind_b][ind_c]:.4f}, time: {times_avg[ind_b][ind_c]:.3f}"
)
iterations_avg[ind_b][n - 2] = avg(
[it for it in iterations[ind_b][n - 2]])
times_avg[ind_b][n - 2] = avg([it for it in times[ind_b][n - 2]])
print(
f"Pollard simple: itertions: {iterations_avg[ind_b][n - 2] :.4f}, time: {times_avg[ind_b][n - 2]:.3f}"
)
iterations_avg[ind_b][n - 1] = avg(
[it for it in iterations[ind_b][n - 1]])
times_avg[ind_b][n - 1] = avg([it for it in times[ind_b][n - 1]])
print(
f"Shanks clasic: itertions: {iterations_avg[ind_b][n - 1] :.4f}, time: {times_avg[ind_b][n - 1]:.3f}"
)
# iterations_avg[ind_b][n - 1] = avg([it for it in iterations[ind_b][n - 1]])
# times_avg[ind_b][n - 1] = avg([it for it in times[ind_b][n - 1]])
# print(f"Two giants: itertions: {iterations_avg[ind_b][n - 1]:.4f}, time: {times_avg[ind_b][n - 1]:.3f}")
print("Finished bits: ", bits)
print("\nThe avg number of iterations: ", end='')
avgits = []
for ind_c, c in enumerate(contests):
avg_c = avg([it[ind_c] for it in iterations_avg])
print(c[0] + '-' + c[1] + f": {avg_c:.4f}", end=' ')
avgits.append(avg_c)
avg_c = avg([it[n - 2] for it in iterations_avg])
print(f"pollard simple: {avg_c:.4f}", end=', ')
avg_c = avg([it[n - 1] for it in iterations_avg])
print(f"shanks clasic: {avg_c:.4f}", end=', ')
# avg_c = avg([it[n - 1] for it in iterations_avg])
# print(f"two giants: {avg_c:.4f}", end=' .')
return iterations_avg
# def test_shanks_vs_pollard(numOfTests: int, listOfBits: list, contests: dict, rand_seeds = [0]):
# n = len(contests) + 2
# times = [[[0 for _ in rand_seeds] for _ in range(n)] for _ in listOfBits]
# iterations = [[[0 for _ in rand_seeds] for _ in range(n)] for _ in listOfBits]
# iterations_avg = [[0 for _ in range(n)] for _ in listOfBits]
# times_avg = [[0 for _ in range(n)] for _ in listOfBits]
# for ind_b, bits in enumerate(listOfBits):
# tests = num_of_tests(bits, numOfTests)
# p_set = set()
# print("\nStarted bits: ", bits)
# print("Seeds:", end = ' ')
# for ind_s, s in enumerate(rand_seeds):
# print(s, end=', ')
# seed(s)
# i = 0
# distinct_primes = number_of_distinct_primes(bits)
# while i < tests:
# p, g, exp, h = logarithm_test_numbers(bits, safe=False)
# p_iter = 0
# while (p in p_set or ceil(sqrt(p)) > 30000000) and len(p_set) < distinct_primes and p_iter < 10**2:
# p, g, exp, h = logarithm_test_numbers(bits, safe=False)
# p_iter += 1
# p_set.add(p)
#
# bit_seed = randint(1, s)
# # print(f"sqrt(p): {ceil(sqrt(p))}")
#
# t = timer()
# x, iter = poll.pollard_simple(g, h, p, rand_seed=bit_seed)
# if x != exp:
# if x == None:
# continue
# print("WRONG Pollard simplu")
# times[ind_b][n - 2][ind_s] += (timer() - t) * 1000
# iterations[ind_b][n - 2][ind_s] += iter
# # print("Poll simplu Done!:", (timer() - t) * 1000)
#
# t = timer()
# x, sm, gs, _ = shanks.shanks_classic(g, h, p, p - 1)
# if x != exp:
# if x == None:
# continue
# print("WRONG Shanks clasic")
# times[ind_b][n - 1][ind_s] += (timer() - t) * 1000
# iterations[ind_b][n - 1][ind_s] += sm + gs
# # print("Shanks Done!", (timer() - t) * 1000)
#
#
# for ind_c, c in enumerate(contests):
# t = timer()
# x, iter = poll.pollard_rho(g, h, p, cycle=c[0], func=c[1], rand_seed=bit_seed)
# if x != exp:
# print("WRONG " + c[0] + " " + c[1])
# times[ind_b][ind_c][ind_s] += (timer() - t) * 1000
# iterations[ind_b][ind_c][ind_s] += iter
# # print("Polls done")
# i += 1
#
# # t = timer()
# # x, op, _ = shanks.shanks_two_grumpys_one_baby(g, h, p, p - 1)
# # if x != exp:
# # print("WRONG Shanks clasic")
# # times[ind_b][n - 1][ind_s] += (timer() - t) * 1000
# # iterations[ind_b][n - 1][ind_s] += op
#
# for ind_c, c in enumerate(contests):
# iterations[ind_b][ind_c][ind_s] /= tests * ceil(sqrt(p))
# times[ind_b][ind_c][ind_s] /= tests
# iterations[ind_b][n - 2][ind_s] /= tests * ceil(sqrt(p)); times[ind_b][n - 2][ind_s] /= tests
# iterations[ind_b][n - 1][ind_s] /= tests * ceil(sqrt(p)); times[ind_b][n - 1][ind_s] /= tests
# # iterations[ind_b][n - 1][ind_s] /= tests * ceil(sqrt(p)); times[ind_b][n - 1][ind_s] /= tests
# print()
# for ind_c, c in enumerate(contests):
# iterations_avg[ind_b][ind_c] = avg([it for it in iterations[ind_b][ind_c]])
# times_avg[ind_b][ind_c] = avg([it for it in times[ind_b][ind_c]])
# print(f"Cycle: {c[0]}, function: {c[1]}: itertions: {iterations_avg[ind_b][ind_c]:.4f}, time: {times_avg[ind_b][ind_c]:.3f}")
# iterations_avg[ind_b][n - 2] = avg([it for it in iterations[ind_b][n - 2]])
# times_avg[ind_b][n - 2] = avg([it for it in times[ind_b][n - 2]])
# print(f"Pollard simple: itertions: {iterations_avg[ind_b][n - 2] :.4f}, time: {times_avg[ind_b][n - 2]:.3f}")
# iterations_avg[ind_b][n - 1] = avg([it for it in iterations[ind_b][n - 1]])
# times_avg[ind_b][n - 1] = avg([it for it in times[ind_b][n - 1]])
# print(f"Shanks clasic: itertions: {iterations_avg[ind_b][n - 1] :.4f}, time: {times_avg[ind_b][n - 1]:.3f}")
# # iterations_avg[ind_b][n - 1] = avg([it for it in iterations[ind_b][n - 1]])
# # times_avg[ind_b][n - 1] = avg([it for it in times[ind_b][n - 1]])
# # print(f"Two giants: itertions: {iterations_avg[ind_b][n - 1]:.4f}, time: {times_avg[ind_b][n - 1]:.3f}")
#
# print("Finished bits: ", bits)
#
# print("\nThe avg number of iterations: ", end='');
# avgits = []
# for ind_c, c in enumerate(contests):
# avg_c = avg([it[ind_c] for it in iterations_avg])
# print(c[0] + '-' + c[1] + f": {avg_c:.4f}", end=' ')
# avgits.append(avg_c)
# avg_c = avg([it[n - 2] for it in iterations_avg])
# print(f"pollard simple: {avg_c:.4f}", end=', ')
# avg_c = avg([it[n - 1] for it in iterations_avg])
# print(f"shanks clasic: {avg_c:.4f}", end=', ')
# # avg_c = avg([it[n - 1] for it in iterations_avg])
# # print(f"two giants: {avg_c:.4f}", end=' .')
#
# return iterations_avg
# if __name__ == "__main__":
# numOfTests = 100
# bits = [15]
# seed(42)
# rand_seeds = sample(range(0, 5000), 1)
# contests = [('brent', 'pollard'), ('floyd', 'pollard'), ('teske', 'pollard')]
# iters = test_shanks_vs_pollard(numOfTests, bits, contests, rand_seeds)
def test_shanks_clasic_inter_grumpy(numOfTests: int,
numOfBits: list,
randSeeds=[0]):
total_steps_class_list, times_clasic_list, total_memory_clasic = [], [], []
total_steps_inter_list, times_inter_list, total_memory_inter = [], [], []
total_steps_grumpy_list, times_grumpy_list, total_memory_grumpy = [], [], []
for bits in numOfBits:
seed_steps_class_list, seed_times_clasic_list, seed_total_memory_clasic = [], [], []
seed_steps_inter_list, seed_times_inter_list, seed_total_memory_inter = [], [], []
seed_steps_grumpy_list, seed_times_grumpy_list, seed_total_memory_grumpy = [], [], []
print("Started: ", bits)
if bits >= 50:
numOfTests = 50
elif bits >= 40:
numOfTests = 100
elif bits >= 30:
numOfTests = 500
for s in randSeeds:
seed(s)
time_clas, time_inter, time_grumpy = [], [], []
steps_clas, steps_inter, steps_grumpy = [], [], []
mem_clas, mem_inter, mem_grumpy = [], [], []
for iter in range(numOfTests):
p, g, exp, h = gnp.logarithm_test_numbers(bits, False)
t = timer()
x_c, small_clas, giant_clas, mem_c = shanks_classic(
g, h, p, p - 1)
steps_clas.append(small_clas + giant_clas)
mem_clas.append(mem_c)
passed_time = (timer() - t) * 1000
time_clas.append(passed_time)
t = timer()
x_c, oper, mem_c = shanks_interleved(g, h, p, p - 1)
if x_c != exp:
print("NI")
steps_inter.append(oper)
mem_inter.append(mem_c)
passed_time = (timer() - t) * 1000
time_inter.append(passed_time)
t = timer()
x_c, oper, mem_c = shanks_two_grumpys_one_baby(g, h, p, p - 1)
if x_c != exp:
print("NG")
steps_grumpy.append(oper)
mem_grumpy.append(mem_c)
passed_time = (timer() - t) * 1000
time_grumpy.append(passed_time)
seed_steps_class_list.append(avg(steps_clas) / ceil(sqrt(p)))
seed_steps_inter_list.append(avg(steps_inter) / ceil(sqrt(p)))
seed_steps_grumpy_list.append(avg(steps_grumpy) / ceil(sqrt(p)))
seed_times_clasic_list.append(avg(time_clas))
seed_times_inter_list.append(avg(time_inter))
seed_times_grumpy_list.append(avg(time_grumpy))
seed_total_memory_clasic.append(avg(mem_clas) / ceil(sqrt(p)))
seed_total_memory_inter.append(avg(mem_inter) / ceil(sqrt(p)))
seed_total_memory_grumpy.append(avg(mem_grumpy) / ceil(sqrt(p)))
print(
f"Avg steps clasic:{avg(seed_steps_class_list):.4f} -- Avg steps inter:{avg(seed_steps_inter_list):.4f} -- Avg steps grumpy:{avg(seed_steps_grumpy_list):.4f}"
)
print(
f"Avg memory clasic:{avg(seed_total_memory_clasic):.4f} -- Avg memory inter:{avg(seed_total_memory_inter):.4f} -- Avg memory grumpy:{avg(seed_total_memory_grumpy):.4f}"
)
print(
f"Avg time clasic:{avg(seed_times_clasic_list):.4f} -- Avg time inter:{avg(seed_times_inter_list):.4f} -- Avg time grumpy:{avg(seed_times_grumpy_list):.4f}"
)
total_steps_class_list.append(avg(seed_steps_class_list))
total_steps_inter_list.append(avg(seed_steps_inter_list))
total_steps_grumpy_list.append(avg(seed_steps_grumpy_list))
times_clasic_list.append(avg(seed_times_clasic_list))
times_inter_list.append(avg(seed_times_inter_list))
times_grumpy_list.append(avg(seed_times_grumpy_list))
total_memory_clasic.append(avg(seed_total_memory_clasic))
total_memory_inter.append(avg(seed_total_memory_inter))
total_memory_grumpy.append(avg(seed_total_memory_grumpy))
print(f"Finished: {bits}\n")
print(
f"Avg steps clasic:{avg(total_steps_class_list):.4f} -- Avg steps inter:{avg(total_steps_inter_list):.4f} -- Avg steps grumpy:{avg(total_steps_grumpy_list):.4f}"
)
print(
f"Avg memory clasic:{avg(total_memory_clasic):.4f} -- Avg memory inter:{avg(total_memory_inter):.4f} -- Avg memory grumpy:{avg(total_memory_grumpy):.4f}"
)
print(
f"Avg time clasic:{avg(times_clasic_list):.4f} -- Avg time inter:{avg(times_inter_list):.4f} -- Avg time grumpy:{avg(times_grumpy_list):.4f}"
)
i = 0
ts, tts = [], []
its = []
seed(42)
for q in range(5):
for _ in range(500):
ok = 1
while ok:
ok = 0
p, g, exponent, h = logarithm_test_numbers(15, safe=False)
x = 2**ceil(log2(p - 1))
B = ceil(exp(1 / sqrt(2) * sqrt(log(x) * log(log(x)))) / 2)
# print(L(p), shanks_complex(p))
primesB = primes_up_to_B(B)
max_equations = primes_upto(B) + 5
# print(B, max_equations, p)
t = timer()
x, ta, it = SELD_lect11(g, h, p, B, max_equations, primesB, 42)
ts.append((timer() - t) * 1000)
its.append(it)
if x == exponent:
# print("DA")
i += 1
else:
if pow(g, x, p) != h:
print("Nu")
avg_ts = avg(ts)
tts.append(avg_ts)
print("\n", i, avg_ts)
print("\n", i, sum(its))
print(avg(tts))