C++ API Reference for Intel® Data Analytics Acceleration Library 2018 Update 3

data_dictionary.h
1 /* file: data_dictionary.h */
2 /*******************************************************************************
3 * Copyright 2014-2018 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 a data dictionary.
19 //--
20 */
21 
22 #ifndef __DATA_DICTIONARY_H__
23 #define __DATA_DICTIONARY_H__
24 
25 #include "services/daal_defines.h"
26 #include "services/daal_memory.h"
27 #include "data_management/data/data_serialize.h"
28 #include "data_management/data/data_archive.h"
29 #include "data_management/data/data_utils.h"
30 
31 namespace daal
32 {
33 namespace data_management
34 {
35 
36 namespace interface1
37 {
48 class NumericTableFeature : public SerializationIface
49 {
50 public:
51  data_feature_utils::IndexNumType indexType;
52  data_feature_utils::PMMLNumType pmmlType;
53  data_feature_utils::FeatureType featureType;
54  size_t typeSize;
55  size_t categoryNumber;
56 
57 public:
61  NumericTableFeature()
62  {
63  indexType = data_feature_utils::DAAL_OTHER_T;
64  pmmlType = data_feature_utils::DAAL_GEN_UNKNOWN;
65  featureType = data_feature_utils::DAAL_CONTINUOUS;
66  typeSize = 0;
67  categoryNumber = 0;
68  }
69 
73  NumericTableFeature &operator= (const NumericTableFeature &f)
74  {
75  indexType = f.indexType ;
76  pmmlType = f.pmmlType ;
77  featureType = f.featureType ;
78  typeSize = f.typeSize ;
79  categoryNumber = f.categoryNumber;
80 
81  return *this;
82  }
83 
84  virtual ~NumericTableFeature() {}
85 
90  template<typename T>
91  void setType()
92  {
93  typeSize = sizeof(T);
94  indexType = data_feature_utils::getIndexNumType<T>();
95  pmmlType = data_feature_utils::getPMMLNumType<T>();
96  }
97 
99  services::Status serializeImpl (InputDataArchive *arch) DAAL_C11_OVERRIDE
100  {
101  serialImpl<InputDataArchive, false>( arch );
102 
103  return services::Status();
104  }
105 
107  services::Status deserializeImpl(const OutputDataArchive *arch) DAAL_C11_OVERRIDE
108  {
109  serialImpl<const OutputDataArchive, true>( arch );
110 
111  return services::Status();
112  }
113 
115  template<typename Archive, bool onDeserialize>
116  services::Status serialImpl( Archive *arch )
117  {
118  arch->set( pmmlType );
119  arch->set( featureType );
120  arch->set( typeSize );
121  arch->set( categoryNumber );
122  arch->set( indexType );
123 
124  return services::Status();
125  }
126 
127  virtual int getSerializationTag() const DAAL_C11_OVERRIDE
128  {
129  return SERIALIZATION_DATAFEATURE_NT_ID;
130  }
131 
132  data_feature_utils::IndexNumType getIndexType() const
133  {
134  return indexType;
135  }
136 };
137 
139 class DictionaryIface {
140 public:
145  enum FeaturesEqual
146  {
147  notEqual,
148  equal
149  };
150 };
151 
157 template<typename Feature, int SerializationTag>
158 class DAAL_EXPORT Dictionary : public SerializationIface, public DictionaryIface
159 {
160 public:
161  static int serializationTag() { return SerializationTag; }
162  virtual int getSerializationTag() const DAAL_C11_OVERRIDE { return serializationTag(); }
163 
170  Dictionary( size_t nfeat, FeaturesEqual featuresEqual = notEqual ):
171  _nfeat(0), _featuresEqual(featuresEqual), _dict(0), _errors(new services::KernelErrorCollection())
172  {
173  if(nfeat) { setNumberOfFeatures(nfeat); }
174  }
175 
183  static services::SharedPtr<Dictionary> create( size_t nfeat, FeaturesEqual featuresEqual = notEqual, services::Status *stat = NULL )
184  {
185  DAAL_DEFAULT_CREATE_IMPL_EX(Dictionary, nfeat, featuresEqual);
186  }
187 
192  Dictionary(): _nfeat(0), _dict(0), _featuresEqual(DictionaryIface::notEqual), _errors(new services::KernelErrorCollection()) {}
193 
199  static services::SharedPtr<Dictionary> create( services::Status *stat = NULL )
200  {
201  DAAL_DEFAULT_CREATE_IMPL(Dictionary);
202  }
203 
205  virtual ~Dictionary()
206  {
207  resetDictionary();
208  }
209 
213  services::Status resetDictionary()
214  {
215  if(_dict)
216  {
217  delete[] _dict;
218  _dict = NULL;
219  }
220  _nfeat = 0;
221  return services::Status();
222  }
223 
228  virtual services::Status setAllFeatures(const Feature &defaultFeature)
229  {
230  if (_featuresEqual == DictionaryIface::equal)
231  {
232  if (_nfeat > 0)
233  {
234  _dict[0] = defaultFeature;
235  }
236  }
237  else
238  {
239  for( size_t i = 0 ; i < _nfeat ; i++ )
240  {
241  _dict[i] = defaultFeature;
242  }
243  }
244  return services::Status();
245  }
246 
251  template<typename featureType>
252  services::Status setAllFeatures()
253  {
254  Feature defaultFeature;
255  defaultFeature.template setType<featureType>();
256  return setAllFeatures(defaultFeature);
257  }
258 
263  virtual services::Status setNumberOfFeatures(size_t numberOfFeatures)
264  {
265  resetDictionary();
266  _nfeat = numberOfFeatures;
267  if (_featuresEqual == DictionaryIface::equal)
268  {
269  _dict = new Feature[1];
270  }
271  else
272  {
273  _dict = new Feature[_nfeat];
274  }
275  return services::Status();
276  }
277 
282  size_t getNumberOfFeatures() const
283  {
284  return _nfeat;
285  }
286 
291  FeaturesEqual getFeaturesEqual() const
292  {
293  return _featuresEqual;
294  }
295 
301  Feature &operator[](const size_t idx)
302  {
303  if (_featuresEqual == DictionaryIface::equal)
304  {
305  return _dict[0];
306  }
307  else
308  {
309  return _dict[idx];
310  }
311  }
312 
320  services::Status setFeature(const Feature &feature, size_t idx)
321  {
322  if(idx >= _nfeat)
323  return services::Status(services::ErrorIncorrectNumberOfFeatures);
324 
325  if (_featuresEqual == DictionaryIface::equal)
326  {
327  _dict[0] = feature;
328  }
329  else
330  {
331  _dict[idx] = feature;
332  }
333  return services::Status();
334  }
335 
340  template<typename T>
341  services::Status setFeature(size_t idx)
342  {
343  Feature df;
344  df.template setType<T>();
345  return setFeature(df, idx);
346  }
347 
348  services::Status checkDictionary() const
349  {
350  size_t nFeat = _nfeat;
351  if (_featuresEqual == DictionaryIface::equal) nFeat = 1;
352 
353  for (size_t i = 0; i < nFeat; ++i)
354  {
355  if (_dict[i].getIndexType() == data_feature_utils::DAAL_OTHER_T)
356  {
357  return services::Status(services::ErrorUndefinedFeature);
358  }
359  }
360  return services::Status();
361  }
362 
368  DAAL_DEPRECATED services::SharedPtr<services::KernelErrorCollection> getErrors()
369  {
370  return _errors;
371  }
372 
374  services::Status serializeImpl (InputDataArchive *arch) DAAL_C11_OVERRIDE
375  {
376  serialImpl<InputDataArchive, false>( arch );
377 
378  return services::Status();
379  }
380 
382  services::Status deserializeImpl(const OutputDataArchive *arch) DAAL_C11_OVERRIDE
383  {
384  serialImpl<const OutputDataArchive, true>( arch );
385 
386  return services::Status();
387  }
388 
389 private:
391  template<typename Archive, bool onDeserialize>
392  services::Status serialImpl( Archive *arch )
393  {
394  arch->segmentHeader();
395 
396  arch->set( _nfeat );
397  arch->set( _featuresEqual );
398 
399  if( onDeserialize )
400  {
401  size_t nfeat = _nfeat;
402  _nfeat = 0;
403  setNumberOfFeatures(nfeat);
404  }
405 
406  if (_featuresEqual)
407  {
408  arch->setObj( _dict, 1 );
409  }
410  else
411  {
412  arch->setObj( _dict, _nfeat );
413  }
414 
415  arch->segmentFooter();
416 
417  return services::Status();
418  }
419 
420 protected:
421  size_t _nfeat;
422  FeaturesEqual _featuresEqual;
423  Feature *_dict;
424  services::SharedPtr<services::KernelErrorCollection> _errors;
425 
426  Dictionary( size_t nfeat, FeaturesEqual featuresEqual, services::Status &st ):
427  _nfeat(0), _featuresEqual(featuresEqual), _dict(0), _errors(new services::KernelErrorCollection())
428  {
429  if(nfeat) { st |= setNumberOfFeatures(nfeat); }
430  }
431 
432  Dictionary(services::Status &st): _nfeat(0), _dict(0), _featuresEqual(DictionaryIface::notEqual), _errors(new services::KernelErrorCollection()) {}
433 };
434 typedef Dictionary<NumericTableFeature, SERIALIZATION_DATADICTIONARY_NT_ID> NumericTableDictionary;
435 typedef services::SharedPtr<NumericTableDictionary> NumericTableDictionaryPtr;
436 typedef services::SharedPtr<NumericTableFeature> NumericTableFeaturePtr;
439 } // namespace interface1
440 using interface1::NumericTableFeature;
441 using interface1::NumericTableFeaturePtr;
442 using interface1::DictionaryIface;
443 using interface1::Dictionary;
444 using interface1::NumericTableDictionary;
445 using interface1::NumericTableDictionaryPtr;
446 
447 }
448 } // namespace daal
449 #endif
daal::data_management::interface1::Dictionary::resetDictionary
services::Status resetDictionary()
Definition: data_dictionary.h:213
daal
Definition: algorithm_base_common.h:31
daal::data_management::interface1::InputDataArchive
Provides methods to create an archive data object (serialized) and access this object.
Definition: data_archive.h:689
daal::data_management::interface1::NumericTableFeature::NumericTableFeature
NumericTableFeature()
Definition: data_dictionary.h:61
daal::data_management::interface1::DictionaryIface::notEqual
Definition: data_dictionary.h:147
daal::data_management::interface1::Dictionary::operator[]
Feature & operator[](const size_t idx)
Definition: data_dictionary.h:301
daal::data_management::interface1::Dictionary::create
static services::SharedPtr< Dictionary > create(services::Status *stat=NULL)
Definition: data_dictionary.h:199
daal::services::ErrorIncorrectNumberOfFeatures
Definition: error_indexes.h:70
daal::data_management::interface1::Dictionary::getErrors
DAAL_DEPRECATED services::SharedPtr< services::KernelErrorCollection > getErrors()
Definition: data_dictionary.h:368
daal::services::SerializationTag
Definition: error_indexes.h:57
daal_defines.h
daal::data_management::interface1::Dictionary::getNumberOfFeatures
size_t getNumberOfFeatures() const
Definition: data_dictionary.h:282
daal::data_management::interface1::Dictionary::setFeature
services::Status setFeature(size_t idx)
Definition: data_dictionary.h:341
daal::data_management::interface1::NumericTableFeature::operator=
NumericTableFeature & operator=(const NumericTableFeature &f)
Definition: data_dictionary.h:73
daal::data_management::interface1::Dictionary::getSerializationTag
virtual int getSerializationTag() const DAAL_C11_OVERRIDE
Definition: data_dictionary.h:162
daal::data_management::interface1::NumericTableFeature::getSerializationTag
virtual int getSerializationTag() const DAAL_C11_OVERRIDE
Definition: data_dictionary.h:127
daal::data_management::interface1::Dictionary::setNumberOfFeatures
virtual services::Status setNumberOfFeatures(size_t numberOfFeatures)
Definition: data_dictionary.h:263
daal::data_management::interface1::Dictionary::setAllFeatures
services::Status setAllFeatures()
Definition: data_dictionary.h:252
daal::data_management::interface1::Dictionary::Dictionary
Dictionary(size_t nfeat, FeaturesEqual featuresEqual=notEqual)
Definition: data_dictionary.h:170
daal::data_management::interface1::Dictionary::setFeature
services::Status setFeature(const Feature &feature, size_t idx)
Adds a feature to a data dictionary.
Definition: data_dictionary.h:320
daal::data_management::interface1::DictionaryIface::FeaturesEqual
FeaturesEqual
Enumeration to specify whether the Data Dictionary contains equal features.
Definition: data_dictionary.h:145
daal::data_management::interface1::NumericTableFeature::setType
void setType()
Definition: data_dictionary.h:91
daal::data_management::interface1::Dictionary::create
static services::SharedPtr< Dictionary > create(size_t nfeat, FeaturesEqual featuresEqual=notEqual, services::Status *stat=NULL)
Definition: data_dictionary.h:183
daal::services::ErrorUndefinedFeature
Definition: error_indexes.h:140
daal::data_management::interface1::Dictionary::setAllFeatures
virtual services::Status setAllFeatures(const Feature &defaultFeature)
Definition: data_dictionary.h:228
daal::data_management::interface1::Dictionary::Dictionary
Dictionary()
Definition: data_dictionary.h:192
daal::data_management::interface1::SerializationIface
Abstract interface class that defines the interface for serialization and deserialization.
Definition: data_serialize.h:50
daal::data_management::interface1::NumericTableFeature
Data structure describes the Numeric Table feature.
Definition: data_dictionary.h:48
daal::data_management::interface1::Dictionary::getFeaturesEqual
FeaturesEqual getFeaturesEqual() const
Definition: data_dictionary.h:291
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:158

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