def test_hamming_distance_multiple(self): test_logger.debug( "FindNearestTest - test_hamming_distance_multiple Starts") points = ["abcdef", "abcefg", "abcdeg"] point = "abcdef" find_nearest = FindNearest(points, point, HammingDistance, k=2) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals(['abcdef', 'abcdeg'], nearest) points = ["abcXdef", "abcXefg", "abcXdeg"] point = "abcdefg" find_nearest = FindNearest(points, point, HammingDistance, k=2) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals(['abcXefg', 'abcXdeg'], nearest) points = ["abcXdef", "abcXefg", "abcXdeg"] point = "1234567" find_nearest = FindNearest(points, point, HammingDistance, k=2) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals(['abcXdef', 'abcXdef'], nearest) points = ["abcXdef", "abcXefg", "abcXdeg"] point = "123456 " find_nearest = FindNearest(points, point, HammingDistance, k=2) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals(['abcXdef', 'abcXdef'], nearest) test_logger.debug( "FindNearestTest - test_hamming_distance_multiple Ends")
def test_correlation_distance_multiple(self): test_logger.debug("FindNearestTest - test_correlation_distance_multiple Starts") points = [(2, 3), (4, 6), (6, 5)] point = (2, 1) find_nearest = FindNearest(points, point, CorrelationDistance, k=2) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals([(6, 5), (2, 3)], nearest) points = [(2, 3), (4, 6), (6, 5)] point = (3, 2) find_nearest = FindNearest(points, point, CorrelationDistance, k=2) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals([(6, 5), (2, 3)], nearest) points = [(2, 3), (4, 6), (6, 5)] point = (3, 1) find_nearest = FindNearest(points, point, CorrelationDistance, k=2) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals([(6, 5), (2, 3)], nearest) test_logger.debug("FindNearestTest - test_correlation_distance_multiple Ends")
def test_correlation_distance(self): test_logger.debug("FindNearestTest - test_correlation_distance Starts") points = [(2, 3), (3, 4), (4, 5)] point = (2, 1) find_nearest = FindNearest(points, point, CorrelationDistance) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals((2, 3), nearest) points = [(2, 3), (3, 4), (4, 5)] point = (3, 2) find_nearest = FindNearest(points, point, CorrelationDistance) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals((2, 3), nearest) points = [(2, 3), (3, 4), (4, 5)] point = (3, 4) find_nearest = FindNearest(points, point, CorrelationDistance) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals((2, 3), nearest) test_logger.debug("FindNearestTest - test_correlation_distance Ends")
def test_correlation_distance_multiple(self): test_logger.debug( "FindNearestTest - test_correlation_distance_multiple Starts") points = [(2, 3), (4, 6), (6, 5)] point = (2, 1) find_nearest = FindNearest(points, point, CorrelationDistance, k=2) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals([(6, 5), (2, 3)], nearest) points = [(2, 3), (4, 6), (6, 5)] point = (3, 2) find_nearest = FindNearest(points, point, CorrelationDistance, k=2) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals([(6, 5), (2, 3)], nearest) points = [(2, 3), (4, 6), (6, 5)] point = (3, 1) find_nearest = FindNearest(points, point, CorrelationDistance, k=2) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals([(6, 5), (2, 3)], nearest) test_logger.debug( "FindNearestTest - test_correlation_distance_multiple Ends")
def test_hamming_distance_multiple(self): test_logger.debug("FindNearestTest - test_hamming_distance_multiple Starts") points = ["abcdef", "abcefg", "abcdeg"] point = "abcdef" find_nearest = FindNearest(points, point, HammingDistance, k=2) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals(['abcdef', 'abcdeg'], nearest) points = ["abcXdef", "abcXefg", "abcXdeg"] point = "abcdefg" find_nearest = FindNearest(points, point, HammingDistance, k=2) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals(['abcXefg', 'abcXdeg'], nearest) points = ["abcXdef", "abcXefg", "abcXdeg"] point = "1234567" find_nearest = FindNearest(points, point, HammingDistance, k=2) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals(['abcXdef', 'abcXdef'], nearest) points = ["abcXdef", "abcXefg", "abcXdeg"] point = "123456 " find_nearest = FindNearest(points, point, HammingDistance, k=2) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals(['abcXdef', 'abcXdef'], nearest) test_logger.debug("FindNearestTest - test_hamming_distance_multiple Ends")
def test_edit_distance(self): test_logger.debug("FindNearestTest - test_edit_distance Starts") points = ["abcdef", "abcef", "abcde"] point = "abcdefg" find_nearest = FindNearest(points, point, EditDistance) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals("abcdef", nearest) points = ["abcXdef", "abcXef", "abcXde"] point = "abcdefg" find_nearest = FindNearest(points, point, EditDistance) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals("abcXdef", nearest) points = ["abcXdef", "abcXef", "abcXde"] point = "123456" find_nearest = FindNearest(points, point, EditDistance) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals("abcXef", nearest) points = ["abcXdef", "abcXef", "abcXde"] point = "123456 " find_nearest = FindNearest(points, point, EditDistance) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals("abcXdef", nearest) test_logger.debug("FindNearestTest - test_edit_distance Ends")
def test_damerau_levenshtein_distance(self): test_logger.debug( "FindNearestTest - test_damerau_levenshtein_distance Starts") points = ["abcdef", "abcef", "abcde"] point = "abcdefg" find_nearest = FindNearest(points, point, DamerauLevenshteinDistance) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals("abcdef", nearest) points = ["abcXdef", "abcXef", "abcXde"] point = "abcdefg" find_nearest = FindNearest(points, point, DamerauLevenshteinDistance) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals("abcXdef", nearest) points = ["abcXdef", "abcXef", "abcXde"] point = "123456" find_nearest = FindNearest(points, point, DamerauLevenshteinDistance) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals("abcXef", nearest) points = ["abcXdef", "abcXef", "abcXde"] point = "123456 " find_nearest = FindNearest(points, point, DamerauLevenshteinDistance) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals("abcXdef", nearest) test_logger.debug( "FindNearestTest - test_damerau_levenshtein_distance Ends")
def test_rogers_tanimoto_dissimilarity_multiple(self): test_logger.debug( "FindNearestTest - test_rogers_tanimoto_dissimilarity_multiple Starts" ) points = [(1, 0, 1, 0, 1, 0), (1, 0, 1, 0, 1, 1), (1, 0, 1, 1, 1, 0)] point = (1, 0, 0, 0, 0, 0) find_nearest = FindNearest(points, point, RogersTanimotoDissimilarity, k=2) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals([(1, 0, 1, 0, 1, 0), (1, 0, 1, 0, 1, 1)], nearest) points = [(1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1), (1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1), (0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1)] point = (0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1) find_nearest = FindNearest(points, point, RogersTanimotoDissimilarity, k=2) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals([(0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1), (1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1)], nearest) test_logger.debug( "FindNearestTest - test_rogers_tanimoto_dissimilarity_multiple Ends" )
def test_damerau_levenshtein_distance_multiple(self): test_logger.debug("FindNearestTest - test_damerau_levenshtein_distance_multiple Starts") points = ["abcdef", "abcef", "abcde"] point = "abcdefg" find_nearest = FindNearest(points, point, DamerauLevenshteinDistance, k=2) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals(['abcdef', 'abcef'], nearest) points = ["abcXdef", "abcXef", "abcXde"] point = "abcdefg" find_nearest = FindNearest(points, point, DamerauLevenshteinDistance, k=2) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals(['abcXdef', 'abcXdef'], nearest) points = ["abcXdef", "abcXef", "abcXde"] point = "123456" find_nearest = FindNearest(points, point, DamerauLevenshteinDistance, k=2) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals(['abcXef', 'abcXef'], nearest) points = ["abcXdef", "abcXef", "abcXde"] point = "123456 " find_nearest = FindNearest(points, point, DamerauLevenshteinDistance, k=2) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals(['abcXdef', 'abcXdef'], nearest) test_logger.debug("FindNearestTest - test_damerau_levenshtein_distance_multiple Ends")
def test_algorithm(self): test_logger.debug( "NormalizedSquaredEuclideanDistanceTest - test_algorithm Starts") data = [(1, 2, 3), (3, 5, 10)] normalized_squared_euclidean_distance = NormalizedSquaredEuclideanDistance( data) normalized_squared_euclidean_distance.process() result = normalized_squared_euclidean_distance.get_result() self.assertEquals(1.0 / 4, result) data = [(1, 1, 4, 6, 1200, 3, 2, 3, 2, 8), (2, 1, 5, 6, 1300, 3, 2, 5, 3, 8)] normalized_squared_euclidean_distance = NormalizedSquaredEuclideanDistance( data) normalized_squared_euclidean_distance.process() result = normalized_squared_euclidean_distance.get_result() self.assertEquals(0.001589630279970944, result) data = [(3, 1), (4, 1)] normalized_squared_euclidean_distance = NormalizedSquaredEuclideanDistance( data) normalized_squared_euclidean_distance.process() result = normalized_squared_euclidean_distance.get_result() self.assertEquals(0.038461538461538464, result) data = [[3], [4]] normalized_squared_euclidean_distance = NormalizedSquaredEuclideanDistance( data) with self.assertRaises(ArithmeticError) as context: normalized_squared_euclidean_distance.process() self.assertEqual('float division by zero', context.exception.message) data = [[3], [4, 5, 6]] normalized_squared_euclidean_distance = NormalizedSquaredEuclideanDistance( data) with self.assertRaises(ArithmeticError) as context: normalized_squared_euclidean_distance.process() self.assertEqual( 'You cant calculate Normalized Squared Euclidean distance of array has different sizes.', context.exception.message) data = [["a"], [4]] normalized_squared_euclidean_distance = NormalizedSquaredEuclideanDistance( data) with self.assertRaises(TypeError) as context: normalized_squared_euclidean_distance.process() self.assertEqual("unsupported operand type(s) for +: 'int' and 'str'", context.exception.message) data = [] normalized_squared_euclidean_distance = NormalizedSquaredEuclideanDistance( data) with self.assertRaises(ArithmeticError) as context: normalized_squared_euclidean_distance.process() self.assertEqual( 'You must enter two array to find Normalized Squared Euclidean distance.', context.exception.message) test_logger.debug( "NormalizedSquaredEuclideanDistanceTest - test_algorithm Ends")
def test_manhattan_distance_multiple(self): test_logger.debug( "FindNearestTest - test_manhattan_distance_multiple Starts") points = [(1, 0, 1, 0, 1, 0), (1, 0, 1, 0, 1, 1), (1, 0, 1, 1, 1, 0)] point = (1, 0, 0, 0, 0, 0) find_nearest = FindNearest(points, point, ManhattanDistance, k=2) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals([(1, 0, 1, 0, 1, 0), (1, 0, 1, 0, 1, 1)], nearest) points = [(1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1), (1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1), (0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1)] point = (0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1) find_nearest = FindNearest(points, point, ManhattanDistance, k=2) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals([(0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1), (1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1)], nearest) points = [(2, 3), (3, 4), (4, 5)] point = (0, 1) find_nearest = FindNearest(points, point, ManhattanDistance, k=2) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals([(2, 3), (3, 4)], nearest) points = [(2, 3), (3, 4), (4, 5)] point = (3, 3) find_nearest = FindNearest(points, point, ManhattanDistance, k=2) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals([(2, 3), (2, 3)], nearest) points = [(2, 3), (3, 4), (4, 5)] point = (3, 4) find_nearest = FindNearest(points, point, ManhattanDistance, k=2) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals([(3, 4), (2, 3)], nearest) points = [[1], [5], [10]] point = [8] find_nearest = FindNearest(points, point, ManhattanDistance, k=2) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals([[10], [5]], nearest) points = [[1], [5], [10]] point = [17] find_nearest = FindNearest(points, point, ManhattanDistance, k=2) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals([[10], [5]], nearest) test_logger.debug( "FindNearestTest - test_manhattan_distance_multiple Ends")
def test_algorithm_with_list(self): test_logger.debug("StandartDeviationTest - test_algorithm_with_list Starts") standart_deviation = StandartDeviation() data_list = [1, 2, 3, 4, 5] self.assertEquals(1.5811, standart_deviation.calculate(data_list)) data_list = [1, 2, 3, 4] self.assertEquals(1.291, standart_deviation.calculate(data_list)) test_logger.debug("StandartDeviationTest - test_algorithm_with_list Ends")
def test_squared_euclidean_distance(self): test_logger.debug( "FindNearestTest - test_squared_euclidean_distance Starts") points = [(1, 0, 1, 0, 1, 0), (1, 0, 1, 0, 1, 1), (1, 0, 1, 1, 1, 0)] point = (1, 0, 0, 0, 0, 0) find_nearest = FindNearest(points, point, SquaredEuclideanDistance) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals((1, 0, 1, 0, 1, 0), nearest) points = [(1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1), (1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1), (0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1)] point = (0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1) find_nearest = FindNearest(points, point, SquaredEuclideanDistance) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals((0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1), nearest) points = [(2, 3), (3, 4), (4, 5)] point = (0, 1) find_nearest = FindNearest(points, point, SquaredEuclideanDistance) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals((2, 3), nearest) points = [(2, 3), (3, 4), (4, 5)] point = (3, 3) find_nearest = FindNearest(points, point, SquaredEuclideanDistance) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals((2, 3), nearest) points = [(2, 3), (3, 4), (4, 5)] point = (3, 4) find_nearest = FindNearest(points, point, SquaredEuclideanDistance) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals((3, 4), nearest) points = [[1], [5], [10]] point = [8] find_nearest = FindNearest(points, point, SquaredEuclideanDistance) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals([10], nearest) points = [[1], [5], [10]] point = [17] find_nearest = FindNearest(points, point, SquaredEuclideanDistance) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals([10], nearest) test_logger.debug( "FindNearestTest - test_squared_euclidean_distance Ends")
def test_algorithm_with_tuple(self): test_logger.debug("MeanTest - test_algorithm_with_tuple Starts") mean = Mean() data_list = [("a", 1), ("b", 2), ("c", 3), ( "d", 4), ("e", 5)] self.assertEquals(3, mean.calculate(data_list, is_tuple=True, index=1)) data_list = [("a", "a", 1), ("b", "b", 2), ("c", "c", 3), ("d", "d", 4), ("e", "e", 5)] self.assertEquals(3.0, mean.calculate(data_list, is_tuple=True, index=2)) test_logger.debug("MeanTest - test_algorithm_with_tuple Ends")
def test_algorithm(self): test_logger.debug("ManhattanDistanceTest - test_algorithm Starts") data = [(1, 2, 3, 4), (1, 2, 3, 6)] manhattan_distance = ManhattanDistance(data) manhattan_distance.process() result = manhattan_distance.get_result() self.assertEquals(2.0, result) data = [(1, 2, 3, 4), (5, 6, 7, 8)] manhattan_distance = ManhattanDistance(data) manhattan_distance.process() result = manhattan_distance.get_result() self.assertEquals(16.0, result) data = [(3, 1), (4, 1)] manhattan_distance = ManhattanDistance(data) manhattan_distance.process() result = manhattan_distance.get_result() self.assertEquals(1.0, result) data = [(3, 1, 5), (5, 5, 3)] manhattan_distance = ManhattanDistance(data) manhattan_distance.process() result = manhattan_distance.get_result() self.assertEquals(8.0, result) data = [[3], [4]] manhattan_distance = ManhattanDistance(data) manhattan_distance.process() result = manhattan_distance.get_result() self.assertEquals(1.0, result) data = [[3], [4, 5, 6]] manhattan_distance = ManhattanDistance(data) with self.assertRaises(ArithmeticError) as context: manhattan_distance.process() self.assertEqual( 'You cant calculate Manhattan distance of array has different sizes.', context.exception.message) data = [["a"], [4]] manhattan_distance = ManhattanDistance(data) with self.assertRaises(TypeError) as context: manhattan_distance.process() self.assertEqual("unsupported operand type(s) for -: 'int' and 'str'", context.exception.message) data = [] manhattan_distance = ManhattanDistance(data) with self.assertRaises(ArithmeticError) as context: manhattan_distance.process() self.assertEqual( 'You must enter two array to find Manhattan distance.', context.exception.message) test_logger.debug("ManhattanDistanceTest - test_algorithm Ends")
def test_algorithm_with_list(self): test_logger.debug( "StandartDeviationTest - test_algorithm_with_list Starts") standart_deviation = StandartDeviation() data_list = [1, 2, 3, 4, 5] self.assertEquals(1.5811, standart_deviation.calculate(data_list)) data_list = [1, 2, 3, 4] self.assertEquals(1.291, standart_deviation.calculate(data_list)) test_logger.debug( "StandartDeviationTest - test_algorithm_with_list Ends")
def test_algorithm(self): test_logger.debug("CosineDistanceTest - test_algorithm Starts") data = [(1, 2, 3), (3, 5, 7)] cosine_distance = CosineDistance(data) cosine_distance.process() result = cosine_distance.get_result() self.assertEquals(0.002585096956942312, result) data = [(1, 2, 3, 4), (1, 2, 3, 6)] cosine_distance = CosineDistance(data) cosine_distance.process() result = cosine_distance.get_result() self.assertEquals(0.018844218960787695, result) data = [(3, 1), (4, 1)] cosine_distance = CosineDistance(data) cosine_distance.process() result = cosine_distance.get_result() self.assertEquals(0.002945514498418511, result) data = [[3], [4]] cosine_distance = CosineDistance(data) cosine_distance.process() result = cosine_distance.get_result() self.assertEquals(0.0, result) data = [[3, 4], [6, 8]] cosine_distance = CosineDistance(data) cosine_distance.process() result = cosine_distance.get_result() self.assertEquals(0.0, result) data = [[3], [4, 5, 6]] cosine_distance = CosineDistance(data) with self.assertRaises(ArithmeticError) as context: cosine_distance.process() self.assertEqual( 'You cant calculate Cosine distance of array has different sizes.', context.exception.message) data = [["a"], [4]] cosine_distance = CosineDistance(data) with self.assertRaises(TypeError) as context: cosine_distance.process() self.assertEqual("unsupported operand type(s) for +: 'int' and 'str'", context.exception.message) data = [] cosine_distance = CosineDistance(data) with self.assertRaises(ArithmeticError) as context: cosine_distance.process() self.assertEqual('You must enter two array to find Cosine distance.', context.exception.message) test_logger.debug("CosineDistanceTest - test_algorithm Ends")
def test_manhattan_distance_multiple(self): test_logger.debug("FindNearestTest - test_manhattan_distance_multiple Starts") points = [(1, 0, 1, 0, 1, 0), (1, 0, 1, 0, 1, 1), (1, 0, 1, 1, 1, 0)] point = (1, 0, 0, 0, 0, 0) find_nearest = FindNearest(points, point, ManhattanDistance, k=2) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals([(1, 0, 1, 0, 1, 0), (1, 0, 1, 0, 1, 1)], nearest) points = [(1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1), (1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1), (0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1)] point = (0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1) find_nearest = FindNearest(points, point, ManhattanDistance, k=2) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals([(0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1), (1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1)] , nearest) points = [(2, 3), (3, 4), (4, 5)] point = (0, 1) find_nearest = FindNearest(points, point, ManhattanDistance, k=2) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals([(2, 3), (3, 4)], nearest) points = [(2, 3), (3, 4), (4, 5)] point = (3, 3) find_nearest = FindNearest(points, point, ManhattanDistance, k=2) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals([(2, 3), (2, 3)], nearest) points = [(2, 3), (3, 4), (4, 5)] point = (3, 4) find_nearest = FindNearest(points, point, ManhattanDistance, k=2) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals([(3, 4), (2, 3)], nearest) points = [[1], [5], [10]] point = [8] find_nearest = FindNearest(points, point, ManhattanDistance, k=2) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals([[10], [5]], nearest) points = [[1], [5], [10]] point = [17] find_nearest = FindNearest(points, point, ManhattanDistance, k=2) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals([[10], [5]], nearest) test_logger.debug("FindNearestTest - test_manhattan_distance_multiple Ends")
def test_algorithm(self): test_logger.debug("FindNearestTest - test_algorithm Starts") points = "abcdef" point = "abcdefg" with self.assertRaises(TypeError) as context: FindNearest(points, point, "") self.assertEqual("You must initialize array and a point", context.exception.message) test_logger.debug("FindNearestTest - test_algorithm Starts")
def test_euclidean_distance(self): test_logger.debug("FindNearestTest - test_euclidean_distance Starts") points = [(1, 0, 1, 0, 1, 0), (1, 0, 1, 0, 1, 1), (1, 0, 1, 1, 1, 0)] point = (1, 0, 0, 0, 0, 0) find_nearest = FindNearest(points, point, EuclideanDistance) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals((1, 0, 1, 0, 1, 0), nearest) points = [(1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1), (1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1), (0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1)] point = (0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1) find_nearest = FindNearest(points, point, EuclideanDistance) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals((0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1), nearest) points = [(2, 3), (3, 4), (4, 5)] point = (0, 1) find_nearest = FindNearest(points, point, EuclideanDistance) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals((2, 3), nearest) points = [(2, 3), (3, 4), (4, 5)] point = (3, 3) find_nearest = FindNearest(points, point, EuclideanDistance) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals((2, 3), nearest) points = [(2, 3), (3, 4), (4, 5)] point = (3, 4) find_nearest = FindNearest(points, point, EuclideanDistance) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals((3, 4), nearest) points = [[1], [5], [10]] point = [8] find_nearest = FindNearest(points, point, EuclideanDistance) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals([10], nearest) points = [[1], [5], [10]] point = [17] find_nearest = FindNearest(points, point, EuclideanDistance) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals([10], nearest) test_logger.debug("FindNearestTest - test_euclidean_distance Ends")
def test_algorithm(self): test_logger.debug("CosineDistanceTest - test_algorithm Starts") data = [(1, 2, 3), (3, 5, 7)] cosine_distance = CosineDistance(data) cosine_distance.process() result = cosine_distance.get_result() self.assertEquals(0.002585096956942312, result) data = [(1, 2, 3, 4), (1, 2, 3, 6)] cosine_distance = CosineDistance(data) cosine_distance.process() result = cosine_distance.get_result() self.assertEquals(0.018844218960787695, result) data = [(3, 1), (4, 1)] cosine_distance = CosineDistance(data) cosine_distance.process() result = cosine_distance.get_result() self.assertEquals(0.002945514498418511, result) data = [[3], [4]] cosine_distance = CosineDistance(data) cosine_distance.process() result = cosine_distance.get_result() self.assertEquals(0.0, result) data = [[3, 4], [6, 8]] cosine_distance = CosineDistance(data) cosine_distance.process() result = cosine_distance.get_result() self.assertEquals(0.0, result) data = [[3], [4, 5, 6]] cosine_distance = CosineDistance(data) with self.assertRaises(ArithmeticError) as context: cosine_distance.process() self.assertEqual('You cant calculate Cosine distance of array has different sizes.', context.exception.message) data = [["a"], [4]] cosine_distance = CosineDistance(data) with self.assertRaises(TypeError) as context: cosine_distance.process() self.assertEqual("unsupported operand type(s) for +: 'int' and 'str'", context.exception.message) data = [] cosine_distance = CosineDistance(data) with self.assertRaises(ArithmeticError) as context: cosine_distance.process() self.assertEqual('You must enter two array to find Cosine distance.', context.exception.message) test_logger.debug("CosineDistanceTest - test_algorithm Ends")
def test_algorithm(self): test_logger.debug("ManhattanDistanceTest - test_algorithm Starts") data = [(1, 2, 3, 4), (1, 2, 3, 6)] manhattan_distance = ManhattanDistance(data) manhattan_distance.process() result = manhattan_distance.get_result() self.assertEquals(2.0, result) data = [(1, 2, 3, 4), (5, 6, 7, 8)] manhattan_distance = ManhattanDistance(data) manhattan_distance.process() result = manhattan_distance.get_result() self.assertEquals(16.0, result) data = [(3, 1), (4, 1)] manhattan_distance = ManhattanDistance(data) manhattan_distance.process() result = manhattan_distance.get_result() self.assertEquals(1.0, result) data = [(3, 1, 5), (5, 5, 3)] manhattan_distance = ManhattanDistance(data) manhattan_distance.process() result = manhattan_distance.get_result() self.assertEquals(8.0, result) data = [[3], [4]] manhattan_distance = ManhattanDistance(data) manhattan_distance.process() result = manhattan_distance.get_result() self.assertEquals(1.0, result) data = [[3], [4, 5, 6]] manhattan_distance = ManhattanDistance(data) with self.assertRaises(ArithmeticError) as context: manhattan_distance.process() self.assertEqual('You cant calculate Manhattan distance of array has different sizes.', context.exception.message) data = [["a"], [4]] manhattan_distance = ManhattanDistance(data) with self.assertRaises(TypeError) as context: manhattan_distance.process() self.assertEqual("unsupported operand type(s) for -: 'int' and 'str'", context.exception.message) data = [] manhattan_distance = ManhattanDistance(data) with self.assertRaises(ArithmeticError) as context: manhattan_distance.process() self.assertEqual('You must enter two array to find Manhattan distance.', context.exception.message) test_logger.debug("ManhattanDistanceTest - test_algorithm Ends")
def test_algorithm_with_tuple(self): test_logger.debug("MeanTest - test_algorithm_with_tuple Starts") mean = Mean() data_list = [("a", 1), ("b", 2), ("c", 3), ("d", 4), ("e", 5)] self.assertEquals(3, mean.calculate(data_list, is_tuple=True, index=1)) data_list = [("a", "a", 1), ("b", "b", 2), ("c", "c", 3), ("d", "d", 4), ("e", "e", 5)] self.assertEquals(3.0, mean.calculate(data_list, is_tuple=True, index=2)) test_logger.debug("MeanTest - test_algorithm_with_tuple Ends")
def test_formula(self): test_logger.debug("SumFormulaTest - test_formula Starts") sum_formula = SumFormula() data_list = [1, 2, 3, 4, 5] self.assertEquals(15, sum_formula.calculate(data_list)) data_list = [1, 2, 3, 4] self.assertEquals(10, sum_formula.calculate(data_list)) data_list = [2] self.assertEquals(4, sum_formula.calculate(data_list, power=2)) data_list = [1, 2, 3, 4] self.assertEquals(30, sum_formula.calculate(data_list, power=2)) test_logger.debug("SumFormulaTest - test_formula Ends")
def test_algorithm_with_tuple(self): test_logger.debug("SumFormulaTest - test_algorithm_with_tuple Starts") sum_formula = SumFormula() data_list = [("a", 1), ("b", 2), ("c", 3), ( "d", 4), ("e", 5)] self.assertEquals(15, sum_formula.calculate(data_list, is_tuple=True, index=1)) data_list = [("a", "a", 1), ("b", "b", 2), ("c", "c", 3), ("d", "d", 4), ("e", "e", 5)] self.assertEquals(15, sum_formula.calculate(data_list, is_tuple=True, index=2)) data_list = [("a", "a", 1), ("e", "e", 5)] self.assertEquals(26, sum_formula.calculate(data_list, is_tuple=True, index=2, power=2)) test_logger.debug("SumFormulaTest - test_algorithm_with_tuple Ends")
def test_algorithm_with_tuple(self): test_logger.debug("VarianceTest - test_algorithm_with_tuple Starts") variance = Variance() data_list = [("a", 1), ("b", 2), ("c", 3), ( "d", 4), ("e", 5)] self.assertEquals(2.5, variance.calculate(data_list, is_tuple=True, index=1)) data_list = [("a", "a", 1), ("b", "b", 2), ("c", "c", 3), ("d", "d", 4), ("e", "e", 5)] self.assertEquals(2.5, variance.calculate(data_list, is_tuple=True, index=2)) data_list = [("a", "a", 1), ("b", "b", 2), ("c", "c", 3), ("d", "d", 4)] self.assertEquals(1.6667, variance.calculate(data_list, is_tuple=True, index=2)) test_logger.debug("VarianceTest - test_algorithm_with_tuple Ends")
def test_algorithm_with_tuple(self): test_logger.debug("StandartDeviationTest - test_algorithm_with_tuple Starts") standart_deviation = StandartDeviation() data_list = [("a", 1), ("b", 2), ("c", 3), ( "d", 4), ("e", 5)] self.assertEquals(1.5811, standart_deviation.calculate(data_list, is_tuple=True, index=1)) data_list = [("a", "a", 1), ("b", "b", 2), ("c", "c", 3), ("d", "d", 4), ("e", "e", 5)] self.assertEquals(1.5811, standart_deviation.calculate(data_list, is_tuple=True, index=2)) data_list = [("a", "a", 1), ("b", "b", 2), ("c", "c", 3), ("d", "d", 4)] self.assertEquals(1.291, standart_deviation.calculate(data_list, is_tuple=True, index=2)) test_logger.debug("StandartDeviationTest - test_algorithm_with_tuple Ends")
def test_algorithm_with_list(self): test_logger.debug("MeanTest - test_algorithm_with_list Starts") mean = Mean() data_list = [1, 2, 3, 4, 5] self.assertEquals(3, mean.calculate(data_list)) data_list = [1, 2, 3, 4] self.assertEquals(2.5, mean.calculate(data_list)) data_list = [] with self.assertRaises(ZeroDivisionError) as context: mean.calculate(data_list) self.assertEqual("integer division or modulo by zero", context.exception.message) test_logger.debug("MeanTest - test_algorithm_with_list Ends")
def test_algorithm_with_list(self): test_logger.debug("VarianceTest - test_algorithm_with_list Starts") variance = Variance() data_list = [1, 2, 3, 4, 5] self.assertEquals(2.5, variance.calculate(data_list)) data_list = [1, 2, 3, 4] self.assertEquals(1.6667, variance.calculate(data_list)) data_list = [] with self.assertRaises(ZeroDivisionError) as context: variance.calculate(data_list) self.assertEqual("integer division or modulo by zero", context.exception.message) test_logger.debug("VarianceTest - test_algorithm_with_list Ends")
def test_algorithm(self): test_logger.debug("ChessBoardDistanceTest - test_algorithm Starts") data = [(1, 2, 3, 4), (1, 2, 3, 8)] chessboard_distance = ChessBoardDistance(data) chessboard_distance.process() result = chessboard_distance.get_result() self.assertEquals(4.0, result) data = [(3, 1), (4, 1)] chessboard_distance = ChessBoardDistance(data) chessboard_distance.process() result = chessboard_distance.get_result() self.assertEquals(1.0, result) data = [(-3, 1), (4, 1)] chessboard_distance = ChessBoardDistance(data) chessboard_distance.process() result = chessboard_distance.get_result() self.assertEquals(7.0, result) data = [[3], [4]] chessboard_distance = ChessBoardDistance(data) chessboard_distance.process() result = chessboard_distance.get_result() self.assertEquals(1.0, result) data = [[3], [4, 5, 6]] chessboard_distance = ChessBoardDistance(data) with self.assertRaises(ArithmeticError) as context: chessboard_distance.process() self.assertEqual( 'You cant calculate Chess Board distance of array has different sizes.', context.exception.message) data = [["a"], [4]] chessboard_distance = ChessBoardDistance(data) with self.assertRaises(TypeError) as context: chessboard_distance.process() self.assertEqual("unsupported operand type(s) for -: 'int' and 'str'", context.exception.message) data = [] chessboard_distance = ChessBoardDistance(data) with self.assertRaises(ArithmeticError) as context: chessboard_distance.process() self.assertEqual( 'You must enter two array to find Chess Board distance.', context.exception.message) test_logger.debug("ChessBoardDistanceTest - test_algorithm Ends")
def test_algorithm(self): test_logger.debug("CorrelationDistanceTest - test_algorithm Starts") data = [(1, 2, 3), (3, 5, 10)] correlation_distance = CorrelationDistance(data) correlation_distance.process() result = correlation_distance.get_result() self.assertEquals(0.029274656605848937, result) data = [(1, 2, 3, 4), (1, 2, 3, 6)] correlation_distance = CorrelationDistance(data) correlation_distance.process() result = correlation_distance.get_result() self.assertEquals(0.0438171125324851, result) data = [(3, 1), (4, 1)] correlation_distance = CorrelationDistance(data) correlation_distance.process() result = correlation_distance.get_result() self.assertEquals(0.0, result) data = [[3], [4]] correlation_distance = CorrelationDistance(data) with self.assertRaises(ArithmeticError) as context: correlation_distance.process() self.assertEqual('float division by zero', context.exception.message) data = [[3], [4, 5, 6]] correlation_distance = CorrelationDistance(data) with self.assertRaises(ArithmeticError) as context: correlation_distance.process() self.assertEqual( 'You cant calculate Correlation distance of array has different sizes.', context.exception.message) data = [["a"], [4]] correlation_distance = CorrelationDistance(data) with self.assertRaises(TypeError) as context: correlation_distance.process() self.assertEqual("unsupported operand type(s) for +: 'int' and 'str'", context.exception.message) data = [] correlation_distance = CorrelationDistance(data) with self.assertRaises(ArithmeticError) as context: correlation_distance.process() self.assertEqual( 'You must enter two array to find Correlation distance.', context.exception.message) test_logger.debug("CorrelationDistanceTest - test_algorithm Ends")
def test_algorithm_with_list(self): test_logger.debug("MedianTest - test_algorithm_with_list Starts") median = Median() data_list = [1, 2, 3, 4, 5] self.assertEquals(3, median.calculate(data_list)) data_list = [1, 2, 3, 4] self.assertEquals(2, median.calculate(data_list)) data_list = [] with self.assertRaises(IndexError) as context: median.calculate(data_list) self.assertEqual("list index out of range", context.exception.message) test_logger.debug("MedianTest - test_algorithm_with_list Ends")
def test_algorithm(self): test_logger.debug( "SokalSneathDissimilarityTest - test_algorithm Starts") data = [[1, 0, 1, 1, 0], [1, 1, 0, 1, 1]] sokal_sneath_dissimilarity = SokalSneathDissimilarity(data) sokal_sneath_dissimilarity.process() result = sokal_sneath_dissimilarity.get_result() self.assertEquals(0.75, result) data = [[True, False, True], [True, True, False]] sokal_sneath_dissimilarity = SokalSneathDissimilarity(data) sokal_sneath_dissimilarity.process() result = sokal_sneath_dissimilarity.get_result() self.assertEquals(0.8, result) data = [[1, 1, 1, 1], [1, 1, 1, 1]] sokal_sneath_dissimilarity = SokalSneathDissimilarity(data) sokal_sneath_dissimilarity.process() result = sokal_sneath_dissimilarity.get_result() self.assertEquals(0.0, result) data = [[0, 0, 0, 0], [1, 1, 1, 1]] sokal_sneath_dissimilarity = SokalSneathDissimilarity(data) sokal_sneath_dissimilarity.process() result = sokal_sneath_dissimilarity.get_result() self.assertEquals(1.0, result) data = [[3], [4, 5, 6]] sokal_sneath_dissimilarity = SokalSneathDissimilarity(data) with self.assertRaises(ArithmeticError) as context: sokal_sneath_dissimilarity.process() self.assertEqual( 'You cant calculate Sokal Sneath dissimilarity of array has different sizes.', context.exception.message) data = [[], []] sokal_sneath_dissimilarity = SokalSneathDissimilarity(data) with self.assertRaises(ArithmeticError) as context: sokal_sneath_dissimilarity.process() self.assertEqual('float division by zero', context.exception.message) data = [] sokal_sneath_dissimilarity = SokalSneathDissimilarity(data) with self.assertRaises(ArithmeticError) as context: sokal_sneath_dissimilarity.process() self.assertEqual( 'You must enter two array to find squared euclidean distance.', context.exception.message) test_logger.debug("SokalSneathDissimilarityTest - test_algorithm Ends")
def test_algorithm(self): test_logger.debug("JaccardDissimilarityTest - test_algorithm Starts") data = [[1, 0, 1, 1, 0], [1, 1, 0, 1, 1]] jaccard_dissimilarity = JaccardDissimilarity(data) jaccard_dissimilarity.process() result = jaccard_dissimilarity.get_result() self.assertEquals(0.6, result) data = [[True, False, True], [True, True, False]] jaccard_dissimilarity = JaccardDissimilarity(data) jaccard_dissimilarity.process() result = jaccard_dissimilarity.get_result() self.assertEquals(0.6666666666666666, result) data = [[1, 1, 1, 1], [1, 1, 1, 1]] jaccard_dissimilarity = JaccardDissimilarity(data) jaccard_dissimilarity.process() result = jaccard_dissimilarity.get_result() self.assertEquals(0.0, result) data = [[0, 0, 0, 0], [1, 1, 1, 1]] jaccard_dissimilarity = JaccardDissimilarity(data) jaccard_dissimilarity.process() result = jaccard_dissimilarity.get_result() self.assertEquals(1.0, result) data = [[3], [4, 5, 6]] jaccard_dissimilarity = JaccardDissimilarity(data) with self.assertRaises(ArithmeticError) as context: jaccard_dissimilarity.process() self.assertEqual( 'You cant calculate hamming distance of array has different sizes.', context.exception.message) data = [[0, 0, 0, 0], [0, 0, 0, 0]] jaccard_dissimilarity = JaccardDissimilarity(data) with self.assertRaises(ArithmeticError) as context: jaccard_dissimilarity.process() self.assertEqual('float division by zero', context.exception.message) data = [] jaccard_dissimilarity = JaccardDissimilarity(data) with self.assertRaises(ArithmeticError) as context: jaccard_dissimilarity.process() self.assertEqual( 'You must enter two array to find squared euclidean distance.', context.exception.message) test_logger.debug("JaccardDissimilarityTest - test_algorithm Ends")
def test_algorithm(self): test_logger.debug("NormalizedSquaredEuclideanDistanceTest - test_algorithm Starts") data = [(1, 2, 3), (3, 5, 10)] normalized_squared_euclidean_distance = NormalizedSquaredEuclideanDistance(data) normalized_squared_euclidean_distance.process() result = normalized_squared_euclidean_distance.get_result() self.assertEquals(1.0 / 4, result) data = [(1, 1, 4, 6, 1200, 3, 2, 3, 2, 8), (2, 1, 5, 6, 1300, 3, 2, 5, 3, 8)] normalized_squared_euclidean_distance = NormalizedSquaredEuclideanDistance(data) normalized_squared_euclidean_distance.process() result = normalized_squared_euclidean_distance.get_result() self.assertEquals(0.001589630279970944, result) data = [(3, 1), (4, 1)] normalized_squared_euclidean_distance = NormalizedSquaredEuclideanDistance(data) normalized_squared_euclidean_distance.process() result = normalized_squared_euclidean_distance.get_result() self.assertEquals(0.038461538461538464, result) data = [[3], [4]] normalized_squared_euclidean_distance = NormalizedSquaredEuclideanDistance(data) with self.assertRaises(ArithmeticError) as context: normalized_squared_euclidean_distance.process() self.assertEqual('float division by zero', context.exception.message) data = [[3], [4, 5, 6]] normalized_squared_euclidean_distance = NormalizedSquaredEuclideanDistance(data) with self.assertRaises(ArithmeticError) as context: normalized_squared_euclidean_distance.process() self.assertEqual('You cant calculate Normalized Squared Euclidean distance of array has different sizes.', context.exception.message) data = [["a"], [4]] normalized_squared_euclidean_distance = NormalizedSquaredEuclideanDistance(data) with self.assertRaises(TypeError) as context: normalized_squared_euclidean_distance.process() self.assertEqual("unsupported operand type(s) for +: 'int' and 'str'", context.exception.message) data = [] normalized_squared_euclidean_distance = NormalizedSquaredEuclideanDistance(data) with self.assertRaises(ArithmeticError) as context: normalized_squared_euclidean_distance.process() self.assertEqual('You must enter two array to find Normalized Squared Euclidean distance.', context.exception.message) test_logger.debug("NormalizedSquaredEuclideanDistanceTest - test_algorithm Ends")
def test_algorithm(self): test_logger.debug("CorrelationDistanceTest - test_algorithm Starts") data = [(1, 2, 3), (3, 5, 10)] correlation_distance = CorrelationDistance(data) correlation_distance.process() result = correlation_distance.get_result() self.assertEquals(0.029274656605848937, result) data = [(1, 2, 3, 4), (1, 2, 3, 6)] correlation_distance = CorrelationDistance(data) correlation_distance.process() result = correlation_distance.get_result() self.assertEquals(0.0438171125324851, result) data = [(3, 1), (4, 1)] correlation_distance = CorrelationDistance(data) correlation_distance.process() result = correlation_distance.get_result() self.assertEquals(0.0, result) data = [[3], [4]] correlation_distance = CorrelationDistance(data) with self.assertRaises(ArithmeticError) as context: correlation_distance.process() self.assertEqual('float division by zero', context.exception.message) data = [[3], [4, 5, 6]] correlation_distance = CorrelationDistance(data) with self.assertRaises(ArithmeticError) as context: correlation_distance.process() self.assertEqual('You cant calculate Correlation distance of array has different sizes.', context.exception.message) data = [["a"], [4]] correlation_distance = CorrelationDistance(data) with self.assertRaises(TypeError) as context: correlation_distance.process() self.assertEqual("unsupported operand type(s) for +: 'int' and 'str'", context.exception.message) data = [] correlation_distance = CorrelationDistance(data) with self.assertRaises(ArithmeticError) as context: correlation_distance.process() self.assertEqual('You must enter two array to find Correlation distance.', context.exception.message) test_logger.debug("CorrelationDistanceTest - test_algorithm Ends")
def test_algorithm(self): test_logger.debug("ChessBoardDistanceTest - test_algorithm Starts") data = [(1, 2, 3, 4), (1, 2, 3, 8)] chessboard_distance = ChessBoardDistance(data) chessboard_distance.process() result = chessboard_distance.get_result() self.assertEquals(4.0, result) data = [(3, 1), (4, 1)] chessboard_distance = ChessBoardDistance(data) chessboard_distance.process() result = chessboard_distance.get_result() self.assertEquals(1.0, result) data = [(-3, 1), (4, 1)] chessboard_distance = ChessBoardDistance(data) chessboard_distance.process() result = chessboard_distance.get_result() self.assertEquals(7.0, result) data = [[3], [4]] chessboard_distance = ChessBoardDistance(data) chessboard_distance.process() result = chessboard_distance.get_result() self.assertEquals(1.0, result) data = [[3], [4, 5, 6]] chessboard_distance = ChessBoardDistance(data) with self.assertRaises(ArithmeticError) as context: chessboard_distance.process() self.assertEqual('You cant calculate Chess Board distance of array has different sizes.', context.exception.message) data = [["a"], [4]] chessboard_distance = ChessBoardDistance(data) with self.assertRaises(TypeError) as context: chessboard_distance.process() self.assertEqual("unsupported operand type(s) for -: 'int' and 'str'", context.exception.message) data = [] chessboard_distance = ChessBoardDistance(data) with self.assertRaises(ArithmeticError) as context: chessboard_distance.process() self.assertEqual('You must enter two array to find Chess Board distance.', context.exception.message) test_logger.debug("ChessBoardDistanceTest - test_algorithm Ends")
def test_algorithm(self): test_logger.debug("DiceDissimilarityTest - test_algorithm Starts") data = [[1, 0, 1, 1, 0], [1, 1, 0, 1, 1]] dice_dissimilarity = DiceDissimilarity(data) dice_dissimilarity.process() result = dice_dissimilarity.get_result() self.assertEquals(3.0 / 7, result) data = [[True, False, True], [True, True, False]] dice_dissimilarity = DiceDissimilarity(data) dice_dissimilarity.process() result = dice_dissimilarity.get_result() self.assertEquals(0.5, result) data = [[1, 1, 1, 1], [1, 1, 1, 1]] dice_dissimilarity = DiceDissimilarity(data) dice_dissimilarity.process() result = dice_dissimilarity.get_result() self.assertEquals(0.0, result) data = [[0, 0, 0, 0], [1, 1, 1, 1]] dice_dissimilarity = DiceDissimilarity(data) dice_dissimilarity.process() result = dice_dissimilarity.get_result() self.assertEquals(1.0, result) data = [[3], [4, 5, 6]] dice_dissimilarity = DiceDissimilarity(data) with self.assertRaises(ArithmeticError) as context: dice_dissimilarity.process() self.assertEqual('You cant calculate dice dissimilarity of array has different sizes.', context.exception.message) data = [[0, 0, 0, 0], [0, 0, 0, 0]] dice_dissimilarity = DiceDissimilarity(data) with self.assertRaises(ArithmeticError) as context: dice_dissimilarity.process() self.assertEqual('float division by zero', context.exception.message) data = [] dice_dissimilarity = DiceDissimilarity(data) with self.assertRaises(ArithmeticError) as context: dice_dissimilarity.process() self.assertEqual('You must enter two array to find squared euclidean distance.', context.exception.message) test_logger.debug("DiceDissimilarityTest - test_algorithm Ends")
def test_algorithm(self): test_logger.debug("BrayCurtisDistanceTest - test_algorithm Starts") data = [(1, 2, 3), (2, 4, 6)] bray_curtis_distance = BrayCurtisDistance(data) bray_curtis_distance.process() result = bray_curtis_distance.get_result() expected_result = float(1.0 / 3.0) self.assertEquals(expected_result, result) data = [(3, 1), (4, 1)] bray_curtis_distance = BrayCurtisDistance(data) bray_curtis_distance.process() result = bray_curtis_distance.get_result() expected_result = float(1.0 / 9.0) self.assertEquals(expected_result, result) data = [[3], [4]] bray_curtis_distance = BrayCurtisDistance(data) bray_curtis_distance.process() result = bray_curtis_distance.get_result() expected_result = 0.14285714285714285 self.assertEquals(expected_result, result) data = [[3], [4, 5, 6]] bray_curtis_distance = BrayCurtisDistance(data) with self.assertRaises(ArithmeticError) as context: bray_curtis_distance.process() self.assertEqual( 'You cant calculate Bray Curtis distance of array has different sizes.', context.exception.message) data = [["a"], [4]] bray_curtis_distance = BrayCurtisDistance(data) with self.assertRaises(TypeError) as context: bray_curtis_distance.process() self.assertEqual("unsupported operand type(s) for -: 'int' and 'str'", context.exception.message) data = [] bray_curtis_distance = BrayCurtisDistance(data) with self.assertRaises(ArithmeticError) as context: bray_curtis_distance.process() self.assertEqual( 'You must enter two array to find Bray Curtis distance.', context.exception.message) test_logger.debug("BrayCurtisDistanceTest - test_algorithm Ends")
def test_algorithm(self): test_logger.debug("SimilarityMeasureTest - test_algorithm Starts") data = [] similarity_measure = SimilarityMeasure(data) with self.assertRaises(NotImplementedError) as context: similarity_measure.process() self.assertEqual('Subclasses should implement this!', context.exception.message) data = "" with self.assertRaises(TypeError) as context: SimilarityMeasure(data) self.assertEqual('You must initialize array.', context.exception.message) test_logger.debug("SimilarityMeasureTest - test_algorithm Ends")
def test_normalized_squared_euclidean_distance_multiple(self): test_logger.debug("FindNearestTest - test_normalized_squared_euclidean_distance_multiple Starts") points = [(1, 0, 1, 0, 1, 0), (1, 0, 1, 0, 1, 1), (1, 0, 1, 1, 1, 0)] point = (1, 0, 0, 0, 0, 0) find_nearest = FindNearest(points, point, NormalizedSquaredEuclideanDistance, k=2) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals([(1, 0, 1, 0, 1, 0), (1, 0, 1, 0, 1, 1)], nearest) points = [ (1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1), (1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1), (0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1), ] point = (0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1) find_nearest = FindNearest(points, point, NormalizedSquaredEuclideanDistance, k=2) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals( [(0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1), (1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1)], nearest ) points = [(2, 3), (3, 4), (4, 5)] point = (0, 1) find_nearest = FindNearest(points, point, NormalizedSquaredEuclideanDistance, k=2) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals([(2, 3), (2, 3)], nearest) points = [(2, 3), (3, 4), (4, 5)] point = (3, 3) find_nearest = FindNearest(points, point, NormalizedSquaredEuclideanDistance, k=2) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals([(2, 3), (2, 3)], nearest) points = [(2, 3), (3, 4), (4, 5)] point = (3, 4) find_nearest = FindNearest(points, point, NormalizedSquaredEuclideanDistance, k=2) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals([(2, 3), (2, 3)], nearest) test_logger.debug("FindNearestTest - test_normalized_squared_euclidean_distance_multiple Ends")
def test_dice_dissimilarity(self): test_logger.debug("FindNearestTest - test_dice_dissimilarity Starts") points = [(1, 0, 1, 0, 1, 0), (1, 0, 1, 0, 1, 1), (1, 0, 1, 1, 1, 0)] point = (1, 0, 0, 0, 0, 0) find_nearest = FindNearest(points, point, DiceDissimilarity) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals((1, 0, 1, 0, 1, 0), nearest) points = [(1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1), (1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1), (0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1)] point = (0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1) find_nearest = FindNearest(points, point, DiceDissimilarity) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals((0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1), nearest) test_logger.debug("FindNearestTest - test_dice_dissimilarity Ends")
def test_algorithm(self): test_logger.debug("CanberraDistanceTest - test_algorithm Starts") data = [(1, 2, 3), (2, 4, 6)] canberra_distance = CanberraDistance(data) canberra_distance.process() result = canberra_distance.get_result() self.assertEquals(1.0, result) data = [(3, 1), (4, 1)] canberra_distance = CanberraDistance(data) canberra_distance.process() result = canberra_distance.get_result() self.assertEquals(0.14285714285714285, result) data = [[3], [4]] canberra_distance = CanberraDistance(data) canberra_distance.process() result = canberra_distance.get_result() self.assertEquals(0.14285714285714285, result) data = [[3], [4, 5, 6]] canberra_distance = CanberraDistance(data) with self.assertRaises(ArithmeticError) as context: canberra_distance.process() self.assertEqual( 'You cant calculate Canberra distance of array has different sizes.', context.exception.message) data = [["a"], [4]] canberra_distance = CanberraDistance(data) with self.assertRaises(TypeError) as context: canberra_distance.process() self.assertEqual("unsupported operand type(s) for -: 'int' and 'str'", context.exception.message) data = [] canberra_distance = CanberraDistance(data) with self.assertRaises(ArithmeticError) as context: canberra_distance.process() self.assertEqual( 'You must enter two array to find squared Canberra distance.', context.exception.message) test_logger.debug("CanberraDistanceTest - test_algorithm Ends")
def test_algorithm(self): test_logger.debug("BrayCurtisDistanceTest - test_algorithm Starts") data = [(1, 2, 3), (2, 4, 6)] bray_curtis_distance = BrayCurtisDistance(data) bray_curtis_distance.process() result = bray_curtis_distance.get_result() expected_result = float(1.0 / 3.0) self.assertEquals(expected_result, result) data = [(3, 1), (4, 1)] bray_curtis_distance = BrayCurtisDistance(data) bray_curtis_distance.process() result = bray_curtis_distance.get_result() expected_result = float(1.0 / 9.0) self.assertEquals(expected_result, result) data = [[3], [4]] bray_curtis_distance = BrayCurtisDistance(data) bray_curtis_distance.process() result = bray_curtis_distance.get_result() expected_result = 0.14285714285714285 self.assertEquals(expected_result, result) data = [[3], [4, 5, 6]] bray_curtis_distance = BrayCurtisDistance(data) with self.assertRaises(ArithmeticError) as context: bray_curtis_distance.process() self.assertEqual( "You cant calculate Bray Curtis distance of array has different sizes.", context.exception.message ) data = [["a"], [4]] bray_curtis_distance = BrayCurtisDistance(data) with self.assertRaises(TypeError) as context: bray_curtis_distance.process() self.assertEqual("unsupported operand type(s) for -: 'int' and 'str'", context.exception.message) data = [] bray_curtis_distance = BrayCurtisDistance(data) with self.assertRaises(ArithmeticError) as context: bray_curtis_distance.process() self.assertEqual("You must enter two array to find Bray Curtis distance.", context.exception.message) test_logger.debug("BrayCurtisDistanceTest - test_algorithm Ends")
def test_algorithm(self): test_logger.debug("FunctionDerivateTest - test_algorithm Starts") def g(x): return x * x * x dg = FunctionDerivate.calculate(g) self.assertEqual(27.0, dg(3)) data = [1, 2, 3, 4, 5] dg = FunctionDerivate.calculate(data) self.assertEqual(184.0, dg(3)) self.assertEqual(20.0, dg(1)) self.assertEqual(4.0, dg(0)) test_logger.debug("FunctionDerivateTest - test_algorithm Ends")
def test_algorithm(self): test_logger.debug("CanberraDistanceTest - test_algorithm Starts") data = [(1, 2, 3), (2, 4, 6)] canberra_distance = CanberraDistance(data) canberra_distance.process() result = canberra_distance.get_result() self.assertEquals(1.0, result) data = [(3, 1), (4, 1)] canberra_distance = CanberraDistance(data) canberra_distance.process() result = canberra_distance.get_result() self.assertEquals(0.14285714285714285, result) data = [[3], [4]] canberra_distance = CanberraDistance(data) canberra_distance.process() result = canberra_distance.get_result() self.assertEquals(0.14285714285714285, result) data = [[3], [4, 5, 6]] canberra_distance = CanberraDistance(data) with self.assertRaises(ArithmeticError) as context: canberra_distance.process() self.assertEqual('You cant calculate Canberra distance of array has different sizes.', context.exception.message) data = [["a"], [4]] canberra_distance = CanberraDistance(data) with self.assertRaises(TypeError) as context: canberra_distance.process() self.assertEqual("unsupported operand type(s) for -: 'int' and 'str'", context.exception.message) data = [] canberra_distance = CanberraDistance(data) with self.assertRaises(ArithmeticError) as context: canberra_distance.process() self.assertEqual('You must enter two array to find squared Canberra distance.', context.exception.message) test_logger.debug("CanberraDistanceTest - test_algorithm Ends")
def test_matching_dissimilarity_multiple(self): test_logger.debug("FindNearestTest - test_matching_dissimilarity_multiple Starts") points = [(1, 0, 1, 0, 1, 0), (1, 0, 1, 0, 1, 1), (1, 0, 1, 1, 1, 0)] point = (1, 0, 0, 0, 0, 0) find_nearest = FindNearest(points, point, MatchingDissimilarity, k=2) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals([(1, 0, 1, 0, 1, 0), (1, 0, 1, 0, 1, 1)], nearest) points = [(1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1), (1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1), (0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1)] point = (0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1) find_nearest = FindNearest(points, point, MatchingDissimilarity, k=2) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals([(0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1), (1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1)] , nearest) test_logger.debug("FindNearestTest - test_matching_dissimilarity_multiple Ends")
def test_algorithm_with_tuple(self): test_logger.debug( "StandartDeviationTest - test_algorithm_with_tuple Starts") standart_deviation = StandartDeviation() data_list = [("a", 1), ("b", 2), ("c", 3), ("d", 4), ("e", 5)] self.assertEquals( 1.5811, standart_deviation.calculate(data_list, is_tuple=True, index=1)) data_list = [("a", "a", 1), ("b", "b", 2), ("c", "c", 3), ("d", "d", 4), ("e", "e", 5)] self.assertEquals( 1.5811, standart_deviation.calculate(data_list, is_tuple=True, index=2)) data_list = [("a", "a", 1), ("b", "b", 2), ("c", "c", 3), ("d", "d", 4)] self.assertEquals( 1.291, standart_deviation.calculate(data_list, is_tuple=True, index=2)) test_logger.debug( "StandartDeviationTest - test_algorithm_with_tuple Ends")
def test_algorithm(self): test_logger.debug("NormTest - test_algorithm Starts") data = [1, -2] norm = Norm.calculate(data) result = math.sqrt(5) self.assertEquals(result, norm) data = [1, 2, 3, 4] norm = Norm.calculate(data) self.assertEquals(5.477225575051661, norm) data = (5, 6, 7, 8) norm = Norm.calculate(data) self.assertEquals(13.19090595827292, norm) data = [3, 1, 4, 1] norm = Norm.calculate(data) self.assertEquals(5.196152422706632, norm) data = [3, 1, 5, 5, 5, 3] norm = Norm.calculate(data) self.assertEquals(9.695359714832659, norm) data = [3] norm = Norm.calculate(data) self.assertEquals(3.0, norm) data = [[3], [4, 5, 6]] with self.assertRaises(TypeError) as context: norm = Norm.calculate(data) self.assertEqual('float() argument must be a string or a number', context.exception.message) data = [["a"], [4]] with self.assertRaises(TypeError) as context: norm = Norm.calculate(data) self.assertEqual("float() argument must be a string or a number", context.exception.message) test_logger.debug("NormTest - test_algorithm Ends")
def test_canberra_distance(self): test_logger.debug("FindNearestTest - test_canberra_distance Starts") points = [(2, 3), (3, 4), (4, 5)] point = (0, 0) find_nearest = FindNearest(points, point, CanberraDistance) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals((2, 3), nearest) points = [(2, 3), (3, 4), (4, 5)] point = (3, 3) find_nearest = FindNearest(points, point, CanberraDistance) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals((2, 3), nearest) points = [(2, 3), (3, 4), (4, 5)] point = (3, 4) find_nearest = FindNearest(points, point, CanberraDistance) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals((2, 3), nearest) points = [[1], [5], [10]] point = [8] find_nearest = FindNearest(points, point, CanberraDistance) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals([1], nearest) points = [[1], [5], [10]] point = [17] find_nearest = FindNearest(points, point, CanberraDistance) find_nearest.process() nearest = find_nearest.get_result() self.assertEquals([1], nearest) test_logger.debug("FindNearestTest - test_canberra_distance Ends")
def test_algorithm(self): test_logger.debug("LinearEquationDerivateTest - test_algorithm Starts") """ This data symbolise "y=2x + 1" """ data = [2, 1] linear_equation_derivate = LinearEquationDerivate.calculate(data) expected_result = [2] self.assertEquals(expected_result, linear_equation_derivate) linear_equation_derivate = LinearEquationDerivate.calculate_equation( data) expected_result = "2" self.assertEquals(expected_result, linear_equation_derivate) data = [3, 4, 5, 6, 2, 1] linear_equation_derivate = LinearEquationDerivate.calculate(data) expected_result = [15, 16, 15, 12, 2] self.assertEquals(expected_result, linear_equation_derivate) linear_equation_derivate = LinearEquationDerivate.calculate_equation( data) expected_result = "15*x^4+ 16*x^3+ 15*x^2+ 12*x+ 2" self.assertEquals(expected_result, linear_equation_derivate) test_logger.debug("LinearEquationDerivateTest - test_algorithm Ends") def derivative(f): """Computes the numerical derivative of a function.""" def df(x, h=0.1e-5): return (f(x + h / 2) - f(x - h / 2)) / h return df def g(x): return x * x * x dg = derivative(g) print dg(3)