src/Data.cc

   1 /*
   2  * DataRange.cc
   3  *
   4  *  Created on: Dec 7, 2010
   5  *      Author: lamikr
   6  */
   7
   8 #include <string>
   9 #include <iostream>
  10 #include <sstream>
  11 #include <iomanip>
  12
  13 #include <stdio.h>
  14 #include <time.h>
  15 #include <malloc.h>
  16
  17 #include <plp/log.h>
  18
  19 #include "Data.hh"
  20 #include "W1Util.hh"
  21
  22 using namespace std;
  23 using namespace plp;
  24 using namespace w1;
  25
  26 template <class NumberDataType>
  27 bool string_to_number(NumberDataType& result,
  28                  const string& string_param,
  29                  std::ios_base& (*format)(std::ios_base&))
  30 {
  31         std::istringstream iss(string_param);
  32         return !(iss >> format >> result).fail();
  33 }
  34
  35 Data::Data(int size) {
  36         value_arr.resize(size);
  37 }
  38
  39 Data::Data(int size, double default_value, string unit_param) {
  40         int ii;
  41
  42         value_arr.resize(size);
  43         for (ii = 0; ii < size; ii++) {
  44                 value_arr[ii]   = default_value;
  45         }
  46         unit    = unit_param;
  47 }
  48
  49 Data::Data(vector<double> *vect_param) {
  50         unsigned int    ii;
  51         unsigned int    sz;
  52
  53         sz      = vect_param->size();
  54         //log_debug("Data(), value count: %d\n", size);
  55         value_arr.resize(sz);
  56         for (ii = 0; ii < sz; ii++) {
  57                 value_arr[ii]   = vect_param->at(ii);
  58                 //log_debug("Data(), value[%d]: %f\n", ii, value_arr[ii]);
  59         }
  60 }
  61
  62 Data::Data(std::vector<double> *vector_param, string unit_param) {
  63         unsigned int    ii;
  64         unsigned int    sz;
  65
  66         sz      = vector_param->size();
  67         //log_debug("Data(), value count: %d\n", size);
  68         value_arr.resize(sz);
  69         for (ii = 0; ii < sz; ii++) {
  70                 value_arr[ii]   = vector_param->at(ii);
  71                 //log_debug("Data(), value[%d]: %f\n", ii, value_arr[ii]);
  72         }
  73         unit    = unit_param;
  74 }
  75
  76 Data::Data(vector<double> *vector_param,
  77                 Date *date_param,
  78                 string unit_param) {
  79         unsigned int    ii;
  80         unsigned int    size;
  81
  82         size    = vector_param->size();
  83         //log_debug("Data(), value count: %d\n", size);
  84         value_arr.resize(size);
  85         for (ii = 0; ii < size; ii++) {
  86                 value_arr[ii]   = vector_param->at(ii);
  87                 //log_debug("Data(), value[%d]: %f\n", ii, value_arr[ii]);
  88         }
  89         date_time.copy(date_param);
  90         unit    = unit_param;
  91 }
  92
  93 Data::Data(std::valarray<double> *val_arr_param, Date *date_param) {
  94         unsigned int    ii;
  95         unsigned int    sz;
  96
  97         sz      = val_arr_param->size();
  98         value_arr.resize(sz);
  99         for (ii = 0; ii < sz; ii++) {
 100                 value_arr[ii]   = (*val_arr_param)[ii];
 101         }
 102         date_time.copy(date_param);
 103 }
 104
 105 Data::~Data() {
 106 }
 107
 108 Data *Data::clone() {
 109         Data    *ret_val;
 110
 111         ret_val = new Data(&value_arr, &date_time);
 112         return ret_val;
 113 }
 114
 115 void Data::printout() {
 116         log_debug("  data: %s\n", to_string().c_str());
 117 }
 118
 119 plp::Date Data::get_date() {
 120         return date_time;
 121 }
 122
 123 void Data::set_date(Date *date_param) {
 124         date_time.copy(date_param);
 125 }
 126
 127 string Data::get_unit() {
 128         return unit;
 129 }
 130
 131 Data *Data::parse_string(const string& dataline) {
 132         stringstream    ss(dataline);
 133         string          item;
 134         double          val;
 135         Data            *ret_val;
 136         int             ii;
 137         int             sz;
 138         bool            suc_flg;
 139         vector<double>  v;
 140         string          unit;
 141         Date            date;
 142
 143         ii      = 0;
 144         ret_val = NULL;
 145         //log_debug("parse_string: %s\n", dataline.c_str());
 146         while(getline(ss, item, '|')) {
 147                 if (ii == 0) {
 148                         // parse date
 149                         date    = W1Util::parse_date_str(item);
 150                 }
 151                 else if (ii >= 1) {
 152                         suc_flg = string_to_number<double>(val, item, dec);
 153                         if (suc_flg) {
 154                                 //log_debug("adding number: %f\n", val);
 155                                 v.push_back(val);
 156                         }
 157                 }
 158                 ii++;
 159         }
 160         ii      = item.find_last_of(" ");
 161         sz      = item.size();
 162         if ((ii >= 0) &&
 163             ((ii + 1) <= (sz - 1))) {
 164                 unit    = item.substr(ii + 1);
 165         }
 166         else {
 167                 unit    = "";
 168         }
 169         if (v.size() > 0) {
 170                 ret_val = new Data(&v, &date, unit);
 171         }
 172         return ret_val;
 173 }
 174
 175 string Data::to_string(int dec_precision) {
 176         unsigned int    ii;
 177         ostringstream   out;
 178         string          ret_val;
 179
 180         ret_val = date_time.to_string();
 181         if (value_arr.size() > 0) {
 182                 for (ii = 0; ii < value_arr.size(); ii++) {
 183                         out << "|" << fixed << setprecision(dec_precision) << value_arr[ii];
 184                 }
 185                 ret_val.append(out.str());
 186                 if (unit.empty() == false) {
 187                         ret_val.append(" ");
 188                         ret_val.append(unit.c_str());
 189                 }
 190         }
 191         return ret_val;
 192 }
 193
 194 string Data::to_string() {
 195         return to_string(3);
 196 }
 197
 198 DataRange::DataRange() {
 199         val_matrix      = NULL;
 200         column_count    = 0;
 201         row_count       = 0;
 202         unit            = "";
 203 }
 204
 205 DataRange::DataRange(Data *data) {
 206         val_matrix      = NULL;
 207         row_count       = 0;
 208         if (data != NULL) {
 209                 column_count    = data->value_arr.size();
 210                 unit            = data->get_unit();
 211                 add(data);
 212         }
 213         else {
 214                 column_count    = 0;
 215                 unit            = "";
 216         }
 217 }
 218
 219 DataRange::DataRange(DataRange *datarange) {
 220         val_matrix      = NULL;
 221         row_count       = 0;
 222         column_count    = 0;
 223         unit            = "";
 224         if (datarange != NULL) {
 225                 add(datarange);
 226         }
 227 }
 228
 229 DataRange::DataRange(int value_count_per_data_item, string unit_param) {
 230         val_matrix      = NULL;
 231         column_count    = value_count_per_data_item;
 232         row_count       = 0;
 233         unit            = unit_param;
 234 }
 235
 236 DataRange::~DataRange() {
 237         unsigned int    ii;
 238         Date            *date;
 239
 240         if (val_matrix != NULL) {
 241                 free(val_matrix);
 242                 val_matrix      = NULL;
 243         }
 244         for (ii = 0; ii < date_list.size(); ii++) {
 245                 date    = date_list.at(ii);
 246                 delete(date);
 247         }
 248 }
 249
 250 void DataRange::add(Data *data) {
 251         int     ii;
 252         int     indx;
 253         Date    *date;
 254         int     cnt;
 255
 256         if (data != NULL) {
 257                 if ((val_matrix == NULL) &&
 258                     (column_count == 0) &&
 259                     (unit.empty() == true)) {
 260                         column_count    = data->value_arr.size();
 261                         unit            = data->get_unit();
 262                 }
 263                 cnt             = (row_count + 1) * column_count;
 264                 val_matrix      = (double *)realloc(val_matrix, cnt * sizeof(double));
 265                 indx            = row_count * column_count;
 266                 cnt             = data->value_arr.size();
 267                 if (cnt != column_count) {
 268                         log_error("Error when adding data... Invalid data item count!\n");
 269                         if (cnt > column_count) {
 270                                 cnt     = column_count;
 271                         }
 272                         else {
 273                                 for (ii = cnt; ii < column_count; ii++) {
 274                                         val_matrix[indx + ii]   = 0;
 275                                 }
 276                         }
 277                 }
 278                 for (ii = 0; ii < cnt; ii++) {
 279                         val_matrix[indx + ii]   = data->value_arr[ii];
 280                 }
 281 /*
 282                 for (int ii = 0; ii < ((row_count + 1) * column_count); ii++) {
 283                         log_debug("data_matrix[%d] = %f\n", ii, val_matrix[ii]);
 284                 }
 285 */
 286                 date    = data->get_date().clone();
 287                 date_list.push_back(date);
 288                 row_count++;
 289         }
 290 }
 291
 292 void DataRange::add(DataRange *datarange) {
 293         int     ii;
 294         int     cnt;
 295         Data    *dta;
 296
 297         if (datarange != NULL) {
 298                 cnt     = datarange->get_count();
 299                 for (ii = 0; ii < cnt; ii++) {
 300                         dta     = datarange->get(ii);
 301                         add(dta);
 302                         delete(dta);
 303                 }
 304         }
 305 }
 306
 307 Data *DataRange::get(int row_index) {
 308         Data            *ret_val;
 309         int             start_indx;
 310         int             ii;
 311         vector<double>  vect;
 312         Date            *date;
 313         double          val;
 314
 315         ret_val = NULL;
 316         if ((row_index >= 0) &&
 317             (row_index < row_count)) {
 318                 start_indx      = row_index * column_count;
 319                 for (ii = 0; ii < column_count; ii++) {
 320                         //val   = val_matrix[0];
 321                         val     = val_matrix[start_indx + ii];
 322                         //log_debug("val[%d] = %f\n", (start_indx + ii), val);
 323                         vect.push_back(val);
 324                 }
 325                 date    = date_list.at(row_index);
 326                 ret_val = new Data(&vect, date, unit);
 327         }
 328         return ret_val;
 329 }
 330
 331 int DataRange::get_count() {
 332         return row_count;
 333 }
 334
 335 int DataRange::get_data_item_value_count() {
 336         return column_count;
 337 }
 338
 339 Data *DataRange::get_first() {
 340         Data    *ret_val;
 341
 342         ret_val = NULL;
 343         if (row_count > 0) {
 344                 ret_val = get(0);
 345         }
 346         return ret_val;
 347 }
 348
 349 Data *DataRange::get_last() {
 350         return get(row_count - 1);
 351 }
 352
 353 void DataRange::printout() {
 354         int     ii;
 355         Data    *data;
 356
 357         log_debug("---- DataRange, number of data items: %d\n ----", row_count);
 358         for (ii = 0; ii < row_count; ii++) {
 359                 data    = get(ii);
 360                 if (data != NULL) {
 361                         data->printout();
 362                         delete(data);
 363                 }
 364         }
 365         log_debug("---- DataRange printout done ----\n");
 366 }