def testShouldDivideTwoComplexNumbers(self):
c1 = complex.ComplexNumber(4, 5)
c2 = complex.ComplexNumber(2,6)
cResultTest = c1.division(c2)
cResultTest.showNumber()
self.assertAlmostEqual(cResultTest.partReal,0.95)
self.assertAlmostEqual(cResultTest.partImag,0.35)
def testShouldGetTheInnerProductoOfTwoMatrices(self):
m1 = matrix.Matrix([[complex.ComplexNumber(1, 0), complex.ComplexNumber(1, 0)], [complex.ComplexNumber(-1, 0), complex.ComplexNumber(1, 0)]])
m2 = matrix.Matrix([[complex.ComplexNumber(2, 0), complex.ComplexNumber(1, 0)], [complex.ComplexNumber(1, 0), complex.ComplexNumber(3, 0)]])
mTest = m1.innerProduct(m2)
mSol = 5
self.assertEqual(mSol,mTest.partReal)
def complexMatrix(self):
""" Crea una matriz con entradas de numeros complejos y retorna la
matrix creada"""
m = len(self) #rows
n = len(self[0]) #column
matrixC= [[complex.ComplexNumber(0,0) for x in range(n)] for y in range(m)]
for i in range (m):
for j in range (n):
matrixC[i][j] = complex.ComplexNumber(self[i][j][0], self[i][j][1])
return Matrix(matrixC)
def realMatrix(self):
""" Crea una matriz con entradas de numeros reales y retorna la
matrix creada"""
m = len(self) #rows
n = len(self[0]) #column
matrixR= [[complex.ComplexNumber(0,0) for x in range(n)] for y in range(m)]
for i in range (m):
for j in range (n):
matrixR[i][j] = complex.ComplexNumber(self[i][j], 0)
return Matrix(matrixR)
def booleanMatrix(pmatrix):
""" Crea una matriz con entradas de numeros booleanos y retorna la
matrix creada"""
m = len(pmatrix) #rows
n = len(pmatrix[0]) #column
matrixBoolean= [[complex.ComplexNumber(0,0) for x in range(n)] for y in range(m)]
for i in range (m):
for j in range (n):
matrixBoolean[i][j] = complex.ComplexNumber(pmatrix[i][j], 0)
return Matrix(matrixBoolean)
def test_01_integer_equality(self):
"""
Note all other tests depend on this test !
We want also to test the constructor, so in c we set stuff by hand
"""
c = ComplexNumber(0,0)
c.real = 1
c.imaginary = 2
self.assertEquals(c, ComplexNumber(1,2))
def trace (self):
""" Traza de una matriz: la suma de los elementos de la diagonal"""
if (self.m != self.n ):
raise Exception('The dimensions of rows and columns do not match')
else:
sum = complex.ComplexNumber(0,0)
for i in range (self.m):
self.mtx[i][i].showNumber()
sum = sum.add(self.mtx[i][i])
resp = complex.ComplexNumber(sum.partReal,sum.partImag)
return resp
def identityMatrix(rows, colums):
"""Crear una matriz de identidad (solo las entradas diferentes a cero
pertenecen a la diagonal) de filas rows y columnas columns"""
m = rows #rows
n = colums #column
matrixC= [[complex.ComplexNumber(0,0) for x in range(n)] for y in range(m)]
for i in range (m):
for j in range (n):
if i ==j:
matrixC[i][j] = complex.ComplexNumber(1, 0)
return Matrix(matrixC)
def testShouldGeteigenValues(self):
mSol = matrix.Matrix([[complex.ComplexNumber(1, 0), complex.ComplexNumber(-3, 0),complex.ComplexNumber(3, 0)], [complex.ComplexNumber(3, 0), complex.ComplexNumber(-5,0),complex.ComplexNumber(3, 0)],[complex.ComplexNumber(6, 0), complex.ComplexNumber(-6, 0),complex.ComplexNumber(4, 0)]])
listValues = mSol.eigenValues()
listSolutio = [complex.ComplexNumber(4, 0), complex.ComplexNumber(-2, 0),complex.ComplexNumber(-2, 0)]
result = True
if (len(listValues)!= len(listSolutio)):
raise Exception('The dimensions of the lists are not the same ')
for i in range(len(listValues)):
if(listValues[i].partReal != listSolutio[i].partReal or listValues[i].partImag != listSolutio[i].partImag):
result = False
self.assertTrue(result)
def sums(ls, start, end): """Sums up all the numbers in the given range of the list Input data: ls -- The list start -- The starting point of the range end -- The end point of the range Output data: The sum of the numbers in the given range """ s = ComplexNumber.create(0) for cn in ls[start:end + 1]: s = ComplexNumber.add(s, cn) return s
def eigenValues(self):
""" retorna los valores propios de una matriz"""
SympyMatrix = [[complex.ComplexNumber(0,0) for x in range(self.n)] for y in range(self.m)]
for i in range (self.m):
for k in range (self.n):
SympyMatrix[i][k] = ((self.mtx[i][k].partReal)+(self.mtx[i][k].partImag*1j))
matResult = sympy.Matrix(SympyMatrix)
values = matResult.eigenvals()
resultValues = []
for key,value in values.items():
for nRepetidos in range(value):
#print(key)
resultValues.append(complex.ComplexNumber(sympy.re(key),sympy.im(key)))
return resultValues
def product(ls, start, end): """Multiplies all the numbers in the given range of the list Input data: ls -- The list start -- The starting point of the range end -- The end point of the range Output data: The product of the numbers in the given range """ prod = ComplexNumber.create(1) for i in ls[start:end + 1]: prod = ComplexNumber.multiply(prod, i) return prod
def action(self, mat2):
""" accion de una matriz sobre un vector """
if (self.n != mat2.m ):
raise Exception('The dimensions of rows and columns do not match')
else:
matrixResult = [[complex.ComplexNumber(0,0) for x in range(mat2.n)] for y in range(self.m)]
for i in range (self.m):
for j in range (mat2.n):
sum = complex.ComplexNumber(0,0)
for z in range(self.n):
sum = sum.add(self.mtx[i][z].multiplication(mat2.mtx[z][j]))
matrixResult[i][j] = sum
matResult = Matrix(matrixResult)
return matResult
def main():
print(list(set([11, 22, 33, 44, 11, 22])))
defaultshape = sp.shape()
if (isinstance(defaultshape, sp.shape)):
print('default area is {}'.format(defaultshape.area()))
squareshape = sp.square(5)
if (isinstance(squareshape, sp.shape)):
print('Square area is {}'.format(squareshape.area()))
c1 = cn.ComplexNumber(4, 2)
c2 = cn.ComplexNumber(5, 3)
c3 = c1.add(c2)
#print("Complex Number {}+i{}".format(c3.real, c3.complex))
print('Sum is {}'.format(c3))
def testLabTensor(self):
h = matrix.Matrix([[complex.ComplexNumber(1, 0), complex.ComplexNumber(1, 0)], [complex.ComplexNumber(1, 0), complex.ComplexNumber(-1, 0)]])
h = h.scalarMultiplication(complex.ComplexNumber(1/math.sqrt(2),0))
x = matrix.Matrix([[complex.ComplexNumber(0, 0), complex.ComplexNumber(1, 0)], [complex.ComplexNumber(1, 0), complex.ComplexNumber(0, 0)]])
m1 = h.tensorProduct(h)
m2 = h.tensorProduct(x)
v = matrix.Matrix([[complex.ComplexNumber(1, 0), complex.ComplexNumber(0, 0),complex.ComplexNumber(0, 0), complex.ComplexNumber(0, 0)]])
res = v.multiplication(m1)
resultado = res.multiplication(m2)
def conjugate (self):
""" Conjuagada de una matriz/vector"""
matrixResult = [[complex.ComplexNumber(0,0) for x in range(self.n)] for y in range(self.m)]
for i in range (self.m):
for j in range (self.n):
matrixResult[i][j] = self.mtx[i][j].conjugate()
matResult = Matrix(matrixResult)
return matResult
def transpose (self) :
""" Transpuesta de una matriz/vector"""
matrixResult = [[complex.ComplexNumber(0,0) for x in range(self.m)] for y in range(self.n)]
for i in range (self.m):
for j in range (self.n):
matrixResult[j][i] = self.mtx[i][j]
matResult = Matrix(matrixResult)
return matResult
def inverse (self):
""" Inversa de una matriz/vectore"""
matrixResult = [[complex.ComplexNumber(0,0) for x in range(self.n)] for y in range(self.m)]
for i in range (self.m):
for j in range (self.n):
matrixResult[i][j] = self.mtx[i][j].inverse()
matResult = Matrix(matrixResult)
return matResult
def tensorProduct(self,mat2):
"producto tensor"
matrixResult = [[complex.ComplexNumber(0,0) for x in range(self.n*mat2.n)] for y in range(self.m*mat2.m)]
for i in range (self.m):
for j in range (self.n):
matriz = mat2.scalarMultiplication(self.mtx[i][j])
matrixResult = self.fillTensor(matrixResult,matriz,i,j)
matResult = Matrix(matrixResult)
return matResult
def scalarMultiplication(self,c):
""" Producto escalar de una matrix/vector y un numero complejo c """
matrixResult = [[complex.ComplexNumber(0,0) for x in range(self.n)] for y in range(self.m)]
for i in range (self.m):
for j in range (self.n):
matrixResult[i][j]=self.mtx[i][j].multiplication(c)
matResult = Matrix(matrixResult)
return matResult
def testeigenValuesAndEigenVectorsProbability(self):
omega = matrix.complexMatrix([[(-1, 0), (0, -1)], [(0, 1), (1, 0)]])
startState = matrix.complexMatrix([[(1 / 2, 0)], [(1 / 2, 0)]])
#Valores Propios
eigenValues = omega.eigenValues()
solutionEigenValues = [
complex.ComplexNumber(-math.sqrt(2), 0),
complex.ComplexNumber(math.sqrt(2), 0)
]
for i in range(len(eigenValues)):
solutionEigenValues[i]
solutionEigenValues[i]
#Vectores Propios
eigenVectorsProbabilities = qm.probabilityForAStateToCollapseIntoAnEigenVentor(
omega, startState)
solutionProbabilities = [0.5, 0.5]
for i in range(len(eigenVectorsProbabilities)):
probability = round(eigenVectorsProbabilities[i], 2)
self.assertAlmostEqual(probability, solutionProbabilities[i])
def testShouldAddTwoComplexVectors(self):
m1 = matrix.Matrix([[complex.ComplexNumber(2, 5), complex.ComplexNumber(1, 1),complex.ComplexNumber(4, 3)]])
m2 = matrix.Matrix([[complex.ComplexNumber(5, 13), complex.ComplexNumber(6, 2),complex.ComplexNumber(0.53, -6), complex.ComplexNumber(12, 0)]])
m3 = matrix.Matrix([[complex.ComplexNumber(7, -8), complex.ComplexNumber(0, 4),complex.ComplexNumber(2, 0), complex.ComplexNumber(9.4, 3)]])
vectorSDifferentLength = False
try:
mTest1 = m1.add(m2)
except:
vectorSDifferentLength = True
mTest2 = m2.add(m3)
mSol = matrix.Matrix([[complex.ComplexNumber(12, 5), complex.ComplexNumber(6, 6),complex.ComplexNumber(2.53, -6), complex.ComplexNumber(21.4, 3)]])
self.assertTrue(vectorSDifferentLength)
self.assertTrue(mTest2.equals(mSol))
def testShouldSubtractTwoMatrices(self):
m1 = matrix.Matrix([[complex.ComplexNumber(-1, -1), complex.ComplexNumber(3, 0)], [complex.ComplexNumber(4, 6), complex.ComplexNumber(2, 2)]])
m2 = matrix.Matrix([[complex.ComplexNumber(1, 0), complex.ComplexNumber(3, 4)], [complex.ComplexNumber(0, 2), complex.ComplexNumber(-3, 1)]])
m3 = matrix.Matrix([[complex.ComplexNumber(2, -7.86), complex.ComplexNumber(6.5, 1),complex.ComplexNumber(-4, 8)]])
MatricesDifferentLength = False
try:
mTest1 = m1.subtract(m3)
except:
MatricesDifferentLength = True
mTest2 = m1.subtract(m2)
mSol = matrix.Matrix([[complex.ComplexNumber(-2, -1), complex.ComplexNumber(0, -4)], [complex.ComplexNumber(4, 4), complex.ComplexNumber(5, 1)]])
self.assertTrue(MatricesDifferentLength)
self.assertTrue(mTest2.equals(mSol))
def transitionAmplitude(ketIni,ketFin):
"""Dados dos vectores ket (inicial y final ) calcula la probabilidad de transitar del primer vector al segundo."""
ket1M = normalize(ketIni)
ket2M = normalize(ketFin)
braket = ket2M.innerProduct(ket1M)
norm1 = ket1M.norm()
norm2 = ket2M.norm()
productNorm = norm1*norm2
productC = complex.ComplexNumber(productNorm,0)
amplitud = braket.division(productC)
return amplitud
def testMatricesMultiplication(self):
m1 = matrix.Matrix([[complex.ComplexNumber(3, 2), complex.ComplexNumber(0, 0),complex.ComplexNumber(5, -6)], [complex.ComplexNumber(1, 0), complex.ComplexNumber(4, 2),complex.ComplexNumber(0, 1)],[complex.ComplexNumber(4, -1), complex.ComplexNumber(0, 0),complex.ComplexNumber(4, 0)]])
m2 = matrix.Matrix([[complex.ComplexNumber(5, 0), complex.ComplexNumber(2, -1),complex.ComplexNumber(6, -4)], [complex.ComplexNumber(0, 0), complex.ComplexNumber(4, 5),complex.ComplexNumber(2, 0)],[complex.ComplexNumber(7, -4), complex.ComplexNumber(2, 7),complex.ComplexNumber(0, 0)]])
m3 = matrix.Matrix([[complex.ComplexNumber(-1, -1), complex.ComplexNumber(3, 0)], [complex.ComplexNumber(4, 6), complex.ComplexNumber(2, 2)]])
MatricesDifferentLength = False
try:
mTest1 = m1.subtract(m3)
except:
MatricesDifferentLength = True
mTest2 = m1.multiplication(m2)
mSol = matrix.Matrix([[complex.ComplexNumber(26, -52), complex.ComplexNumber(60, 24),complex.ComplexNumber(26, 0)], [complex.ComplexNumber(9, 7), complex.ComplexNumber(1, 29),complex.ComplexNumber(14, 0)],[complex.ComplexNumber(48, -21), complex.ComplexNumber(15, 22),complex.ComplexNumber(20, -22)]])
self.assertTrue(MatricesDifferentLength)
self.assertTrue(mTest2.equals(mSol))
def subtract (self, mat2):
""" Resta de dos matrices/vectores """
if (self.m != mat2.m or self.n != mat2.n):
raise Exception('The dimensions of the matrices are not the same ')
else:
matrixResult = [[complex.ComplexNumber(0,0) for x in range(self.n)] for y in range(self.m)]
for i in range (self.m):
for j in range (self.n):
matrixResult[i][j] = self.mtx[i][j].subtract(mat2.mtx[i][j])
matResult = Matrix(matrixResult)
return matResult
def list_modulo(ls, op, comp): """Lists all the elements in the list which fit in the given condition Input data: ls -- The list op -- function object to be used for the condition comp -- integer to use for the condition Output data: The list of all the numbers that fit in the condition """ return [n for n in ls if op(float(ComplexNumber.modulo(n)), comp)]
def lists(ls, args, **kwargs):
Validators.lists(ls, args)
if len(args) == 0:
show = Commands.lists(ls)
if len(args) == 4:
show = Commands.list_real_range(ls, int(args[1]), int(args[3]))
if len(args) == 3:
ops = {"=": float.__eq__, "<": float.__lt__, ">": float.__gt__}
show = Commands.list_modulo(ls, ops[args[1]], float(args[2]))
show = ", ".join([ComplexNumber.format(i) for i in show])
print(show if show != "" else "No results")
def testShouldCalculateAmplitude(self):
ket = matrix.complexMatrix([[(2, 1)], [(-1, 2)], [(0, 1)], [(1, 0)],
[(3, -1)], [(2, 0)], [(0, -2)], [(-2, 1)],
[(1, -3)], [(0, -1)]])
ket2 = matrix.complexMatrix([[(-1, -4)], [(2, -3)], [(-7, 6)],
[(-1, 1)], [(-5, -3)], [(5, 0)], [(5, 8)],
[(4, -4)], [(8, -7)], [(2, -7)]])
braket = qm.transitionAmplitude(ket, ket2)
mSol = complex.ComplexNumber(-0.022, -0.131)
self.assertAlmostEqual(braket.partReal, mSol.partReal)
self.assertAlmostEqual(braket.partImag, mSol.partImag)
def eigenVectors(self):
""" retorna los vectores propios de una matriz"""
SympyMatrix = [[complex.ComplexNumber(0,0) for x in range(self.n)] for y in range(self.m)]
for i in range (self.m):
for k in range (self.n):
SympyMatrix[i][k] = ((self.mtx[i][k].partReal)+(self.mtx[i][k].partImag*1j))
matResult = sympy.Matrix(SympyMatrix)
vectors = matResult.eigenvects()
resultVectors = [Matrix([[]]) for i in range(len(vectors))]
#print(vectors)
for i in range(len(vectors)):
eigenVect = vectors[i][2]
#print(vectors[i][2])
complexEigenVect = [[complex.ComplexNumber(0,0)] for j in range (len(eigenVect[0]))]
for j in range(len(eigenVect)):
for x in range(len(eigenVect[j])):
#print(eigenVect[j][x])
valEigenVect = eigenVect[j][x]
comValEigenVect = complex.ComplexNumber(sympy.re(valEigenVect),sympy.im(valEigenVect))
complexEigenVect[x][0] = comValEigenVect
resultVectors[i] = Matrix(complexEigenVect)
return resultVectors
