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

numeric_table.h
1 /* file: numeric_table.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 // Declaration and implementation of the base class for numeric tables.
21 //--
22 */
23 
24 
25 #ifndef __NUMERIC_TABLE_H__
26 #define __NUMERIC_TABLE_H__
27 
28 #include "services/base.h"
29 #include "services/daal_defines.h"
30 #include "services/daal_memory.h"
31 #include "services/error_handling.h"
32 #include "algorithms/algorithm_types.h"
33 #include "data_management/data/data_collection.h"
34 #include "data_management/data/data_dictionary.h"
35 
36 #include "data_management/data/numeric_types.h"
37 
38 namespace daal
39 {
41 namespace data_management
42 {
43 
44 namespace interface1
45 {
50 class NumericTable;
51 
56 template<typename DataType = DAAL_DATA_TYPE>
57 class DAAL_EXPORT BlockDescriptor
58 {
59 public:
61  BlockDescriptor() : _ptr(), _buffer(), _capacity(0), _ncols(0), _nrows(0), _colsOffset(0), _rowsOffset(0), _rwFlag(0), _pPtr(0), _rawPtr(0)
62  {}
63 
65  ~BlockDescriptor() { freeBuffer(); }
66 
71  inline DataType *getBlockPtr() const
72  {
73  if(_rawPtr)
74  {
75  return (DataType *)_rawPtr;
76  }
77  return _ptr.get();
78  }
79 
84  inline services::SharedPtr<DataType> getBlockSharedPtr() const
85  {
86  if(_rawPtr)
87  {
88  return services::SharedPtr<DataType>(services::reinterpretPointerCast<DataType, byte>(*_pPtr), (DataType *)_rawPtr);
89  }
90  return _ptr;
91  }
92 
97  inline size_t getNumberOfColumns() const { return _ncols; }
98 
103  inline size_t getNumberOfRows() const { return _nrows; }
104 
108  inline void reset()
109  {
110  _colsOffset = 0;
111  _rowsOffset = 0;
112  _rwFlag = 0;
113  _pPtr = NULL;
114  _rawPtr = NULL;
115  }
116 
117 public:
124  inline void setPtr( DataType *ptr, size_t nColumns, size_t nRows )
125  {
126  _ptr = services::SharedPtr<DataType>(ptr, services::EmptyDeleter());
127  _ncols = nColumns;
128  _nrows = nRows;
129  }
130 
137  void setPtr(services::SharedPtr<byte> *pPtr, byte *rawPtr, size_t nColumns, size_t nRows )
138  {
139  _pPtr = pPtr;
140  _rawPtr = rawPtr;
141  _ncols = nColumns;
142  _nrows = nRows;
143  }
144 
153  inline bool resizeBuffer( size_t nColumns, size_t nRows, size_t auxMemorySize = 0 )
154  {
155  _ncols = nColumns;
156  _nrows = nRows;
157 
158  size_t newSize = nColumns * nRows * sizeof(DataType) + auxMemorySize;
159 
160  if ( newSize > _capacity )
161  {
162  freeBuffer();
163  _buffer = services::SharedPtr<DataType>((DataType *)daal::services::daal_malloc(newSize), services::ServiceDeleter());
164  if ( _buffer != 0 )
165  {
166  _capacity = newSize;
167  }
168  else
169  {
170  return false;
171  }
172 
173  }
174 
175  _ptr = _buffer;
176  if(!auxMemorySize)
177  {
178  if(_aux_ptr)
179  {
180  _aux_ptr = services::SharedPtr<DataType>();
181  }
182  }
183  else
184  {
185  _aux_ptr = services::SharedPtr<DataType>(_buffer, _buffer.get() + nColumns * nRows);
186  }
187 
188  return true;
189  }
190 
197  inline void setDetails( size_t columnIdx, size_t rowIdx, int rwFlag )
198  {
199  _colsOffset = columnIdx;
200  _rowsOffset = rowIdx;
201  _rwFlag = rwFlag;
202  }
203 
208  inline size_t getColumnsOffset() const { return _colsOffset; }
209 
214  inline size_t getRowsOffset() const { return _rowsOffset; }
215 
220  inline size_t getRWFlag() const { return _rwFlag; }
221 
226  inline void *getAdditionalBufferPtr() const { return _aux_ptr.get(); }
227  inline services::SharedPtr<DataType> getAdditionalBufferSharedPtr() const { return _aux_ptr; }
228 
229 protected:
233  void freeBuffer()
234  {
235  if(_buffer)
236  {
237  _buffer = services::SharedPtr<DataType>();
238  }
239  _capacity = 0;
240  }
241 
242 private:
243  services::SharedPtr<DataType> _ptr;
244  size_t _nrows;
245  size_t _ncols;
246 
247  size_t _colsOffset;
248  size_t _rowsOffset;
249  int _rwFlag;
250 
251  services::SharedPtr<DataType> _aux_ptr;
252 
253  services::SharedPtr<DataType> _buffer; /*<! Pointer to the buffer */
254  size_t _capacity; /*<! Buffer size in bytes */
255 
256  services::SharedPtr<byte> *_pPtr;
257  byte *_rawPtr;
258 };
259 
265 class NumericTableIface
266 {
267 public:
268  virtual ~NumericTableIface()
269  {}
274  enum MemoryStatus
275  {
276  notAllocated,
277  userAllocated,
278  internallyAllocated
279  };
280 
285  enum AllocationFlag
286  {
287  doNotAllocate = 0,
288  notAllocate = 0,
289  doAllocate = 1
290  };
291 
296  enum BasicStatisticsId
297  {
298  minimum = 0,
299  maximum = 1,
300  sum = 2,
301  sumSquares = 3
302  };
303 
308  enum FeatureBasicStatistics
309  {
310  counters
311  };
312 
317  enum NormalizationType
318  {
319  nonNormalized = 0,
320  standardScoreNormalized = 1,
321  minMaxNormalized = 2
322  };
323 
328  enum StorageLayout
329  {
330  soa = 1, // 1
331  aos = 2, // 2
332  csrArray = 1 << 4,
333  upperPackedSymmetricMatrix = 1 << 8,
334  lowerPackedSymmetricMatrix = 2 << 8,
335  upperPackedTriangularMatrix = 1 << 7,
336  lowerPackedTriangularMatrix = 4 << 8,
337  arrow = 8 << 8,
338 
339  layout_unknown = 0x80000000 // the last bit set
340  };
341 
347  DAAL_DEPRECATED_VIRTUAL virtual services::Status setDictionary( NumericTableDictionary *ddict ) { return services::Status(); }
348 
354  DAAL_DEPRECATED_VIRTUAL virtual NumericTableDictionary *getDictionary() const = 0;
355 
360  virtual NumericTableDictionaryPtr getDictionarySharedPtr() const = 0;
361 
366  DAAL_DEPRECATED_VIRTUAL virtual services::Status resetDictionary() { return services::Status(); }
367 
373  virtual features::FeatureType getFeatureType(size_t feature_idx) const = 0;
374 
380  virtual size_t getNumberOfCategories(size_t feature_idx) const = 0;
381 
386  virtual StorageLayout getDataLayout() const = 0;
387 
391  virtual services::Status resize(size_t nrows) = 0;
392 
399  DAAL_DEPRECATED_VIRTUAL virtual services::Status setNumberOfColumns(size_t ncol) = 0;
400 
407  DAAL_DEPRECATED_VIRTUAL virtual services::Status setNumberOfRows(size_t nrow) = 0;
408 
413  DAAL_DEPRECATED_VIRTUAL virtual services::Status allocateDataMemory(daal::MemType type = daal::dram) = 0;
414 
419  DAAL_DEPRECATED_VIRTUAL virtual void freeDataMemory() = 0;
420 
424  virtual services::Status allocateBasicStatistics() = 0;
425 
432  virtual services::Status check(const char *description, bool checkDataAllocation = true) const = 0;
433 
434 };
435 } // namespace interface1
436 using interface1::BlockDescriptor;
437 using interface1::NumericTableIface;
438 
439 const int packed_mask = (int)NumericTableIface::csrArray |
440  (int)NumericTableIface::upperPackedSymmetricMatrix |
441  (int)NumericTableIface::lowerPackedSymmetricMatrix |
442  (int)NumericTableIface::upperPackedTriangularMatrix |
443  (int)NumericTableIface::lowerPackedTriangularMatrix;
444 
445 namespace interface1
446 {
452 class DenseNumericTableIface
453 {
454 public:
455  virtual ~DenseNumericTableIface()
456  {}
467  virtual services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<double> &block) = 0;
468 
479  virtual services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<float> &block) = 0;
480 
491  virtual services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<int> &block) = 0;
492 
497  virtual services::Status releaseBlockOfRows(BlockDescriptor<double> &block) = 0;
498 
503  virtual services::Status releaseBlockOfRows(BlockDescriptor<float> &block) = 0;
504 
509  virtual services::Status releaseBlockOfRows(BlockDescriptor<int> &block) = 0;
510 
522  virtual services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
523  ReadWriteMode rwflag, BlockDescriptor<double> &block) = 0;
524 
536  virtual services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
537  ReadWriteMode rwflag, BlockDescriptor<float> &block) = 0;
538 
550  virtual services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
551  ReadWriteMode rwflag, BlockDescriptor<int> &block) = 0;
552 
557  virtual services::Status releaseBlockOfColumnValues(BlockDescriptor<double> &block) = 0;
558 
563  virtual services::Status releaseBlockOfColumnValues(BlockDescriptor<float> &block) = 0;
564 
569  virtual services::Status releaseBlockOfColumnValues(BlockDescriptor<int> &block) = 0;
570 };
571 
577 class DAAL_EXPORT NumericTable : public SerializationIface, public NumericTableIface, public DenseNumericTableIface
578 {
579 public:
580  DAAL_CAST_OPERATOR(NumericTable);
581 
587  DAAL_DEPRECATED NumericTable( NumericTableDictionary *ddict )
588  {
589  _obsnum = 0;
590  _ddict = NumericTableDictionaryPtr(ddict, services::EmptyDeleter());
591  _layout = layout_unknown;
592  _memStatus = notAllocated;
593  _normalizationFlag = NumericTable::nonNormalized;
594  }
595 
600  NumericTable( NumericTableDictionaryPtr ddict )
601  {
602  _obsnum = 0;
603  _ddict = ddict;
604  _layout = layout_unknown;
605  _memStatus = notAllocated;
606  _normalizationFlag = NumericTable::nonNormalized;
607  }
608 
615  NumericTable( size_t featnum, size_t obsnum, DictionaryIface::FeaturesEqual featuresEqual = DictionaryIface::notEqual )
616  {
617  _obsnum = obsnum;
618  _ddict = NumericTableDictionaryPtr(new NumericTableDictionary(featnum, featuresEqual));
619  _layout = layout_unknown;
620  _memStatus = notAllocated;
621  _normalizationFlag = NumericTable::nonNormalized;
622  }
623 
625  virtual ~NumericTable() {}
626 
627  DAAL_DEPRECATED_VIRTUAL virtual services::Status setDictionary( NumericTableDictionary *ddict ) DAAL_C11_OVERRIDE
628  {
629  _ddict = NumericTableDictionaryPtr(ddict, services::EmptyDeleter());
630  return services::Status();
631  }
632 
633  DAAL_DEPRECATED_VIRTUAL virtual NumericTableDictionary *getDictionary() const DAAL_C11_OVERRIDE { return _ddict.get(); }
634 
635  virtual NumericTableDictionaryPtr getDictionarySharedPtr() const DAAL_C11_OVERRIDE { return _ddict; }
636 
637  DAAL_DEPRECATED_VIRTUAL virtual services::Status resetDictionary() DAAL_C11_OVERRIDE { return services::Status(); }
638 
639  virtual services::Status resize(size_t nrows) DAAL_C11_OVERRIDE
640  {
641  size_t obsnum = _obsnum;
642  services::Status s = setNumberOfRowsImpl(nrows);
643  if((_memStatus != userAllocated && obsnum < nrows) || _memStatus == notAllocated)
644  {
645  s |= allocateDataMemoryImpl();
646  }
647  return s;
648  }
649 
654  size_t getNumberOfColumns() const
655  {
656  return _ddict->getNumberOfFeatures();
657  }
658 
663  size_t getNumberOfRows() const { return _obsnum; }
664 
665  DAAL_DEPRECATED_VIRTUAL services::Status setNumberOfColumns(size_t ncol) DAAL_C11_OVERRIDE
666  {
667  return setNumberOfColumnsImpl(ncol);
668  }
669 
670  DAAL_DEPRECATED_VIRTUAL services::Status setNumberOfRows(size_t nrow) DAAL_C11_OVERRIDE
671  {
672  return setNumberOfRowsImpl(nrow);
673  }
674 
675  DAAL_DEPRECATED_VIRTUAL services::Status allocateDataMemory(daal::MemType type = daal::dram) DAAL_C11_OVERRIDE
676  {
677  return allocateDataMemoryImpl(type);
678  }
679 
680  DAAL_DEPRECATED_VIRTUAL void freeDataMemory() DAAL_C11_OVERRIDE
681  {
682  freeDataMemoryImpl();
683  }
684 
685  StorageLayout getDataLayout() const DAAL_C11_OVERRIDE
686  {
687  return _layout;
688  }
689 
690  features::FeatureType getFeatureType(size_t feature_idx) const DAAL_C11_OVERRIDE
691  {
692  if ( _ddict.get() != NULL && _ddict->getNumberOfFeatures() > feature_idx )
693  {
694  const NumericTableFeature &f = (*_ddict)[feature_idx];
695  return f.featureType;
696  }
697  else
698  {
699  /* If no dictionary was set, all features are considered numeric */
700  return features::DAAL_CONTINUOUS;
701  }
702  }
703 
704  size_t getNumberOfCategories(size_t feature_idx) const DAAL_C11_OVERRIDE
705  {
706  if ( _ddict.get() != NULL && _ddict->getNumberOfFeatures() > feature_idx &&
707  getFeatureType(feature_idx) != features::DAAL_CONTINUOUS )
708  {
709  const NumericTableFeature &f = (*_ddict)[feature_idx];
710  return f.categoryNumber;
711  }
712  else
713  {
714  /* If no dictionary was set, all features are considered numeric */
715  return -1;
716  }
717  }
718 
722  virtual MemoryStatus getDataMemoryStatus() const { return _memStatus; }
723 
729  bool isNormalized(NormalizationType flag) const
730  {
731  return (_normalizationFlag == flag);
732  }
733 
739  NormalizationType setNormalizationFlag(NormalizationType flag)
740  {
741  NormalizationType oldValue = _normalizationFlag;
742  _normalizationFlag = flag;
743  return oldValue;
744  }
745 
751  DAAL_DEPRECATED services::SharedPtr<services::KernelErrorCollection> getErrors()
752  {
753  return _status.getCollection()->getErrors();
754  }
755 
759  virtual services::Status allocateBasicStatistics() DAAL_C11_OVERRIDE;
760 
764  virtual services::Status check(const char *description, bool checkDataAllocation = true) const DAAL_C11_OVERRIDE
765  {
766  if (getDataMemoryStatus() == notAllocated && checkDataAllocation)
767  {
768  return services::Status(services::Error::create(services::ErrorNullNumericTable, services::ArgumentName, description));
769  }
770 
771  if (getNumberOfColumns() == 0)
772  {
773  return services::Status(services::Error::create(services::ErrorIncorrectNumberOfColumns, services::ArgumentName, description));
774  }
775 
776  if (getNumberOfRows() == 0 && getDataMemoryStatus() != notAllocated)
777  {
778  return services::Status(services::Error::create(services::ErrorIncorrectNumberOfRows, services::ArgumentName, description));
779  }
780 
781  return services::Status();
782  }
783 
788  virtual services::Status assign(float value) {return assignImpl<float>(value);}
789 
794  virtual services::Status assign(double value) {return assignImpl<double>(value);}
795 
800  virtual services::Status assign(int value) {return assignImpl<int>(value);}
801 
808  template <typename DataType>
809  DataType getValue(size_t column, size_t row) const
810  {
811  services::Status status;
812  return getValueImpl<DataType>(column, row, status);
813  }
814 
822  template <typename DataType>
823  DataType getValue(size_t column, size_t row, services::Status & status) const
824  {
825  return getValueImpl<DataType>(column, row, status);
826  }
827 
828 public:
833  class BasicStatisticsDataCollection : public algorithms::Argument
834  {
835  public:
836  BasicStatisticsDataCollection() : algorithms::Argument(4) {}
837 
838  services::SharedPtr<NumericTable> get(BasicStatisticsId id)
839  {
840  return services::staticPointerCast<NumericTable, SerializationIface>(Argument::get(id));
841  }
842 
843  void set(BasicStatisticsId id, const services::SharedPtr<NumericTable> &value)
844  {
845  Argument::set(id, value);
846  }
847  };
848 
849  BasicStatisticsDataCollection basicStatistics;
851 protected:
852  NumericTableDictionaryPtr _ddict;
853 
854  size_t _obsnum;
855 
856  MemoryStatus _memStatus;
857  StorageLayout _layout;
858 
859  NormalizationType _normalizationFlag;
860 
861  services::Status _status;
862 
863 protected:
864 
865  NumericTable(NumericTableDictionaryPtr ddict, services::Status &st) :
866  _obsnum(0), _ddict(ddict), _layout(layout_unknown), _memStatus(notAllocated), _normalizationFlag(NumericTable::nonNormalized)
867  {
868  }
869 
870  NumericTable(size_t featnum, size_t obsnum, DictionaryIface::FeaturesEqual featuresEqual, services::Status &st):
871  _obsnum(obsnum), _layout(layout_unknown), _memStatus(notAllocated), _normalizationFlag(NumericTable::nonNormalized)
872  {
873  _ddict = NumericTableDictionary::create(featnum, featuresEqual, &st);
874  if (!st) return;
875  }
876 
877  virtual services::Status setNumberOfColumnsImpl(size_t ncol)
878  {
879  return _ddict->setNumberOfFeatures(ncol);
880  }
881 
882  virtual services::Status setNumberOfRowsImpl(size_t nrow)
883  {
884  _obsnum = nrow;
885  return services::Status();
886  }
887 
888  virtual services::Status allocateDataMemoryImpl(daal::MemType type = daal::dram) { return services::Status(); }
889 
890  virtual void freeDataMemoryImpl() {}
891 
892  template <typename DataType>
893  DataType getValueImpl(size_t column, size_t row, services::Status & status) const
894  {
895  const DataType defaultValue = 0;
896  if (!status)
897  return defaultValue;
898  BlockDescriptor<DataType> bd;
899  status |= const_cast<NumericTable *>(this)->getBlockOfColumnValues(column, row, 1, readOnly, bd);
900  if (!status)
901  return defaultValue;
902  const DataType v = *(bd.getBlockPtr());
903  status |= const_cast<NumericTable *>(this)->releaseBlockOfColumnValues(bd);
904  return v;
905  }
906 
907  virtual float getFloatValueImpl(size_t column, size_t row, services::Status & status) const
908  {
909  return getValueImpl<float>(column, row, status);
910  }
911 
912  virtual double getDoubleValueImpl(size_t column, size_t row, services::Status & status) const
913  {
914  return getValueImpl<double>(column, row, status);
915  }
916 
917  virtual int getIntValueImpl(size_t column, size_t row, services::Status & status) const
918  {
919  return getValueImpl<int>(column, row, status);
920  }
921 
923  template<typename Archive, bool onDeserialize>
924  services::Status serialImpl( Archive *arch )
925  {
926  arch->setSharedPtrObj( _ddict );
927 
928  arch->set( _obsnum );
929 
930  if( onDeserialize )
931  {
932  _memStatus = notAllocated;
933  }
934 
935  arch->set( _layout );
936 
937  return services::Status();
938  }
939 
940 private:
941  template <typename T>
942  services::Status assignImpl(T value)
943  {
944  size_t nRows = getNumberOfRows();
945  size_t nCols = getNumberOfColumns();
946  BlockDescriptor<T> block;
947  DAAL_CHECK(getBlockOfRows(0, nRows, writeOnly, block), services::ErrorMemoryAllocationFailed)
948  T* array = block.getBlockSharedPtr().get();
949  for(size_t i = 0; i < nCols * nRows; i++) {array[i] = value;}
950  releaseBlockOfRows(block);
951  return services::Status();
952  }
953 };
954 typedef services::SharedPtr<NumericTable> NumericTablePtr;
955 typedef services::SharedPtr<const NumericTable> NumericTableConstPtr;
956 
957 template <>
958 inline float NumericTable::getValue<float>(size_t column, size_t row) const
959 {
960  services::Status status;
961  return getFloatValueImpl(column, row, status);
962 }
963 
964 template <>
965 inline double NumericTable::getValue<double>(size_t column, size_t row) const
966 {
967  services::Status status;
968  return getDoubleValueImpl(column, row, status);
969 }
970 
971 template <>
972 inline int NumericTable::getValue<int>(size_t column, size_t row) const
973 {
974  services::Status status;
975  return getIntValueImpl(column, row, status);
976 }
977 
978 template <>
979 inline float NumericTable::getValue<float>(size_t column, size_t row, services::Status & status) const
980 {
981  return getFloatValueImpl(column, row, status);
982 }
983 
984 template <>
985 inline double NumericTable::getValue<double>(size_t column, size_t row, services::Status & status) const
986 {
987  return getDoubleValueImpl(column, row, status);
988 }
989 
990 template <>
991 inline int NumericTable::getValue<int>(size_t column, size_t row, services::Status & status) const
992 {
993  return getIntValueImpl(column, row, status);
994 }
995 
998 } // namespace interface1
999 using interface1::DenseNumericTableIface;
1000 using interface1::NumericTable;
1001 using interface1::NumericTablePtr;
1002 using interface1::NumericTableConstPtr;
1003 
1017 DAAL_EXPORT services::Status checkNumericTable(const NumericTable *nt, const char *description,
1018  const int unexpectedLayouts = 0, const int expectedLayouts = 0, size_t nColumns = 0, size_t nRows = 0,
1019  bool checkDataAllocation = true);
1026 template<typename DataType>
1027 DAAL_EXPORT daal::data_management::NumericTablePtr convertToHomogen(NumericTable &src, daal::MemType type = daal::dram);
1028 }
1029 } // namespace daal
1030 #endif
daal::data_management::interface1::NumericTableIface::setNumberOfColumns
virtual DAAL_DEPRECATED_VIRTUAL services::Status setNumberOfColumns(size_t ncol)=0
daal::data_management::interface1::NumericTable::getDataLayout
StorageLayout getDataLayout() const DAAL_C11_OVERRIDE
Definition: numeric_table.h:685
daal::data_management::interface1::NumericTableIface::sumSquares
Definition: numeric_table.h:301
daal::data_management::interface1::NumericTableIface::internallyAllocated
Definition: numeric_table.h:278
daal::data_management::interface1::NumericTableIface::maximum
Definition: numeric_table.h:299
daal::data_management::interface1::NumericTable::getValue
DataType getValue(size_t column, size_t row) const
Definition: numeric_table.h:809
daal::data_management::interface1::NumericTable::getDataMemoryStatus
virtual MemoryStatus getDataMemoryStatus() const
Definition: numeric_table.h:722
daal::services::ArgumentName
Definition: error_indexes.h:52
daal::data_management::interface1::NumericTable::getDictionary
virtual DAAL_DEPRECATED_VIRTUAL NumericTableDictionary * getDictionary() const DAAL_C11_OVERRIDE
Definition: numeric_table.h:633
daal::data_management::interface1::NumericTableIface::counters
Definition: numeric_table.h:310
daal::data_management::interface1::NumericTableIface::check
virtual services::Status check(const char *description, bool checkDataAllocation=true) const =0
daal::data_management::interface1::NumericTable::NumericTable
NumericTable(NumericTableDictionaryPtr ddict)
Definition: numeric_table.h:600
daal::data_management::interface1::DenseNumericTableIface
Abstract interface class for a data management component responsible for accessing data in the numeri...
Definition: numeric_table.h:452
daal::data_management::interface1::NumericTableIface
Abstract interface class for a data management component responsible for representation of data in th...
Definition: numeric_table.h:265
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::NumericTableIface::resize
virtual services::Status resize(size_t nrows)=0
daal::data_management::interface1::NumericTableIface::doAllocate
Definition: numeric_table.h:289
daal::data_management::interface1::DenseNumericTableIface::releaseBlockOfColumnValues
virtual services::Status releaseBlockOfColumnValues(BlockDescriptor< double > &block)=0
daal::data_management::interface1::BlockDescriptor::getBlockSharedPtr
services::SharedPtr< DataType > getBlockSharedPtr() const
Definition: numeric_table.h:84
daal::data_management::interface1::BlockDescriptor::getAdditionalBufferPtr
void * getAdditionalBufferPtr() const
Definition: numeric_table.h:226
daal::data_management::interface1::NumericTableIface::notAllocated
Definition: numeric_table.h:276
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::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::NumericTableIface::minMaxNormalized
Definition: numeric_table.h:321
daal::data_management::interface1::NumericTable::getNumberOfCategories
size_t getNumberOfCategories(size_t feature_idx) const DAAL_C11_OVERRIDE
Definition: numeric_table.h:704
daal::data_management::interface1::NumericTableIface::standardScoreNormalized
Definition: numeric_table.h:320
daal::data_management::interface1::BlockDescriptor::setPtr
void setPtr(services::SharedPtr< byte > *pPtr, byte *rawPtr, size_t nColumns, size_t nRows)
Definition: numeric_table.h:137
daal::data_management::interface1::BlockDescriptor::getNumberOfRows
size_t getNumberOfRows() const
Definition: numeric_table.h:103
daal::data_management::interface1::NumericTableIface::resetDictionary
virtual DAAL_DEPRECATED_VIRTUAL services::Status resetDictionary()
Definition: numeric_table.h:366
daal::data_management::interface1::NumericTableIface::getNumberOfCategories
virtual size_t getNumberOfCategories(size_t feature_idx) const =0
daal::data_management::convertToHomogen
DAAL_EXPORT daal::data_management::NumericTablePtr convertToHomogen(NumericTable &src, daal::MemType type=daal::dram)
daal::services::ErrorNullNumericTable
Definition: error_indexes.h:115
daal::data_management::interface1::NumericTable::setNumberOfColumns
DAAL_DEPRECATED_VIRTUAL services::Status setNumberOfColumns(size_t ncol) DAAL_C11_OVERRIDE
Definition: numeric_table.h:665
daal::data_management::interface1::BlockDescriptor::getColumnsOffset
size_t getColumnsOffset() const
Definition: numeric_table.h:208
daal::data_management::interface1::NumericTableIface::notAllocate
Definition: numeric_table.h:288
daal::data_management::interface1::BlockDescriptor::reset
void reset()
Definition: numeric_table.h:108
daal::data_management::interface1::NumericTable::getErrors
DAAL_DEPRECATED services::SharedPtr< services::KernelErrorCollection > getErrors()
Definition: numeric_table.h:751
daal::data_management::interface1::NumericTableIface::minimum
Definition: numeric_table.h:298
daal::MemType
MemType
Definition: daal_defines.h:147
daal::data_management::interface1::NumericTable::resetDictionary
virtual DAAL_DEPRECATED_VIRTUAL services::Status resetDictionary() DAAL_C11_OVERRIDE
Definition: numeric_table.h:637
daal::data_management::interface1::NumericTable::setDictionary
virtual DAAL_DEPRECATED_VIRTUAL services::Status setDictionary(NumericTableDictionary *ddict) DAAL_C11_OVERRIDE
Definition: numeric_table.h:627
daal::data_management::interface1::BlockDescriptor::getRowsOffset
size_t getRowsOffset() const
Definition: numeric_table.h:214
daal::data_management::interface1::NumericTable::getFeatureType
features::FeatureType getFeatureType(size_t feature_idx) const DAAL_C11_OVERRIDE
Definition: numeric_table.h:690
daal::data_management::interface1::NumericTableIface::userAllocated
Definition: numeric_table.h:277
daal_defines.h
daal::data_management::interface1::SerializationIface
Abstract interface class that defines the interface for serialization and deserialization.
Definition: data_serialize.h:52
daal::data_management::interface1::NumericTableIface::getDataLayout
virtual StorageLayout getDataLayout() const =0
daal::data_management::interface1::NumericTable::isNormalized
bool isNormalized(NormalizationType flag) const
Definition: numeric_table.h:729
daal::data_management::interface1::NumericTable::assign
virtual services::Status assign(int value)
Definition: numeric_table.h:800
daal::data_management::interface1::NumericTableIface::doNotAllocate
Definition: numeric_table.h:287
daal::data_management::interface1::NumericTable::getNumberOfColumns
size_t getNumberOfColumns() const
Definition: numeric_table.h:654
daal::data_management::interface1::NumericTableIface::getFeatureType
virtual features::FeatureType getFeatureType(size_t feature_idx) const =0
daal::data_management::interface1::NumericTable::assign
virtual services::Status assign(double value)
Definition: numeric_table.h:794
daal::data_management::interface1::NumericTable::resize
virtual services::Status resize(size_t nrows) DAAL_C11_OVERRIDE
Definition: numeric_table.h:639
daal::data_management::interface1::BlockDescriptor::setPtr
void setPtr(DataType *ptr, size_t nColumns, size_t nRows)
Definition: numeric_table.h:124
daal::data_management::interface1::NumericTable::getNumberOfRows
size_t getNumberOfRows() const
Definition: numeric_table.h:663
daal::data_management::interface1::NumericTable::NumericTable
NumericTable(size_t featnum, size_t obsnum, DictionaryIface::FeaturesEqual featuresEqual=DictionaryIface::notEqual)
Definition: numeric_table.h:615
daal::data_management::interface1::NumericTableIface::AllocationFlag
AllocationFlag
Enumeration to specify whether the Numeric Table must allocate memory.
Definition: numeric_table.h:285
daal::data_management::interface1::NumericTableIface::FeatureBasicStatistics
FeatureBasicStatistics
Enumeration to specify feature-specific estimates of basic statistics stored.
Definition: numeric_table.h:308
daal::data_management::interface1::NumericTable::getValue
DataType getValue(size_t column, size_t row, services::Status &status) const
Definition: numeric_table.h:823
daal::data_management::interface1::NumericTableIface::MemoryStatus
MemoryStatus
Enumeration to specify the status of memory related to the Numeric Table.
Definition: numeric_table.h:274
daal::data_management::interface1::NumericTable::NumericTable
DAAL_DEPRECATED NumericTable(NumericTableDictionary *ddict)
Definition: numeric_table.h:587
daal::data_management::interface1::NumericTableIface::nonNormalized
Definition: numeric_table.h:319
daal::dram
Definition: daal_defines.h:149
daal::services::daal_malloc
DAAL_EXPORT void * daal_malloc(size_t size, size_t alignment=DAAL_MALLOC_DEFAULT_ALIGNMENT)
daal::data_management::interface1::NumericTable::setNumberOfRows
DAAL_DEPRECATED_VIRTUAL services::Status setNumberOfRows(size_t nrow) DAAL_C11_OVERRIDE
Definition: numeric_table.h:670
daal::data_management::interface1::NumericTableIface::setDictionary
virtual DAAL_DEPRECATED_VIRTUAL services::Status setDictionary(NumericTableDictionary *ddict)
Definition: numeric_table.h:347
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:188
daal::data_management::interface1::NumericTable::assign
virtual services::Status assign(float value)
Definition: numeric_table.h:788
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
Base class that manages buffer memory for read/write operations required by numeric tables...
Definition: numeric_table.h:57
daal::data_management::interface1::NumericTableIface::allocateBasicStatistics
virtual services::Status allocateBasicStatistics()=0
daal::data_management::interface1::NumericTableIface::NormalizationType
NormalizationType
Enumeration to specify types of normalization.
Definition: numeric_table.h:317
daal::data_management::interface1::NumericTableIface::getDictionary
virtual DAAL_DEPRECATED_VIRTUAL NumericTableDictionary * getDictionary() const =0
daal::data_management::interface1::DenseNumericTableIface::releaseBlockOfRows
virtual services::Status releaseBlockOfRows(BlockDescriptor< double > &block)=0
daal::data_management::interface1::NumericTable::getDictionarySharedPtr
virtual NumericTableDictionaryPtr getDictionarySharedPtr() const DAAL_C11_OVERRIDE
Definition: numeric_table.h:635
daal::services::ErrorMemoryAllocationFailed
Definition: error_indexes.h:150
daal::services::ErrorIncorrectNumberOfColumns
Definition: error_indexes.h:116
daal::data_management::interface1::NumericTable::BasicStatisticsDataCollection
Basic statistics for each column of original Numeric Table.
Definition: numeric_table.h:833
daal::data_management::interface1::NumericTableFeature
Data structure describes the Numeric Table feature.
Definition: data_dictionary.h:53
daal::data_management::interface1::NumericTableIface::StorageLayout
StorageLayout
Storage layouts that may need to be supported.
Definition: numeric_table.h:328
daal::data_management::interface1::BlockDescriptor::getNumberOfColumns
size_t getNumberOfColumns() const
Definition: numeric_table.h:97
daal::data_management::interface1::NumericTableIface::sum
Definition: numeric_table.h:300
daal::services::ErrorIncorrectNumberOfRows
Definition: error_indexes.h:117
daal::data_management::interface1::NumericTableIface::freeDataMemory
virtual DAAL_DEPRECATED_VIRTUAL void freeDataMemory()=0
daal::data_management::interface1::BlockDescriptor::freeBuffer
void freeBuffer()
Definition: numeric_table.h:233
daal::data_management::interface1::NumericTableIface::getDictionarySharedPtr
virtual NumericTableDictionaryPtr getDictionarySharedPtr() const =0
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::algorithms::math::abs::value
Definition: abs_types.h:88
daal::data_management::interface1::NumericTable::setNormalizationFlag
NormalizationType setNormalizationFlag(NormalizationType flag)
Definition: numeric_table.h:739
daal::data_management::interface1::BlockDescriptor::getRWFlag
size_t getRWFlag() const
Definition: numeric_table.h:220
daal::data_management::interface1::NumericTableIface::allocateDataMemory
virtual DAAL_DEPRECATED_VIRTUAL services::Status allocateDataMemory(daal::MemType type=daal::dram)=0
daal::data_management::interface1::NumericTable::allocateDataMemory
DAAL_DEPRECATED_VIRTUAL services::Status allocateDataMemory(daal::MemType type=daal::dram) DAAL_C11_OVERRIDE
Definition: numeric_table.h:675
daal::data_management::interface1::BlockDescriptor::setDetails
void setDetails(size_t columnIdx, size_t rowIdx, int rwFlag)
Definition: numeric_table.h:197
daal::data_management::interface1::BlockDescriptor::getBlockPtr
DataType * getBlockPtr() const
Definition: numeric_table.h:71
daal::data_management::interface1::NumericTable::_ddict
NumericTableDictionaryPtr _ddict
Definition: numeric_table.h:852
daal::data_management::interface1::BlockDescriptor::resizeBuffer
bool resizeBuffer(size_t nColumns, size_t nRows, size_t auxMemorySize=0)
Definition: numeric_table.h:153
daal::data_management::interface1::NumericTableIface::setNumberOfRows
virtual DAAL_DEPRECATED_VIRTUAL services::Status setNumberOfRows(size_t nrow)=0
daal::data_management::interface1::NumericTable::freeDataMemory
DAAL_DEPRECATED_VIRTUAL void freeDataMemory() DAAL_C11_OVERRIDE
Definition: numeric_table.h:680
daal::data_management::interface1::NumericTableIface::BasicStatisticsId
BasicStatisticsId
Enumeration to specify estimates of basic statistics stored.
Definition: numeric_table.h:296

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