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

data_dictionary.h
1 /* file: data_dictionary.h */
2 /*******************************************************************************
3 * Copyright 2014-2017 Intel Corporation
4 * All Rights Reserved.
5 *
6 * If this software was obtained under the Intel Simplified Software License,
7 * the following terms apply:
8 *
9 * The source code, information and material ("Material") contained herein is
10 * owned by Intel Corporation or its suppliers or licensors, and title to such
11 * Material remains with Intel Corporation or its suppliers or licensors. The
12 * Material contains proprietary information of Intel or its suppliers and
13 * licensors. The Material is protected by worldwide copyright laws and treaty
14 * provisions. No part of the Material may be used, copied, reproduced,
15 * modified, published, uploaded, posted, transmitted, distributed or disclosed
16 * in any way without Intel's prior express written permission. No license under
17 * any patent, copyright or other intellectual property rights in the Material
18 * is granted to or conferred upon you, either expressly, by implication,
19 * inducement, estoppel or otherwise. Any license under such intellectual
20 * property rights must be express and approved by Intel in writing.
21 *
22 * Unless otherwise agreed by Intel in writing, you may not remove or alter this
23 * notice or any other notice embedded in Materials by Intel or Intel's
24 * suppliers or licensors in any way.
25 *
26 *
27 * If this software was obtained under the Apache License, Version 2.0 (the
28 * "License"), the following terms apply:
29 *
30 * You may not use this file except in compliance with the License. You may
31 * obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
32 *
33 *
34 * Unless required by applicable law or agreed to in writing, software
35 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
36 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
37 *
38 * See the License for the specific language governing permissions and
39 * limitations under the License.
40 *******************************************************************************/
41 
42 /*
43 //++
44 // Implementation of a data dictionary.
45 //--
46 */
47 
48 #ifndef __DATA_DICTIONARY_H__
49 #define __DATA_DICTIONARY_H__
50 
51 #include "services/daal_defines.h"
52 #include "services/daal_memory.h"
53 #include "data_management/data/data_serialize.h"
54 #include "data_management/data/data_archive.h"
55 #include "data_management/data/data_utils.h"
56 
57 namespace daal
58 {
59 namespace data_management
60 {
61 
62 namespace interface1
63 {
74 class NumericTableFeature : public SerializationIface
75 {
76 public:
77  data_feature_utils::IndexNumType indexType;
78  data_feature_utils::PMMLNumType pmmlType;
79  data_feature_utils::FeatureType featureType;
80  size_t typeSize;
81  size_t categoryNumber;
82 
83 public:
87  NumericTableFeature()
88  {
89  indexType = data_feature_utils::DAAL_OTHER_T;
90  pmmlType = data_feature_utils::DAAL_GEN_UNKNOWN;
91  featureType = data_feature_utils::DAAL_CONTINUOUS;
92  typeSize = 0;
93  categoryNumber = 0;
94  }
95 
99  NumericTableFeature &operator= (const NumericTableFeature &f)
100  {
101  indexType = f.indexType ;
102  pmmlType = f.pmmlType ;
103  featureType = f.featureType ;
104  typeSize = f.typeSize ;
105  categoryNumber = f.categoryNumber;
106 
107  return *this;
108  }
109 
110  virtual ~NumericTableFeature() {}
111 
116  template<typename T>
117  void setType()
118  {
119  typeSize = sizeof(T);
120  indexType = data_feature_utils::getIndexNumType<T>();
121  pmmlType = data_feature_utils::getPMMLNumType<T>();
122  }
123 
125  services::Status serializeImpl (InputDataArchive *arch) DAAL_C11_OVERRIDE
126  {
127  serialImpl<InputDataArchive, false>( arch );
128 
129  return services::Status();
130  }
131 
133  services::Status deserializeImpl(const OutputDataArchive *arch) DAAL_C11_OVERRIDE
134  {
135  serialImpl<const OutputDataArchive, true>( arch );
136 
137  return services::Status();
138  }
139 
141  template<typename Archive, bool onDeserialize>
142  services::Status serialImpl( Archive *arch )
143  {
144  arch->set( pmmlType );
145  arch->set( featureType );
146  arch->set( typeSize );
147  arch->set( categoryNumber );
148  arch->set( indexType );
149 
150  return services::Status();
151  }
152 
153  virtual int getSerializationTag() const DAAL_C11_OVERRIDE
154  {
155  return SERIALIZATION_DATAFEATURE_NT_ID;
156  }
157 
158  data_feature_utils::IndexNumType getIndexType() const
159  {
160  return indexType;
161  }
162 };
163 
165 class DictionaryIface {
166 public:
171  enum FeaturesEqual
172  {
173  notEqual,
174  equal
175  };
176 };
177 
183 template<typename Feature, int SerializationTag>
184 class DAAL_EXPORT Dictionary : public SerializationIface, public DictionaryIface
185 {
186 public:
187  static int serializationTag() { return SerializationTag; }
188  virtual int getSerializationTag() const DAAL_C11_OVERRIDE { return serializationTag(); }
189 
196  Dictionary( size_t nfeat, FeaturesEqual featuresEqual = notEqual ):
197  _nfeat(0), _featuresEqual(featuresEqual), _dict(0), _errors(new services::KernelErrorCollection())
198  {
199  if(nfeat) { setNumberOfFeatures(nfeat); }
200  }
201 
209  static services::SharedPtr<Dictionary> create( size_t nfeat, FeaturesEqual featuresEqual = notEqual, services::Status *stat = NULL )
210  {
211  DAAL_DEFAULT_CREATE_IMPL_EX(Dictionary, nfeat, featuresEqual);
212  }
213 
218  Dictionary(): _nfeat(0), _dict(0), _featuresEqual(DictionaryIface::notEqual), _errors(new services::KernelErrorCollection()) {}
219 
225  static services::SharedPtr<Dictionary> create( services::Status *stat = NULL )
226  {
227  DAAL_DEFAULT_CREATE_IMPL(Dictionary);
228  }
229 
231  virtual ~Dictionary()
232  {
233  resetDictionary();
234  }
235 
239  services::Status resetDictionary()
240  {
241  if(_dict)
242  {
243  delete[] _dict;
244  _dict = NULL;
245  }
246  _nfeat = 0;
247  return services::Status();
248  }
249 
254  virtual services::Status setAllFeatures(const Feature &defaultFeature)
255  {
256  if (_featuresEqual == DictionaryIface::equal)
257  {
258  if (_nfeat > 0)
259  {
260  _dict[0] = defaultFeature;
261  }
262  }
263  else
264  {
265  for( size_t i = 0 ; i < _nfeat ; i++ )
266  {
267  _dict[i] = defaultFeature;
268  }
269  }
270  return services::Status();
271  }
272 
277  template<typename featureType>
278  services::Status setAllFeatures()
279  {
280  Feature defaultFeature;
281  defaultFeature.template setType<featureType>();
282  return setAllFeatures(defaultFeature);
283  }
284 
289  virtual services::Status setNumberOfFeatures(size_t numberOfFeatures)
290  {
291  resetDictionary();
292  _nfeat = numberOfFeatures;
293  if (_featuresEqual == DictionaryIface::equal)
294  {
295  _dict = new Feature[1];
296  }
297  else
298  {
299  _dict = new Feature[_nfeat];
300  }
301  return services::Status();
302  }
303 
308  size_t getNumberOfFeatures() const
309  {
310  return _nfeat;
311  }
312 
317  FeaturesEqual getFeaturesEqual() const
318  {
319  return _featuresEqual;
320  }
321 
327  Feature &operator[](const size_t idx)
328  {
329  if (_featuresEqual == DictionaryIface::equal)
330  {
331  return _dict[0];
332  }
333  else
334  {
335  return _dict[idx];
336  }
337  }
338 
346  services::Status setFeature(const Feature &feature, size_t idx)
347  {
348  if(idx >= _nfeat)
349  return services::Status(services::ErrorIncorrectNumberOfFeatures);
350 
351  if (_featuresEqual == DictionaryIface::equal)
352  {
353  _dict[0] = feature;
354  }
355  else
356  {
357  _dict[idx] = feature;
358  }
359  return services::Status();
360  }
361 
366  template<typename T>
367  services::Status setFeature(size_t idx)
368  {
369  Feature df;
370  df.template setType<T>();
371  return setFeature(df, idx);
372  }
373 
374  services::Status checkDictionary() const
375  {
376  size_t nFeat = _nfeat;
377  if (_featuresEqual == DictionaryIface::equal) nFeat = 1;
378 
379  for (size_t i = 0; i < nFeat; ++i)
380  {
381  if (_dict[i].getIndexType() == data_feature_utils::DAAL_OTHER_T)
382  {
383  return services::Status(services::ErrorUndefinedFeature);
384  }
385  }
386  return services::Status();
387  }
388 
394  DAAL_DEPRECATED services::SharedPtr<services::KernelErrorCollection> getErrors()
395  {
396  return _errors;
397  }
398 
400  services::Status serializeImpl (InputDataArchive *arch) DAAL_C11_OVERRIDE
401  {
402  serialImpl<InputDataArchive, false>( arch );
403 
404  return services::Status();
405  }
406 
408  services::Status deserializeImpl(const OutputDataArchive *arch) DAAL_C11_OVERRIDE
409  {
410  serialImpl<const OutputDataArchive, true>( arch );
411 
412  return services::Status();
413  }
414 
415 private:
417  template<typename Archive, bool onDeserialize>
418  services::Status serialImpl( Archive *arch )
419  {
420  arch->segmentHeader();
421 
422  arch->set( _nfeat );
423  arch->set( _featuresEqual );
424 
425  if( onDeserialize )
426  {
427  size_t nfeat = _nfeat;
428  _nfeat = 0;
429  setNumberOfFeatures(nfeat);
430  }
431 
432  if (_featuresEqual)
433  {
434  arch->setObj( _dict, 1 );
435  }
436  else
437  {
438  arch->setObj( _dict, _nfeat );
439  }
440 
441  arch->segmentFooter();
442 
443  return services::Status();
444  }
445 
446 protected:
447  size_t _nfeat;
448  FeaturesEqual _featuresEqual;
449  Feature *_dict;
450  services::SharedPtr<services::KernelErrorCollection> _errors;
451 
452  Dictionary( size_t nfeat, FeaturesEqual featuresEqual, services::Status &st ):
453  _nfeat(0), _featuresEqual(featuresEqual), _dict(0), _errors(new services::KernelErrorCollection())
454  {
455  if(nfeat) { st |= setNumberOfFeatures(nfeat); }
456  }
457 
458  Dictionary(services::Status &st): _nfeat(0), _dict(0), _featuresEqual(DictionaryIface::notEqual), _errors(new services::KernelErrorCollection()) {}
459 };
460 typedef Dictionary<NumericTableFeature, SERIALIZATION_DATADICTIONARY_NT_ID> NumericTableDictionary;
461 typedef services::SharedPtr<NumericTableDictionary> NumericTableDictionaryPtr;
462 typedef services::SharedPtr<NumericTableFeature> NumericTableFeaturePtr;
465 } // namespace interface1
466 using interface1::NumericTableFeature;
467 using interface1::NumericTableFeaturePtr;
468 using interface1::DictionaryIface;
469 using interface1::Dictionary;
470 using interface1::NumericTableDictionary;
471 using interface1::NumericTableDictionaryPtr;
472 
473 }
474 } // namespace daal
475 #endif
daal::data_management::interface1::Dictionary::resetDictionary
services::Status resetDictionary()
Definition: data_dictionary.h:239
daal
Definition: algorithm_base_common.h:57
daal::data_management::interface1::InputDataArchive
Provides methods to create an archive data object (serialized) and access this object.
Definition: data_archive.h:715
daal::data_management::interface1::NumericTableFeature::NumericTableFeature
NumericTableFeature()
Definition: data_dictionary.h:87
daal::data_management::interface1::DictionaryIface::notEqual
Definition: data_dictionary.h:173
daal::data_management::interface1::Dictionary::operator[]
Feature & operator[](const size_t idx)
Definition: data_dictionary.h:327
daal::data_management::interface1::Dictionary::create
static services::SharedPtr< Dictionary > create(services::Status *stat=NULL)
Definition: data_dictionary.h:225
daal::services::ErrorIncorrectNumberOfFeatures
Definition: error_indexes.h:96
daal::data_management::interface1::Dictionary::getErrors
DAAL_DEPRECATED services::SharedPtr< services::KernelErrorCollection > getErrors()
Definition: data_dictionary.h:394
daal::services::SerializationTag
Definition: error_indexes.h:83
daal_defines.h
daal::data_management::interface1::Dictionary::getNumberOfFeatures
size_t getNumberOfFeatures() const
Definition: data_dictionary.h:308
daal::data_management::interface1::Dictionary::setFeature
services::Status setFeature(size_t idx)
Definition: data_dictionary.h:367
daal::data_management::interface1::NumericTableFeature::operator=
NumericTableFeature & operator=(const NumericTableFeature &f)
Definition: data_dictionary.h:99
daal::data_management::interface1::Dictionary::getSerializationTag
virtual int getSerializationTag() const DAAL_C11_OVERRIDE
Definition: data_dictionary.h:188
daal::data_management::interface1::NumericTableFeature::getSerializationTag
virtual int getSerializationTag() const DAAL_C11_OVERRIDE
Definition: data_dictionary.h:153
daal::data_management::interface1::Dictionary::setNumberOfFeatures
virtual services::Status setNumberOfFeatures(size_t numberOfFeatures)
Definition: data_dictionary.h:289
daal::data_management::interface1::Dictionary::setAllFeatures
services::Status setAllFeatures()
Definition: data_dictionary.h:278
daal::data_management::interface1::Dictionary::Dictionary
Dictionary(size_t nfeat, FeaturesEqual featuresEqual=notEqual)
Definition: data_dictionary.h:196
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:346
daal::data_management::interface1::DictionaryIface::FeaturesEqual
FeaturesEqual
Enumeration to specify whether the Data Dictionary contains equal features.
Definition: data_dictionary.h:171
daal::data_management::interface1::NumericTableFeature::setType
void setType()
Definition: data_dictionary.h:117
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:209
daal::services::ErrorUndefinedFeature
Definition: error_indexes.h:166
daal::data_management::interface1::Dictionary::setAllFeatures
virtual services::Status setAllFeatures(const Feature &defaultFeature)
Definition: data_dictionary.h:254
daal::data_management::interface1::Dictionary::Dictionary
Dictionary()
Definition: data_dictionary.h:218
daal::data_management::interface1::SerializationIface
Abstract interface class that defines the interface for serialization and deserialization.
Definition: data_serialize.h:76
daal::data_management::interface1::NumericTableFeature
Data structure describes the Numeric Table feature.
Definition: data_dictionary.h:74
daal::data_management::interface1::Dictionary::getFeaturesEqual
FeaturesEqual getFeaturesEqual() const
Definition: data_dictionary.h:317
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:184

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