def eig2(mat): a1 = mat[0][0] a2 = mat[0][1] a3 = mat[1][0] a4 = mat[1][1] c1 = GSConst.c[1] c2 = GSConst.c[2] c4 = GSConst.c[4] b = -(a1 + a4) c = a1*a4 - a2*a3 d = b*b - c4*c l1 = (-b - sqrt(d)) / c2 l2 = (-b + sqrt(d)) / c2 k1 = a2 / (l1 - a1) k2 = a2 / (l2 - a1) v12 = c1 / sqrt(c1 + k1*k1) v11 = k1 * v12 v22 = c1 / sqrt(c1 + k2*k2) v21 = k2 * v22 if norm(l1) < norm(l2): return [[[v12, v11], [v22, v21]], [l1, l2]] else: return [[[v22, v21], [v12, v11]], [l2, l1]]
def factorization(n, delta): gmpy2.get_context().precision=1000000 t = gmpy2.mpz(gmpy2.sqrt(n)) res = gmpy2.mpfr('0.0', 1000000) steps = delta-t print "Steps: %d" % steps while True: res = gmpy2.sqrt(t**2 - n) if gmpy2.is_integer(res): break if res >= n/2: sys.stderr.write('I can\'t solve') exit() t += 1 steps -= 1 if steps % 1000 == 0: print steps p = t - gmpy2.mpz(res) q = n/p return { 'p': int(q), 'q': int(p) }
def __init__(self, l_fac, r0): self.PI_2 = acos(D0) self.ph = self.phDot = D0 self.r = r0 self.L = l_fac * sqrt(r0) self.L2 = self.L**2 self.rDot = - sqrt(r0 - self.L2) / self.r self.H0 = self.h()
def fermat_factor(n): assert n % 2 != 0 # Odd integers only a = gmpy2.isqrt(n) b2 = gmpy2.square(a) - n while not is_square(b2): a += 1 b2 = gmpy2.square(a) - n factor1 = a + gmpy2.sqrt(b2) factor2 = a - gmpy2.sqrt(b2) return int(factor1), int(factor2)
def computeN3Factors(): A = gmpy2.ceil(gmpy2.mul(2, gmpy2.sqrt(gmpy2.mul(6, N3)))) X = gmpy2.ceil( gmpy2.sqrt( gmpy2.sub( pow(A, 2), gmpy2.mul(24, N3) ) ) ) p = gmpy2.ceil(gmpy2.div(gmpy2.sub(A, X), 6)) # Only round one. q = gmpy2.div(N3, p) confirmed(N3, p, q)
def q3(): N = 720062263747350425279564435525583738338084451473999841826653057981916355690188337790423408664187663938485175264994017897083524079135686877441155132015188279331812309091996246361896836573643119174094961348524639707885238799396839230364676670221627018353299443241192173812729276147530748597302192751375739387929 rt = gmpy2.sqrt(gmpy2.mul(N, 6)) A = gmpy2.ceil(rt) A2 = pow(A, 2) assert A2 > N x = gmpy2.sqrt(gmpy2.sub(A2, N)) x = gmpy2.mul(x, 3/2) p = gmpy2.sub(A, x) q = gmpy2.add(A, x) gotcha(N, p, q)
def q1(): N = 179769313486231590772930519078902473361797697894230657273430081157732675805505620686985379449212982959585501387537164015710139858647833778606925583497541085196591615128057575940752635007475935288710823649949940771895617054361149474865046711015101563940680527540071584560878577663743040086340742855278549092581 rt = gmpy2.sqrt(N) A = gmpy2.ceil(rt) A2 = pow(A, 2) assert A2 > N x = gmpy2.sqrt(gmpy2.sub(A2, N)) p = gmpy2.sub(A, x) q = gmpy2.add(A, x) gotcha(N, p, q)
def FermatFactor(N): A = gmpy2.mpz( gmpy2.ceil( gmpy2.sqrt(N) ) ) B2 = gmpy2.sub( gmpy2.square(A), N ) while not gmpy2.is_square(B2): A = gmpy2.add( A, gmpy2.mpz("1") ) B2 = gmpy2.sub( gmpy2.square(A), N ) B = gmpy2.sqrt(B2) P = gmpy2.mpz( gmpy2.sub( A, B ) ) Q = gmpy2.mpz( gmpy2.add( A, B ) ) if not checkFactors(P,Q,N): raise Exception("Bad factors generated") return ( P, Q )
def solve_first(N): gmpy2.get_context().precision = 1000 Nsqrt = gmpy2.sqrt(N) A = gmpy2.mpz(gmpy2.rint_ceil(Nsqrt)) A2 = A*A x = gmpy2.isqrt(A2 - N) print "#1 ----> P is: " + str(A-x)
def could_be_prime(n): '''Performs some trials to compute whether n could be prime. Run time is O(N^3 / (log N)^2) for N bits. Returns whether it is possible for n to be prime (True or False). ''' if n < 2: return False if n == 2: return True if not int(n) & 1: return False product = ONE log_n = int(math.log(n)) + 1 bound = int(math.log(n) / (LOG_2 * math.log(math.log(n))**2)) + 1 if bound * log_n >= n: bound = 1 log_n = int(sqrt(n)) prime_bound = 0 prime = 3 for _ in range(bound): p = [] prime_bound += log_n while prime <= prime_bound: p.append(prime) prime = next_prime(prime) if p != []: p = prod(p) product = (product * p) % n return gcd(n, product) == 1
def chudnovsky(digits): # 20 safety digits because lots of calculations (only about 3 are needed) scale = 10**(mpz(digits+20)) gmpy2.get_context().precision = int(math.log2(10) * (digits + 20)) k = mpz(1) a_k = scale a_sum = scale b_sum = mpz(0) C = mpz(640320) C_cubed_over_24 = C**3 // 24 while True: a_k *= -(6*k-5) * (2*k-1) * (6*k-1) a_k //= k**3 * C_cubed_over_24 a_sum += a_k b_sum += k * a_k k += 1 if a_k == 0: break total_sum = mpfr(13591409 * a_sum + 545140134 * b_sum) pi = (426880 * gmpy2.sqrt(mpfr(10005))) / total_sum return pi*scale
def callfunc2(a, b): # print("Number of arguments", emb.numargs()) gmpy2.get_context().precision = 100 print(gmpy2.sqrt(5)) mp.dps = 50 print(mpf(2) ** mpf("0.5")) x = 21.3 s = "a*x+1 * math.sin(3)" result = eval(s) print(result) mycode = """print ('hello world from mycode')""" exec(mycode) def f(x): x = x + 12 return x print(f(4)) print("Will compute", a, "times", b) c = 0 for i in range(0, a): c = c + b return c
def main23(N): c=gmpy2.context() c.precision=len(str(N))+20 c.real_prec=len(str(N))+20 gmpy2.set_context(c) assert N==gmpy2.mpz(N) N=gmpy2.mpz(N) A=find_sqrt(6*N) A = gmpy2.mpz(A) assert ( (A-1)**2<6*N<A**2 ),'not found' Atag = A for iA in xrange(-2**20,2**20): A = Atag + iA s =A**2-N x = gmpy2.sqrt(s) try: x = gmpy2.mpz(x) except:continue '''print x**2 > s , x**2 < s while x**2>s: x-=1 print 1, print x**2 > s , x**2 < s''' for p in [(A-x)/2,(A-x)/3,(A+x)/2,(A+x)/3 ]: q = N/p if p*q==N: print gmpy2.is_prime(q) print gmpy2.is_prime(p) print min(p,q) assert False,'bla'
def main(N): c=gmpy2.context() c.precision=len(str(N))+20 c.real_prec=len(str(N))+20 gmpy2.set_context(c) assert N==gmpy2.mpz(N) N=gmpy2.mpz(N) A=find_sqrt(N) A = gmpy2.mpz(A) assert ( (A-1)**2<N<A**2 ),'not found' Atag = A for iA in xrange(-2**20,2**20): A = Atag + iA s =A**2-N x = gmpy2.sqrt(s) try: x = gmpy2.mpz(x) except:continue print x**2 > s , x**2 < s '''while x**2>s: x-=1 print 1,''' print x**2 > s , x**2 < s p = A-x q = A+x q = N/p if p*q==N: print gmpy2.is_prime(q) print gmpy2.is_prime(p) print min(p,q) break
def solve_quadratic(a, b, c): """ Solves the quadratic equation ```a x2 + b x + c = 0``` :return: the GMP result of solving the quadratic equation usign multi-precision numbers """ bb = sqrt(sub(mul(b, b), mul(mpz(4), mul(a, c)))) x1 = gmpy2.div(sub(-b, bb), mul(mpz(2), a)) x2 = gmpy2.div(add(-b, bb), mul(mpz(2), a)) return x1, x2
def Numbers(n): i = pow(gmpy2.mpfr(3 + gmpy2.sqrt(5)), n) #print(i) i = int(gmpy2.rint_trunc(i)) % 1000 o = i - ((i // 10) * 10) t = (i - ((i // 100) * 100) - o) / 10 h = (i - t - o) / 100 return str(h)+str(t)+str(o)
def Carpenter(p, q,r, s): p = gmpy2.mpfr(p) q = gmpy2.mpfr(q) r = gmpy2.mpfr(r) s = gmpy2.mpfr(s) """ Solves for all roots of the quartic polynomial P(x) = x^4 + px^3 + qx^2 + rx + s. """ #print "@@@ inside Carpenter", p,q,r,s pby4 = p/4.0 C = ((6 * pby4) - 3*p)*pby4 + q D = (((-4*pby4) + 3*p)*pby4 - 2*q)*pby4 + r E = (((pby4 - p)* pby4 + q)*pby4 - r)*pby4 + s #print "C, D, E=",C, D, E root = None for zero in polyCubicRoots(2*C, (C**2 - 4*E), -D**2): #print "zero = ", zero if type(zero)== type(gmpy2.mpfr(1.0)) and zero > 0.0: root = zero #print "found a positive root." break if root == None: return None sqroot = gmpy2.sqrt(root) Q1 = -root/4.0 - C/2.0 - D/2.0 / sqroot Q2 = -root/4.0 - C/2.0 + D/2.0 / sqroot #print "Q1,Q2=", Q1, Q2 sqy2 = sqroot/2.0 if Q1 >= 0.0: sqQ1 = gmpy2.sqrt(Q1) z1 = sqy2 + sqQ1 -pby4 z2 = sqy2 - sqQ1 -pby4 else: sqQ1 = gmpy2.sqrt(-Q1) z1 = (sqy2-pby4, sqQ1) z2 = (sqy2-pby4, - sqQ1) if Q2 >= 0.0: sqQ2 = gmpy2.sqrt(Q2) z3 = -sqy2 - sqQ2 -pby4 z4 = -sqy2 + sqQ2 -pby4 else: sqQ2 = gmpy2.sqrt(-Q2) z3 = (-sqy2-pby4, sqQ2) z4 = (-sqy2-pby4, -sqQ2) return (z1, z2,z3, z4)
def calc_brute_force(self): a = ceil(sqrt(self.n)) for n in xrange(1, 2 ** 20): p, q = self._calc_factors(add(a, n)) if self._check_sol(p, q): return p, q #self.log.print_progress(n) else: raise ValueError("Cannot factor {}".format(self.n))
def is_square(integer): itg = gmpy2.mpz(integer) gmpy2.get_context().precision = 2048 root = gmpy2.sqrt(itg) # root = math.sqrt(integer) if int(root) ** 2 == integer: return True else: return False
def q2(): N = 648455842808071669662824265346772278726343720706976263060439070378797308618081116462714015276061417569195587321840254520655424906719892428844841839353281972988531310511738648965962582821502504990264452100885281673303711142296421027840289307657458645233683357077834689715838646088239640236866252211790085787877 rt = gmpy2.sqrt(N) A = gmpy2.ceil(rt) q = 0 p = 0 while not gotcha(N, p, q): A2 = pow(A, 2) assert A2 > N x = gmpy2.sqrt(gmpy2.sub(A2, N)) p = gmpy2.sub(A, x) q = gmpy2.add(A, x) assert N == gmpy2.mul(p, q) A += 1
def squareroot_test(): start_timer() for i in range(100): x = gmpy2.isqrt(3 * scale**2) print_timer() start_timer() for i in range(100): x = gmpy2.sqrt(gmpy2.mpfr(3)) print_timer()
def main(): # predefine these, we will stop overwriting them when ready to run the big numbers p=mpz('13407807929942597099574024998205846127' '47936582059239337772356144372176403007' '35469768018742981669034276900318581848' '6050853753882811946569946433649006084171' ) g=mpz('117178298803662070095161175963353670885' '580849999989522055999794590639294997365' '837466705721764714603129285948296754282' '79466566527115212748467589894601965568' ) y=mpz('323947510405045044356526437872806578864' '909752095244952783479245297198197614329' '255807385693795855318053287892800149470' '6097394108577585732452307673444020333' ) log.info("Starting Discrete Log Calculation") log.info("p: %i", p) log.info("g: %i", g) log.info("y: %i", y) m = gmpy2.ceil(gmpy2.sqrt(p)) log.info("m: %i", m) # custom range since builtin has a size limit long_range = lambda start, stop: iter(itertools.count(start).next, stop) chunk_size = 100000 if m < 100000: chunk_size = m stop_at = chunk_size start = 0 while True: chunk = {} log.info("Starting chunk from %i to %i", start, stop_at) for i in xrange(start, stop_at): chunk[gmpy2.powmod(g,i,p)] = i for t in long_range(0,m): expone = mpz(gmpy2.mul(-m,t)) g_term = gmpy2.powmod(g, expone, p) res = gmpy2.f_mod(gmpy2.mul(y, g_term), p) if res in chunk: s = chunk[res] dc = gmpy2.f_mod(mpz(gmpy2.add(s, gmpy2.mul(m,t))), p) log.info("DC LOG FOUND") log.info("dc: %i", dc) return log.info("Completed chunk run: %i to %i no DC yet :(", start, stop_at) start = stop_at stop_at += chunk_size
def gauss_legendre(digits): gmpy2.get_context().precision = int(math.log2(10) * (digits + 5)) iterations = int(math.log2(digits)) # Direct translation of algorithm a = mpfr(1) b = 1 / gmpy2.sqrt(mpfr(2)) t = mpfr(1)/4 x = mpfr(1) for i in range(iterations): y = a a = (a + b) / 2 b = gmpy2.sqrt(b * y) t = t - x * (y-a)**2 x = 2 * x pi = ((a+b)**2) / (4*t) return pi
def computeN2Factors(): p = 0 q = 0 A = computeA(N2) while not confirmed(N2, p, q): A2 = pow(A, 2) assert A2 > N2 x = gmpy2.sqrt(gmpy2.sub(A2, N2)) p = gmpy2.sub(A, x) q = gmpy2.add(A, x) A += 1
def default_keylists(*args, **kwargs): """Default arg for build_config""" size = kwargs.pop('size', None) if size is None: size = 9 assert gmpy2.is_square(size), "size must be a square number" groupwidth = int(gmpy2.sqrt(size)) k1 = lambda i, j: i // groupwidth + (j // groupwidth) * groupwidth k2 = lambda i, j: i % groupwidth + (j % groupwidth) * groupwidth return [ [(k1(i,j),k2(i,j)) for i in range(size)] for j in range(size) ]
def find_sqrt(N): n =gmpy2.floor( gmpy2.sqrt( gmpy2.mpfr(N,precision = len(str(N))+50 ) ) ) n = gmpy2.mpz(n) for i in xrange(-2**10,2**20,1): #print (n+i)**2>N if (n+i)**2>N: print 'found' return n+i assert False,'bla'
def borwein(digits): gmpy2.get_context().precision = int(math.log2(10) * (digits + 10)) sqrt_2 = gmpy2.sqrt(mpfr(2)) a_n = sqrt_2 b_n = mpz(0) p_n = 2 + sqrt_2 while True: sqrt_a_n = gmpy2.sqrt(a_n) a_n1 = (sqrt_a_n + 1/sqrt_a_n) / 2 b_n1 = (1 + b_n) * sqrt_a_n / (a_n + b_n) p_n1 = (1 + a_n1) * p_n * b_n1 / (1 + b_n1) if p_n1 == p_n: break a_n = a_n1 b_n = b_n1 p_n = p_n1 return p_n
def __init__(self, cc, a, mu2, e, l, q, r0, th0, xh): self.l_3 = cc / D3 self.a = a self.mu2 = mu2 self.E = e self.L = l self.a2 = a**2 self.a2l_3 = self.a2 * self.l_3 self.a2mu2 = self.a2 * mu2 self.aE = a * e self.aL = a * l self.X2 = (D1 + self.a2l_3)**2 self.two_EX2 = D2 * e * self.X2 self.two_aE = D2 * a * e self.K = q + self.X2 * (l - self.aE)**2 self.t = self.ph = D0 self.r = r0 self.th = (mpfr("90.0") - th0) * acos(mpfr("-1")) / mpfr("180.0") self.cross = xh self.refresh() self.Ur = - sqrt(self.r_potential if self.r_potential >= D0 else -self.r_potential) self.Uth = - sqrt(self.th_potential if self.th_potential >= D0 else -self.th_potential)
def fairsquare(a, b): import gmpy2 global fns ans = 0 for i in xrange(a, b + 1): if i in fns: ans += 1 else: if is_palindrome(i): if gmpy2.is_square(i): s = int(gmpy2.sqrt(i)) if is_palindrome(s): fns.add(i) ans += 1 return ans
def findFactorsCaseTwo(self): print("===========================================") print("Modulus N is: " + str(self.N)) #A = (p+q)/2 AND A can be any where from ceil(sqrt(N)) to ceil(sqrt(N)) + 2 ^ 20 A = gmpy2.ceil(gmpy2.sqrt(self.N)) print("A is: " + str(A)) upperRange = 2 ** 20 for index in range (0, upperRange + 1): #x = sqrt(A^2 - N) A_square = gmpy2.mul(A, A) diff = gmpy2.sub(A_square, self.N) x = mpz(gmpy2.sqrt(diff)) #p = A - x AND q = A + x self.p = gmpy2.sub(A, x) self.q = gmpy2.add(A, x) prod = gmpy2.mul(self.p, self.q) if prod == self.N: print("We have got the factors RIGHT") return else: A = A + 1 print("We didn't get the factors") self.p = 0 self.q = 0
def findFactorsCaseOne(self): print("===========================================") print("Modulus N is: " + str(self.N)) #A = (p+q)/2 == ceil(sqrt(N)) A = gmpy2.ceil(gmpy2.sqrt(self.N)) print("A is: " + str(A)) #x = sqrt(A^2 - N) A_square = gmpy2.mul(A, A) x = gmpy2.sqrt(gmpy2.sub(A_square, self.N)) print("x is: " + str(x)) #p = A - x AND q = A + x self.p = gmpy2.sub(A, x) self.q = gmpy2.add(A, x) prod = gmpy2.mul(self.p, self.q) print("Product of pq is: " + str(prod)) if prod == self.N: print("We have got the factors RIGHT") else: print("We didn't get the factors") print(self.p) print(self.q) self.p = 0 self.q = 0 print("===========================================")
def findpq(d, e, N): ed = e * d gmpy2.get_context().precision=10000 # my_ed * d = phi(n) * k + 1 # print (my_e * d - 1) # <-- this is a multiple of phi(n) # the range is 1 -> e for k p = -1 q = -1 for k in range(1, e): temp = (ed-1) if temp % k == 0: temp //= k # phi(n) possibility p_plus_q = N + 1 - temp # ((p+q) + sqrt((p+q)2 - 4*pq))/2 sqrt_check = gmpy2.is_square( pow(p_plus_q, 2) - 4 * N) if sqrt_check == True: # p = ((p+q) + sqrt((p+q)2 - 4*pq))/2 # q = ((p+q) - sqrt((p+q)2 - 4*pq))/2 p = (p_plus_q + gmpy2.sqrt( pow(p_plus_q, 2) - 4 * N)) //2 p = int(p) q = (p_plus_q - gmpy2.sqrt( pow(p_plus_q, 2) - 4 * N)) //2 q = int(q) return p, q
def main(): # 2; used alpertron to factor n n = 742449129124467073921545687640895127535705902454369756401331 e = 3 ct = 39207274348578481322317340648475596807303160111338236677373 p = 752708788837165590355094155871 q = 986369682585281993933185289261 phi = (p - 1) * (q - 1) d = gmpy2.invert(e, phi) plain = pow(ct, d, n) print(trans(plain)) # 3: n = 171731371218065444125482536302245915415603318380280392385291836472299752747934607246477508507827284075763910264995326010251268493630501989810855418416643352631102434317900028697993224868629935657273062472544675693365930943308086634291936846505861203914449338007760990051788980485462592823446469606824421932591 e = 65537 ct = 161367550346730604451454756189028938964941280347662098798775466019463375610700074840105776873791605070092554650190486030367121011578171525759600774739890458414593857709994072516290998135846956596662071379067305011746842247628316996977338024343628757374524136260758515864509435302781735938531030576289086798942 phi = n - 1 d = gmpy2.invert(e, phi) plain = pow(ct, d, n) print(trans(plain)) # 4: N = 535860808044009550029177135708168016201451343147313565371014459027743491739422885443084705720731409713775527993719682583669164873806842043288439828071789970694759080842162253955259590552283047728782812946845160334801782088068154453021936721710269050985805054692096738777321796153384024897615594493453068138341203673749514094546000253631902991617197847584519694152122765406982133526594928685232381934742152195861380221224370858128736975959176861651044370378539093990198336298572944512738570839396588590096813217791191895941380464803377602779240663133834952329316862399581950590588006371221334128215409197603236942597674756728212232134056562716399155080108881105952768189193728827484667349378091100068224404684701674782399200373192433062767622841264055426035349769018117299620554803902490432339600566432246795818167460916180647394169157647245603555692735630862148715428791242764799469896924753470539857080767170052783918273180304835318388177089674231640910337743789750979216202573226794240332797892868276309400253925932223895530714169648116569013581643192341931800785254715083294526325980247219218364118877864892068185905587410977152737936310734712276956663192182487672474651103240004173381041237906849437490609652395748868434296753449 e = 65537 c = 222502885974182429500948389840563415291534726891354573907329512556439632810921927905220486727807436668035929302442754225952786602492250448020341217733646472982286222338860566076161977786095675944552232391481278782019346283900959677167026636830252067048759720251671811058647569724495547940966885025629807079171218371644528053562232396674283745310132242492367274184667845174514466834132589971388067076980563188513333661165819462428837210575342101036356974189393390097403614434491507672459254969638032776897417674577487775755539964915035731988499983726435005007850876000232292458554577437739427313453671492956668188219600633325930981748162455965093222648173134777571527681591366164711307355510889316052064146089646772869610726671696699221157985834325663661400034831442431209123478778078255846830522226390964119818784903330200488705212765569163495571851459355520398928214206285080883954881888668509262455490889283862560453598662919522224935145694435885396500780651530829377030371611921181207362217397805303962112100190783763061909945889717878397740711340114311597934724670601992737526668932871436226135393872881664511222789565256059138002651403875484920711316522536260604255269532161594824301047729082877262812899724246757871448545439896 gmpy2.get_context().precision = 10000 p = int(gmpy2.sqrt(N)) # print(p) phi = (p - 1) * (p) d = gmpy2.invert(e, phi) plain = pow(c, d, N) print(trans(plain)) # 5: n = 580642391898843192929563856870897799650883152718761762932292482252152591279871421569162037190419036435041797739880389529593674485555792234900969402019055601781662044515999210032698275981631376651117318677368742867687180140048715627160641771118040372573575479330830092989800730105573700557717146251860588802509310534792310748898504394966263819959963273509119791037525504422606634640173277598774814099540555569257179715908642917355365791447508751401889724095964924513196281345665480688029639999472649549163147599540142367575413885729653166517595719991872223011969856259344396899748662101941230745601719730556631637 e = 65537 ct = 320721490534624434149993723527322977960556510750628354856260732098109692581338409999983376131354918370047625150454728718467998870322344980985635149656977787964380651868131740312053755501594999166365821315043312308622388016666802478485476059625888033017198083472976011719998333985531756978678758897472845358167730221506573817798467100023754709109274265835201757369829744113233607359526441007577850111228850004361838028842815813724076511058179239339760639518034583306154826603816927757236549096339501503316601078891287408682099750164720032975016814187899399273719181407940397071512493967454225665490162619270814464 # factoring done using alpertron temp = "9 282105 380008 121879 × 9 303850 685953 812323 × 9 389357 739583 927789 × 10 336650 220878 499841 × 10 638241 655447 339831 × 11 282698 189561 966721 × 11 328768 673634 243077 × 11 403460 639036 243901 × 11 473665 579512 371723 × 11 492065 299277 279799 × 11 530534 813954 192171 × 11 665347 949879 312361 × 12 132158 321859 677597 × 12 834461 276877 415051 × 12 955403 765595 949597 × 12 973972 336777 979701 × 13 099895 578757 581201 × 13 572286 589428 162097 × 14 100640 260554 622013 × 14 178869 592193 599187 × 14 278240 802299 816541 × 14 523070 016044 624039 × 14 963354 250199 553339 × 15 364597 561881 860737 × 15 669758 663523 555763 × 15 824122 791679 574573 × 15 998365 463074 268941 × 16 656402 470578 844539 × 16 898740 504023 346457 × 17 138336 856793 050757 × 17 174065 872156 629921 × 17 281246 625998 849649" factors = temp.split("×") factors = [int(i.replace(" ", "")) for i in factors] phi = 1 for i in factors: phi *= (i - 1) d = gmpy2.invert(e, phi) plain = pow(ct, d, n) print(trans(plain))
def test(m): rx, ry = mpfr(0), mpfr(0) for M in P: dx = m[0] - M[0] dy = m[1] - M[1] if dx == 0 and dy == 0: continue dist = gmpy2.sqrt(dx**2 + dy**2) forc = force(M, m) rate = forc / dist rx += dx * rate ry += dy * rate return (rx, ry)
def b_genNext(): ''' b(n+1) ''' # Variables nonlocal b nonlocal a_n # To be updated nonlocal b_n nonlocal b_np1 # Iteration b_n = b b = ((1 + b_n) * (sqrt(a_n))) / (a_n + b_n) b_np1 = b
def pollard_rho(n, process_id): i = 1 # set the point in which rho starts if gmpy2.bit_length(gmpy2.mpz(n)) < RHO_CONSTANT: # small value modulo so we are better off starting with small value if DEBUG: print("bit size", gmpy2.bit_length(gmpy2.mpz(n)), "less than", RHO_CONSTANT, "so non ran") initial = process_id + 2 re_rand = False else: # small value modulo so we are better off starting with a random value if DEBUG: print("ran") # set a flag so we can re rand rho at a latter point re_rand = True # process_id + 2 # this could also be random.randomint(0, n - 1) initial = random.randint(primes[len(primes) - 1], n // (process_id + 2)) if DEBUG: processLock.acquire() print("CORE", process_id, "checking rho of", initial) processLock.release() y = initial k = 2 previous = initial count = 0 while True: i += 1 count += 1 # alt methods # gmpy2.powmod(pow(previous, 2) - 1, 1, n) # ((pow(previous, 2)) - 1) % n # current = (((previous**2) - 1) % n) d = gmpy2.gcd(y - current, n) # check to see if we've found the terminating conditions for rho and we've found a factor if d != 1 and d != n: return d if i == k: y = current k = 2 * k previous = current # check to see if we are in random mode and if we need to re random if re_rand and count > 100000: # (gmpy2.sqrt(n) // primes[len(primes)-1]): # print("RE-RAN") count = 0 previous = random.randint(primes[len(primes) - 1], int(gmpy2.sqrt(n)))
def icosahedron_vertices(): zero = gmpy2.zero() one = gmpy2.mpfr(1) phi = (gmpy2.sqrt(5) + 1) / 2 return ( (+one, +phi, zero), (+one, -phi, zero), (-one, +phi, zero), (-one, -phi, zero), (zero, +one, +phi), (zero, +one, -phi), (zero, -one, +phi), (zero, -one, -phi), (+phi, zero, +one), (+phi, zero, -one), (-phi, zero, +one), (-phi, zero, -one))
def cracker(N, root): """ We know that N = p*q --> N = (a+b)*(a-b) <=> N = a^2 - b^2 from fermat's factorization method Thus, b^2 = a^2 - N. Now, We discovered that Primes generated by the getPrimes method above Always generates primes that are symmetric around one of the modular square root of N modulo 2^1024. The choosen root shall always satisfy the condition root^2 > N. Thus, we can have a = root, and b as the deviation from a to give p and q Thus, b = sqrt(a^2 - N) given (a^2 - N) is a perfect square """ bsquare = root**2 - N if bsquare < 0: return 0, 0 b = gmpy2.sqrt(root**2 - N) if int(b)**2 != int(bsquare): return 0, 0 p = int(root + b) q = int(root - b) return p, q
def crack(self): for cvg in cf2cvg(f2cf(self.e, self.n)): k = cvg.numerator if k == 0: continue d = cvg.denominator phi = (self.e * d - 1) // k nb = self.n - phi + 1 squ = nb * nb - 4 * self.n if squ < 0: continue root = gmpy.sqrt(squ) if root * root == squ and not (nb + root) & 1: self.p = (nb + root) >> 1 self.q = (nb - root) >> 1 self.d = d return True return False
def naive(number): if number == 2: return True if number % 2 == 0 or number < 2: return False i = 3 rooted = gmpy2.floor(gmpy2.sqrt(number)) print rooted while i <= rooted: if number % i == 0: return False i += 2 if i % 10000000 == 1: print i return True
def factor(n, s): r = 0.5 while r < 4.5: a = 0.8 while a < 1.1: old_p = 0 p = s i = 0 while abs(p - old_p) > 0.00001 and i < 20 and p < sqrt(n): old_p = p p = iter(old_p, n, r, a) i += 1 if abs(p - old_p) <= 0.00001: #print('{}'.format(int(p))) return True a += 0.005 r += 0.1 return False
def checkPQDistance(self, keys): if not isinstance(keys, (tuple, list)): keys = [keys] ctx = gmpy2.get_context() ctx.precision = 5000 ctx.round = gmpy2.RoundDown ctx.real_round = gmpy2.RoundDown gmpy2.set_context(ctx) for key in keys: gmpy_key = gmpy2.mpfr(key) skey = int(gmpy2.sqrt(gmpy_key)) skey2 = skey**2 if (skey2 > key) or (((skey + 1)**2) < key): print skey2 print(skey + 1)**2 raise Exception("WTF") bits = int(gmpy2.log2(key - skey2)) if bits < 480: print '%d Has p, q distance of %d bits' % (key, bits)
def synapsegrow(synapse): global memories fish = len(memories) for x in range(fish): if type(synapse[x]) != np.ndarray: p = 0 else: p = len(synapse[x]) q = len(memories[x]) pq = int(q - p) rtq = len(memories[x]) for y in range(pq): init = np.random.randn() init *= mp.sqrt(2 / rtq) * init ainit = np.array([init], dtype=object) if type(synapse[x]) != np.ndarray: synapse[x] = ainit else: synapse[x] = np.append(synapse[x], ainit) return synapse
def factors2(n): n = gmpy2.mpz(n) init_guess = gmpy2.isqrt(n) A = init_guess # print('intial guess:') # print(guess) #print('N2/guess:\n'+ str(int(N2/guess)) + '\nN2%guess:\n'+ str(int(N2%guess))) mindiv = n for i in range(1048576): x = gmpy2.sqrt(A**2 - n) p = A - x q = A + x mod = gmpy2.fmod(n, p) div = gmpy2.div(n, p * q) if div < mindiv: mindiv = div if not mod: print('p:\n' + str(int(p))) print('q:\n' + str(int(q))) break A += 1
def _house(self): """Householder reflection, defined for column vector shapes x=(m,1). Returns (v, beta), where v is a column vector v with v[0]=1, and the matrix P = I - beta * v * v.T gives the Householder transformation satisfying: Px = norm(x)*e_1. Context: recall that a Householder transformation is given by an m-by-m matrix of the form: P = I - beta * v * v.T It reflects over v, the Householder vector. The matrix is never explicitly formed. Further info: algorithm 5.1.1, pg 236, Matrix Computations (4th ed). To efficiently apply the transformation to a matrix: PA = A - (beta * v) (v.T * A) AP = A - (A*v) (B*v).T """ m, n = self.shape assert n == 1, "need shape (m,1); have ({}, {})".format(m, n) alpha = self[0, 0] y = self[1:] sigma = y.frob_prod(y) #norm squared if sigma == 0: return self, 0 else: v = self.copy() mu = gmpy2.sqrt(alpha**2 + sigma) # always positive if alpha <= 0: new_v0 = alpha - mu else: new_v0 = -sigma / (alpha + mu) beta = 2 * new_v0**2 / (sigma + new_v0**2) v[(0, 0)] = new_v0 v /= new_v0 return v, beta
def get_matrix_from_data_file(): matrix = list() # 读取所有乘客的坐标 with open("passenger.txt", "r") as f: passengers = [x.rstrip() for x in f.readlines()] # 读取所有司机的坐标 with open("ubercar.txt", "r") as f: cars = [x.rstrip() for x in f.readlines()] # 计算并存在矩阵中 for each_passenger in passengers: x1, y1 = each_passenger.split(" ") x1, y1 = gmpy2.mpz(float(x1)), gmpy2.mpz(float(y1)) cost_line = list() for each_car in cars: x2, y2 = each_car.split(" ") x2, y2 = float(x2), float(y2) cost = gmpy2.sqrt((x1 - x2)**2 + (y1 - y2)**2) cost_line.append(cost) matrix.append(cost_line) return matrix
import gmpy2 from Crypto.Util.number import inverse gmpy2.get_context().precision = 4096 n = 3332188378295875783869064122703412230143264268626208625352231809707004626253693498892823264566220909462343272078555847886616528581762042090546179170482236487869003184706780657600698382325015809116744248893806650852223735783470295773006852652525553466007962717720284304724619241395637108961365171979649 e = 65537 ct = 3316983025788692017396821771835311006322014015027406970602003270080890623639030751135640062117695237676733971772109533247669892340663705733239749827632105244781062716356677792105791119992377197378659424691710778109509477222535640626877439474417447571477422236539760920897186204634495349674479974912987 p = int(gmpy2.sqrt(n)) phi = n - p d = inverse(e, phi) pt = pow(ct, d, n) hex_pt = hex(pt) flag = bytes.fromhex(hex_pt[2:]) print(flag)
import gmpy2 T = int(raw_input()) + 1 for i in range(1, T): line = raw_input() [A, B] = line.split(' ') A = int(A) B = int(B) fairsquare = 0 for x in range(A, B + 1): if gmpy2.is_square(x) and str(x) == str(x)[::-1]: root = int(gmpy2.sqrt(x)) if str(root) == str(root)[::-1]: fairsquare = fairsquare + 1 print 'Case #' + str(i) + ': ' + str(fairsquare)
def break_primes(n, process_id, sync, output): # check to see if the primes were the same gmpy2.get_context().precision = 4096 n_sqrt = gmpy2.sqrt(n) # check to see if the modulo is a perfect square root of itself if n_sqrt % 1 == 0.0: processLock.acquire() if output.empty(): output.put(n_sqrt) sync.set() print("Duplicate primes detected! Prime is", n_sqrt) processLock.release() return n_sqrt # trial division processLock.acquire() # loop through the trivial primes for i in range(len(primes)): # check if we've haven't found anything yet if output.empty(): # the smaller of any factors of modulo has to be less than the sqrt of that modulo so we can give up if we # haven't found anything by then if primes[i] > gmpy2.sqrt(n): break elif gmpy2.f_mod(n, primes[i]) == 0.0: # share the result and handle the multiprocessing cleanup print("Trial Division Success! Divisible by", primes[i]) print("Result is", n // primes[i]) output.put(primes[i]) sync.set() # processLock.release() return primes[i] processLock.release() # informative statements if DEBUG: print("No Trivial") print("nothing easy :(") # check to see if the modulo is vulnerable to pollard p - 1 p1_result = pollard_p1(n, process_id) processLock.acquire() if p1_result > 1 and output.empty(): # share the result and handle the multiprocessing cleanup print(process_id, "p1 factor found:", p1_result) output.put(p1_result) sync.set() return p1_result if DEBUG: print(process_id, ": p1 no factors") processLock.release() # check to see if the modulo is vulnerable to william p + 1 william = 1 # william_p1(n, process_id) processLock.acquire() if william > 1 and output.empty(): # share the result and handle the multiprocessing cleanup print("William factor found:", william) output.put(william) sync.set() return william if DEBUG: print(process_id, ": william no factors") processLock.release() # if all else fails try pollard rho on it rho_result = pollard_rho(n, process_id) processLock.acquire() if output.empty(): # share the result and handle the multiprocessing cleanup print(process_id, "rho factor found:", rho_result) output.put_nowait(rho_result) sync.set() # processLock.release() return rho_result
# brew install gmp # brew install mpfr # brew install libmpc # bin/easy_install http://gmpy.googlecode.com/files/gmpy2-2.0.0b1.zip # wget http://www.math.umbc.edu/~campbell/Computers/Python/numbthy.py from __future__ import division # division with floats import gmpy2 gmpy2.get_context().precision = 1100 N = 179769313486231590772930519078902473361797697894230657273430081157732675805505620686985379449212982959585501387537164015710139858647833778606925583497541085196591615128057575940752635007475935288710823649949940771895617054361149474865046711015101563940680527540071584560878577663743040086340742855278549092581 A = gmpy2.ceil(gmpy2.sqrt(N)) A2 = A**2 print "N :", int(N) print "sq(A): %.f" % gmpy2.sqrt(N) print "round:", int(gmpy2.ceil(gmpy2.sqrt(N))) print "A^2 :", int(A2) assert A2 > N x = gmpy2.sqrt(A2 - N) print "x :", int(x) p = gmpy2.sub(A, x) q = gmpy2.add(A, x) print "p*q :", int(gmpy2.mul(p, q))
def fp_sqrt(self) -> 'FPVector': return type(self)(gmpy2.sqrt(self._value))
dat = in_file.readline().strip().split() d = mpfr(dat[0]) n = int(dat[1]) a = int(dat[2]) this_time, this_pos = map(mpfr, in_file.readline().strip().split()) last_time, last_pos = this_time, this_pos car_time = 0.0 inp_count = 1 while this_pos < d: last_time, last_pos = this_time, this_pos dat = in_file.readline().strip().split() this_time, this_pos = map(mpfr, dat) inp_count += 1 if this_pos >= d: spd = (this_pos - last_pos) / (this_time - last_time) car_time = (d - last_pos) / spd + last_time break while inp_count < n: in_file.readline() inp_count += 1 a_data = map(mpfr, in_file.readline().strip().split()) pp('Case #' + str(case) + ':') for acc in a_data: opt_time = sqrt(2.0 * d / acc) # print opt_time, car_time pp(str(max(opt_time, car_time))) out_file.close() in_file.close()
import gmpy2 gmpy2.get_context().precision=100 # in bits min_delta = 1e-20 # this implementation assumes the signs for a and b and sometimes fails print(f"Finding n s.t. (√2-1)^n < min_delta") n = 0 while (gmpy2.sqrt(2) - 1)**n > min_delta: n += 1 print(f"n: {n}") print((gmpy2.sqrt(2) - 1)**n) print(50*'-') print(f"Simplifying (√2-1)^n to a√2 - b") simplified = sympy.expand((sympy.sqrt(2)-1)**n) a, b = simplified.args[1].args[0], -1*simplified.args[0] print(f"a={a}, b={b}") print(50*'-') print("Factoring a and b into their binary representations") def two_powers(num): return [i for i, bit in enumerate(bin(num)[:1:-1]) if bit == "1"] a_powers, b_powers = two_powers(a), two_powers(b) print(f'''a: {a} = {' + '.join([f"2^{x}" for x in a_powers])}''') print(f'''b: {b} = {' + '.join([f"2^{x}" for x in b_powers])}''') print(50*'-') print("Forming and outputting the smooth sets A and B") A = [2**(2*x+1) for x in a_powers] B = [2**(2*x) for x in b_powers] print(f'''A: {', '.join([f"2^{2*x+1}" for x in a_powers])}''') print(f'''B: {', '.join([f"2^{2*x}" for x in b_powers])}''')
def isqrt(n): n = gmpy2.mpz(n) x = gmpy2.sqrt(n) return int(x)
def smooth_sum(nums): return sum(gmpy2.sqrt(x) for x in nums) print(smooth_sum(A) - smooth_sum(B))
import math import gmpy2 N = gmpy2.mpz( E8953849F11E932E9127AF35E1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000051F8EB7D0556E09FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFBAD55 ) gmpy2.get_context().precision = 2048 a = int(gmpy2.sqrt(n)) a2 = a * a b2 = gmpy2.sub(a2, N) while not (gmpy2.is_square(b2)): a = a + 1 b2 = a * a - N b2 = gmpy2.mpz(b2) gmpy2.get_context().precision = 2048 b = int(gmpy2.sqrt(b2)) print a + b print a - b
from gmpy2 import context, set_context from gmpy2 import mpfr, sqrt, const_pi, exp, sin, cos, polar, norm import matplotlib.pyplot as plt from seaborn import set_style # ------------------------------------------------ ### DEFINITIONS ### set_style('darkgrid') bits = 64 set_context(context(precision=bits, allow_complex=True)) I = sqrt(-1) pi = const_pi(bits) # ------------------------------------------------ ### FUNCTIONS ### def backf(val, digits=8): return [backf(v, digits) for v in val] if isinstance(val, (list, tuple, map, zip)) else float(round(val, digits)) def fourier(func, dt, freq_max):
def mainloop(n, u, p1): ''' Input: n -- an integer to (try) to factor. u -- the phase 1 smoothness bound p1 -- a list of sigma parameters to try Output: A factor of n. (1 is returned on faliure). Notes: 1. Other parameters, such as the phase 2 smoothness bound are selected by the mainloop function. 2. This function uses batch algorithms, so if p1 is not long enough, there will be a loss in efficiency. 3. Of course, if p1 is too long, then the mainloop will have to use more memory. [The memory is polynomial in the length of p1, log u, and log n].''' k = inv_const(n) log_u = math.log(u) log_log_u = math.log(log_u) log_n = math.log(n) u2 = int(_7_OVER_LOG_2 * u * log_u / log_log_u) ncurves = len(p1) w = int(math.sqrt(_3_OVER_LOG_2 * ncurves / k) - 0.5) number_of_primes = int((ncurves << w) * math.sqrt(LOG_4_OVER_9 * log_n / k) / log_u) # Lagrange multipliers! number_of_primes = min(number_of_primes, int((log_n / math.log(log_n))**2 * ncurves / log_u), int(u / log_u)) number_of_primes = max(number_of_primes, 1) m = math.log(number_of_primes) + log_log_u w = min(w, int((m - 2 * math.log(m) + LOG_3_MINUS_LOG_LOG_2) / LOG_2)) w = max(w, 1) max_order = n + sqrt(n << 2) + 1 # By Hasse's theorem. det_bound = ((1 << w) - 1 + ((w & 1) << 1)) / 3 log_mo = math.log(max_order) p = range(number_of_primes) prime = mpz(2) p1 = get_points(p1, n) if not isinstance(p1, list): return p1 for _ in xrange(int(log_mo / LOG_2)): p1 = double(p1, n) if not isinstance(p1, list): return p1 for i in xrange(1, det_bound): prime = (i << 1) + 1 if isprime(prime): for _ in xrange(int(log_mo / math.log(prime))): p1 = multiply(p1, prime, n) if not isinstance(p1, list): return p1 while prime < sqrt(u) and isinstance(p1, list): for i in xrange(number_of_primes): prime = next_prime(prime) p[i] = prime ** max(1, int(log_u / math.log(prime))) p1 = fast_multiply(p1, prod(p), n, w) if not isinstance(p1, list): return p1 while prime < u and isinstance(p1, list): for i in xrange(number_of_primes): prime = next_prime(prime) p[i] = prime p1 = fast_multiply(p1, prod(p), n, w) if not isinstance(p1, list): return p1 del p small_jump = int(greatest_n((1 << (w + 2)) / 3)) small_jump = max(120, small_jump) big_jump = 1 + (int(sqrt((5 << w) / 21)) << 1) total_jump = small_jump * big_jump big_multiple = max(total_jump << 1, ((int(next_prime(prime)) - (total_jump >> 1)) / total_jump) * total_jump) big_jump_2 = big_jump >> 1 small_jump_2 = small_jump >> 1 product = ONE psmall_jump = multiply(p1, small_jump, n) if not isinstance(psmall_jump, list): return psmall_jump ptotal_jump = multiply(psmall_jump, big_jump, n) if not isinstance(ptotal_jump, list): return ptotal_jump pgiant_step = multiply(p1, big_multiple, n) if not isinstance(pgiant_step, list): return pgiant_step small_multiples = [None] for i in xrange(1, small_jump >> 1): if gcd(i, small_jump) == 1: tmp = multiply(p1, i, n) if not isinstance(tmp, list): return tmp for i in xrange(len(tmp)): tmp[i] = tmp[i][0] small_multiples.append(tuple(tmp)) else: small_multiples.append(None) small_multiples = tuple(small_multiples) big_multiples = [None] for i in xrange(1, (big_jump + 1) >> 1): tmp = multiply(psmall_jump, i, n) if not isinstance(tmp, list): return tmp big_multiples.append(to_tuple(tmp)) big_multiples = tuple(big_multiples) psmall_jump = to_tuple(psmall_jump) ptotal_jump = to_tuple(ptotal_jump) while big_multiple < u2: big_multiple += total_jump center_up = big_multiple center_down = big_multiple pgiant_step = add(ptotal_jump, pgiant_step, n) if not isinstance(pgiant_step, list): return pgiant_step prime_up = next_prime(big_multiple - small_jump_2) while prime_up < big_multiple + small_jump_2: s = small_multiples[abs(int(prime_up) - big_multiple)] for j in xrange(ncurves): product *= pgiant_step[j][0] - s[j] product %= n prime_up = next_prime(prime_up) for i in xrange(1, big_jump_2 + 1): center_up += small_jump center_down -= small_jump pmed_step_up, pmed_step_down = add_sub_x_only(big_multiples[i], pgiant_step, n) if pmed_step_down == None: return pmed_step_up while prime_up < center_up + small_jump_2: s = small_multiples[abs(int(prime_up) - center_up)] for j in xrange(ncurves): product *= pmed_step_up[j] - s[j] product %= n prime_up = next_prime(prime_up) prime_down = next_prime(center_down - small_jump_2) while prime_down < center_down + small_jump_2: s = small_multiples[abs(int(prime_down) - center_down)] for j in xrange(ncurves): product *= pmed_step_down[j] - s[j] product %= n prime_down = next_prime(prime_down) if gcd(product, n) != 1: return gcd(product, n) return 1
def sub_sub_sure_factors(f, u, curve_parameter): '''Finds all factors that can be found using ECM with a smoothness bound of u and sigma and give curve parameters. If that fails, checks for being a prime power and does Fermat factoring as well. Yields factors.''' while not (f & 1): yield 2 f >>= 1 while not (f % 3): yield 3 f /= 3 if isprime(f): yield f return log_u = math.log(u) u2 = int(_7_OVER_LOG_2 * u * log_u / math.log(log_u)) primes = [] still_a_chance = True log_mo = math.log(f + 1 + sqrt(f << 2)) g = gcd(curve_parameter, f) if g not in (1, f): for factor in sub_sub_sure_factors(g, u, curve_parameter): yield factor for factor in sub_sub_sure_factors(f/g, u, curve_parameter): yield factor return g2 = gcd(curve_parameter**2 - 5, f) if g2 not in (1, f): for factor in sub_sub_sure_factors(g2, u, curve_parameter): yield factor for factor in sub_sub_sure_factors(f / g2, u, curve_parameter): yield factor return if f in (g, g2): yield f while still_a_chance: p1 = get_points([curve_parameter], f) for prime in primes: p1 = multiply(p1, prime, f) if not isinstance(p1, list): if p1 != f: for factor in sub_sub_sure_factors(p1, u, curve_parameter): yield factor for factor in sub_sub_sure_factors(f/p1, u, curve_parameter): yield factor return else: still_a_chance = False break if not still_a_chance: break prime = 1 still_a_chance = False while prime < u2: prime = next_prime(prime) should_break = False for _ in xrange(int(log_mo / math.log(prime))): p1 = multiply(p1, prime, f) if not isinstance(p1, list): if p1 != f: for factor in sub_sub_sure_factors(p1, u, curve_parameter): yield factor for factor in sub_sub_sure_factors(f/p1, u, curve_parameter): yield factor return else: still_a_chance = True primes.append(prime) should_break = True break if should_break: break for i in xrange(2, int(math.log(f) / LOG_2) + 2): r = root(f, i) if r[1]: for factor in sub_sub_sure_factors(r[0], u, curve_parameter): for _ in xrange(i): yield factor return a = 1 + sqrt(f) bsq = a * a - f iter = 0 while bsq != sqrt(bsq)**2 and iter < 3: a += 1 iter += 1 bsq += a + a - 1 if bsq == sqrt(bsq)**2: b = sqrt(bsq) for factor in sub_sub_sure_factors(a - b, u, curve_parameter): yield factor for factor in sub_sub_sure_factors(a + b, u, curve_parameter): yield factor return yield f return
import gmpy2 N = gmpy2.mpz( 0xE8953849F11E932E9127AF35E1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000051F8EB7D0556E09FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFBAD55 ) gmpy2.get_context().precision = 2048 a = int(gmpy2.sqrt(N)) a2 = a * a b2 = gmpy2.sub(a2, N) while not (gmpy2.is_square(b2)): a = a + 1 b2 = a * a - N b2 = gmpy2.mpz(b2) gmpy2.get_context().precision = 2048 b = int(gmpy2.sqrt(b2)) p = a + b q = a - b print p print q