def test_visual_factorint(): assert type(factorint(42, visual=True)) == Mul assert str(factorint(42, visual=True)) == '2**1*3**1*7**1' assert factorint(1, visual=True) is S.One assert factorint(42**2, visual=True) == Mul(Pow(2, 2, evaluate=False), Pow(3, 2, evaluate=False), Pow(7, 2, evaluate=False), evaluate=False) assert Pow(-1, 1, evaluate=False) in factorint(-42, visual=True).args
def test_visual_factorint(): assert factorint(1, visual=1) == 1 forty2 = factorint(42, visual=True) assert type(forty2) == Mul assert str(forty2) == "2**1*3**1*7**1" assert factorint(1, visual=True) is S.One no = dict(evaluate=False) assert factorint(42 ** 2, visual=True) == Mul(Pow(2, 2, **no), Pow(3, 2, **no), Pow(7, 2, **no), **no) assert Pow(-1, 1, **no) in factorint(-42, visual=True).args
def factors(self, limit=None, verbose=False): """A wrapper to factorint which return factors of self that are smaller than limit (or cheap to compute).""" from sympy.ntheory import factorint f = factorint(self.p, limit=limit, verbose=verbose).copy() for p, e in factorint(self.q, limit=limit, verbose=verbose).items(): try: f[p] += -e except KeyError: f[p] = -e if len(f)>1 and 1 in f: del f[1] return f
def gf_irred_p_rabin(f, p, K): """Rabin's polynomial irreducibility test over finite fields. """ n = gf_degree(f) if n <= 1: return True _, f = gf_monic(f, p, K) x = [K.one, K.zero] H = h = gf_pow_mod(x, p, f, p, K) indices = set([ n//d for d in factorint(n) ]) for i in xrange(1, n): if i in indices: g = gf_sub(h, x, p, K) if gf_gcd(f, g, p, K) != [K.one]: return False h = gf_compose_mod(h, H, f, p, K) return h == x
def gf_csolve(f, n): """ To solve f(x) congruent 0 mod(n). n is divided into canonical factors and f(x) cong 0 mod(p**e) will be solved for each factor. Applying the Chinese Remainder Theorem to the results returns the final answers. Examples ======== Solve [1, 1, 7] congruent 0 mod(189): >>> from sympy.polys.galoistools import gf_csolve >>> gf_csolve([1, 1, 7], 189) [13, 49, 76, 112, 139, 175] References ========== [1] 'An introduction to the Theory of Numbers' 5th Edition by Ivan Niven, Zuckerman and Montgomery. """ from sympy.polys.domains import ZZ P = factorint(n) X = [csolve_prime(f, p, e) for p, e in P.iteritems()] pools = map(tuple, X) perms = [[]] for pool in pools: perms = [x + [y] for x in perms for y in pool] dist_factors = [pow(p, e) for p, e in P.iteritems()] return sorted([gf_crt(per, dist_factors, ZZ) for per in perms])
def getFactorListSympy( n ): # We shouldn't have to check for lists here, but something isn't right... if isinstance( n, list ): return [ getFactorListSympy( i ) for i in n ] from sympy.ntheory import factorint return getExpandedFactorListSympy( factorint( n ) )
def dup_zz_cyclotomic_poly(n, K): """Efficiently generate n-th cyclotomic polnomial. """ h = [K.one,-K.one] for p, k in factorint(n).iteritems(): h = dup_quo(dup_inflate(h, p, K), h, K) h = dup_inflate(h, p**(k-1), K) return h
def main(): i = 1 while True: # nth triangular number is n*(n+1) / 2 tri = (i*(i+1))/2 if count_factors(factorint(tri)) >= 1500: print tri break i += 1
def mobius(n): dict = factorint(n) factor_count = list(dict.values()) for i in factor_count: if i != 1: return 0 if n == 1: return 1 else: return (-1) ** (len(factor_count))
def _dup_cyclotomic_decompose(n, K): H = [[K.one,-K.one]] for p, k in factorint(n).iteritems(): Q = [ dup_quo(dup_inflate(h, p, K), h, K) for h in H ] H.extend(Q) for i in xrange(1, k): Q = [ dup_inflate(q, p, K) for q in Q ] H.extend(Q) return H
def solution(q): c = 0 for p in count(start=1, step=1): if len(factorint(p)) == q: c += 1 if c == 1: last = p else: c = 0 if c == q: return last
def get_sq_free_int(limit: int): """Get the none-sqare factors number""" result = [] for i in range(1, limit + 1): factors = factorint(i) if any(value > 1 for value in factors.values()): continue result.append(str(i)) return ", ".join(result)
def dup_zz_irreducible_p(f, K): """Test irreducibility using Eisenstein's criterion. """ lc = dup_LC(f, K) tc = dup_TC(f, K) e_fc = dup_content(f[1:], K) if e_fc: e_ff = factorint(int(e_fc)) for p in e_ff.iterkeys(): if (lc % p) and (tc % p**2): return True
def generator_Zp(p): factorizare = factorint(p - 1) N = p - 1 gasit = False while not gasit: a = random.randint(1, N) for factor in factorizare.keys(): b = pow(a, N // factor, p) if b == 1: break else: gasit = True return a
def fft_nice(n): '''Given integer ``n``, check if it is at the best handling size fot FFTW according to http://www.fftw.org/fftw2_doc/fftw_3.html ''' factors = factorint(n) max_prime = max(factors) if max_prime <= 7: return True elif max_prime <= 13: if factors.get(11, 0) + factors.get(13, 0) <= 1: return True return False
def divisible_triangle_number(divisors): n = 1 while True: triangle = (n * (n + 1)) // 2 # calculate the next triangle number prime_factors_tri = factorint( triangle) # find prime factors of the triangle number total_divs = 1 for i in prime_factors_tri: # let's say 6 = 2 * 3 = 2^1 + 3^1 so the number of divisors of 6 is (1+1)*(1+1) total_divs *= prime_factors_tri[ i] + 1 # add one to the prime factors exponents and then multiply them if total_divs > divisors: # compare the total_divs of the current tirangle and see it's greater than the given divisors return triangle n += 1
def get_prime(numOfBits: int, safe=False): if safe == False: return get_primes(numOfBits, 1)[0] else: iter = 0 while 1 or iter < 10**10: p = get_primes(numOfBits, 1)[0] t = factorint(p - 1) if len(t) == 2: if 2 in t.keys() and t[2] == 1: return p iter += 1 print("No safe prime found in max iterations!")
def gen_relatively_prime(f, name): factors = set(factorint(f).keys()) possible_factors = [ factor for factor in GenBBS.big + GenBBS.small if factor not in factors ] x = 1 for idx in range(2): x *= random.choice(possible_factors) Gen.print_genned_param(name, x) return x
def dup_zz_irreducible_p(f, K): """Test irreducibility using Eisenstein's criterion. """ lc = dup_LC(f, K) tc = dup_TC(f, K) e_fc = dup_content(f[1:], K) if e_fc: e_ff = factorint(int(e_fc)) for p in e_ff.keys(): if (lc % p) and (tc % p**2): return True
def test_factor(): assert trial(1) == [] assert trial(2) == [(2,1)] assert trial(3) == [(3,1)] assert trial(4) == [(2,2)] assert trial(5) == [(5,1)] assert trial(128) == [(2,7)] assert trial(720) == [(2,4), (3,2), (5,1)] assert factorint(123456) == [(2, 6), (3, 1), (643, 1)] assert primefactors(123456) == [2, 3, 643] assert factorint(-16) == [(-1, 1), (2, 4)] assert factorint(2**(2**6) + 1) == [(274177, 1), (67280421310721, 1)] assert factorint(5951757) == [(3, 1), (7, 1), (29, 2), (337, 1)] assert factorint(64015937) == [(7993, 1), (8009, 1)] assert divisors(1) == [1] assert divisors(2) == [1, 2] assert divisors(3) == [1, 3] assert divisors(10) == [1, 2, 5, 10] assert divisors(100) == [1, 2, 4, 5, 10, 20, 25, 50, 100] assert divisors(101) == [1, 101] assert pollard_rho(2**64+1, max_iters=1, seed=1) == 274177 assert pollard_rho(19) is None
def find_larger_prime(value, decomp): if value == 1: assert not decomp return missing_decomp = [] for w, n in decomp: w_val = get_known_word(w) if w_val is not None: print("\033[37mRemoving %d**%d from %d\033[m" % (w_val, n, value)) assert value % (w_val**n) == 0 value = value // (w_val**n) else: missing_decomp.append((w, n)) if value == 1: assert not missing_decomp return value_d = factorint(value) assert len(value_d) == len(missing_decomp) if len(missing_decomp) == 1: # Single decomp the_prime = list(value_d.keys())[0] assert value_d[the_prime] == missing_decomp[0][ 1], "Mismatching single-decomp for %r vs %r" % (value_d, missing_decomp) add_known(missing_decomp[0][0], the_prime) return if sorted(set(value_d.values())) == [1]: print("Finding larger prime from decomp %d=%r from %r" % (value, value_d, missing_decomp)) larger_prime = max(value_d.keys()) puiss = int(math.log(P) / math.log(larger_prime)) + 1 if not all( (x**puiss) < P for x in value_d.keys() if x != larger_prime): print("... skipping because not real puiss") else: assert (larger_prime**puiss) > P for w, n in missing_decomp: decomp_w = send_words(((w, puiss), )) if len(decomp_w) != 1: print("... found %r^%d = %r" % (w, puiss, decomp_w)) add_known(w, larger_prime) assert value % (larger_prime**n) == 0 find_larger_prime(value, missing_decomp) #global_queue.append((pow(larger_prime, puiss, P), decomp_w)) return print("NO DECOMP FOUND")
def mobius(n): primeNos = 0 if n < 1: return "Invalid" if n == 1: return 1 for prime, exp in factorint(n).items(): if exp >= 2: return 0 primeNos = primeNos + 1 if primeNos % 2 == 0: return 1 else: return -1
def partB(inputText): _, busList = inputText.split() busList = enumerate(busList.split(",")) busList = [(busPos%int(busN), int(busN)) for busPos, busN in busList if busN != "x"] #unzip busN = [i[1] for i in busList] busPos = [i[0] for i in busList] #confirm busN are coprime from sympy.ntheory import factorint factorized = [factorint(i) for i in busN] print(busN, busPos, factorized) return None
def generate_samples(max_n): #x is our modulus for x in range(3, max_n): self_squares = [] #factoring to find invertible numbers primes = factorint(x) #checking all the numbers where gcd(x,y)=1 for y in range(1, x): #checks that no prime divisors of our modulus (x) divide our number y #then checks if y is its own inverse if all(y % p != 0 for p in primes.keys()) and (y * y) % x == 1: self_squares.append(y) print("n: {} self squares: {}".format(x, self_squares))
def _dup_cyclotomic_decompose(n, K): from sympy.ntheory import factorint H = [[K.one, -K.one]] for p, k in factorint(n).items(): Q = [ dup_quo(dup_inflate(h, p, K), h, K) for h in H ] H.extend(Q) for i in range(1, k): Q = [ dup_inflate(q, p, K) for q in Q ] H.extend(Q) return H
def factors(): answer = [] for num in range(134000, 135000): lst =[] test = factorint(num) for i in test.keys(): lst.append(i) if len(lst) == 4: answer.append(num) print(answer) for j in answer: if (j+1) in answer: if (j+2) in answer: if (j+3) in answer: print(j)
def naive_search(M, N, J): p = np.array([0] * N) p[0], p[-1] = 1, 1 jamcoins = [] proofs = [] for i in range(0, 2**(N - 2)): p_ = [int(a) for a in str(bin(i))[2:]] p[-(len(p_) + 1):-1] = p_ c = [sum([a * b for a, b in zip(p, D)]) for D in M] if all([not isprime(a) for a in c]): jamcoins.append("".join([str(a) for a in p])) proofs.append([min(list(factorint(a).keys())) for a in c]) if len(jamcoins) == J: break return jamcoins, proofs
def calcGeneratorInefficient(p): primeFactors = factorint(p - 1) generators = [] for g in range(2, p - 1): results = [] for x in primeFactors: result = g**((p - 1) / x) % p if result == 1: break results.append(result) # print g, results generators.append(g) return generators
def compute(): user, session = get_user(request) if user is None: return redirect(url_for('login')) try: number = int(request.form['number']) except: return render_template("index.html", user=user, number_result='Incorrect Input') return render_template("index.html", user=user, number_result=factorint(number))
def d(n): global d_memo if n in d_memo: return d_memo.get(n) factors = factorint(n) d_sum = 1 for p, m in factors.items(): d_sum *= ((p**(m + 1) - 1) // (p - 1)) d_sum -= n d_memo[n] = d_sum return d_sum
def return_parents(n): factor_dict = factorint(n) factors = [] for i in factor_dict: factors.append(str(i)) parents_iter = [] for parent in itertools.permutations(factors): parents_iter.append(parent) parents = [] for parent in parents_iter: result = "" for element in parent: result += element parents.append(int(result)) return parents
def generate_with_factorization(n): rnd = randint(int(math.e**n), int(2 * math.e**n)) log_rnd = math.log(rnd) xs = [] factorization = factorint(rnd) for fact in factorization: for i in range(factorization[fact]): xs.append(math.log(fact) / log_rnd) print("rnd =", rnd, "\nlen_fact =", len(xs), "\nfactorization =", factorization) return list(reversed(xs))
def findAVulnerablePrime(bitSize): generator = 65537 m = nt.primorial(prime_default(bitSize), False) max_order = nt.totient(m) max_order_factors = nt.factorint(max_order) order = element_order_general(generator, m, max_order, max_order_factors) order_factors = nt.factorint(order) power_range = [0, order - 1] min_prime = g.bit_set( g.bit_set(g.mpz(0), bitSize // 2 - 1), bitSize // 2 - 2 ) # g.add(pow(g.mpz(2), (length / 2 - 1)), pow(g.mpz(2), (length / 2 - 2))) max_prime = g.bit_set( min_prime, bitSize // 2 - 4 ) # g.sub(g.add(min_prime, pow(g.mpz(2), (length / 2 - 4))), g.mpz(1)) multiple_range = [g.f_div(min_prime, m), g.c_div(max_prime, m)] random_state = g.random_state(random.SystemRandom().randint(0, 2**256)) return random_prime(random_state, nt.primorial(prime_default(bitSize), False), generator, power_range, multiple_range)
def isItJamCoin(number): binnumber = bin(number)[2:] divisors = [] for i in range(2, 11): current = int(binnumber, i) if isprime(current): return None divisor = min(factorint(current).keys()) if divisor == current: return None divisors.append(divisor) return divisors
def generate_key(): p = random.choice(big_primes) q = list(sorted(factorint(p - 1)))[-1] a = q - 1 while pow(a, q, p) != 1: a -= 1 x = random.randint(1, (p - 1) // 2) y = pow(a, x, p) with open('key.txt', 'w') as f: f.write('{}\n{}\n{}\n{}\n{}'.format(p, q, a, x, y)) return p, q, a, x, y
def generate_solns(max_n, interval=1, offset=0, target_dict=None): #added fillers so solns[n] gives soln mod n D = dict() #handling cases less than interval (tricky since we are avoiding 0,1,2) start_val = 0 while (start_val * interval + offset < 3): start_val += 1 #x is our modulus #only looking at offset values x = start_val * interval + offset while x < max_n + 1: #factoring to find invertible numbers primes = factorint(x) prime_len = len(primes) if prime_len == 1 and 2 not in primes: D[x] = 1 x += interval continue elif prime_len == 2 and (2 in primes and primes[2] == 1): D[x] = 1 x += interval continue #checking all the numbers where gcd(x,y)=1 #does not check n-1 aka y=1 (trivial case) solved = False sub_bound = int(sqrt(x) + 1) for y in range(sub_bound, int(x / 2) + 1): #start at the largest value less than x-1 since we're looking for max X = x - y #checks that no prime divisors of our modulus (x) divide our number y #then checks if y is its own inverse if all(X % p != 0 for p in primes.keys()) and (X * X) % x == 1: D[x] = X solved = True break if not solved: D[x] = 1 x += interval if target_dict == None: return D else: target_dict.update(D)
def test_decomp_8(): # This time we consider various cubics, and try factoring all primes # dividing the index. cases = ( x**3 + 3 * x**2 - 4 * x + 4, x**3 + 3 * x**2 + 3 * x - 3, x**3 + 5 * x**2 - x + 3, x**3 + 5 * x**2 - 5 * x - 5, x**3 + 3 * x**2 + 5, x**3 + 6 * x**2 + 3 * x - 1, x**3 + 6 * x**2 + 4, x**3 + 7 * x**2 + 7 * x - 7, x**3 + 7 * x**2 - x + 5, x**3 + 7 * x**2 - 5 * x + 5, x**3 + 4 * x**2 - 3 * x + 7, x**3 + 8 * x**2 + 5 * x - 1, x**3 + 8 * x**2 - 2 * x + 6, x**3 + 6 * x**2 - 3 * x + 8, x**3 + 9 * x**2 + 6 * x - 8, x**3 + 15 * x**2 - 9 * x + 13, ) def display(T, p, radical, P, I, J): """Useful for inspection, when running test manually.""" print('=' * 20) print(T, p, radical) for Pi in P: print(f' ({Pi!r})') print("I: ", I) print("J: ", J) print(f'Equal: {I == J}') inspect = False for g in cases: T = Poly(g) rad = {} ZK, dK = round_two(T, radicals=rad) dT = T.discriminant() f_squared = dT // dK F = factorint(f_squared) for p in F: radical = rad.get(p) P = prime_decomp(p, T, dK=dK, ZK=ZK, radical=radical) I = prod(Pi**Pi.e for Pi in P) J = p * ZK if inspect: display(T, p, radical, P, I, J) assert I == J
def _gen_relatively_prime(f): factors = set(factorint(f).keys()) possible_factors = [ factor for factor in GenRSA.big + GenRSA.small if factor < f and factor not in factors ] if not possible_factors: return f - 1 e = 1 while e < f: next_prime = random.choice(possible_factors) if next_prime * e > f: break e *= next_prime return e
def multipliers(n): """Разложение на множители. Параметры: n : int Целое число для факторизации. Выходные данные: str: string Строка разложения на множители. """ mult = factorint(n) # Получение словаря простых множителей числа n. l = [] for key in mult: l.append(str(key) + "*" + str(mult[key])) return (str(n) + " = " + " + ".join(l))
def residue_system(n, reduced=False, mod=True): """ @type n: integer > 1 @type reduced: bool @param reduced: return a reduced residue system modulo n or a complete residue system modulo n @type mod: bool @param mod: use mod when generate final list or not @rtype: list @return: a residue system modulo n """ assert isinstance(n, int) and n > 1 if n == 2: return [1] if reduced else [0, 1] n_fact = factorint(n) # if len(n_fact) == 1: # if reduced: # return rrs_of_prime_power( # *list(n_fact.items())[0]) # else: # return list(range(n)) m_list = [pow(*e) for e in n_fact.items()] M_list = [n//x for x in m_list] if reduced: vec = [rrs_of_prime_power(*e) for e in n_fact.items()] else: vec = [list(range(x)) for x in m_list] vec = [[x*s for x in l] for l, s in zip(vec, M_list)] if mod: res = reduce(lambda l1, l2: [(x+y) % n for x in l1 for y in l2], vec) else: res = reduce(lambda l1, l2: [x+y for x in l1 for y in l2], vec) res.sort() return res
def euler05(n): # Evenly divisible by all numbers from 1-20 d = {} i = Sieve(n+1) p = i.prime_list() for i in p: d[i] = 1 for j in range(4, n+1): f = factorint(j) for i in f.keys(): if f[i] > d[i]: d[i] = f[i] counter = 1 for i in d.keys(): counter = counter * i**d[i] print(counter)
def __cols_rows(figures): if figures == 1: return 1, 1 factors = nt.factorint(figures) expand = [[v] * count for v, count in factors.items()] expand = [i for sub in expand for i in sub] cols = 1 rows = 1 for f in reversed(expand): if rows < cols: rows *= f else: cols *= f if cols / rows > 2: cols = math.ceil(math.sqrt(figures)) rows = math.ceil(figures / cols) return cols, rows
def crackRsaPrivateKey(e, n): """Given an RSA public key, return the private exponent.""" factorsOfN = factorint(n) # since n is the product of two primes, we know its only factors are those two primes # if this is not the case, n is invalid (i.e., not the product of two primes) factorsAreValid = len(factorsOfN) == 2 and all(multiplicity == 1 for multiplicity in factorsOfN.values()) if (not factorsAreValid): raise Exception(f"{n} is not a valid n value.") factorsList = list(factorsOfN) p = factorsList[0] q = factorsList[1] phi = (p - 1) * (q - 1) d = inverse_mod(e, phi) return d
def smallest_number_divisible(start, stop): # Extract all common factors factors = dict() for i in range(start, stop + 1): if i == 0: continue for prime, amount in factorint(i).items(): prime = abs(prime) factors[prime] = max(amount, factors.get(prime, 0)) # Multiply them together answer = 1 for factor, amount in factors.items(): answer *= (factor**amount) return answer
def gf_irred_p_rabin(f, p, K): """ Rabin's polynomial irreducibility test over finite fields. Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.galoistools import gf_irred_p_rabin >>> gf_irred_p_rabin(ZZ.map([1, 4, 2, 2, 3, 2, 4, 1, 4, 0, 4]), 5, ZZ) True >>> gf_irred_p_rabin(ZZ.map([3, 2, 4]), 5, ZZ) False """ n = gf_degree(f) if n <= 1: return True _, f = gf_monic(f, p, K) x = [K.one, K.zero] H = h = gf_pow_mod(x, p, f, p, K) indices = set([n // d for d in factorint(n)]) for i in xrange(1, n): if i in indices: g = gf_sub(h, x, p, K) if gf_gcd(f, g, p, K) != [K.one]: return False h = gf_compose_mod(h, H, f, p, K) return h == x
def divisor_sum(n): r = 1 for k,v in factorint(n).iteritems(): r *= powsum(k, v) return r
def bestFFTlength(n): while max(factorint(n)) >= FACTOR_LIMIT: n -= 1 return n
@author VegasAce last modified 11/9/15 ''' import sympy, re, time from sympy.ntheory import factorint startTime = time.time() primeFactors = [] stringFactors = '' factors = {} total = 1 # get the prime factors for each number 1-20 for num in xrange(1,21,1): primeFactors.append(factorint(num)) # concatenate those to a string for num in xrange(0,len(primeFactors),1): stringFactors += (str(primeFactors[num])) # remove all characters but the numbers stringFactors = re.findall("\d+",stringFactors) # add the number of factors to a corresponding dictionary # by key of the factor for num in xrange(0,len(stringFactors)-1,2): if int(stringFactors[num]) in factors.keys(): if factors.get(int(stringFactors[num])) > int(stringFactors[num+1]): continue else:
def prime_factors(n): dict = factorint(n) return dict
def prime_factors(num): primes = factorint(num) return sorted(list(ii for k in primes for ii in repeat(k, primes[k])))
def factors_count(number): return sum(factorint(number).values()) return 0
def test_factorint(): assert primefactors(123456) == [2, 3, 643] assert factorint(0) == {0: 1} assert factorint(1) == {} assert factorint(-1) == {-1: 1} assert factorint(-2) == {-1: 1, 2: 1} assert factorint(-16) == {-1: 1, 2: 4} assert factorint(2) == {2: 1} assert factorint(126) == {2: 1, 3: 2, 7: 1} assert factorint(123456) == {2: 6, 3: 1, 643: 1} assert factorint(5951757) == {3: 1, 7: 1, 29: 2, 337: 1} assert factorint(64015937) == {7993: 1, 8009: 1} assert factorint(2**(2**6) + 1) == {274177: 1, 67280421310721: 1} assert multiproduct(factorint(fac(200))) == fac(200) for b, e in factorint(fac(150)).items(): assert e == fac_multiplicity(150, b) assert factorint(103005006059**7) == {103005006059: 7} assert factorint(31337**191) == {31337: 191} assert factorint(2**1000 * 3**500 * 257**127 * 383**60) == \ {2: 1000, 3: 500, 257: 127, 383: 60} assert len(factorint(fac(10000))) == 1229 assert factorint(12932983746293756928584532764589230) == \ {2: 1, 5: 1, 73: 1, 727719592270351: 1, 63564265087747: 1, 383: 1} assert factorint(727719592270351) == {727719592270351: 1} assert factorint(2**64 + 1, use_trial=False) == factorint(2**64 + 1) for n in range(60000): assert multiproduct(factorint(n)) == n assert pollard_rho(2**64 + 1, seed=1) == 274177 assert pollard_rho(19, seed=1) is None assert factorint(3, limit=2) == {3: 1} assert factorint(12345) == {3: 1, 5: 1, 823: 1} assert factorint( 12345, limit=3) == {4115: 1, 3: 1} # the 5 is greater than the limit assert factorint(1, limit=1) == {} assert factorint(0, 3) == {0: 1} assert factorint(12, limit=1) == {12: 1} assert factorint(30, limit=2) == {2: 1, 15: 1} assert factorint(16, limit=2) == {2: 4} assert factorint(124, limit=3) == {2: 2, 31: 1} assert factorint(4*31**2, limit=3) == {2: 2, 31: 2} p1 = nextprime(2**32) p2 = nextprime(2**16) p3 = nextprime(p2) assert factorint(p1*p2*p3) == {p1: 1, p2: 1, p3: 1} assert factorint(13*17*19, limit=15) == {13: 1, 17*19: 1} assert factorint(1951*15013*15053, limit=2000) == {225990689: 1, 1951: 1} assert factorint(primorial(17) + 1, use_pm1=0) == \ {long(19026377261): 1, 3467: 1, 277: 1, 105229: 1} # when prime b is closer than approx sqrt(8*p) to prime p then they are # "close" and have a trivial factorization a = nextprime(2**2**8) # 78 digits b = nextprime(a + 2**2**4) assert 'Fermat' in capture(lambda: factorint(a*b, verbose=1)) raises(ValueError, lambda: pollard_rho(4)) raises(ValueError, lambda: pollard_pm1(3)) raises(ValueError, lambda: pollard_pm1(10, B=2)) # verbose coverage n = nextprime(2**16)*nextprime(2**17)*nextprime(1901) assert 'with primes' in capture(lambda: factorint(n, verbose=1)) capture(lambda: factorint(nextprime(2**16)*1012, verbose=1)) n = nextprime(2**17) capture(lambda: factorint(n**3, verbose=1)) # perfect power termination capture(lambda: factorint(2*n, verbose=1)) # factoring complete msg # exceed 1st n = nextprime(2**17) n *= nextprime(n) assert '1000' in capture(lambda: factorint(n, limit=1000, verbose=1)) n *= nextprime(n) assert len(factorint(n)) == 3 assert len(factorint(n, limit=p1)) == 3 n *= nextprime(2*n) # exceed 2nd assert '2001' in capture(lambda: factorint(n, limit=2000, verbose=1)) assert capture( lambda: factorint(n, limit=4000, verbose=1)).count('Pollard') == 2 # non-prime pm1 result n = nextprime(8069) n *= nextprime(2*n)*nextprime(2*n, 2) capture(lambda: factorint(n, verbose=1)) # non-prime pm1 result # factor fermat composite p1 = nextprime(2**17) p2 = nextprime(2*p1) assert factorint((p1*p2**2)**3) == {p1: 3, p2: 6} # Test for non integer input raises(ValueError, lambda: factorint(4.5))
def phi2(n): value = n for prime, exp in factorint(n).items(): value = value * (1 - prime ** -1) return int(value)
def test_factorint(): assert sorted(factorint(123456).items()) == [(2, 6), (3, 1), (643, 1)] assert primefactors(123456) == [2, 3, 643] assert factorint(-16) == {-1:1, 2:4} assert factorint(2**(2**6) + 1) == {274177:1, 67280421310721:1} assert factorint(5951757) == {3:1, 7:1, 29:2, 337:1} assert factorint(64015937) == {7993:1, 8009:1} assert divisors(1) == [1] assert divisors(2) == [1, 2] assert divisors(3) == [1, 3] assert divisors(10) == [1, 2, 5, 10] assert divisors(100) == [1, 2, 4, 5, 10, 20, 25, 50, 100] assert divisors(101) == [1, 101] assert factorint(0) == {0:1} assert factorint(1) == {} assert factorint(-1) == {-1:1} assert factorint(-2) == {-1:1, 2:1} assert factorint(-16) == {-1:1, 2:4} assert factorint(2) == {2:1} assert factorint(126) == {2:1, 3:2, 7:1} assert factorint(123456) == {2:6, 3:1, 643:1} assert factorint(5951757) == {3:1, 7:1, 29:2, 337:1} assert factorint(64015937) == {7993:1, 8009:1} assert factorint(2**(2**6) + 1) == {274177:1, 67280421310721:1} assert multiproduct(factorint(fac(200))) == fac(200) for b, e in factorint(fac(150)).items(): assert e == fac_multiplicity(150, b) assert factorint(103005006059**7) == {103005006059:7} assert factorint(31337**191) == {31337:191} assert factorint(2**1000 * 3**500 * 257**127 * 383**60) == \ {2:1000, 3:500, 257:127, 383:60} assert len(factorint(fac(10000))) == 1229 assert factorint(12932983746293756928584532764589230) == \ {2: 1, 5: 1, 73: 1, 727719592270351: 1, 63564265087747: 1, 383: 1} assert factorint(727719592270351) == {727719592270351:1} assert factorint(2**64+1, use_trial=False) == factorint(2**64+1) for n in range(60000): assert multiproduct(factorint(n)) == n assert pollard_rho(2**64+1, seed=1) == 274177 assert pollard_rho(19, seed=1) is None assert factorint(3,2) == {3: 1} assert factorint(12345) == {3: 1, 5: 1, 823: 1} assert factorint(12345, 3) == {12345: 1} # there are no factors less than 3
def test_issue_4356(): assert factorint(1030903) == {53: 2, 367: 1}
def factors(n): return factorint(n)
def test_issue1257(): assert factorint(1030903) == {53: 2, 367: 1}
def count_factors(m): prime_fact = factorint(m) num = 1 for k in prime_fact: num *= prime_fact[k]+1 return num