file_util.hpp

Go to the documentation of this file.

#include "Headers/mytypes.hpp"
#include "Headers/mydebug.hpp"
#include "Headers/matrix_util.hpp"
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <vector>
#include <regex>
#include <algorithm>
#include <tuple>
#include <complex>
#include <cassert>
#include <sysexits.h>
 
bool checkFileExistence(std::string const& str) {
  std::ifstream ifs(str);
  return ifs.is_open();
}
 
 
bool checkIsFileOpen(std::ifstream& file, std::string const& filename) {
  if( file.fail() ) {
    std::cerr << "Can't open a file " << filename << "." << std::endl;
    std::exit(EX_CANTCREAT);
  }
  return true;
}
bool checkIsFileOpen(std::ofstream& file, std::string const& filename) {
  if( file.fail() ) {
    std::cerr << "Can't open a file " << filename << "." << std::endl;
    std::exit(EX_CANTCREAT);
  }
  return true;
}
 
 
//********** Skip lines with comments **********/
static inline void skip_header(std::ifstream& Infs){
  Infs.exceptions(std::fstream::eofbit);
  std::string line("#");
  std::ifstream::pos_type pos;
  while( line[0]=='#' || line.length()==0 ) {
    pos = Infs.tellg();
    getline(Infs,line);
  }
  Infs.seekg(pos);
}
 
 
static inline void readMatrix(std::ifstream& Infs, int const dim1, int const dim2, matrix<Complex_t<double>>& mat, std::string UPLO = "All") {
  std::string str;
  bool flag = false;
  while(std::getline(Infs, str, '\n')) {
        debug_print("(" << (str.find("[")!=std::string::npos) << "): " << str);
    if(str.find("[") != std::string::npos) { flag = true; break; };
  }
  if(flag == false) {
    std::cerr << "Error: Can't read matrix from a file." << std::endl;
    std::exit(EX_DATAERR);
  }
 
  mat.resize(dim1,dim2);
 
  std::stringstream ss;
  std::string::size_type pos;
  double real, imag;
 
  int index1, index2;
  for(index1 = 0;std::getline(Infs, str); ++index1) {
    if( str.find("]") != std::string::npos ) break;
    std::replace(str.begin(), str.end(), ';', ' ');
    std::regex_replace(str, std::regex("  *"), " ");
    str.erase(std::remove(str.begin(), str.end(), '\t'), str.end());
    if( (pos = str.find_first_not_of(' ')) != std::string::npos ) str.erase(std::remove(str.begin(), str.begin()+pos, ' '),  str.begin()+pos);
 
    debug_print("# line = " << str);
    ss.str(str); ss.clear(std::stringstream::goodbit);
    for(index2 = 0; std::getline(ss, str, ' ') && index2<dim2; ) {
      if( (pos = str.find_first_not_of(' ')) != std::string::npos ) str.erase(std::remove(str.begin(), str.begin()+pos, ' '),  str.begin()+pos);
      else break;
 
            debug_print("# element = " << str);
      if( (pos = str.find("i"))  == std::string::npos ) {
          if(UPLO=="Upper" || UPLO=="U") mat.at(index1,index1+(index2++)) = DoubleComplexOne*std::stod(str);
          else mat.at(index1,index2++) = DoubleComplexOne*std::stod(str);
      } else {
            str.replace(pos, 1, " ");
            if( (pos = str.find('*') ) != std::string::npos ) str.replace(pos, 1, " ");
 
                    // Find a seperator between the real and imaginary part.
                    flag = false; pos = str.size();
                    while( (pos = str.rfind('+',pos-1)) != std::string::npos ) {
                        if(pos == 0) break;
                        if(str[pos-1]!='e' && str[pos-1]!='E') { flag=true; break; }
                    }
                    debug_print("# pos of +: " << pos);
                    if(!flag) {
                        pos = str.size();
                        while( (pos = str.rfind('-', pos-1)) != std::string::npos ) {
                            if(pos == 0) { std::cerr << "Can't seperate real and imaginary parts. " << std::endl; std::exit(EX_DATAERR); }
                            if(str[pos-1]!='e' && str[pos-1]!='E') { flag=true; break; }
                        }
                        debug_print("# pos of -: " << pos);
                    }
                    debug_print("# real = " << str.substr(0,pos));
                    debug_print("# imag = " << str.substr(pos));
            real = std::stod(str.substr(0,pos).c_str());
            imag = std::stod(str.substr(pos).c_str());
 
            if(UPLO=="Upper" || UPLO=="U") mat.at(index1,index1+(index2++)) = real + DoubleComplexI*imag;
            else mat.at(index1,index2++) = real + DoubleComplexI*imag;
          }
 
                if(UPLO=="Upper" || UPLO=="U") {
                    debug_print("# index1=" << index1 << ", index2 = " << index2);
                    if(index1+index2 == dim2) break;
                }
    }
        debug_print("index1 = " << index1 << ", index2 = " << index2);
        if(UPLO=="Upper" || UPLO=="U" || UPLO=="Lower" || UPLO=="L") assert(index1<dim1 && index1+index2==dim2);
        else assert(index1<dim1 && index2==dim2);
  }
  assert(index1 == dim1);
}
 
// static inline void readMatrix(std::ifstream& Infs, int const dim1, int const dim2, matrix<Complex_t<double>>& mat) {
//  readMatrix(Infs, dim1, dim2, mat, "All");
// }
 
static inline std::tuple<int,int,std::string> readMatrix(std::ifstream& Infs, matrix<Complex_t<double>>& mat) {
  bool flag = false;
    int dim1, dim2;
    std::string str;
    auto oldpos1 = Infs.tellg(), oldpos2=oldpos1;
  while(std::getline(Infs, str, '\n')) {
        debug_print(oldpos2 << "(" << (str.find("[")!=std::string::npos) << "): " << str);
    if(str.find("[") != std::string::npos) { flag = true; break; };
         oldpos2 = oldpos1; oldpos1 = Infs.tellg();
  }
  if(flag == false) {
    std::cerr << "Error: Can't read matrix from a file." << std::endl;
    std::exit(EX_DATAERR);
  }
    Infs.seekg(oldpos2); std::getline(Infs, str);
 
    std::string UPLO = "All";
    std::stringstream ss(str);
    ss >> dim1 >> dim2;
    if(ss >> UPLO) debug_print("# Read UPLO=" << UPLO);
    debug_print("# dim1=" << dim1 << ", dim2=" << dim2);
    readMatrix(Infs, dim1, dim2, mat, UPLO);
    return {dim1, dim2, UPLO};
}
 
static inline std::tuple<int,int,std::string> readDiagonal(std::ifstream& Infs, std::vector<double>& vec) {
  bool flag = false;
    int dim1, dim2, index;
    std::string str;
    auto oldpos1 = Infs.tellg(), oldpos2=oldpos1;
  auto& pos = oldpos1;
  while(std::getline(Infs, str, '\n')) {
        // debug_print(oldpos2 << "(" << (str.find("[")!=std::string::npos) << "): " << str);
    if(str.find("[") != std::string::npos) { flag = true; break; };
         oldpos2 = oldpos1; oldpos1 = Infs.tellg();
  }
  if(flag == false) {
    std::cerr << "Error: Can't read matrix from a file." << std::endl;
    std::exit(EX_DATAERR);
  }
    Infs.seekg(oldpos2); std::getline(Infs, str);
 
  std::string UPLO = "All";
    std::stringstream ss(str);
    ss >> dim1 >> dim2;
    if(ss >> UPLO) debug_print("# Read UPLO=" << UPLO);
  debug_print("# dim1=" << dim1 << ", dim2=" << dim2);
  vec.resize(dim1<=dim2 ? dim1: dim2);
 
 
  //--------------------- skip header ---------------------//
  for(flag = false; std::getline(Infs, str, '\n'); ) {
        debug_print("(" << (str.find("[")!=std::string::npos) << "): " << str);
    if(str.find("[") != std::string::npos) { flag = true; break; };
  }
  if(flag == false) {
    std::cerr << "Error: Can't read matrix from a file." << std::endl;
    std::exit(EX_DATAERR);
  }
 
  //--------------------- Read diagonal elements ---------------------//
  for(index = 0;index < dim1 && std::getline(Infs, str); ++index) {
    std::cout << "Reading diagonal elements... " << (double)index/(double)dim1*100 << " %\t\r";
    if( str.find("]") != std::string::npos ) break;
    std::replace(str.begin(), str.end(), ';', ' ');
    std::regex_replace(str, std::regex("  *"), " ");
    str.erase(std::remove(str.begin(), str.end(), '\t'), str.end());
    if( (pos = str.find_first_not_of(' ')) != std::string::npos )
          str.erase(std::remove(str.begin(), str.begin()+pos, ' '),  str.begin()+pos);
    if( (pos = str.find_last_not_of(' ')) != std::string::npos && (size_t)pos+1 < str.size())
          str.erase(std::remove(str.begin()+pos+1, str.end(), ' '),  str.end());
    ss.str(str); ss.clear(std::stringstream::goodbit);
 
    if(UPLO == "Upper") {
      ss >> str;
      // debug_print(__func__ << ":index=" << index << ", str=" << str);
    // } else if(UPLO == "Lower") {
    //   if( (pos = str.rfind(' ')) != std::string::npos) {
    //     debug_print("pos=" << pos << "; " << str.substr((size_t)pos+1));
    //     str = str.substr((size_t)pos+1);
    //   } else {
    //     debug_print("pos=" << 0 << "; " << str);
    //   }
    //   // if(pos>=1) pos=str.substr(0,(size_t)pos-(size_t)1).rfind(' ');
    } else {
      for(int i = 0;i <= index; ++i) std::getline(ss, str, ' ');
      // debug_print(__func__ << ":index=" << index << ", str=" << str);
    }
    vec.at(index) = std::stod(str);
  }
  return {dim1, dim2, UPLO};
}