Example #1
0
File: 504.py Project: wxv/PyPE
def lattice(m):
    square_num = set(i**2 for i in range(int(20000**0.5)))

    # Precalculate triangle values
    tri_table = [[[0]*101 for i in range(101)] for j in range(101)]
    for a in range(101):
        for h in range(101):
            for c in range(101):
                A2 = (a+c)*h
                B = gcd(a, h) + gcd(h, c) + a + c
                tri_table[a][h][c] = (A2 - B)//2 + 1

    s = 0
    for a in range(1, m+1):
        for c in range(1, a+1):
            # Symmetry case counter
            rc = 2 if c!=a else 1 # a,c symmetry

            for b in range(1, a+1):
                rcb = 2*rc if b!=a else rc # a, b symmetry
                # Upper triangle + horizontal edge correction
                abc_ = tri_table[a][b][c] + a + c - 1

                for d in range(1, b+1):
                    if abc_ + tri_table[a][d][c] in square_num:
                        s += 2*rcb if d!=b else rcb # b,d symmetry

    return s
Example #2
0
def make_salt(digest):
    salt = (get_cation(digest),
            get_anion(digest))
    paren = [False, False]
    subscript = "₀ ₂₃₄₅₆₇₈₉"
    for sub in subscript:
        if sub in salt[0][1]:
            paren[0] = True
        if sub in salt[1][1]:
            paren[1] = True
    if sum(1 for c in salt[0][1] if c.isupper()) is not 1:
        paren[0] = True
    if sum(1 for c in salt[1][1] if c.isupper()) is not 1:
        paren[1] = True
    name = salt[0][0] + " " + salt[1][0]
    formula_parts = [salt[0][1], salt[1][1], salt[1][2], salt[0][2]]
    if paren[0]:
        formula_parts[0] = "(" + formula_parts[0] + ")"
    if paren[1]:
        formula_parts[1] = "(" + formula_parts[1] + ")"
    formula_parts[2] = formula_parts[2]//fractions.gcd(formula_parts[2],
                                                       formula_parts[3])
    formula_parts[3] = formula_parts[3]//fractions.gcd(formula_parts[2],
                                                       formula_parts[3])
    formula = ''.join([f for f in (formula_parts[0] +
                       subscript[formula_parts[2]] +
                       formula_parts[1] +
                       subscript[formula_parts[3]]) if not f == ' '])
    return (name,formula)
Example #3
0
File: keygen.py Project: ptmono/ppf
def keygen(N, public=None):
    ''' Generate public and private keys from primes up to N.

    Optionally, specify the public key exponent (65537 is popular choice).

        >>> pubkey, privkey = keygen(2**64)
        >>> msg = 123456789012345
        >>> coded = pow(msg, *pubkey)
        >>> plain = pow(coded, *privkey)
        >>> assert msg == plain

    '''
    # http://en.wikipedia.org/wiki/RSA
    prime1 = gen_prime(N)
    prime2 = gen_prime(N)
    composite = prime1 * prime2
    totient = (prime1 - 1) * (prime2 - 1)
    if public is None:
        while True:
            private = randrange(totient)
            if gcd(private, totient) == 1:
                break
        public = multinv(totient, private)
    else:
        private = multinv(totient, public)
    assert public * private % totient == gcd(public, totient) == gcd(private, totient) == 1
    assert pow(pow(1234567, public, composite), private, composite) == 1234567
    return KeyPair(Key(public, composite), Key(private, composite))
Example #4
0
def _lambda(P, other=None):
    if other:
        Q = other
        a = (Q.y - P.y) % P.curve.field
        b = Q.x - P.x

        aux = abs(a)
        d = gcd(aux, b)

        a /= d; b /= d
        a = (a + P.curve.field) % P.curve.field
        if (a % b != 0):
            b = invmod(b, P.curve.field)
            return a * b % P.curve.field

        return a / b
    else:
        a = (3*P.x*P.x + P.curve.A) % P.curve.field
        b = 2*P.y

        aux = abs(a)
        d = gcd(aux, b)

        a /= d; b /= d
        a = (a + P.curve.field) % P.curve.field
        if (a % b != 0):
            b = invmod(b, P.curve.field)
            return a * b % P.curve.field

        return a / b
Example #5
0
def factor(n, b1, b2, m, s):
    u = (s * s - 5) % n
    v = (4 * s) % n
    an = (pow(v - u, 3, n) * (3 * u + v)) % n
    ad = (4 * pow(u, 3) * v) % n
    q = Point(pow(u, 3, n), pow(v, 3, n))
    for p in sieve(b1):
        q = mul(pow(p, ilog(b1, p), n), q, an, ad, n)
    g = gcd(q.z, n)
    if 1 < g < n:
        return 1, g
    c = [Point(0, 0)] * (m + 1)
    b = [Point(0, 0)] * (m + 1)
    c[1] = double(q, an, ad, n)
    c[2] = double(c[1], an, ad, n)
    for i in xrange(1, m + 1):
        if i > 2:
            c[i] = add(c[i - 1], c[1], c[i - 2], n)
        b[i] = (c[i].x * c[i].z) % n
    g = 1
    t = mul(b1 - 1 - 2 * m, q, an, ad, n)
    r = mul(b1 - 1, q, an, ad, n)
    for i in xrange(b1 - 1, b2, 2 * m):
        a = (r.x * r.z) % n
        for p in primes(i + 2, i + 2 * m, m):
            d = (p - i) // 2
            g = (g * (((r.x - c[d].x) * (r.z + c[d].z)) - a + b[d])) % n
        r, t = add(r, c[m], t, n), r
    g = gcd(g, n)
    if 1 < g < n:
        return 2, g
    return "factorization failed"
Example #6
0
def generate_key_pair(size=512, number=2, rnd=random.SystemRandom, k=DEFAULT_ITERATION,
        primality_algorithm=None, strict_size=True, e=0x10001):
    primes = []
    lbda = 1
    bits = size // number + 1
    n = 1
    while len(primes) < number:
        if number - len(primes) == 1:
            bits = size - integer_bit_size(n) + 1
        prime = get_prime(bits, rnd, k, algorithm=primality_algorithm)
        if prime in primes:
            continue
        if e is not None and fractions.gcd(e, lbda) != 1:
            continue
        if strict_size and number - len(primes) == 1 and integer_bit_size(n*prime) != size:
            continue
        primes.append(prime)
        n *= prime
        lbda *= prime - 1
    if e is None:
        e = 0x10001
        while e < lbda:
            if fractions.gcd(e, lbda) == 1:
                break
            e += 2
    assert 3 <= e <= n-1
    public = keys.RsaPublicKey(n, e)
    private = keys.MultiPrimeRsaPrivateKey(primes, e, blind=True, rnd=rnd)
    return public, private
Example #7
0
def testCase(a, b, x, y):
    gcd1 = gcd(a, b)
    gcd2 = gcd(x, y)
    if gcd1 == gcd2:
        print("YES")
    else:
        print("NO")
Example #8
0
def solveTwo(e1, e2):

    (c,a,m) = e1
    (d,b,n) = e2

    if solveOne(c,a,m) == None:
        return None
    if solveOne(d,b,n) == None:
        return None

    if c!=1:
        a = solveOne(c,a,m)
        m//= gcd(c,m)
    if d!=1:
        b = solveOne(d,b,n)
        n//= gcd(d,n)


    g = gcd(m, n)
    newM = m // g
    newN = n // g
    
    if (a%g) != (b%g):
        return None

    buf = a
    x1 = (a - buf) // g
    x2 = (b - buf) // g

    ans = (x1 * (newM * inv(newN, newM)) + x2 * (newM * inv(newM, newN)) ) % (newM * newN)
    return (ans*g) + buf
Example #9
0
def rsa(p,q,k):

  t = time()              # we start the clock here
  rngs = deque()          # store the rngs for testing

  n = p*q
  phi = (p-1) * (q-1)

  e = (p-1)               # this block of code choses e so that gcd(e,phi)=1
  while ( gcd(e,phi) != 1):
    e = randint(2, phi-1)
	
  x_0 = (p-1)             # this block of code choses x_0 so that gcd(x_0,phi)=1
  while ( gcd(e,phi) != 1):
    x_0 = randint(2, phi-1)


  z=0 

  for a in range(k):      # here we generate k values
    x_0 = pow(x_0,e,n)
    rngs.append(x_0%2)

  t=time()-t
  print('--------')
  print('{0} bits generated with RSA'.format(k))
  print('Generating time: {0}'.format(t))
  
  sarray = stest(rngs)
  sarray.insert(0,t)
  
  return sarray
Example #10
0
def factor(n, b1, b2, m, s):
    u = (s*s - 5) % n
    v = (4 * s) % n
    an = (pow(v-u, 3) * (3*u + v)) % n
    ad = (4 * pow(u, 3) * v) % n
    q = pow(u, 3) % n, pow(v, 3) % n
    for p in sieve(b1):
        q = mul(pow(p, ilog(b1,p)), q, an, ad, n)
    g = gcd(q[1], n)
    if 1 < g < n: return 1, g
    c = [(0,0)] * (m+1)
    b = [(0,0)] * (m+1)
    c[1] = double(q, an, ad, n)
    c[2] = double(c[1], an, ad, n)
    for i in range(1, m+1):
        if i > 2:
            c[i] = add(c[i-1], c[1], c[i-2], n)
        b[i] = (c[i][0] * c[i][1]) % n
    g = 1
    t = mul(b1 - 1 - 2*m, q, an, ad, n)
    r = mul(b1 - 1, q, an, ad, n)
    for i in range(b1-1, b2, 2*m):
        a = (r[0] * r[1]) % n
        for p in primes(i+2, i+2*m, m):
            d = (p - i) / 2
            g = g * ( ( (r[0] - c[d][0])
                      * (r[1] + c[d][1]) )
                    - a + b[d]) % n
        r, t = add(r, c[m], t, n), r
    g = gcd(g, n)
    if 1 < g < n: return 2, g
    return "factorization failed"
Example #11
0
def brent(n):
  if n % 2 == 0:
    return 2
  y, c, m = randint(1, n-1), randint(1, n-1), randint(1, n-1)
  g, r, q = 1, 1, 1
  while g == 1:
    x = y
    for i in range(r):
      y = ( (y * y) % n + c ) % n
    k = 0
    while k < r and g == 1:
      ys = y
      for i in range(min(m, r-k)):
        y = ( (y * y) % n + c ) % n
        q =  q * ( abs(x - y)) % n
      g = gcd(q, n)
      k = k + m
    r = r*2
  if g == n:
    while True:
      ys = ((ys * ys) % n + c) % n
      g = gcd(abs(x - ys), n)
      if g > 1:
        break
  return int(g)
Example #12
0
    def rabin_miller_trial(num):
        """ Find factor based on the Rabin-Miller trial.

        :param num: a random "witness" of primality.

        :return: > 1 if composite, 1 if probably prime.
        """
        num = pow(num, remainder, prime)

        # For first iteration, 1 or -1 remainder implies prime
        if num == 1 or num == prime - 1:
            return 1
        else:
            gcd = fractions.gcd(num-1, prime)
            if gcd > 1:
                return gcd

        # For next iterations, -1 implies prime, 1 implies composite
        for _ in xrange(exponent):
            num = pow(num, 2, prime)
            if num == prime - 1:
                return 1
            else:
                gcd = fractions.gcd(num-1, prime)
                if gcd > 1:
                    return gcd

        # It is a composite, but could not find a factor
        return -1
Example #13
0
def prb(N):
    if N % 2 == 0:
        return 2
    (y, c, m) = (random.randint(1, N - 1), random.randint(1, N - 1),
                 random.randint(1, N - 1))
    (g, r, q) = (1, 1, 1)
    while g == 1:
        x = y
        for i in range(r):
            y = (y * y % N + c) % N
        k = 0
        while k < r and g == 1:
            ys = y
            for i in range(min(m, r - k)):
                y = (y * y % N + c) % N
                q = q * abs(x - y) % N
            g = fractions.gcd(q, N)
            k = k + m
        r = r * 2
    if g == N:
        while True:
            ys = (ys * ys % N + c) % N
            g = fractions.gcd(abs(x - ys), N)
            if g > 1:
                break
    return g
Example #14
0
File: hw5.py Project: TWaltze/CS235
def findCoprime(m):
	p = (3 * m // 4) + 3

	while gcd(p - 1, m) != 1:
		p = p * gcd(p - 1, m)

	return p - 1
def compute():
	SIZE = 18
	# possible[i] holds all the possible capacitance values of a series/parallel
	# capacitor network that uses exactly i capacitors of 60 uF each
	possible = []
	all = set()  # Union of every possible[i]
	# Note: Each fraction is represented as a pair (num, den), where den > 0 and gcd(num, den) = 1.
	# This approach is much faster than using the fractions.Fraction class.
	possible.append(set())
	possible.append({(60, 1)})
	all.update(possible[1])
	for i in range(2, SIZE + 1):
		poss = set()
		for j in range(1, i // 2 + 1):
			for (n0, d0) in possible[j]:
				for (n1, d1) in possible[i - j]:
					pseudosum = n0 * d1 + n1 * d0
					numerprod = n0 * n1
					denomprod = d0 * d1
					npgcd = fractions.gcd(pseudosum, numerprod)
					dpgcd = fractions.gcd(pseudosum, denomprod)
					poss.add((pseudosum // dpgcd, denomprod // dpgcd))  # Parallel
					poss.add((numerprod // npgcd, pseudosum // npgcd))  # Series
		possible.append(poss)
		all.update(poss)
	return str(len(all))
Example #16
0
def brent(N):
        if N%2==0:
                return 2
        y,c,m = random.randint(1, N-1),random.randint(1, N-1),random.randint(1, N-1)
        g,r,q = 1,1,1
        while g==1:             
                x = y
                for i in range(r):
                        y = ((y*y)%N+c)%N
                k = 0
                while (k<r and g==1):
                        ys = y
                        for i in range(min(m,r-k)):
                                y = ((y*y)%N+c)%N
                                q = q*(abs(x-y))%N
                        g = gcd(q,N)
                        k = k + m
                r = r*2
        if g==N:
                while True:
                        ys = ((ys*ys)%N+c)%N
                        g = gcd(abs(x-ys),N)
                        if g>1:
                                break
         
        return g
Example #17
0
def pollard_brent_find_factor(n, max_iter=None):
    """Perform Brent's variant of the Pollard rho factorisation
    algorithm to attempt to a non-trivial factor of the given number n.
    If max_iter > 0, return None if no factors were found within
    max_iter iterations.
    """
    y, c, m = (random.randint(1, n - 1) for _ in range(3))
    r, q, g = 1, 1, 1
    i = 0
    while g == 1:
        x = y
        for _ in range(r):
            y = pollard_brent_f(c, n, y)
        k = 0
        while k < r and g == 1:
            ys = y
            for _ in range(min(m, r - k)):
                y = pollard_brent_f(c, n, y)
                q = (q * abs(x - y)) % n
            g = gcd(q, n)
            k += m
        r *= 2
        if max_iter:
            i += 1
            if (i == max_iter):
                return None

    if g == n:
        while True:
            ys = pollard_brent_f(c, n, ys)
            g = gcd(abs(x - ys), n)
            if g > 1:
                break
    return g
Example #18
0
def next(a, b):
    a += b      # +1
    help = a    # invertieren
    a = b
    b = help  
    a += b      # +1
    return [a//fractions.gcd(a,b),b//fractions.gcd(a,b)] # kuerzen
Example #19
0
	def runTests(self):			
		# Checking if inputs satisfy conditions
		if not self.isPrime() :
			#print "Error: N is not prime!"
			return False
	
		if gcd(self.N,self.p) != 1 :
			#print "Error: gcd(N,p) is not 1"
			return False

		if gcd(self.N,self.q)!=1 :
			#print "Error: gcd(N,q) is not 1"
			return False
	
		if self.q<=(6*self.d+1)*self.p:
			#print "Error: q is not > (6*d+1)*p"
			return False
	
		if not poly.isTernary(self.f,self.d+1,self.d):
			#print "Error: f does not belong to T(d+1,d)"
			return False
		
		if not poly.isTernary(self.g,self.d,self.d):
			#print "Error: g does not belong to T(d,d)"
			return False
	
		return True		
def pe182():
    """
    Exact number of unconcealed messages: 
        (1 + gcd(e-1, p-1)) * (1 + gcd(e-1, p-1))
        
    (1009 - 1) * (3643 - 1) = 2^5 * 3^3 * 7 * 607
    Then e = 6 * k + 1 or 5, e % 7 != 0 and e % 607 != 0
    """
    
    from fractions import gcd

    p, q = 1009, 3643
    emin, edict = p * q, {}
    for k in xrange(611856):
        for e in (6 * k + 1, 6 * k + 5):
            if e % 7 and e % 607:
                u = (1 + gcd(e-1, p-1)) * (1 + gcd(e-1, q-1))
                emin = min(emin, u)
                if u in edict:
                    edict[u] += e
                else:
                    edict[u] = e
    
    # answer: 399788195976
    return edict[emin]
Example #21
0
	def is_prime(self, n):
		if n == 2:
			return True
		if n < 2:
			return False
		for a in range(2, self.isqrt(n) + 1):
			for b in range(2, n):
				t = a ** b
				if t == n:
					return False
				if t > n:
					break
		logn = math.log(n,2)
		logn2 = logn ** 2
		for r in IT.count(3):
			if fractions.gcd(r, n) == 1 and self.ordr(r, n) >= logn2:
				break
		for a in range(2, r + 1):
			if 1 < fractions.gcd(a, n) < n:
				return False
		if n <= r:
			return True
		for a in range(1, int(math.sqrt(self.phi(r)) * logn)):
			if not self.testan(a, n, r):
				return False
		return True
Example #22
0
 def __init__(self, numerator = 1, denominator = 1):
     '''
     
     >>> a = ratios.IntervalRatio(4,3)
     '''
     self.unreduced_num = Decimal(numerator)
     self.unreduced_den = Decimal(denominator)
     GCD = fractions.gcd(numerator, denominator)
     
     self.numerator = Decimal(numerator/GCD)
     self.denominator = Decimal(denominator/GCD)
     self.decimal = self.numerator/self.denominator
     octaveless = denominator
     octaves = 0
     while ((octaveless * 2) < numerator):
         octaveless = octaveless * 2
         octaves += 1
     octaveless_GCD = fractions.gcd(numerator, octaveless)
     self.octaveless_num = numerator/octaveless_GCD
     self.octaveless_den = octaveless/octaveless_GCD
     self.octaves = octaves
     self.octaveless_decimal = self.octaveless_num/self.octaveless_den
     self.ratio = str(self.numerator) + ":" + str(self.denominator)
     self.ratio_unreduced = str(self.unreduced_num) + ":" + str(self.unreduced_den)
     self.ratio_octaveless = str(self.octaveless_num) + ":" + str(self.octaveless_den)
Example #23
0
def brent(N):
    """Fast finding of a single factor"""
    if N % 2 == 0:
        return 2
    y, c, m = random.randint(1, N - 1), random.randint(1, N - 1), random.randint(1, N - 1)
    g, r, q = 1, 1, 1
    while g == 1:
        x = y
        for i in xrange(r):
            y = ((y * y) % N + c) % N
        k = 0
        while k < r and g == 1:
            ys = y
            for i in xrange(min(m, r - k)):
                y = ((y * y) % N + c) % N
                q = q * (abs(x - y)) % N
            g = gcd(q, N)
            k = k + m
        r *= 2
        if g == N:
            while True:
                ys = ((ys * ys) % N + c) % N
                g = gcd(abs(x - ys), N)
                if g > 1:
                    break

        return g
Example #24
0
def makechunks(dat, chunksize=0):
   Ny, Nx = np.shape(dat)
   
   if chunksize==0:
      # get optimal number of slices
      if Nx%2==0:
         H = []
         for k in xrange(2,50):
            H.append(gcd(Nx,Nx/k))
         hslice = np.max(H)
      else:
         dat = np.hstack( (dat,np.ones((Ny,1))) )
         Ny, Nx = np.shape(dat)
         H = []
         for k in xrange(2,50):
            H.append(gcd(Nx,Nx/k))
         hslice = np.max(H)
   
      # get windowed data
      Zt,ind = humutils.sliding_window(dat,(Ny,hslice))

   else:
      if chunksize>np.shape(data_port)[1]:
         Zt,ind = humutils.sliding_window(dat,(Ny,chunksize))
      else:
         print "Error: chunk size is larger than number of scan lines. Please choose smaller chunk size ... exiting"

   return Zt, ind
def solve_the_problem():
	a, b, n = [int(x) for x in input().split(' ')]

	turn = 0

	while True:
		remove_stones = 0
		if turn == 0:
			remove_stones = gcd(a, n)
		else:
			remove_stones = gcd(b, n)

		n -= remove_stones

		if n < 0:
			if turn == 0:
				print(1)
				return
			else:
				print(0)
				return
		
		if turn == 0:
			turn = 1
		else:
			turn = 0
Example #26
0
def gcds(nums):
    if len(nums) <= 1:
        return 0
    gcd = fractions.gcd(nums[0], nums[1])
    for n in nums:
        gcd = fractions.gcd(n, gcd)
    return gcd
Example #27
0
    def getMaxEarnings(self, fishCost, moveCost):
        # load all the yields
        self.createAllYields()
        y = self.level['yields']
        # maximum depth of movement (num moves)
        maxDepth = gamedef.TOTAL_TIME / fishCost
        # optimisation: use less memory by lowering time
        d = gcd(gamedef.TOTAL_TIME, gcd(moveCost, fishCost))
        t = gamedef.TOTAL_TIME / d
        fishC = fishCost / d
        moveC = moveCost / d
        # this gcd thing is a bit pretentious, since the rest
        # of the code assumes fishC is 1. gcd should better
        # be fishCost...

        # array of best values
        values = [[0 for i in range(maxDepth + 1)] for j in range(len(y))]

        # and now let's calculate benefits
        for pos in range(len(y)):
            # first element for every yield will stay 0,
            # as it means we did not fish there
            nfish = len(y[pos]) - pos * moveC
            nfish = 0 if nfish < 0 else nfish
            for i in range(nfish):
                val = y[pos][i]['value'] if None != y[pos][i] else 0
                values[pos][i+1] = values[pos][i] + val

        # perform a O(n*t*k^2) algorithm :(
        val, moves = opt(values, t, fishC, moveC)
        return val
def main():
	gcdwarning = "You chose an alpha%s value with no inverse.  This program cannot reverse the cipher."
	if len(sys.argv) < 3:
		print "Usage: python affine.py 'image' r-multiplier r-shift [g-m g-s b-m b-s]\n"
		print "If no g and b keys are given, the r key will apply to all three channels."
		print "Input the original key used to encrypt the image, not the inverse."
		return
	elif len(sys.argv) < 8:
		#Assume image, r key.
		if gcd(int(sys.argv[2]), 256) != 1:
			print gcdwarning % ('')
			return
		key = [(int(sys.argv[2]), int(sys.argv[3]))]*3
	else:
		#assume image, rgb key.
		if gcd(int(sys.argv[2]), 256) != 1:
			print gcdwarning % (' R')
			return
		if gcd(int(sys.argv[4]), 256) != 1:
			print gcdwarning % (' G')
			return
		if gcd(int(sys.argv[6]), 256) != 1:
			print gcdwarning % (' B')
			return
		key = [(naive_inverse(int(sys.argv[2])), int(sys.argv[3])),
				(naive_inverse(int(sys.argv[4])), int(sys.argv[5])),
				(naive_inverse(int(sys.argv[6])), int(sys.argv[7]))]
	img = deaffine(sys.argv[1], key)	
	img.show()
def coarse(hoc_filename,cube_length,save_filename):
	# INPUT: NEURON .hoc filename to import (str), voxel cube side length (fl/str for gcd), name of file to create for mesh output (str)
	# 		>> cube_length: 'gcd' (gcd of box dims) OR floating-point (must be common factor of all box dims)
	# This function reads in NEURON data and passes their info to
	# coarse_gen(), then associates the tets of the STEPS Tetmesh object returned
	# to the NEURON sections which exist inside of them. 
	# Returns a tet_hoc dictionary -- tet_hoc[tet_index] = [encapsulated hoc section references] -- as well as the Tetmesh object

	## GET HOC SECTION INFO ##
	h.load_file(hoc_filename)

	allp = [[],[],[]]
	for s in h.allsec():
		for j in range(int(h.n3d())):
			allp[0].append(h.x3d(j))
			allp[1].append(h.y3d(j))
			allp[2].append(h.z3d(j))

	maxl = [max(allp[0]),max(allp[1]),max(allp[2])]
	minl = [min(allp[0]),min(allp[1]),min(allp[2])]
	bdim = [ maxl[0] - minl[0], maxl[1] - minl[1], maxl[2] - minl[2] ]
	print "dims: ", bdim
	print "mins: ", minl

	## CREATE COARSE MESH ##
	if (cube_length == 'gcd'):
		gcd = fractions.gcd(fractions.gcd(bdim[0],bdim[1]),fractions.gcd(bdim[2],bdim[1]))
		print "GCD: ", gcd
		cube_length = gcd

	sm = coarse_gen(cube_length,bdim,minl,save_filename)

	## ASSOCIATE HOC SECTIONS WITH THEIR TETS ##
	tet_hoc = tet_associate(sm[0])
	return tet_hoc, sm[0]
def generating_keys(prime1,prime2):
    fie_function = (prime1-1)*(prime2-1)
    print("Fie Function: ",format(fie_function))

    N = prime1*prime2
    print("N: ",format(N))
    i =2
    encryption_key=0

    while i < fie_function and encryption_key ==0:
        if gcd(N,i) == 1 and gcd(fie_function,i) == 1:
                encryption_key=i
        i+=1
    print("Encryption Key: ",format(encryption_key))

    decryption_key = 0
    i = 1
    check = 'true'
    while check =='true':
        if (i*encryption_key)%fie_function ==1:
            decryption_key = i
            check = 'false'
        else:
            i+=1

    print("Decryption Key: ",format(decryption_key))

    return [fie_function,N,decryption_key,encryption_key]
Example #31
0
File: c.py Project: kp047i/AtCoder
from fractions import gcd


a, b, c, d = map(int, input().split())
lcm = int(c * d / gcd(c, d))
A = a - 1
l_cd = A - A // c - A // d + A // lcm
r_cd = b - b // c - b // d + b // lcm
print(r_cd - l_cd)
Example #32
0
from fractions import gcd

with open('A.in', 'r') as fin:
    lines = fin.readlines()

T = int(lines[0])

for i in range(1, T + 1):
    line = lines[i]
    bits = line.split()
    N = int(bits[0])
    PD = int(bits[1])
    PG = int(bits[2])
    Dgcd = gcd(PD, 100)
    Ddenom = 100 / Dgcd
    if Ddenom > N:
        #print "Ddenom > N"
        print "Case #{0}: Broken".format(i)
        continue
    Ggcd = gcd(PG, 100)
    WD = PD / Dgcd
    D = 100 / Dgcd
    WG = PG / Ggcd
    G = 100 / Ggcd
    #print "D:", D, "WD:", WD, "G:", G, "WG:", WG
    if PD == 100 and PG == 100:
        print "Case #{0}: Possible".format(i)
    elif PD == 0 and PG == 0:
        print "Case #{0}: Possible".format(i)
    elif PG == 100 or PG == 0:
        print "Case #{0}: Broken".format(i)
Example #33
0
def lcm(a, b):
    return a * b / gcd(a, b)
Example #34
0
def modInverse(a, m):
    g = gcd(a, m)
    if (g != 1):
        return -1
    else:
        return powerm(a, m - 2, m)
Example #35
0
def gcd(a, b):
    if (a == 0):
        return b
    return gcd(b % a, a)
Example #36
0
#!/usr/bin/python

from fractions import gcd
import time

start = time.clock()
bound = 120000

#generate list with radicals
radicals = [1 for _ in xrange(bound + 1)]

for i in xrange(2, bound + 1):
    if radicals[i] == 1:
        radicals[i] = i
        for j in xrange(i + i, bound + 1, i):
            radicals[j] *= i

tot = 0

for a in xrange(1, bound / 2 + 1):
    for b in xrange(a + 1, bound - a, 2 - a % 2):
        c = a + b
        if radicals[a] * radicals[b] * radicals[c] < c:
            if gcd(a, b) == 1:
                tot += c
                print a

print tot
print time.clock() - start
Example #37
0
from fractions import gcd, Fraction

m = Fraction(0, 1)

for i in range(2, 1000001):
    if i % 7 == 0: continue
    numerator = (3 * i) / 7
    if gcd(numerator, i) == 1 and Fraction(numerator, i) > m:
        m = Fraction(numerator, i)

print m
Example #38
0
def mgcd(*args):
    """Greatest common divisor that accepts multiple arguments."""
    return mgcd(args[0], mgcd(*args[1:])) if len(args) > 2 else gcd(*args)
Example #39
0
def result(n):
    lcm = 1
    for i in range(1, n + 1):
        lcm = (lcm * i)/fractions.gcd(lcm, i)
    
    return int(lcm)
Example #40
0
def GenVector(n):
    h = []
    for i in range(n):
        if fc.gcd(i, n) == 1:
            h.append(i)
    return h
Example #41
0
# -*- coding: utf-8 -*-
"""
Created on Sun May 22 15:51:04 2016

@author: qnl
"""
from __future__ import division
import numpy as np
import fractions

count = 0

for i in xrange(4, 12001):
    start = np.floor(i / 3) + 1
    end = np.ceil(i / 2) - 1
    for j in xrange(int(start), int(end) + 1):
        if fractions.gcd(i, j) == 1:
            count += 1

print count
Example #42
0
# encoding:utf-8
import copy
import random
import bisect #bisect_left これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math
import sys

mod = 10**9+7
sys.setrecursionlimit(mod) # 再帰回数上限はでdefault1000

N = int(input())
dp = [[0,0] for i in range(N)]
for i in range(N):
    a,b = map(int,input().split())
    if i == 0:
        dp[0] = [a,b]
    else:
        dp[i][0] = max(fractions.gcd(dp[i-1][0],a),fractions.gcd(dp[i-1][1],a))
        dp[i][1] = max(fractions.gcd(dp[i-1][0],b),fractions.gcd(dp[i-1][1],b))

print(max(dp[-1]))
Example #43
0
def lcm(x, y):
    return (x * y) / gcd(x, y)
Example #44
0
def lcm(a, b):
    """ Return the Least Common Multiple of a and b. """
    return abs(a * b) / gcd(a, b) if a and b else 0
def lcm(a, b): return abs(a * b)/fractions.gcd(a, b) if a and b else 0


opt = TrainOptions().parse()
Example #46
0
def lcm(a, b):
    return a // gcd(a, b) * b
Example #47
0
def lcm(numbers):
    return reduce(lambda x, y: (x * y) / gcd(x, y), numbers, 1)
 def lcm(n1, n2):
     """
     Find least common multiple of two numbers
     """
     return n1 * n2 / gcd(n1, n2)
Example #49
0
def f(x):
    # sum of GCDs
    sum = 0
    for i in range(1, x + 1):
        sum += gcd(i, x)
    return sum
4
6
8
Output:
24 48 72 96 120
#include<stdio.h>
#include <stdlib.h>
int main()
{
int a,b,c,i,f=0;
scanf("%d%d%d",&a,&b,&c);
for(i=1;i<1000;i++){
    if(f==5)
    break;
    if(i%a==0&&i%b==0&&i%c==0){
    printf("%d ",i);
    f++;
    }
}
 }
from fractions import gcd
d=[int(input()),int(input()),int(input())]
l=d[0]
for i in d:
    l=l*i//gcd(l,i)
i=1
while i!=6:
    print(l*i,end=" ")

    i+=1
Example #51
0
import sys, fractions, math
fin = open('B-small-attempt1.in', 'r')
sys.stdout = open('B-small-attempt1.out', 'w')
T = int(fin.readline())
for cs in range(1, T + 1):
    num = [int(x) for x in fin.readline().split(' ')]
    N = num[0]
    del num[0]
    if N == 2:
        a = math.fabs(num[0] - num[1])
        if num[0] % a != 0: ans = a - num[0] % a
        else: ans = 0
    else:
        a = math.fabs(num[0] - num[1])
        b = math.fabs(num[1] - num[2])
        c = math.fabs(num[2] - num[0])
        gc = fractions.gcd(a, fractions.gcd(b, c))
        if num[0] % gc != 0: ans = gc - num[0] % gc
        else: ans = 0
    print('Case #%d: %d' % (cs, ans))
fin.close()
test_norm = (df_new_test - df_new_test.mean()) / (df_new_test.max() -
                                                  df_new_test.min())

# In[ ]:

train_norm.reset_index(inplace=True, drop=True)
test_norm.reset_index(inplace=True, drop=True)

# ### Making train and test sets with train_norm and test_norm

# #### finding the gcf (greatest common factor) of train and test dataset's length and chop off the extra rows to make it divisible with the batchsize

# In[89]:

from fractions import gcd
gcd(train_norm.shape[0], test_norm.shape[0])

# In[ ]:

import math


def roundup(x):
    return int(math.ceil(x / 100.0)) * 100


# In[ ]:

train_lim = roundup(train_norm.shape[0])
test_lim = roundup(test_norm.shape[0])
Example #53
0
import fractions
for t in xrange(input()):
    a, b, c, d = map(int, raw_input().split())
    g = fractions.gcd(c, d)
    diff = abs(a - b)
    i = (diff / g) * g
    j = i + g
    print min(abs(i - diff), j - diff)
Example #54
0
#!/usr/bin/env python

import fractions
import math

if __name__ == '__main__':
    T = int(raw_input())
    for i in range(1, T + 1):
        P, Q = map(int, raw_input().split('/'))
        g = fractions.gcd(P, Q)
        P /= g
        Q /= g
        ans = 0
        if Q != 0 and (Q & (Q - 1) == 0):
            if P == 1:
                ans = int(math.log(Q, 2))
            else:
                while Q > P:
                    Q /= 2
                    ans += 1
        else:
            ans = 'impossible'
        print 'Case #%d: %s' % (i, ans) 
Example #55
0
import sys
input = sys.stdin.readline
from fractions import gcd

Q = int(input())
Query = []
for _ in range(Q):
    a, b, q = map(int, input().split())
    LR = [list(map(int, input().split())) for _ in range(q)]
    Query.append((a, b, q, LR))


def solve(lcm, m, x):
    cycle = x//lcm
    amari = x%lcm
    return (lcm-m)*cycle + max(0, amari-m+1)

for a, b, q, LR in Query:
    lcm = a*b//gcd(a,b)
    m = max(a, b)
    ans = []
    for l, r in LR:
        ans.append(solve(lcm, m, r)-solve(lcm, m, l-1))
    print(*ans)
Example #56
0
def lcm(x, y):  # 最小公倍数
    return (x * y) // fractions.gcd(x, y)
def smallest_r(n, log_2_n_squared, log_2_n):
    #find smallest r such that order_r(n) > log_2_n_squared
    #if f and n are not coprime, then SKIP this r.
    print "Running smallest_r(n , log_2_n_squared, log_2_n).."
    print "log_2_n is: " + str(log_2_n)
    print "log_2_n_squared is: " + str(log_2_n_squared)

    #intialise r
    r = 1

    # G is the Multiplicative Group - (Z/rZ)*
    #Z_r - denotes set of integers modulo r
    #F_p denotes finite field with p elements

    #order_r(n) = order of n modulo r
    #integer n, positive integer r with gcd(n,r)=1,
    #multiplicative order of n modulo r is the smallest integer k with pow(n,k,r)=1
    #r is unknown & we want to find.

    #print "pow(log_2_n, 5) is: "+str(pow(log_2_n,5))
    #print "math.ceil(pow(log_2_n, 5)) is: "+str(math.ceil(pow(log_2_n,5)))
    #print "int(math.ceil(pow(log_2_n, 5))) is: "+str(int(math.ceil(pow(log_2_n,5))))
    while r <= int(math.ceil(pow(log_2_n, 5))):

        #print "r is now: "+str(r)
        order_result = calc_order(n, r)
        #return status, order
        #status is False for "no exponent found"
        #status is True for exponent found
        status = order_result[0]  #O(1)
        order_r_n = order_result[1]  #O(1)
        #status = result[1]

        #print "status is: "+str(status)
        #raw_input("Waiting for user..")

        if status == False:
            #print "order_r_n is not found!"
            r = r + 1
        elif status == True:
            if order_r_n <= log_2_n_squared:
                r = r + 1
            elif order_r_n > log_2_n_squared:
                #check if r and n are coprime
                if gcd(r, n) <> 1:
                    r = r + 1
                else:
                    print "r found: " + str(r)
                    status = True
                    return r, status
            else:
                print "order_r_n: " + str(
                    order_r_n) + ", log_2_n_squared: " + str(log_2_n_squared)
                raw_input("Waiting for user..")
        else:
            print "order_r_n is: " + str(order_r_n)
            raw_input("Waiting for user..")

    if r == 1:
        status = False
        return r, status
        print "r not found!"
Example #58
0
def lcm(a, b):
    return abs(a * b) / fractions.gcd(a, b) if a and b else 0
Example #59
0
def _is_coprime(a, b):
    return gcd(a, b) == 1
Example #60
0
from fractions import gcd
A = ((1,1),(1,0))

def multi(a, b, k):
    return (((a[0][0]*b[0][0]+a[0][1]*b[1][0])%k,
             (a[0][0]*b[0][1]+a[0][1]*b[1][1])%k),
            ((a[1][0]*b[0][0]+a[1][1]*b[1][0])%k,
             (a[1][0]*b[0][1]+a[1][1]*b[1][1])%k))

def power(L, p, k):
    if p == 1:
        return L
    sq = power(L, p//2, k)
    if p%2==0:
        return multi(sq,sq,k)
    return multi(multi(sq,sq,k),L,k)

n, m = map(int,input().split())
print(power(A,gcd(n,m),1000000007)[0][1])