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