MC_int_vector.cpp

Go to the documentation of this file.

#include <MC_int_vector.hpp>
#include <MC_string_helper.hpp>
#include <MC_int_pair.hpp>

//using namespace mc;
namespace mesh_conv
{


  MC_int_vector::MC_int_vector(){}

  MC_int_vector::MC_int_vector(const int& u0)
  {int_list.push_back(u0);}
  MC_int_vector::MC_int_vector(const int& u0,const int& u1){int_list.push_back(u0);int_list.push_back(u1);}
  MC_int_vector::MC_int_vector(const int& u0,const int& u1,const int& u2){int_list.push_back(u0);int_list.push_back(u1);int_list.push_back(u2);}
  MC_int_vector::MC_int_vector(const int& u0,const int& u1,const int& u2,const int& u3){int_list.push_back(u0);int_list.push_back(u1);int_list.push_back(u2);int_list.push_back(u3);}
  MC_int_vector::MC_int_vector(const int& u0,const int& u1,const int& u2,const int& u3,const int& u4){int_list.push_back(u0);int_list.push_back(u1);int_list.push_back(u2);int_list.push_back(u3);int_list.push_back(u4);}
  MC_int_vector::MC_int_vector(const int& u0,const int& u1,const int& u2,const int& u3,const int& u4,const int& u5){int_list.push_back(u0);int_list.push_back(u1);int_list.push_back(u2);int_list.push_back(u3);int_list.push_back(u4);int_list.push_back(u5);}

  void MC_int_vector::assert_bounds(const int& u) const
  {
    if(u<0 || u>=int(int_list.size()))
      {std::cout<<"Assert mesh_conv::MC_int_vector::assert_bounds("<<u<<") failed, because size="<<int_list.size()<<std::endl;exit(-1);}
  }  

  int MC_int_vector::size() const
  {return int_list.size();}

  const int& MC_int_vector::operator()(const int& index) const
  {assert_bounds(index); return int_list[index];}
  int& MC_int_vector::operator()(const int& index)
  {assert_bounds(index); return int_list[index];}
  const int& MC_int_vector::operator[](const int& index) const
  {assert_bounds(index); return int_list[index];}
  int& MC_int_vector::operator[](const int& index)
  {assert_bounds(index); return int_list[index];}

  void MC_int_vector::clear()
  {int_list.clear();}



  std::ostream& operator<<(std::ostream& output,const MC_int_vector& in)
  {
    int N=in.size();
    for(int k=0;k<N;k++)
      output<<in[k]<<" ";
    return output;
  }

  MC_int_vector::MC_int_vector(const std::string& in,const std::string& delimiter)
  {
    std::vector <std::string> v_string=MC_string_tokenizer::tokenize(in,delimiter);
    bool is_converted=false;
    for(unsigned int k=0;k<v_string.size();k++)
      {
        int value=MC_string_converter::value_of<int>(v_string[k],&is_converted);
        if(is_converted==true)
          add(value);
      }
  }  
  

  MC_int_vector& MC_int_vector::add(const int& val)
  {int_list.push_back(val);return *this;}

  MC_int_vector operator<<(const MC_int_vector& vec,const int& value)
  {return MC_int_vector(vec).add(value);}


  MC_int_vector& MC_int_vector::add(const MC_int_vector& val)
  {
      int N=val.size();
      int end=int_list.size();
      int_list.resize(int_list.size()+N);
      for(int k=0;k<N;++k)
          int_list[end+k]=val[k];
    return *this;
  }
  
  std::vector <int>& MC_int_vector::get_vector() {return int_list;}
  const std::vector <int>& MC_int_vector::to_vector() const {return int_list;}

  
  std::set <int> MC_int_vector::to_set() const
  {
    std::set <int> set_int;
    set_int.insert(int_list.begin(),int_list.end());
    return set_int;
  }
  std::map <int,int> MC_int_vector::to_map() const
  {
    std::map <int,int> map_int;
    int N=size();
    for(int k=0;k<N;k++)
      map_int.insert(std::pair<int,int>(this->operator()(k),k));
    return map_int;
  }

  mesh_conv::MC_int_vector operator<<(const mesh_conv::MC_int_vector& vec,const mesh_conv::MC_int_vector& to_add)
  {return MC_int_vector(vec).add(to_add);}

  MC_int_vector& MC_int_vector::set(const int& k_index,const int& new_value)
  {
    if(k_index<0)
      {std::cout<<"Error in MC_int_vector::set("<<k_index<<","<<new_value<<"), index must be >0"<<std::endl;exit(-1);}
    if(k_index>=size())
      int_list.resize(k_index+1);
    int_list[k_index]=new_value;
    return *this;
  }
  
  MC_int_vector& MC_int_vector::set(const MC_int_vector& k_index,const MC_int_vector& new_value)
  {
    MC_int_vector v_new_value=new_value;
    if(new_value.size()!=1 && new_value.size()!=k_index.size())
      {std::cout<<"Error in MC_int_vector::set(MC_int_vector,MC_int_vector), size are not correct: "<<k_index.size()<<","<<new_value.size()<<std::endl;exit(-1);}
    if(new_value.size()==1)
      v_new_value=MC_int_vector::zeros(k_index.size())+new_value;
    
    
    int N=v_new_value.size();
    for(int k=0;k<N;k++)
      set(k_index[k],v_new_value[k]);
    return *this;
  }
    

  MC_int_vector::MC_int_vector(const std::set <int>& vec)
  {
    for(std::set <int> :: const_iterator it=vec.begin();it!=vec.end();++it)
      int_list.push_back(*it);
  }
  MC_int_vector::MC_int_vector(const std::map <int,int> &vec)
  {
    for(std::map <int,int> :: const_iterator it=vec.begin();it!=vec.end();++it)
      set(it->second,it->first);
  }
  MC_int_vector::MC_int_vector(const std::vector <int> &vec)
  {
    int_list=vec;
  }
  MC_int_vector::MC_int_vector(const MC_int_vector& vec)
  {
    int_list=vec.to_vector();
  }

  MC_int_vector MC_int_vector::zeros(const int& new_size)
  {
    MC_int_vector vec;vec.resize(new_size);
    return vec;
  }

  MC_int_vector MC_int_vector::linspace(const int& begin,const int& end,const double& iteration)
  {
      MC_int_vector temp;
      double d_begin=static_cast<double>(begin);
      double d_end=static_cast<double>(end);

      if(d_end>=d_begin && iteration>0)
      {
          for(double u=d_begin;u<=d_end;u+=iteration)
              temp.add(static_cast<int>(u));
      }
      else if(iteration<0)
      {
          for(double u=d_begin;u>=d_end;u+=iteration)
              temp.add(static_cast<int>(u));
      }
      else
      {std::cout<<"Error in MC_int_vector::linspace("<<begin<<","<<end<<","<<iteration<<"), parameters will infinitely loop"<<std::endl;exit(-1);}

      return temp;
  }


  MC_int_vector& MC_int_vector::resize(const int& new_size)
  {
    int N=int_list.size();
    if(N==new_size) //same size
      return *this;
    
    if(new_size<0)
      {std::cout<<"Error in MC_int_vector::resize("<<new_size<<") new size must be >0"<<std::endl;exit(-1);}
    
    int_list.resize(new_size);
    return *this;
    
  }
  MC_int_vector MC_int_vector::operator-() const
  {
    MC_int_vector opposite;
    int N=size();
    opposite.resize(N);
    for(int k=0;k<N;++k)
      opposite[k]=-int_list[k];
    return opposite;
  }

  MC_int_vector operator+(const MC_int_vector& vec,const int& to_add)
  {
    int N=vec.size();
    MC_int_vector new_vec=MC_int_vector::zeros(N);
    for(int k=0;k<N;k++)
      new_vec[k]=vec[k]+to_add;
    return new_vec;
  }
  MC_int_vector operator-(const MC_int_vector& vec,const int& to_sub)
  {
    int N=vec.size();
    MC_int_vector new_vec=MC_int_vector::zeros(N);
    for(int k=0;k<N;k++)
      new_vec[k]=vec[k]-to_sub;
    return new_vec;
  }
  MC_int_vector operator*(const MC_int_vector& vec,const int& to_mult)
  {
   int N=vec.size();
    MC_int_vector new_vec=MC_int_vector::zeros(N);
    for(int k=0;k<N;k++)
      new_vec[k]=vec[k]*to_mult;
    return new_vec;
  }
  MC_int_vector operator/(const MC_int_vector& vec,const int& to_subdiv)
  {
    if(to_subdiv==0)
      {std::cout<<"Error in MC_int_vector::operator/(MC_int_vector,int), int value is 0"<<std::endl;exit(-1);}
    int N=vec.size();
    MC_int_vector new_vec=MC_int_vector::zeros(N);
    for(int k=0;k<N;k++)
      new_vec[k]=vec[k]/to_subdiv;
    return new_vec;
  }

  MC_int_vector& MC_int_vector::operator+=(const int& to_add)
  {
    int N=size();
    for(int k=0;k<N;++k)
      int_list[k]+=to_add;
    return *this;
  }
  MC_int_vector& MC_int_vector::operator-=(const int& to_sub)
  {
    int N=size();
    for(int k=0;k<N;++k)
      int_list[k]-=to_sub;
    return *this;
  }
  MC_int_vector& MC_int_vector::operator*=(const int& to_mult)
  {
    int N=size();
    for(int k=0;k<N;++k)
      int_list[k]*=to_mult;
    return *this;
  }
  MC_int_vector& MC_int_vector::operator/=(const int& to_subdiv)
  {
   if(to_subdiv==0)
      {std::cout<<"Error in MC_int_vector::operator/=(int), int value is 0"<<std::endl;exit(-1);}
    int N=size();
    for(int k=0;k<N;++k)
      int_list[k]/=to_subdiv;
    return *this;
  }


  MC_int_vector operator+(const MC_int_vector& vec,const MC_int_vector& to_add)
  {
    if(to_add.size()==1)
      return vec+to_add.first();
    else if(vec.size()==1)
        return to_add+static_cast<int>(vec.first());
    else
      {
        if(vec.size()!=to_add.size())
          {std::cout<<"Error in MC_int_vector::operator+(MC_int_vector,MC_int_vector), size are not compatible "<<vec.size()<<";"<<to_add.size()<<std::endl;exit(-1);}
        

        int N=vec.size();
        MC_int_vector new_vec=MC_int_vector::zeros(N);
        for(int k=0;k<N;++k)
          new_vec[k]=vec[k]+to_add[k];
        return new_vec;
      }
  }
  MC_int_vector operator-(const MC_int_vector& vec,const MC_int_vector& to_sub)
  {
    if(to_sub.size()==1)
      return vec-to_sub.first();
    else
      {
        if(vec.size()!=to_sub.size())
          {std::cout<<"Error in MC_int_vector::operator-(MC_int_vector,MC_int_vector), size are not compatible "<<vec.size()<<";"<<to_sub.size()<<std::endl;exit(-1);}
        

        int N=vec.size();
        MC_int_vector new_vec=MC_int_vector::zeros(N);
        for(int k=0;k<N;++k)
          new_vec[k]=vec[k]-to_sub[k];
        return new_vec;
      }
  }
  MC_int_vector operator*(const MC_int_vector& vec,const MC_int_vector& to_mult)
  {
    if(to_mult.size()==1)
      return vec*to_mult.first();
    else
      {
        if(vec.size()!=to_mult.size())
          {std::cout<<"Error in MC_int_vector::operator*(MC_int_vector,MC_int_vector), size are not compatible "<<vec.size()<<";"<<to_mult.size()<<std::endl;exit(-1);}
        

        int N=vec.size();
        MC_int_vector new_vec=MC_int_vector::zeros(N);
        for(int k=0;k<N;++k)
          new_vec[k]=vec[k]*to_mult[k];
        return new_vec;
      }
  }
  MC_int_vector operator/(const MC_int_vector& vec,const MC_int_vector& to_subdiv)
  {
    if(to_subdiv.size()==1)
      return vec/to_subdiv.first();
    else
      {
        if(vec.size()!=to_subdiv.size())
          {std::cout<<"Error in MC_int_vector::operator/(MC_int_vector,MC_int_vector), size are not compatible "<<vec.size()<<";"<<to_subdiv.size()<<std::endl;exit(-1);}
        

        int N=vec.size();
        MC_int_vector new_vec=MC_int_vector::zeros(N);
        for(int k=0;k<N;++k)
          {
            int current=to_subdiv[k];
            if(current==0)
              {std::cout<<"Error in MC_int_vector::operator/(MC_int_vector,MC_int_vector), int value at index"<<k<<" is 0"<<std::endl;exit(-1);}
            new_vec[k]=vec[k]/current;
          }
        return new_vec;
      }

  }


  MC_int_vector& MC_int_vector::operator+=(const MC_int_vector& to_add)
  {
    if(to_add.size()==1)
      return *this+=to_add.first();
    else
      {
        if(size()!=to_add.size())
          {std::cout<<"Error in MC_int_vector::operator+=(MC_int_vector), size are not compatible "<<size()<<";"<<to_add.size()<<std::endl;exit(-1);}
        
        int N=size();
        for(int k=0;k<N;++k)
          int_list[k]+=to_add[k];
        return *this;
      }
  }
  MC_int_vector& MC_int_vector::operator-=(const MC_int_vector& to_sub)
  {
    if(to_sub.size()==1)
      return *this-=to_sub.first();
    else
      {
        if(size()!=to_sub.size())
          {std::cout<<"Error in MC_int_vector::operator-=(MC_int_vector), size are not compatible "<<size()<<";"<<to_sub.size()<<std::endl;exit(-1);}
        
        int N=size();
        for(int k=0;k<N;++k)
          int_list[k]-=to_sub[k];
        return *this;
      }

  }
  MC_int_vector& MC_int_vector::operator*=(const MC_int_vector& to_mult)
  {
    if(to_mult.size()==1)
      return *this*=to_mult.first();
    else
      {
        if(size()!=to_mult.size())
          {std::cout<<"Error in MC_int_vector::operator*=(MC_int_vector), size are not compatible "<<size()<<";"<<to_mult.size()<<std::endl;exit(-1);}
        
        int N=size();
        for(int k=0;k<N;++k)
          int_list[k]*=to_mult[k];
        return *this;
      }
  }
  MC_int_vector& MC_int_vector::operator/=(const MC_int_vector& to_subdiv)
  {
    if(to_subdiv.size()==1)
      return *this/=to_subdiv.first();
    else
      {
        if(size()!=to_subdiv.size())
          {std::cout<<"Error in MC_int_vector::operator/=(MC_int_vector), size are not compatible "<<size()<<";"<<to_subdiv.size()<<std::endl;exit(-1);}
        
        int N=size();
        for(int k=0;k<N;++k)
          {
            int current=to_subdiv[k];
            if(current==0)
              {std::cout<<"Error in MC_int_vector::operator/=(MC_int_vector), try do divide by u["<<k<<"]=0"<<std::endl;exit(-1);}
            int_list[k]*=current;
          }
        return *this;
      }
  }

  const int& MC_int_vector::first() const
  {
    if(size()>0)
      return int_list[0];
    else
      {
        std::cout<<"Error, call MC_int_vector::first() with size=0"<<std::endl;exit(-1);
        exit(-1);
      }
  }
  int& MC_int_vector::first()
  {
    if(size()>0)
      return int_list[0];
    else
      {
        std::cout<<"Error, call MC_int_vector::first() with size=0"<<std::endl;exit(-1);
        exit(-1);
      }
  }
  const int& MC_int_vector::last() const
  {
    if(size()>0)
      return int_list[size()-1];
    else
      {
        std::cout<<"Error, call MC_int_vector::last() with size=0"<<std::endl;exit(-1);
      }
  }
  int& MC_int_vector::last()
  {
    if(size()>0)
      return int_list[size()-1];
    else
      {
        std::cout<<"Error, call MC_int_vector::last() with size=0"<<std::endl;exit(-1);
      }
  }
  
  std::pair <MC_int_vector,int> MC_int_vector::delete_index(const int& index_to_delete) const
  {
    if(index_to_delete<0 || index_to_delete>=size())
      {std::cout<<"Error in MC_int_vector::delete("<<index_to_delete<<", when size="<<size()<<std::endl;exit(-1);}
    MC_int_vector new_vec;
    int N=size();
    for(int k=0;k<N;++k)
      if(k!=index_to_delete)
        new_vec.add(int_list[k]);
    return std::pair <MC_int_vector,int>(new_vec,int_list[index_to_delete]);
  }
  std::pair <MC_int_vector,MC_int_vector> MC_int_vector::delete_index(const MC_int_vector& index_to_delete) const
  {
    std::set <int> set_index=index_to_delete.to_set();
    MC_int_vector new_vec;
    MC_int_vector deleted_vec;
    int N=size();
    for(int k=0;k<N;k++)
      {
        if(set_index.find(k)!=set_index.end())
          new_vec.add(int_list[k]);
        else
          deleted_vec.add(int_list[k]);
      }
    return std::pair <MC_int_vector,MC_int_vector> (new_vec,deleted_vec);
  }
    
  MC_int_vector MC_int_vector::operator()(const MC_int_vector& index) const
  {
    int N=size();
    int N2=index.size();
    MC_int_vector new_vec=zeros(N2);
    for(int k=0;k<N2;++k)
      {
        if(index[k]<0 || index[k]>N)
          {std::cout<<"Error in MC_int_vector::operator()(MC_int_vector), value index["<<k<<"]="<<index[k]<<" not correct for size="<<N<<std::endl;exit(-1);}
        new_vec[k]=int_list[index[k]];
      }
    return new_vec;
  }
  MC_int_vector MC_int_vector::operator[](const MC_int_vector& index) const
  {return (*this)(index);}


  mesh_conv::MC_int_vector& operator>>(std::istream& input,mesh_conv::MC_int_vector& vec)
  {
      while(input.good())
      {
          int temp=0;
          input>>temp;
          if(input.good())
              vec.add(temp);
      }
      return vec;
  }


  MC_int_vector operator<(const MC_int_vector& vec,const int& val)
  {
      int N=vec.size();
      MC_int_vector res=MC_int_vector::zeros(N);
      for(int k=0;k<N;k++)
          if(vec[k]<val)
              res[k]=1;
      return res;
  }
  MC_int_vector operator<=(const MC_int_vector& vec,const int& val)
  {
      int N=vec.size();
      MC_int_vector res=MC_int_vector::zeros(N);
      for(int k=0;k<N;k++)
          if(vec[k]<=val)
              res[k]=1;
      return res;
  }
  MC_int_vector operator>(const MC_int_vector& vec,const int& val)
  {
      int N=vec.size();
      MC_int_vector res=MC_int_vector::zeros(N);
      for(int k=0;k<N;k++)
          if(vec[k]>val)
              res[k]=1;
      return res;
  }
  MC_int_vector operator>=(const MC_int_vector& vec,const int& val)
  {
      int N=vec.size();
      MC_int_vector res=MC_int_vector::zeros(N);
      for(int k=0;k<N;k++)
          if(vec[k]>=val)
              res[k]=1;
      return res;
  }
  MC_int_vector operator==(const MC_int_vector& vec,const int& val)
  {
      int N=vec.size();
      MC_int_vector res=MC_int_vector::zeros(N);
      for(int k=0;k<N;k++)
          if(vec[k]==val)
              res[k]=1;
      return res;
  }

  MC_int_vector operator<(const int& val,const MC_int_vector& vec)
  {return vec>val;}
  MC_int_vector operator<=(const int& val,const MC_int_vector& vec)
  {return vec>=val;}
  MC_int_vector operator>(const int& val,const MC_int_vector& vec)
  {return vec<val;}
  MC_int_vector operator>=(const int& val,const MC_int_vector& vec)
  {return vec<=val;}
  MC_int_vector operator==(const int& val,const MC_int_vector& vec)
  {return vec==val;}
  const int* MC_int_vector::pointer() const {return &int_list[0];}

  std::list <MC_int_vector> MC_int_vector::connected_component(const std::set<MC_int_pair,MC_int_pair_less>& pair_set)
  {
      std::list <MC_int_vector> full;


      std::list <MC_int_pair> list_pair;
      for(std::set <MC_int_pair,MC_int_pair_less>::iterator it=pair_set.begin();it!=pair_set.end();++it)
          list_pair.push_back(*it);




      // add forward
      std::list <MC_int_pair> :: iterator it;
      std::list <int> current_curve;

      // while the list is not empty
      while(list_pair.size()>0)
      {
          // fill the first found
          it=list_pair.begin();
          int to_find=(*it)[1];
          current_curve.push_back( (*it)[0] );
          current_curve.push_back( to_find );
          list_pair.erase(it);

          // find the next index until no more index
          bool find_next=true;
          while(find_next==true)
          {
              find_next=false;
              std::list<MC_int_pair>::iterator searcher;

              // exhaustive research
              for(searcher=list_pair.begin();searcher!=list_pair.end();++searcher)
              {
                  if( (*searcher)[0]==to_find )
                  {
                      current_curve.push_back( (*searcher)[1] );
                      to_find=(*searcher)[1];
                      break;
                  }
                  else if((*searcher)[1]==to_find )
                  {
                      current_curve.push_back( (*searcher)[0] );
                      to_find=(*searcher)[0];
                      break;
                  }
              }
              if(searcher!=list_pair.end())
              {
                  list_pair.erase(searcher);
                  find_next=true;
              }
          }

          //
//          for(std::list <MC_int_pair>:: iterator it=list_pair.begin();it!=list_pair.end();++it)
//              std::cout<<*it<<std::endl;
//          for(std::list <int>:: iterator it=current_curve.begin();it!=current_curve.end();++it)
//              std::cout<<"plop "<<*it<<std::endl;

          // add the curve in the list
          full.push_back(MC_int_vector(current_curve));
          current_curve.clear();

      }

      return full;
  }

  MC_int_vector::MC_int_vector(const std::list <int> &vec)
  {
      for(std::list <int>::const_iterator it=vec.begin();it!=vec.end();++it)
          add(*it);
  }
  std::list <int> MC_int_vector::to_list() const
  {
      std::list <int> index;
      int N=size();
      for(int k=0;k<N;++k)
          index.push_back(int_list[k]);
      return index;
  }

  int MC_int_vector::find(const int& to_find) const
  {
      int N=size();
      for(int k=0;k<N;++k)
          if(to_find==int_list[k])
              return k;
      return -1;
  }

  std::pair <MC_int_vector,MC_int_vector> MC_int_vector::sort() const
  {
      //prepare the sorting structure
      int N=size();
      std::vector <std::pair<int,int> > vec_to_sort(N);
      for(int k=0;k<N;++k)
          vec_to_sort[k]=std::pair <int,int>(int_list[k],k);

      //sort
      std::sort(vec_to_sort.begin(),
                vec_to_sort.end(),
                comparator_less_int_int());

      //redistribute
      std::pair <MC_int_vector,MC_int_vector> res;
      res.first.resize(N);res.second.resize(N);
      for(int k=0;k<N;++k)
      {
          res.first[k]=vec_to_sort[k].first;
          res.second[k]=vec_to_sort[k].second;
      }
      return res;
  }

  MC_int_vector& MC_int_vector::erase_last()
  {resize(size()-1);return *this;}

//  std::map <int,int> MC_int_vector::reverse_index_mapping(const std::map<int,int>& input_mapping)
//  {
//      std::map <int,int> reversed;
//      std::map <int,int> :: const_iterator it=input_mapping.begin();
//      std::map <int,int> :: const_iterator it_end=input_mapping.end();
//      for(;it!=it_end;++it)
//          reversed.insert(std::make_pair(it->second,it->first));
//      return reversed;
//  }

  MC_int_vector MC_int_vector::mapping(const std::map<int,int> map_to_apply) const
  {
      std::map <int,int> :: const_iterator it_end=map_to_apply.end();
      std::map <int,int> :: const_iterator it;

      int N=size();
      MC_int_vector mapped_value=MC_int_vector::zeros(N);
      for(int k=0;k<N;++k)
      {
          int current_index=int_list[k];
          it=map_to_apply.find(current_index);
          if(it==it_end)
              mapped_value[k]=-1;
          else
              mapped_value[k]=it->second;
      }
      return mapped_value;
  }

  MC_int_vector MC_int_vector::inverted() const
  {
      unsigned int N=size();
      MC_int_vector inv=MC_int_vector::zeros(N);
      for(int k=0;k<N;++k)
          inv[k]=int_list[N-k-1];
      return inv;
  }
  MC_int_vector::MC_int_vector(const std::set <unsigned int>& vec)
  {
      for(std::set<unsigned int>::const_iterator it=vec.begin(),it_end=vec.end();it!=it_end;++it)
          add(*it);
  }
  MC_v3d MC_int_vector::to_v3d() const
  {return MC_v3d(int_list[0],int_list[1],int_list[2]);}

}