def test(a, b):
div = utils.gcd(a, b)
a1 = a // div
b1 = b // div
a2_str = ''
b2_str = str(b)
has_common = False
for c in str(a):
if c != '0':
if c in str(b):
has_common = True
b2_str = b2_str.replace(c, '')
else:
a2_str += c
if not has_common or a2_str == '' or b2_str == '':
return False
a2 = int(a2_str)
b2 = int(b2_str)
if a2 == 0 or b2 == 0:
return False
div2 = utils.gcd(a2, b2)
a3 = a2 // div2
b3 = b2 // div2
return a1 == a3 and b1 == b3
def pollard_p_minus_one(n, b=5, m=13, a=2):
if b < 1:
raise Exception('B must be bigger than 1')
if b >= m:
raise Exception('B must be less than sqrt(n)')
if m >= b**2:
raise Exception('M must be less than B^2')
if m >= math.sqrt(n):
raise Exception('M must be less than sqrt(n)')
if a < 1:
raise Exception('a must be bigger than 1')
mb_primes = utils.primes(2, b)
primes_mul = reduce(operator.mul, mb_primes, 1)
b = (a**primes_mul) % n
q = utils.gcd(b - 1, n)
if q > 1:
return q, n // q
m_primes = utils.primes(b, m)
for m in m_primes:
fm = (b**(m - 1)) % n
gm = utils.gcd(fm, n)
if gm > 1:
return gm, n // gm
return math.nan, math.nan
def pollard_po(n, func=lambda x: x**2 + 1):
x = random.randint(1, n - 2)
y = 1
i = 1
stage = 2
while utils.gcd(n, x - y) == 1:
if i == stage:
y = x
stage *= 2
x = func(x) % n
i += 1
d = utils.gcd(n, x - y)
b = n // d
res = [d]
if not utils.is_prime(b):
b1, b2 = pollard_po(b)
res.append(b1)
if isinstance(b2, tuple):
res.append(b2[0])
res.append(b2[1])
else:
res.append(b2)
return res
res.append(b)
return res
def isprime(p):
q = p - 1
m = 0
while q & 1 == 0:
m += 1
q //= 2
s = q
r = 0
while r < miller_rabin_tests_count:
a = random.randint(2, p - 2)
while gcd(a, p) > 1:
a = random.randint(2, p - 2)
b = pow(a, s, p)
if b == 1:
continue
elif b == p - 1:
r += 1
continue
for l in range(1, m):
c = pow(a, s * pow(2, l), p)
if c == p - 1:
r += 1
break
else:
return False
return True
def __init__(self, hypervector=None, multiplier=None, modulus=None):
'''
Реализира кодирането на Merkle-Hellman,
използващо алгоритъма за раницата.
Конструкторът приема хипернарастващ вектор,
число, по което се умножават елементите му
и модул(последните две се използват за генериране на публичния ключ).
'''
# Ако тези стойности не са дадени, произволни ще бъдат автоматично генерирани.
if not multiplier:
for x in range(modulus):
if gcd(x, modulus) == 1:
self.multiplier = x
break
else:
self.multiplier = multiplier
self.private_key = hypervector
sum_vector = sum(hypervector)
self.modulus = modulus or randint(sum_vector + 1, sum_vector * 2)
if self.modulus < sum_vector:
print('''Внимание! Кодирането се извършва по модул,
по-малък от сумата на числата във хипернарастващия вектор!
Това **ще** доведе до грешки и е силно непрепоръчително!''')
self.public_key = [(element * multiplier) % modulus
for element in hypervector]
def __init__(self, hypervector = None, multiplier = None, modulus = None):
'''
Реализира кодирането на Merkle-Hellman,
използващо алгоритъма за раницата.
Конструкторът приема хипернарастващ вектор,
число, по което се умножават елементите му
и модул(последните две се използват за генериране на публичния ключ).
'''
# Ако тези стойности не са дадени, произволни ще бъдат автоматично генерирани.
if not multiplier:
for x in range(modulus):
if gcd(x, modulus) == 1:
self.multiplier = x
break
else:
self.multiplier = multiplier
self.private_key = hypervector
sum_vector = sum(hypervector)
self.modulus = modulus or randint(sum_vector + 1, sum_vector * 2)
if self.modulus < sum_vector:
print('''Внимание! Кодирането се извършва по модул,
по-малък от сумата на числата във хипернарастващия вектор!
Това **ще** доведе до грешки и е силно непрепоръчително!''')
self.public_key = [(element * multiplier) % modulus for element in hypervector]
def run():
"""
Solution: Since we are dealing with only 2 digit numbers,
a brute force search is not so bad.
"""
top, bottom = 1, 1
for d in xrange(10, 100):
for n in xrange(10, d):
# extract digits as strings
ns, ds = set(str(n)), set(str(d))
# we need exactly one overlap
if len(ds) is 1 or len(ns) is 1:
continue
# skip if there are no shared digits or if shared 0
common = ds.intersection(ns)
if len(common) is not 1 or str(0) in common:
continue
# compute the new fraction after removal of common digit
denominator = float("".join(ds.difference(common)))
if denominator < 1:
continue
numerator = float("".join(ns.difference(common)))
# compare it to the original fraction
a = float(n) / float(d)
b = numerator / denominator
if abs(a - b) < 0.000001:
top *= n
bottom *= d
return bottom / gcd(top, bottom)
def gen_relatively_prime(size):
q = gen_odd(size)
while utils.gcd(q, SMALL_PRIMES_PRODUCT) > 1 or q % 4 != 3:
q += 2
if not check_len(q, size):
q = gen_odd(size)
return q
def p33():
def check(no, de):
digit_in_de = {digit for digit in str(denominator)}
digit_in_no = {digit for digit in str(nominator)}
same_digit = digit_in_de.intersection(digit_in_no)
digit_in_de = digit_in_de - same_digit
digit_in_no = digit_in_no - same_digit
if "0" in same_digit or len(same_digit) != 1:
return False
if not digit_in_de or not digit_in_no or "0" in digit_in_de:
return False
if float(digit_in_no.pop()) / float(digit_in_de.pop()) == \
float(nominator) / float(denominator):
return True
target_de = 1
target_no = 1
for denominator in range(12, 100):
for nominator in range(11, denominator):
if not check(nominator, denominator):
continue
target_no *= nominator
target_de *= denominator
return target_de / gcd(target_de, target_no)
def gen_relatively_prime(size):
q = gen_odd_q(size)
while gcd(q, mul_small_primes) > 1 or q % 4 != 3:
q += 2
if not check_len(q, size):
q = gen_odd_q(size)
return q
def signing(self, message):
m = self.__encode_md5(message)
self.K = random.randint(1, self.q-1)
while gcd(self.K, self.q-1) != 1:
self.K = random.randint(1, self.q-1)
s1 = pow(self.a, self.K, self.q)
s2 = modinv(self.K, self.q-1)*(m - self.X*s1)%(self.q-1)
return s1, s2
def main():
min_dist = Fraction(3 / 7)
for d in range(2, 10**6 + 1):
n = ceil(d * 3 / 7) - 1
if gcd(n, d) == 1:
dist = Fraction(3, 7) - Fraction(n, d)
if dist < min_dist:
min_dist = dist
closest_fraction = Fraction(n, d)
print(closest_fraction.numerator)
def remove(x,y):
if(inv[x][y] == 0):
#if(x<len(inv)-1):
# inv[x], inv[x+1] = inv[x+1].copy(), inv[x].copy()
#print inv
return
GCD = gcd(inv[x][y], inv[y][y])
LCM = inv[x][y]*inv[y][y]/GCD
a = LCM / inv[x][y]
b = LCM / inv[y][y]
inv[x] = inv[x]*a - inv[y]*b
def factorize_rho(n, verbose=False):
if n == 1 or utils.is_prime(n):
return n
# If no factor is found, return -1
for i in range(len(small_primes) - 1, -1, -1):
r, c, y = 1, small_primes[i], random.randint(1, n - 1)
if verbose:
print "Trying offset:", c
m, g, q, ys = random.randint(1, n - 1), 1, 1, y
min_val, k = 0, 0
while g == 1:
x, k = y, 0
for j in range(r):
y = y * y + c
if y > n: y %= n
while k < r and g == 1:
ys, min_val = y, min(m, r - k)
for j in range(min_val):
y = y * y + c
if y > n: y %= n
q = q * abs(x - y)
if q > n: q %= n
g = utils.gcd(q, n)
k += m
r <<= 1
if g == n:
# If no factor found, try again.
while True:
ys = ys * ys + c
if ys > n: ys %= n
g = utils.gcd(abs(x - ys), n)
if g > 1:
break
if g != n:
return g
else:
return -1
def D(N):
k = floor(N / e)
if k * log(N / k) < (k + 1) * log(N / (k + 1)):
k += 1
k //= gcd(N, k)
while k % 2 == 0:
k //= 2
while k % 5 == 0:
k //= 5
if k == 1:
return -N
return N
def original_solution():
"""runtime on mbp is: 31s, yikes. Solution based on #71
Want to just take 1/3 of the sequence length (calculated using #72), which is really close, but off by 4
"""
N = 12000
# from the data given, we know that we can do at least 2/5ths, use that as a starting point
start, end = (1.0/3.0), (1.0/2.0)
count = 0
for base in xrange(1, N+1):
for n in xrange(int(start*base), int(end * base)+1):
if start < (float(n) / base) < end and gcd(n, base) == 1:
count += 1
return count
def original_solution():
"""runtime on mbp is: 31s, yikes. Solution based on #71
Want to just take 1/3 of the sequence length (calculated using #72), which is really close, but off by 4
"""
N = 12000
# from the data given, we know that we can do at least 2/5ths, use that as a starting point
start, end = (1.0 / 3.0), (1.0 / 2.0)
count = 0
for base in xrange(1, N + 1):
for n in xrange(int(start * base), int(end * base) + 1):
if start < (float(n) / base) < end and gcd(n, base) == 1:
count += 1
return count
def main():
max_perimeter = 10**8
count = 0
for m in range(2, int((max_perimeter / 2)**0.5) + 1):
for n in range(m - 1, 0, -2):
if gcd(m, n) == 1:
a = m * m - n * n
b = 2 * m * n
c = m * m + n * n
c = (m + n) * (m + n) - b
if c % abs(b - a) == 0:
count += max_perimeter // (a + b + c)
print(count)
def p071():
LIMIT = 1000000
best_diff = 1.0/35
best_n = 0
for d in xrange(8,LIMIT+1):
n = d * 3 / 7
if gcd(n,d) == 1:
diff = 3.0/7.0 - n*1.0/d
if diff < best_diff:
best_diff = diff
best_n = n
return best_n
def factor(n=256961):
base = [-1] + [x for x in range(2, 32) if is_prime(x)]
start = int(n**.5)
pairs = []
for i in range(start, n):
for j in base:
if i**2 % n == j**2 % n:
pairs.append([i, j])
for i in pairs:
factor = gcd(i[0] - i[1], n)
if factor != 1:
return factor, n // factor
def mul_inv_int(self, num, mode = 'bezout'):
num = int_check_strict(num, ZN_ERR_MSG_NUM)
n = self.n
g = gcd(num, n)
if g > 1:
return ZN_ERR_MSG_INV.format(a = num, n = n, gcd = g)
if mode == 'bezout':
_, inv, _ = bezout(num % n, n)
return inv % n
elif mode == 'euler':
return self.pow_int(num, self.totient() - 1)
else:
raise ValueError
def optimized_solution():
"""optimized_solution took 638.455 ms"""
N = 1500*1000
sqrt_N = int(N**.5) + 1
wires = [0] * (N+1) # array = hash for ints. This saves about a second.
for m in xrange(1, sqrt_N):
start = 2 if (m & 1) else 1 # if m is even, n is odd, and vice versa
end = min(m, 1 + int(N / 2.0 / m) - m) # choose the end so that the max perimeter is <= N
for n in xrange(start, end, 2):
if gcd(n, m) == 1: # primitive
perimeter = 2*m*(m + n)
for p in xrange(perimeter, N+1, perimeter):
wires[p] += 1
return wires.count(1)
def main():
n_max = 10**12
total = 0
for a in range(2, floor(n_max**(1 / 3))):
for b in range(1, a):
if ((a % 2 == 1 or b % 2 == 1) and (a % 3 != 0 or b % 3 != 0)
and gcd(a, b) == 1):
c = 1
while True:
n = b * c * (a**3 * c + b)
if n > n_max:
break
if is_square(n):
total += n
c += 1
print(total)
def main():
print 'task 33'
prod_a = 0
prod_b = 0
for a in range(10, 99):
for b in range(a + 1, 100):
if test(a, b):
print '(%d)/(%d)' % (a, b)
if prod_a == 0:
prod_a = a
prod_b = b
else:
prod_a *= a
prod_b *= b
div = utils.gcd(prod_a, prod_b)
print (prod_b // div)
def compute_phi(n, sieve=None):
if n % 2 == 0:
if n / 2 % 2 == 0:
phi = 2 * cache[n / 2]
else:
phi = cache[n / 2]
elif sieve and sieve[n]:
phi = n - 1
else:
for a in xrange(2, int(math.sqrt(n)) + 1):
if n % a == 0:
b = n / a
c = gcd(a, b)
phi = cache[a] * cache[b] * c / cache[c]
break
cache[n] = phi
return phi
def skfunc(U, n):
if n == 0:
M = U.full()
v = np.array([[np.real(M[0, 0]), np.imag(M[0, 0]), np.real(M[1, 0]), np.imag(M[1, 0])]])
dist, index = tree['tree'].query(v, k=1)
name = tree['names'][index[0, 0]]
if name == '':
return gate.I
else:
basis = tree['basis']
return multiply([basis[int(x)] for x in name])
else:
U_next = skfunc(U, n - 1)
V, W = gcd(U * U_next.dag())
V_next = skfunc(V, n - 1)
W_next = skfunc(W, n - 1)
return V_next * W_next * V_next.dag() * W_next.dag() * U_next
def convergent(coeffs, N):
if N == 0:
return coeffs[0]
n, d = 0, 0
while N > 0:
c = coeffs[N]
if d is 0:
n = 1
d = c
else:
temp = n
n = d
d = temp + c * d
N -= 1
n = coeffs[0] * d + n
g = gcd(n, d)
return n / g, d / g
def M(n, k):
if gcd((pow(2, n, n) - 1) % n, n) == 1:
# if gcd((2**n-1)%n, n) is 1, then we are definitely already reduced!
# this is because gcd(2**n-1, (2**n-1)*(k-1)+n) == gcd(2**n-1,n) == gcd((2**n-1)%n, n)
pass
else:
# otherwise, I don't know how to guarantee that gcd((2**n-1)**2, (2**n-1)*(k-1)+n) == gcd(2**n-1, (2**n-1)*(k-1)+n),
# in which case things become messier since some factors of the latter could possibly be duplicated in the gcd.
# fortunately this doesn't happen for the input requested by PE. If it did, one possibility is to find the gcd
# gcd(2**n-1, n) with gcd(k-1, n) -- I haven't proved it but I think these factors would be replicated in both
# numerator and denominator.
raise Exception(
"we maybe need more heavy lifting because of the square in the denominator"
)
x = (pow(2, n, mod) - 1) % mod
numerator = pow(2, n - k, mod) * ((k - 1) * x % mod + n) % mod
denominator = pow(x, 2, mod) % mod
return numerator * denominator % mod
def count_quadrilaterals(m):
gcd_vals = np.zeros((m, m))
for i in range(m):
for j in range(m):
gcd_vals[i, j] = gcd(i + 1, j + 1)
count = 0
for a in range(1, m + 1):
for b in range(1, m + 1):
for c in range(1, m + 1):
for d in range(1, m + 1):
area_term = a * b + b * c + c * d + d * a
edge_term = (gcd_vals[a - 1, b - 1] +
gcd_vals[b - 1, c - 1] +
gcd_vals[c - 1, d - 1] +
gcd_vals[d - 1, a - 1])
count += is_square((area_term - edge_term) // 2 + 1)
return count
def original_solution():
"""runtime on mbp is 93ms.
This is another case (I'm looking at you, #70) of decreasing runtime by looking
where the answer is and returning. Searching the whole space takes considerably longer.
"""
N = 1000*1000
# from the data given, we know that we can do at least 2/5ths, use that as a starting point
frac, best, three_sevenths = .4, 2, (3.0/7.0)
for base in xrange(N, N-10, -1): # I bet we'll find it within 10 loops
for n in xrange(int(frac*base), int(three_sevenths * base)):
if frac < (float(n)/base) and gcd(n, base) == 1:
best = n
frac = float(n) / base
#print "best: (%d / %d) " % (n, base)
return best
def euclid_pythagorean_triple():
return_type = namedtuple('Data', 'abc a b c')
primes = prime_factors(500)
all_combinations = set([1]) # Not returned as a prime
for i in range(1, len(primes) + 1):
all_combinations.update(
[product(tuple_) for tuple_ in combinations(primes, i)])
valid_set = sorted(all_combinations)
for k in valid_set:
for n, i in enumerate(valid_set):
for m in valid_set[i:]:
if gcd(m, n) == 1 and k * m * (m + n) == 500:
return return_type(k**3 * 2 * m * (m**4 - n**4),
k * (m**2 - n**2), 2 * m * n * k,
k * (m**2 + n**2))
def mul_inv(self, mode = 'bezout'):
"""
mode='bezout' or 'euler'
"""
n = self.n
a = self.reduced
g = gcd(a, n)
if g > 1:
return ZN_ERR_MSG_INV.format(a = self.original, n = n, gcd = g)
if mode == 'bezout':
_, inv, _ = bezout(a, n)
return ZnNumber(inv % n, n)
elif mode == 'euler':
return self ** (ZnNumber.totient(n) - 1)
else:
raise ValueError
def original_solution():
"""runtime on mbp is 93ms.
This is another case (I'm looking at you, #70) of decreasing runtime by looking
where the answer is and returning. Searching the whole space takes considerably longer.
"""
N = 1000 * 1000
# from the data given, we know that we can do at least 2/5ths, use that as a starting point
frac, best, three_sevenths = .4, 2, (3.0 / 7.0)
for base in xrange(N, N - 10, -1): # I bet we'll find it within 10 loops
for n in xrange(int(frac * base), int(three_sevenths * base)):
if frac < (float(n) / base) and gcd(n, base) == 1:
best = n
frac = float(n) / base
#print "best: (%d / %d) " % (n, base)
return best
def legendre(a, p):
"""
источник: Маховенко Е.Б. 'Теоретическая криптография', стр. 83
:return: значение символа Лежандра (1, -1, 0)
"""
a %= p
if a % p == 0:
return 0
if utils.gcd(a, p) != 1:
raise ArithmeticError(
'Символ Лежандра имеет смысл для взаимно простых a и p')
q = pow(a, (p - 1) // 2, p)
if q == 1:
return 1
elif q == p - 1:
return -1
else:
raise ArithmeticError('Неверно вычислен символ Лежандра')
def GenRSA(n: int, tries=200, dictionary={}):
N, p, q = GenModulus(n, tries)
phi_n = (p - 1) * (q - 1)
e = random.randint(5000, 500_000)
# e = random.choice(PRIMES)
while gcd(e, phi_n) > 1:
e = random.randint(5000, 500_000)
# print(e, phi_n)
# input()
d = modInverse(e, phi_n)
dictionary['n'] = N
dictionary['e'] = e
dictionary['d'] = d
dictionary['p'] = p
dictionary['q'] = q
return N, e, d
def array_rotation(array=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
rotate_till_element=3):
# So take the gcd of Len. of array and elem.
# to rotate and make pairs, shift pairwise elements
pairs = gcd(len(array), rotate_till_element)
temp = array[0]
starting_posi = 0
while (rotate_till_element > 0):
temp = array[starting_posi]
num = starting_posi
try:
while num < len(array):
array[num] = array[num + pairs]
num += pairs
print(num)
except Exception as e:
array[num] = temp
starting_posi += 1
rotate_till_element -= 1
return array
def angled_below_diagonal(size):
count = 0
for x in xrange(1,size):
for y in xrange(1,x):
if gcd(x,y) > 1: continue
m1 = 1
while x*m1 <= size and y*m1 <= size:
p1x, p1y = x*m1, y*m1
m2 = 1
while p1x + m2*y <= size and p1y - m2*x >= 0:
count += 1
# print ((p1x, p1y, p1x+m2*y, p1y-m2*x))
m2 += 1
m2 = 1
while p1x - m2*y >= 0 and p1y + m2*x <= size:
count += 1
# print ((p1x, p1y, p1x-m2*y, p1y+m2*x))
m2 += 1
m1 += 1
return count
def run():
"""
Iterate through all denominators d, then descend through numerators n
less than 3d/7 until gcd(n,d) = 1 (reduced proper fraction). The largest
n / d fraction obtained in this fashion for some d is the answer we are
looking for.
Alternatively, just realize that 7 divides 999999 evenly so the answer
must be 999999 * 3/7 - 1. No other fraction with d < 1000000 is closer to
3/7 than this number.
"""
bn, bd = 0, 1
for d in xrange(8, 1000000):
n = int(3 * d / 7.0)
while gcd(n, d) > 1:
n -= 1
if n * bd > d * bn:
bn = n
bd = d
return bn
def main(): print 'Task 71' closest = 2.0 / 5 value = 3.0 / 7 min_dist = value - closest min_dist_nom = 0 for d in xrange(9, 1000001): if d % 100000 == 0: print d, min_dist_nom nom = int(d * value) cur_dist = value - float(nom) / d if cur_dist > min_dist: continue while utils.gcd(nom, d) != 1: nom -= 1 cur_dist = value - float(nom) / d if cur_dist < min_dist: min_dist = cur_dist min_dist_nom = nom print min_dist_nom
def generate_triples(total_length_limit):
triples = set()
max_m = int(math.sqrt((total_length_limit)//2))
for m in xrange(1, max_m+1):
if m % (max_m//100) == 0:
print "%d/%d" % (m, max_m)
max_n = (total_length_limit - 2 * m * m) // (2 * m)
max_n = min(max_n, m-1)
for n in xrange(1, max_n+1):
if not ((m+n) % 2):
continue
if gcd(m,n) > 1:
continue
b = m*m - n*n
if b < 1:
continue
a = 2*m*n
c = m*m + n*n
a,b,c = sorted([a,b,c])
if (a + b + c) <= total_length_limit:
triples.add((a,b,c))
return triples
def generate_triples(total_length_limit):
triples = set()
max_m = int(math.sqrt((total_length_limit)//2))
for m in xrange(1, max_m+1):
max_n = (total_length_limit - 2 * m * m) // (2 * m)
max_n = min(max_n, m-1)
for n in xrange(1, max_n+1):
if not ((m+n) % 2):
continue
if gcd(m,n) > 1:
continue
b = m*m - n*n
if b < 1:
continue
a = 2*m*n
c = m*m + n*n
a,b,c = sorted([a,b,c])
s = a + b + c
mult = 1
while mult * s <= total_length_limit:
triples.add((a*mult, b*mult, c*mult))
mult += 1
return triples
def original_solution():
""" original_solution took 2711.536 ms
The answer (original) is: 161667
"""
N = 1500*1000
sqrt_N = int(N**.5) + 1
wires = defaultdict(int)
# So, we're looking for all pythagorean triplets that sum to less than 1.5M
# use Euclid's formula: http://en.wikipedia.org/wiki/Pythagorean_triple
for m in xrange(1, sqrt_N):
for n in xrange(1, m):
if gcd(n, m) == 1 and (m+n)%2 == 1: # primitive
sides = m**2 - n**2, 2*m*n, m**2 + n**2
perimeter = sum(sides)
#print "(%d, %d): %s -> %d" % (m, n, sides, perimeter)
for p in xrange(perimeter, N+1, perimeter):
#print '\t', p
wires[p] += 1
count = 0
for p, n in wires.iteritems():
if n == 1:
count += 1
return count
def main():
N = 12 * 10**4
primes = list(get_primes_up_to_n(N))
@lru_cache(maxsize=None)
def rad(n):
ret = 1
for p in primes:
if p > n:
break
if n % p == 0:
ret *= p
n //= p
return ret
# Possible optimisation - compute radicals and primes simultaneously
rads = defaultdict(list)
for n in range(1, N):
rads[rad(n)].append(n)
rads = sorted((rad, lst) for rad, lst in rads.items())
total = 0
for c in range(2, N):
rad_c = rad(c)
if 2 * rad_c >= c:
continue
for rad_a, a_vals in rads:
if 2 * rad_a * rad_c >= c:
break
for a in a_vals:
if 2 * a > c:
break
if rad_a * rad(c - a) * rad_c < c and gcd(c - a, a) == 1:
total += c
print(total)
def isprime(prime):
"""
источник: Маховенко. "Теоретическая криптография", стр. 166, алгоритм 7.7.1
:param prime: проверяемое на простоту число
:return: True - p простое, False - p составное
"""
if prime & 1 == 0:
return False
q = prime - 1
m = 0
while q & 1 == 0:
m += 1
q //= 2
s = q
r = 0
while r < MR_TESTS:
a = random.randint(2, prime - 2)
while utils.gcd(a, prime) > 1:
a = random.randint(2, prime - 2)
b = pow(a, s, prime)
if b == 1:
continue
elif b == prime - 1:
r += 1
continue
for l in range(1, m):
c = pow(a, s * pow(2, l), prime)
if c == prime - 1:
r += 1
break
else:
return False
return True
def mod_mul(x, dim, N=None):
r"""Modular multiplication gate.
U = mod_mul(x, dim) N == prod(dim)
U = mod_mul(x, dim, N) gate dimension prod(dim) must be >= N
Returns the gate U, which, operating on the computational state
:math:`|y\rangle`, multiplies it by x (mod N):
:math:`U |y\rangle = |x*y (mod N)\rangle`.
x and N must be coprime for the operation to be reversible.
If N is given, U will act trivially on computational states >= N.
"""
# Ville Bergholm 2010-2011
if isscalar(dim): dim = (dim,) # scalar into a tuple
d = prod(dim)
if N == None:
N = d
elif d < N:
raise ValueError('Gate dimension must be >= N.')
if gcd(x, N) != 1:
raise ValueError('x and N must be coprime for the mul operation to be reversible.')
# NOTE: a real quantum computer would implement this gate using a
# sequence of reversible arithmetic gates but since we don't have
# one we might as well cheat
U = sparse.dok_matrix((d, d))
for y in range(N):
U[mod(x*y, N), y] = 1
# U acts trivially for states >= N
for y in range(N, d):
U[y, y] = 1
return lmap(U.tocsr(), (dim, dim))
def test_gcd_correctness():
assert_equal(utils.gcd(976, 1024), 16)
assert_equal(utils.gcd(125, 1024), 1)
assert_equal(utils.gcd(380, 1024), 4)
def simplify(n, d):
x = utils.gcd(n, d)
return n // x, d // x
# generate our pitches
anchor_pitches = [rr(-12, 12) for _ in range(5)]
pitch_range = (-24, 18)
pc_anneal = a.annealer(temp_f=lambda t: 1 - t,
energy_f=pc_energy(choice(anchor_pitches),
m.pitch_distance),
state_gen=pc_gen(choice(anchor_pitches), pitch_range[0],
pitch_range[1]),
accept_p=a.basic_acceptance)
pcs = collect_pcs(pc_anneal, 60, 100, 10)
print("pitches collected")
# get our durations
gcd = u.gcd(60, len(pcs))
flat_pcs = [p for pc_b in pcs for p in pc_b]
bucket_durs = u.gen_equal_partitions(60, len(pcs))
pcs = u.partition_equally(gcd, flat_pcs)
pos_pcs = [[((pc % 12) + 1.0) / 24.0 for pc in pc_b] for pc_b in pcs]
durs = [[(ceil(pc * (dur / sum(pc_b))), 8) for pc in pc_b]
for pc_b, dur in zip(pos_pcs, bucket_durs)]
print("durations generated")
# generate notes
notes_prime = [
deepcopy(note) for pc_coll, dur_coll in zip(pcs, durs)
for note in list(st.make_notes(pc_coll, dur_coll))
]
notes = [
u.multiply_by(choice([3]), n)
def Zps(N):
""" Returns Z_p^* """
return [n for n in range(0, N) if gcd(n, N) == 1]
import sys
sys.path.insert(0, '../common/')
import utils
def same():
for n in range(10,100):
for d in range(n+1, 100):
nd = str(n)
dd = str(d)
if nd[0] == dd[1] and int(nd[1]) * d == n * int(dd[0]):
yield n,d
if nd[1] == dd[0] and int(nd[0]) * d == n * int(dd[1]):
yield n,d
(n,d)=reduce(lambda (a,b),(d,c): (a*d,b*c), same(), (1,1))
print d/utils.gcd(n,d)
# generate our pitches
anchor_pitches = [rr(-12, 12) for _ in range(5)]
pitch_range = (-24, 18)
pc_anneal = a.annealer(temp_f=lambda t: 1 - t,
energy_f=pc_energy(choice(anchor_pitches),
m.pitch_distance),
state_gen=pc_gen(choice(anchor_pitches),
pitch_range[0],
pitch_range[1]),
accept_p=a.basic_acceptance)
pcs = collect_pcs(pc_anneal, 60, 100, 10)
print("pitches collected")
# get our durations
gcd = u.gcd(60, len(pcs))
flat_pcs = [p for pc_b in pcs for p in pc_b]
bucket_durs = u.gen_equal_partitions(60, len(pcs))
pcs = u.partition_equally(gcd, flat_pcs)
pos_pcs = [[((pc % 12) + 1.0) / 24.0 for pc in pc_b]
for pc_b in pcs]
durs = [[(ceil(pc * (dur / sum(pc_b))), 8) for pc in pc_b]
for pc_b, dur in zip(pos_pcs, bucket_durs)]
print("durations generated")
# generate notes
notes_prime = [deepcopy(note)
for pc_coll, dur_coll in zip(pcs, durs)
for note in list(st.make_notes(pc_coll, dur_coll))]
notes = [u.multiply_by(choice([3]), n)
if abs(random() - random()) < 0.2 and n.written_duration >= 0.125
def fracs_in_range(n):
count = 0
for i in range(n//3+1,(n//2)+n%2):
if gcd(i,n) == 1: count += 1
return count
#!/usr/bin/env python
from __future__ import division
from itertools import combinations
from utils import gcd
nrs = [(i, str(i)) for i in xrange(10, 100)]
pairs = ((0, 0), (0, 1), (1, 0), (1, 1))
pn = pd = 1
for (n, ns), (d, ds) in combinations(nrs, 2):
if n < d:
for i, j in pairs:
if ds[1 - j] != '0' and ns[i] == ds[j] \
and int(ns[1 - i]) / int(ds[1 - j]) == n / d \
and ns[1] != '0':
pn *= n
pd *= d
print '%d / %d == %s / %s' % (n, d, ns[1 - i], ds[1 - j])
g = gcd(pn, pd)
print 'product: %d / %d' % (pn/ g, pd / g)
print 'answer: %d' % (pd / g)
from utils import gcd
N = 3/7.
L = 1000000
mina = N
for b in range(L, L-7, -1):
a = N - int(b*N) * 1.0/b
if mina > a != 0: mina, minD = a,b
print "Answer to PE71 =", int(minD*N), "/", minD
print gcd(56*7, 78*7)
goal = 3.0/7
print goal
m_num = 4
m_den = 1
cmin = 200
for num in range(421262, 430000):
for den in range(989586, 1000000):
res = 1.0*num/den
if res < goal:
#print num, den, 1.0*num/den
if goal - res < cmin:
m_num = num
m_den = den
cmin = goal - res
break
print 'result:', m_num, m_den, 1.0*m_num/m_den
def outer_loop(params, x_f, filter_location, filter_estimation, simulation=None):
permute = np.empty(params.total_loops)
permute_b = np.empty(params.total_loops)
x_samp = []
# for i in xrange(params.total_loops):
# if i < params.location_loops:
# x_samp.append(np.zeros(params.B_location, dtype=np.complex128))
# else:
# x_samp.append(np.zeros(params.B_estimation, dtype=np.complex128))
hits_found = 0
hits = np.zeros(params.n)
scores = np.zeros(params.n)
# Inner loop
for i in xrange(params.total_loops):
a = 0
b = 0
# GCD test
# http://en.wikipedia.org/wiki/GCD_test
while utils.gcd(a, params.n) != 1:
a = np.random.randint(params.n)
# print 'check', a, params.n, utils.gcd(a, params.n)
ai = utils.mod_inverse(a, params.n)
permute[i] = ai
permute_b[i] = b
perform_location = i < params.location_loops
if perform_location:
current_filter = filter_location
current_B = params.B_location
else:
current_filter = filter_estimation
current_B = params.B_estimation
inner_loop_locate_result = inner_loop_locate(
x=x_f,
n=params.n,
filt=current_filter,
B=current_B,
B_threshold=params.B_threshold,
a=a,
ai=ai,
b=b
)
x_samp.append(inner_loop_locate_result['x_samp'])
# assert x_samp[i].shape == inner_loop_locate_result['x_samp'].shape
# print i, x_samp[i].shape, inner_loop_locate_result['x_samp'].shape
assert inner_loop_locate_result['J'].size == params.B_threshold
if perform_location:
inner_loop_filter_result = inner_loop_filter(
J=inner_loop_locate_result['J'],
B=current_B,
B_threshold=params.B_threshold,
loop_threshold=params.loop_threshold,
n=params.n,
a=a,
hits_found=hits_found,
hits=hits,
scores=scores
)
hits_found = inner_loop_filter_result['hits_found']
hits = inner_loop_filter_result['hits']
scores = inner_loop_filter_result['scores']
# print params.B_threshold, inner_loop_locate_result['J'][0], inner_loop_locate_result['J'][1], hits_found
print('Number of candidates: {0}'.format(hits_found))
# Estimate values
answers = estimate_values(
hits=hits,
hits_found=hits_found,
x_samp=x_samp,
loops=params.total_loops,
n=params.n,
permute=permute,
B_location=params.B_location,
B_estimation=params.B_estimation,
filter_location=filter_location,
filter_estimation=filter_estimation,
location_loops=params.location_loops
)
# Reconstructed signal
x_f = np.zeros(params.n)
for location, value in answers.iteritems():
print 'got', int(location), np.abs(value)
x_f[int(location)] = np.abs(value)
# Counts
xc = np.zeros(params.n)
for i in xrange(params.n):
xc[i] = scores[i] * 1./ params.total_loops
# debug
if simulation is not None:
fig = plt.figure()
ax = fig.gca()
ax.plot(
simulation.t, xc, '-x',
simulation.t, simulation.x_f * params.n, '-x',
simulation.t, x_f * params.n, '-.x',
)
ax.legend(
(
'counts',
'true signal',
'reconstruction'
)
)
ax.set_xlim(right=simulation.t.shape[-1]-1)
return {
'x_f': x_f,
'answers': answers
}
def test_gcd_correctness():
assert_equal(utils.gcd(976, 1024), 16)
assert_equal(utils.gcd(125, 1024), 1)
assert_equal(utils.gcd(380, 1024), 4)
def coprimes(n):
return [k for k in xrange(2, (n/2) +1) if gcd(k, n) == 1]
