Ymir  .9
Fast\C++toolforcomputationofassemblingprobabilities,statisticalinferenceofassemblingstatisticalmodelandgenerationofartificialsequencesofT-cellreceptorsdata.
textdata.h
1 //
2 // Created by Vadim N. on 03/04/2015.
3 //
4 
5 
6 // Disclaimer: I doesn't like IO in C++.
7 
8 
9 #ifndef YMIR_TEXTDATA_H
10 #define YMIR_TEXTDATA_H
11 
12 //#include <vector>
13 
14 #include "types.h"
15 
16 
17 namespace ymir {
18 
19 
20  enum CONTAINER_TYPE {
21  VECTOR,
22  VECTOR_LIST,
23  MATRIX,
24  MATRIX_LIST
25  };
26 
27 
28  struct AbstractTDContainer {
29  public:
30 
31  AbstractTDContainer(CONTAINER_TYPE ctype, bool skip_first_column, prob_t laplace, const std::string &filepath) {
32  _colnames.reserve(40);
33  _rownames.reserve(40);
34  _data.reserve(40);
35  _laplace = laplace;
36  _skip_first_column = skip_first_column;
37  _type = ctype;
38  _filepath = filepath;
39 
40  std::ifstream ifs;
41  ifs.open(filepath);
42  if (ifs.good()) {
43  _file_exists = true;
44  } else {
45  _file_exists = false;
46  }
47  ifs.close();
48  }
49 
50 
51  virtual ~AbstractTDContainer() { }
52 
53 
54  virtual void addDataValue(prob_t value, size_t i = 0) { _data[i].push_back(value + _laplace); }
55 
56 
57  virtual void addDataVector(const std::vector<prob_t> &vec) {
58  _data.push_back(std::vector<prob_t>());
59  for (auto i = 0; i < vec.size(); ++i) {
60  _data[_data.size() - 1].push_back(vec[i] + _laplace);
61  }
62  }
63 
64 
65  virtual void addDataVector(std::vector<prob_t>::const_iterator start, std::vector<prob_t>::const_iterator end) {
66  _data.push_back(std::vector<prob_t>());
67  _data[_data.size() - 1].insert(_data[_data.size() - 1].end(), start, end);
68  }
69 
70 
71  prob_t laplace() const { return _laplace; }
72 
73 
74  seg_index_t n_rows() const { return _rownames.size(); }
75 
76 
77  seg_index_t n_columns() const { return _colnames.size(); }
78 
79 
80  void addRowName(const std::string& name) { _rownames.push_back(name); }
81 
82 
83  void addColumnName(const std::string& name) { _colnames.push_back(name); }
84 
85 
86  void addMetadata(seq_len_t data) { _metadata.push_back(data); }
87 
88 
89  const std::vector<std::string>& row_names() const { return _rownames; }
90 
91 
92  const std::vector<std::string>& column_names() const { return _colnames; }
93 
94 
95  seq_len_t metadata(size_t i) const { return _metadata[i]; }
96 
97 
98  virtual bool read(std::string &err_message) = 0;
99 
100 
101  virtual bool write(const std::string& filepath) = 0;
102 
103 
104  const std::vector<prob_t>& data(size_t i) const { return _data[i]; }
105 
106 
107  CONTAINER_TYPE type() const { return _type; }
108 
109 
110  bool file_exists() const { return _file_exists; }
111 
112  protected:
113 
114  std::vector< std::vector<prob_t> > _data;
115  std::vector<std::string> _colnames;
116  std::vector<std::string> _rownames;
117  prob_t _laplace;
118  bool _skip_first_column, _file_exists;
119  CONTAINER_TYPE _type;
120  std::vector<seq_len_t> _metadata;
121  std::string _filepath;
122 
123 
124  AbstractTDContainer() {
125  _colnames.reserve(40);
126  _rownames.reserve(40);
127  _data.reserve(40);
128  _laplace = 0;
129  _skip_first_column = true;
130  }
131 
132  };
133 
134 
138  struct TDVector : public AbstractTDContainer {
139  public:
140 
141  TDVector(bool skip_first_column = true, prob_t laplace = 0, const std::string &filepath = "")
142  : AbstractTDContainer(VECTOR, skip_first_column, laplace, filepath) { }
143 
144 
145  virtual ~TDVector() { }
146 
147 
148  bool read(std::string &err_message) {
149  std::ifstream ifs;
150 
151  ifs.open(_filepath);
152 
153  if (ifs.is_open()) {
154  std::stringstream line_stream;
155  std::string line, word;
156  std::vector<prob_t> word_vec;
157  int line_num = 1;
158  bool skip_col_num_check = true, empty_line = false;
159 
160  while (!ifs.eof()) {
161  getline(ifs, line);
162  if (line[0] != '\n' && line[0] != 0) {
163  word_vec.clear();
164  line_stream.str(line);
165  int i = !_skip_first_column;
166 
167  if (skip_col_num_check) {
168  getline(line_stream, word, '\t');
169  this->addColumnName("Probability");
170  _data.push_back(std::vector<prob_t>());
171  _data[0].reserve(60);
172  } else {
173  while (!line_stream.eof()) {
174  getline(line_stream, word, '\t');
175  // MPFR?!?!?! I don't know
176  // add row
177  if (i) { word_vec.push_back(stod(word)); }
178  else { this->addRowName(word); }
179  ++i;
180  }
181 
182  }
183  line_stream.clear();
184  } else {
185  empty_line = true;
186  }
187 
188  if (!empty_line) {
189  if (!skip_col_num_check) {
190  if (word_vec.size() == _colnames.size()) {
191  for (size_t i = 0; i < word_vec.size(); ++i) {
192  _data[i].push_back(word_vec[i]);
193  }
194  } else {
195  std::stringstream ss;
196  ss << "ERROR: number of elements doesn't match the number of columns in the line " <<
197  (int) line_num <<
198  " (expected: " <<
199  (int) _colnames.size() <<
200  ", got: " <<
201  (int) word_vec.size() << ")";
202  err_message = ss.str();
203  return false;
204  }
205  } else {
206  skip_col_num_check = false;
207  }
208  } else {
209  empty_line = false;
210  }
211 
212  ++line_num;
213  }
214  ifs.close();
215  _file_exists = true;
216  return true;
217  }
218 
219  _file_exists = false;
220  err_message = "ERROR: can't open file [" + _filepath + "]";
221  return false;
222  }
223 
224 
225  bool write(const std::string& filepath) {
226  std::ofstream ofs;
227 
228  ofs.open(filepath);
229 
230  if (ofs.is_open()) {
231 
232  ofs << _colnames[0] << '\t' << _colnames[1] << std::endl;
233 
234  for (auto i = 0; i < _data[0].size(); ++i) {
235  ofs << _rownames[i] << '\t' << _data[0][i] << std::endl;
236  }
237 
238  ofs.close();
239  _file_exists = true;
240  return true;
241  }
242 
243  _file_exists = false;
244  return false;
245  }
246 
247  protected:
248 
249  TDVector() : AbstractTDContainer() {}
250 
251  };
252 
253 
254 
258  struct TDVectorList : public AbstractTDContainer {
259  public:
260 
261  TDVectorList(bool skip_first_column = true, prob_t laplace = 0, const std::string &filepath = "")
262  : AbstractTDContainer(VECTOR_LIST, skip_first_column, laplace, filepath) { }
263 
264 
265  virtual ~TDVectorList() { }
266 
267 
268  bool read(std::string &err_message) {
269  std::ifstream ifs;
270 
271  ifs.open(_filepath);
272 
273  if (ifs.is_open()) {
274  std::stringstream line_stream;
275  std::string line, word;
276  std::vector<prob_t> word_vec;
277  int line_num = 1;
278  bool skip_col_num_check = true, empty_line = false;
279  while (!ifs.eof()) {
280  getline(ifs, line);
281  if (line[0] != '\n' && line[0] != 0) {
282  word_vec.clear();
283  line_stream.str(line);
284  int i = !_skip_first_column;
285 
286  if (skip_col_num_check) {
287  while (!line_stream.eof()) {
288  getline(line_stream, word, '\t');
289  if (i) {
290  this->addColumnName(word);
291  _data.push_back(std::vector<prob_t>());
292  _data[_data.size() - 1].reserve(40);
293  }
294  ++i;
295  }
296  } else {
297  while (!line_stream.eof()) {
298  getline(line_stream, word, '\t');
299  // MPFR?!?!?! I don't know
300  // add row
301  if (i) { word_vec.push_back(stod(word)); }
302  else { this->addRowName(word); }
303  ++i;
304  }
305 
306  }
307  line_stream.clear();
308  } else {
309  empty_line = true;
310  }
311 
312  if (!empty_line) {
313  if (!skip_col_num_check) {
314  if (word_vec.size() == _colnames.size()) {
315  for (size_t i = 0; i < word_vec.size(); ++i) {
316  _data[i].push_back(word_vec[i]);
317  }
318  } else {
319  std::stringstream ss;
320  ss << "ERROR: number of elements doesn't match the number of columns in the line " <<
321  (int) line_num <<
322  " (expected: " <<
323  (int) _colnames.size() <<
324  ", got: " <<
325  (int) word_vec.size() << ")";
326  err_message = ss.str();
327  return false;
328  }
329  } else {
330  skip_col_num_check = false;
331  }
332  } else {
333  empty_line = false;
334  }
335 
336  ++line_num;
337  }
338  ifs.close();
339  _file_exists = true;
340  return true;
341  }
342 
343  _file_exists = false;
344  err_message = "ERROR: can't open file [" + _filepath + "]";
345  return false;
346  }
347 
348 
349  bool write(const std::string& filepath) {
350  std::ofstream ofs;
351 
352  ofs.open(filepath);
353 
354  if (ofs.is_open()) {
355  seq_len_t max_len = _data[0].size();
356  for (auto i = 1; i < _data.size(); ++i) { max_len = std::max(max_len, (seq_len_t) _data[i].size()); }
357 
358  for (auto i = 0; i < _colnames.size(); ++i) {
359  ofs << _colnames[i];
360  if (i < _colnames.size() - 1) {
361  ofs << "\t";
362  } else {
363  ofs << std::endl;
364  }
365  }
366 
367  for (auto pos_i = 0; pos_i < max_len; ++pos_i) {
368  if (pos_i < _rownames.size()) {
369  ofs << _rownames[pos_i] << '\t';
370  } else {
371  ofs << "0" << '\t';
372  }
373 
374  for (auto vec_i = 0; vec_i < _data.size(); ++vec_i) {
375  if (pos_i < _data[vec_i].size()) {
376  ofs << _data[vec_i][pos_i];
377  } else {
378  ofs << 0;
379  }
380  if (vec_i < _data.size() - 1) { ofs << '\t'; }
381  }
382  ofs << std::endl;
383  }
384 
385  ofs.close();
386  _file_exists = true;
387  return true;
388  }
389 
390  _file_exists = false;
391  return false;
392  }
393 
394  protected:
395 
396  TDVectorList() : AbstractTDContainer() {}
397 
398  };
399 
400 
401  struct TDMatrix : public AbstractTDContainer {
402  public:
403 
404  TDMatrix(bool skip_first_column = true, prob_t laplace = 0, const std::string &filepath = "")
405  : AbstractTDContainer(MATRIX, skip_first_column, laplace, filepath) { }
406 
407 
408  virtual ~TDMatrix() { }
409 
410 
411  virtual void addDataVector(const std::vector<prob_t> &vec) {
412  if (!_data.size()) {
413  _data.push_back(std::vector<prob_t>());
414  }
415  _data[0].insert(_data[0].end(), vec.begin(), vec.end());
416  }
417 
418 
419  bool read(std::string &err_message) {
420  std::ifstream ifs;
421 
422  ifs.open(_filepath);
423 
424  if (ifs.is_open()) {
425  _data.push_back(std::vector<prob_t>());
426  std::stringstream line_stream;
427  std::string line, word;
428  std::vector<prob_t> word_vec;
429  int line_num = 1;
430  bool skip_col_num_check = true, empty_line = false;
431  while (!ifs.eof()) {
432  getline(ifs, line);
433  if (line[0] != '\n' && line[0] != 0) {
434  word_vec.clear();
435  line_stream.str(line);
436  int i = !_skip_first_column;
437 
438  if (skip_col_num_check) {
439  while (!line_stream.eof()) {
440  getline(line_stream, word, '\t');
441  if (i) { this->addColumnName(word); }
442  ++i;
443  }
444  } else {
445  while (!line_stream.eof()) {
446  getline(line_stream, word, '\t');
447  // MPFR?!?!?! I don't know
448  // add row
449  if (i) { word_vec.push_back(stod(word)); }
450  else { this->addRowName(word); }
451  ++i;
452  }
453 
454  }
455  line_stream.clear();
456  } else {
457  empty_line = true;
458  }
459 
460  if (!empty_line) {
461  if (!skip_col_num_check) {
462  if (word_vec.size() == _colnames.size()) {
463  _data[0].insert(_data[0].end(), word_vec.begin(), word_vec.end());
464  } else {
465  std::stringstream ss;
466  ss << "ERROR: number of elements doesn't match the number of columns in the line " <<
467  (int) line_num <<
468  " (expected: " <<
469  (int) _colnames.size() <<
470  ", got: " <<
471  (int) word_vec.size() << ")";
472  err_message = ss.str();
473  return false;
474  }
475  } else {
476  skip_col_num_check = false;
477  }
478  } else {
479  empty_line = false;
480  }
481 
482  ++line_num;
483  }
484  ifs.close();
485  _file_exists = true;
486  return true;
487  }
488 
489  _file_exists = false;
490  err_message = "ERROR: can't open file [" + _filepath + "]";
491  return false;
492  }
493 
494 
495  bool write(const std::string& filepath) {
496  std::ofstream ofs;
497 
498  ofs.open(filepath);
499 
500  if (ofs.is_open()) {
501  for (auto i = 0; i < _colnames.size(); ++i) {
502  ofs << _colnames[i];
503  if (i < _colnames.size() - 1) {
504  ofs << "\t";
505  } else {
506  ofs << std::endl;
507  }
508  }
509 
510  for (size_t row_i = 0; row_i < _data[0].size() / _metadata[0]; ++row_i) {
511  ofs << _rownames[row_i] << '\t';
512  for (auto col_i = 0; col_i < _metadata[0]; ++col_i) {
513  ofs << _data[0][row_i * _metadata[0] + col_i];
514  if (col_i < _metadata[0] - 1) { ofs << '\t'; }
515  }
516  ofs << std::endl;
517  }
518 
519  ofs.close();
520  _file_exists = true;
521  return true;
522  }
523 
524  _file_exists = false;
525  return false;
526  }
527 
528  protected:
529 
530  TDMatrix() : AbstractTDContainer() {}
531 
532  };
533 
534 
540  struct TDMatrixList : public AbstractTDContainer {
541  public:
542 
543 
544  TDMatrixList(bool skip_first_column = true, prob_t laplace = 0, const std::string &filepath = "")
545  : AbstractTDContainer(MATRIX_LIST, skip_first_column, laplace, filepath) { }
546 
547 
548  virtual ~TDMatrixList() { }
549 
550 
551  bool read(std::string &err_message) {
552  std::ifstream ifs;
553 
554  ifs.open(_filepath);
555 
556  if (ifs.is_open()) {
557  std::stringstream line_stream;
558  std::string line, word;
559  std::vector<prob_t> word_vec;
560  int line_num = 1, matrix_num = 0;
561  bool skip_col_num_check = true, in_matrix = true, empty_line = false;
562  _data.push_back(std::vector<prob_t>());
563  while (!ifs.eof()) {
564  getline(ifs, line);
565  if (line[0] != '\n' && line[0] != 0) {
566  word_vec.clear();
567  line_stream.str(line);
568  int i = !_skip_first_column;
569 
570  if (skip_col_num_check) {
571  while (!line_stream.eof()) {
572  getline(line_stream, word, '\t');
573  if (i) { this->addColumnName(word); }
574  else { this->addRowName(word); }
575  ++i;
576  }
577  _metadata.push_back(i - 1);
578  } else {
579  while (!line_stream.eof()) {
580  getline(line_stream, word, '\t');
581  // MPFR?!?!?! I don't know
582  // add row
583  if (i) { word_vec.push_back(stod(word)); }
584  ++i;
585  }
586 
587  }
588  line_stream.clear();
589  } else {
590  matrix_num++;
591  _data.push_back(std::vector<prob_t>());
592  empty_line = true;
593  skip_col_num_check = true;
594  }
595 
596  if (!empty_line) {
597  if (!skip_col_num_check) {
598  if (word_vec.size() == _metadata[matrix_num]) {
599  _data[matrix_num].insert(_data[matrix_num].end(), word_vec.begin(), word_vec.end());
600  } else {
601  std::stringstream ss;
602  ss << "ERROR: number of elements doesn't match the number of columns in the line " <<
603  (int) line_num <<
604  " (expected: " <<
605  (int) _colnames.size() <<
606  ", got: " <<
607  (int) word_vec.size() << ")";
608  err_message = ss.str();
609  return false;
610  }
611  } else {
612  skip_col_num_check = false;
613  }
614  } else {
615  empty_line = false;
616  }
617 
618  ++line_num;
619  }
620  ifs.close();
621  _file_exists = true;
622  return true;
623  }
624 
625  _file_exists = false;
626  err_message = "ERROR: can't open file [" + _filepath + "]";
627  return false;
628  }
629 
630 
631  bool write(const std::string& filepath) {
632  std::ofstream ofs;
633 
634  ofs.open(filepath);
635 
636  if (ofs.is_open()) {
637  for (auto mat_i = 0; mat_i < _data.size(); ++mat_i) {
638  ofs << _rownames[mat_i] << '\t';
639  for (auto i = 0; i < _metadata[mat_i]; ++i) {
640  ofs << std::to_string(i);
641  if (i < _metadata[mat_i] - 1) { ofs << "\t"; }
642  }
643  ofs << std::endl;
644 
645  for (size_t row_i = 0; row_i < _data[mat_i].size() / _metadata[mat_i]; ++row_i) {
646  ofs << std::to_string(row_i) << '\t';
647  for (auto col_i = 0; col_i < _metadata[mat_i]; ++col_i) {
648  ofs << _data[mat_i][row_i * _metadata[mat_i] + col_i];
649  if (col_i < _metadata[mat_i] - 1) { ofs << '\t'; }
650  }
651  ofs << std::endl;
652  }
653 
654  ofs << std::endl;
655  }
656 
657  ofs.close();
658  _file_exists = true;
659  return true;
660  }
661 
662  _file_exists = false;
663  return false;
664  }
665 
666  protected:
667 
668  TDMatrixList() : AbstractTDContainer() {}
669 
670  };
671 
672 
678  AbstractTDContainer* read_textdata(const std::string& filepath,
679  const std::string& filetype,
680  bool skip_first_column,
681  prob_t laplace,
682  std::string& err_message) {
683  AbstractTDContainer* container;
684  err_message = "OK";
685  if (filetype == "matrix") {
686  container = new TDMatrix(skip_first_column, laplace, filepath);
687  } else if (filetype == "vector.list") {
688  container = new TDVectorList(skip_first_column, laplace, filepath);
689  } else if (filetype == "matrix.list") {
690  container = new TDMatrixList(skip_first_column, laplace, filepath);
691  } else if (filetype == "vector") {
692  container = new TDVector(skip_first_column, laplace, filepath);
693  } else {
694  if (filetype == "") {
695  err_message = "ERROR: no file type for [" + filepath + "]";
696  } else {
697  err_message = "ERROR: unrecognised file type for [" + filepath + "]";
698  }
699  return nullptr;
700  }
701 
702  if (container->file_exists()) {
703  container->read(err_message);
704  return container;
705  } else {
706  err_message = "ERROR: can't open or read the file [" + filepath + "]";
707  return nullptr;
708  }
709  }
710 
711 }
712 
713 #endif //YMIR_TEXTDATA_H
ymir
Definition: aligner.h:37
ymir::TDMatrixList
Definition: textdata.h:540
ymir::TDVector
Vector of gene segments.
Definition: textdata.h:138
ymir::AbstractTDContainer
Definition: textdata.h:28
ymir::TDMatrix
Definition: textdata.h:401
ymir::TDVectorList
List of std::vectors for deletions and insertions.
Definition: textdata.h:258
Generated on Thu Mar 24 2016 23:59:14 for Ymir by   doxygen 1.8.11