00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #include <vector>
00021 #include <map>
00022 #include <algorithm>
00023 #include <string>
00024 #include <iostream>
00025 #include <iomanip>
00026 #include <sstream>
00027 #include <fstream>
00028 #include <ctime>
00029 #include <cmath>
00030 #include "DataHandler.h"
00031
00032 using namespace std;
00033
00039 template <typename T> class DataOperations: public DataHandler {
00040 public:
00041
00045 DataOperations(){
00046 isJoined = false;
00047 isMerged = false;
00048 tabulator = false;
00049 columns = false;
00050 tolerance = 0;
00051 precision = 0;
00052 blank = "--";
00053 commentMode = 0;
00054 };
00055
00059 virtual void swap(string command);
00060
00064 virtual void parseFiles(string names );
00065
00071 virtual void load();
00072
00076 virtual void join() {
00077 isJoined = true;
00078 }
00079
00081 virtual void merge();
00082
00084 virtual void col(){
00085 columns = true;
00086 }
00087
00089 virtual void tab() {
00090 tabulator = true;
00091 }
00092
00097 virtual void printOut();
00098
00102 virtual void setCommand(string cmd) {
00103 command = cmd;
00104 }
00105
00109 virtual void blanks(string arg) {
00110 blank = arg;
00111 }
00112
00116 virtual void tol(double t){
00117 tolerance = (T) t;
00118 }
00119
00123 virtual void prec(int p){
00124 precision = p;
00125 }
00126
00130 virtual void setFilter(string arg);
00131
00135 virtual void setOutputFiles(string names);
00136
00140 virtual void group(string arg);
00141
00145 virtual void comments(string arg);
00146
00150 virtual void calculate(string arg);
00151
00155 virtual void print(string arg);
00156
00157 private:
00162 class Value {
00163 public:
00165 bool isNumber;
00166
00168 T val;
00169
00173 Value (T v) : isNumber(true), val(v) {};
00174
00176 Value () : isNumber(false), val(0) {};
00177 };
00178
00180 size_t col_cond;
00181
00183 bool isJoined;
00184
00186 bool isMerged;
00187
00189 bool tabulator;
00190
00192 bool columns;
00193
00197 char c;
00198
00200 T tolerance;
00201
00205 int precision;
00206
00208 string blank;
00209
00211 int commentMode;
00212
00214 vector<string> file_names;
00215
00217 vector<string> file_out;
00218
00220 vector< vector< vector<Value> > > all_values;
00221
00223 vector< vector<string> > all_comments;
00224
00226 vector< map<string, double> > all_param;
00227
00229 vector< vector<Value> > tab_tmp;
00230
00232 vector<Value> vall_tmp;
00233
00235 vector<double> conditions;
00236
00238 vector<string> kind_of_cond;
00239
00241 vector<size_t> out;
00242
00244 vector< vector <size_t> > dim;
00245
00247 string command;
00248
00250 DataOperations(DataOperations &) {}
00251
00253 void printToStd();
00254
00256 void printToFile();
00257
00259 void printToFiles();
00260
00264 size_t startFiltering();
00265
00269 void mean();
00270
00274 void count();
00275
00279 void sum();
00280
00284 void median();
00285
00289 void deviation();
00290
00294 void fillInBlanks();
00295
00297 void commOut(ostream* out);
00298
00300 void commIn(ostream* out, int i);
00301
00303 void parseComments();
00304 };
00305
00306 template <typename T> void DataOperations<T>::fillInBlanks(){
00307 if (isJoined){
00308 size_t max_col = 0;
00309 for(size_t i = 0; i < all_values.size(); i++) {
00310 for(size_t j = 0; j < all_values[i].size(); j++) {
00311 if (all_values[i][j].size() > max_col) max_col = all_values[i][j].size();
00312 }
00313
00314 }
00315 for(size_t i = 0; i < all_values.size(); i++) {
00316 for(size_t j = 0; j < all_values[i].size(); j++) {
00317 if (all_values[i][j].size() < max_col){
00318 for (size_t k = all_values[i][j].size(); k < max_col; k++) {
00319 all_values[i][j].push_back(Value());
00320 }
00321 }
00322 }
00323 }
00324 }
00325 else {
00326 for(size_t i = 0; i < all_values.size(); i++) {
00327 size_t max_col = 0;
00328 for(size_t j = 0; j < all_values[i].size(); j++) {
00329 if (all_values[i][j].size() > max_col) max_col = all_values[i][j].size();
00330 }
00331 for(size_t j = 0; j < all_values[i].size(); j++) {
00332 if (all_values[i][j].size() < max_col){
00333 for (size_t k = all_values[i][j].size(); k < max_col; k++) {
00334 all_values[i][j].push_back(Value());
00335 }
00336 }
00337 }
00338 }
00339 }
00340 }
00341
00342 template <typename T> void DataOperations<T>::parseComments() {
00343 size_t a;
00344 size_t b;
00345 size_t e;
00346 string tmp;
00347 string name;
00348 double value;
00349 const char* white = " \t";
00350 all_param.resize(all_comments.size());
00351 for (size_t i = 0; i < all_comments.size(); i++){
00352 for (size_t j = 0; j < all_comments[i].size(); j++){
00353 tmp = all_comments[i][j];
00354 a = tmp.find_first_of("=");
00355 name = tmp.substr(0, a);
00356 while (a != string::npos){
00357 if ( tmp[a-1] == ' ' || tmp[a-1] == '\t' ){
00358 e = name.find_last_not_of(white);
00359 }
00360 else {
00361 e = a-1;
00362 }
00363 b = name.find_last_of(white, e);
00364 if (b != string::npos) {
00365 name = name.substr(b+1, e-b);
00366 }
00367 else {
00368 name = name.substr(0, e+1);
00369 }
00370 tmp = tmp.substr(a+1);
00371 value = atof(tmp.c_str());
00372 if(value != 0 || (value == 0 && (tmp == "0" || tmp.find("0.0") == 0))) {
00373 all_param[i][name] = value;
00374 }
00375 else {
00376 cerr << "Invalid value of parameter " << name << " in data file: " << i+1 << endl;
00377 }
00378 a = tmp.find_first_of("=");
00379 name = tmp.substr(0, a);
00380 }
00381 }
00382 }
00383
00384 }
00385
00386 template <typename T> void DataOperations<T>::parseFiles(string names) {
00387 char delim = ',';
00388 string name;
00389 istringstream iss(names);
00390 while (getline(iss, name, delim)) {
00391 file_names.push_back(name);
00392 }
00393 load();
00394 parseComments();
00395 }
00396
00397 template <typename T> void DataOperations<T>::load() {
00398 vector< vector<Value> > tab_tmp;
00399 vector<string> com_tmp;
00400 vector<Value> val_tmp;
00401 string s, line;
00402 T liczba;
00403 size_t found, found1;
00404 const char* white = " \t\r\n";
00405 size_t ile = file_names.size();
00406 if(file_names.size() == 0) ile = 1;
00407 for(size_t i = 0; i < ile; i++) {
00408 istream* in;
00409 ifstream infile;
00410 if(file_names.size() != 0) {
00411 infile.open(file_names[i].c_str());
00412 in = &infile;
00413 }
00414 else {
00415 in = &cin;
00416 }
00417 while(getline(*in, line)) {
00418 found = line.find_first_not_of(white);
00419 if (found != string::npos && line[found] == '#') {
00420 com_tmp.push_back(line.substr(found));
00421 }
00422 else if(found != string::npos && line[found] != '#') {
00423 line = line+"\r\n";
00424 do {
00425 found1 = line.find_first_of(white, found);
00426 if(found1 != string::npos) s = line.substr(found, found1-found);
00427 found = line.find_first_not_of(white, found1);
00428 liczba = (T) atof(s.c_str());
00429 if(liczba != 0 || (liczba == 0 && (s == "0" || s.find("0.0") == 0))) {
00430 val_tmp.push_back(Value(liczba));
00431 }
00432 else {
00433 cerr << "Invalid value detected in data file: " << i+1 << endl;
00434 val_tmp.push_back(Value());
00435 }
00436 } while(found != string::npos && found1 != string::npos);
00437 if(!val_tmp.empty()) {
00438 tab_tmp.push_back(val_tmp);
00439 val_tmp.clear();
00440 }
00441 }
00442 }
00443 if(!tab_tmp.empty()) {
00444 all_values.push_back(tab_tmp);
00445 tab_tmp.clear();
00446 }
00447 if(!com_tmp.empty()) {
00448 all_comments.push_back(com_tmp);
00449 com_tmp.clear();
00450 } else {
00451 com_tmp.push_back("\r\n");
00452 all_comments.push_back(com_tmp);
00453 com_tmp.clear();
00454 }
00455 }
00456 fillInBlanks();
00457 }
00458
00459 template <typename T> void DataOperations<T>::swap(string arg) {
00460 size_t n, m, file;
00461 n = atoi(arg.c_str());
00462 size_t found = arg.find_first_of(',');
00463 size_t found2 = arg.find_last_of(',');
00464 m = atoi(arg.substr(found+1, found2).c_str());
00465 file = atoi(arg.substr(found2+1).c_str());
00466 size_t begin;
00467 size_t end;
00468 Value tmp;
00469 n--; m--; file--;
00470 if(isJoined || found == found2) {
00471 begin = 0;
00472 end = all_values.size();
00473 file = 0;
00474 }
00475 else {
00476 begin = file;
00477 end = file+1;
00478 }
00479 for(size_t i = begin; i < end; i++) {
00480 if(n >= all_values[i][0].size() || m >= all_values[i][0].size() || n == m || file > all_values.size() || begin >= all_values.size()) {
00481 cerr << "Wrong swap argument!" << endl;
00482 exit(1);
00483 }
00484 }
00485 for( ; begin < end; begin++) {
00486 for(size_t j = 0; j < all_values[begin].size(); j++) {
00487 tmp = all_values[begin][j][n];
00488 all_values[begin][j][n] = all_values[begin][j][m];
00489 all_values[begin][j][m] = tmp;
00490 }
00491 }
00492 }
00493
00494 template <typename T> void DataOperations<T>::mean() {
00495 T tmp = 0;
00496 int l = 0;
00497 vector<Value> tmp_vec;
00498 vector<int> x;
00499 if (columns){
00500 if (isJoined){
00501 if (dim[0].size() > 0){
00502 tmp_vec.resize(dim[0][0]);
00503 x.resize(dim[0][0]);
00504 for(size_t i = 0; i < dim.size(); i++) {
00505 for(size_t j = 0; j < dim[i].size(); j++) {
00506 for(size_t k = 0; k < dim[i][j]; k++) {
00507 if (all_values[i][j][k].isNumber){
00508 tmp_vec[k].val += all_values[i][j][k].val;
00509 tmp_vec[k].isNumber = true;
00510 x[k]++;
00511 }
00512 }
00513 }
00514 }
00515 for(size_t i = 0; i < dim.size(); i++) {
00516 for(size_t j = 0; j < dim[i].size(); j++) {
00517 for(size_t k = 0; k < dim[i][j]; k++) {
00518 if (x[k] > 0 && tmp_vec[k].isNumber){
00519 tmp_vec[k].val = (T) (tmp_vec[k].val / (double)x[k]);
00520 x[k] = -1;
00521 }
00522 }
00523 }
00524 }
00525 all_values[dim.size()-1].push_back(tmp_vec);
00526 }
00527 }
00528 else {
00529 for(size_t i = 0; i < dim.size(); i++) {
00530 if (dim[0].size() > 0){
00531 tmp_vec.clear();
00532 tmp_vec.resize(dim[i][0]);
00533 x.clear();
00534 x.resize(dim[i][0]);
00535 for(size_t j = 0; j < dim[i].size(); j++) {
00536 for(size_t k = 0; k < dim[i][j]; k++) {
00537 if (all_values[i][j][k].isNumber){
00538 tmp_vec[k].val += all_values[i][j][k].val;
00539 tmp_vec[k].isNumber = true;
00540 x[k]++;
00541 }
00542 }
00543 }
00544 for(size_t k = 0; k < dim[i][0]; k++) {
00545 if (x[k] > 0 && tmp_vec[k].isNumber){
00546 tmp_vec[k].val = (T) (tmp_vec[k].val / (double)x[k]);
00547 x[k] = -1;
00548 }
00549 }
00550 all_values[i].push_back(tmp_vec);
00551 }
00552 }
00553 }
00554 }
00555 else {
00556 for(size_t i = 0; i < dim.size(); i++) {
00557 for(size_t j = 0; j < dim[i].size(); j++) {
00558 for(size_t k = 0; k < dim[i][j]; k++) {
00559 if (all_values[i][j][k].isNumber){
00560 tmp += all_values[i][j][k].val;
00561 l++;
00562 }
00563 }
00564 tmp = (T) (tmp/double(l));
00565 all_values[i][j].push_back(Value(tmp));
00566 tmp = 0 ;
00567 l = 0;
00568 }
00569 }
00570 }
00571 }
00572
00573 template <typename T> void DataOperations<T>::count() {
00574 size_t tmp = 0;
00575 vector<Value> tmp_vec;
00576 if (columns){
00577 if (isJoined){
00578 if (dim[0].size() > 0){
00579 tmp_vec.resize(dim[0][0]);
00580 for(size_t i = 0; i < dim.size(); i++) {
00581 for(size_t j = 0; j < dim[i].size(); j++) {
00582 for(size_t k = 0; k < dim[i][j]; k++) {
00583 if (all_values[i][j][k].isNumber){
00584 tmp_vec[k].val++;
00585 tmp_vec[k].isNumber = true;
00586 }
00587 }
00588 }
00589 }
00590 }
00591 all_values[dim.size()-1].push_back(tmp_vec);
00592 }
00593 else {
00594 for(size_t i = 0; i < dim.size(); i++) {
00595 if (dim[0].size() > 0){
00596 tmp_vec.clear();
00597 tmp_vec.resize(dim[i][0]);
00598 for(size_t j = 0; j < dim[i].size(); j++) {
00599 for(size_t k = 0; k < dim[i][j]; k++) {
00600 if (all_values[i][j][k].isNumber){
00601 tmp_vec[k].val++;
00602 tmp_vec[k].isNumber = true;
00603 }
00604 }
00605 }
00606 all_values[i].push_back(tmp_vec);
00607 }
00608 }
00609 }
00610 }
00611 else {
00612 for(size_t i = 0; i < dim.size(); i++) {
00613 for(size_t j = 0; j < dim[i].size(); j++) {
00614 for(size_t k = 0; k < dim[i][j]; k++) {
00615 if (all_values[i][j][k].isNumber){
00616 tmp++;
00617 }
00618 }
00619 all_values[i][j].push_back(Value(tmp));
00620 tmp = 0 ;
00621 }
00622 }
00623 }
00624 }
00625
00626 template <typename T> void DataOperations<T>::sum() {
00627 T tmp = 0;
00628 vector<Value> tmp_vec;
00629 if (columns){
00630 if (isJoined){
00631 if (dim[0].size() > 0){
00632 tmp_vec.resize(dim[0][0]);
00633 for(size_t i = 0; i < dim.size(); i++) {
00634 for(size_t j = 0; j < dim[i].size(); j++) {
00635 for(size_t k = 0; k < dim[i][j]; k++) {
00636 if (all_values[i][j][k].isNumber){
00637 tmp_vec[k].val += all_values[i][j][k].val;
00638 tmp_vec[k].isNumber = true;
00639 }
00640 }
00641 }
00642 }
00643 all_values[dim.size()-1].push_back(tmp_vec);
00644 }
00645 }
00646 else {
00647 for(size_t i = 0; i < dim.size(); i++) {
00648 if (dim[0].size() > 0){
00649 tmp_vec.clear();
00650 tmp_vec.resize(dim[i][0]);
00651 for(size_t j = 0; j < dim[i].size(); j++) {
00652 for(size_t k = 0; k < dim[i][j]; k++) {
00653 if (all_values[i][j][k].isNumber){
00654 tmp_vec[k].val += all_values[i][j][k].val;
00655 tmp_vec[k].isNumber = true;
00656 }
00657 }
00658 }
00659 all_values[i].push_back(tmp_vec);
00660 }
00661 }
00662 }
00663 }
00664 else {
00665 for(size_t i = 0; i < dim.size(); i++) {
00666 for(size_t j = 0; j < dim[i].size(); j++) {
00667 for(size_t k = 0; k < dim[i][j]; k++) {
00668 if (all_values[i][j][k].isNumber){
00669 tmp += all_values[i][j][k].val;
00670 }
00671 }
00672 all_values[i][j].push_back(Value(tmp));
00673 tmp = 0 ;
00674 }
00675 }
00676 }
00677 }
00678
00679 template <typename T> void DataOperations<T>::deviation() {
00680 T tmp = 0;
00681 T tmp2 = 0;
00682 int l = 0;
00683 vector<Value> tmp_vec;
00684 vector<Value> tmp_vec2;
00685 vector<int> x;
00686 if (columns){
00687 if (isJoined){
00688 if (dim[0].size() > 0){
00689 tmp_vec.resize(dim[0][0]);
00690 tmp_vec2.resize(dim[0][0]);
00691 x.resize(dim[0][0]);
00692 for(size_t i = 0; i < dim.size(); i++) {
00693 for(size_t j = 0; j < dim[i].size(); j++) {
00694 for(size_t k = 0; k < dim[i][j]; k++) {
00695 if (all_values[i][j][k].isNumber){
00696 tmp_vec[k].val += all_values[i][j][k].val;
00697 tmp_vec[k].isNumber = true;
00698 tmp_vec2[k].val += all_values[i][j][k].val*all_values[i][j][k].val;
00699 tmp_vec2[k].isNumber = true;
00700 x[k]++;
00701 }
00702 }
00703 }
00704 }
00705 for(size_t i = 0; i < dim.size(); i++) {
00706 for(size_t j = 0; j < dim[i].size(); j++) {
00707 for(size_t k = 0; k < dim[i][j]; k++) {
00708 if (x[k] > 0 && tmp_vec[k].isNumber){
00709 tmp_vec[k].val = (T) (tmp_vec[k].val / (double)x[k]);
00710 tmp_vec[k].val *= tmp_vec[k].val;
00711 tmp_vec2[k].val = (T) (tmp_vec2[k].val / (double)x[k]);
00712 tmp_vec[k].val = tmp_vec2[k].val-tmp_vec[k].val;
00713 tmp_vec[k].val = (T) ( tmp_vec[k].val*x[k]/(double)(x[k]-1) );
00714 tmp_vec[k].val = (T) sqrt(tmp_vec[k].val);
00715 x[k] = -1;
00716 }
00717 }
00718 }
00719 }
00720 all_values[dim.size()-1].push_back(tmp_vec);
00721 }
00722 }
00723 else {
00724 for(size_t i = 0; i < dim.size(); i++) {
00725 if (dim[0].size() > 0){
00726 tmp_vec.clear();
00727 tmp_vec.resize(dim[i][0]);
00728 tmp_vec2.clear();
00729 tmp_vec2.resize(dim[i][0]);
00730 x.clear();
00731 x.resize(dim[0][0]);
00732 for(size_t j = 0; j < dim[i].size(); j++) {
00733 for(size_t k = 0; k < dim[i][j]; k++) {
00734 if (all_values[i][j][k].isNumber){
00735 tmp_vec[k].val += all_values[i][j][k].val;
00736 tmp_vec[k].isNumber = true;
00737 tmp_vec2[k].val += all_values[i][j][k].val*all_values[i][j][k].val;
00738 tmp_vec2[k].isNumber = true;
00739 x[k]++;
00740 }
00741 }
00742 }
00743 for(size_t k = 0; k < dim[i][0]; k++) {
00744 if (x[k] > 0 && tmp_vec[k].isNumber){
00745 tmp_vec[k].val = (T) (tmp_vec[k].val / (double)x[k]);
00746 tmp_vec[k].val *= tmp_vec[k].val;
00747 tmp_vec2[k].val = (T) (tmp_vec2[k].val / (double)x[k]);
00748 tmp_vec[k].val = tmp_vec2[k].val - tmp_vec[k].val;
00749 tmp_vec[k].val = (T) ( tmp_vec[k].val*x[k] / (double)(x[k]-1) );
00750 tmp_vec[k].val = (T) sqrt(tmp_vec[k].val);
00751 x[k] = -1;
00752 }
00753 }
00754 all_values[i].push_back(tmp_vec);
00755 }
00756 }
00757 }
00758 }
00759 else {
00760 for(size_t i = 0; i < dim.size(); i++) {
00761 for(size_t j = 0; j < dim[i].size(); j++) {
00762 for(size_t k = 0; k < dim[i][j]; k++) {
00763 if (all_values[i][j][k].isNumber){
00764 tmp += all_values[i][j][k].val;
00765 tmp2 += all_values[i][j][k].val*all_values[i][j][k].val;
00766 l++;
00767 }
00768 }
00769 tmp = (T) (tmp/double(l));
00770 tmp *= tmp;
00771 tmp2 = (T) (tmp2/double(l));
00772 tmp = tmp2-tmp;
00773 tmp = (T) ( tmp*l/(double(l)-1) );
00774 tmp = (T) sqrt(tmp);
00775 all_values[i][j].push_back(Value(tmp));
00776 tmp = 0 ;
00777 tmp2 = 0 ;
00778 l = 0;
00779 }
00780 }
00781 }
00782 }
00783
00784 template <typename T> void DataOperations<T>::median() {
00785 vector<Value> tmp_vec;
00786 vector<T> x;
00787 vector< vector<T> > y;
00788 T tmp;
00789 if (columns){
00790 if (isJoined){
00791 if (dim[0].size() > 0){
00792 tmp_vec.resize(dim[0][0]);
00793 y.resize(dim[0][0]);
00794 for(size_t i = 0; i < dim.size(); i++) {
00795 for(size_t j = 0; j < dim[i].size(); j++) {
00796 for(size_t k = 0; k < dim[i][j]; k++) {
00797 if (all_values[i][j][k].isNumber){
00798 y[k].push_back(all_values[i][j][k].val);
00799 }
00800 }
00801 }
00802 }
00803 for(size_t k = 0; k < dim[0][0]; k++) {
00804 sort(y[k].begin(), y[k].end());
00805 }
00806 for(size_t k = 0; k < dim[0][0]; k++) {
00807 if (y[k].size()%2 == 1){
00808 tmp_vec[k].val = y[k][y[k].size()/2];
00809 tmp_vec[k].isNumber = true;
00810 }
00811 else {
00812 tmp_vec[k].val = (y[k][(y[k].size()/2)-1] + y[k][y[k].size()/2])/2;
00813 tmp_vec[k].isNumber = true;
00814 }
00815 }
00816 all_values[dim.size()-1].push_back(tmp_vec);
00817 }
00818 }
00819 else {
00820 for(size_t i = 0; i < dim.size(); i++) {
00821 if (dim[0].size() > 0){
00822 tmp_vec.clear();
00823 tmp_vec.resize(dim[i][0]);
00824 y.clear();
00825 y.resize(dim[i][0]);
00826 for(size_t j = 0; j < dim[i].size(); j++) {
00827 for(size_t k = 0; k < dim[i][0]; k++) {
00828 if (all_values[i][j][k].isNumber){
00829 y[k].push_back(all_values[i][j][k].val);
00830 }
00831 }
00832 }
00833 for(size_t k = 0; k < dim[i][0]; k++) {
00834 sort(y[k].begin(), y[k].end());
00835 }
00836 for(size_t k = 0; k < dim[i][0]; k++) {
00837 if (y[k].size()%2 == 1){
00838 tmp_vec[k].val = y[k][y[k].size()/2];
00839 tmp_vec[k].isNumber = true;
00840 }
00841 else {
00842 tmp_vec[k].val = (y[k][(y[k].size()/2)-1] + y[k][y[k].size()/2])/2;
00843 tmp_vec[k].isNumber = true;
00844 }
00845 }
00846 all_values[i].push_back(tmp_vec);
00847 }
00848 }
00849 }
00850 }
00851 else {
00852 for(size_t i = 0; i < dim.size(); i++) {
00853 for(size_t j = 0; j < dim[i].size(); j++) {
00854 for(size_t k = 0; k < dim[i][j]; k++) {
00855 if (all_values[i][j][k].isNumber){
00856 x.push_back(all_values[i][j][k].val);
00857 }
00858 }
00859 sort(x.begin(), x.end());
00860 if (x.size()%2 == 1){
00861 tmp = x[x.size()/2];
00862 }
00863 else {
00864 tmp = (x[(x.size()/2)-1] + x[x.size()/2])/2;
00865 }
00866 all_values[i][j].push_back(Value(tmp));
00867 x.clear();
00868 }
00869 }
00870 }
00871 }
00872
00873 template <typename T> void DataOperations<T>::printOut() {
00874 if (file_out.size() == 0) {
00875 printToStd();
00876 }
00877 else if (file_out.size() == 1 && (isJoined || file_names.size() == 1)) {
00878 printToFile();
00879 }
00880 else if (file_names.size() == file_out.size()) {
00881 printToFiles();
00882 }
00883 else {
00884 int c = 1;
00885 while(c) {
00886 cout << "\nWARNING!!!Output and input file lists doesnt match to any standard pattern \nYou have three options:\n1. Print all to standard output.\n2. Print all to first file on the output file list.\n\n0. Exit without saving.\n(select 1, 2 or 0): ";
00887 cin >> c;
00888 switch (c) {
00889 case 1:
00890 printToStd();
00891 c = 0;
00892 break;
00893 case 2:
00894 printToFile();
00895 c = 0;
00896 break;
00897 case 0:
00898 break;
00899 default:
00900 break;
00901 }
00902 }
00903 }
00904 }
00905
00906 template <typename T> void DataOperations<T>::commOut(ostream* out) {
00907 time_t rawtime;
00908 struct tm* timeinfo;
00909 string temp;
00910 if (isMerged) {
00911 temp = "# Data from files: ";
00912 for (size_t i = 0; i < file_names.size(); i++){
00913 temp += file_names[i];
00914 if (i < file_names.size()-1) temp += ",";
00915 temp += " ";
00916 }
00917 }
00918 if (commentMode >= 0){
00919 time(&rawtime);
00920 timeinfo = localtime(&rawtime);
00921 if (isJoined){
00922 *out << "#" << command << endl;
00923 *out << "#" << asctime(timeinfo) << endl;
00924 if (isMerged) *out << temp << endl;
00925 if (commentMode == 1){
00926 for(size_t i = 0; i < all_comments.size(); i++) {
00927 *out << all_comments[i][0] << endl;
00928 }
00929 }
00930 else if (commentMode == 2){
00931 for(size_t i = 0; i < all_comments.size(); i++) {
00932 for(size_t j = 0; j < all_comments[i].size(); j++) {
00933 *out << all_comments[i][j] << endl;
00934 }
00935 }
00936 }
00937 }
00938 }
00939 }
00940
00941 template <typename T> void DataOperations<T>::commIn(ostream* out, int i) {
00942 time_t rawtime;
00943 struct tm* timeinfo;
00944 string temp;
00945 if (isMerged) {
00946 temp = "# Data from files: ";
00947 for (size_t i = 0; i < file_names.size(); i++){
00948 temp += file_names[i];
00949 if (i < file_names.size()-1) temp += ",";
00950 temp += " ";
00951 }
00952 }
00953 if (!isJoined && commentMode >= 0){
00954 time(&rawtime);
00955 timeinfo = localtime(&rawtime);
00956 if (!i){
00957 *out << "#" << command << endl;
00958 *out << "#" << asctime(timeinfo) << endl;
00959 if (isMerged) *out << temp << endl;
00960 }
00961 if (commentMode == 1){
00962 *out << all_comments[i][0] << endl;
00963 }
00964 else if (commentMode == 2){
00965 for(size_t j = 0; j < all_comments[i].size(); j++) {
00966 *out << all_comments[i][j] << endl;
00967 }
00968 }
00969 }
00970 }
00971
00972 template <typename T> void DataOperations<T>::printToStd() {
00973 commOut(&cout);
00974 for(size_t i = 0; i < all_values.size(); i++) {
00975 if (all_values.size() < all_comments.size()){
00976 for (size_t f; f < all_comments.size(); f++){
00977 commIn(&cout, f);
00978 }
00979 }
00980 else {
00981 commIn(&cout, i);
00982 }
00983 for(size_t j = 0; j < all_values[i].size(); j++) {
00984 for(size_t k = 0; k < all_values[i][j].size(); k++) {
00985 if (all_values[i][j][k].isNumber) {
00986 if (precision > 0) {
00987 cout << setiosflags(ios::showpoint) << setprecision(precision) << all_values[i][j][k].val;
00988 }
00989 else {
00990 cout << all_values[i][j][k].val;
00991 }
00992 }
00993 else cout << blank;
00994 if (tabulator) cout << "\t";
00995 else cout << " ";
00996 }
00997 cout << endl;
00998 }
00999 if (!isJoined) cout << endl;
01000 }
01001
01002 }
01003
01004 template <typename T> void DataOperations<T>::printToFile() {
01005 ofstream outfile;
01006 outfile.open(file_out[0].c_str());
01007 commOut(&outfile);
01008 for(size_t i = 0; i < all_values.size(); i++) {
01009 if (all_values.size() < all_comments.size()){
01010 for (size_t f; f < all_comments.size(); f++){
01011 commIn(&outfile, f);
01012 }
01013 }
01014 else {
01015 commIn(&outfile, i);
01016 }
01017 for(size_t j = 0; j < all_values[i].size(); j++) {
01018 for(size_t k = 0; k < all_values[i][j].size(); k++) {
01019 if (all_values[i][j][k].isNumber) {
01020 if (precision > 0) {
01021 outfile << setiosflags(ios::showpoint) << setprecision(precision) << all_values[i][j][k].val;
01022 }
01023 else {
01024 outfile << all_values[i][j][k].val;
01025 }
01026 }
01027 else outfile << blank;
01028 if (tabulator) outfile << "\t";
01029 else outfile << " ";
01030 }
01031 outfile << endl;
01032 }
01033 if (!isJoined) outfile << endl;
01034 }
01035 }
01036
01037 template <typename T> void DataOperations<T>::printToFiles() {
01038 ofstream outfile;
01039 for(size_t i = 0; i < all_values.size(); i++) {
01040 outfile.open(file_out[i].c_str());
01041 commIn(&outfile, i);
01042 for(size_t j = 0; j < all_values[i].size(); j++) {
01043 for(size_t k = 0; k < all_values[i][j].size(); k++) {
01044 if (all_values[i][j][k].isNumber) {
01045 if (precision > 0) {
01046 outfile << setiosflags(ios::showpoint) << setprecision(precision) << all_values[i][j][k].val;
01047 }
01048 else {
01049 outfile << all_values[i][j][k].val;
01050 }
01051 }
01052 else outfile << blank;
01053 if (tabulator) outfile << "\t";
01054 else outfile << " ";
01055 }
01056 outfile << endl;
01057 }
01058 outfile.close();
01059 }
01060 }
01061
01062 template <typename T> void DataOperations<T>::setOutputFiles(string names) {
01063 char delim = ',';
01064 string name;
01065 istringstream iss(names);
01066 while (getline(iss, name, delim)) {
01067 file_out.push_back(name);
01068 }
01069 }
01070
01071
01072
01073
01074
01075
01076 template <typename T> void DataOperations<T>::setFilter(string arg) {
01077 int z, outt;
01078 double val1, val2;
01079 char *war1 = new char[2];
01080 char *war2 = new char[2];
01081 char *tmp = new char[100];
01082 char *tmp2 = new char[100];
01083 c = '0';
01084 int aa;
01085 const char *b = arg.c_str();
01086 z = sscanf(b, "%d,%2s%lf,%s", &aa, war1, &val1, tmp);
01087 col_cond = aa;
01088 if(z < 3 || (strcmp(war1, "lt") && strcmp(war1, "gt") && strcmp(war1, "le") && strcmp(war1, "ge") && strcmp(war1, "eq") && strcmp(war1, "ne"))) {
01089 cerr << "Wrong filtr argument" << endl;
01090 exit(1);
01091 }
01092 col_cond--;
01093 kind_of_cond.push_back(string(war1));
01094 conditions.push_back(val1);
01095 z = sscanf(tmp, "%c", &c);
01096 if(c != '0') {
01097 if(c == 'o' || c == 'a') {
01098 strcpy(tmp2, tmp);
01099 strcpy(tmp, "");
01100 z = sscanf(tmp2, "%*c,%2s%lf,%s", war2, &val2, tmp);
01101 if((z < 2 && !strcmp(tmp, "")) || (strcmp(war2, "lt") && strcmp(war2, "gt") && strcmp(war2, "le") && strcmp(war2, "ge") && strcmp(war2, "eq") && strcmp(war1, "ne"))) {
01102 cerr << "Wrong filtr argument" << endl;
01103 exit(1);
01104 }
01105 kind_of_cond.push_back(string(war2));
01106 conditions.push_back(val2);
01107 }
01108 else {
01109 cerr << "Wrong filtr argument" << endl;
01110 exit(1);
01111 }
01112 }
01113 if(strcmp(tmp, "")) {
01114 while(strcmp(tmp, "")) {
01115 strcpy(tmp2, tmp);
01116 strcpy(tmp, "");
01117 z = sscanf(tmp2, "%d,%s", &outt, tmp);
01118 if((z<1 && !strcmp(tmp, ""))) {
01119 cerr << "Wrong filtr argument" << endl;
01120 exit(1);
01121 }
01122 out.push_back(--outt);
01123 }
01124 }
01125 startFiltering();
01126 }
01127
01128 template <typename T> size_t DataOperations<T>::startFiltering() {
01129 size_t a = 0;
01130 tab_tmp.clear();
01131 for(size_t i = 0; i < all_values.size(); i++) {
01132 for(size_t j = 0; j < all_values[i].size(); j++) {
01133 for(size_t k = 0; k < kind_of_cond.size(); k++) {
01134 if(all_values[i][j].size() <= col_cond || !all_values[i][j][col_cond].isNumber) {
01135 a = 0;
01136 break;
01137 }
01138 if(kind_of_cond[k].compare("eq") == 0) {
01139 if( fabs(all_values[i][j][col_cond].val-conditions[k]) <= conditions[k]+tolerance-conditions[k] ) a++;
01140 else a = 0;
01141 }
01142 else if(kind_of_cond[k].compare("lt") == 0) {
01143 if(all_values[i][j][col_cond].val < conditions[k]+tolerance) a++;
01144 else a = 0;
01145 }
01146 else if(kind_of_cond[k].compare("le") == 0) {
01147 T x = (T) conditions[k]+tolerance;
01148 if(all_values[i][j][col_cond].val <= x) a++;
01149 else a = 0;
01150 }
01151 else if(kind_of_cond[k].compare("gt") == 0) {
01152 if(all_values[i][j][col_cond].val > conditions[k]-tolerance) a++;
01153 else a = 0;
01154 }
01155 else if(kind_of_cond[k].compare("ge") == 0) {
01156 if(all_values[i][j][col_cond].val >= conditions[k]-tolerance) a++;
01157 else a = 0;
01158 }
01159 else if(kind_of_cond[k].compare("ne") == 0) {
01160 if( fabs(all_values[i][j][col_cond].val-conditions[k]) > tolerance) a++;
01161 else a = 0;
01162 }
01163 if(c == 'o') {
01164 if(a != 0) break;
01165 }
01166 else if(c == 'a') {
01167 if(a == 0) break;
01168 }
01169 }
01170 if(a != 0) {
01171 vall_tmp.clear();
01172 if(out.size() > 0) {
01173 for(size_t l = 0; l < out.size(); l++){
01174 if(all_values[i][j].size() > out[l]) {
01175 vall_tmp.push_back(all_values[i][j][out[l]]);
01176 }
01177 }
01178 }
01179 else {
01180 for(size_t l = 0; l < all_values[i][j].size(); l++){
01181 vall_tmp.push_back(all_values[i][j][l]);
01182 }
01183 }
01184 tab_tmp.push_back(vall_tmp);
01185 }
01186 }
01187 }
01188 all_values.clear();
01189 all_values.push_back(tab_tmp);
01190 return 0;
01191 }
01192
01193 template <typename T> void DataOperations<T>::group(string arg) {
01194 size_t col;
01195 if (arg.compare("f") == 0){
01196 for(size_t i = 1; i < all_values.size(); i++) {
01197 for(size_t j = 0; j < all_values[i].size(); j++) {
01198 for(size_t k = 0; k < all_values[i][j].size(); k++) {
01199 all_values[0][j].push_back(all_values[i][j][k]);
01200 }
01201 all_values[i][j].clear();
01202 }
01203 all_values[i].clear();
01204 }
01205 all_values.resize(1);
01206 }
01207 else {
01208 col = atoi(arg.c_str());
01209 if (col > 0){
01210 col--;
01211 bool r = true;
01212 typedef map< T, vector<Value> > Mymap;
01213 Mymap m;
01214 for(size_t i = 0; i < all_values.size(); i++) {
01215 for(size_t j = 0; j < all_values[i].size(); j++) {
01216 if ( col < all_values[i][0].size() ){
01217 r = false;
01218 for(size_t k = 0; k < all_values[i][j].size(); k++) {
01219 if (k != col && all_values[i][j][col].isNumber){
01220 m[ all_values[i][j][col].val ].push_back(all_values[i][j][k]);
01221 }
01222 }
01223 }
01224 }
01225 }
01226 if (r) {
01227 cerr << "Wrong group argument" << endl;
01228 exit(1);
01229 }
01230 tab_tmp.clear();
01231 typename Mymap::iterator it;
01232 for (it = m.begin(); it != m.end(); it++){
01233 T i = (*it).first;
01234 m[i].insert(m[i].begin(), Value(i));
01235 tab_tmp.push_back(m[i]);
01236 }
01237 all_values.clear();
01238 all_values.push_back(tab_tmp);
01239 fillInBlanks();
01240 }
01241 else {
01242 cerr << "Wrong group argument" << endl;
01243 exit(1);
01244 }
01245 }
01246 }
01247
01248 template <typename T> void DataOperations<T>::comments(string arg){
01249 if (arg.compare("off") == 0){
01250 commentMode = -1;
01251 }
01252 else if (arg.compare("all") == 0){
01253 commentMode = 2;
01254 }
01255 else if (arg.compare("1") == 0){
01256 commentMode = 1;
01257 }
01258 else {
01259 cerr << "Wrong comments argument" << endl;
01260 exit(1);
01261 }
01262 }
01263
01264 template <typename T> void DataOperations<T>::calculate(string arg){
01265 if (arg.size() < 10 || arg.size() > 0){
01266 dim.clear();
01267 dim.resize(all_values.size());
01268 for(size_t i = 0; i < all_values.size(); i++) {
01269 dim[i].resize(all_values[i].size());
01270 for(size_t j = 0; j < all_values[i].size(); j++) {
01271 dim[i][j] = all_values[i][j].size();
01272 }
01273 }
01274 string calc(arg);
01275 while (calc.size()){
01276 switch (calc[0]) {
01277 case 'a':
01278 mean();
01279 break;
01280 case 'c':
01281 count();
01282 break;
01283 case 'd':
01284 deviation();
01285 break;
01286 case 'm':
01287 median();
01288 break;
01289 case 's':
01290 sum();
01291 break;
01292 default:
01293 cerr << "Wrong calculate argument" << endl;
01294 exit(1);
01295 }
01296 if (calc[1] == ','){
01297 calc = calc.substr(2);
01298 }
01299 else if (calc.size() != 1){
01300 cerr << "Wrong calculate argument" << endl;
01301 exit(1);
01302 }
01303 else{
01304 calc = "";
01305 }
01306 }
01307 }
01308 else {
01309 cerr << "Wrong calculate argument" << endl;
01310 exit(1);
01311 }
01312 }
01313
01314 template <typename T> void DataOperations<T>::print(string arg){
01315 string prt(arg);
01316 string tmp;
01317 vector< vector<Value> > tmp_vec;
01318 vector< size_t > pa;
01319 vector<string> what;
01320 bool isParam = false;
01321 while (prt.size()){
01322 int k;
01323 if (prt.find_first_of(",") != string::npos){
01324 k = prt.find_first_of(",");
01325 if (k == 0){
01326 cerr << "Wrong print argument" << endl;
01327 exit(1);
01328 }
01329 tmp = prt.substr(0, k);
01330 what.push_back(tmp);
01331 prt = prt.substr(k+1);
01332 }
01333 else if (prt.size() > 0){
01334 what.push_back(prt);
01335 prt = "";
01336 }
01337 else {
01338 cerr << "Wrong print argument" << endl;
01339 exit(1);
01340 }
01341 }
01342 bool f_n = true;
01343 for (size_t w = 0; w < what.size(); w++){
01344 isParam = false;
01345 size_t col = atoi(what[w].c_str());
01346 if(col == 0 && (what[w] == "0" || what[w].find("0.0") == 0)) {
01347 cerr << "Wrong print argument" << endl;
01348 exit(1);
01349 }
01350 else if (col == 0) {
01351 for (size_t p = 0; p < all_param.size(); p++){
01352 if (all_param[p].count(what[w])) isParam = true;
01353 }
01354 if (!isParam){
01355 cerr << "Wrong print argument" << endl;
01356 exit(1);
01357 }
01358 else pa.push_back(w);
01359 }
01360 else {
01361 col--;
01362 }
01363 size_t l = 1;
01364 if (!isParam){
01365 for(size_t i = 0; i < all_values.size(); i++) {
01366 for(size_t j = 0; j < all_values[i].size(); j++) {
01367 if (f_n) tmp_vec.resize(l);
01368 if (col < all_values[i][j].size()){
01369 for(size_t k = 0; k < all_values[i][j].size(); k++) {
01370 if (k == col){
01371 tmp_vec[l-1].push_back(all_values[i][j][k]);
01372 }
01373 }
01374 }
01375 else {
01376 tmp_vec[l-1].push_back(Value());
01377 }
01378 l++;
01379 }
01380 }
01381 f_n = false;
01382 }
01383 }
01384 bool p_only = false;
01385 if (tmp_vec.size() == 0){
01386 tmp_vec.resize(all_values.size());
01387 p_only = true;
01388 }
01389 if (p_only){
01390 for (size_t w = 0; w < pa.size(); w++){
01391 size_t a_f = 0;
01392 for(size_t i = 0; i < tmp_vec.size(); i++){
01393 if (all_param[i].count( what[ pa[w] ] ) ){
01394 tmp_vec[i].push_back(Value( (T) all_param[a_f][what[ pa[w] ]]));
01395 }
01396 else {
01397 tmp_vec[i].push_back(Value());
01398 }
01399 a_f++;
01400 }
01401 }
01402 }
01403 else {
01404 for (size_t w = 0; w < pa.size(); w++){
01405 size_t a_f = 0;
01406 for(size_t i = 0; i < tmp_vec.size(); i++){
01407 size_t p = 0;
01408 for (size_t f = 0; f < a_f+1; f++) p += all_values[f].size();
01409 if (i == p) a_f++;
01410 typename vector<Value>::iterator it;
01411 for(size_t j = 0; j < tmp_vec[i].size(); j++){
01412 it = tmp_vec[i].begin();
01413 for(size_t k = 0; k < j; k++) it++;
01414 if (pa[w] == j){
01415 if (all_param[a_f].count(what[ pa[w] ])){
01416 tmp_vec[i].insert(it, Value( (T) all_param[a_f][what[ pa[w] ]]));
01417 }
01418 else {
01419 tmp_vec[i].insert(it, Value());
01420 }
01421 }
01422 else if (pa[w] == tmp_vec[i].size()){
01423 if (all_param[a_f].count(what[ pa[w] ])){
01424 tmp_vec[i].push_back(Value( (T) all_param[a_f][what[ pa[w] ]]));
01425 }
01426 else {
01427 tmp_vec[i].push_back(Value());
01428 }
01429 break;
01430 }
01431 }
01432 }
01433 }
01434 }
01435
01436 all_values.clear();
01437 all_values.push_back(tmp_vec);
01438 }
01439
01440 template <typename T> void DataOperations<T>::merge(){
01441 isMerged = true;
01442 for(size_t i = 0; i < all_values.size(); i++) {
01443 for(size_t j = 0; j < all_values[i].size(); j++) {
01444 if (isJoined){
01445 all_values[i][j].insert(all_values[i][j].begin(), Value(1));
01446 }
01447 else {
01448 all_values[i][j].insert(all_values[i][j].begin(), Value(i+1));
01449 }
01450 }
01451 }
01452 }