C++ API Reference for Intel® Data Analytics Acceleration Library 2019 Update 5

kdb_feature_manager.h
1 /* file: kdb_feature_manager.h */
2 /*******************************************************************************
3 * Copyright 2014-2019 Intel Corporation.
4 *
5 * This software and the related documents are Intel copyrighted materials, and
6 * your use of them is governed by the express license under which they were
7 * provided to you (License). Unless the License provides otherwise, you may not
8 * use, modify, copy, publish, distribute, disclose or transmit this software or
9 * the related documents without Intel's prior written permission.
10 *
11 * This software and the related documents are provided as is, with no express
12 * or implied warranties, other than those that are expressly stated in the
13 * License.
14 *******************************************************************************/
15 
16 /*
17 //++
18 // Implementation of the KDB data source class.
19 //--
20 */
21 #ifndef __KDB_FEATURE_MANAGER_H__
22 #define __KDB_FEATURE_MANAGER_H__
23 
24 #include "services/daal_memory.h"
25 #include "data_management/data_source/data_source.h"
26 #include "data_management/data/data_dictionary.h"
27 #include "data_management/data/numeric_table.h"
28 #include "data_management/data/homogen_numeric_table.h"
29 
30 #include <k.h>
31 
32 namespace daal
33 {
34 namespace data_management
35 {
36 
37 namespace interface1
38 {
43 class KDBFeatureManager
44 {
45 public:
46  KDBFeatureManager() : _errors(new services::ErrorCollection()) {}
47 
54  void createDictionaryFromTable(const K& table, DataSourceDictionary *dict)
55  {
56  K featureNames = kK(table)[0];
57  K featureData = kK(table)[1];
58  size_t nFeatures = featureNames->n;
59 
60  dict->setNumberOfFeatures( nFeatures );
61 
62  for(size_t i = 0; i < nFeatures; i++)
63  {
64  DataSourceFeature &feature = (*dict)[i];
65 
66  feature.setFeatureName(kS(featureNames)[i]);
67 
68  K column = kK(featureData)[i];
69 
70  switch(column->t)
71  {
72  case(KF): case(KZ):
73  feature.setType<double>();
74  break;
75  case(KE):
76  feature.setType<float>();
77  break;
78  case(KB): case(KG): case(KC):
79  feature.setType<char>();
80  break;
81  case(KH):
82  feature.setType<short>();
83  break;
84  case(KI): case(KM): case(KD): case(KU): case(KV): case(KT):
85  feature.setType<int>();
86  break;
87  case(KJ):
88  feature.setType<DAAL_INT64>();
89  break;
90  default:
91  _errors->add(services::ErrorKDBTypeUnsupported);
92  break;
93  }
94  }
95  }
96 
103  void createDictionaryFromList(const K& lst, DataSourceDictionary *dict)
104  {
105  size_t nFeatures = lst->n;
106 
107  dict->setNumberOfFeatures( nFeatures );
108 
109  for(size_t i = 0; i < nFeatures; i++)
110  {
111  DataSourceFeature &feature = (*dict)[i];
112 
113  I curType;
114 
115  if (lst->t == 0) curType = kK(lst)[i]->t; else curType = lst->t;
116 
117  if (curType < 0) curType = -curType;
118 
119  switch(curType)
120  {
121  case(KF): case(KZ):
122  feature.setType<double>();
123  break;
124  case(KE):
125  feature.setType<float>();
126  break;
127  case(KB): case(KG): case(KC):
128  feature.setType<char>();
129  break;
130  case(KH):
131  feature.setType<short>();
132  break;
133  case(KI): case(KM): case(KD): case(KU): case(KV): case(KT):
134  feature.setType<int>();
135  break;
136  case(KJ):
137  feature.setType<DAAL_INT64>();
138  break;
139  default:
140  _errors->add(services::ErrorKDBTypeUnsupported);
141  break;
142  }
143  }
144  }
145 
146  void statementResultsNumericTableFromColumnData(const K& columnData, NumericTable *nt, size_t nRows)
147  {
148  BlockDescriptor<DAAL_DATA_TYPE> block;
149  nt->getBlockOfRows(0, nRows, writeOnly, block);
150  DAAL_DATA_TYPE *blockPtr = block.getBlockPtr();
151  size_t nFeatures = nt->getNumberOfColumns();
152  for (size_t row = 0; row < nRows; row++)
153  {
154  for(size_t col = 0; col < nFeatures; col++)
155  {
156  K column = kK(columnData)[col];
157  switch(column->t)
158  {
159  case(KB):
160  blockPtr[row * nFeatures + col] = kG(column)[row];
161  break;
162  case(KG):
163  blockPtr[row * nFeatures + col] = kG(column)[row];
164  break;
165  case(KH):
166  blockPtr[row * nFeatures + col] = kH(column)[row];
167  break;
168  case(KI): case(KM): case(KD): case(KU): case(KV): case(KT):
169  blockPtr[row * nFeatures + col] = kI(column)[row];
170  break;
171  case(KJ): case(KP): case(KN):
172  blockPtr[row * nFeatures + col] = kJ(column)[row];
173  break;
174  case(KE):
175  blockPtr[row * nFeatures + col] = kE(column)[row];
176  break;
177  case(KF):
178  blockPtr[row * nFeatures + col] = kF(column)[row];
179  break;
180  default:
181  _errors->add(services::ErrorKDBTypeUnsupported);
182  break;
183  }
184  }
185  }
186  nt->releaseBlockOfRows(block);
187  }
188 
189  void statementResultsNumericTableFromList(const K& lst, NumericTable *nt, size_t nRows)
190  {
191  BlockDescriptor<DAAL_DATA_TYPE> block;
192  nt->getBlockOfRows(0, nRows, writeOnly, block);
193  DAAL_DATA_TYPE *blockPtr = block.getBlockPtr();
194  size_t nFeatures = nt->getNumberOfColumns();
195  for (size_t row = 0; row < nRows; row++)
196  {
197  K data;
198  if (lst->t == 0) data = kK(lst)[row]; else data = lst;
199  for(size_t col = 0; col < nFeatures; col++)
200  {
201  switch(data->t)
202  {
203  case(KB):
204  blockPtr[row * nFeatures + col] = kG(data)[col];
205  break;
206  case(KG):
207  blockPtr[row * nFeatures + col] = kG(data)[col];
208  break;
209  case(KH):
210  blockPtr[row * nFeatures + col] = kH(data)[col];
211  break;
212  case(KI): case(KM): case(KD): case(KU): case(KV): case(KT):
213  blockPtr[row * nFeatures + col] = kI(data)[col];
214  break;
215  case(KJ): case(KP): case(KN):
216  blockPtr[row * nFeatures + col] = kJ(data)[col];
217  break;
218  case(KE):
219  blockPtr[row * nFeatures + col] = kE(data)[col];
220  break;
221  case(KF):
222  blockPtr[row * nFeatures + col] = kF(data)[col];
223  break;
224  default:
225  _errors->add(services::ErrorKDBTypeUnsupported);
226  break;
227  }
228  }
229  if (lst->t == 0) r0(data);
230  }
231  nt->releaseBlockOfRows(block);
232  }
233 
234  services::SharedPtr<services::ErrorCollection> getErrors()
235  {
236  return _errors;
237  }
238 
239 private:
240  services::SharedPtr<services::ErrorCollection> _errors;
241 
242 };
243 
244 } // namespace interface1
245 using interface1::KDBFeatureManager;
246 
247 }
248 }
249 #endif
daal::data_management::interface1::BlockDescriptor::getBlockPtr
DataType * getBlockPtr() const
Definition: numeric_table.h:69
daal
Definition: algorithm_base_common.h:31
daal::data_management::interface1::DataSourceFeature::setFeatureName
void setFeatureName(const services::String &featureName)
Definition: data_source_dictionary.h:130
daal::data_management::interface1::DataSourceFeature::setType
void setType()
Definition: data_source_dictionary.h:141
daal::data_management::interface1::DataSourceFeature
Data structure that describes the Data Source feature.
Definition: data_source_dictionary.h:51
daal::data_management::interface1::KDBFeatureManager
Contains KDB-specific commands.
Definition: kdb_feature_manager.h:43
daal::data_management::interface1::NumericTable::getNumberOfColumns
size_t getNumberOfColumns() const
Definition: numeric_table.h:652
daal::data_management::interface1::KDBFeatureManager::createDictionaryFromList
void createDictionaryFromList(const K &lst, DataSourceDictionary *dict)
Definition: kdb_feature_manager.h:103
daal::algorithms::association_rules::data
Definition: apriori_types.h:81
daal::data_management::interface1::NumericTable
Class for a data management component responsible for representation of data in the numeric format...
Definition: numeric_table.h:575
daal::data_management::interface1::Dictionary::setNumberOfFeatures
virtual services::Status setNumberOfFeatures(size_t numberOfFeatures)
Definition: data_dictionary.h:266
daal::services::ErrorKDBTypeUnsupported
Definition: error_indexes.h:389
daal::data_management::interface1::BlockDescriptor< DAAL_DATA_TYPE >
daal::data_management::interface1::DenseNumericTableIface::releaseBlockOfRows
virtual services::Status releaseBlockOfRows(BlockDescriptor< double > &block)=0
daal::data_management::interface1::KDBFeatureManager::createDictionaryFromTable
void createDictionaryFromTable(const K &table, DataSourceDictionary *dict)
Definition: kdb_feature_manager.h:54
daal::data_management::interface1::DenseNumericTableIface::getBlockOfRows
virtual services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor< double > &block)=0
daal::data_management::interface1::Dictionary
Class that represents a dictionary of a data set and provides methods to work with the data dictionar...
Definition: data_dictionary.h:161

For more complete information about compiler optimizations, see our Optimization Notice.