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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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
def normalize(ket):
"""Normaliza un vector ket, dividiendo a las entradas por la longitud del vector """
length = ket.norm()
m = matrix.getRows(ket) #rows
n = matrix.getColumns(ket) #column
ketM = matrix.getMtx(ket)
for i in range (m):
for j in range (n):
temp = ketM[i][j]
lengthC = complex.ComplexNumber(length,0)
ketM[i][j] = temp.division(lengthC)
matrixVector = matrix.Matrix(ketM)
return matrixVector
def test_02_phase(self):
"""
NOTE: we can't use assertEqual, as the result of phase() is a
float number which may have floating point rounding errors. So it's
necessary to use assertAlmostEqual
As an option with the delta you can declare the precision you require.
For more info see Python docs:
https://docs.python.org/2/library/unittest.html#unittest.TestCase.assertAlmostEqual
NOTE: assertEqual might still work on your machine but just DO NOT use it
for float numbers!!!
"""
self.assertAlmostEqual(ComplexNumber(0.0,1.0).phase(), math.pi / 2, delta=0.001)
def testMatrixTranspose(self):
m1 = matrix.Matrix([[
complex.ComplexNumber(6, -3),
complex.ComplexNumber(2, 12),
complex.ComplexNumber(0, -19)
],
[
complex.ComplexNumber(0, 0),
complex.ComplexNumber(5, 2.1),
complex.ComplexNumber(17, 0)
],
[
complex.ComplexNumber(1, 0),
complex.ComplexNumber(2, 5),
complex.ComplexNumber(3, -4.5)
]])
mTest = m1.transpose()
mSol = matrix.Matrix([[
complex.ComplexNumber(6, -3),
complex.ComplexNumber(0, 0),
complex.ComplexNumber(1, 0)
],
[
complex.ComplexNumber(2, 12),
complex.ComplexNumber(5, 2.1),
complex.ComplexNumber(2, 5)
],
[
complex.ComplexNumber(0, -19),
complex.ComplexNumber(17, 0),
complex.ComplexNumber(3, -4.5)
]])
self.assertTrue(mTest.equals(mSol))
def testShouldAddTwoMatrices(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)]])
mTest = m1.add(m2)
mSol = matrix.Matrix(
[[complex.ComplexNumber(0, -1),
complex.ComplexNumber(6, 4)],
[complex.ComplexNumber(4, 8),
complex.ComplexNumber(-1, 3)]])
self.assertTrue(mTest.equals(mSol))
