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

numeric_table.h
1 /* file: numeric_table.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 // Declaration and implementation of the base class for numeric tables.
45 //--
46 */
47 
48 
49 #ifndef __NUMERIC_TABLE_H__
50 #define __NUMERIC_TABLE_H__
51 
52 #include "services/base.h"
53 #include "services/daal_defines.h"
54 #include "services/daal_memory.h"
55 #include "services/error_handling.h"
56 #include "algorithms/algorithm_types.h"
57 #include "data_management/data/data_collection.h"
58 #include "data_management/data/data_dictionary.h"
59 
60 #include "data_management/data/numeric_types.h"
61 
62 namespace daal
63 {
65 namespace data_management
66 {
67 
68 namespace interface1
69 {
74 class NumericTable;
75 
80 template<typename DataType = DAAL_DATA_TYPE>
81 class DAAL_EXPORT BlockDescriptor
82 {
83 public:
85  BlockDescriptor() : _ptr(), _buffer(), _capacity(0), _ncols(0), _nrows(0), _colsOffset(0), _rowsOffset(0), _rwFlag(0), _pPtr(0), _rawPtr(0)
86  {}
87 
89  ~BlockDescriptor() { freeBuffer(); }
90 
95  inline DataType *getBlockPtr() const
96  {
97  if(_rawPtr)
98  {
99  return (DataType *)_rawPtr;
100  }
101  return _ptr.get();
102  }
103 
108  inline services::SharedPtr<DataType> getBlockSharedPtr() const
109  {
110  if(_rawPtr)
111  {
112  return services::SharedPtr<DataType>(services::reinterpretPointerCast<DataType, byte>(*_pPtr), (DataType *)_rawPtr);
113  }
114  return _ptr;
115  }
116 
121  inline size_t getNumberOfColumns() const { return _ncols; }
122 
127  inline size_t getNumberOfRows() const { return _nrows; }
128 
132  inline void reset()
133  {
134  _colsOffset = 0;
135  _rowsOffset = 0;
136  _rwFlag = 0;
137  _pPtr = NULL;
138  _rawPtr = NULL;
139  }
140 
141 public:
148  inline void setPtr( DataType *ptr, size_t nColumns, size_t nRows )
149  {
150  _ptr = services::SharedPtr<DataType>(ptr, services::EmptyDeleter());
151  _ncols = nColumns;
152  _nrows = nRows;
153  }
154 
161  void setPtr(services::SharedPtr<byte> *pPtr, byte *rawPtr, size_t nColumns, size_t nRows )
162  {
163  _pPtr = pPtr;
164  _rawPtr = rawPtr;
165  _ncols = nColumns;
166  _nrows = nRows;
167  }
168 
177  inline bool resizeBuffer( size_t nColumns, size_t nRows, size_t auxMemorySize = 0 )
178  {
179  _ncols = nColumns;
180  _nrows = nRows;
181 
182  size_t newSize = nColumns * nRows * sizeof(DataType) + auxMemorySize;
183 
184  if ( newSize > _capacity )
185  {
186  freeBuffer();
187  _buffer = services::SharedPtr<DataType>((DataType *)daal::services::daal_malloc(newSize), services::ServiceDeleter());
188  if ( _buffer != 0 )
189  {
190  _capacity = newSize;
191  }
192  else
193  {
194  return false;
195  }
196 
197  }
198 
199  _ptr = _buffer;
200  if(!auxMemorySize)
201  {
202  if(_aux_ptr)
203  {
204  _aux_ptr = services::SharedPtr<DataType>();
205  }
206  }
207  else
208  {
209  _aux_ptr = services::SharedPtr<DataType>(_buffer, _buffer.get() + nColumns * nRows);
210  }
211 
212  return true;
213  }
214 
221  inline void setDetails( size_t columnIdx, size_t rowIdx, int rwFlag )
222  {
223  _colsOffset = columnIdx;
224  _rowsOffset = rowIdx;
225  _rwFlag = rwFlag;
226  }
227 
232  inline size_t getColumnsOffset() const { return _colsOffset; }
233 
238  inline size_t getRowsOffset() const { return _rowsOffset; }
239 
244  inline size_t getRWFlag() const { return _rwFlag; }
245 
250  inline void *getAdditionalBufferPtr() const { return _aux_ptr.get(); }
251  inline services::SharedPtr<DataType> getAdditionalBufferSharedPtr() const { return _aux_ptr; }
252 
253 protected:
257  void freeBuffer()
258  {
259  if(_buffer)
260  {
261  _buffer = services::SharedPtr<DataType>();
262  }
263  _capacity = 0;
264  }
265 
266 private:
267  services::SharedPtr<DataType> _ptr;
268  size_t _nrows;
269  size_t _ncols;
270 
271  size_t _colsOffset;
272  size_t _rowsOffset;
273  int _rwFlag;
274 
275  services::SharedPtr<DataType> _aux_ptr;
276 
277  services::SharedPtr<DataType> _buffer; /*<! Pointer to the buffer */
278  size_t _capacity; /*<! Buffer size in bytes */
279 
280  services::SharedPtr<byte> *_pPtr;
281  byte *_rawPtr;
282 };
283 
289 class NumericTableIface
290 {
291 public:
292  virtual ~NumericTableIface()
293  {}
298  enum MemoryStatus
299  {
300  notAllocated,
301  userAllocated,
302  internallyAllocated
303  };
304 
309  enum AllocationFlag
310  {
311  doNotAllocate = 0,
312  notAllocate = 0,
313  doAllocate = 1
314  };
315 
320  enum BasicStatisticsId
321  {
322  minimum = 0,
323  maximum = 1,
324  sum = 2,
325  sumSquares = 3
326  };
327 
332  enum FeatureBasicStatistics
333  {
334  counters
335  };
336 
341  enum NormalizationType
342  {
343  nonNormalized = 0,
344  standardScoreNormalized = 1,
345  minMaxNormalized = 2
346  };
347 
352  enum StorageLayout
353  {
354  soa = 1, // 1
355  aos = 2, // 2
356  csrArray = 1 << 4,
357  upperPackedSymmetricMatrix = 1 << 8,
358  lowerPackedSymmetricMatrix = 2 << 8,
359  upperPackedTriangularMatrix = 1 << 7,
360  lowerPackedTriangularMatrix = 4 << 8,
361 
362  layout_unknown = 0x80000000 // the last bit set
363  };
364 
370  DAAL_DEPRECATED_VIRTUAL virtual services::Status setDictionary( NumericTableDictionary *ddict ) { return services::Status(); }
371 
377  DAAL_DEPRECATED_VIRTUAL virtual NumericTableDictionary *getDictionary() const = 0;
378 
383  virtual NumericTableDictionaryPtr getDictionarySharedPtr() const = 0;
384 
389  DAAL_DEPRECATED_VIRTUAL virtual services::Status resetDictionary() { return services::Status(); }
390 
396  virtual data_feature_utils::FeatureType getFeatureType(size_t feature_idx) const = 0;
397 
403  virtual size_t getNumberOfCategories(size_t feature_idx) const = 0;
404 
409  virtual StorageLayout getDataLayout() const = 0;
410 
414  virtual services::Status resize(size_t nrows) = 0;
415 
422  DAAL_DEPRECATED_VIRTUAL virtual services::Status setNumberOfColumns(size_t ncol) = 0;
423 
430  DAAL_DEPRECATED_VIRTUAL virtual services::Status setNumberOfRows(size_t nrow) = 0;
431 
436  DAAL_DEPRECATED_VIRTUAL virtual services::Status allocateDataMemory(daal::MemType type = daal::dram) = 0;
437 
442  DAAL_DEPRECATED_VIRTUAL virtual void freeDataMemory() = 0;
443 
447  virtual services::Status allocateBasicStatistics() = 0;
448 
455  virtual services::Status check(const char *description, bool checkDataAllocation = true) const = 0;
456 
457 };
458 } // namespace interface1
459 using interface1::BlockDescriptor;
460 using interface1::NumericTableIface;
461 
462 const int packed_mask = (int)NumericTableIface::csrArray |
463  (int)NumericTableIface::upperPackedSymmetricMatrix |
464  (int)NumericTableIface::lowerPackedSymmetricMatrix |
465  (int)NumericTableIface::upperPackedTriangularMatrix |
466  (int)NumericTableIface::lowerPackedTriangularMatrix;
467 
468 namespace interface1
469 {
475 class DenseNumericTableIface
476 {
477 public:
478  virtual ~DenseNumericTableIface()
479  {}
490  virtual services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<double> &block) = 0;
491 
502  virtual services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<float> &block) = 0;
503 
514  virtual services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<int> &block) = 0;
515 
520  virtual services::Status releaseBlockOfRows(BlockDescriptor<double> &block) = 0;
521 
526  virtual services::Status releaseBlockOfRows(BlockDescriptor<float> &block) = 0;
527 
532  virtual services::Status releaseBlockOfRows(BlockDescriptor<int> &block) = 0;
533 
545  virtual services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
546  ReadWriteMode rwflag, BlockDescriptor<double> &block) = 0;
547 
559  virtual services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
560  ReadWriteMode rwflag, BlockDescriptor<float> &block) = 0;
561 
573  virtual services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
574  ReadWriteMode rwflag, BlockDescriptor<int> &block) = 0;
575 
580  virtual services::Status releaseBlockOfColumnValues(BlockDescriptor<double> &block) = 0;
581 
586  virtual services::Status releaseBlockOfColumnValues(BlockDescriptor<float> &block) = 0;
587 
592  virtual services::Status releaseBlockOfColumnValues(BlockDescriptor<int> &block) = 0;
593 };
594 
600 class DAAL_EXPORT NumericTable : public SerializationIface, public NumericTableIface, public DenseNumericTableIface
601 {
602 public:
603  DAAL_CAST_OPERATOR(NumericTable);
604 
610  DAAL_DEPRECATED NumericTable( NumericTableDictionary *ddict )
611  {
612  _obsnum = 0;
613  _ddict = NumericTableDictionaryPtr(ddict, services::EmptyDeleter());
614  _layout = layout_unknown;
615  _memStatus = notAllocated;
616  _normalizationFlag = NumericTable::nonNormalized;
617  }
618 
623  NumericTable( NumericTableDictionaryPtr ddict )
624  {
625  _obsnum = 0;
626  _ddict = ddict;
627  _layout = layout_unknown;
628  _memStatus = notAllocated;
629  _normalizationFlag = NumericTable::nonNormalized;
630  }
631 
638  NumericTable( size_t featnum, size_t obsnum, DictionaryIface::FeaturesEqual featuresEqual = DictionaryIface::notEqual )
639  {
640  _obsnum = obsnum;
641  _ddict = NumericTableDictionaryPtr(new NumericTableDictionary(featnum, featuresEqual));
642  _layout = layout_unknown;
643  _memStatus = notAllocated;
644  _normalizationFlag = NumericTable::nonNormalized;
645  }
646 
648  virtual ~NumericTable() {}
649 
650  DAAL_DEPRECATED_VIRTUAL virtual services::Status setDictionary( NumericTableDictionary *ddict ) DAAL_C11_OVERRIDE
651  {
652  _ddict = NumericTableDictionaryPtr(ddict, services::EmptyDeleter());
653  return services::Status();
654  }
655 
656  DAAL_DEPRECATED_VIRTUAL virtual NumericTableDictionary *getDictionary() const DAAL_C11_OVERRIDE { return _ddict.get(); }
657 
658  virtual NumericTableDictionaryPtr getDictionarySharedPtr() const DAAL_C11_OVERRIDE { return _ddict; }
659 
660  DAAL_DEPRECATED_VIRTUAL virtual services::Status resetDictionary() DAAL_C11_OVERRIDE { return services::Status(); }
661 
662  virtual services::Status resize(size_t nrows) DAAL_C11_OVERRIDE
663  {
664  size_t obsnum = _obsnum;
665  services::Status s = setNumberOfRowsImpl(nrows);
666  if((_memStatus != userAllocated && obsnum < nrows) || _memStatus == notAllocated)
667  {
668  s |= allocateDataMemoryImpl();
669  }
670  return s;
671  }
672 
677  size_t getNumberOfColumns() const
678  {
679  return _ddict->getNumberOfFeatures();
680  }
681 
686  size_t getNumberOfRows() const { return _obsnum; }
687 
688  DAAL_DEPRECATED_VIRTUAL services::Status setNumberOfColumns(size_t ncol) DAAL_C11_OVERRIDE
689  {
690  return setNumberOfColumnsImpl(ncol);
691  }
692 
693  DAAL_DEPRECATED_VIRTUAL services::Status setNumberOfRows(size_t nrow) DAAL_C11_OVERRIDE
694  {
695  return setNumberOfRowsImpl(nrow);
696  }
697 
698  DAAL_DEPRECATED_VIRTUAL services::Status allocateDataMemory(daal::MemType type = daal::dram) DAAL_C11_OVERRIDE
699  {
700  return allocateDataMemoryImpl(type);
701  }
702 
703  DAAL_DEPRECATED_VIRTUAL void freeDataMemory() DAAL_C11_OVERRIDE
704  {
705  freeDataMemoryImpl();
706  }
707 
708  StorageLayout getDataLayout() const DAAL_C11_OVERRIDE
709  {
710  return _layout;
711  }
712 
713  data_feature_utils::FeatureType getFeatureType(size_t feature_idx) const DAAL_C11_OVERRIDE
714  {
715  if ( _ddict.get() != NULL && _ddict->getNumberOfFeatures() > feature_idx )
716  {
717  const NumericTableFeature &f = (*_ddict)[feature_idx];
718  return f.featureType;
719  }
720  else
721  {
722  /* If no dictionary was set, all features are considered numeric */
723  return data_feature_utils::DAAL_CONTINUOUS;
724  }
725  }
726 
727  size_t getNumberOfCategories(size_t feature_idx) const DAAL_C11_OVERRIDE
728  {
729  if ( _ddict.get() != NULL && _ddict->getNumberOfFeatures() > feature_idx &&
730  getFeatureType(feature_idx) != data_feature_utils::DAAL_CONTINUOUS )
731  {
732  const NumericTableFeature &f = (*_ddict)[feature_idx];
733  return f.categoryNumber;
734  }
735  else
736  {
737  /* If no dictionary was set, all features are considered numeric */
738  return -1;
739  }
740  }
741 
745  virtual MemoryStatus getDataMemoryStatus() const { return _memStatus; }
746 
752  bool isNormalized(NormalizationType flag) const
753  {
754  return (_normalizationFlag == flag);
755  }
756 
762  NormalizationType setNormalizationFlag(NormalizationType flag)
763  {
764  NormalizationType oldValue = _normalizationFlag;
765  _normalizationFlag = flag;
766  return oldValue;
767  }
768 
774  DAAL_DEPRECATED services::SharedPtr<services::KernelErrorCollection> getErrors()
775  {
776  return _status.getCollection()->getErrors();
777  }
778 
782  virtual services::Status allocateBasicStatistics() DAAL_C11_OVERRIDE;
783 
787  virtual services::Status check(const char *description, bool checkDataAllocation = true) const DAAL_C11_OVERRIDE
788  {
789  if (getDataMemoryStatus() == notAllocated && checkDataAllocation)
790  {
791  return services::Status(services::Error::create(services::ErrorNullNumericTable, services::ArgumentName, description));
792  }
793 
794  if (getNumberOfColumns() == 0)
795  {
796  return services::Status(services::Error::create(services::ErrorIncorrectNumberOfColumns, services::ArgumentName, description));
797  }
798 
799  if (getNumberOfRows() == 0 && getDataMemoryStatus() != notAllocated)
800  {
801  return services::Status(services::Error::create(services::ErrorIncorrectNumberOfRows, services::ArgumentName, description));
802  }
803 
804  return services::Status();
805  }
806 
811  virtual services::Status assign(float value) {return assignImpl<float>(value);}
812 
817  virtual services::Status assign(double value) {return assignImpl<double>(value);}
818 
823  virtual services::Status assign(int value) {return assignImpl<int>(value);}
824 
831  template <typename DataType>
832  DataType getValue(size_t column, size_t row) const
833  {
834  services::Status status;
835  return getValueImpl<DataType>(column, row, status);
836  }
837 
845  template <typename DataType>
846  DataType getValue(size_t column, size_t row, services::Status & status) const
847  {
848  return getValueImpl<DataType>(column, row, status);
849  }
850 
851 public:
856  class BasicStatisticsDataCollection : public algorithms::Argument
857  {
858  public:
859  BasicStatisticsDataCollection() : algorithms::Argument(4) {}
860 
861  services::SharedPtr<NumericTable> get(BasicStatisticsId id)
862  {
863  return services::staticPointerCast<NumericTable, SerializationIface>(Argument::get(id));
864  }
865 
866  void set(BasicStatisticsId id, const services::SharedPtr<NumericTable> &value)
867  {
868  Argument::set(id, value);
869  }
870  };
871 
872  BasicStatisticsDataCollection basicStatistics;
874 protected:
875  NumericTableDictionaryPtr _ddict;
876 
877  size_t _obsnum;
878 
879  MemoryStatus _memStatus;
880  StorageLayout _layout;
881 
882  NormalizationType _normalizationFlag;
883 
884  services::Status _status;
885 
886 protected:
887 
888  NumericTable(NumericTableDictionaryPtr ddict, services::Status &st) :
889  _obsnum(0), _ddict(ddict), _layout(layout_unknown), _memStatus(notAllocated), _normalizationFlag(NumericTable::nonNormalized)
890  {
891  }
892 
893  NumericTable(size_t featnum, size_t obsnum, DictionaryIface::FeaturesEqual featuresEqual, services::Status &st):
894  _obsnum(obsnum), _layout(layout_unknown), _memStatus(notAllocated), _normalizationFlag(NumericTable::nonNormalized)
895  {
896  _ddict = NumericTableDictionary::create(featnum, featuresEqual, &st);
897  if (!st) return;
898  }
899 
900  virtual services::Status setNumberOfColumnsImpl(size_t ncol)
901  {
902  return _ddict->setNumberOfFeatures(ncol);
903  }
904 
905  virtual services::Status setNumberOfRowsImpl(size_t nrow)
906  {
907  _obsnum = nrow;
908  return services::Status();
909  }
910 
911  virtual services::Status allocateDataMemoryImpl(daal::MemType type = daal::dram) { return services::Status(); }
912 
913  virtual void freeDataMemoryImpl() {}
914 
915  template <typename DataType>
916  DataType getValueImpl(size_t column, size_t row, services::Status & status) const
917  {
918  const DataType defaultValue = 0;
919  if (!status)
920  return defaultValue;
921  BlockDescriptor<DataType> bd;
922  status |= const_cast<NumericTable *>(this)->getBlockOfColumnValues(column, row, 1, readOnly, bd);
923  if (!status)
924  return defaultValue;
925  const DataType v = *(bd.getBlockPtr());
926  status |= const_cast<NumericTable *>(this)->releaseBlockOfColumnValues(bd);
927  return v;
928  }
929 
930  virtual float getFloatValueImpl(size_t column, size_t row, services::Status & status) const
931  {
932  return getValueImpl<float>(column, row, status);
933  }
934 
935  virtual double getDoubleValueImpl(size_t column, size_t row, services::Status & status) const
936  {
937  return getValueImpl<double>(column, row, status);
938  }
939 
940  virtual int getIntValueImpl(size_t column, size_t row, services::Status & status) const
941  {
942  return getValueImpl<int>(column, row, status);
943  }
944 
946  template<typename Archive, bool onDeserialize>
947  services::Status serialImpl( Archive *arch )
948  {
949  arch->setSharedPtrObj( _ddict );
950 
951  arch->set( _obsnum );
952 
953  if( onDeserialize )
954  {
955  _memStatus = notAllocated;
956  }
957 
958  arch->set( _layout );
959 
960  return services::Status();
961  }
962 
963 private:
964  template <typename T>
965  services::Status assignImpl(T value)
966  {
967  size_t nRows = getNumberOfRows();
968  size_t nCols = getNumberOfColumns();
969  BlockDescriptor<T> block;
970  DAAL_CHECK(getBlockOfRows(0, nRows, writeOnly, block), services::ErrorMemoryAllocationFailed)
971  T* array = block.getBlockSharedPtr().get();
972  for(size_t i = 0; i < nCols * nRows; i++) {array[i] = value;}
973  releaseBlockOfRows(block);
974  return services::Status();
975  }
976 };
977 typedef services::SharedPtr<NumericTable> NumericTablePtr;
978 typedef services::SharedPtr<const NumericTable> NumericTableConstPtr;
979 
980 template <>
981 inline float NumericTable::getValue<float>(size_t column, size_t row) const
982 {
983  services::Status status;
984  return getFloatValueImpl(column, row, status);
985 }
986 
987 template <>
988 inline double NumericTable::getValue<double>(size_t column, size_t row) const
989 {
990  services::Status status;
991  return getDoubleValueImpl(column, row, status);
992 }
993 
994 template <>
995 inline int NumericTable::getValue<int>(size_t column, size_t row) const
996 {
997  services::Status status;
998  return getIntValueImpl(column, row, status);
999 }
1000 
1001 template <>
1002 inline float NumericTable::getValue<float>(size_t column, size_t row, services::Status & status) const
1003 {
1004  return getFloatValueImpl(column, row, status);
1005 }
1006 
1007 template <>
1008 inline double NumericTable::getValue<double>(size_t column, size_t row, services::Status & status) const
1009 {
1010  return getDoubleValueImpl(column, row, status);
1011 }
1012 
1013 template <>
1014 inline int NumericTable::getValue<int>(size_t column, size_t row, services::Status & status) const
1015 {
1016  return getIntValueImpl(column, row, status);
1017 }
1018 
1021 } // namespace interface1
1022 using interface1::DenseNumericTableIface;
1023 using interface1::NumericTable;
1024 using interface1::NumericTablePtr;
1025 using interface1::NumericTableConstPtr;
1026 
1040 DAAL_EXPORT services::Status checkNumericTable(const NumericTable *nt, const char *description,
1041  const int unexpectedLayouts = 0, const int expectedLayouts = 0, size_t nColumns = 0, size_t nRows = 0,
1042  bool checkDataAllocation = true);
1049 template<typename DataType>
1050 DAAL_EXPORT daal::data_management::NumericTablePtr convertToHomogen(NumericTable &src, daal::MemType type = daal::dram);
1051 }
1052 } // namespace daal
1053 #endif
daal::data_management::interface1::NumericTableIface::setDictionary
virtual DAAL_DEPRECATED_VIRTUAL services::Status setDictionary(NumericTableDictionary *ddict)
Definition: numeric_table.h:370
daal::data_management::interface1::NumericTable::freeDataMemory
DAAL_DEPRECATED_VIRTUAL void freeDataMemory() DAAL_C11_OVERRIDE
Definition: numeric_table.h:703
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:244
daal::data_management::interface1::NumericTableIface::AllocationFlag
AllocationFlag
Enumeration to specify whether the Numeric Table must allocate memory.
Definition: numeric_table.h:309
daal::data_management::interface1::BlockDescriptor::freeBuffer
void freeBuffer()
Definition: numeric_table.h:257
daal::data_management::interface1::BlockDescriptor::getBlockSharedPtr
services::SharedPtr< DataType > getBlockSharedPtr() const
Definition: numeric_table.h:108
daal::data_management::interface1::NumericTable::getValue
DataType getValue(size_t column, size_t row) const
Definition: numeric_table.h:832
daal::data_management::interface1::NumericTableIface::notAllocated
Definition: numeric_table.h:300
daal::data_management::interface1::BlockDescriptor::getBlockPtr
DataType * getBlockPtr() const
Definition: numeric_table.h:95
daal
Definition: algorithm_base_common.h:57
daal::data_management::interface1::NumericTable::NumericTable
NumericTable(NumericTableDictionaryPtr ddict)
Definition: numeric_table.h:623
daal::data_management::interface1::BlockDescriptor::getAdditionalBufferPtr
void * getAdditionalBufferPtr() const
Definition: numeric_table.h:250
daal::data_management::interface1::NumericTable::assign
virtual services::Status assign(double value)
Definition: numeric_table.h:817
daal::data_management::interface1::BlockDescriptor::getNumberOfColumns
size_t getNumberOfColumns() const
Definition: numeric_table.h:121
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:341
daal::data_management::interface1::NumericTableIface::standardScoreNormalized
Definition: numeric_table.h:344
daal::data_management::interface1::NumericTableIface::resetDictionary
virtual DAAL_DEPRECATED_VIRTUAL services::Status resetDictionary()
Definition: numeric_table.h:389
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:727
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:660
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:658
daal::services::ErrorIncorrectNumberOfColumns
Definition: error_indexes.h:140
daal::services::ErrorMemoryAllocationFailed
Definition: error_indexes.h:170
daal::data_management::interface1::NumericTable::getNumberOfColumns
size_t getNumberOfColumns() const
Definition: numeric_table.h:677
daal::dram
Definition: daal_defines.h:158
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:811
daal::data_management::interface1::NumericTable::setNumberOfColumns
DAAL_DEPRECATED_VIRTUAL services::Status setNumberOfColumns(size_t ncol) DAAL_C11_OVERRIDE
Definition: numeric_table.h:688
daal::data_management::interface1::NumericTableIface::userAllocated
Definition: numeric_table.h:301
daal_defines.h
daal::data_management::interface1::NumericTableIface::FeatureBasicStatistics
FeatureBasicStatistics
Enumeration to specify feature-specific estimates of basic statistics stored.
Definition: numeric_table.h:332
daal::data_management::interface1::NumericTable::BasicStatisticsDataCollection
Basic statistics for each column of original Numeric Table.
Definition: numeric_table.h:856
daal::data_management::interface1::NumericTable::NumericTable
DAAL_DEPRECATED NumericTable(NumericTableDictionary *ddict)
Definition: numeric_table.h:610
daal::data_management::interface1::BlockDescriptor::resizeBuffer
bool resizeBuffer(size_t nColumns, size_t nRows, size_t auxMemorySize=0)
Definition: numeric_table.h:177
daal::data_management::interface1::NumericTableIface::minimum
Definition: numeric_table.h:322
daal::data_management::interface1::BlockDescriptor::setPtr
void setPtr(services::SharedPtr< byte > *pPtr, byte *rawPtr, size_t nColumns, size_t nRows)
Definition: numeric_table.h:161
daal::data_management::interface1::NumericTable::assign
virtual services::Status assign(int value)
Definition: numeric_table.h:823
daal::data_management::interface1::NumericTable::isNormalized
bool isNormalized(NormalizationType flag) const
Definition: numeric_table.h:752
daal::data_management::interface1::NumericTable::setNormalizationFlag
NormalizationType setNormalizationFlag(NormalizationType flag)
Definition: numeric_table.h:762
daal::data_management::interface1::NumericTableIface::counters
Definition: numeric_table.h:334
daal::data_management::interface1::NumericTable::getDictionary
virtual DAAL_DEPRECATED_VIRTUAL NumericTableDictionary * getDictionary() const DAAL_C11_OVERRIDE
Definition: numeric_table.h:656
daal::data_management::interface1::NumericTable::allocateDataMemory
DAAL_DEPRECATED_VIRTUAL services::Status allocateDataMemory(daal::MemType type=daal::dram) DAAL_C11_OVERRIDE
Definition: numeric_table.h:698
daal::data_management::interface1::NumericTableIface::nonNormalized
Definition: numeric_table.h:343
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:298
daal::data_management::interface1::NumericTable
Class for a data management component responsible for representation of data in the numeric format...
Definition: numeric_table.h:600
daal::data_management::interface1::NumericTableIface::StorageLayout
StorageLayout
Storage layouts that may need to be supported.
Definition: numeric_table.h:352
daal::data_management::interface1::NumericTableIface::doNotAllocate
Definition: numeric_table.h:311
daal::data_management::interface1::NumericTable::resize
virtual services::Status resize(size_t nrows) DAAL_C11_OVERRIDE
Definition: numeric_table.h:662
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:323
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:875
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:320
daal::data_management::interface1::NumericTable::getErrors
DAAL_DEPRECATED services::SharedPtr< services::KernelErrorCollection > getErrors()
Definition: numeric_table.h:774
daal::data_management::interface1::NumericTable::NumericTable
NumericTable(size_t featnum, size_t obsnum, DictionaryIface::FeaturesEqual featuresEqual=DictionaryIface::notEqual)
Definition: numeric_table.h:638
daal::data_management::interface1::NumericTable::getValue
DataType getValue(size_t column, size_t row, services::Status &status) const
Definition: numeric_table.h:846
daal::data_management::interface1::NumericTableIface::doAllocate
Definition: numeric_table.h:313
daal::data_management::interface1::NumericTable::getFeatureType
data_feature_utils::FeatureType getFeatureType(size_t feature_idx) const DAAL_C11_OVERRIDE
Definition: numeric_table.h:713
daal::data_management::interface1::BlockDescriptor::reset
void reset()
Definition: numeric_table.h:132
daal::services::ErrorIncorrectNumberOfRows
Definition: error_indexes.h:141
daal::data_management::interface1::NumericTable::getNumberOfRows
size_t getNumberOfRows() const
Definition: numeric_table.h:686
daal::data_management::interface1::BlockDescriptor
Base class that manages buffer memory for read/write operations required by numeric tables...
Definition: numeric_table.h:81
daal::data_management::interface1::DenseNumericTableIface
Abstract interface class for a data management component responsible for accessing data in the numeri...
Definition: numeric_table.h:475
daal::data_management::interface1::DictionaryIface::FeaturesEqual
FeaturesEqual
Enumeration to specify whether the Data Dictionary contains equal features.
Definition: data_dictionary.h:171
daal::algorithms::math::abs::value
Definition: abs_types.h:112
daal::data_management::interface1::NumericTableIface::notAllocate
Definition: numeric_table.h:312
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:127
daal::data_management::interface1::NumericTableIface::internallyAllocated
Definition: numeric_table.h:302
daal::data_management::interface1::NumericTableIface::sum
Definition: numeric_table.h:324
daal::data_management::interface1::NumericTable::getDataLayout
StorageLayout getDataLayout() const DAAL_C11_OVERRIDE
Definition: numeric_table.h:708
daal::data_management::interface1::BlockDescriptor::getRowsOffset
size_t getRowsOffset() const
Definition: numeric_table.h:238
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:209
daal::data_management::interface1::NumericTableIface::sumSquares
Definition: numeric_table.h:325
daal::services::ErrorNullNumericTable
Definition: error_indexes.h:139
daal::data_management::interface1::BlockDescriptor::setDetails
void setDetails(size_t columnIdx, size_t rowIdx, int rwFlag)
Definition: numeric_table.h:221
daal::data_management::interface1::NumericTable::setDictionary
virtual DAAL_DEPRECATED_VIRTUAL services::Status setDictionary(NumericTableDictionary *ddict) DAAL_C11_OVERRIDE
Definition: numeric_table.h:650
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:289
daal::data_management::interface1::NumericTableIface::minMaxNormalized
Definition: numeric_table.h:345
daal::data_management::interface1::BlockDescriptor::setPtr
void setPtr(DataType *ptr, size_t nColumns, size_t nRows)
Definition: numeric_table.h:148
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::BlockDescriptor::getColumnsOffset
size_t getColumnsOffset() const
Definition: numeric_table.h:232
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:74
daal::services::ArgumentName
Definition: error_indexes.h:76
daal::data_management::interface1::NumericTable::getDataMemoryStatus
virtual MemoryStatus getDataMemoryStatus() const
Definition: numeric_table.h:745
daal::data_management::interface1::NumericTableIface::allocateBasicStatistics
virtual services::Status allocateBasicStatistics()=0
daal::MemType
MemType
Definition: daal_defines.h:156
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:693
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.