C++ API Reference for Intel® Data Analytics Acceleration Library 2020 Update 1

kdb_feature_manager.h
1 /* file: kdb_feature_manager.h */
2 /*******************************************************************************
3 * Copyright 2014-2020 Intel Corporation
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *******************************************************************************/
17 
18 /*
19 //++
20 // Implementation of the KDB data source class.
21 //--
22 */
23 #ifndef __KDB_FEATURE_MANAGER_H__
24 #define __KDB_FEATURE_MANAGER_H__
25 
26 #include "services/daal_memory.h"
27 #include "data_management/data_source/data_source.h"
28 #include "data_management/data/data_dictionary.h"
29 #include "data_management/data/numeric_table.h"
30 #include "data_management/data/homogen_numeric_table.h"
31 
32 #include <k.h>
33 
34 namespace daal
35 {
36 namespace data_management
37 {
38 
39 namespace interface1
40 {
45 class KDBFeatureManager
46 {
47 public:
48  KDBFeatureManager() : _errors(new services::ErrorCollection()) {}
49 
56  void createDictionaryFromTable(const K& table, DataSourceDictionary *dict)
57  {
58  K featureNames = kK(table)[0];
59  K featureData = kK(table)[1];
60  size_t nFeatures = featureNames->n;
61 
62  dict->setNumberOfFeatures( nFeatures );
63 
64  for(size_t i = 0; i < nFeatures; i++)
65  {
66  DataSourceFeature &feature = (*dict)[i];
67 
68  feature.setFeatureName(kS(featureNames)[i]);
69 
70  K column = kK(featureData)[i];
71 
72  switch(column->t)
73  {
74  case(KF): case(KZ):
75  feature.setType<double>();
76  break;
77  case(KE):
78  feature.setType<float>();
79  break;
80  case(KB): case(KG): case(KC):
81  feature.setType<char>();
82  break;
83  case(KH):
84  feature.setType<short>();
85  break;
86  case(KI): case(KM): case(KD): case(KU): case(KV): case(KT):
87  feature.setType<int>();
88  break;
89  case(KJ):
90  feature.setType<DAAL_INT64>();
91  break;
92  default:
93  _errors->add(services::ErrorKDBTypeUnsupported);
94  break;
95  }
96  }
97  }
98 
105  void createDictionaryFromList(const K& lst, DataSourceDictionary *dict)
106  {
107  size_t nFeatures = lst->n;
108 
109  dict->setNumberOfFeatures( nFeatures );
110 
111  for(size_t i = 0; i < nFeatures; i++)
112  {
113  DataSourceFeature &feature = (*dict)[i];
114 
115  I curType;
116 
117  if (lst->t == 0) curType = kK(lst)[i]->t; else curType = lst->t;
118 
119  if (curType < 0) curType = -curType;
120 
121  switch(curType)
122  {
123  case(KF): case(KZ):
124  feature.setType<double>();
125  break;
126  case(KE):
127  feature.setType<float>();
128  break;
129  case(KB): case(KG): case(KC):
130  feature.setType<char>();
131  break;
132  case(KH):
133  feature.setType<short>();
134  break;
135  case(KI): case(KM): case(KD): case(KU): case(KV): case(KT):
136  feature.setType<int>();
137  break;
138  case(KJ):
139  feature.setType<DAAL_INT64>();
140  break;
141  default:
142  _errors->add(services::ErrorKDBTypeUnsupported);
143  break;
144  }
145  }
146  }
147 
148  void statementResultsNumericTableFromColumnData(const K& columnData, NumericTable *nt, size_t nRows)
149  {
150  BlockDescriptor<DAAL_DATA_TYPE> block;
151  nt->getBlockOfRows(0, nRows, writeOnly, block);
152  DAAL_DATA_TYPE *blockPtr = block.getBlockPtr();
153  size_t nFeatures = nt->getNumberOfColumns();
154  for (size_t row = 0; row < nRows; row++)
155  {
156  for(size_t col = 0; col < nFeatures; col++)
157  {
158  K column = kK(columnData)[col];
159  switch(column->t)
160  {
161  case(KB):
162  blockPtr[row * nFeatures + col] = kG(column)[row];
163  break;
164  case(KG):
165  blockPtr[row * nFeatures + col] = kG(column)[row];
166  break;
167  case(KH):
168  blockPtr[row * nFeatures + col] = kH(column)[row];
169  break;
170  case(KI): case(KM): case(KD): case(KU): case(KV): case(KT):
171  blockPtr[row * nFeatures + col] = kI(column)[row];
172  break;
173  case(KJ): case(KP): case(KN):
174  blockPtr[row * nFeatures + col] = kJ(column)[row];
175  break;
176  case(KE):
177  blockPtr[row * nFeatures + col] = kE(column)[row];
178  break;
179  case(KF):
180  blockPtr[row * nFeatures + col] = kF(column)[row];
181  break;
182  default:
183  _errors->add(services::ErrorKDBTypeUnsupported);
184  break;
185  }
186  }
187  }
188  nt->releaseBlockOfRows(block);
189  }
190 
191  void statementResultsNumericTableFromList(const K& lst, NumericTable *nt, size_t nRows)
192  {
193  BlockDescriptor<DAAL_DATA_TYPE> block;
194  nt->getBlockOfRows(0, nRows, writeOnly, block);
195  DAAL_DATA_TYPE *blockPtr = block.getBlockPtr();
196  size_t nFeatures = nt->getNumberOfColumns();
197  for (size_t row = 0; row < nRows; row++)
198  {
199  K data;
200  if (lst->t == 0) data = kK(lst)[row]; else data = lst;
201  for(size_t col = 0; col < nFeatures; col++)
202  {
203  switch(data->t)
204  {
205  case(KB):
206  blockPtr[row * nFeatures + col] = kG(data)[col];
207  break;
208  case(KG):
209  blockPtr[row * nFeatures + col] = kG(data)[col];
210  break;
211  case(KH):
212  blockPtr[row * nFeatures + col] = kH(data)[col];
213  break;
214  case(KI): case(KM): case(KD): case(KU): case(KV): case(KT):
215  blockPtr[row * nFeatures + col] = kI(data)[col];
216  break;
217  case(KJ): case(KP): case(KN):
218  blockPtr[row * nFeatures + col] = kJ(data)[col];
219  break;
220  case(KE):
221  blockPtr[row * nFeatures + col] = kE(data)[col];
222  break;
223  case(KF):
224  blockPtr[row * nFeatures + col] = kF(data)[col];
225  break;
226  default:
227  _errors->add(services::ErrorKDBTypeUnsupported);
228  break;
229  }
230  }
231  if (lst->t == 0) r0(data);
232  }
233  nt->releaseBlockOfRows(block);
234  }
235 
236  services::SharedPtr<services::ErrorCollection> getErrors()
237  {
238  return _errors;
239  }
240 
241 private:
242  services::SharedPtr<services::ErrorCollection> _errors;
243 
244 };
245 
246 } // namespace interface1
247 using interface1::KDBFeatureManager;
248 
249 }
250 }
251 #endif
daal::services::ErrorKDBTypeUnsupported
Definition: error_indexes.h:400
daal::data_management::interface1::KDBFeatureManager
Contains KDB-specific commands.
Definition: kdb_feature_manager.h:45
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:163
daal::algorithms::association_rules::data
Definition: apriori_types.h:83
daal::data_management::interface1::KDBFeatureManager::createDictionaryFromList
void createDictionaryFromList(const K &lst, DataSourceDictionary *dict)
Definition: kdb_feature_manager.h:105
daal::data_management::interface1::NumericTable
Class for a data management component responsible for representation of data in the numeric format...
Definition: numeric_table.h:577
daal::data_management::interface1::Dictionary::setNumberOfFeatures
virtual services::Status setNumberOfFeatures(size_t numberOfFeatures)
Definition: data_dictionary.h:268
daal::data_management::interface1::DataSourceFeature::setFeatureName
void setFeatureName(const services::String &featureName)
Definition: data_source_dictionary.h:135
daal::data_management::interface1::NumericTable::getNumberOfColumns
size_t getNumberOfColumns() const
Definition: numeric_table.h:654
daal::data_management::interface1::KDBFeatureManager::createDictionaryFromTable
void createDictionaryFromTable(const K &table, DataSourceDictionary *dict)
Definition: kdb_feature_manager.h:56
daal::data_management::interface1::DataSourceFeature::setType
void setType()
Definition: data_source_dictionary.h:146
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::BlockDescriptor< DAAL_DATA_TYPE >
daal::data_management::interface1::DenseNumericTableIface::releaseBlockOfRows
virtual services::Status releaseBlockOfRows(BlockDescriptor< double > &block)=0
daal::data_management::interface1::DataSourceFeature
Data structure that describes the Data Source feature.
Definition: data_source_dictionary.h:53
daal::data_management::interface1::BlockDescriptor::getBlockPtr
DataType * getBlockPtr() const
Definition: numeric_table.h:71

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