nation.h

Go to the documentation of this file.

#ifndef NATION_H
#define NATION_H

#include "MyTools.h"
#include "compare.h"

#include <boost/bimap.hpp>

typedef boost::bimap <string, string> idmap;
typedef idmap::value_type ID;

class Nation{
public:
  
  Nation():threshold(-1){
    comp = NULL;
  }
  
  Nation(double v):threshold(v){
    comp = NULL;
  }
  
  Nation(double thresh, string c, int s, string d):threshold(thresh){
    Compare* God = new Compare();
    comp = God->Produce(c);
    comp->graphSize = s;
    comp->setDist(d);
    delete God;
  };
  
  bool CalculateBinary(vector < set < string > > Allies){
    if (threshold == -1)
      return false;
    
    if (memberships.size() == 0)
      memberships = CalculateMemberships(&communities);
    
    map < string, vector <int> > others = CalculateMemberships(&Allies, "other_memberships.dat");
    map < string, vector <int> >::iterator it_A, it_B;
    
    set < pair <int, int > > potentials;
    set < pair <int, int> >::iterator it_pot;
    for (it_A = memberships.begin();it_A != memberships.end(); it_A++){
      if ((it_B = others.find(it_A->first)) != others.end()){
        for (sui i = 0; i < it_A->second.size(); i++){
          for (sui j = 0; j < it_B->second.size(); j++){
            int a = it_A->second[i], b = it_B->second[j];
            pair <int, int> n = make_pair<int, int>(a, b);
            
            if (potentials.find(n) == potentials.end()){
              potentials.insert(n);
            }
          }
        }
      } 
    }
    
    set <int> MatchThis, MatchOther;
    
    for (it_pot = potentials.begin(); it_pot != potentials.end(); it_pot++){
      if (Match(&(communities[it_pot->first]), &(Allies[it_pot->second]))){
        MatchThis.insert(it_pot->first);
        MatchOther.insert(it_pot->second);
      }
    }
    
    double tPositives = MatchThis.size();
    double fNegatives = Allies.size() - MatchOther.size();
    double fPositives = communities.size() - tPositives;
            
    prec = tPositives / (tPositives + fPositives);
    rec = tPositives / (tPositives + fNegatives);
    fscore = (2 * prec * rec) / (prec + rec); 
    
    return true;
  };
   
  void PrintStats(){
    cout << "Precision: " << prec << endl;
    cout << "Recall: " << rec << endl;
    cout << "FScore: " << fscore << endl;
  };
  
  void PrintStats(ofstream * rout){
    *rout << "Precision: " << prec << endl;
    *rout << "Recall: " << rec << endl;
    *rout << "FScore: " << fscore << endl;
  };
  
  void load(string filename){
    ifstream fin;
    openFile(&fin, filename.c_str());
    vector <string> fields;
    
    while (fline_tr(&fin, &fields, " \t")){
      if (fields.size() < 3)
        continue;
      
      set < string > current;
      for (sui i = 2; i < fields.size(); i++){
        current.insert(fields[i]);
      }
      
      communities.push_back(current);
    }
  };
  
  void loadLFR(string filename){
    ifstream fin;
    openFile(&fin, filename.c_str());
    vector <string> fields;
    
    while (fline_tr(&fin, &fields, " \t")){
      if (fields.size() == 0)
        continue;
      
      string node = fields[0];
      
      for (sui i = 1; i < fields.size(); i++){
        int comm = boost::lexical_cast<int>(fields[i]);
        for (sui t = communities.size(); t <= comm - 1; t++){
          set <string> temp;
          communities.push_back(temp);
        }
        
        communities[comm-1].insert(node);
      }
    }
  };
  
  void loadID(string filename, string delimiters){
    ifstream fin;
    vector <string> fields;
    openFile(&fin, filename.c_str());
    
    while(fline_tr(&fin, &fields, delimiters)){
      if (fields.size() != 2){
        cerr << "Invalid ID entry: ";
        for (sui i = 0; i < fields.size(); i++){
          cerr << fields[i] << " ";
        }
        cerr << endl;
        
        exit(3);
      }
      
      directory.insert(make_pair<string, string>(fields[0], fields[1]));
      reverse_yellow.insert(make_pair<string, string>(fields[1], fields[0]));
    }
  }
  
  double getPrecision(){
    return prec;
  }
  
  double getFScore(){
    return fscore;
  }
  
  double getRecall(){
    return rec;
  }
  
  double CalculateCompare(vector < set < string > > Allies){
    
    if (comp == NULL || comp->graphSize == 0)
      return -1;
    
    return (*comp)(&Allies, &communities);
  }
  
  void setCompare(string c, string d){
    Compare* God = new Compare();
    comp = God->Produce(c);
    comp->graphSize = network.size();
    comp->setDist(d);
    delete God;
  }
  
  vector < set < string > > getCommunities(){return communities;};
  
  void LoadGraph(string filename, string delim, bool translate){
    ifstream fin;
    openFile(&fin, filename);
    vector <string> fields;
    
    while (fline_tr(&fin, &fields, delim)){
      if (fields.size() != 3)
        continue;
      
      string to, from;
      
      if (translate){
        map <string, string>::iterator it_id;
        if ((it_id = directory.find(fields[0])) != directory.end())
          from = directory.find(fields[0])->second;
        else {
          cerr << "Vertex not in ID file : " << fields[0] << endl;
          exit(5);
        }
        
        if ((it_id = directory.find(fields[1])) != directory.end())
          from = directory.find(fields[1])->second;
        else {
          cerr << "Vertex not in ID file : " << fields[1] << endl;
          exit(5);
        }
      } else {
        from = fields[0];
        to = fields[1];
      } 
      
      if ((it_net = network.find(from)) != network.end()){
        it_net->second.insert(make_pair<string, double>(to, boost::lexical_cast<double>(fields[2])));   
      } else {
        map <string, double> temp;
        temp.insert(make_pair<string, double>(to, boost::lexical_cast<double>(fields[2])));
        network.insert(make_pair<string, map <string, double> >(from, temp));
      }
      
      if ((it_net = network.find(to)) != network.end()){
        it_net->second.insert(make_pair<string, double>(from, boost::lexical_cast<double>(fields[2]))); 
      } else {
        map <string, double> temp;
        temp.insert(make_pair<string, double>(from, boost::lexical_cast<double>(fields[2])));
        network.insert(make_pair<string, map <string, double> >(to, temp));
      }
    }
    
    if (comp != NULL)
      comp->graphSize = network.size();
  };
  
  map < string, vector <int> > CalculateMemberships(vector < set < string > >* comms, string fileout = "memberships.dat"){
    
    map <string, vector <int> > members;
    map <string, vector < int > >::iterator it_m;
    set <string>::iterator it_s;
    
    map <int, int> reverse_members;
    map <int, int>::iterator it_rm;
    
    for (sui i = 0; i < comms->size(); i++){
      for (it_s = (*comms)[i].begin(); it_s != (*comms)[i].end(); it_s++){
        if ((it_m = members.find(*it_s)) == members.end()){
          vector <int> temp;
          temp.push_back(i);
          members.insert(make_pair<string, vector < int > >(*it_s, temp));
        } else {
          it_m->second.push_back(i);
        }
      }
    }
    
    for (it_m = members.begin(); it_m != members.end(); it_m++){
      if ((it_rm = reverse_members.find(it_m->second.size())) == reverse_members.end()){
          reverse_members.insert(make_pair<int, int>(it_m->second.size(), 1));
        } else {
          it_rm->second++;
        }
    }
    
    ofstream fout(fileout.c_str());
    for (it_rm = reverse_members.begin(); it_rm != reverse_members.end(); it_rm++){
     fout << it_rm->first << " : " << it_rm->second << endl;
    }
    
    return members;
  };
  
  
private:
  double threshold, prec,  fscore,  rec;
  vector < set < string > > communities;
  map < string, map <string, double > > network; 
  map < string, map <string, double > >::iterator it_net;
  Compare* comp; 
  map < string, string> directory; 
  map < string, string > reverse_yellow; 
  map < string, vector < int > > memberships; 
  bool Match(set <string>* A, set <string>* B){
    double truePositive = 0, falsePositive = 0, falseNegative = 0;
  
    set <string>::iterator it_slA, it_slB;
    for (it_slA = A->begin(); it_slA != A->end(); it_slA++){
      if (B->find(*it_slA) != B->end())
        truePositive++;
      else
        falsePositive++;
    }
    
    for (it_slB = B->begin(); it_slB != B->end(); it_slB++){
      if (A->find(*it_slB) == A->end())
        falseNegative++;
    }
    
    double precision = truePositive / (truePositive + falsePositive);
    double recall = truePositive / (truePositive + falseNegative);
    return ((2 * precision * recall) / (precision + recall) >= threshold);
  }
};

#endif