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

numeric_table.h
1 /* file: numeric_table.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 // Declaration and implementation of the base class for numeric tables.
19 //--
20 */
21 
22 
23 #ifndef __NUMERIC_TABLE_H__
24 #define __NUMERIC_TABLE_H__
25 
26 #include "services/base.h"
27 #include "services/daal_defines.h"
28 #include "services/daal_memory.h"
29 #include "services/error_handling.h"
30 #include "algorithms/algorithm_types.h"
31 #include "data_management/data/data_collection.h"
32 #include "data_management/data/data_dictionary.h"
33 
34 #include "data_management/data/numeric_types.h"
35 
36 namespace daal
37 {
39 namespace data_management
40 {
41 
42 namespace interface1
43 {
48 class NumericTable;
49 
54 template<typename DataType = DAAL_DATA_TYPE>
55 class DAAL_EXPORT BlockDescriptor
56 {
57 public:
59  BlockDescriptor() : _ptr(), _buffer(), _capacity(0), _ncols(0), _nrows(0), _colsOffset(0), _rowsOffset(0), _rwFlag(0), _pPtr(0), _rawPtr(0)
60  {}
61 
63  ~BlockDescriptor() { freeBuffer(); }
64 
69  inline DataType *getBlockPtr() const
70  {
71  if(_rawPtr)
72  {
73  return (DataType *)_rawPtr;
74  }
75  return _ptr.get();
76  }
77 
82  inline services::SharedPtr<DataType> getBlockSharedPtr() const
83  {
84  if(_rawPtr)
85  {
86  return services::SharedPtr<DataType>(services::reinterpretPointerCast<DataType, byte>(*_pPtr), (DataType *)_rawPtr);
87  }
88  return _ptr;
89  }
90 
95  inline size_t getNumberOfColumns() const { return _ncols; }
96 
101  inline size_t getNumberOfRows() const { return _nrows; }
102 
106  inline void reset()
107  {
108  _colsOffset = 0;
109  _rowsOffset = 0;
110  _rwFlag = 0;
111  _pPtr = NULL;
112  _rawPtr = NULL;
113  }
114 
115 public:
122  inline void setPtr( DataType *ptr, size_t nColumns, size_t nRows )
123  {
124  _ptr = services::SharedPtr<DataType>(ptr, services::EmptyDeleter());
125  _ncols = nColumns;
126  _nrows = nRows;
127  }
128 
135  void setPtr(services::SharedPtr<byte> *pPtr, byte *rawPtr, size_t nColumns, size_t nRows )
136  {
137  _pPtr = pPtr;
138  _rawPtr = rawPtr;
139  _ncols = nColumns;
140  _nrows = nRows;
141  }
142 
151  inline bool resizeBuffer( size_t nColumns, size_t nRows, size_t auxMemorySize = 0 )
152  {
153  _ncols = nColumns;
154  _nrows = nRows;
155 
156  size_t newSize = nColumns * nRows * sizeof(DataType) + auxMemorySize;
157 
158  if ( newSize > _capacity )
159  {
160  freeBuffer();
161  _buffer = services::SharedPtr<DataType>((DataType *)daal::services::daal_malloc(newSize), services::ServiceDeleter());
162  if ( _buffer != 0 )
163  {
164  _capacity = newSize;
165  }
166  else
167  {
168  return false;
169  }
170 
171  }
172 
173  _ptr = _buffer;
174  if(!auxMemorySize)
175  {
176  if(_aux_ptr)
177  {
178  _aux_ptr = services::SharedPtr<DataType>();
179  }
180  }
181  else
182  {
183  _aux_ptr = services::SharedPtr<DataType>(_buffer, _buffer.get() + nColumns * nRows);
184  }
185 
186  return true;
187  }
188 
195  inline void setDetails( size_t columnIdx, size_t rowIdx, int rwFlag )
196  {
197  _colsOffset = columnIdx;
198  _rowsOffset = rowIdx;
199  _rwFlag = rwFlag;
200  }
201 
206  inline size_t getColumnsOffset() const { return _colsOffset; }
207 
212  inline size_t getRowsOffset() const { return _rowsOffset; }
213 
218  inline size_t getRWFlag() const { return _rwFlag; }
219 
224  inline void *getAdditionalBufferPtr() const { return _aux_ptr.get(); }
225  inline services::SharedPtr<DataType> getAdditionalBufferSharedPtr() const { return _aux_ptr; }
226 
227 protected:
231  void freeBuffer()
232  {
233  if(_buffer)
234  {
235  _buffer = services::SharedPtr<DataType>();
236  }
237  _capacity = 0;
238  }
239 
240 private:
241  services::SharedPtr<DataType> _ptr;
242  size_t _nrows;
243  size_t _ncols;
244 
245  size_t _colsOffset;
246  size_t _rowsOffset;
247  int _rwFlag;
248 
249  services::SharedPtr<DataType> _aux_ptr;
250 
251  services::SharedPtr<DataType> _buffer; /*<! Pointer to the buffer */
252  size_t _capacity; /*<! Buffer size in bytes */
253 
254  services::SharedPtr<byte> *_pPtr;
255  byte *_rawPtr;
256 };
257 
263 class NumericTableIface
264 {
265 public:
266  virtual ~NumericTableIface()
267  {}
272  enum MemoryStatus
273  {
274  notAllocated,
275  userAllocated,
276  internallyAllocated
277  };
278 
283  enum AllocationFlag
284  {
285  doNotAllocate = 0,
286  notAllocate = 0,
287  doAllocate = 1
288  };
289 
294  enum BasicStatisticsId
295  {
296  minimum = 0,
297  maximum = 1,
298  sum = 2,
299  sumSquares = 3
300  };
301 
306  enum FeatureBasicStatistics
307  {
308  counters
309  };
310 
315  enum NormalizationType
316  {
317  nonNormalized = 0,
318  standardScoreNormalized = 1,
319  minMaxNormalized = 2
320  };
321 
326  enum StorageLayout
327  {
328  soa = 1, // 1
329  aos = 2, // 2
330  csrArray = 1 << 4,
331  upperPackedSymmetricMatrix = 1 << 8,
332  lowerPackedSymmetricMatrix = 2 << 8,
333  upperPackedTriangularMatrix = 1 << 7,
334  lowerPackedTriangularMatrix = 4 << 8,
335 
336  layout_unknown = 0x80000000 // the last bit set
337  };
338 
344  DAAL_DEPRECATED_VIRTUAL virtual services::Status setDictionary( NumericTableDictionary *ddict ) { return services::Status(); }
345 
351  DAAL_DEPRECATED_VIRTUAL virtual NumericTableDictionary *getDictionary() const = 0;
352 
357  virtual NumericTableDictionaryPtr getDictionarySharedPtr() const = 0;
358 
363  DAAL_DEPRECATED_VIRTUAL virtual services::Status resetDictionary() { return services::Status(); }
364 
370  virtual data_feature_utils::FeatureType getFeatureType(size_t feature_idx) const = 0;
371 
377  virtual size_t getNumberOfCategories(size_t feature_idx) const = 0;
378 
383  virtual StorageLayout getDataLayout() const = 0;
384 
388  virtual services::Status resize(size_t nrows) = 0;
389 
396  DAAL_DEPRECATED_VIRTUAL virtual services::Status setNumberOfColumns(size_t ncol) = 0;
397 
404  DAAL_DEPRECATED_VIRTUAL virtual services::Status setNumberOfRows(size_t nrow) = 0;
405 
410  DAAL_DEPRECATED_VIRTUAL virtual services::Status allocateDataMemory(daal::MemType type = daal::dram) = 0;
411 
416  DAAL_DEPRECATED_VIRTUAL virtual void freeDataMemory() = 0;
417 
421  virtual services::Status allocateBasicStatistics() = 0;
422 
429  virtual services::Status check(const char *description, bool checkDataAllocation = true) const = 0;
430 
431 };
432 } // namespace interface1
433 using interface1::BlockDescriptor;
434 using interface1::NumericTableIface;
435 
436 const int packed_mask = (int)NumericTableIface::csrArray |
437  (int)NumericTableIface::upperPackedSymmetricMatrix |
438  (int)NumericTableIface::lowerPackedSymmetricMatrix |
439  (int)NumericTableIface::upperPackedTriangularMatrix |
440  (int)NumericTableIface::lowerPackedTriangularMatrix;
441 
442 namespace interface1
443 {
449 class DenseNumericTableIface
450 {
451 public:
452  virtual ~DenseNumericTableIface()
453  {}
464  virtual services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<double> &block) = 0;
465 
476  virtual services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<float> &block) = 0;
477 
488  virtual services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<int> &block) = 0;
489 
494  virtual services::Status releaseBlockOfRows(BlockDescriptor<double> &block) = 0;
495 
500  virtual services::Status releaseBlockOfRows(BlockDescriptor<float> &block) = 0;
501 
506  virtual services::Status releaseBlockOfRows(BlockDescriptor<int> &block) = 0;
507 
519  virtual services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
520  ReadWriteMode rwflag, BlockDescriptor<double> &block) = 0;
521 
533  virtual services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
534  ReadWriteMode rwflag, BlockDescriptor<float> &block) = 0;
535 
547  virtual services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
548  ReadWriteMode rwflag, BlockDescriptor<int> &block) = 0;
549 
554  virtual services::Status releaseBlockOfColumnValues(BlockDescriptor<double> &block) = 0;
555 
560  virtual services::Status releaseBlockOfColumnValues(BlockDescriptor<float> &block) = 0;
561 
566  virtual services::Status releaseBlockOfColumnValues(BlockDescriptor<int> &block) = 0;
567 };
568 
574 class DAAL_EXPORT NumericTable : public SerializationIface, public NumericTableIface, public DenseNumericTableIface
575 {
576 public:
577  DAAL_CAST_OPERATOR(NumericTable);
578 
584  DAAL_DEPRECATED NumericTable( NumericTableDictionary *ddict )
585  {
586  _obsnum = 0;
587  _ddict = NumericTableDictionaryPtr(ddict, services::EmptyDeleter());
588  _layout = layout_unknown;
589  _memStatus = notAllocated;
590  _normalizationFlag = NumericTable::nonNormalized;
591  }
592 
597  NumericTable( NumericTableDictionaryPtr ddict )
598  {
599  _obsnum = 0;
600  _ddict = ddict;
601  _layout = layout_unknown;
602  _memStatus = notAllocated;
603  _normalizationFlag = NumericTable::nonNormalized;
604  }
605 
612  NumericTable( size_t featnum, size_t obsnum, DictionaryIface::FeaturesEqual featuresEqual = DictionaryIface::notEqual )
613  {
614  _obsnum = obsnum;
615  _ddict = NumericTableDictionaryPtr(new NumericTableDictionary(featnum, featuresEqual));
616  _layout = layout_unknown;
617  _memStatus = notAllocated;
618  _normalizationFlag = NumericTable::nonNormalized;
619  }
620 
622  virtual ~NumericTable() {}
623 
624  DAAL_DEPRECATED_VIRTUAL virtual services::Status setDictionary( NumericTableDictionary *ddict ) DAAL_C11_OVERRIDE
625  {
626  _ddict = NumericTableDictionaryPtr(ddict, services::EmptyDeleter());
627  return services::Status();
628  }
629 
630  DAAL_DEPRECATED_VIRTUAL virtual NumericTableDictionary *getDictionary() const DAAL_C11_OVERRIDE { return _ddict.get(); }
631 
632  virtual NumericTableDictionaryPtr getDictionarySharedPtr() const DAAL_C11_OVERRIDE { return _ddict; }
633 
634  DAAL_DEPRECATED_VIRTUAL virtual services::Status resetDictionary() DAAL_C11_OVERRIDE { return services::Status(); }
635 
636  virtual services::Status resize(size_t nrows) DAAL_C11_OVERRIDE
637  {
638  size_t obsnum = _obsnum;
639  services::Status s = setNumberOfRowsImpl(nrows);
640  if((_memStatus != userAllocated && obsnum < nrows) || _memStatus == notAllocated)
641  {
642  s |= allocateDataMemoryImpl();
643  }
644  return s;
645  }
646 
651  size_t getNumberOfColumns() const
652  {
653  return _ddict->getNumberOfFeatures();
654  }
655 
660  size_t getNumberOfRows() const { return _obsnum; }
661 
662  DAAL_DEPRECATED_VIRTUAL services::Status setNumberOfColumns(size_t ncol) DAAL_C11_OVERRIDE
663  {
664  return setNumberOfColumnsImpl(ncol);
665  }
666 
667  DAAL_DEPRECATED_VIRTUAL services::Status setNumberOfRows(size_t nrow) DAAL_C11_OVERRIDE
668  {
669  return setNumberOfRowsImpl(nrow);
670  }
671 
672  DAAL_DEPRECATED_VIRTUAL services::Status allocateDataMemory(daal::MemType type = daal::dram) DAAL_C11_OVERRIDE
673  {
674  return allocateDataMemoryImpl(type);
675  }
676 
677  DAAL_DEPRECATED_VIRTUAL void freeDataMemory() DAAL_C11_OVERRIDE
678  {
679  freeDataMemoryImpl();
680  }
681 
682  StorageLayout getDataLayout() const DAAL_C11_OVERRIDE
683  {
684  return _layout;
685  }
686 
687  data_feature_utils::FeatureType getFeatureType(size_t feature_idx) const DAAL_C11_OVERRIDE
688  {
689  if ( _ddict.get() != NULL && _ddict->getNumberOfFeatures() > feature_idx )
690  {
691  const NumericTableFeature &f = (*_ddict)[feature_idx];
692  return f.featureType;
693  }
694  else
695  {
696  /* If no dictionary was set, all features are considered numeric */
697  return data_feature_utils::DAAL_CONTINUOUS;
698  }
699  }
700 
701  size_t getNumberOfCategories(size_t feature_idx) const DAAL_C11_OVERRIDE
702  {
703  if ( _ddict.get() != NULL && _ddict->getNumberOfFeatures() > feature_idx &&
704  getFeatureType(feature_idx) != data_feature_utils::DAAL_CONTINUOUS )
705  {
706  const NumericTableFeature &f = (*_ddict)[feature_idx];
707  return f.categoryNumber;
708  }
709  else
710  {
711  /* If no dictionary was set, all features are considered numeric */
712  return -1;
713  }
714  }
715 
719  virtual MemoryStatus getDataMemoryStatus() const { return _memStatus; }
720 
726  bool isNormalized(NormalizationType flag) const
727  {
728  return (_normalizationFlag == flag);
729  }
730 
736  NormalizationType setNormalizationFlag(NormalizationType flag)
737  {
738  NormalizationType oldValue = _normalizationFlag;
739  _normalizationFlag = flag;
740  return oldValue;
741  }
742 
748  DAAL_DEPRECATED services::SharedPtr<services::KernelErrorCollection> getErrors()
749  {
750  return _status.getCollection()->getErrors();
751  }
752 
756  virtual services::Status allocateBasicStatistics() DAAL_C11_OVERRIDE;
757 
761  virtual services::Status check(const char *description, bool checkDataAllocation = true) const DAAL_C11_OVERRIDE
762  {
763  if (getDataMemoryStatus() == notAllocated && checkDataAllocation)
764  {
765  return services::Status(services::Error::create(services::ErrorNullNumericTable, services::ArgumentName, description));
766  }
767 
768  if (getNumberOfColumns() == 0)
769  {
770  return services::Status(services::Error::create(services::ErrorIncorrectNumberOfColumns, services::ArgumentName, description));
771  }
772 
773  if (getNumberOfRows() == 0 && getDataMemoryStatus() != notAllocated)
774  {
775  return services::Status(services::Error::create(services::ErrorIncorrectNumberOfRows, services::ArgumentName, description));
776  }
777 
778  return services::Status();
779  }
780 
785  virtual services::Status assign(float value) {return assignImpl<float>(value);}
786 
791  virtual services::Status assign(double value) {return assignImpl<double>(value);}
792 
797  virtual services::Status assign(int value) {return assignImpl<int>(value);}
798 
805  template <typename DataType>
806  DataType getValue(size_t column, size_t row) const
807  {
808  services::Status status;
809  return getValueImpl<DataType>(column, row, status);
810  }
811 
819  template <typename DataType>
820  DataType getValue(size_t column, size_t row, services::Status & status) const
821  {
822  return getValueImpl<DataType>(column, row, status);
823  }
824 
825 public:
830  class BasicStatisticsDataCollection : public algorithms::Argument
831  {
832  public:
833  BasicStatisticsDataCollection() : algorithms::Argument(4) {}
834 
835  services::SharedPtr<NumericTable> get(BasicStatisticsId id)
836  {
837  return services::staticPointerCast<NumericTable, SerializationIface>(Argument::get(id));
838  }
839 
840  void set(BasicStatisticsId id, const services::SharedPtr<NumericTable> &value)
841  {
842  Argument::set(id, value);
843  }
844  };
845 
846  BasicStatisticsDataCollection basicStatistics;
848 protected:
849  NumericTableDictionaryPtr _ddict;
850 
851  size_t _obsnum;
852 
853  MemoryStatus _memStatus;
854  StorageLayout _layout;
855 
856  NormalizationType _normalizationFlag;
857 
858  services::Status _status;
859 
860 protected:
861 
862  NumericTable(NumericTableDictionaryPtr ddict, services::Status &st) :
863  _obsnum(0), _ddict(ddict), _layout(layout_unknown), _memStatus(notAllocated), _normalizationFlag(NumericTable::nonNormalized)
864  {
865  }
866 
867  NumericTable(size_t featnum, size_t obsnum, DictionaryIface::FeaturesEqual featuresEqual, services::Status &st):
868  _obsnum(obsnum), _layout(layout_unknown), _memStatus(notAllocated), _normalizationFlag(NumericTable::nonNormalized)
869  {
870  _ddict = NumericTableDictionary::create(featnum, featuresEqual, &st);
871  if (!st) return;
872  }
873 
874  virtual services::Status setNumberOfColumnsImpl(size_t ncol)
875  {
876  return _ddict->setNumberOfFeatures(ncol);
877  }
878 
879  virtual services::Status setNumberOfRowsImpl(size_t nrow)
880  {
881  _obsnum = nrow;
882  return services::Status();
883  }
884 
885  virtual services::Status allocateDataMemoryImpl(daal::MemType type = daal::dram) { return services::Status(); }
886 
887  virtual void freeDataMemoryImpl() {}
888 
889  template <typename DataType>
890  DataType getValueImpl(size_t column, size_t row, services::Status & status) const
891  {
892  const DataType defaultValue = 0;
893  if (!status)
894  return defaultValue;
895  BlockDescriptor<DataType> bd;
896  status |= const_cast<NumericTable *>(this)->getBlockOfColumnValues(column, row, 1, readOnly, bd);
897  if (!status)
898  return defaultValue;
899  const DataType v = *(bd.getBlockPtr());
900  status |= const_cast<NumericTable *>(this)->releaseBlockOfColumnValues(bd);
901  return v;
902  }
903 
904  virtual float getFloatValueImpl(size_t column, size_t row, services::Status & status) const
905  {
906  return getValueImpl<float>(column, row, status);
907  }
908 
909  virtual double getDoubleValueImpl(size_t column, size_t row, services::Status & status) const
910  {
911  return getValueImpl<double>(column, row, status);
912  }
913 
914  virtual int getIntValueImpl(size_t column, size_t row, services::Status & status) const
915  {
916  return getValueImpl<int>(column, row, status);
917  }
918 
920  template<typename Archive, bool onDeserialize>
921  services::Status serialImpl( Archive *arch )
922  {
923  arch->setSharedPtrObj( _ddict );
924 
925  arch->set( _obsnum );
926 
927  if( onDeserialize )
928  {
929  _memStatus = notAllocated;
930  }
931 
932  arch->set( _layout );
933 
934  return services::Status();
935  }
936 
937 private:
938  template <typename T>
939  services::Status assignImpl(T value)
940  {
941  size_t nRows = getNumberOfRows();
942  size_t nCols = getNumberOfColumns();
943  BlockDescriptor<T> block;
944  DAAL_CHECK(getBlockOfRows(0, nRows, writeOnly, block), services::ErrorMemoryAllocationFailed)
945  T* array = block.getBlockSharedPtr().get();
946  for(size_t i = 0; i < nCols * nRows; i++) {array[i] = value;}
947  releaseBlockOfRows(block);
948  return services::Status();
949  }
950 };
951 typedef services::SharedPtr<NumericTable> NumericTablePtr;
952 typedef services::SharedPtr<const NumericTable> NumericTableConstPtr;
953 
954 template <>
955 inline float NumericTable::getValue<float>(size_t column, size_t row) const
956 {
957  services::Status status;
958  return getFloatValueImpl(column, row, status);
959 }
960 
961 template <>
962 inline double NumericTable::getValue<double>(size_t column, size_t row) const
963 {
964  services::Status status;
965  return getDoubleValueImpl(column, row, status);
966 }
967 
968 template <>
969 inline int NumericTable::getValue<int>(size_t column, size_t row) const
970 {
971  services::Status status;
972  return getIntValueImpl(column, row, status);
973 }
974 
975 template <>
976 inline float NumericTable::getValue<float>(size_t column, size_t row, services::Status & status) const
977 {
978  return getFloatValueImpl(column, row, status);
979 }
980 
981 template <>
982 inline double NumericTable::getValue<double>(size_t column, size_t row, services::Status & status) const
983 {
984  return getDoubleValueImpl(column, row, status);
985 }
986 
987 template <>
988 inline int NumericTable::getValue<int>(size_t column, size_t row, services::Status & status) const
989 {
990  return getIntValueImpl(column, row, status);
991 }
992 
995 } // namespace interface1
996 using interface1::DenseNumericTableIface;
997 using interface1::NumericTable;
998 using interface1::NumericTablePtr;
999 using interface1::NumericTableConstPtr;
1000 
1014 DAAL_EXPORT services::Status checkNumericTable(const NumericTable *nt, const char *description,
1015  const int unexpectedLayouts = 0, const int expectedLayouts = 0, size_t nColumns = 0, size_t nRows = 0,
1016  bool checkDataAllocation = true);
1023 template<typename DataType>
1024 DAAL_EXPORT daal::data_management::NumericTablePtr convertToHomogen(NumericTable &src, daal::MemType type = daal::dram);
1025 }
1026 } // namespace daal
1027 #endif
daal::data_management::interface1::NumericTableIface::setDictionary
virtual DAAL_DEPRECATED_VIRTUAL services::Status setDictionary(NumericTableDictionary *ddict)
Definition: numeric_table.h:344
daal::data_management::interface1::NumericTable::freeDataMemory
DAAL_DEPRECATED_VIRTUAL void freeDataMemory() DAAL_C11_OVERRIDE
Definition: numeric_table.h:677
daal::data_management::interface1::NumericTableIface::getDataLayout
virtual StorageLayout getDataLayout() const =0
daal::data_management::interface1::BlockDescriptor::getRWFlag
size_t getRWFlag() const
Definition: numeric_table.h:218
daal::data_management::interface1::NumericTableIface::AllocationFlag
AllocationFlag
Enumeration to specify whether the Numeric Table must allocate memory.
Definition: numeric_table.h:283
daal::data_management::interface1::BlockDescriptor::freeBuffer
void freeBuffer()
Definition: numeric_table.h:231
daal::data_management::interface1::BlockDescriptor::getBlockSharedPtr
services::SharedPtr< DataType > getBlockSharedPtr() const
Definition: numeric_table.h:82
daal::data_management::interface1::NumericTable::getValue
DataType getValue(size_t column, size_t row) const
Definition: numeric_table.h:806
daal::data_management::interface1::NumericTableIface::notAllocated
Definition: numeric_table.h:274
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::NumericTable::NumericTable
NumericTable(NumericTableDictionaryPtr ddict)
Definition: numeric_table.h:597
daal::data_management::interface1::BlockDescriptor::getAdditionalBufferPtr
void * getAdditionalBufferPtr() const
Definition: numeric_table.h:224
daal::data_management::interface1::NumericTable::assign
virtual services::Status assign(double value)
Definition: numeric_table.h:791
daal::data_management::interface1::BlockDescriptor::getNumberOfColumns
size_t getNumberOfColumns() const
Definition: numeric_table.h:95
daal::data_management::interface1::NumericTableIface::allocateDataMemory
virtual DAAL_DEPRECATED_VIRTUAL services::Status allocateDataMemory(daal::MemType type=daal::dram)=0
daal::data_management::interface1::NumericTableIface::NormalizationType
NormalizationType
Enumeration to specify types of normalization.
Definition: numeric_table.h:315
daal::data_management::interface1::NumericTableIface::standardScoreNormalized
Definition: numeric_table.h:318
daal::data_management::interface1::NumericTableIface::resetDictionary
virtual DAAL_DEPRECATED_VIRTUAL services::Status resetDictionary()
Definition: numeric_table.h:363
daal::data_management::convertToHomogen
DAAL_EXPORT daal::data_management::NumericTablePtr convertToHomogen(NumericTable &src, daal::MemType type=daal::dram)
daal::data_management::interface1::NumericTable::getNumberOfCategories
size_t getNumberOfCategories(size_t feature_idx) const DAAL_C11_OVERRIDE
Definition: numeric_table.h:701
daal::data_management::interface1::NumericTableIface::getDictionary
virtual DAAL_DEPRECATED_VIRTUAL NumericTableDictionary * getDictionary() const =0
daal::data_management::interface1::NumericTable::resetDictionary
virtual DAAL_DEPRECATED_VIRTUAL services::Status resetDictionary() DAAL_C11_OVERRIDE
Definition: numeric_table.h:634
daal::data_management::interface1::DenseNumericTableIface::releaseBlockOfColumnValues
virtual services::Status releaseBlockOfColumnValues(BlockDescriptor< double > &block)=0
daal::data_management::interface1::NumericTable::getDictionarySharedPtr
virtual NumericTableDictionaryPtr getDictionarySharedPtr() const DAAL_C11_OVERRIDE
Definition: numeric_table.h:632
daal::services::ErrorIncorrectNumberOfColumns
Definition: error_indexes.h:114
daal::services::ErrorMemoryAllocationFailed
Definition: error_indexes.h:146
daal::data_management::interface1::NumericTable::getNumberOfColumns
size_t getNumberOfColumns() const
Definition: numeric_table.h:651
daal::dram
Definition: daal_defines.h:133
daal::data_management::interface1::NumericTableIface::check
virtual services::Status check(const char *description, bool checkDataAllocation=true) const =0
daal::data_management::interface1::NumericTable::assign
virtual services::Status assign(float value)
Definition: numeric_table.h:785
daal::data_management::interface1::NumericTable::setNumberOfColumns
DAAL_DEPRECATED_VIRTUAL services::Status setNumberOfColumns(size_t ncol) DAAL_C11_OVERRIDE
Definition: numeric_table.h:662
daal::data_management::interface1::NumericTableIface::userAllocated
Definition: numeric_table.h:275
daal_defines.h
daal::data_management::interface1::NumericTableIface::FeatureBasicStatistics
FeatureBasicStatistics
Enumeration to specify feature-specific estimates of basic statistics stored.
Definition: numeric_table.h:306
daal::data_management::interface1::NumericTable::BasicStatisticsDataCollection
Basic statistics for each column of original Numeric Table.
Definition: numeric_table.h:830
daal::data_management::interface1::NumericTable::NumericTable
DAAL_DEPRECATED NumericTable(NumericTableDictionary *ddict)
Definition: numeric_table.h:584
daal::data_management::interface1::BlockDescriptor::resizeBuffer
bool resizeBuffer(size_t nColumns, size_t nRows, size_t auxMemorySize=0)
Definition: numeric_table.h:151
daal::data_management::interface1::NumericTableIface::minimum
Definition: numeric_table.h:296
daal::data_management::interface1::BlockDescriptor::setPtr
void setPtr(services::SharedPtr< byte > *pPtr, byte *rawPtr, size_t nColumns, size_t nRows)
Definition: numeric_table.h:135
daal::data_management::interface1::NumericTable::assign
virtual services::Status assign(int value)
Definition: numeric_table.h:797
daal::data_management::interface1::NumericTable::isNormalized
bool isNormalized(NormalizationType flag) const
Definition: numeric_table.h:726
daal::data_management::interface1::NumericTable::setNormalizationFlag
NormalizationType setNormalizationFlag(NormalizationType flag)
Definition: numeric_table.h:736
daal::data_management::interface1::NumericTableIface::counters
Definition: numeric_table.h:308
daal::data_management::interface1::NumericTable::getDictionary
virtual DAAL_DEPRECATED_VIRTUAL NumericTableDictionary * getDictionary() const DAAL_C11_OVERRIDE
Definition: numeric_table.h:630
daal::data_management::interface1::NumericTable::allocateDataMemory
DAAL_DEPRECATED_VIRTUAL services::Status allocateDataMemory(daal::MemType type=daal::dram) DAAL_C11_OVERRIDE
Definition: numeric_table.h:672
daal::data_management::interface1::NumericTableIface::nonNormalized
Definition: numeric_table.h:317
daal::services::daal_malloc
DAAL_EXPORT void * daal_malloc(size_t size, size_t alignment=DAAL_MALLOC_DEFAULT_ALIGNMENT)
daal::data_management::interface1::NumericTableIface::MemoryStatus
MemoryStatus
Enumeration to specify the status of memory related to the Numeric Table.
Definition: numeric_table.h:272
daal::data_management::interface1::NumericTable
Class for a data management component responsible for representation of data in the numeric format...
Definition: numeric_table.h:574
daal::data_management::interface1::NumericTableIface::StorageLayout
StorageLayout
Storage layouts that may need to be supported.
Definition: numeric_table.h:326
daal::data_management::interface1::NumericTableIface::doNotAllocate
Definition: numeric_table.h:285
daal::data_management::interface1::NumericTable::resize
virtual services::Status resize(size_t nrows) DAAL_C11_OVERRIDE
Definition: numeric_table.h:636
daal::data_management::interface1::NumericTableIface::resize
virtual services::Status resize(size_t nrows)=0
daal::data_management::interface1::NumericTableIface::getNumberOfCategories
virtual size_t getNumberOfCategories(size_t feature_idx) const =0
daal::data_management::interface1::NumericTableIface::getDictionarySharedPtr
virtual NumericTableDictionaryPtr getDictionarySharedPtr() const =0
daal::data_management::interface1::NumericTableIface::maximum
Definition: numeric_table.h:297
daal::data_management::checkNumericTable
DAAL_EXPORT services::Status checkNumericTable(const NumericTable *nt, const char *description, const int unexpectedLayouts=0, const int expectedLayouts=0, size_t nColumns=0, size_t nRows=0, bool checkDataAllocation=true)
daal::data_management::interface1::NumericTable::_ddict
NumericTableDictionaryPtr _ddict
Definition: numeric_table.h:849
daal::data_management::interface1::NumericTableIface::setNumberOfColumns
virtual DAAL_DEPRECATED_VIRTUAL services::Status setNumberOfColumns(size_t ncol)=0
daal::data_management::interface1::NumericTableIface::BasicStatisticsId
BasicStatisticsId
Enumeration to specify estimates of basic statistics stored.
Definition: numeric_table.h:294
daal::data_management::interface1::NumericTable::getErrors
DAAL_DEPRECATED services::SharedPtr< services::KernelErrorCollection > getErrors()
Definition: numeric_table.h:748
daal::data_management::interface1::NumericTable::NumericTable
NumericTable(size_t featnum, size_t obsnum, DictionaryIface::FeaturesEqual featuresEqual=DictionaryIface::notEqual)
Definition: numeric_table.h:612
daal::data_management::interface1::NumericTable::getValue
DataType getValue(size_t column, size_t row, services::Status &status) const
Definition: numeric_table.h:820
daal::data_management::interface1::NumericTableIface::doAllocate
Definition: numeric_table.h:287
daal::data_management::interface1::NumericTable::getFeatureType
data_feature_utils::FeatureType getFeatureType(size_t feature_idx) const DAAL_C11_OVERRIDE
Definition: numeric_table.h:687
daal::data_management::interface1::BlockDescriptor::reset
void reset()
Definition: numeric_table.h:106
daal::services::ErrorIncorrectNumberOfRows
Definition: error_indexes.h:115
daal::data_management::interface1::NumericTable::getNumberOfRows
size_t getNumberOfRows() const
Definition: numeric_table.h:660
daal::data_management::interface1::BlockDescriptor
Base class that manages buffer memory for read/write operations required by numeric tables...
Definition: numeric_table.h:55
daal::data_management::interface1::DenseNumericTableIface
Abstract interface class for a data management component responsible for accessing data in the numeri...
Definition: numeric_table.h:449
daal::data_management::interface1::DictionaryIface::FeaturesEqual
FeaturesEqual
Enumeration to specify whether the Data Dictionary contains equal features.
Definition: data_dictionary.h:145
daal::algorithms::math::abs::value
Definition: abs_types.h:86
daal::data_management::interface1::NumericTableIface::notAllocate
Definition: numeric_table.h:286
daal::data_management::interface1::DenseNumericTableIface::releaseBlockOfRows
virtual services::Status releaseBlockOfRows(BlockDescriptor< double > &block)=0
daal::data_management::interface1::BlockDescriptor::getNumberOfRows
size_t getNumberOfRows() const
Definition: numeric_table.h:101
daal::data_management::interface1::NumericTableIface::internallyAllocated
Definition: numeric_table.h:276
daal::data_management::interface1::NumericTableIface::sum
Definition: numeric_table.h:298
daal::data_management::interface1::NumericTable::getDataLayout
StorageLayout getDataLayout() const DAAL_C11_OVERRIDE
Definition: numeric_table.h:682
daal::data_management::interface1::BlockDescriptor::getRowsOffset
size_t getRowsOffset() const
Definition: numeric_table.h:212
daal::data_management::interface1::NumericTableIface::setNumberOfRows
virtual DAAL_DEPRECATED_VIRTUAL services::Status setNumberOfRows(size_t nrow)=0
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::data_management::interface1::NumericTableIface::sumSquares
Definition: numeric_table.h:299
daal::services::ErrorNullNumericTable
Definition: error_indexes.h:113
daal::data_management::interface1::BlockDescriptor::setDetails
void setDetails(size_t columnIdx, size_t rowIdx, int rwFlag)
Definition: numeric_table.h:195
daal::data_management::interface1::NumericTable::setDictionary
virtual DAAL_DEPRECATED_VIRTUAL services::Status setDictionary(NumericTableDictionary *ddict) DAAL_C11_OVERRIDE
Definition: numeric_table.h:624
daal::data_management::interface1::DenseNumericTableIface::getBlockOfColumnValues
virtual services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num, ReadWriteMode rwflag, BlockDescriptor< double > &block)=0
daal::data_management::interface1::NumericTableIface::getFeatureType
virtual data_feature_utils::FeatureType getFeatureType(size_t feature_idx) const =0
daal::data_management::interface1::NumericTableIface
Abstract interface class for a data management component responsible for representation of data in th...
Definition: numeric_table.h:263
daal::data_management::interface1::NumericTableIface::minMaxNormalized
Definition: numeric_table.h:319
daal::data_management::interface1::BlockDescriptor::setPtr
void setPtr(DataType *ptr, size_t nColumns, size_t nRows)
Definition: numeric_table.h:122
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::BlockDescriptor::getColumnsOffset
size_t getColumnsOffset() const
Definition: numeric_table.h:206
daal::data_management::interface1::NumericTableIface::freeDataMemory
virtual DAAL_DEPRECATED_VIRTUAL void freeDataMemory()=0
daal::data_management::interface1::NumericTableFeature
Data structure describes the Numeric Table feature.
Definition: data_dictionary.h:48
daal::services::ArgumentName
Definition: error_indexes.h:50
daal::data_management::interface1::NumericTable::getDataMemoryStatus
virtual MemoryStatus getDataMemoryStatus() const
Definition: numeric_table.h:719
daal::data_management::interface1::NumericTableIface::allocateBasicStatistics
virtual services::Status allocateBasicStatistics()=0
daal::MemType
MemType
Definition: daal_defines.h:131
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::NumericTable::setNumberOfRows
DAAL_DEPRECATED_VIRTUAL services::Status setNumberOfRows(size_t nrow) DAAL_C11_OVERRIDE
Definition: numeric_table.h:667
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.