def testLatticeGen(self): calc = Calculate() #Lattice sizes sizes = [0,1,2,3] sets = {0:set([(0,0)]), 1:set([(0,0),(0,1),(1,0),(1,1)]), 2:set([(0,0),(0,1),(1,0),(1,1),(2,0),(0,2),(1,2),(2,1),(2,2)]), 3:set([(0,0),(0,1),(1,0),(1,1),(2,0),(0,2),(2,1),(1,2),(2,2),(3,0),(0,3),(3,1),(1,3),(3,2),(2,3),(3,3)]) } for size in sizes: lattice = calc.square_lattice(size) eq_(sets[size],set(tuple(tuple(x) for x in lattice)))
def testPolygonScramble(self): # Here, rearrange polygon randomly and repeatedly get results. See if come out different. # Presets. precision = 20 maple_link = maple.MapleLink( "/opt/maple13/bin/maple -tu" ) #TODO: hopefully remove this maple dependency...too hardwirey. L = 3 calc = Calculate() polygon = calc.square_lattice(L) X, P = calc.correlations(polygon, maple_link, precision) # Get eigenvals with sympy.mpmath.extraprec(500): XP = X * P XPnum = sympy.matrix2numpy(XP) sqrt_eigs = sp.sqrt(linalg.eigvals(XPnum)) sqrt_eigs_orig = sqrt_eigs.real # Scramble polygon. sp.random.shuffle(polygon) # Perform the integration again. X, P = calc.correlations(polygon, maple_link, precision) # Get eigenvals with sympy.mpmath.extraprec(500): XP = X * P XPnum = sympy.matrix2numpy(XP) sqrt_eigs = sp.sqrt(linalg.eigvals(XPnum)) sqrt_eigs_scrambled = sqrt_eigs.real # Compare. a = set(tuple([round(float(x), 10) for x in sqrt_eigs_orig])) b = set(tuple([round(float(x), 10) for x in sqrt_eigs_scrambled])) eq_(a, b)
def testLatticeGen(self): calc = Calculate() #Lattice sizes sizes = [0, 1, 2, 3] sets = { 0: set([(0, 0)]), 1: set([(0, 0), (0, 1), (1, 0), (1, 1)]), 2: set([(0, 0), (0, 1), (1, 0), (1, 1), (2, 0), (0, 2), (1, 2), (2, 1), (2, 2)]), 3: set([(0, 0), (0, 1), (1, 0), (1, 1), (2, 0), (0, 2), (2, 1), (1, 2), (2, 2), (3, 0), (0, 3), (3, 1), (1, 3), (3, 2), (2, 3), (3, 3)]) } for size in sizes: lattice = calc.square_lattice(size) eq_(sets[size], set(tuple(tuple(x) for x in lattice)))
def testPolygonScramble(self): # Here, rearrange polygon randomly and repeatedly get results. See if come out different. # Presets. precision = 20 maple_link = maple.MapleLink("/opt/maple13/bin/maple -tu") #TODO: hopefully remove this maple dependency...too hardwirey. L = 3 calc = Calculate() polygon = calc.square_lattice(L) X,P = calc.correlations(polygon, maple_link, precision) # Get eigenvals with sympy.mpmath.extraprec(500): XP = X*P XPnum = sympy.matrix2numpy(XP) sqrt_eigs = sp.sqrt(linalg.eigvals(XPnum)) sqrt_eigs_orig = sqrt_eigs.real # Scramble polygon. sp.random.shuffle(polygon) # Perform the integration again. X,P = calc.correlations(polygon, maple_link, precision) # Get eigenvals with sympy.mpmath.extraprec(500): XP = X*P XPnum = sympy.matrix2numpy(XP) sqrt_eigs = sp.sqrt(linalg.eigvals(XPnum)) sqrt_eigs_scrambled = sqrt_eigs.real # Compare. a = set(tuple([round(float(x),10) for x in sqrt_eigs_orig])) b = set(tuple([round(float(x),10) for x in sqrt_eigs_scrambled])) eq_(a,b)
class CorrelationsTest(unittest.TestCase): #TODO: Currently limited to a small case. In future, when program optimized, expand this! maple_link = None # For L = 3... X = None P = None XP = None precision = None @classmethod def setUpClass(cls): cls.calc = Calculate() if cls.X is None and cls.P is None: # Startup Maple. #TODO: Replace with sympy when they fix bug (see src.main). This is ugly since relying on a hardcoded dir. cls.maple_link = maple.MapleLink("/opt/maple13/bin/maple -tu") cls.precision = 25 lattice = cls.calc.square_lattice(5) cls.X,cls.P = cls.calc.correlations(lattice,cls.maple_link,cls.precision) else: # TODO: rremove this if this doesn't show up print "Bug: This function has been called twice" def setUp(self): self.calc = Calculate() def testSymmetric(self): eq_(True,self.X.is_symmetric()) eq_(True,self.P.is_symmetric()) def testReal(self): eq_(True, self.X == self.X.conjugate()) eq_(True, self.P == self.P.conjugate()) def testPrecision(self): """ See if the precision increases with the variable. """ polygon = self.calc.square_lattice(1) precisions = [20,30,40,50] # Find X,P for each precision corrs_collection = [] for precision in precisions: X,P = self.calc.correlations(polygon, self.maple_link, precision) corrs_collection.append([X,P]) for i in range(0, len(precisions)-1): # get X and P pairs for precisions[i] and precisions[i+1] pairX = sp.array([corrs_collection[i][0],corrs_collection[i+1][0]]) pairP = sp.array([corrs_collection[i][1],corrs_collection[i+1][1]]) # Check if increasing the precision variable actually does this. bound = 10**(-precisions[i]) eq_(True, ( abs(pairX[0] - pairX[1]) < bound ).all()) eq_(True, ( abs(pairP[0] - pairP[1]) < bound ).all()) def testPrecomputed(self): """ Test the precomputed correlations feature. """ precision = 25 lattice3 = self.calc.square_lattice(3) lattice4 = self.calc.square_lattice(4) X3,P3 = self.calc.correlations(lattice3, self.maple_link, precision, verbose=True) X4,P4 = self.calc.correlations(lattice4, self.maple_link, precision, verbose=True) # With precomputed. precomputed_correlations = {} X3_quick, P3_quick, precomputed_correlations = self.calc.correlations(lattice3, self.maple_link, precision, precomputed_correlations, verbose=True) X4_quick, P4_quick, precomputed_correlations = self.calc.correlations(lattice4, self.maple_link, precision, precomputed_correlations, verbose=True) eq_(True, X3 == X3_quick) eq_(True, P3 == P3_quick) eq_(True, X4 == X4_quick) eq_(True, P4 == P4_quick) def testMatrixSymmetries(self): """ X and P should have the same pattern as the distance matrix defined by the lattice. """ precision = 20 polygon = self.calc.square_lattice(5) X,P = self.calc.correlations(polygon, self.maple_link, precision) # Round X and P down so we can see if elements are distinct or not. X = sympy.matrix2numpy(X) P = sympy.matrix2numpy(P) X = X.astype('float') P = P.astype('float') # Get the pattern of the distance matrix. D = spatial.distance.cdist(polygon,polygon) # The pattern of the distance matrix D_pat = sp.zeros(D.shape) getSignatureMatrix(D_pat,sp.nditer(D),D.shape) # Get the pattern of X and P. X_pat = sp.zeros(X.shape) P_pat = sp.zeros(P.shape) getSignatureMatrix(X_pat,sp.nditer(X),X.shape) getSignatureMatrix(P_pat,sp.nditer(P),P.shape) # Check if patterns match. eq_(False,(D_pat - X_pat).all()) eq_(False,(D_pat - P_pat).all())
class CorrelationsTest(unittest.TestCase): #TODO: Currently limited to a small case. In future, when program optimized, expand this! maple_link = None # For L = 3... X = None P = None XP = None precision = None @classmethod def setUpClass(cls): cls.calc = Calculate() if cls.X is None and cls.P is None: # Startup Maple. #TODO: Replace with sympy when they fix bug (see src.main). This is ugly since relying on a hardcoded dir. cls.maple_link = maple.MapleLink("/opt/maple13/bin/maple -tu") cls.precision = 25 lattice = cls.calc.square_lattice(5) cls.X, cls.P = cls.calc.correlations(lattice, cls.maple_link, cls.precision) else: # TODO: rremove this if this doesn't show up print "Bug: This function has been called twice" def setUp(self): self.calc = Calculate() def testSymmetric(self): eq_(True, self.X.is_symmetric()) eq_(True, self.P.is_symmetric()) def testReal(self): eq_(True, self.X == self.X.conjugate()) eq_(True, self.P == self.P.conjugate()) def testPrecision(self): """ See if the precision increases with the variable. """ polygon = self.calc.square_lattice(1) precisions = [20, 30, 40, 50] # Find X,P for each precision corrs_collection = [] for precision in precisions: X, P = self.calc.correlations(polygon, self.maple_link, precision) corrs_collection.append([X, P]) for i in range(0, len(precisions) - 1): # get X and P pairs for precisions[i] and precisions[i+1] pairX = sp.array( [corrs_collection[i][0], corrs_collection[i + 1][0]]) pairP = sp.array( [corrs_collection[i][1], corrs_collection[i + 1][1]]) # Check if increasing the precision variable actually does this. bound = 10**(-precisions[i]) eq_(True, (abs(pairX[0] - pairX[1]) < bound).all()) eq_(True, (abs(pairP[0] - pairP[1]) < bound).all()) def testPrecomputed(self): """ Test the precomputed correlations feature. """ precision = 25 lattice3 = self.calc.square_lattice(3) lattice4 = self.calc.square_lattice(4) X3, P3 = self.calc.correlations(lattice3, self.maple_link, precision, verbose=True) X4, P4 = self.calc.correlations(lattice4, self.maple_link, precision, verbose=True) # With precomputed. precomputed_correlations = {} X3_quick, P3_quick, precomputed_correlations = self.calc.correlations( lattice3, self.maple_link, precision, precomputed_correlations, verbose=True) X4_quick, P4_quick, precomputed_correlations = self.calc.correlations( lattice4, self.maple_link, precision, precomputed_correlations, verbose=True) eq_(True, X3 == X3_quick) eq_(True, P3 == P3_quick) eq_(True, X4 == X4_quick) eq_(True, P4 == P4_quick) def testMatrixSymmetries(self): """ X and P should have the same pattern as the distance matrix defined by the lattice. """ precision = 20 polygon = self.calc.square_lattice(5) X, P = self.calc.correlations(polygon, self.maple_link, precision) # Round X and P down so we can see if elements are distinct or not. X = sympy.matrix2numpy(X) P = sympy.matrix2numpy(P) X = X.astype('float') P = P.astype('float') # Get the pattern of the distance matrix. D = spatial.distance.cdist(polygon, polygon) # The pattern of the distance matrix D_pat = sp.zeros(D.shape) getSignatureMatrix(D_pat, sp.nditer(D), D.shape) # Get the pattern of X and P. X_pat = sp.zeros(X.shape) P_pat = sp.zeros(P.shape) getSignatureMatrix(X_pat, sp.nditer(X), X.shape) getSignatureMatrix(P_pat, sp.nditer(P), P.shape) # Check if patterns match. eq_(False, (D_pat - X_pat).all()) eq_(False, (D_pat - P_pat).all())