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
  12 #include <stdio.h>
  13 #include <time.h>
  14 #include <malloc.h>
  15
  16 #include <plp/log.h>
  17
  18 #include "Data.hh"
  19 #include "W1Util.hh"
  20
  21 using namespace std;
  22 using namespace plp;
  23 using namespace w1;
  24
  25 template <class NumberDataType>
  26 bool string_to_number(NumberDataType& result,
  27                  const std::string& string_param,
  28                  std::ios_base& (*format)(std::ios_base&))
  29 {
  30         std::istringstream iss(string_param);
  31         return !(iss >> format >> result).fail();
  32 }
  33
  34 Data::Data(int size) {
  35         value_arr.resize(size);
  36 }
  37
  38 Data::Data(int size, double default_value) {
  39         int ii;
  40
  41         value_arr.resize(size);
  42         for (ii = 0; ii < size; ii++) {
  43                 value_arr[ii]   = default_value;
  44         }
  45 }
  46
  47 Data::Data(vector<double> vector_param, Date *date_param) {
  48         unsigned int    ii;
  49         unsigned int    size;
  50
  51         size    = vector_param.size();
  52         //log_debug("Data(), value count: %d\n", size);
  53         value_arr.resize(size);
  54         for (ii = 0; ii < vector_param.size(); ii++) {
  55                 value_arr[ii]   = vector_param.at(ii);
  56                 //log_debug("Data(), value[%d]: %f\n", ii, value_arr[ii]);
  57         }
  58         date_time.copy(date_param);
  59 }
  60
  61 Data::Data(std::valarray<double> value_arr_param, Date *date_param) {
  62         unsigned int ii;
  63
  64         value_arr.resize(value_arr_param.size());
  65         for (ii = 0; ii < value_arr_param.size(); ii++) {
  66                 value_arr[ii]   = value_arr_param[ii];
  67         }
  68         date_time.copy(date_param);
  69 }
  70
  71 Data::~Data() {
  72 }
  73
  74 Data *Data::clone() {
  75         Data    *ret_val;
  76
  77         ret_val = new Data(value_arr, &date_time);
  78         return ret_val;
  79 }
  80
  81 plp::Date Data::get_date() {
  82         return date_time;
  83 }
  84
  85 void Data::set_date(plp::Date date) {
  86         date_time.copy(&date);
  87 }
  88
  89 void Data::printout() {
  90         unsigned int    ii;
  91
  92         date_time.printout();
  93         for (ii = 0; ii < value_arr.size(); ii++) {
  94                 log_debug("  data[%d] = %f\n", ii, value_arr[ii]);
  95         }
  96 }
  97
  98 Data *Data::parse_data_string(const string& dataline) {
  99         stringstream    ss(dataline);
 100         string          item;
 101         double          val;
 102         Data            *ret_val;
 103         int             ii;
 104         bool            suc_flg;
 105         vector<double>  v;
 106         Date            date;
 107
 108         ii      = 0;
 109         while(getline(ss, item, '|')) {
 110                 if (ii == 0) {
 111                         // parse date
 112                         date    = W1Util::parse_date_str(item);
 113                 }
 114                 else if (ii >= 1) {
 115                         suc_flg = string_to_number<double>(val, item, dec);
 116                         if (suc_flg) {
 117                                 //log_debug("adding number: %f\n", val);
 118                                 v.push_back(val);
 119                         }
 120                 }
 121                 ii++;
 122         }
 123         ret_val = new Data(v, &date);
 124         return ret_val;
 125 }
 126
 127 DataRange::DataRange(int value_count_per_data_item) {
 128         val_matrix      = NULL;
 129         column_count    = value_count_per_data_item;
 130         row_count       = 0;
 131 }
 132
 133 DataRange::DataRange(Data data) {
 134         val_matrix      = NULL;
 135         column_count    = data.value_arr.size();
 136         row_count       = 0;
 137         add_data(data);
 138 }
 139
 140 DataRange::~DataRange() {
 141         unsigned int    ii;
 142         Date            *date;
 143
 144         if (val_matrix != NULL) {
 145                 free(val_matrix);
 146                 val_matrix      = NULL;
 147         }
 148         for (ii = 0; ii < date_list.size(); ii++) {
 149                 date    = date_list.at(ii);
 150                 delete(date);
 151         }
 152 }
 153
 154 void DataRange::add_data(Data data) {
 155         unsigned int    ii;
 156         int             indx;
 157         Date            date;
 158
 159         //log_debug("old row_count: %d, column_count: %d, value_arr_size: %d\n", row_count, column_count, data.value_arr.size());
 160         val_matrix      = (double *)realloc(val_matrix, ((row_count + 1) * column_count) * sizeof(double));
 161         indx            = row_count * column_count;
 162         for (ii = 0; ii < data.value_arr.size(); ii++) {
 163                 val_matrix[indx + ii]   = data.value_arr[ii];
 164         }
 165 /*
 166         for (int ii = 0; ii < ((row_count + 1) * column_count); ii++) {
 167                 log_debug("data_matrix[%d] = %f\n", ii, val_matrix[ii]);
 168         }
 169 */
 170         date    = data.get_date();
 171         date_list.push_back(date.clone());
 172         row_count++;
 173 }
 174
 175 Data *DataRange::get_data(int row_index) {
 176         Data            *ret_val;
 177         int             start_indx;
 178         int             ii;
 179         vector<double>  vector;
 180         Date            *date;
 181
 182         ret_val = NULL;
 183         if ((row_index >= 0) &&
 184             (row_index < row_count)) {
 185                 start_indx      = row_index * column_count;
 186                 for (ii = 0; ii < column_count; ii++) {
 187                         vector.push_back(val_matrix[start_indx + ii]);
 188                 }
 189                 date    = date_list.at(row_index);
 190                 ret_val = new Data(vector, date);
 191         }
 192         return ret_val;
 193 }
 194
 195 int DataRange::get_data_row_count() {
 196         return row_count;
 197 }
 198
 199 int DataRange::get_data_column_count() {
 200         return column_count;
 201 }
 202
 203 Data *DataRange::get_first_data() {
 204         Data    *ret_val;
 205
 206         ret_val = NULL;
 207         if (row_count > 0) {
 208                 ret_val = get_data(0);
 209         }
 210         return ret_val;
 211 }
 212
 213 Data *DataRange::get_last_data() {
 214         return get_data(row_count - 1);
 215 }
 216
 217 void DataRange::printout() {
 218         int     ii;
 219         Data    *data;
 220
 221         log_debug("---- DataRange, number of data items: %d\n ----", row_count);
 222         for (ii = 0; ii < row_count; ii++) {
 223                 data    = get_data(ii);
 224                 if (data != NULL) {
 225                         data->printout();
 226                         delete(data);
 227                 }
 228         }
 229         log_debug("---- DataRange printout done ----\n");
 230 }