distance.h

#ifndef DIST_H
#define DIST_H

#include "MyTools.h"
#include "MySets.h"

class dist{
public:
  dist(){type = 0;};
  
  ~dist(){};
  
  template <typename T> 
  double operator() (T C1, T C2, int N);
  
  dist* Produce(string s);
  
  int type; 
};

class moves:public dist{ 
public:
  moves(){type = 1;};
  
  template <typename T>
  double operator() (T C1, T C2) {
    return C1.size() + C2.size() - (2 * (Intersection<T>(C1, C2)).size());
  };
};

class normalized:public dist{
public:
  normalized(){type = 2;};
  
  template <typename T>
  double operator() (T C1, T C2){
   return (1 - ((double)(Intersection<T>(C1, C2).size()) / (double)(Union<T>(C1, C2).size()))); 
  }
};

class entropy:public dist{
public:
  entropy(){type = 3;};
  
  template <typename T>
  double operator() (T C1, T C2, int N){
    //double Px = (double)(C1.size()) / (double)N;
    //double Py = (double)(C2.size()) / (double)N;
    
    T Int = Intersection(C1, C2);
    double a = N - (C1.size() + C2.size() - Int.size());
    double b = C2.size() - Int.size();
    double c = C1.size() - Int.size();
    double d = Int.size();
    
    double H1 = h(a, N) + h(d, N);
    double H2 = h(b, N) + h(c, N);
    if (H1 >= H2)
      return (H1 + H2 - h(b+d, N) - h(a+c, N));
    else
      return (h(c+d, N) + h(a+b, N));
  }
  
  double h(double a, double n){
    if (a == 0) 
      return 0; 
    return -a*log2(a/n);
  };
  int N;
};

/*class L2:public dist{
public:
  
  **Constructor
  L2(){type = 4;};
  **
   * Compute the similarity
   * 
   * @param C1 First cluster to compare
   * @param C2 Second cluster to compare
   * 
   * @return L2 distance
   
  template <typename T>
  double operator() (T C1, T C2){
    typename T::iterator it_t, it_t2;
    
    double sum = 0;
    
    for (it_t = C1.begin(), it_t2 = C2.begin(); it_t != C1.end() && it_t2 != C2.end(); it_t++, it_t2++){
      sum += (*it_t2 - *it_t) * (*it_t2 - *it_t);
    }
    
    return sqrt(sum);
  }
};*/

dist* dist::Produce(string s){
  if ((strcmp(s.c_str(), "moves")) == 0){
    return new moves();
  } else if ((strcmp(s.c_str(), "norm")) == 0) {
    return new normalized();
  } else if ((strcmp(s.c_str(), "entropy")) == 0) {
    return new entropy();
  } /*else if ((strcmp(s.c_str(), "kl")) == 0) {
    return new KL();
  } */else {    
    cerr << "Invalid distance measure chosen" << endl;
    exit(4);
  }
};


template <typename T>
double dist::operator() (T C1, T C2, int N){
    switch (this->type){
      case 1: 
        return (*((moves*)(this)))(C1, C2);
        break;
      case 2:
        return (*((normalized*)(this)))(C1, C2);
        break;
      case 3:
        return (*((entropy*)(this)))(C1, C2, N);
        break; 
      /*case 5:
        return (*((KL*)(this)))(C1, C2);
        break;*/
      default:
        cerr << "Invalid Distance Specified" << endl;
        exit(5);
      
    }
  }
  

#endif