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_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_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("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_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_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(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_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_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_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)
