CIS.h

#ifndef CIS_H
#define CIS_H

#include "MyTools.h"

#include "seed.h"
#include "iterativescan.h"
#include "cluster.h"

#include <queue>

template <typename R>
class IterativeDensity:public ClusterAlg<R>
{
  public:
  IterativeDensity(string ar, double a, double b, double weightThreshold, bool t):alpha(a), beta(b), wt(weightThreshold){
      this->args = "CISParams " + ar;
        /*Get the clique size to percolate */
        vector <string> aa;
        boost::split(aa, this->args, boost::is_any_of(" "));
        
        char** av = new char*[aa.size()];
        for (sui r = 0; r < aa.size();r++){
          av[r] = (char*)(malloc((aa[r].size() + 1) * sizeof(char)));
          strcpy(av[r], aa[r].c_str());
        }
        std::map <string, vector < string > > subParam = getParameters(aa.size(), av);
        std::map <string, vector < string > >::iterator it_sub;
        
        if ((it_sub = subParam.find("l")) != subParam.end()){
          lambda = boost::lexical_cast<double>(it_sub->second[0]);
        } else {
          cerr << "Invalid Clique Percolation Params (need size (-k))" << endl;
          exit(2);
        }
        
        if ((it_sub = subParam.find("d")) != subParam.end()){
          if ((it_sub->second[0])[0] == 'n')
            this->dens = new negative_density<bidirected_t>(lambda);
          else
            this->dens = new complex_density<bidirected_t>(lambda);
        } else {
          cerr << "Using complex density" << endl;
          this->dens = new complex_density<bidirected_t>(lambda);
          exit(3);
        }
                  
      this->translate = t;
      this->fileout = &cout;
    };
    
    
    ~IterativeDensity(){};
    
    void calculate();
    
    bool ReadGraph(ifstream* fin, string delim){
      delimiters = delim;      
      read_from_stream<bidirected_t>(graph, map, (this->idmap), *fin, alpha, beta, wt, delimiters);
      return true;
    };
    
    bool PrintCommunities(string filename){
      ofstream fout(filename.c_str());
      for (int i = 0; i < comms.size(); i++){
        print_set<bidirected_t>(graph, comms[i].vertices(), fout, comms[i].dens());
      }
      return true;
    };
    
    bool PrintTranslatedCommunities(string filename){
      ofstream fout(filename.c_str());
      for (int i = 0; i < comms.size(); i++){
        print_set_trans<bidirected_t>(graph, comms[i].vertices(), fout, comms[i].dens(), this->idmap, delimiters[0]);
      }
      return true;
    };
    
    template <typename graph_t>
    bool TranslateCommunities(){
      std::map <long unsigned int, string> rID;
      std::map <long unsigned int, string>::iterator it_r;
      std::map <string, long unsigned int>::iterator it_id;
      set <lui>::iterator it_sl; 
      
      for (it_id = (this->idmap).begin(); it_id != (this->idmap).end(); it_id++){
        rID.insert(make_pair<lui, string>(it_id->second, it_id->first));
      }
      
      for (int i = 0; i < comms.size(); i++){
        set<typename graph_t::vertex> v = comms[i].vertices();
        if (v.size() > 2)
        {
          set <lui> clust;
          typename std::set<typename graph_t::vertex>::const_iterator i;
          for (i = v.begin(); i != v.end(); ++i)
          {
              typename graph_t::vertex_name_t u;
              u = boost::get(boost::vertex_name, graph, *i);
              clust.insert(boost::lexical_cast<lui>((rID.find(boost::lexical_cast<lui>(u)))->second));
          }
          
          (this->communities).push_back(clust);
        }
      }
      return true;
    };

    void setOutput(string filename){
      this->fileout = new ofstream(filename.c_str());
    };

  private:
    double lambda, alpha, beta, wt; 
    vector <seed> comms; 
    bidirected_t::graph graph; 
    bidirected_t::map map; 
    string delimiters;

    class future_actions
    {
        public:
            typedef std::pair<const std::vector<seed>*, double> results;

            virtual ~future_actions(){};
            
            virtual void operator ()(const results, std::queue<seed>* q,
                    std::vector<seed>* ret) =0;
    };

    class take_best: public IterativeDensity<R>::future_actions
    {
        public:
            take_best(double threshold=0):thresh_(threshold){};
            
            void operator ()(const typename IterativeDensity<R>::future_actions::results r, std::queue<seed>* q,
                    std::vector<seed>* ret){
            /*Makes sure there is a graph to work with*/
                if ((*r.first).size() < 1)
                {
                    throw "ret too short";
                }
            /*Initialize*/
                seed best = (*r.first)[0];

            /*Find the disjoint subgraph from results.first with the highest connectivity.*/
                for (unsigned int i = 0; i < r.first->size(); ++i)
                {
                    if (best.dens() < (*r.first)[i].dens())
                    {
                        best = (*r.first)[i];
                    }else if (best.dens() == (*r.first)[i].dens() && best.vertices().size() < (*r.first)[i].vertices().size())
                    {
                      
                    }
                }

            /*Depending on whether or not the set's connectiveness is good enough, sort it*/
            /*NOTE: should be best.dens() ?*/
                if (r.second <= thresh_)
                {
                    ret->push_back(best);
                }
                else
                {
                    q->push(best);
                }
            };

                private:
                    double thresh_; 
            };
  
    std::vector<seed>* cluster(const seed& S, future_actions* act, bidirected_t::graph* graph)
    {
      //Start with seed
      std::vector<seed>* ret = new std::vector<seed>();
      std::queue<seed> to_consider;
      to_consider.push(S);

      //Keep expanding seed until convergence
      while (!to_consider.empty())
      {
          seed s = to_consider.front();
          to_consider.pop();
          
          std::pair<std::vector<seed>*, double> results;
          results = expand_seed(s);

          (*act)(results, &to_consider, ret);
          
          delete results.first;
      }

      return ret;
    }

};

#endif