Implemented Various Distance Metric

CMakeLists.txt

@@ -62,4 +62,6 @@ add_library(slowmokit
         src/slowmokit/methods/metrics/f1score.hpp
         src/slowmokit/methods/metrics/f1score.cpp
         src/slowmokit/methods/metrics/mean_squared_error.hpp
-        src/slowmokit/methods/metrics/mean_squared_error.cpp)
+        src/slowmokit/methods/metrics/mean_squared_error.cpp
+        src/slowmokit/methods/neighbors/distance_metric/distance_metric.cpp
+        src/slowmokit/methods/neighbors/distance_metric/distance_metric.hpp)

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/neighbors/distance_metric_eg.cpp

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

src/slowmokit/methods/neighbors/distance_metric/distance_metric.cpp

@@ -0,0 +1,89 @@
+/**
+ * @file methods/neighbors/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> &t)
+{
+  this->x = x;
+  this->y = y;
+}
+
+template<class T>
+double DistanceMetric<T>::euclidean(std::vector<T> &x, std::vector<T> &y)
+{
+  if (x.size() != y.size())
+  {
+    throw std::domain_error("Size of the two vectors must be same");
+  }
+  double distance = 0;
+  int n = x.size();
+  for (int i = 0; i < n; i++)
+  {
+    distance += (x[i] - y[i]) * (x[i] - y[i]);
+  }
+  return sqrt(distance);
+}
+
+template<class T>
+double DistanceMetric<T>::manhattan(std::vector<T> &x, std::vector<T> &y)
+{
+  if (x.size() != y.size())
+  {
+    throw std::domain_error("Size of the two vectors must be same");
+  }
+  double distance = 0;
+  int n = x.size();
+  for (int i = 0; i < n; i++)
+  {
+    distance += abs(x[i] - y[i]);
+  }
+  return distance;
+}
+template<class T>
+double DistanceMetric<T>::minkowski(std::vector<T> &x, std::vector<T> &y,
+                                    int power)
+{
+  if (x.size() != y.size())
+  {
+    throw std::domain_error("Size of the two vectors must be same");
+  }
+  double distance = 0.0;
+  int n = x.size();
+  for (int i = 0; i < n; i++)
+  {
+    distance += pow(x[i] - y[i], power);
+  }
+  return pow(distance, 1.0 / power);
+}
+
+template<class T> double DistanceMetric<T>::magnitude(std::vector<T> &x)
+{
+  double result = 0.0;
+  int n = x.size();
+  for (int i = 0; i < n; i++)
+  {
+    result += pow(x[i], 2);
+  }
+  return sqrt(result);
+}
+
+template<class T>
+double DistanceMetric<T>::cosineSimilarity(std::vector<T> &x, std::vector<T> &y)
+{
+  if (x.size() != y.size())
+  {
+    throw std::domain_error("Size of the two vectors must be same");
+  }
+  double dotProduct = 0.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/neighbors/distance_metric/distance_metric.hpp

@@ -0,0 +1,69 @@
+/**
+ * @file methods/neighbors/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);
+
+  /**
+   * @param x An array where each row is a sample and each column is a feature.
+   * @param y An array where each row is a sample and each column is a feature.
+   * @throws domain_error exception when size of the two vectors is not equal
+   * @returns euclidean distance between the two vectors
+   */
+  double euclidean(std::vector<T> &, std::vector<T> &);
+
+
+  /**
+   *@param x An array where each row is a sample and each column is a feature.
+   * @param y An array where each row is a sample and each column is a feature.
+   * @throws domain_error exception when size of the two vectors is not equal
+   * @returns manhattan distance between the two vectors
+   */
+  double manhattan(std::vector<T> &, std::vector<T> &);
+
+
+  /**
+   * @param x An array where each row is a sample and each column is a feature.
+   * @param y An array where each row is a sample and each column is a feature.
+   * @throws domain_error exception when size of the two vectors is not equal
+   * @returns minkowski distance between the two vectors
+   */
+  double minkowski(std::vector<T> &, std::vector<T> &, int);
+
+  /**
+   * @brief to find the magnitude of the vector
+   * @param x a vector
+   * @returns magnitude of x
+   */
+  double magnitude(std::vector<T> &);
+
+  /**
+   * @param x An array where each row is a sample and each column is a feature.
+   * @param y An array where each row is a sample and each column is a feature.
+   * @throws domain_error exception when size of the two vectors is not equal
+   * @returns cosine similarity between the two vectors
+   */
+  double cosineSimilarity(std::vector<T> &, std::vector<T> &);
+};
+
+#endif // SLOWMOKIT_DISTANCE_METRIC_HPP