def __init__(self, p=Fraction(0), q=Fraction(0), ext=2):
self.p = p
self.q = q
self.ext = ext
if is_square(ext):
self.p += lsqrt(ext)
self.q = 0
while is_square(self.ext):
self.ext = lsqrt(self.ext)
def solve(N):
solutions = []
for m in range(1,2*lsqrt(lsqrt(N))+4):
n = find_n(m, N)
solutions.append((m,n, f(m,n)))
print(solutions)
closest = min(solutions, key=lambda (a,b,z): abs(z-N))
return closest[0]*closest[1]
def find_min_solution(D):
y = 1
if(is_square(D)):
return None
while(True):
xsq_candidate = D*(y**2) + 1
if(is_square(xsq_candidate)):
return (lsqrt(xsq_candidate), y)
y += 1
def factorize_with_eratosthenes(number, primes = None):
primes_in_number = []
if not primes:
primes = gen_sieve_eratosthenes(lsqrt(number))
for prime in primes:
while number % prime == 0:
primes_in_number.append(prime)
number = number / prime
if len(primes_in_number) == 0 or number > primes_in_number[-1]:
primes_in_number.append(number)
return primes_in_number
def solve(L):
solutions = {}
for a in range(1, L/4 + 1):
if a % 100 == 0:
print(a)
for b in range(a+1, (L-2*a)/2 + 1):
absq = a**2 + b**2
if is_square(absq):
c = lsqrt(absq)
try:
solutions[a + b + c].append((a,b,c))
except KeyError, e:
solutions[a + b + c] = [(a,b,c)]
def solve(N):
result = 0 #@UnusedVariable
perimeter_to_sides = {}
for a in range(1, N + 1):
for b in range(a, N-a + 1):
if is_square(a**2 + b**2):
p = perimeter(a, b)
if p > N:
break
c = lsqrt(a**2+b**2)
try:
perimeter_to_sides[p].append((a,b,c))
except KeyError, e:
perimeter_to_sides[p] = [(a,b,c)]
def solve(n):
for a in range(0, int(n/2) + 1):
asq = a**2
start = max(a+1, n/2 - a)
end = n/2
for b in range(start, end + 1):
bsq = b**2
csq_candidate = asq + bsq
if(is_square(csq_candidate) and csq_candidate > bsq):
c = lsqrt(csq_candidate)
if((a + b + c) == n):
return (a, b, c)
return None
def solve(N):
primes = sieve_eratosthenes(lsqrt(N)*2)
print_sieve_stats(primes)
min_frac = N
min_number = N
for step in range(1, 500):
for (p, q) in [(primes[i], primes[i-step]) for i in range(len(primes)-1, step-1, -1)]:
for (p_power, q_power) in zip(powers_below(p, N), powers_below(q, N)):
n = p_power*q_power
if n > N:
continue
phi = (p_power - p_power/p)*(q_power - q_power/q)
if permutation.is_permuted(n, phi):
frac = float(n)/phi
if frac < min_frac:
print(n, p, q, phi, frac, step)
min_frac = frac
min_number = n
return min_number
def perimeter(a, b):
c = lsqrt(a**2 + b**2)
return a + b + c
