class VectorTest(unittest.TestCase): data1 = [2, 3, 4, 5, 6] def setUp(self): data2 = [8, 7, 6, 5, 4] self.smallVector1 = Vector(self.data1) self.smallVector2 = Vector(data2) largeData1 = [] for i in range(1, 1001): largeData1.append(i) self.largeVector1 = Vector(largeData1) largeData2 = [] for i in range(1, 1001): largeData2.append(1000 - i + 1) self.largeVector2 = Vector(largeData2) def test_Biased(self): biased = self.smallVector1.biased() self.assertEqual(1, biased.getValue(0)) self.assertEqual(self.smallVector1.size() + 1, biased.size()) def test_ElementAdd(self): self.smallVector1.add(7) self.assertEqual(7, self.smallVector1.getValue(5)) self.assertEqual(6, self.smallVector1.size()) self.smallVector1.remove(5) def test_Insert(self): self.smallVector1.insert(3, 6) self.assertEqual(6, self.smallVector1.getValue(3)) self.assertEqual(6, self.smallVector1.size()) self.smallVector1.remove(3) def test_Remove(self): self.smallVector1.remove(2) self.assertEqual(5, self.smallVector1.getValue(2)) self.assertEqual(4, self.smallVector1.size()) self.smallVector1.insert(2, 4) def test_SumOfElementsSmall(self): self.assertEqual(20, self.smallVector1.sumOfElements()) self.assertEqual(30, self.smallVector2.sumOfElements()) def test_SumOfElementsLarge(self): self.assertEqual(20, self.smallVector1.sumOfElements()) self.assertEqual(30, self.smallVector2.sumOfElements()) self.assertEqual(500500, self.largeVector1.sumOfElements()) self.assertEqual(500500, self.largeVector2.sumOfElements()) def test_MaxIndex(self): self.assertEqual(4, self.smallVector1.maxIndex()) self.assertEqual(0, self.smallVector2.maxIndex()) def test_Sigmoid(self): smallVector3 = Vector(self.data1) smallVector3.sigmoid() self.assertAlmostEqual(0.8807971, smallVector3.getValue(0), 6) self.assertAlmostEqual(0.9975274, smallVector3.getValue(4), 6) def test_SkipVectorSmall(self): smallVector3 = self.smallVector1.skipVector(2, 0) self.assertEqual(2, smallVector3.getValue(0)) self.assertEqual(6, smallVector3.getValue(2)) smallVector3 = self.smallVector1.skipVector(3, 1) self.assertEqual(3, smallVector3.getValue(0)) self.assertEqual(6, smallVector3.getValue(1)) def test_SkipVectorLarge(self): largeVector3 = self.largeVector1.skipVector(2, 0) self.assertEqual(250000, largeVector3.sumOfElements()) largeVector3 = self.largeVector1.skipVector(5, 3) self.assertEqual(100300, largeVector3.sumOfElements()) def test_VectorAddSmall(self): self.smallVector1.addVector(self.smallVector2) self.assertEqual(50, self.smallVector1.sumOfElements()) self.smallVector1.subtract(self.smallVector2) def test_VectorAddLarge(self): self.largeVector1.addVector(self.largeVector2) self.assertEqual(1001000, self.largeVector1.sumOfElements()) self.largeVector1.subtract(self.largeVector2) def test_SubtractSmall(self): self.smallVector1.subtract(self.smallVector2) self.assertEqual(-10, self.smallVector1.sumOfElements()) self.smallVector1.addVector(self.smallVector2) def test_SubtractLarge(self): self.largeVector1.subtract(self.largeVector2) self.assertEqual(0, self.largeVector1.sumOfElements()) self.largeVector1.addVector(self.largeVector2) def test_DifferenceSmall(self): smallVector3 = self.smallVector1.difference(self.smallVector2) self.assertEqual(-10, smallVector3.sumOfElements()) def test_DifferenceLarge(self): largeVector3 = self.largeVector1.difference(self.largeVector2) self.assertEqual(0, largeVector3.sumOfElements()) def test_DotProductWithVectorSmall(self): dotProduct = self.smallVector1.dotProduct(self.smallVector2) self.assertEqual(110, dotProduct) def test_DotProductWithVectorLarge(self): dotProduct = self.largeVector1.dotProduct(self.largeVector2) self.assertEqual(167167000, dotProduct) def test_DotProductWithItselfSmall(self): dotProduct = self.smallVector1.dotProductWithSelf() self.assertEqual(90, dotProduct) def test_DotProductWithItselfLarge(self): dotProduct = self.largeVector1.dotProductWithSelf() self.assertEqual(333833500, dotProduct) def test_ElementProductSmall(self): smallVector3 = self.smallVector1.elementProduct(self.smallVector2) self.assertEqual(110, smallVector3.sumOfElements()) def test_ElementProductLarge(self): largeVector3 = self.largeVector1.elementProduct(self.largeVector2) self.assertEqual(167167000, largeVector3.sumOfElements()) def test_Divide(self): self.smallVector1.divide(10.0) self.assertEqual(2, self.smallVector1.sumOfElements()) self.smallVector1.multiply(10.0) def test_Multiply(self): self.smallVector1.multiply(10.0) self.assertEqual(200, self.smallVector1.sumOfElements()) self.smallVector1.divide(10.0) def test_Product(self): smallVector3 = self.smallVector1.product(7.0) self.assertEqual(140, smallVector3.sumOfElements()) def test_L1NormalizeSmall(self): self.smallVector1.l1Normalize() self.assertEqual(1.0, self.smallVector1.sumOfElements()) self.smallVector1.multiply(20) def test_L1NormalizeLarge(self): self.largeVector1.l1Normalize() self.assertEqual(1.0, self.largeVector1.sumOfElements()) self.largeVector1.multiply(500500) def test_L2NormSmall(self): norm = self.smallVector1.l2Norm() self.assertEqual(norm, math.sqrt(90)) def test_L2NormLarge(self): norm = self.largeVector1.l2Norm() self.assertEqual(norm, math.sqrt(333833500)) def test_cosineSimilaritySmall(self): similarity = self.smallVector1.cosineSimilarity(self.smallVector2) self.assertAlmostEqual(0.8411910, similarity, 6) def test_cosineSimilarityLarge(self): similarity = self.largeVector1.cosineSimilarity(self.largeVector2) self.assertAlmostEqual(0.5007497, similarity, 6)
class MatrixTest(unittest.TestCase): def setUp(self): self.small = Matrix(3, 3) for i in range(3): for j in range(3): self.small.setValue(i, j, 1.0) self.v = Vector(3, 1.0) self.large = Matrix(1000, 1000) for i in range(1000): for j in range(1000): self.large.setValue(i, j, 1.0) self.medium = Matrix(100, 100) for i in range(100): for j in range(100): self.medium.setValue(i, j, 1.0) self.V = Vector(1000, 1.0) self.vr = Vector(100, 1.0) self.random = Matrix(100, 100, 1, 10, 1) self.originalSum = self.random.sumOfElements() self.identity = Matrix(100) def test_ColumnWiseNormalize(self): mClone = self.small.clone() mClone.columnWiseNormalize() self.assertEqual(3, mClone.sumOfElements()) MClone = self.large.clone() MClone.columnWiseNormalize() self.assertAlmostEqual(1000, MClone.sumOfElements(), 3) self.identity.columnWiseNormalize() self.assertEqual(100, self.identity.sumOfElements()) def test_MultiplyWithConstant(self): self.small.multiplyWithConstant(4) self.assertEqual(36, self.small.sumOfElements()) self.small.divideByConstant(4) self.large.multiplyWithConstant(1.001) self.assertAlmostEqual(1001000, self.large.sumOfElements(), 3) self.large.divideByConstant(1.001) self.random.multiplyWithConstant(3.6) self.assertAlmostEqual(self.originalSum * 3.6, self.random.sumOfElements(), 4) self.random.divideByConstant(3.6) def test_DivideByConstant(self): self.small.divideByConstant(4) self.assertEqual(2.25, self.small.sumOfElements()) self.small.multiplyWithConstant(4) self.large.divideByConstant(10) self.assertAlmostEqual(100000, self.large.sumOfElements(), 3) self.large.multiplyWithConstant(10) self.random.divideByConstant(3.6) self.assertAlmostEqual(self.originalSum / 3.6, self.random.sumOfElements(), 4) self.random.multiplyWithConstant(3.6) def test_Add(self): self.random.add(self.identity) self.assertAlmostEqual(self.originalSum + 100, self.random.sumOfElements(), 4) self.random.subtract(self.identity) def test_AddVector(self): self.large.addRowVector(4, self.V) self.assertEqual(1001000, self.large.sumOfElements(), 0.0) self.V.multiply(-1.0) self.large.addRowVector(4, self.V) self.V.multiply(-1.0) def test_Subtract(self): self.random.subtract(self.identity) self.assertAlmostEqual(self.originalSum - 100, self.random.sumOfElements(), 4) self.random.add(self.identity) def test_MultiplyWithVectorFromLeft(self): result = self.small.multiplyWithVectorFromLeft(self.v) self.assertEqual(9, result.sumOfElements()) result = self.large.multiplyWithVectorFromLeft(self.V) self.assertEqual(1000000, result.sumOfElements()) result = self.random.multiplyWithVectorFromLeft(self.vr) self.assertAlmostEqual(self.originalSum, result.sumOfElements(), 4) def test_MultiplyWithVectorFromRight(self): result = self.small.multiplyWithVectorFromRight(self.v) self.assertEqual(9, result.sumOfElements()) result = self.large.multiplyWithVectorFromRight(self.V) self.assertEqual(1000000, result.sumOfElements()) result = self.random.multiplyWithVectorFromRight(self.vr) self.assertAlmostEqual(self.originalSum, result.sumOfElements(), 4) def test_ColumnSum(self): self.assertEqual(3, self.small.columnSum(randrange(3))) self.assertEqual(1000, self.large.columnSum(randrange(1000))) self.assertEqual(1, self.identity.columnSum(randrange(100))) def test_SumOfRows(self): self.assertEqual(9, self.small.sumOfRows().sumOfElements()) self.assertEqual(1000000, self.large.sumOfRows().sumOfElements()) self.assertEqual(100, self.identity.sumOfRows().sumOfElements()) self.assertAlmostEqual(self.originalSum, self.random.sumOfRows().sumOfElements(), 3) def test_RowSum(self): self.assertEqual(3, self.small.rowSum(randrange(3))) self.assertEqual(1000, self.large.rowSum(randrange(1000))) self.assertEqual(1, self.identity.rowSum(randrange(100))) def test_Multiply(self): result = self.small.multiply(self.small) self.assertEqual(27, result.sumOfElements()) result = self.medium.multiply(self.medium) self.assertEqual(1000000.0, result.sumOfElements()) result = self.random.multiply(self.identity) self.assertEqual(self.originalSum, result.sumOfElements()) result = self.identity.multiply(self.random) self.assertEqual(self.originalSum, result.sumOfElements()) def test_ElementProduct(self): result = self.small.elementProduct(self.small) self.assertEqual(9, result.sumOfElements()) result = self.large.elementProduct(self.large) self.assertEqual(1000000, result.sumOfElements()) result = self.random.elementProduct(self.identity) self.assertEqual(result.trace(), result.sumOfElements()) def test_SumOfElements(self): self.assertEqual(9, self.small.sumOfElements()) self.assertEqual(1000000, self.large.sumOfElements()) self.assertEqual(100, self.identity.sumOfElements()) self.assertEqual(self.originalSum, self.random.sumOfElements()) def test_Trace(self): self.assertEqual(3, self.small.trace()) self.assertEqual(1000, self.large.trace()) self.assertEqual(100, self.identity.trace()) def test_Transpose(self): self.assertEqual(9, self.small.transpose().sumOfElements()) self.assertEqual(1000000, self.large.transpose().sumOfElements()) self.assertEqual(100, self.identity.transpose().sumOfElements()) self.assertAlmostEqual(self.originalSum, self.random.transpose().sumOfElements(), 3) def test_IsSymmetric(self): self.assertTrue(self.small.isSymmetric()) self.assertTrue(self.large.isSymmetric()) self.assertTrue(self.identity.isSymmetric()) self.assertFalse(self.random.isSymmetric()) def test_Determinant(self): self.assertEqual(0, self.small.determinant()) self.assertEqual(0, self.large.determinant()) self.assertEqual(1, self.identity.determinant()) def test_Inverse(self): self.identity.inverse() self.assertEqual(100, self.identity.sumOfElements()) self.random.inverse() self.random.inverse() self.assertAlmostEqual(self.originalSum, self.random.sumOfElements(), 5) def test_Characteristics(self): vectors = self.small.characteristics() self.assertEqual(2, len(vectors)) vectors = self.identity.characteristics() self.assertEqual(100, len(vectors)) vectors = self.medium.characteristics() self.assertEqual(46, len(vectors))