distance

/*
* Copyright 2016 E-Tool, Inc.
*/

#ifndef distance_h
#define distance_h
#include <math.h>
#include <vector>
using std::vector;

#define max(a,b) (a>b?a:b)
#define min(a,b) (a<b?a:b)

class Distance {
public:
    static double euclidean_distance(double x1,double y1,double x2,double y2) {
        return sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
    }
    static double euclidean_distance(double x1, double y1, double z1, double x2, double y2,  double z2) {
        return sqrt((x1 - x2)*(x1 - x2) + (y1 - y2)*(y1 - y2)+(z1-z2)*(z1-z2));
    }
    static double euclidean_distance(vector<double> x, vector<double> y) {
        double result = 0;
        for (int i = 0;i < x.size();i++) {
            result += (x[i]-y[i])*(x[i]-y[i]);
        }
        return sqrt(result);
    }
    static double manhattan_distance(double x1, double y1, double x2, double y2) {
        return abs(x1 - x2) + abs(y1 - y2);
    }
    static double manhattan_distance(vector<double> x, vector<double> y) {
        double result = 0;
        for (int i = 0;i < x.size();i++) {
            result += abs(x[i] - y[i]);
        }
        return result;
    }
    static double chebyshev_distance(double x1, double y1, double x2, double y2) {
        return max(abs(x1 - x2) ,abs(y1 - y2));
    }
    static double chebyshev_distance(vector<double> x, vector<double> y) {
        double result=-1;
        for (int i = 0;i < x.size();i++) {
            result = max(result, abs(x[i] - y[i]));
        }
        return result;
    }
    static double minkowski_distance(vector<double> x, vector<double> y,int p) {
        double result = 0;
        for (int i = 0;i < x.size();i++) {
            result += pow(abs(x[i]-y[i]),p);
        }
        return pow(result,1/p);
    }
    /*
    *  Standardized Euclidean distance
    */
    static double standardized_euclidean_distance(vector<double> x, vector<double> y) {
        double result = 0;
        for (int i = 0;i < x.size();i++) {
            double r=(x[i]+y[i])/2;
            double s = (x[i]-r)*(x[i]-r)+(y[i]-r)*(y[i]-r);
            result += (x[i]-y[i])*(x[i]-y[i]) / s;
        }
        return sqrt(result);
    }
    static double information_entropy(vector<double> p) {
        double result=0;
        for (int i = 0;i < p.size();i++) {
            result -= p[i] * (log(p[i])/log(2));
        }
        return result;
    }
};

#endif