def __init__(self, difficulty): if difficulty not in [1, 2, 3]: raise ValueError('You gave an invalid difficulty of %d!' % difficulty) while True: a = not_named_yet.randint_no_zero(-coefficients_bound + 2, coefficients_bound - 2) b = random.randint(-coefficients_bound * 4, coefficients_bound * 4) c = random.randint(-coefficients_bound * 4, coefficients_bound * 4) discriminant = b**2 - 4 * a * c if difficulty == 1 and discriminant == 0 and (b == 0 or c == 0): break elif difficulty == 2 and discriminant > 0 and gmpy.is_square( discriminant): break elif difficulty == 3 and discriminant > 0 and not gmpy.is_square( discriminant): break self.equation = a * x**2 + b * x + c self.discriminant = b**2 - 4 * a * c self.domain = sympy.Interval(-sympy.oo, sympy.oo, True, True) vertex_x = -sympy.Rational(b, 2 * a) vertex_y = self.equation.subs({x: vertex_x}) if a > 0: self.range = sympy.Interval(vertex_y, sympy.oo, False, True) else: self.range = sympy.Interval(-sympy.oo, vertex_y, True, False)
def __init__(self, difficulty): if difficulty not in [1, 2, 3]: raise ValueError("You gave an invalid difficulty of %d!" % difficulty) while True: a = not_named_yet.randint_no_zero(-coefficients_bound + 2, coefficients_bound - 2) b = random.randint(-coefficients_bound * 4, coefficients_bound * 4) c = random.randint(-coefficients_bound * 4, coefficients_bound * 4) discriminant = b ** 2 - 4 * a * c if difficulty == 1 and discriminant == 0 and (b == 0 or c == 0): break elif difficulty == 2 and discriminant > 0 and gmpy.is_square(discriminant): break elif difficulty == 3 and discriminant > 0 and not gmpy.is_square(discriminant): break self.equation = a * x ** 2 + b * x + c self.discriminant = b ** 2 - 4 * a * c self.domain = sympy.Interval(-sympy.oo, sympy.oo, True, True) vertex_x = -sympy.Rational(b, 2 * a) vertex_y = self.equation.subs({x: vertex_x}) if a > 0: self.range = sympy.Interval(vertex_y, sympy.oo, False, True) else: self.range = sympy.Interval(-sympy.oo, vertex_y, True, False)
def Euler_98(i_file='98.txt'): '''Find the largest square anagram in the given text file The anagram of the word must exist in the text file ''' with open(i_file, encoding="utf-8") as data: for a_line in data: word_tuple = tuple([x.strip('"') for x in a_line.split('","')]) if not word_tuple: return None word_list = [x for x in reversed(sorted(list(word_tuple), key=len))] dict_list = [{a:x.count(a) for a in x} for x in word_list] ''' word_tuple = tuple(word_list) for x in range(len(word_tuple)): pair = False for y in range(len(word_list)): if (not word_tuple[x] == word_list[y]) and dict_list[ print(x,y) pair = True break if not pair: word_list.remove(x) ''' print(word_list) word_tuple = tuple(word_list) max_length = 0 max_sq = 0 digits = tuple(ord(c) for c in '0123456789') for index in range(word_tuple): word = word_tuple[index] tmp = dict_list[index] dict_list[index] = 0 if not tmp in dict_list: break if len(word) < max_length: break letter_set = tuple(ord(c) for c in set(word)) for guess in itertools.permutations(digits, len(letter_set)): translation = dict(zip(letter_set, guess)) if not gmpy.is_square(int(word.translate(translation))): continue word_dict = {x:word.count(x) for x in word} for candidate in word_tuple: if word_dict == {x:candidate.count(x) for x in candidate} and gmpy.is_square(int(candidate.translate(translation))): if int(candidate.translate(translation)) > max_sq: max_sq = int(candidate.translate(translation)) max_length = len(candidate) if int(word.translate(translation)) > max_sq: max_sq = int(word.translate(translation)) max_length = len(word) return max_sq
def q1(): N = gmpy.mpz( "17976931348623159077293051907890247336179769789423065727343008115 \ 77326758055056206869853794492129829595855013875371640157101398586 \ 47833778606925583497541085196591615128057575940752635007475935288 \ 71082364994994077189561705436114947486504671101510156394068052754 \ 0071584560878577663743040086340742855278549092581") A = gmpy.sqrt(N) + 1 x1 = A**2 - N assert gmpy.is_square(x1) x = gmpy.sqrt(x1) p = A - x q = A + x assert p * q == N print "Answer to Question 1:" print p #print q #print x # Answer: assert p == gmpy.mpz( "134078079299425970995740249982058461274793658205923933777235614437217640300736 \ 62768891111614362326998675040546094339320838419523375986027530441562135724301" ) return N, p, q
def parseFile(self, input_file):#parses a text file for its Sudoku grid ''' files will be saved in the the following format: 1,2,3,4,5,6,7,8,9 2,3,4,5,6,7,8,9,1 ... 9,8,7,6,4,5,3,1,2 ''' try: with open(input_file,"r") as f: self.grid = f.read().split("\n") if self.grid[-1] == "": self.grid.pop(-1) self.size = len(self.grid) if not is_square(self.size): sys.exit("Invalid input file length") for i in range(self.size): self.grid[i] = self.grid[i].split(",") if len(self.grid[i]) != self.size: sys.exit("Input file is formatted incorrectly") for j in range(self.size): try: self.grid[i][j] = [int(self.grid[i][j])] except ValueError: if self.grid[i][j] == "-" self.grid[i][j] = [i for i in range(1,self.size+1)] else: sys.exit("Input file is formatted incorrectly") except IOError: sys.exit("Input file does not exist")
def rational_golden_nugget(N): # assert N > 10, "N should be an integer larger than 10" # k = 74049691 #(k, 5*k^2 + 2*k + 1) #(2, 25) #(15, 1156) #(104, 54289) #(714, 2550409) #(4895, 119814916) #(33552, 5628750625) #(229970, 264431464441) #(1576239, 12422650078084) #(10803704, 583600122205489) #(74049690, 27416783093579881) #(507544127, 1288005205276048900) #s = [2,15,104,714,4895,33552,229970,1576239,10803704,74049690,507544127] index = 8 k = 10803704 kold = k d = 5*k**2 + 2*k + 1 while index < N: if gmpy.is_square(d): index += 1 print(index, k, d) kold = k k = int(6.8541*k) d = 5*k**2 + 2*k + 1 d += 10*k + 7 k += 1 return kold
def check(a,b,p): semip = p/2 c = (semip*(semip-b)) if gmpy.is_square(c): print (a,a,b,p) return True return False
def q2(): N = gmpy.mpz( "6484558428080716696628242653467722787263437207069762630604390703787 \ 9730861808111646271401527606141756919558732184025452065542490671989 \ 2428844841839353281972988531310511738648965962582821502504990264452 \ 1008852816733037111422964210278402893076574586452336833570778346897 \ 15838646088239640236866252211790085787877") A0 = gmpy.sqrt(N) + 1 for i in xrange(2**20): A = A0 + i x1 = A**2 - N if gmpy.is_square(x1): x = gmpy.sqrt(x1) p = A - x q = A + x if p * q == N: break assert p * q == N print "Answer to Question 2:" print p # Answer: assert p == gmpy.mpz( "254647961469961834380088165639739422293414542685241578463285819278857779699852 \ 22835143851073249573454107384461557193173304497244814071505790566593206419759" )
def to_matrix(s): s = s.rstrip() if gmpy.is_square(len(s)): r = int(round(len(s)**0.5)) nums = [ord(x.lower()) - 97 for x in s] arr = [nums[x:x + r] for x in range(0, len(nums), r)] return np.array(arr)
def solve(A, B): counter = 0 for x in range(A, B + 1): if is_fair(str(x)): if gmpy.is_square(x): if is_fair(str(gmpy.sqrt(x))): counter += 1 return counter
def count_odd_periods(max_root): count = 0 for root in xrange(2, max_root + 1): if gmpy.is_square(root): continue period = get_period(root) if period % 2 == 1: count += 1 return count
def diophantine(d): """Determines the minimum solution of x for the equation x**2 - Dy**2 = 1""" x = gmpy.mpz(2) while True: num = x*x-1 if num%d == 0 and gmpy.is_square(num/d): return x x += 1
def is_pentagonal(x): """Number x is pentagonal if (sqrt(24x+1) + 1) / 6 is natural""" root = 24*x+1 if gmpy.is_square(root): return 0 == (int(root**0.5) + 1) % 6 #if 0 == (int(root**0.5) + 1) % 6: # print (int(root**0.5) + 1) / 6 # return True return False
def find_minimal_sol(n): j = 1 while True: i_2 = 1 + n * j**2 if gmpy.is_square(i_2): i = math.sqrt(i_2) print i, j, n return i j += 1
def solve(a,b): global count aSqrt = int(sqrt(a)) if is_square(a) else int(sqrt(a)) + 1 bSqrt = int(sqrt(b)) count = 0 search([], aSqrt, bSqrt) return count
def fermat(N): a = gmpy.sqrt(N) b2 = a*a - N while not gmpy.is_square(gmpy.mpz(b2)): b2 += 2*a + 1 a += 1 factor1 = a - gmpy.sqrt(b2) factor2 = a + gmpy.sqrt(b2) return (long(factor1.digits()), long(factor2.digits()))
def area(a, b, c): if (a + b + c) & 1: return False s = (a + b + c) / 2 A = s * (s - a) * (s - b) * (s - c) if A < 0: return False return gmpy.is_square(A)
def getDivisors(num): """Gets the number of divisors for the number.""" # Start with 2 for num and 1 numDivisors = 2 for i in range(2, (int(math.sqrt(num)) + 1)): if num % i == 0: numDivisors += 2 if gmpy.is_square(num): numDivisors -= 1 return numDivisors
def solution(): # 422ms for d in itertools.count(1): D_ = 1 + 12*d*(3*d-1) for j in range(1, d): #cheat! (D-1)/3 J_ = 12*j*(3*j-1) K_ = D_ + J_ if not is_square(K_): continue N_ = K_ + J_ if not is_square(N_): continue k_ = int(math.sqrt(K_)) if k_ % 6 != 5: continue n_ = int(math.sqrt(N_)) if n_ % 6 != 5: continue #print 'd=',d, 'j=',j return pentagonal(d)
def __init__(self, size=400, *args, **kwargs): '''initializes a square playground. size must be a perfect square ''' if is_square(size): self.size = size self.length = int(sqrt(self.size)) self.set_grid() else: raise ValueError("size must be a perfect square") object.__init__(self, *args, **kwargs)
def palindromeQ(n): s = str(n) if s[-1] not in goodDigits: return False else: if gmpy.is_square(n): return (palindrome(s) and palindrome(str(math.floor(math.sqrt(n))))) else: return False
def getDivisors(num): """Gets the number of divisors for the number.""" #Start with 2 for num and 1 numDivisors = 2 for i in range(2, (int(math.sqrt(num)) + 1)): if (num % i == 0): numDivisors += 2 if gmpy.is_square(num): numDivisors -= 1 return numDivisors
def verify(self, f): k = f.numerator d = f.denominator phin = (self.key.e * d - 1) / k B = self.key.n - phin + 1 det = (B * B) - (4 * 1 * self.key.n) if det > 0 and gmpy.is_square(det): self.key.d = d self.key.phin = phin return True else: return False
def is_goldbach(n): for p in primes(): if p > n: return False if (n - p) % 2 != 0: continue sub_p = (n - p) // 2 if gmpy.is_square(sub_p): if (n % 1000 == 1): print(f'{n} = {p} + 2*{sub_p}') return True return False
def read_file(f): try: r = None with open(f, "r") as content: r = content.read() r = [c for c in r.replace('\n', ' ').split() if c != ''] if not is_square(len(r)): error(str(f) + " input is not a square", 5) make_matrix(r) return r except Exception as e: error(e.strerror, 4)
def slaves(): while True: b2 = queue.get() if b2 is None: break if gmpy.is_square(gmpy.mpz(b2)): with lock: finish.value = 1 a = gmpy.sqrt(n + b2) factor1 = a - gmpy.sqrt(b2) factor2 = a + gmpy.sqrt(b2) p.value = long(factor1.digits()) q.value = long(factor2.digits())
def factor_fermat(N): a = gmpy.sqrt(N) b2 = a * a - N tes = 0 while not gmpy.is_square(gmpy.mpz(b2)): b2 += 2 * a + 1 a += 1 tes += 1 if tes > 3000: return "x", "x" factor1 = a - gmpy.sqrt(b2) factor2 = a + gmpy.sqrt(b2) return (long(factor1.digits()), long(factor2.digits()))
def q3(): N = gmpy.mpz( "72006226374735042527956443552558373833808445147399984182665305798191 \ 63556901883377904234086641876639384851752649940178970835240791356868 \ 77441155132015188279331812309091996246361896836573643119174094961348 \ 52463970788523879939683923036467667022162701835329944324119217381272 \ 9276147530748597302192751375739387929") ''' Given: |3p - 2q| < N**(1/4) (1) N = pq Let A = (3p+2q)/2 => 2A = (6p+4q)/2 => 2A is an integer, and lies exactly midway between 6p and 4q Let 6p = 2A - x 4q = 2A + x => 24pq = 4A**2 - x**2 => 24N = 4A**2 - x**2 => x = sqrt(4A**2 - 24N) (2) To find x using (2), we need to find relation between A and N. Consider the value A**2 - 6N A**2 - 6N = (3p+2q)**2 / 4 - 6pq = (3p-2q)**2 / 4 , on simplifying. But, A**2 - 6N = (A + sqrt(6N))(A - sqrt(6N)) Hence, A - sqrt(6N) = (3p-2q)**2 / (4(A + sqrt(6N))) (3) Now A = (3p+2q)/2 > sqrt(3p*2q) = sqrt(6N) since AM > GM for 2 non-equal numbers => A > sqrt(6N) => A + sqrt(6N) > 2*sqrt(6N) Using above line in (3), we get the inequality: A - sqrt(6N) < (3p-2q)**2 / (8*sqrt(6N)) < sqrt(N) / (8*sqrt(6N)) Using (1) Thus A - sqrt(6N) < 1 / (8*sqrt(6) < 1 [Proved]''' twoA = gmpy.sqrt( 4 * 6 * N ) + 1 # A = sqrt(6N) + 0.5, since A, which is (3p+2q)/2, is NOT an integer. v = (twoA**2) - 24 * N assert gmpy.is_square(v) x = gmpy.sqrt(v) p = (twoA - x) / 6 q = (twoA + x) / 4 assert p * q == N print "Answer to Question 3:" print p # Answer: assert p == gmpy.mpz( "219098495924755330922739885315839558989821760933449290300994235841272120781261 \ 50044721102570957812665127475051465088833555993294644190955293613411658629209" )
def throughRange(low, high): count = 0 for i in range(low, high + 1): if (gmpy.is_square(i)): x = palindrone(list(str(i))) integer = math.sqrt(i) y = palindrone(list(str(int(math.sqrt(i))))) if (x and y): count += 1 return count
def check_range(start, end): qty = 0 i = start for i in xrange(start, end+1): if gmpy.is_square(i): strn = str(i) if strn == strn[::-1]: n = str(gmpy.sqrt(i)) if n == n[::-1]: qty += 1 i += 1 return qty
def factor_fermat(N): """ Guess at a and hope that a^2 - N = b^2, which is the case if p and q is "too close". """ a = gmpy.sqrt(N) b2 = a*a - N while not gmpy.is_square(gmpy.mpz(b2)): b2 += 2*a + 1 a += 1 factor1 = a - gmpy.sqrt(b2) factor2 = a + gmpy.sqrt(b2) return (int(factor1.digits()),int(factor2.digits()))
def wieners_attack(e, n): cf = continued_fraction(e, n) convergents = convergents_of_contfrac(cf) for k, d in convergents: if k == 0: continue phi, rem = divmod(e * d - 1, k) if rem != 0: continue s = n - phi + 1 # check if x^2 - s*x + n = 0 has integer roots D = s * s - 4 * n if D > 0 and gmpy.is_square(D): return d
def Fermat(n): """ Implementa el Método de Fermat para factorización de enteros """ if 1 & n == 0: return "The number is even" x = int(ceil(isqrt(n))) perfect = (x * x) - n isPerfect = False while not isPerfect: x += 1 perfect = (x * x) - n if gmpy.is_square(perfect): isPerfect = True return x - isqrt(perfect)
def fermat(n, astart, aend, astep, k): if k==len(moduli) or (aend-astart)/astep < 2: lista = [astart+i*astep for i in range(0,((aend-astart)/astep)+1)] listb2 = [a**2 - n for a in lista] return any([gmp.is_square(b2) for b2 in listb2]) result = [] mod, quadRes = moduli[k] a = astart for i in range(0, min(mod, (aend-astart)/astep + 1)): if ((a**2-n) % mod) in quadRes: result.append(fermat(n, a, aend, astep*mod, k+1)) a+=astep return any(result)
def Factor(n, parameter): if n % 2 == 0: return true a = gmp.sqrt(n) b2 = a**2-n bound = a + parameter while not gmp.is_square(b2) and a<=bound: b2=b2+2*a+1 a+=1 if a > bound: return False else: return True
def check(num): ''' if num is palindrome then add to palindrome dict if it is a perfect square then, check if square root is palindrome ''' if isPalindrome(str(num)): ''' ''' if gmpy.is_square(num): sq_root = int(math.sqrt(num)) if isPalindrome(str(sq_root)): return True return False
def wieners_attack(e, n): def continued_fraction(n, d): """ 415/93 = 4 + 1/(2 + 1/(6 + 1/7)) >>> continued_fraction(415, 93) [4, 2, 6, 7] """ cf = [] while d: q = n // d cf.append(q) n, d = d, n-d*q return cf def convergents_of_contfrac(cf): """ 4 + 1/(2 + 1/(6 + 1/7)) is approximately 4/1, 9/2, 58/13 and 415/93 >>> list(convergents_of_contfrac([4, 2, 6, 7])) [(4, 1), (9, 2), (58, 13), (415, 93)] """ n0, n1 = cf[0], cf[0]*cf[1]+1 d0, d1 = 1, cf[1] yield (n0, d0) yield (n1, d1) for i in xrange(2, len(cf)): n2, d2 = cf[i]*n1+n0, cf[i]*d1+d0 yield (n2, d2) n0, n1 = n1, n2 d0, d1 = d1, d2 cf = continued_fraction(e, n) convergents = convergents_of_contfrac(cf) for k, d in convergents: if k == 0: continue phi, rem = divmod(e*d-1, k) if rem != 0: continue s = n - phi + 1 # check if x^2 - s*x + n = 0 has integer roots D = s*s - 4*n if D > 0 and is_square(D): return d
def main(): board_size = 0 if len(sys.argv) < 2: print("Usage is ./main.py <N:int:perfect_square>") exit() try: board_size = int(sys.argv[1]) if not gmpy.is_square(board_size): print("Number is not a perfect square") exit() except ValueError: print("Argument is not int") exit() game = [[0 for _ in range(board_size)] for _ in range(board_size)] sudoku = Sudoku(game) sudoku.solve() sudoku.printGame()
def main(): max_D = 0 max_x = 0 y = 1 y_sqr = 1 while len(todo) > 0: for D in list(todo): if gmpy.is_square(D * y_sqr + 1): int_sqrt = int(sqrt(D * y_sqr + 1)) Ds[D] = int_sqrt todo.remove(D) print "D:", D print "Minimal (x, y):", int_sqrt, y if int_sqrt > max_x: max_x = int_sqrt max_D = D y_sqr += 2 * y + 1 y += 1 print max_D
def wiener(e, n): """ Wiener's Attack @param e int: public exponent @param n int: modulus @return d int: private key """ cf = continued_fraction(e, n) convergents = convergents_of_contfrac(cf) for k, d in convergents: if k == 0: continue phi, rem = divmod(e * d - 1, k) if rem != 0: continue s = n - phi + 1 D = s * s - 4 * n if D > 0 and gmpy.is_square(D): return d
def main(loc=""): raw = input('input location: ') f = open(raw, 'r+') o = open("C:/Users/Matt/Desktop/output.txt", 'w') num = int(f.readline()) #num of inputs board = "" inp = [] for j in xrange(0, num): inp = readinput(f, 1, 0) inpstr = ''.join(inp) bounds = inpstr.split(" ") count = 0 for i in xrange(int(bounds[0]), int(bounds[1]) + 1): if str(i) == str(i)[::-1]: if gmpy.is_square(i): root = int(math.sqrt(i)) print root if str(root) == str(root)[::-1]: count += 1 done(count, j, o)
def almostEqualTri(x, y): if gmpy.is_square(x**2-(y/2)**2): print("found %d" % x) return x+x+y return 0
solution by Kevin Retzke, May 2012 """ import math import gmpy def diophantine(d): """Determines the minimum solution of x for the equation x**2 - Dy**2 = 1""" x = gmpy.mpz(2) while True: num = x*x-1 if num%d == 0 and gmpy.is_square(num/d): return x x += 1 if __name__ == '__main__': assert map(diophantine, [2,3,5,6,7]) == [3,2,9,5,8] maxx = 0 maxd = 0 for d in xrange(2,62): if gmpy.is_square(d): continue x = diophantine(d) print d, x if x > maxx: maxx = x maxd = d #print maxd, maxx print maxd
while len(i) > 1: i.insert(0, i.pop(0) + i.pop(0)) while len(j) > 1: j.insert(0, j.pop(0) + j.pop(0)) # print i, j if i == j: print len(queue), str(current[0][0]) + ": " + (answers[str(current)][0]) + "\n", writefile.write(str(current[0][0]) + ": " + answers[str(current)][0] + "\n") # print curscore, len(queue), current, current = [Fraction(i[0], i[1]) for i in current] # print answers[str([(k.numerator, k.denominator) for k in current])] for i in range(len(current)): # sqrt temp = copy(current) tempstr = copy(stringrep) if is_square(temp[i].numerator) and is_square(temp[i].denominator): temp[i] = Fraction(-isqrt(temp[i].numerator), isqrt(temp[i].denominator)) tempstr.insert(i, "-sqrt(" + tempstr.pop(i) + ")") if str([(k.numerator, k.denominator) for k in temp]) not in answers: heapq.heappush(queue, (score(tempstr), [(k.numerator, k.denominator) for k in temp])) answers[str([(k.numerator, k.denominator) for k in temp])] = tempstr # Factorial temp = copy(current) tempstr = copy(stringrep) try: if temp[i].numerator >= 0 and temp[i].numerator < 20 and temp[i].denominator == 1: temp.insert(i, Fraction(-factorials[temp.pop(i).numerator], 1)) tempstr.insert(i, "-(" + tempstr.pop(i) + ")! ") if str([(k.numerator, k.denominator) for k in temp]) not in answers: heapq.heappush(queue, (score(tempstr), [(k.numerator, k.denominator) for k in temp])) answers[str([(k.numerator, k.denominator) for k in temp])] = tempstr
words = [] for key in dic.keys(): if len(dic[key])==2: words.append(dic[key]) elif len(dic[key])>=3: comb = itertools.combinations(dic[key],2) while (1): try: words.append(list(comb.next())) except StopIteration: break for word_pair in words: word0, word1 = word_pair a = itertools.permutations([1,2,3,4,5,6,7,8,9], len(word0)) print word_pair while(1): try: numbers = list(a.next()) dic = dict(zip(sorted(word0),numbers)) number0 = int("".join([str(dic[i]) for i in word0])) if gmpy.is_square(number0): number1 = int("".join([str(dic[i]) for i in word1])) if gmpy.is_square(number1): print number0, number1 except StopIteration: break
a = 1 yield a b = 5 yield b r = 0 while r < n: r = 6 * b - a yield r a = b b = r nums = seq_A001653() tr = next(nums) while True: tr = next(nums) s = tr ** 2 if (not gmpy.is_square(2 * s - 1)): continue t = (1 + gmpy.sqrt(2 * s - 1)) / 2 r = 1 + 2 * t ** 2 - 2 * t if (gmpy.is_square(r)): if (r % 2 == 1): print int(1+gmpy.sqrt(r))/2, t if (t > 10 ** 12): break
import gmpy side = 333333334 solution = 0 for x in xrange( 2, side ): for ( a, b, c ) in [ ( x, x, x + 1 ), ( x, x, x - 1 ) ]: if c % 2 == 0: s = ( a + b + c ) / 2 if gmpy.is_square( s * ( s - a ) * ( s - b ) * ( s - c ) ): solution = solution + a + b + c if x % 1000000 == 0: print "Progress: %i%%" % ( 100 * x / side ) print solution
def gevp(plotting_function, plotdata, bootstrapsize, pdfplot, logscale=False, verbose=False): """ Create a multipage plot with a page for every element of the rho gevp Parameters ---------- plotdata: pd.DataFrame Table with a row for each gevp element (sorted by gevp column running faster than gevp row) and hierarchical columns for gauge configuration number and timeslice bootstrapsize : int The number of bootstrap samples being drawn from `plotdata`. pdfplot : mpl.PdfPages object Plots will be written to the path `pdfplot` was created with. See also -------- utils.create_pdfplot() """ assert np.all(plotdata.notnull()), 'Gevp contains null entires' plotdata = mean_and_std(plotdata, bootstrapsize) # abs of smallest positive value #linthreshy = plotdata['mean'][plotdata['mean'] > 0].min().min() # abs of value closest to zero linthreshy = 1e3 * plotdata['mean'].iloc[plotdata.loc[:, ('mean', 0)].nonzero()].abs().min().min() # Create unique list of gevp elements to loop over while keeping order intact seen = set() plotlabel = [] for item in [(i[0], i[1]) for i in plotdata.index.values]: if item not in seen: seen.add(item) plotlabel.append(item) assert gmpy.is_square(len(plotlabel)), 'Gevp is not a square matrix' gevp_size = int(gmpy.sqrt(len(plotlabel))) # Prepare Figure fig, axes = plt.subplots(gevp_size, gevp_size, sharex=True, sharey=True) for counter, graphlabel in enumerate(plotlabel): if verbose: print '\tplotting ', graphlabel[0], ' - ', graphlabel[1] # Prepare Axes ax = axes[counter // gevp_size, counter % gevp_size] # ax.set_title(r'Gevp Element ${}$ - ${}$'.format(graphlabel[0], graphlabel[1])) ax.set_xlabel(r'$%s$' % graphlabel[1], fontsize=3, rotation=30) ax.set_ylabel(r'$%s$' % graphlabel[0], fontsize=3, rotation=30) # https://stackoverflow.com/questions/4209467/matplotlib-share-x-axis-but-dont-show-x-axis-tick-labels-for-both-just-one ax.label_outer() if logscale: # ax.locator_params(axis='y', numticks=3) ax.set_yscale('symlog', linthreshy=linthreshy) ax.set_xticks([]) # ax.tick_params(labelleft='off') ax.set_yticks([]) # Select data for plot graphdata = plotdata.xs(graphlabel, level=['gevp_row', 'gevp_col']) plotting_function(graphdata, ax, scale=gevp_size) if ax.legend_: ax.legend_.remove() # plt.locator_params(axis='y', numticks=2) plt.tight_layout(h_pad=0.1, w_pad=0.15) pdfplot.savefig(fig) plt.close(fig) return
def test_difficulty_three(): obj = quadratic.Quadratic(difficulty=3) assert obj.discriminant > 0 assert not gmpy.is_square(obj.discriminant)
def test_difficulty_two(): obj = quadratic.Quadratic(difficulty=2) assert obj.discriminant > 0 assert gmpy.is_square(obj.discriminant)
def is_diophantine_solution(d, x): tmp = x ** 2 - 1 if tmp % d != 0: return False return tmp / d > 0 and gmpy.is_square(tmp / d)
import gmpy def gcd(a,b): if b == 0: return a else: return gcd(b, a % b) l = set() for a in range(2,10**4): for b in range(1,a): if gcd(a,b) > 1: continue n = a**3*b+b**2 c = 1 if n > 10 ** 12: break if gmpy.is_square(n): print n l.add(n) while n < 10**12: c += 1 n = c**2*a**3*b+c*b**2 if gmpy.is_square(n): l.add(n) print n print sum(l)
q_n = int(x_n) P_n_minus_2 = 1 P_n_minus_1 = q_0 P_n = q_n * P_n_minus_1 + P_n_minus_2 Q_n_minus_2 = 0 Q_n_minus_1 = 1 Q_n = q_n * Q_n_minus_1 + Q_n_minus_2 while True: P_n_minus_2 = P_n_minus_1 Q_n_minus_2 = Q_n_minus_1 x_n, q_n, P_n, P_n_minus_1, Q_n, Q_n_minus_1 = pells_reccurence(x_n, q_n, P_n, P_n_minus_1, Q_n, Q_n_minus_1) n = n + 1 print "\tx_n=%s" % x_n if x_n == x_1: # n == k + 1 # k = n - 1 # x = P_k_minus_1 = P_n_minus_2 P = P_n_minus_2 Q = Q_n_minus_2 if P**2 - d * Q**2 == 1: return P else: assert(P**2 - d * Q**2 == -1) return P**2 + d * Q**2 if __name__ == '__main__': max_d = 1000 solutions = [(d, solve_pells_equation(d)) for d in xrange(1, max_d + 1) if not gmpy.is_square(d)] print max(solutions, key=lambda x: x[1])
#!/usr/bin/python from gmpy import is_square import sys M=int(sys.argv[1]) powers=range(int(((M+M)**2+M**2)**0.5)+1) count=0 for i in range(1,M+1): for j in range(i,M+1): a=(i+j)**2 count+=sum([1 for k in range(j,M+1) if is_square(a+k**2)]) print count print count
# Her ne kadar 6 bilinmeyen var gibi görünse de bunlardan üçünü bildiğimizde kalan üçü onlar cinsinden hesaplanabilir. # 6 değişken tam kare olarak hesaplandığında geri kalan sadece onlara karşılık gelen x,y,z üçlüsünü hesaplamak olacaktır. # Aşağıdaki kod pisagor üçlüsü olma özelliği de kullanılarak daha verimli hale getirilebilir ama algoritma dersinde kullanmak için bu kadarını bırakıyorum. from gmpy import is_square def solve(a,b,c,d,e,f): x = (a+b)/2 y = (e+f)/2 z = (c-d)/2 if(x>y and y>z and z>0 and x==int(x) and y==int(y) and z==int(z)): return(int(x+y+z)) else: return(0) for a in range(2,1000): a2 = a**2 for c in range(2,1000): c2 = c**2 for d in range(2,1000): d2 = d**2 f2 = a2-c2 if(f2>0 and is_square(f2)): e2 = a2-d2 if(e2>0 and is_square(e2)): b2 = c2-e2 if(b2>0 and is_square(b2)): if(solve(a2,b2,c2,d2,e2,f2)!=0): print(solve(a2,b2,c2,d2,e2,f2)) break
def write_ascii_gevp(path, basename, data, verbose=1): ensure_dir(path) # Cast data into longish data format with only gevp_row and gevp_col as index data = data.T.reset_index().set_index(['cnfg', 'T']).stack( level=['gevp_row', 'gevp_col', 'p_{cm}', '\mu']).reset_index(['p_{cm}', '\mu', 'cnfg', 'T']) data[['p_x', 'p_y', 'p_z']] = data['p_{cm}'].apply(literal_eval).apply(pd.Series) del data['p_{cm}'] data.rename(columns={0: 'value', '\mu': 'alpha'}, inplace=True) gevp_indices = data.index.unique() operator_indices = data.loc[gevp_indices[0]].set_index( ['p_x', 'p_y', 'p_z', 'alpha']).index.unique() assert np.all(data.notnull()), ('Gevp contains null entires') assert gmpy.is_square(len(gevp_indices)), 'Gevp is not a square matrix' gevp_size = gmpy.sqrt(len(gevp_indices)) # Write file with physical content corresponding to gevp index number (gevp_col) gevp_elements = [i[1] for i in gevp_indices.values[:gevp_size]] np.savetxt(os.path.join(path, basename + '_gevp-indices.tsv'), np.array(zip(range(gevp_size), gevp_elements)), fmt='%s', delimiter='\t', comments='', header='id\telement') # Write file with physical content corresponding to operator (p_cm, alpha) operator_elements = np.array([tuple(i) for i in operator_indices.values]) np.savetxt( os.path.join(path, basename + '_operator-indices.tsv'), np.column_stack( (np.arange( operator_elements.shape[0]), operator_elements)), fmt='%s', delimiter='\t', comments='', header='id\tp_x\tp_y\tp_z\talpha') if verbose: print 'Creating a {} x {} Gevp from {} operators'.format( gevp_size, gevp_size, operator_elements.shape[0]) # Loop over all projected operators and gevp elements and write an ascii file for gevp_counter, gevp_index in enumerate(gevp_indices): for operator_counter, operator_index in enumerate(operator_indices): filename = os.path.join( path, basename + '_op%d_gevp%d.%d.tsv' % (operator_counter, gevp_counter / gevp_size, gevp_counter % gevp_size)) df = data.loc[gevp_index].set_index( ['p_x', 'p_y', 'p_z', 'alpha']).loc[operator_index] df.to_csv(filename, sep='\t', index=False)