def mert_theo_list_up_to_x(x, format):
mert_theo_list = [0]
# calculate prime_list, von_mang list, out side of loop,
# so that we do not need to calculate it every time.in the loop
if (format == 2):
von_mang_list = von_mang_upto(x)
else:
primes_list = get_prime_list(x)
print 'Before loop'
for n in range(2, x+1):
# format 1, log only
if(format == 1):
mert_item = mert_theo_1_log_x(n, primes_list)
# format 2, use von_mang
if(format == 2):
mert_item = mert_theo_1_using_von_mang(n, von_mang_list )
# format 3:
if(format == 3):
mert_item = mert_theo_2_sum_1_p(n, primes_list)
# format 4:
if(format == 4):
mert_item =mert_theo_3_prod_1_1_p_inv(n, primes_list)
mert_theo_list.append(mert_item)
return mert_theo_list
def verify_von_mang_as_sum_of_rama_sum(n, num_of_sum_terms = 1000):
vm_list = von_mang_upto(n)
# print 'test_1: vm_list', vm_list
sum_of_rama_sum_list=[]
for m in range(1, n + 1):
tmp = 0
for term in range(1, num_of_sum_terms + 1):
rama_sum = rama_sum_use_mobi(m, term)
# rama_sum = rama_sum_use_prim_unit_root(m, term)
# print rama_sum
tmp += rama_sum/float(term)
sum_of_rama_sum_list.append(tmp)
print 'verify_von_mang_as_sum_of_rama_sum, n = %d, num_of_sum_terms = %d'%(n, num_of_sum_terms )
print '-vm_list = ', -np.asarray(vm_list)
print 'sum_of_rama_sum_list = ', np.asarray(sum_of_rama_sum_list)
# diff = sum_of_rama_sum_list - (-vm_list) = sum_of_rama_sum_list + vm_list
diff = np.asarray(vm_list) + np.asarray(sum_of_rama_sum_list)
print 'Diff: sum_of_rama_sum_list - (-vm_list) = ', diff
print '================ verify_von_mang_as_sum_of_rama_sum: done !\n'
def cheby_fun_q_a_integer_use_saved_von_mang(n, q, a):
global g_cnt
global von_mang_list
global g_n
# only call von_mang_upto() once
if(g_cnt == 0):
von_mang_list = von_mang_upto(n)
g_cnt = 1
g_n = n
print '1st time calculate von_mang_list for n = %d, len(von_mang_list) = %d'%(n, len(von_mang_list) )
else:
assert(g_n == n)
assert(len(von_mang_list) == n)
print 'use existing von_mang_list for n = %d, len(von_mang_list) = %d, q = %d, a = %d'%(n, len(von_mang_list), q, a)
cheby_list=[]
# construct cheby_fun without consider averaging on jump of prime numbers
tmp_sum = 0
# Note, the range(0, n) will goes to n-1, which actually access von_mang_list[n-1], which is for
# von_mang for number n.
for i in range(1, n+1):
if ((i%q) == a):
tmp_sum = tmp_sum + von_mang_list[i - 1]
cheby_list.append(tmp_sum)
return cheby_list
def selb_formu_list_up_to_x(x, format, sample_rate=1):
selb_sum_list = []
sum_1st_part_list = []
sum_2nd_part_list = []
# calculate prime_list, von_mang list, cheby_list out side of loop,
# so that we do not need to calculate it every time.in the loop
if(format == 1):
primes_list = get_prime_list(x)
if ((format == 2) or (format == 3)):
von_mang_list = von_mang_upto(x)
if (format == 3):
cheby_list = cheby_fun_integer(x)
if(format == 4):
primes_list = get_prime_list(x)
primes_and_log_2d_list = get_primes_and_log_2d_list(primes_list)
print primes_and_log_2d_list
print 'Before loop, format = ', format
count = 0
for n in range(2, x+1, sample_rate):
# format 1, log only
if(format == 1):
selb_sum, sum_1st_part, sum_2nd_part = selb_formu_for_one_x_log_only(n, primes_list)
# format 2, use von_mang
if(format == 2):
# print n
selb_sum, sum_1st_part, sum_2nd_part = selb_formu_for_one_x_using_von_mang(n, von_mang_list )
# format 3: use cheby_fun
if(format == 3):
selb_sum, sum_1st_part, sum_2nd_part = selb_formu_for_one_x_using_cheby(n, von_mang_list, cheby_list )
# format 4, log only, formula is same as 1, with some speed optimization
if(format == 4):
selb_sum, sum_1st_part, sum_2nd_part = selb_formu_for_one_x_log_only_optimized(n, primes_and_log_2d_list)
# show some progress, print every 100 steps,
count += 1
if((count%100) == 0):
print 'Total = ', x, 'current n = ', n
# Save results
selb_sum_list.append(selb_sum)
sum_1st_part_list.append(sum_1st_part)
sum_2nd_part_list.append(sum_2nd_part)
return selb_sum_list, sum_1st_part_list, sum_2nd_part_list
def cheby_fun_integer(n):
von_mang_list = von_mang_upto(n)
cheby_list=[]
# construct cheby_fun without consider averaging on jump of prime numbers
tmp_sum = 0
# von_mang_list[] is for prime 1, 2, 3, ..., n
# von_mang_list[0] is for prime 1, von_mang_list[n-1] is for von_mang function(n)
for i in range(1, n+1):
tmp_sum = tmp_sum + von_mang_list[i-1]
cheby_list.append(tmp_sum)
return cheby_list
def cheby_fun_real(n, sampling_per_unit):
von_mang_list = von_mang_upto(n)
cheby_list=[]
cheby_ave_list =[]
assert(sampling_per_unit > 1)
# construct range_list
step = 1/float(sampling_per_unit)
# step = 0.1
# add step to n, to make sure that the largest number is n,
#
range_list = np.arange(0, n+step, step)
# construct cheby_fun without considering averaging on jump of prime numbers
tmp_sum = 0
for x in range_list:
x_int = int(x)
if(x_int <1):
tmp_sum = 0
else:
# Note, von_mang_list is defined for n =1, 2, 3, von_mang[0] is actual for number 1
if((x - x_int) == 0):
tmp_sum = tmp_sum + von_mang_list[x_int-1]
cheby_list.append(tmp_sum)
# construct cheby_fun considering averaging on jump of prime numbers
tmp_sum = 0
for x in range_list:
x_int = int(x)
if(x_int <1):
tmp_sum = 0
else:
if((x - x_int) == 0):
tmp_sum = tmp_sum + 0.5*(von_mang_list[x_int -2] + von_mang_list[x_int -1])
cheby_ave_list.append(tmp_sum)
assert(len(cheby_list) == len(cheby_ave_list))
assert(len(cheby_list) == len(range_list))
return cheby_list, cheby_ave_list, range_list
def cheby_fun_q_a_integer(n, q, a):
von_mang_list = von_mang_upto(n)
cheby_list=[]
# construct cheby_fun without consider averaging on jump of prime numbers
tmp_sum = 0
# Note, the range(0, n) will goes to n-1, which actually access von_mang_list[n-1], which is for
# von_mang for number n.
for i in range(1, n+1):
if ((i%q) == a):
tmp_sum = tmp_sum + von_mang_list[i - 1]
cheby_list.append(tmp_sum)
return cheby_list
def verify_hard_littlew_conj_for_twi_prim(x):
# fix h = 2
h = 2
von_mang_list = von_mang_upto(x+h)
lamda_n_lamda_n_h_sum_list = []
for i in range(1, x+1):
lamda_n_lamda_n_h_sum = 0
for n in range(1, i):
tmp = von_mang_list[n - 1]*von_mang_list[n + h - 1]
lamda_n_lamda_n_h_sum += tmp
# print h, von_mang_list[n - 1], von_mang_list[n + h - 1], tmp, lamda_n_lamda_n_h_sum
lamda_n_lamda_n_h_sum_list.append(lamda_n_lamda_n_h_sum)
return lamda_n_lamda_n_h_sum_list
def verify_hard_littlew_conj(x, h):
# if we fix h to 2, then, it will be verify_hard_littlew_conj_for_twi_prim(...)
von_mang_list = von_mang_upto(x+h)
lamda_n_lamda_n_h_sum_list = []
for i in range(1, x+1):
lamda_n_lamda_n_h_sum = 0
for n in range(1, i):
tmp = von_mang_list[n - 1]*von_mang_list[n + h - 1]
lamda_n_lamda_n_h_sum += tmp
# print h, von_mang_list[n - 1], von_mang_list[n + h - 1], tmp, lamda_n_lamda_n_h_sum
lamda_n_lamda_n_h_sum_list.append(lamda_n_lamda_n_h_sum)
last_num_vs_x = lamda_n_lamda_n_h_sum/float(x)
print 'h = ', h, ', x = ', x, ', last_num_vs_x = ', last_num_vs_x
return lamda_n_lamda_n_h_sum_list, last_num_vs_x
for i in range(5, 20):
von_mang_new = vaugh_iden_von_mang_3_parts_format(i, y, z, von_mang_list, mobi_list)
# print von_mang_new
diff_abs = np.absolute(von_mang_new - von_mang_list[i - 1])
assert(diff_abs < ALMOST_ZERO)
von_mang_list_new.append(von_mang_new)
print 'unit_test_vaugh_iden_von_mang_3_parts_format, start from 5, new von_mang_list: \n', np.asarray(von_mang_list_new)
# ===============================================================================
if __name__=='__main__':
np.set_printoptions(precision=4)
np.set_printoptions(suppress=True)
print mobi_list
unit_test_vaugh_iden_mobi_format_version()
von_mang_list = von_mang_upto(100)
#print 'old: von_mang_list', np.asarray(von_mang_list)
unit_test_vaugh_iden_von_mang_4_parts_format()
unit_test_vaugh_iden_von_mang_3_parts_format()
unit_fun_list = unit_fun(n)
constant_fun_list = constant_fun(n)
x_fun_list = x_fun(n)
log_x_fun_list = log_x_fun(n)
e_x_fun_list = e_x_fun(n) # value of this function is too large, we do not include in function list
unit_circle_fun_list = unit_circle_fun(n)
unit_circle_fun_arr = np.asarray(unit_circle_fun_list)
# mobi_fun
mobi_fun_list = mobi_list[:n]
# liouv_fun
liouvi_fun_list = liouvi_list[:n]
# von_mang_fun
von_mang_fun_list = von_mang_upto(n)
# get square of mobi_fun
mobi_square_fun_list = [0]*n
for i in range(n):
mobi_square_fun_list[i] = mobi_fun_list[i]*mobi_fun_list[i]
build_fun_list(unit_fun_list, 'unit')
build_fun_list(constant_fun_list, 'constant')
build_fun_list(x_fun_list, 'x')
build_fun_list(log_x_fun_list, 'log')
build_fun_list(unit_circle_fun_arr, 'unit circle')
build_fun_list(mobi_fun_list, 'mobi')
build_fun_list(liouvi_fun_list, 'liouvi')
build_fun_list(mobi_square_fun_list, 'mobi square')
build_fun_list(von_mang_fun_list, 'von mang')
