def least_common_multiple(divisors=range(1, 21)): # Returns least common multiple of INTs in <divisors> # No matter the divisors, we at least need the max divisor as an LCM lcm = max(divisors) lcm_factors = sympy.factorint(lcm) for n in divisors: n_factors = sympy.factorint(n) for f in n_factors: # If this factor appears in the LCM ... if f in lcm_factors: factor_excess = lcm_factors[f] - n_factors[f] # ... check if there are enough of them if factor_excess < 0: # If not, we multiply into LCM to account for this lcm *= - factor_excess * f lcm_factors[f] += - factor_excess # If this factor does not appear in the LCM, multiple into LCM else: lcm *= n_factors[f] * f lcm_factors[f] = n_factors[f] return lcm
def mu(n): # check if the value is memoized check = memo.get(n) if check is not None: return memo[n] # sympy.perfect_power returns (base, exp) or False tmp = perfect_power(n) if tmp: # if n is a prime power not pre-memoized, then exp > base, and we use kempner's algorithm from [1] if isprime(tmp[0]): return (tmp[0] - 1) * tmp[1] + sumk(tmp[0], tmp[1]) # sympy.factorint returns a dictionary of { primefactor : power } # we recursively check the value of mu(primefactor**power), returning the max # this should be very fast most of the time, as small primes have all been pre-memoized else: f = factorint(n) memo[n] = max([mu(p**f[p]) for p in f.keys()]) return memo[n] else: # any prime not pre-memoized : mu(p) = p if isprime(n): memo[n] = n return memo[n] # else recursively check the prime powers in n's factorization as above f = factorint(n) memo[n] = max([mu(p**f[p]) for p in f.keys()]) return memo[n]
def totient_comparisons(max_n): #x is our modulus false_pos = 0 false_neg = 0 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) #if we have some interesting solutions, verify the relationship between #totient(n)%4 and the existence of solutions (it's necessary, not sufficient) if (len(self_squares) > 2) != (sp.totient(x) % 4 == 0): if len(self_squares) > 2: false_neg += 1 else: false_pos += 1 if len(self_squares) > 2: print("Solution totient: {}".format( sp.factorint(sp.totient(max(self_squares))))) #looking at the factorizations of solutions print("N totient: {}".format(sp.factorint(sp.totient(x)))) print("False positive solns: {} False negative solns: {}".format( false_pos, false_neg))
def main(): print "euler23.py" print sum(proper_factors(28)) print deficient(28) print perfect(28) print factorint(28) abridged_abundant = lambda(x): x%6 != 0 and x%28 != 0 and x%496 != 0 and abundant(x) print ascuii_map([('X', abridged_abundant), (' ', nil)], ['list', 0, 8000, 60])
def factor_fraction(fraction): N, D = to_numerator_denominator_pair(fraction) ps = factorint(N) qs = factorint(D) L = len(ps) + len(qs) ps.update((q, -exp) for q, exp in qs.items()) assert len(ps) == L return ps
def main(): print('----------------Lluís----------------') print(sympy.factorint(nLluis)) #115281056474331054700251942688513962925044855473544908166056180479356817897219 4 veces #3347812451 32 veces print("phi(p): ") p = 115281056474331054700251942688513962925044855473544908166056180479356817897219**4 p_1 = (p - 1) * (p**3) print(p_1) print("phi(q): ") q = 3347812451**32 q_1 = (q - 1) * (q**31) print(q_1) print("phi(n): ") phi_n = p_1 * q_1 print(phi_n) dLluis = sympy.gcdex(e, phi_n)[0] privateLluis = RSA.construct((nLluis, e, int(dLluis))) outputLluis = open('keyLluis2.pem', 'wb') outputLluis.write(privateLluis.exportKey('PEM')) outputLluis.close() #openssl rsautl -decrypt -inkey keyLluis2.pem -in lluis.marques_RSA_pseudo.enc -out decLluis2 print('----------------Toni----------------') print(sympy.factorint(nToni)) #3916392617 32 veces #238276963031717718724382324364818146621 8 veces p2 = 3916392617**32 p2_1 = (p2 - 1) * (p2**31) print("phi(p2): ") print(p2_1) print("phi(q2): ") q2 = 238276963031717718724382324364818146621**8 q2_1 = (q2 - 1) * (q2**7) print(q2_1) print("phi(n2): ") phi_n2 = p2_1 * q2_1 print(phi_n2) dToni = sympy.gcdex(e, phi_n2)[0] dToni = dToni % phi_n2 # dona negatiu, cal fer modul privateToni = RSA.construct((nToni, e, int(dToni))) outputToni = open('keyToni2.pem', 'wb') outputToni.write(privateToni.exportKey('PEM')) outputToni.close() #openssl rsautl -decrypt -inkey keyToni2.pem -in antonio.guilera_RSA_pseudo.enc -out decToni2 print( '-------------------------------------DONETTE-------------------------------------' )
def main(): count = 0 min = 2 * 3 * 5 * 7 while True: if len(sympy.factorint(min)) == 4: count = count + 1 else: count = 0 if count == 4: print ("%d" % (min - 3)) print(sympy.factorint(min - 3)) break min = min + 1
def reduce_power(n, e): """Reduce n^e to normal form.""" if isinstance(n, expr.Expr): return ((n, e),) elif isinstance(n, int): if n >= 0: return tuple((ni, e * ei) for ni, ei in sympy.factorint(n).items()) else: assert Fraction(e).denominator % 2 == 1, 'reduce_power' return ((-1, 1),) + tuple((ni, e * ei) for ni, ei in sympy.factorint(-n).items()) elif n in (Decimal("inf"), Decimal("-inf")): return ((n, e),) else: raise NotImplementedError
def get_times(bits): fact_times = [] mul_times = [] for bit in bits: fact_param = randbits(bit) mul_param = [k**v for k, v in factorint(fact_param).items()] fact_time = timeit.timeit(lambda: factorint(fact_param), "from sympy import factorint", number=1000) mul_time = timeit.timeit(lambda: Mul(*mul_param), "from sympy import Mul", number=1000) fact_times.append(fact_time) mul_times.append(mul_time) return fact_times, mul_times
def is_semiprime(n): factors = sym.factorint(n) if len(factors) == 2: return n if len(factors.values()) == 1 and list(factors.values())[0] == 2: return n return 0
def totient(n): if isprime(n): return n - 1 result = n for p in factorint(n).keys(): result *= (1 - 1 / p) return result
def _GeneratesMaxPeriodSecondCondition(self, a, M): # Calculate M prime factors MPrimeFactors = list(factorint(M).keys()) # Calculate a congruent 1 mod p for each prime im M factorization congruences = all( (a % prime) == (1 % prime) for prime in MPrimeFactors) return congruences
def euler47(): i = 646 while True: i += 1 if all(len(factorint(i + j).keys()) == 4 for j in range(4)): print(i) return
def euler47(): i = 646 while True: i += 1 if all(len(factorint(i+j).keys()) == 4 for j in range(4)): print(i) return
def n_order(a, n, f): from collections import defaultdict a, n = as_int(a), as_int(n) if igcd(a, n) != 1: raise ValueError("The two numbers should be relatively prime") factors = defaultdict(int) for px, kx in f.items(): if kx > 1: factors[px] += kx - 1 fpx = factorint(px - 1) for py, ky in fpx.items(): factors[py] += ky group_order = 1 for px, kx in factors.items(): group_order *= px**kx order = 1 if a > n: a = a % n for p, e in factors.items(): exponent = group_order for f in range(e + 1): if pow(a, exponent, n) != 1: order *= p**(e - f + 1) break exponent = exponent // p return order
def factor(self, n): """Simple example of specific protocol functionality """ log.msg('Factor ', n) f = factorint(long(n)) log.msg('Factors: ', str(f)) return
def is_cyclic_number(n): """ Check whether `n` is a cyclic number. A number `n` is said to be cyclic if and only if every finite group of order `n` is cyclic. For more information see [1]_. Examples ======== >>> from sympy.combinatorics.group_numbers import is_cyclic_number >>> from sympy import randprime >>> is_cyclic_number(15) True >>> is_cyclic_number(randprime(1, 2000)**2) False >>> is_cyclic_number(4) False References ========== .. [1] Pakianathan, J., Shankar, K., *Nilpotent Numbers*, The American Mathematical Monthly, 107(7), 631-634. """ if n <= 0 or int(n) != n: raise ValueError("n must be a positive integer, not %i" % n) n = Integer(n) if not is_nilpotent_number(n): return False prime_factors = list(factorint(n).items()) is_cyclic = all(a_i < 2 for p_i, a_i in prime_factors) return is_cyclic
def sort_N(DF,forms,all_N_factors): Nf = 1.0*1000*1000 DiscF_factors = sympy.factorint(DF*4) a0 = twos[DF] b0 = threes[DF] N1 = noTwoThree(DF, a0, b0) DF_info = {} DF_obstructions = {} for k in range(1, int(Nf / N1) + 1): N = N1 * k a = twos[N] b = threes[N] if a_okay(a, a0) and b_okay(b, b0): N_factors = all_N_factors[N] prime_bounds,prime_list = exponents(N,DF*4,N_factors,DiscF_factors) all_local_obstructions = [] new_forms = [] for F in forms: local_obstruction = local_test(F,DF*4,N_factors) print(N) if local_obstruction == []: new_forms.append(F) else: all_local_obstructions.append([N,F,local_obstruction[0]]) if new_forms != []: DF_info[N] = [N,new_forms,prime_bounds,prime_list] if all_local_obstructions != []: DF_obstructions[N] = all_local_obstructions
def CheckPrime(x, y): n = x * 10 + y d = sympy.factorint(n) if n in d: return 1 else: return 0
def _eval_expand_log(self, deep=True, **hints): from sympy import unpolarify, expand_log, factorint from sympy.concrete import Sum, Product force = hints.get('force', False) factor = hints.get('factor', False) if (len(self.args) == 2): return expand_log(self.func(*self.args), deep=deep, force=force) arg = self.args[0] if arg.is_Integer: # remove perfect powers p = perfect_power(arg) logarg = None coeff = 1 if p is not False: arg, coeff = p logarg = self.func(arg) # expand as product of its prime factors if factor=True if factor: p = factorint(arg) if arg not in p.keys(): logarg = sum(n * log(val) for val, n in p.items()) if logarg is not None: return coeff * logarg elif arg.is_Rational: return log(arg.p) - log(arg.q) elif arg.is_Mul: expr = [] nonpos = [] for x in arg.args: if force or x.is_positive or x.is_polar: a = self.func(x) if isinstance(a, log): expr.append(self.func(x)._eval_expand_log(**hints)) else: expr.append(a) elif x.is_negative: a = self.func(-x) expr.append(a) nonpos.append(S.NegativeOne) else: nonpos.append(x) return Add(*expr) + log(Mul(*nonpos)) elif arg.is_Pow or isinstance(arg, exp): if force or ( arg.exp.is_extended_real and (arg.base.is_positive or ((arg.exp + 1).is_positive and (arg.exp - 1).is_nonpositive))) or arg.base.is_polar: b = arg.base e = arg.exp a = self.func(b) if isinstance(a, log): return unpolarify(e) * a._eval_expand_log(**hints) else: return unpolarify(e) * a elif isinstance(arg, Product): if force or arg.function.is_positive: return Sum(log(arg.function), *arg.limits) return self.func(arg)
def factor(expression, variable = None, ensemble = None, decomposer_entiers = True): if isinstance(expression, (int, long, Integer)): if decomposer_entiers: return ProduitEntiers(*factorint(expression).iteritems()) else: return expression elif isinstance(expression, Basic) and expression.is_polynomial(): if variable is None: variable = extract_var(expression) if variable is None: # polynôme à plusieurs variables return factor_(expression) else: try: return poly_factor(expression, variable, ensemble) except NotImplementedError: if param.debug: print_error() return expression resultat = together_(expression) if resultat.is_rational_function(): num, den = resultat.as_numer_denom() if den != 1: return factor(num, variable, ensemble, decomposer_entiers)/factor(den, variable, ensemble, decomposer_entiers) else: resultat = auto_collect(resultat) if resultat.is_Mul: produit = 1 for facteur in resultat.args: if facteur != 1: produit *= factor(facteur, variable, ensemble, decomposer_entiers) return produit return resultat
def primes_pop(a): if isinstance(a, int): if a < 2: return [] try: import sympy factor_dict = sympy.factorint(a) factors_with_mult = [[fact for _ in range(factor_dict[fact])] for fact in factor_dict] return sorted(sum(factors_with_mult, [])) except: working = a output = [] num = 2 while num * num <= working: while working % num == 0: output.append(num) working //= num num += 1 if working != 1: output.append(working) return output if is_num(a): return cmath.phase(a) if is_seq(a): return a[:-1] raise BadTypeCombinationError("P", a)
def fac_list(n): f_list = [1] prime_fac_dict = sympy.factorint(n) for i, j in prime_fac_dict.items(): f_list.extend([a * i ** k for a in f_list[:] for k in range(1, j+1)]) f_list.remove(n) return f_list
def best_square(n): from sympy import factorint import itertools if n == 1: return 1, 1 # find nearly square factors to cover depth pfd = factorint( n) # the prime factors of ndepth, which is the number of feature maps f = [] for key, val in pfd.items( ): # pfd is a dictionary of factors and number of times they f.append([key] * val) # occur, e.g. 24 -> {{2,3},{3,1}} . So expand it.... f = list(itertools.chain.from_iterable(f)) #...and then flatten it. f.sort() prod = 1 pmax = int(n**0.5) print(f) for pf in f: if prod * pf <= pmax: prod *= pf else: nrows = prod ncols = n // nrows break return nrows, ncols
def compute_MDRS(n): """Computes the MDRS from a number n using greedy local search.""" candidates = [] # Candidates with local optimal DRS def improve(factors): """Recursively multiply two factors as long as it does not decrease the digital root sum of the factors.""" factors = defaultdict(int, factors) improvement = 0 for a, b in find_pairs(factors): c = a*b # If local improvement is possible, create remove the two # old factors once and introduce a new one if DR[c] >= DR[a] + DR[b]: new_factors = factors.copy() new_factors[a] -= 1 new_factors[b] -= 1 new_factors[c] += 1 improvement += 1 improve(new_factors) # If no more local improvements are possible then add # to the pool of local optima as candidates for MDRS if not improvement: candidates.append(factors) # Compute the potential candidates improve(factorint(n)) return max([DRS(f) for f in candidates])
def operate(self, a): if isinstance(a, int): if a < 0: # Primality testing return len(self.operate(-a)) == 1 if a < 2: return [] try: from sympy import factorint factor_dict = factorint(a) factors_with_mult = [[fact for _ in range( factor_dict[fact])] for fact in factor_dict] return sorted(sum(factors_with_mult, [])) except: working = a output = [] num = 2 while num * num <= working: while working % num == 0: output.append(num) working //= num num += 1 if working != 1: output.append(working) return output if is_num(a): return cmath.phase(a) if is_seq(a): return a[:-1] raise BadTypeCombinationError("P", a)
def decodersa(n, e, c): # using sympy factor int function obtain p,q. # takes significant time for long numbers primes = factorint(n) p, _ = dict.popitem(primes) q, _ = dict.popitem(primes) p1, q1 = p-1, q-1 # check p-1 and q-1 if not(gcd(p1 * q1, n) == 1): raise Exception('Incorrect p-1 and q-1, their GCD is not 1') p1q1 = p1 * q1 # now we solve e*d = 1 (mod (p-1)(q-1)) # e^-1 (mod (p-1)(q-1)) e1 = modinv(e, p1q1) # check that e1 is e's modular inverse if not(pow(e * e1, 1, p1q1) == 1): raise Exception('Incorrect e^-1 and e, e*e^-1 not 1') # solve for d d = e1 % p1q1 # solve c^d (mod n) decoded = pow(long(c), d, n) return num2alph(str(decoded))
def totient(n): from sympy import factorint fact_dict = factorint(n) phi_ = 1 for key, val in fact_dict.items(): phi_ *= key**val - key**(val - 1) return phi_
def factorize(*args, **kwargs): temp = sympy.factorint(*args, **kwargs) output = [] for k in temp: for i in range(temp[k]): output.append(k) return output
def report_for_base(base): seqs = get_sequences_for_base(base) seq_lens = [ len(seq) - 2 for seq in seqs ] # len of sequence is actually number of pairs in it, = len(seq) - 2 print("base {} has {} sequences".format(base, len(seqs))) print("lengths in order of sequence number: {}".format(seq_lens)) print("lengths in sorted order: {}".format(sorted(seq_lens))) print() tuple_to_seq_number = {} for i, seq in enumerate(seqs): print("seq #{}, len {} with factorization {}".format( i, seq_lens[i], sympy.factorint(seq_lens[i]))) print(seq) pairs = get_conditions_in_sequence(seq) for pair in pairs: tuple_to_seq_number[tuple(pair)] = i print() print("\n" + ("-" * 40) + "\n") if base <= 50: show_table(base, tuple_to_seq_number) else: print("too big to show table")
def a(n): # Orson R. L. Peters, Jan 31 2017 r = 1 factors = factorint(n) for p, e in factors.items(): if p % 4 == 1: r *= 2 * e + 1 if r * 4 > 420: return 0 return 4 * r if n > 0 else 0
def GenerateSquareRoots(base, gen): # Establecemos las variables globales al nuevo valor global BASE, GEN, P_FACTS, ROOTS BASE = base GEN = gen # El orden del generador es el cardinal de todos los elementos menos el 0 order = base - 1 # Calculamos los factores primos con su exponente P_FACTS = factorint(order) # Tabla con las raíces de la unidad ROOTS = {} # Rellenamos la tabla de raíces for i in P_FACTS: # Raíces p_i-ésimas i_roots = {} # Variables para rellenar ROOTS aux = 1 step = FastExp(gen, order / i, base) # Llenamos la lista for j in range(i): i_roots[aux] = j # Nos ahorramos calcular potencias a cambio de un producto aux = aux * step % base # Las introducimos al resto de raíces ROOTS[i] = i_roots
def drawnumber(xo,yo,num): if num == 1: factors = [1] else: factors = sympy.factorint(num) factors = list(sympy.utilities.iterables.multiset_combinations(factors, sum(factors.values())))[0] factors=factors[0::2] + factors[1::2] for ix,f in enumerate(factors): theta1 = 90+360*(ix-.5)/len(factors) theta2 = 90+360*(ix+.5)/len(factors) color = primecolors.get(f) if not color: color = primecolors.get("fallback") p = patches.Wedge(center=(xo,yo), r=0.5, theta1=0, theta2=360, edgecolor="none", facecolor=primecolors.get('background'), linewidth=0); plt.gca().add_patch(p) p = patches.Wedge(center=(xo,yo), r=1.0, theta1=theta1, theta2=theta2, width=0.5, edgecolor=primecolors.get('background'), facecolor=color, linewidth=1) plt.gca().add_patch(p) plt.text(xo-0.01,yo-0.03, "{}".format(num),horizontalalignment='center',verticalalignment='center', color=primecolors.get('text'), weight='bold', size=12.0) if (f>primecolors['maxprimecolor']) & (len(factors)>1): theta = (theta1+theta2)*.5 plt.text(xo+numpy.cos(theta*numpy.pi/180)*.75,yo+numpy.sin(theta*numpy.pi/180)*.75, f, horizontalalignment='center',verticalalignment='center', fontsize=6, weight='bold', color=primecolors.get('text'))
def factor_special(n): dic1 = sympy.factorint(n) dic2 = {} for i in dic1: if dic1[i] != 1: dic2[i] = dic1[i] // 2 return dic2
def show(value): ''' use sympy.factorint() and display in formatted form ''' assert value >= 0 # factorint() will return dict with factor and its myd = factorint(value) # output the result... msg = f'{value} = ' #print(value, "= ", end='') arr = list(myd.keys()) arr.sort() isFirst = True for key in arr: if not isFirst: #print(" * ", end='') msg = msg + ' * ' else: isFirst = False val = myd[key] if val == 1: msg = msg + str(key) #print(key, end='') else: #print("{}**{}".format(key, myd[key]), end='') msg = msg + f"{key}**{myd[key]}" if HAS_CONSOLE_MODULE: console.alert(msg) else: print(msg)
def gen_prime(a, b, smooth): while (True): p = randprime(a, b) factors = factorint(p - 1, limit=smooth) if (isprime(max(factors)) and max(factors) < smooth): return p
def exec_time_of_fft(): ''' @Description: 观察不同平滑度输入数组的FFT计算时间,理解Cooley-Tukey算法的时间复杂度 最优情况下n(long(n)),退化到最坏情况下n^2 ''' K = 1000 lengths = range(250, 260) # 计算所有输入长度的平滑度 smoothness = [max(factorint(i).keys()) for i in lengths] exec_time_of_fft_array = [] for i in lengths: '''traverse all possible input lengths, and record the minimum time in multiple times calculation''' z = np.random.random(i) times = [] for k in range(K): tic = time.monotonic() fftpack.fft(z) toc = time.monotonic() times.append(toc - tic) exec_time_of_fft_array.append(min(times)) _, (ax0, ax1) = plt.subplots(2, 1, sharex=True) ax0.stem(lengths, np.array(exec_time_of_fft_array) * 1e6) ax0.set_xlabel('Length of input array') ax0.set_ylabel('Execution time [us]') ax1.stem(lengths, np.array(smoothness)) ax1.set_ylabel('Smoothness of input length\n(lower is better)') plt.savefig('./4_6_execution_time_of_fft.png')
def calFactors(x): if x % 2 == 0: x //= 2 divs = factorint(x) num = 1 for p in divs: num *= divs[p] + 1 return num
def _coprime_density(value): """Returns float > 0; asymptotic density of integers coprime to `value`.""" factors = sympy.factorint(value) density = 1.0 for prime in six.iterkeys(factors): density *= 1 - 1 / prime return density
def apply(self, n, evaluation): 'FactorInteger[n_]' if isinstance(n, Integer): factors = sympy.factorint(n.value) factors = sorted(factors.iteritems()) return Expression('List', *[Expression('List', factor, exp) for factor, exp in factors]) elif isinstance(n, Rational): factors = sympy.factorint(n.value.numer()) factors_denom = sympy.factorint(n.value.denom()) for factor, exp in factors_denom.iteritems(): factors[factor] = factors.get(factor, 0) - exp factors = sorted(factors.iteritems()) return Expression('List', *[Expression('List', factor, exp) for factor, exp in factors]) else: return evaluation.message('FactorInteger', 'exact', n)
def factor_special(n): dic1 = sympy.factorint(n) dic2 = {} for i in dic1: if dic1[i] != 1: dic2[i] = dic1[i]//2 return dic2
def __set_letters(self, message: str) -> None: letters = [] for letter in message: letters.append(sp.factorint(ord(letter), multiple=True)) self.letters = np.array(letters, dtype=object)
def phi(n): factor = list(factorint(n)) phi = n for i in range(1, len(factor) +1): for j in combinations(factor, i): phi += (-1) ** i * (n // product(j)) return phi
def phi(n): if isPrime(n): return n-1 else: factors = factorint(n) res = n for f in list(factors.keys()): res = res*(1 - 1/f) return res
def radical(n): """A radical is the product of distinct prime factors For example, 504 = 2^3 x 3^2 x 7, so radical(504) = 2 x 3 x 7 = 42 >>> radical(504) 42 """ return product(sympy.factorint(n).keys())
def eval(cls, expr): if expr.is_Integer: from sympy import factorint factors = factorint(Abs(expr), limit=10000) factorlist=list(factors.keys()) factorlist.sort() return factorlist[0] else: raise ValueError("Argument to smallest_factor must be an integer")
def omega(nval): if nval == 1: return 0 if nval in prime_exponent_dicts: pd = prime_exponent_dicts[nval] else: pd = sympy.factorint(nval) prime_exponent_dicts[nval] = pd return len(pd)
def main(): ''' main function ''' while True: # input value <= zero to exit val = input("input an postive integer (0 to quit): ") val = int(val) if val <= 0: break fdict = factorint(val) print(fdict)
def distinct_powers(max_a, max_b): power_set = set() for a in range(2, max_a + 1): prime_factors = sorted(factorint(a).items()) power_primes = list(prime_factors) for b in range(2, max_b + 1): power_primes = [(z[0][0], z[0][1] + z[1][1]) for z in zip(power_primes, prime_factors)] power_representation = ",".join("{}:{}".format(p[0], p[1]) for p in power_primes) power_set.add(power_representation) return len(power_set)
def fun(n): if n == 1: return 1 factor_list = [1] for i, j in sp.factorint(n).items(): for s in factor_list[:]: for t in range(1, j + 1): factor_list.append(s * i ** t) factor_list.remove(n) return sum(factor_list)
def check(n): test = float(n) if (test/2).is_integer() and not (test/4).is_integer(): return False T1 = time.time() primes = sympy.factorint(n) global tijd tijd += time.time()-T1 count1 = 0 count2 = 0 count3 = 0 count7 = 0 for p in primes: power = primes[p] % 2 if p % 4 == 3: if power == 1: return False count1 += 1 else: if p != 2: count1 -= 10000 count1 += 1 if p % 8 in {5, 7}: if power == 1: return False count2 += 1 else: if p != 2: count2 -= 10000 count2 += 1 if p % 3 == 2: if power == 1: return False if p == 2: count3 -= 10000 count3 += 1 else: if p != 3: count3 -= 10000 if p % 7 in {3, 5, 6}: if power == 1: return False count7 += 1 else: if p != 7 and p != 2: count7 -= 10000 if p == 2: if primes[p] > 2: count7 -= 10000 if count1 > 0 or count2 > 0 or count3 > 0 or count7 > 0: return False return True
def apply(self, n, evaluation): 'PrimePowerQ[n_]' n = n.get_int_value() if n is None: return Symbol('False') n = abs(n) if len(sympy.factorint(n)) == 1: return Symbol('True') else: return Symbol('False')
def smallest_number_whose_square_is_divisible_by_n(nval): if nval == 1: return 1 if nval in prime_exponent_dicts: pd = prime_exponent_dicts[nval] else: pd = sympy.factorint(nval) prime_exponent_dicts[nval] = pd snwsidbn = 1 for pval, expval in pd.items(): snwsidbn *= math.pow(pval, math.ceil(expval / 2)) return int(snwsidbn)
def test_square_factor(): assert square_factor(1) == square_factor(-1) == 1 assert square_factor(0) == 1 assert square_factor(5) == square_factor(-5) == 1 assert square_factor(4) == square_factor(-4) == 2 assert square_factor(12) == square_factor(-12) == 2 assert square_factor(6) == 1 assert square_factor(18) == 3 assert square_factor(52) == 2 assert square_factor(49) == 7 assert square_factor(392) == 14 assert square_factor(factorint(-12)) == 2
def sigma_1(nval): if nval == 1: return 1 if nval in prime_exponent_dicts: pd = prime_exponent_dicts[nval] else: pd = sympy.factorint(nval) prime_exponent_dicts[nval] = nval psigmult = 1 for pval, expval in pd.items(): psigmult *= ((math.pow(pval, expval + 1) - 1) / (pval - 1)) return int(psigmult)
def sigma_0_pow(nval, powval=1): if nval == 1: return 1 if pow == 0: return 1 if nval in prime_exponent_dicts: pd = prime_exponent_dicts[nval] else: pd = sympy.factorint(nval) prime_exponent_dicts[nval] = pd s0mult = 1 for pval, expval in pd.items(): s0mult *= (expval * powval + 1) return int(s0mult)
def smallest_product_sum(k): n = 2 while 1: total = 0 total_cnt = 0 for factor, cnt in factorint(n).iteritems(): total += factor * cnt total_cnt += cnt print n, total_cnt, total, total + (k - total_cnt) if total + (k - total_cnt) == n: return n if n == 8: break n += 1
def is_acceptable_ring_length(n): """ Determine whether `n` is on the form ``2^a * 3^b * 5^c * k``; any other prime factors would non-productively be a part of every ring length. """ if n % k != 0: return False else: n //= k for factor in sympy.factorint(n).keys(): if factor not in [2, 3, 5, k]: return False else: return True
def apply(self, n, evaluation): 'FactorInteger[n_]' if isinstance(n, Integer): factors = sympy.factorint(n.value) factors = sorted(six.iteritems(factors)) return Expression('List', *(Expression('List', factor, exp) for factor, exp in factors)) elif isinstance(n, Rational): factors, factors_denom = list(map( sympy.factorint, n.value.as_numer_denom())) for factor, exp in six.iteritems(factors_denom): factors[factor] = factors.get(factor, 0) - exp factors = sorted(six.iteritems(factors)) return Expression('List', *(Expression('List', factor, exp) for factor, exp in factors)) else: return evaluation.message('FactorInteger', 'exact', n)