Implemented Various Distance Metric

docs/methods/metrics/distance_metric.md

@@ -0,0 +1,47 @@
+# Distance Metric
+
+## Euclidean Distance
+Euclidean Distance represents the shortest distance between two points.
+
+## Manhattan Distance
+Manhattan Distance is the sum of absolute differences between points across all the dimensions.
+
+## Manhattan Distance
+Minkowski Distance is the generalized form of Euclidean and Manhattan Distance.
+
+## Cosine Similarity
+Cosine similarity is a metric, helpful in determining, how similar the data objects are irrespective of their size.
+
+## Parameters
+
+| Name             | Definition                                                                              | Type |
+| -----------------| --------------------------------------------------------------------------------------- | ---- |
+| x                | A vector of values                                                                      |   `T`|
+| y                | A vector of values                                                                      |   `T`|
+
+
+## Methods
+
+| Name                            | Definition                                            | Return value      |
+| ------------------------------- | ----------------------------------------------------- | ----------------- |
+| `euclidean()`                   | To find the euclidean distance                         | `double`         |
+| `manhattan()`                   | To find the manhattan distance                         | `int, double`   |
+| `minkowski(int p)`              | To find the minkowski distance                         | `double`         |
+| `magnitude(vector<T> &x)`       | To find the magnitude of the vector                    | `double`         |
+| `cosineSimilarity()`            | To find the cosine similarity                          | `double`         |
+
+
+
+## Example
+
+```cpp
+std::vector<double> dist1 = {1, 4, 4, 4};
+std::vector<double> dist2 = {1, 2, 3, 4};
+DistanceMetric Dist(dist1, dist2);
+std::cout << "Minkowski Distance is " << Dist.minkowski(3) << std::endl;
+std::cout << "Euclidean Distance is " << Dist.euclidean() << std::endl;
+std::cout << "Manhattan Distance is " << Dist.manhattan() << std::endl;
+std::cout << "Cosine Similarity is  " << Dist.cosineSimilarity() << std::endl;
+```
+
+

docs/methods/metrics/f1Score.md

@@ -7,7 +7,6 @@ Some advantages of F1-score:
 2)If you choose your positive class as the one with fewer samples, F1-score can help balance the metric across positive/negative samples.
 
 
-
 ## Parameters
 
 | Name          | Definition                                                                                  | Type            |

examples/metrics/distance_metric_eg.cpp

@@ -0,0 +1,14 @@
+// #include "../src/slowmokit/methods/metrics/distance_metric/distance_metric.hpp"
+
+
+// int main()
+// {
+//   std::vector<double> dist1 = {1, 4, 4, 4};
+//   std::vector<double> dist2 = {1, 2, 3, 4};
+//   DistanceMetric Dist(dist1, dist2);
+//   std::cout << "Minkowski Distance is " << Dist.minkowski(3) << std::endl;
+//   std::cout << "Euclidean Distance is " << Dist.euclidean() << std::endl;
+//   std::cout << "Manhattan Distance is " << Dist.manhattan() << std::endl;
+//   std::cout << "Cosine Similarity is  " << Dist.cosineSimilarity() << std::endl;
+//   return 0;
+// }

src/slowmokit/methods/metrics/distance_metric/distance_metric.cpp

@@ -0,0 +1,81 @@
+/**
+ * @file methods/metrics/distance_metric/distance_metric.hpp
+ *
+ * Easy include to calculate distance metrics
+ */
+
+#include "distance_metric.hpp"
+
+template <class T>
+DistanceMetric<T>::DistanceMetric(std::vector<T> &x, std::vector<T> &y)
+{
+	this->x = x;
+	this->y = y;
+	if (x.size() != y.size())
+	{
+		throw std::domain_error("Size of the two vectors must be same");
+	}
+}
+
+template <class T>
+double DistanceMetric<T>::euclidean()
+{
+	double distance = 0;
+	int n = x.size();
+	for (int i = 0; i < n; i++)
+	{
+		distance += (x[i] - y[i]) * (x[i] - y[i]);
+	}
+	assert(distance >= 0);
+	return std::sqrt(distance);
+}
+
+template <class T>
+T DistanceMetric<T>::manhattan()
+{
+	T distance = 0;
+	int n = x.size();
+	for (int i = 0; i < n; i++)
+	{
+		distance += std::abs(x[i] - y[i]);
+	}
+	assert(distance >= 0);
+	return distance;
+}
+template <class T>
+double DistanceMetric<T>::minkowski(int power)
+{
+	double distance = 0;
+	int n = x.size();
+	for (int i = 0; i < n; i++)
+	{
+		distance += std::pow(std::abs(x[i] - y[i]), power);
+	}
+	assert(distance >= 0);
+	return std::pow(distance, 1.0 / power);
+}
+
+template <class T>
+double DistanceMetric<T>::magnitude(std::vector<T> &x)
+{
+	double result = 0;
+	int n = x.size();
+	for (int i = 0; i < n; i++)
+	{
+		result += x[i] * x[i];
+	}
+	assert(result >= 0);
+	return std::sqrt(result);
+}
+
+template <class T>
+double DistanceMetric<T>::cosineSimilarity()
+{
+	double dotProduct = 0;
+	int n = x.size();
+	for (int i = 0; i < n; i++)
+	{
+		dotProduct += x[i] * y[i];
+	}
+	return dotProduct / (magnitude(x) * magnitude(y));
+}

src/slowmokit/methods/metrics/distance_metric/distance_metric.hpp

@@ -0,0 +1,59 @@
+/**
+ * @file methods/metrics/distance_metric/distance_metric.hpp
+ *
+ * Easy include to calculate distances
+ */
+
+#ifndef SLOWMOKIT_DISTANCE_METRIC_HPP
+#define SLOWMOKIT_DISTANCE_METRIC_HPP
+#include "../../../core.hpp"
+
+/**
+ * Takes predicted and actual values of classes
+ * @param x
+ * @param y
+ * @returns the distance metrics
+ * @throws domain_error exception when size of the two vectors is not equal
+ */
+template <class T>
+class DistanceMetric
+{
+	private:
+	std::vector<T> x;
+	std::vector<T> y;
+
+	public:
+	DistanceMetric(std::vector<T> &x, std::vector<T> &y);
+
+	/**
+	 * @returns euclidean distance between the two vectors
+	 */
+	double euclidean();
+
+
+	/**
+	 * @returns manhattan distance between the two vectors
+	 */
+	T manhattan();
+
+
+	/**
+	 * @param power The order of the norm
+	 * @returns minkowski distance between the two vectors
+	 */
+	double minkowski(int);
+
+	/**
+	 * @brief to find the magnitude of the vector
+	 * @param x a vector
+	 * @returns magnitude of x
+	 */
+	double magnitude(std::vector<T> &);
+
+	/**
+	 * @returns cosine similarity between the two vectors
+	 */
+	double cosineSimilarity();
+};
+
+#endif // SLOWMOKIT_DISTANCE_METRIC_HPP