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() {
 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(3) << value_arr[ii];
 184                         ret_val.append("|");
 185                         ret_val.append(out.str());
 186                 }
 187                 if (unit.empty() == false) {
 188                         ret_val.append(" ");
 189                         ret_val.append(unit.c_str());
 190                 }
 191         }
 192         return ret_val;
 193 }
 194
 195 DataRange::DataRange(Data *data) {
 196         val_matrix      = NULL;
 197         column_count    = data->value_arr.size();
 198         row_count       = 0;
 199         unit            = data->get_unit();
 200         add_data(data);
 201 }
 202
 203 DataRange::DataRange(int value_count_per_data_item, string unit_param) {
 204         val_matrix      = NULL;
 205         column_count    = value_count_per_data_item;
 206         row_count       = 0;
 207         unit            = unit_param;
 208 }
 209
 210 DataRange::~DataRange() {
 211         unsigned int    ii;
 212         Date            *date;
 213
 214         if (val_matrix != NULL) {
 215                 free(val_matrix);
 216                 val_matrix      = NULL;
 217         }
 218         for (ii = 0; ii < date_list.size(); ii++) {
 219                 date    = date_list.at(ii);
 220                 delete(date);
 221         }
 222 }
 223
 224 void DataRange::add_data(Data *data) {
 225         int     ii;
 226         int     indx;
 227         Date    *date;
 228         int     cnt;
 229
 230         //log_debug("old row_count: %d, column_count: %d, value_arr_size: %d\n", row_count, column_count, data.value_arr.size());
 231         cnt             = (row_count + 1) * column_count;
 232         val_matrix      = (double *)realloc(val_matrix, cnt * sizeof(double));
 233         indx            = row_count * column_count;
 234         cnt             = data->value_arr.size();
 235         if (cnt != column_count) {
 236                 log_error("Error when adding data... Invalid data item count!\n");
 237                 if (cnt > column_count) {
 238                         cnt     = column_count;
 239                 }
 240                 else {
 241                         for (ii = cnt; ii < column_count; ii++) {
 242                                 val_matrix[indx + ii]   = 0;
 243                         }
 244                 }
 245         }
 246         for (ii = 0; ii < cnt; ii++) {
 247                 val_matrix[indx + ii]   = data->value_arr[ii];
 248         }
 249 /*
 250         for (int ii = 0; ii < ((row_count + 1) * column_count); ii++) {
 251                 log_debug("data_matrix[%d] = %f\n", ii, val_matrix[ii]);
 252         }
 253 */
 254         date    = data->get_date().clone();
 255         date_list.push_back(date);
 256         row_count++;
 257 }
 258
 259 Data *DataRange::get_data(int row_index) {
 260         Data            *ret_val;
 261         int             start_indx;
 262         int             ii;
 263         vector<double>  vect;
 264         Date            *date;
 265         double          val;
 266
 267         ret_val = NULL;
 268         if ((row_index >= 0) &&
 269             (row_index < row_count)) {
 270                 start_indx      = row_index * column_count;
 271                 for (ii = 0; ii < column_count; ii++) {
 272                         //val   = val_matrix[0];
 273                         val     = val_matrix[start_indx + ii];
 274                         log_debug("val[%d] = %f\n", (start_indx + ii), val);
 275                         vect.push_back(val);
 276                 }
 277                 date    = date_list.at(row_index);
 278                 ret_val = new Data(&vect, date, unit);
 279         }
 280         return ret_val;
 281 }
 282
 283 int DataRange::get_data_row_count() {
 284         return row_count;
 285 }
 286
 287 int DataRange::get_data_column_count() {
 288         return column_count;
 289 }
 290
 291 Data *DataRange::get_first_data() {
 292         Data    *ret_val;
 293
 294         ret_val = NULL;
 295         if (row_count > 0) {
 296                 ret_val = get_data(0);
 297         }
 298         return ret_val;
 299 }
 300
 301 Data *DataRange::get_last_data() {
 302         return get_data(row_count - 1);
 303 }
 304
 305 void DataRange::printout() {
 306         int     ii;
 307         Data    *data;
 308
 309         log_debug("---- DataRange, number of data items: %d\n ----", row_count);
 310         for (ii = 0; ii < row_count; ii++) {
 311                 data    = get_data(ii);
 312                 if (data != NULL) {
 313                         data->printout();
 314                         delete(data);
 315                 }
 316         }
 317         log_debug("---- DataRange printout done ----\n");
 318 }