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 "log.h"
  18 #include "Data.hh"
  19 #include "Date.hh"
  20
  21 using namespace std;
  22 using namespace plp;
  23
  24 template <class NumberDataType>
  25 bool string_to_number(NumberDataType& result,
  26                  const string& string_param,
  27                  ios_base& (*format)(ios_base&))
  28 {
  29         istringstream iss(string_param);
  30         return !(iss >> format >> result).fail();
  31 }
  32
  33 Data::Data(int size) {
  34         value_arr.resize(size);
  35 }
  36
  37 Data::Data(int size,
  38         double default_value,
  39         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(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(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    = Date::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 int Data::get_value_count() {
 199         return value_arr.size();
 200 }
 201
 202 double Data::get(int indx) {
 203         return value_arr[indx];
 204 }
 205
 206 DataRange::DataRange() {
 207         val_matrix      = NULL;
 208         column_count    = 0;
 209         row_count       = 0;
 210         unit            = "";
 211 }
 212
 213 DataRange::DataRange(Data *data) {
 214         val_matrix      = NULL;
 215         row_count       = 0;
 216         if (data != NULL) {
 217                 column_count    = data->value_arr.size();
 218                 unit            = data->get_unit();
 219                 add(data);
 220         }
 221         else {
 222                 column_count    = 0;
 223                 unit            = "";
 224         }
 225 }
 226
 227 DataRange::DataRange(DataRange *datarange) {
 228         val_matrix      = NULL;
 229         row_count       = 0;
 230         column_count    = 0;
 231         unit            = "";
 232         if (datarange != NULL) {
 233                 add(datarange);
 234         }
 235 }
 236
 237 DataRange::DataRange(int value_count_per_data_item, string unit_param) {
 238         val_matrix      = NULL;
 239         column_count    = value_count_per_data_item;
 240         row_count       = 0;
 241         unit            = unit_param;
 242 }
 243
 244 DataRange::~DataRange() {
 245         unsigned int    ii;
 246         Date            *date;
 247
 248         if (val_matrix != NULL) {
 249                 free(val_matrix);
 250                 val_matrix      = NULL;
 251         }
 252         for (ii = 0; ii < date_list.size(); ii++) {
 253                 date    = date_list.at(ii);
 254                 delete(date);
 255         }
 256 }
 257
 258 void DataRange::add(Data *data) {
 259         int     ii;
 260         int     indx;
 261         Date    *date;
 262         int     cnt;
 263
 264         if (data != NULL) {
 265                 if ((val_matrix == NULL) &&
 266                     (column_count == 0) &&
 267                     (unit.empty() == true)) {
 268                         column_count    = data->value_arr.size();
 269                         unit            = data->get_unit();
 270                 }
 271                 cnt             = (row_count + 1) * column_count;
 272                 val_matrix      = (double *)realloc(val_matrix, cnt * sizeof(double));
 273                 indx            = row_count * column_count;
 274                 cnt             = data->value_arr.size();
 275                 if (cnt != column_count) {
 276                         log_error("Error when adding data... Invalid data item count!\n");
 277                         if (cnt > column_count) {
 278                                 cnt     = column_count;
 279                         }
 280                         else {
 281                                 for (ii = cnt; ii < column_count; ii++) {
 282                                         val_matrix[indx + ii]   = 0;
 283                                 }
 284                         }
 285                 }
 286                 for (ii = 0; ii < cnt; ii++) {
 287                         val_matrix[indx + ii]   = data->value_arr[ii];
 288                 }
 289 /*
 290                 for (int ii = 0; ii < ((row_count + 1) * column_count); ii++) {
 291                         log_debug("data_matrix[%d] = %f\n", ii, val_matrix[ii]);
 292                 }
 293 */
 294                 date    = data->get_date().clone();
 295                 date_list.push_back(date);
 296                 row_count++;
 297         }
 298 }
 299
 300 void DataRange::add(DataRange *datarange) {
 301         int     ii;
 302         int     cnt;
 303         Data    *dta;
 304
 305         if (datarange != NULL) {
 306                 cnt     = datarange->get_count();
 307                 for (ii = 0; ii < cnt; ii++) {
 308                         dta     = datarange->get(ii);
 309                         add(dta);
 310                         delete(dta);
 311                 }
 312         }
 313 }
 314
 315 Data *DataRange::get(int row_index) {
 316         Data            *ret_val;
 317         int             start_indx;
 318         int             ii;
 319         vector<double>  vect;
 320         Date            *date;
 321         double          val;
 322
 323         ret_val = NULL;
 324         if ((row_index >= 0) &&
 325             (row_index < row_count)) {
 326                 start_indx      = row_index * column_count;
 327                 for (ii = 0; ii < column_count; ii++) {
 328                         //val   = val_matrix[0];
 329                         val     = val_matrix[start_indx + ii];
 330                         //log_debug("val[%d] = %f\n", (start_indx + ii), val);
 331                         vect.push_back(val);
 332                 }
 333                 date    = date_list.at(row_index);
 334                 ret_val = new Data(&vect, date, unit);
 335         }
 336         return ret_val;
 337 }
 338
 339 int DataRange::get_count() {
 340         return row_count;
 341 }
 342
 343 int DataRange::get_data_item_value_count() {
 344         return column_count;
 345 }
 346
 347 Data *DataRange::get_first() {
 348         Data    *ret_val;
 349
 350         ret_val = NULL;
 351         if (row_count > 0) {
 352                 ret_val = get(0);
 353         }
 354         return ret_val;
 355 }
 356
 357 Data *DataRange::get_last() {
 358         return get(row_count - 1);
 359 }
 360
 361 void DataRange::printout() {
 362         int     ii;
 363         Data    *data;
 364
 365         log_debug("---- DataRange, number of data items: %d\n ----", row_count);
 366         for (ii = 0; ii < row_count; ii++) {
 367                 data    = get(ii);
 368                 if (data != NULL) {
 369                         data->printout();
 370                         delete(data);
 371                 }
 372         }
 373         log_debug("---- DataRange printout done ----\n");
 374 }