#include <cstring>
#include <iostream>
#include <iomanip>
#include <fstream>
#include <sstream>
#include <cstdio>
#include <cstdlib>
#include "io.h"

// =========================================================
// Open file with error messages
// =========================================================
void file_open(string filename, ofstream &outstream){

  cout << "Open "<< filename<<" for writing\n";
  outstream.open (filename.c_str(), ofstream::out);
  if ( outstream.is_open() ){
    if(outstream.bad()){
      cerr << "file_open: An error occured in File"
	   << filename << ".\n";
      exit( 1 );      
    }
  }else{
    cerr<<"file_open: File "
    << filename <<" could not be opened\n";
    exit( 1 );
  }
  return;
}


// =========================================================
// Convert string to float
// =========================================================
float FloatFromString(const std::string& s)
{
  std::istringstream i_tmp(s); float x;
  if (i_tmp >> x) {
    return x;
  }
  cerr << "FloatFromString: Non-Numeric value '" << s << "'\n";  
  
  return 0.0;
}
// =========================================================
// Convert string to Integer
// =========================================================
int IntFromString(const std::string& s)
{
  std::istringstream i_tmp(s); int x;
  if (i_tmp >> x) return x;
  cerr << "IntFromString:Non-Numeric value";
  return((int)(0));
}

/* ==============================================
 */
int word_count(char *s)
{
  bool blank;
  int i;
  int nword;
 
  nword = 0;
  blank = true;
 
  while (! (*s)){
    if ( *s == ' ' ){
      blank = true;
    }else if( blank ){
      nword = nword + 1;
      blank = false;
    }
    *s++;
  } 
  return nword;
}

/* ==============================================
 * Function read_float_vec
 * ============================================== */
void read_float_vec(string filename, float * &vec, int n){


  // Open file for reading
  FILE *fp = fopen(filename.c_str(), "r");
  if(!fp){
    cerr << "read_float_vec: An error occured. File " << filename << ".\n";
    cerr << "fp = " << fp;
    return;
  }
  
  // Alloc vec
  vec = new float[n];
  
  // Read mat
  float val;
  for(int i=0;i<n;i++){
    fscanf(fp,"%g",&val);
    vec[i]=val;
  }

  fclose(fp);
  return;
}

/* ==============================================
 * Function read_float_mat
 * ============================================== */
void read_float_mat(string filename, float ** &mat,
			int n_rows,int n_cols){


  // Open file for reading
  FILE *fp = fopen(filename.c_str(), "r");
  if(!fp){
    cerr << "read_float_mat: An error occured. File " << filename << ".\n";
    return;
  }
  
  // Alloc mat
  float * tmp_for_alloc_float;
  tmp_for_alloc_float=new float[n_rows*n_cols];
  mat = new float*[n_rows];   
  for(int i=0;i<n_rows;i++){ 
    mat[i]=&(tmp_for_alloc_float[i*n_cols]); 
  }
  
  // Read mat
  float val;
  for(int i_row=0;i_row<n_rows;i_row++){
    //cerr << i_row << "\n\t";          
    for(int i_col=0;i_col<n_cols;i_col++){
      fscanf(fp,"%g",&val);
      mat[i_row][i_col]=val;
      //cerr << i_col << " val=" << val << " " ;
    }
  }

  fclose(fp);
  return;
}

/* ==============================================
 * Function read_double_mat
 * ============================================== */
void read_double_mat(string filename, double ** &mat,
			 int n_rows,int n_cols){


  // Open file for reading
  FILE *fp = fopen(filename.c_str(), "r");
  if(!fp){
    cerr << "read_double_mat: An error occured. File "<<filename<<".\n";
    return;
  }
  
  // Alloc mat
  double * tmp_for_alloc_double;
  tmp_for_alloc_double=new double[n_rows*n_cols];
  mat = new double* [n_rows];   
  for(int i=0;i<n_rows;i++){ 
    mat[i]=&(tmp_for_alloc_double[i*n_cols]); 
  }
  
  // Read mat
  double val;
  for(int i_row=0;i_row<n_rows;i_row++){
    for(int i_col=0;i_col<n_cols;i_col++){
      fscanf(fp,"%g",&val);
      mat[i_row][i_col]=val;
    }
  }

  fclose(fp);
  return;
}

/* ==============================================
 * Function read_int_mat
 * ============================================== */
void read_int_mat(string filename, int ** &mat,
		  int n_rows,int n_cols){


  // Open file for reading
  FILE *fp = fopen(filename.c_str(), "r");
  if(!fp){
    cerr << "read_int_mat: An error occured. File "<<filename<<".\n";
    return;
  }
  
  // Alloc mat
  int * tmp_for_alloc_int;
  tmp_for_alloc_int=new int[n_rows*n_cols];
  mat = new int* [n_rows];   
  for(int i=0;i<n_rows;i++){ 
    mat[i]=&(tmp_for_alloc_int[i*n_cols]); 
  }
  
  // Read mat
  int val;
  for(int i_row=0;i_row<n_rows;i_row++){
    for(int i_col=0;i_col<n_cols;i_col++){
      fscanf(fp,"%g",&val);
      mat[i_row][i_col]=val;
    }
  }

  fclose(fp);
  return;
}


/* ==============================================
 * Function read_bool_mat
 * ============================================== */
void read_bool_mat(string filename, bool ** &mat,
		  int n_rows,int n_cols) {
  //cout << "read_bool_mat: File " << filename << ".\n";
  //cout << "n_cols="<< n_cols << "  n_rows=" << n_rows << "\n";
  
  // Open file for reading
  FILE *fp = fopen(filename.c_str(), "r");
  if(!fp){
    cerr << "read_bool_mat: An error occured. File "<<filename<<".\n";
    return;
  }
  
  // Alloc mat
  bool * tmp_for_alloc_bool;
  tmp_for_alloc_bool=new bool[n_rows*n_cols];
  mat = new bool* [n_rows];   
  for(int i=0;i<n_rows;i++){ 
    mat[i]=&(tmp_for_alloc_bool[i*n_cols]); 
  }
  
  // Read mat
  int val;
  for(int i_row=0;i_row<n_rows;i_row++){
    for(int i_col=0;i_col<n_cols;i_col++){
      fscanf(fp,"%d",&val);
      mat[i_row][i_col]=(val>0);
    }
  }
  fclose(fp);
  return;
}


/* ==============================================
 * Function read_float_mat_bin
 * ============================================== */
void read_float_mat_bin(string filename, float ** &mat,
			int &n_rows,int &n_cols) {
  // Open file for reading
  FILE *fp = fopen(filename.c_str(), "r");
  if(!fp){
    cerr << "read_float_mat_bin: An error occured. File " << filename << ".\n";
    n_cols=0;
    n_rows=0;    
    return;
  }  
  // Read n_rows and n_cols
  float val;
  fread (&n_rows,sizeof(n_rows),1,fp);
  fread (&n_cols,sizeof(n_cols),1,fp);

  // Alloc mat
  float * tmp_for_alloc_float;
  tmp_for_alloc_float=new float[n_rows*n_cols];
  mat = new float* [n_rows];   
  for(int i=0;i<n_rows;i++){ 
    mat[i]=&(tmp_for_alloc_float[i*n_cols]); 
  }
  
  // Read mat
  for(int i_row=0;i_row<n_rows;i_row++){
    for(int i_col=0;i_col<n_cols;i_col++){
      fread(&val,sizeof(val),1,fp);
      mat[i_row][i_col]=val;
    }
  }
  fclose(fp);
  return;
}

/* ==============================================
 * Function read_bool_mat_bin
 * ============================================== */
void read_bool_mat_bin(string filename, bool ** &mat,
		       int &n_rows,int &n_cols) {
  // Open file for reading
  FILE *fp = fopen(filename.c_str(), "r");
  if(!fp){
    cerr << "read_bool_mat_bin: An error occured. File" << filename << ".\n";
    n_cols=0;
    n_rows=0;    
    return;
  }
  
  // Read n_rows and n_cols
  bool val;
  fread (&n_rows,sizeof(n_rows),1,fp);
  fread (&n_cols,sizeof(n_cols),1,fp); 
  // Alloc mat
  bool * tmp_for_alloc_bool;
  tmp_for_alloc_bool=new bool[n_rows*n_cols];
  mat = new bool* [n_rows];   
  for(int i=0;i<n_rows;i++){ 
    mat[i]=&(tmp_for_alloc_bool[i*n_cols]); 
  }
  
  // Read mat
  for(int i_row=0;i_row<n_rows;i_row++){
    for(int i_col=0;i_col<n_cols;i_col++){
      fread(&val,sizeof(val),1,fp);
      mat[i_row][i_col]=val;
    }
  }

  fclose(fp);
  return;  
}


/* ==============================================
 * Function write_float_mat_bin
 * ============================================== */
void write_float_mat_bin(string filename, float **mat,
			  int n_rows,int n_cols){

  // Open file for reading
  FILE *fp = fopen(filename.c_str(), "w");
  if(!fp){
    cerr << "write_float_mat_bin: An error occured. File" << filename << ".\n";
    return;    
  }
  
  // Read n_rows and n_cols
  float val;
  fwrite (&n_rows,sizeof(n_rows),1,fp);
  fwrite (&n_cols,sizeof(n_cols),1,fp);
  for(int i_row=0;i_row<n_rows;i_row++){
    for(int i_col=0;i_col<n_cols;i_col++){
      val = mat[i_row][i_col];
      fwrite(&val,sizeof(val),1,fp);
    }
  }

  fclose(fp);
  return;
 
}


/* ==============================================
 * Function write_float_mat_bin
 * ============================================== */
void write_bool_mat_bin(string filename, bool **mat,
			  int n_rows,int n_cols){

  // Open file for reading
  FILE *fp = fopen(filename.c_str(), "w");
  if(!fp){
    cerr << "write_bool_mat_bin: An error occured. File" << filename << ".\n";
    return;    
  }
  
  // Read n_rows and n_cols
  bool val;
  fwrite (&n_rows,sizeof(n_rows),1,fp);
  fwrite (&n_cols,sizeof(n_cols),1,fp);
  for(int i_row=0;i_row<n_rows;i_row++){
    for(int i_col=0;i_col<n_cols;i_col++){
      val = mat[i_row][i_col];
      fwrite(&val,sizeof(val),1,fp);
    }
  }

  fclose(fp);
  return;
}

/* ==============================================
 * Function read_int_vector
 * ============================================== */
void read_int_vector(string filename, vector<int> &list)
{

  // Open file for reading
  ifstream infile;  
  infile.open(filename.c_str(), ifstream::in);
  
  if ( infile.is_open() ){
    if(infile.bad()){
      cerr << "read_int_vector: An error occured. File" << filename << ".\n";
      exit( 1 );      
    }
  }else{
    cerr << "** read_int_vector: File " << filename << " could not be opened\n";
    exit( 1 );
  }
  int item;
  while ( infile >> item ){
    list.push_back(item);
  }
  infile.close();
  return;  
}

/* ==============================================
 * Function read_float_vector
 * ============================================== */
void read_float_vector(string filename, vector<float> &list)
{

  // Open file for reading
  ifstream infile;  
  infile.open(filename.c_str(), ifstream::in);
  
  if ( infile.is_open() ){
    if(infile.bad()){
      cerr << "read_float_vector: An error occured. File" << filename << ".\n";
      exit( 1 );      
    }
  }else{
    cerr << "** read_float_vector: File " << filename << " could not be opened\n";
    exit( 1 );
  }

  float item;
  while ( infile >> item ){
    list.push_back(item);
  }

  infile.close();
  return;
  
}

/* ==============================================
 * Function read_float_vector
 * ============================================== */
void read_double_vector(string filename, vector<double> &list)
{

  // Open file for reading
  ifstream infile;  
  infile.open(filename.c_str(), ifstream::in);
  
  if ( infile.is_open() ){
    if(infile.bad()){
      cerr << "read_double_vector: An error occured. File" << filename << ".\n";
      exit( 1 );      
    }
  }else{
    cerr << "** read_double_vector: File " << filename << " could not be opened\n";
    exit( 1 );
  }

  double item;
  while ( infile >> item ){
    list.push_back(item);
  }

  infile.close();
  return;
  
}

/* ==============================================
 * Function read_string_vector
 * ============================================== */
void read_string_vector(string filename, vector<string> &list)
{

  // Open file for reading
  ifstream infile;  
  infile.open(filename.c_str(), ifstream::in);
  
  if ( infile.is_open() ){
    if(infile.bad()){
      cerr << "read_string_vector: An error occured. File" << filename << ".\n";
      exit( 1 );      
    }
  }else{
    cerr << "** read_string_vector: File " << filename << " could not be opened\n";
    exit( 1 );
  }

  string item;
  while ( infile >> item ){
    list.push_back(item);
  }

  infile.close();
  return;  
}

/* ==============================================
 * Function read_string_int_hash
 * ============================================== */
void read_string_int_hash(string filename, map<string,int> &hash)
{

  // Open file for reading
  ifstream infile;  
  infile.open(filename.c_str(), ifstream::in);
  
  if ( infile.is_open() ){
    if(infile.bad()){
      cerr << "** An error occured. File " << filename << ".\n";
      exit( 1 );      
    }
  }else{
    cerr << "** File " << filename << " could not be opened\n";
    exit( 1 );
  }

  string key;
  int val;
  while ( infile >> key >> val ){
    hash[key] = val;
  }

  infile.close();
  return;  
}

/* ==============================================*/
int s_len_trim ( char *s )
{

  int n;
  char *t;
 
  n = strlen (s);
  t = s + strlen(s) - 1;
 
  while ( 0 < n ){
    if ( *t != ' ' ){
      return n;
    }
    t--;
    n--;
  } 
  return n;
}



/* ==============================================
 * file_count_columns: count no of columns in a file
 * ============================================== */
int count_columns(string filename)
{
  // Init 
  int column_num;
  ifstream infile;
  bool got_one;
  char line[256];

  // Open file for reading
  infile.open(filename.c_str(), ifstream::in);
  if ( infile.is_open() ){
    if(infile.bad()){
      cerr << "** An error occured. File " << filename << ".\n";
      return(-1);
    }
  }else{
    cerr << "** File " << filename << " could not be opened\n";
    return(-1);
  }

  //  Read one line, but skip blank comment lines (liens with # or %)
  got_one = false;
  for ( ; ; ){
    infile.getline ( line, sizeof ( line ) );    
    if ( infile.eof ( ) ){ break; }
    if ( s_len_trim ( line ) == 0 ){ continue; }
    if ( line[0] == '#' ){ continue;}
    if ( line[0] == '%' ){ continue;}    
    got_one = true;
    break;
  }
  infile.close();
  
  // Try again dont ignore comments lines
  if ( !got_one ) {
    infile.open ( filename.c_str() );
    for ( ; ; ) {
      infile.getline ( line, sizeof ( line ) );
      if ( infile.eof ( ) ){break;}
      if ( s_len_trim ( line ) == 0 ){ continue; }
      got_one = true;
      break;
    }
    infile.close();
  }
                                                                                        
  if ( !got_one ) {
    cerr << "** File " << filename << " does not ontain any data\n";    
    return -1;
  }
  
  column_num = word_count ( line );
  return(column_num);

}


/* ==============================================
 * file_count_rows: count no of rows in a file
 * ============================================== */
int count_rows(string filename)
{
  int bad_num;
  int comment_num;
  ifstream infile;
  int i;
  char line[256];
  int record_num;
  int row_num;
                                                                                        
  row_num = 0;
  comment_num = 0;
  record_num = 0;
  bad_num = 0;

  // Open file for reading  
  infile.open(filename.c_str(), ifstream::in);
  if ( infile.is_open() ){
    if(infile.bad()){
      cerr << "** An error occured. File " << filename << ".\n";
      return(-1);
    }
  }else{
    cerr << "** File " << filename << " could not be opened\n";
    return(-1);
  }

  for ( ; ; )  {
    infile.getline ( line, sizeof ( line ) );
    if ( infile.eof ( ) ){break;};
    record_num = record_num + 1;
    if ( line[0] == '#' ){comment_num = comment_num + 1; continue;}
    if ( line[0] == '%' ){comment_num = comment_num + 1; continue;}    
    if ( s_len_trim ( line ) == 0 ){
      comment_num = comment_num + 1;
      continue;
    }
    row_num = row_num + 1;
  }    
  infile.close ( );
  return row_num;
}

// ==============================================================
// Read the expression matrix
// ==============================================================
void read_expression_mat(string& filename,
			 int n_skip,
			 int n_headers,		    
			 float** &express,
			 bool** &mask,
			 int &n_lines,
			 int &n_fields
			 ){

  // Count no of linesand cols in the matrix (tab delimited) 
  unsigned int ii_field; int i_field;
  unsigned int nn_fields;
  unsigned int nn_lines;
  int i_line;
  char delimiter = '\t';

  count_lines_and_fields(filename, nn_lines, nn_fields, delimiter);
  n_fields = nn_fields - n_skip;
  n_lines = nn_lines - n_headers;
  
  // Allocate contiguous n_rows by n_columns matrix
  bool * tmp_for_alloc_bool;
  tmp_for_alloc_bool=new bool[n_lines*n_fields]; 
  mask=new bool* [n_lines] ;
  for(int i=0;i<n_lines;i++){ 
    mask[i]=&(tmp_for_alloc_bool[i*n_fields]); 
  }

  float * tmp_for_alloc_float;
  tmp_for_alloc_float=new float[n_lines*n_fields]; 
  express=new float* [n_lines]; 
  for(int i=0;i<n_lines;i++){ 
    express[i]=&(tmp_for_alloc_float[i*n_fields]); 
  }

  // Open file for reading, and skip header lines
  ifstream in_stream(filename.c_str());
  string line;  
  for(i_line=0;i_line<n_headers;i_line++){    
    if(!getline(in_stream, line)){
      cerr << i_line << endl;
      cerr << "Illegal no of header lines\n"; exit(1);
    }
  }
  
  // read fields one by one
  string field;
  unsigned int prev=0, curr=0, newline=0;
  float val;  
  for(i_line=n_headers;i_line<n_lines;i_line++){
    int ii_line = i_line-n_headers;
    if((i_line/100)*10 == i_line){cout << "." ;}    
    if((i_line/100)*100 == i_line){cout << i_line << " " ;}
    
    if(!getline(in_stream, line)){
      cerr << i_line << endl;      
      cerr << "Programmers error\n"; exit(1);
    }

    newline = line.find('\n', 0);      
    
    prev=0;
    for(ii_field=0;ii_field<nn_fields;ii_field++){      
      curr = line.find(delimiter, prev);
      i_field = ii_field-n_skip;
      if(i_field<0){
	// Ignore first 'n_skip' fields
      }else{
	if(curr == string::npos & ii_field<nn_fields-1){
	  // pre mature end of line - fill empty values 
	  mask[ii_line][i_field] = 0;
	  express[ii_line][i_field] = 0;
	}else if(curr==prev){
	  // Empty value
	  mask[ii_line][i_field] = 0;
	  express[ii_line][i_field] = 0;
	}else{
	  // Legal value: read the field
	  if(ii_field==nn_fields-1){field = line.substr(prev);
	  }else{field = line.substr(prev,curr-prev);
	  }
	  // handle \t as last field	  
	  if(field.length()<1){ 
	    mask[ii_line][i_field] = 0;
	    express[ii_line][i_field] = 0;
	  }else{
	    mask[ii_line][i_field] = 1;
	    express[ii_line][i_field] = FloatFromString(field);
	  }
	}// if a legal value
      } // if i_field>=n_skip 
      prev = curr+1;      
    } // loop over fields

    
  } // lopp over lines 
  
  // Clean and exit
  //cerr << "<< Finished reading expression file\n";  
  in_stream.close();
  return;
  
}

// =========================================================
// Count no of linesand columns in a matrix
// =========================================================
void count_lines_and_fields(string& filename,
			    unsigned int &n_lines,
			    unsigned int &n_fields,
			    char delimiter){  
  
 // Open file for reading
  ifstream in_stream(filename.c_str());
  if(!in_stream){
    cerr << filename << ": not found.\n";
    exit(1);
  }

  unsigned int max_n_fields=0;
  unsigned int prev=0;
  unsigned int curr=0;
    
  // Count n_lines
  string line;  n_lines=0;
  while (getline(in_stream,line)){
    n_lines++;
    // Count fields per line
    n_fields = 0;
    do{
      curr = line.find(delimiter, prev);
      n_fields++;
      prev = curr+1;
    }while(curr != string::npos);
    if(n_fields> max_n_fields) max_n_fields=n_fields;
  }

  n_fields = max_n_fields;

  // Clean and exit
  in_stream.close();
  return;

}

// =========================================================
// Read the first column of a (tab delimited) matrix file 
// =========================================================
void read_string_column(string& filename,
			int n_headers,		    
			string* &col,
			int &n_lines,
			char delimiter){
  int i_line; 

  // Allocate contiguous n_rows by n_columns matrix
  col=new string[n_lines]; 
  if(col ==NULL) {cerr << "failed malloc for col\n";exit(1);};

  // Open file for reading, and skip header lines
  ifstream in_stream(filename.c_str());
  string line;  
  for(i_line=0;i_line<n_headers;i_line++){    
    if(!getline(in_stream, line)){
      cerr << i_line << endl;
      cerr << "Illegal no of header lines\n"; exit(1);
    }
  }

  // read fields one by one
  string field;
  unsigned int curr;
  for(i_line=n_headers;i_line<n_lines;i_line++){
    
    // Read a line 
    if(!getline(in_stream, line)){
      cerr << i_line << endl;      
      cerr << "Programmers error - not enough lines(?)\n"; exit(1);
    }
    
    // Read first field 
    curr = line.find(delimiter, 0);
    field = line.substr(0,curr);
    col[i_line-n_headers] = field;
  }

  return;
}

/* ==============================================
 * homedir
 * ============================================== */
string homedir(void)
{
  // get homedir name from env variable
  char * dirname = getenv ("HOME");
  if(dirname ==NULL){
    printf ("Failed to get $HOME");
    exit(1);    
  }
  string str_dirname=dirname;
  str_dirname += "/";  
  return str_dirname;
}
/* ==============================================
 * hostname
 * ============================================== */
string hostname(void)
{
  // get hostname from env variable
  char * hostname = getenv ("HOSTNAME");
  if(hostname ==NULL){
    printf ("Failed to get $HOSTNAME");
    exit(1);    
  }
  string str_hostname=hostname;  
  return str_hostname;
}

/* ==============================================
 * homedir
 * ============================================== */
bool file_exists(string filename)
{
  bool exists=0;

  ifstream file;        
  file.open (filename.c_str(), ifstream::in);
  file.close();
  if(!file.fail()){
    exists=1;
  }
  
  return exists;
}


/* ==============================================
 * write_vec_matlab
 * ============================================== */
void write_vec_matlab(ofstream &outstream,string header,double *vec,int n)
{
}
void write_vec_matlab(ofstream &outstream,string header,float *vec,int n)
{
  ofstream& newStream( outstream );
  newStream << header;  
  newStream << "=[";
  for(int i=0;i<n;i++){
    newStream << vec[i] << " ";
  }outstream << "];\n";  
}
void write_vec_matlab(ofstream &outstream,string header,int *vec,int n)
{
  ofstream& newStream( outstream );
  newStream << header;  
  newStream << "=[";
  for(int i=0;i<n;i++){
    newStream << vec[i] << " ";
  }outstream << "];\n";
}

/* ==============================================
 * write_vec_matlab
 * ============================================== */
void write_vec_matlab(ofstream &outstream,string header,vector<double> vec)
{
  ofstream& newStream( outstream );
  newStream << header;  
  newStream << "=[";  
  for(unsigned int i=0;i<vec.size();i++){
    newStream << vec[i] << " ";
  }outstream << "];\n";  
}
void write_vec_matlab(ofstream &outstream,string header,vector<float> vec)
{
  ofstream& newStream( outstream );
  newStream << header;  
  newStream << "=[";  
  for(unsigned int i=0;i<vec.size();i++){
    newStream << vec[i] << " ";
  }outstream << "];\n";  
}
void write_vec_matlab(ofstream &outstream,string header,vector<int> vec)
{
  ofstream& newStream( outstream );
  newStream << header;  
  newStream << "=[";  
  for(unsigned int i=0;i<vec.size();i++){
    newStream << vec[i] << " ";
  }outstream << "];\n";
}

/* ==============================================
 * write_vec_matlab
 * ============================================== */
void write_vec_matlab(string header,double *vec,int n)
{
  cout << header;  
  cout << "=[";
  for(int i=0;i<n;i++){
    cout << vec[i] << " ";
  }cout << "];\n";  
}
void write_vec_matlab(string header,float *vec,int n)
{
  cout << header;  
  cout << "=[";
  for(int i=0;i<n;i++){
    cout << vec[i] << " ";
  }cout << "];\n";  
}
void write_vec_matlab(string header,int *vec,int n)
{
  cout << header;  
  cout << "=[";
  for(int i=0;i<n;i++){
    cout << vec[i] << " ";
  }cout << "];\n";  
}
/* ==============================================
 * write_vec_matlab
 * ============================================== */
void write_vec_matlab(const char* header,double *vec,int n)
{
  cout << header;  
  cout << "=[";
  for(int i=0;i<n;i++){
    cout << vec[i] << " ";
  }cout << "];\n";  
}
void write_vec_matlab(const char* header,float *vec,int n)
{
  cout << header;  
  cout << "=[";
  for(int i=0;i<n;i++){
    cout << vec[i] << " ";
  }cout << "];\n";  
}
void write_vec_matlab(const char* header,int *vec,int n)
{
  cout << header;  
  cout << "=[";
  for(int i=0;i<n;i++){
    cout << vec[i] << " ";
  }cout << "];\n";  
}




/* ==============================================
 * write_vec_matlab
 * ============================================== */
void write_vec_matlab(string header,vector<double> vec)
{
  cout << header;  
  cout << "=[";
  for(unsigned int i=0;i<vec.size();i++){
    cout << vec[i] << " ";
  }cout << "];\n";  
}

/* ==============================================
 * write_vec_matlab
 * ============================================== */
void write_vec_matlab(string header,vector<float> vec)
{
  cout << header;  
  cout << "=[";
  for(unsigned int i=0;i<vec.size();i++){
    cout << vec[i] << " ";
  }cout << "];\n";  
}

/* ==============================================
 * write_vec_matlab
 * ============================================== */
void write_vec_matlab(string header,vector<int> vec)
{
  cout << header;  
  cout << "=[";
  for(unsigned int i=0;i<vec.size();i++){
    cout << vec[i] << " ";
  }cout << "];\n";  
}