def test_polySubtract2(self): poly1 = poly.Poly([]) poly2 = poly.Poly([1,1]) testDiff = poly1 - poly2 correctDiff = poly.Poly([-1,-1]) self.assertEqual(correctDiff,testDiff)
def test_normPolyB2(self): NF = poly.NumberField(poly.Poly([8,29,15,1])) a = -8 b = 3 NF = poly.NumberField(poly.Poly([8,29,15,1])) polyNormB = NF.getPolyNormB(b) self.assertEqual(polyNormB.evaluate(a),-5696)
def __init__(self): self.res = (960, 540) self.screen = pygame.display.set_mode(self.res) self.clock = pygame.time.Clock() self.cam = camera.Camera(self.screen, self.res) self.font_log = pygame.font.SysFont(None, 24) #textrect = text.get_rect() #textrect.centerx = screen.get_rect().centerx #textrect.centery = screen.get_rect().centery self.mouseLock = False self.polyList = [ poly.Poly([ vector.Vector3(10, 1, 0), vector.Vector3(10, 0, 1), vector.Vector3(10, 0, -1) ]) ] for i in range(100): self.polyList.append( poly.Poly([ vector.Vector3(10 + 5 * math.sin(i / 20), 1 + i / 10, 0), vector.Vector3(10 + 5 * math.sin(i / 20), 0, 1 + i / 10), vector.Vector3(10 + 5 * math.sin(i / 20), 0, -1 - i / 10) ]))
def test_equal(self): poly1 = poly.Poly([1,2,3,4]) poly2 = poly.Poly([1,2,3,4]) poly3 = poly.Poly([1,4,2,3]) self.assertEqual(poly1==poly2,True) self.assertEqual(poly1,poly2) self.assertNotEqual(poly1,poly3)
def test_reduceToNFp(self): p = 9923 poly1 = poly.Poly([7301,1477,7726]) poly2 = poly.Poly([8,29,15,1]) NFp = poly.NumberFieldModP(poly1,p) testReduction = NFp(poly2) correctReduction = NFp(poly.Poly([9858, 7744])) self.assertEqual(testReduction,correctReduction)
def test_degree(self): polynomial = poly.Poly([1,2,3]) self.assertEqual(polynomial.degree(), 2) polynomial = poly.Poly([0,2,3]) self.assertEqual(polynomial.degree(), 2) polynomial = poly.Poly([1,2,0]) self.assertEqual(polynomial.degree(), 1) polynomial = poly.Poly([1,2,3,4,5]) self.assertEqual(polynomial.degree(), 4)
def test_numberfield_sqrt_equality(self): nfspoly = poly.Poly([8,29,15,1]) prime = 9929 NFp = poly.NumberFieldModP(nfspoly,prime) posSqrt = NFp(poly.Poly([3077, 1160, 3402])) negSqrt = NFp(poly.Poly([6852, 8769, 6527])) self.assertEqual(posSqrt,-negSqrt) self.assertEqual(-posSqrt,negSqrt)
def test_numberfield_square2(self): # Brigg's example nfspoly = poly.Poly([8,29,15,1]) NF = poly.NumberField(nfspoly) nfspolyd = NF(nfspoly.derivative()) sqrt = NF(poly.Poly([3889976768, 3686043120, 599923511])) correctSquare = NF(poly.Poly([22939402657683071224L, 54100105785512562427L, 22455983949710645412L])) square = sqrt * sqrt self.assertEqual(square,correctSquare)
def test_numberfield_square1(self): # Spaans's example nfspoly = poly.Poly([161, 134, 2, 1]) NF = poly.NumberField(nfspoly) nfspolyd = NF(nfspoly.derivative()) sqrt = NF(poly.Poly([-41757429265579073242,-34105727598423382475,1681812579256330563])) correctSquare = NF(poly.Poly([21124198049840950371210079793023892077432,18523314201045731615331644622444823801483,884477920457388669411401815623954662863])) square = sqrt * sqrt self.assertEqual(square,correctSquare)
def test_numberfield_power_modp2(self): #Briggs polynomial = poly.Poly([8,29,15,1]) p = 9923 NFp = poly.NumberFieldModP(polynomial,p) g = NFp(poly.Poly([0,1])) ** p g = g - NFp(poly.Poly([0,1])) g = g.getPoly() correctG = poly.Poly([7301,1477,7726]) self.assertEqual(g,correctG)
def test_polyRootModPFastDeg5_2(self): p = 157 polynomial = poly.Poly([11,1])*poly.Poly([-23,1])*poly.Poly([-1,1])*poly.Poly([-1,1])*poly.Poly([-1,1]) correctRoots = poly.getRootsModPSlow(polynomial,p) testRoots = poly.getRootsModPFast(polynomial,p) correctRoots.sort() testRoots.sort() self.assertEqual(len(correctRoots),len(testRoots)) for i in range(len(correctRoots)): self.assertEqual(correctRoots[i], testRoots[i])
def test_numberfield_mult2(self): # Spaan's example nfspoly = poly.Poly([161, 134, 2, 1]) NF = poly.NumberField(nfspoly) nfspolyd = NF(nfspoly.derivative()) tomult = [[-92,-1],[-57,-1],[-23,-1],[-8,-1],[-7,-1],[2,-1],[10,-1],[17,-1],[29,-1],[35,-1],[84,-1],[115,-1],[139,-1],[-5,-2],[19,-2],[69,-2],[93,-2],[119,-2],[-542,-3],[-28,-3],[-23,-3],[-8,-3]] tomult = [NF(poly.Poly(x)) for x in tomult] correctProduct = NF(poly.Poly([21124198049840950371210079793023892077432,18523314201045731615331644622444823801483,884477920457388669411401815623954662863])) prod = multAllElements(NF(poly.Poly([1])),tomult) prod = prod * nfspolyd * nfspolyd self.assertEqual(prod,correctProduct)
def test_numberfield_mult1(self): # Briggs' example nfspoly = poly.Poly([8,29,15,1]) NF = poly.NumberField(nfspoly) nfspolyd = NF(nfspoly.derivative()) correctProduct = NF(poly.Poly([22939402657683071224L, 54100105785512562427L, 22455983949710645412L])) tomult = [[-1,1],[3,1],[13,1],[104,1],[3,2],[25,2],[-8,3],[48,5],[54,5],[-43,6],[-8,7],[11,7],[856,11]] tomult = [NF(poly.Poly(x)) for x in tomult] prod = multAllElements(NF(poly.Poly([1])),tomult) prod = prod * nfspolyd * nfspolyd self.assertEqual(prod,correctProduct)
def test_polyRootModPFastRandomZeroRoot(self): p = 503 polynomial = poly.Poly([0,1])*poly.Poly([-11,1])*poly.Poly([-51,1])*poly.Poly([-231,1]) correctRoots = poly.getRootsModPSlow(polynomial,p) testRoots = poly.getRootsModPFast(polynomial,p) correctRoots.sort() testRoots.sort() self.assertEqual(len(correctRoots),len(testRoots)) for i in range(len(correctRoots)): self.assertEqual(correctRoots[i], testRoots[i])
def test_numberfield_modp3(self): # again, for a different prime nfspoly = poly.Poly([161, 134, 2, 1]) NFp = poly.NumberFieldModP(nfspoly,2305843009213693973) nfspolyd = NFp(nfspoly.derivative()) tomult = [[-92,-1],[-57,-1],[-23,-1],[-8,-1],[-7,-1],[2,-1],[10,-1],[17,-1],[29,-1],[35,-1],[84,-1],[115,-1],[139,-1],[-5,-2],[19,-2],[69,-2],[93,-2],[119,-2],[-542,-3],[-28,-3],[-23,-3],[-8,-3]] tomult = [NFp(poly.Poly(x)) for x in tomult] sqrt = NFp(poly.Poly([2053587909481112245, 481917539782027120, 1681812579256330563])) correctProduct = sqrt * sqrt prod = multAllElements(NFp(poly.Poly([1])),tomult) prod = prod * nfspolyd * nfspolyd self.assertEqual(prod,correctProduct)
def test_numberfield_modp1(self): # Briggs' example nfspoly = poly.Poly([8,29,15,1]) NFp = poly.NumberFieldModP(nfspoly,9929) nfspolyd = NFp(nfspoly.derivative()) correctProduct = NFp(poly.Poly([6659,3891,2027])) tomult = [[-1,1],[3,1],[13,1],[104,1],[3,2],[25,2],[-8,3],[48,5],[54,5],[-43,6],[-8,7],[11,7],[856,11]] tomult = [NFp(poly.Poly(x)) for x in tomult] prod = multAllElements(NFp(poly.Poly([1])),tomult) prod = prod * nfspolyd * nfspolyd self.assertEqual(prod,correctProduct)
def test_numberfield_sqrt_modp2(self): # Briggs nfspoly = poly.Poly([161, 134, 2, 1]) primes = [2305843009213693951,2305843009213693967,2305843009213693973,2305843009213694381] tomult = [[-92,-1],[-57,-1],[-23,-1],[-8,-1],[-7,-1],[2,-1],[10,-1],[17,-1],[29,-1],[35,-1],[84,-1],[115,-1],[139,-1],[-5,-2],[19,-2],[69,-2],[93,-2],[119,-2],[-542,-3],[-28,-3],[-23,-3],[-8,-3]] for prime in primes: NFp = poly.NumberFieldModP(nfspoly,prime) tomultNFp = [NFp(poly.Poly(x)) for x in tomult] nfspolyd = NFp(nfspoly.derivative()) prod = multAllElements(NFp(poly.Poly([1])),tomultNFp) prod = prod * nfspolyd * nfspolyd sqrt = prod.sqrt() self.assertEqual(sqrt*sqrt,prod)
def test_numberfield_sqrt_modp1(self): # Briggs nfspoly = poly.Poly([8,29,15,1]) primes = [9851,9907,9929] tomult = [[-1,1],[3,1],[13,1],[104,1],[3,2],[25,2],[-8,3],[48,5],[54,5],[-43,6],[-8,7],[11,7],[856,11]] for prime in primes: NFp = poly.NumberFieldModP(nfspoly,prime) tomultNFp = [NFp(poly.Poly(x)) for x in tomult] nfspolyd = NFp(nfspoly.derivative()) prod = multAllElements(NFp(poly.Poly([1])),tomultNFp) prod = prod * nfspolyd * nfspolyd sqrt = prod.sqrt() self.assertEqual(sqrt*sqrt,prod)
def test_numberfield_modp2(self): # Spaans' examples nfspoly = poly.Poly([161, 134, 2, 1]) NFp = poly.NumberFieldModP(nfspoly,2305843009213693951) nfspolyd = NFp(nfspoly.derivative()) tomult = [[-92,-1],[-57,-1],[-23,-1],[-8,-1],[-7,-1],[2,-1],[10,-1],[17,-1],[29,-1],[35,-1],[84,-1],[115,-1],[139,-1],[-5,-2],[19,-2],[69,-2],[93,-2],[119,-2],[-542,-3],[-28,-3],[-23,-3],[-8,-3]] tomult = [NFp(poly.Poly(x)) for x in tomult] # Spaans provides the sqrt, so square that. sqrt = NFp(poly.Poly([2053587909481111827,481917539782026790,1681812579256330563])) correctProduct = sqrt * sqrt prod = multAllElements(NFp(poly.Poly([1])),tomult) prod = prod * nfspolyd * nfspolyd self.assertEqual(prod,correctProduct)
def main(): (n, nfsPoly, m, B, M, K) = files.loadParamsFile() afBase = files.loadFileArray("afbase.txt") rfBase = files.loadFileArray("rfbase.txt") smoothsFile = open("smooths.txt", "w") smoothsCount = 0 q = B K += K / 10 specialqFile = open("specialq.txt", "w") while (smoothsCount < K): while (True): q = primemath.nextPrime(q) roots = poly.getRootsModPFast(poly.Poly(nfsPoly), q) if (len(roots) > 0): break roots.sort() for s in roots: specialqFile.write(str([s, q]) + "\n") print "special_q: %s" % [q, s] I = 1024 J = 512 smooths = sieve_special_q(q, s, I, J, rfBase, afBase, (n, nfsPoly, m, B, M, K)) smoothsCount += len(smooths) print "total smooths: %s/%s" % (smoothsCount, K) smoothsFile = open("smooths.txt", "a") for smooth in smooths: smoothsFile.write(str(smooth) + "\n") smoothsFile.close()
def getAlgPrimeExponents(smooths, NF, base): primeExponents = [0] * len(base) for i in range(len(smooths)): smoothNorm = NF(poly.Poly(smooths[i])).norm() smoothPrimeExponents = getPrimeExponents(smoothNorm, base) sumExponents(primeExponents, smoothPrimeExponents) return primeExponents
def generateNFSPoly(n, d): m = int(math.pow(n, 1.0 / d)) nfsPoly = poly.Poly(expansionBaseM(n, m)) shrinkNfsPoly(nfsPoly, m) while (reducible(nfsPoly)): m -= 1 nfsPoly = Poly(expansionBaseM(n, m)) shrinkNfsPoly(nfsPoly, m) return (m, nfsPoly)
def main(): nfspoly = poly.Poly([8, 29, 15, 1]) NF = poly.NumberField(nfspoly) while (True): q = primemath.generateLargePrime(10) s = poly.getRootsModPFast(nfspoly, q) if (len(s) > 0): break s = s[0] print "special_q: f(%s) = 0 mod %s" % (s, q) while (True): p = primemath.generateLargePrime(7) r = poly.getRootsModPFast(nfspoly, p) if (len(r) > 0): break r = r[0] print "p: f(%s) = 0 mod %s" % (r, p) basis = find_sublattice_basis(q, s, p, r) print "basis: %s" % basis basis_r = reduce_basis(basis[0], basis[1]) a0 = basis_r[0][0] b0 = basis_r[0][1] a1 = basis_r[1][0] b1 = basis_r[1][1] print "reduced basis: %s" % [[a0, b0], [a1, b1]] print "generating lattice points..." for i in range(-20, 20): for j in range(-20, 20): a = a0 * i + a1 * j b = b0 * i + b1 * j if (a == 0 or b == 0): continue NFelement = NF(poly.Poly([a, b])) if (NFelement.norm() % q == 0 and NFelement.norm() % p == 0): print "%s is q-divisible and p-divisible" % [a, b] else: raise AssertionError("%s is not q-divisible or p-divisible" % [a, b])
def calcAlgMatrixRowsSum(afBase, smooths, m, NF): matrixRowSum = [0] * (len(afBase)) for smoothPair in smooths: smoothPoly = poly.Poly(smoothPair) matrixRow = matrixmath.getMatrixRowAlg(smoothPoly, NF, afBase) for i in range(len(matrixRow)): matrixRowSum[i] += matrixRow[i] return matrixRowSum
def test_numberfield_positivesquareroot_modp1(self): # Briggs' CRT example n = 45113 m = 31 nfspoly = poly.Poly([8,29,15,1]) tomult = [[-1,1],[3,1],[13,1],[104,1],[3,2],[25,2],[-8,3],[48,5],[54,5],[-43,6],[-8,7],[11,7],[856,11]] primeSizeEst = etcmath.calcRequiredPrimeLength(n, m, nfspoly, tomult) #primes = randomPrimes(primeSizeEst,32) prime = 9929 NFp = poly.NumberFieldModP(nfspoly,prime) nfspolyd = NFp(nfspoly.derivative()) tomultNFp = [NFp(poly.Poly(x)) for x in tomult] prod = multAllElements(NFp(poly.Poly([1])),tomultNFp) prod = prod * nfspolyd * nfspolyd sqrt = prod.sqrt() posSqrt = NFp(poly.Poly([3077, 1160, 3402])) negSqrt = NFp(poly.Poly([6852, 8769, 6527])) self.assertTrue(sqrt == posSqrt or sqrt == negSqrt)
def test_polyRootModPSlow(self): nfspoly = poly.Poly([8,29,15,1]) correctRoots = [2,44,6] testRoots = poly.getRootsModPSlow(nfspoly,67) self.assertEqual(len(correctRoots), len(testRoots)) correctRoots.sort() testRoots.sort() for i in range(len(correctRoots)): self.assertEqual(correctRoots[i], testRoots[i])
def test_polyRootModPFast(self): # Briggs polynomial = poly.Poly([8,29,15,1]) testRoots = poly.getRootsModPFast(polynomial,67) correctRoots = [2,44,6] correctRoots.sort() testRoots.sort() self.assertEqual(len(correctRoots),len(testRoots)) for i in range(len(correctRoots)): self.assertEqual(correctRoots[i], testRoots[i])
def orth_pcd(order, dist, eps=1.e-16, normed=False, **kws): """ Create orthogonal polynomial expansion from pivoted Cholesky decompostion. Parameters ---------- order : int Order of polynomial expansion dist : Dist Distribution space where polynomials are orthogonal normed : bool If True orthonormal polynomials will be used instead of monic. **kws : optional Extra keywords passed to dist.mom Examples -------- # >>> Z = cp.Normal() # >>> print cp.orth_pcd(2, Z) # [1.0, q0^2-1.0, q0] """ raise DeprecationWarning("Obsolete. Use orth_chol instead.") dim = len(dist) basis = po.basis(1, order, dim) C = Cov(basis, dist) N = len(basis) L, P = pcd(C, approx=1, pivot=1, tol=eps) Li = np.dot(P, np.linalg.inv(L.T)) if normed: for i in xrange(N): Li[:, i] /= np.sum(Li[:, i] * P[:, i]) E_ = -po.sum(E(basis, dist, **kws) * Li.T, -1) coefs = np.zeros((N + 1, N + 1)) coefs[1:, 1:] = Li coefs[0, 0] = 1 coefs[0, 1:] = E_ out = {} out[(0, ) * dim] = coefs[0] basis = list(basis) for i in xrange(N): I = basis[i].keys[0] out[I] = coefs[i + 1] P = po.Poly(out, dim, coefs.shape[1:], float) return P
def orth_chol(order, dist, normed=True, sort="GR", **kws): """ Create orthogonal polynomial expansion from Cholesky decomposition Parameters ---------- order : int Order of polynomial expansion dist : Dist Distribution space where polynomials are orthogonal normed : bool If True orthonormal polynomials will be used instead of monic. sort : str Ordering argument passed to poly.basis. If custom basis is used, argument is ignored. kws : optional Keyword argument passed to dist.mom. Examples -------- >>> Z = cp.Normal() >>> print cp.orth_chol(3, Z) [1.0, q0, 0.707106781187q0^2-0.707106781187, 0.408248290464q0^3-1.22474487139q0] """ dim = len(dist) basis = po.basis(1, order, dim, sort) C = Cov(basis, dist) N = len(basis) L, e = chol_gko(C) Li = np.linalg.inv(L.T).T if not normed: Li /= np.repeat(np.diag(Li), len(Li)).reshape(Li.shape) E_ = -np.sum(Li * E(basis, dist, **kws), -1) coefs = np.empty((N + 1, N + 1)) coefs[1:, 1:] = Li coefs[0, 0] = 1 coefs[0, 1:] = 0 coefs[1:, 0] = E_ coefs = coefs.T out = {} out[(0, ) * dim] = coefs[0] for i in xrange(N): I = basis[i].keys[0] out[I] = coefs[i + 1] P = po.Poly(out, dim, coefs.shape[1:], float) return P
def main(): nfspoly = poly.Poly([8, 29, 15, 1]) NF = poly.NumberField(nfspoly) while (True): q = primemath.generateLargePrime(20) r = poly.getRootsModPFast(nfspoly, q) if (len(r) > 0): break r = r[0] print "special_q: f(%s) = 0 mod %s" % (r, q) basis = [] b = 1 for i in range(2): a = -b * r + i * q basis.append([a, b]) print "basis: %s" % basis basis_r = reduce_basis(basis[0], basis[1]) a0 = basis_r[0][0] b0 = basis_r[0][1] a1 = basis_r[1][0] b1 = basis_r[1][1] print "reduced basis: %s" % [[a0, b0], [a1, b1]] print "generating lattice points..." for i in range(-2, 2): for j in range(-2, 2): a = a0 * i + a1 * j b = b0 * i + b1 * j if (a == 0 or b == 0): continue NFelement = NF(poly.Poly([a, b])) if (NFelement.norm() % q == 0): print "%s is q-divisible" % [a, b] else: raise AssertionError("%s is not q-divisible" % [a, b])