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

homogen_numeric_table.h
1 /* file: homogen_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 // Implementation of a homogeneous numeric table.
19 //--
20 */
21 
22 
23 #ifndef __HOMOGEN_NUMERIC_TABLE_H__
24 #define __HOMOGEN_NUMERIC_TABLE_H__
25 
26 #include "data_management/data/numeric_table.h"
27 #include "services/daal_memory.h"
28 #include "services/daal_defines.h"
29 #include "data_management/data/data_serialize.h"
30 
31 namespace daal
32 {
33 namespace data_management
34 {
35 
36 namespace interface1
37 {
49 template<typename DataType = DAAL_DATA_TYPE>
50 class DAAL_EXPORT HomogenNumericTable : public NumericTable
51 {
52 public:
53  DECLARE_SERIALIZABLE_TAG();
54  DECLARE_SERIALIZABLE_IMPL();
55 
56  DAAL_CAST_OPERATOR(HomogenNumericTable)
60  typedef DataType baseDataType;
61 
62 public:
68  DAAL_DEPRECATED HomogenNumericTable( NumericTableDictionary *ddict ):
69  NumericTable(ddict)
70  {
71  _layout = aos;
72  }
73 
79  HomogenNumericTable( NumericTableDictionaryPtr ddictForHomogenNumericTable ):
80  NumericTable(ddictForHomogenNumericTable)
81  {
82  _layout = aos;
83  }
84 
91  static services::SharedPtr<HomogenNumericTable<DataType> > create(NumericTableDictionaryPtr ddictForHomogenNumericTable, services::Status *stat = NULL)
92  {
93  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(HomogenNumericTable, DataType, ddictForHomogenNumericTable);
94  }
95 
100  HomogenNumericTable():
101  NumericTable(0, 0)
102  {}
103 
109  static services::SharedPtr<HomogenNumericTable<DataType> > create(services::Status *stat = NULL)
110  {
111  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL(HomogenNumericTable, DataType);
112  }
113 
121  HomogenNumericTable( DataType *const ptr, size_t nColumns = 0, size_t nRows = 0 ):
122  NumericTable( nColumns, nRows )
123  {
124  _layout = aos;
125  this->_status |= setArray( ptr, nRows );
126 
127  NumericTableFeature df;
128  df.setType<DataType>();
129  this->_status |= _ddict->setAllFeatures(df);
130  }
131 
140  static services::SharedPtr<HomogenNumericTable<DataType> > create(DataType *const ptr,
141  size_t nColumns = 0, size_t nRows = 0,
142  services::Status *stat = NULL)
143  {
144  return create(services::SharedPtr<DataType>(ptr, services::EmptyDeleter()), nColumns, nRows, stat);
145  }
146 
154  HomogenNumericTable( const services::SharedPtr<DataType> &ptr, size_t nColumns, size_t nRows ):
155  NumericTable( nColumns, nRows )
156  {
157  _layout = aos;
158  this->_status |= setArray( ptr, nRows );
159 
160  NumericTableFeature df;
161  df.setType<DataType>();
162  this->_status |= _ddict->setAllFeatures(df);
163  }
164 
173  static services::SharedPtr<HomogenNumericTable<DataType> > create(const services::SharedPtr<DataType> &ptr,
174  size_t nColumns, size_t nRows,
175  services::Status *stat = NULL)
176  {
177  return create(DictionaryIface::notEqual, ptr, nColumns, nRows, stat);
178  }
179 
188  HomogenNumericTable( DictionaryIface::FeaturesEqual featuresEqual, DataType *const ptr = 0, size_t nColumns = 0, size_t nRows = 0):
189  NumericTable( nColumns, nRows, featuresEqual )
190  {
191  _layout = aos;
192  this->_status |= setArray( ptr, nRows );
193 
194  NumericTableFeature df;
195  df.setType<DataType>();
196  this->_status |= _ddict->setAllFeatures(df);
197  }
198 
208  static services::SharedPtr<HomogenNumericTable<DataType> > create(DictionaryIface::FeaturesEqual featuresEqual,
209  DataType *const ptr = 0, size_t nColumns = 0, size_t nRows = 0,
210  services::Status *stat = NULL)
211  {
212  return create(featuresEqual, services::SharedPtr<DataType>(ptr, services::EmptyDeleter()), nColumns, nRows, stat);
213  }
214 
223  HomogenNumericTable( DictionaryIface::FeaturesEqual featuresEqual, const services::SharedPtr<DataType> &ptr, size_t nColumns, size_t nRows ):
224  NumericTable( nColumns, nRows, featuresEqual )
225  {
226  _layout = aos;
227  this->_status |= setArray( ptr, nRows );
228 
229  NumericTableFeature df;
230  df.setType<DataType>();
231  this->_status |= _ddict->setAllFeatures(df);
232  }
233 
243  static services::SharedPtr<HomogenNumericTable<DataType> > create(DictionaryIface::FeaturesEqual featuresEqual,
244  const services::SharedPtr<DataType> &ptr,
245  size_t nColumns, size_t nRows, services::Status *stat = NULL)
246  {
247  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(HomogenNumericTable, DataType, featuresEqual, ptr, nColumns, nRows);
248  }
249 
258  HomogenNumericTable( DataType *const ptr, size_t nColumns, size_t nRows, const DataType &constValue ):
259  NumericTable( nColumns, nRows )
260  {
261  _layout = aos;
262  this->_status |= setArray( ptr, nRows );
263 
264  NumericTableFeature df;
265  df.setType<DataType>();
266  this->_status |= _ddict->setAllFeatures(df);
267  this->_status |= assign<DataType>(constValue);
268  }
269 
279  static services::SharedPtr<HomogenNumericTable<DataType> > create(DataType *const ptr, size_t nColumns, size_t nRows, const DataType &constValue,
280  services::Status *stat = NULL)
281  {
282  return create(services::SharedPtr<DataType>(ptr, services::EmptyDeleter()), nColumns, nRows, constValue, stat);
283  }
284 
293  HomogenNumericTable(const services::SharedPtr<DataType> &ptr, size_t nColumns, size_t nRows, const DataType &constValue ):
294  NumericTable( nColumns, nRows )
295  {
296  _layout = aos;
297  this->_status |= setArray( ptr, nRows );
298 
299  NumericTableFeature df;
300  df.setType<DataType>();
301  this->_status |= _ddict->setAllFeatures(df);
302  this->_status |= assign<DataType>(constValue);
303  }
304 
314  static services::SharedPtr<HomogenNumericTable<DataType> > create(const services::SharedPtr<DataType> &ptr, size_t nColumns, size_t nRows,
315  const DataType &constValue, services::Status *stat = NULL)
316  {
317  return create(DictionaryIface::notEqual, ptr, nColumns, nRows, constValue, stat);
318  }
319 
329  HomogenNumericTable( DictionaryIface::FeaturesEqual featuresEqual, DataType *const ptr, size_t nColumns, size_t nRows, const DataType &constValue ):
330  NumericTable( nColumns, nRows, featuresEqual )
331  {
332  _layout = aos;
333  this->_status |= setArray( ptr, nRows );
334 
335  NumericTableFeature df;
336  df.setType<DataType>();
337  this->_status |= _ddict->setAllFeatures(df);
338  this->_status |= assign<DataType>(constValue);
339  }
340 
351  static services::SharedPtr<HomogenNumericTable<DataType> > create(DictionaryIface::FeaturesEqual featuresEqual, DataType *const ptr,
352  size_t nColumns, size_t nRows, const DataType &constValue,
353  services::Status *stat = NULL)
354  {
355  return create(featuresEqual, services::SharedPtr<DataType>(ptr, services::EmptyDeleter()), nColumns, nRows, constValue, stat);
356  }
357 
367  HomogenNumericTable( DictionaryIface::FeaturesEqual featuresEqual, const services::SharedPtr<DataType> &ptr, size_t nColumns, size_t nRows, const DataType &constValue ):
368  NumericTable( nColumns, nRows, featuresEqual )
369  {
370  _layout = aos;
371  this->_status |= setArray( ptr, nRows );
372 
373  NumericTableFeature df;
374  df.setType<DataType>();
375  this->_status |= _ddict->setAllFeatures(df);
376  this->_status |= assign<DataType>(constValue);
377  }
378 
389  static services::SharedPtr<HomogenNumericTable<DataType> > create(DictionaryIface::FeaturesEqual featuresEqual,
390  const services::SharedPtr<DataType> &ptr,
391  size_t nColumns, size_t nRows, const DataType &constValue,
392  services::Status *stat = NULL)
393  {
394  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(HomogenNumericTable, DataType, featuresEqual, ptr, nColumns, nRows, constValue);
395  }
396 
404  HomogenNumericTable( size_t nColumns, size_t nRows, AllocationFlag memoryAllocationFlag ):
405  NumericTable( nColumns, nRows )
406  {
407  _layout = aos;
408 
409  NumericTableFeature df;
410  df.setType<DataType>();
411  this->_status |= _ddict->setAllFeatures(df);
412 
413  if( memoryAllocationFlag == doAllocate ) this->_status |= allocateDataMemoryImpl();
414  }
415 
424  static services::SharedPtr<HomogenNumericTable<DataType> > create(size_t nColumns, size_t nRows, AllocationFlag memoryAllocationFlag,
425  services::Status *stat = NULL)
426  {
427  return create(DictionaryIface::notEqual, nColumns, nRows, memoryAllocationFlag, stat);
428  }
429 
438  HomogenNumericTable( DictionaryIface::FeaturesEqual featuresEqual, size_t nColumns, size_t nRows, AllocationFlag memoryAllocationFlag ):
439  NumericTable( nColumns, nRows, featuresEqual )
440  {
441  _layout = aos;
442 
443  NumericTableFeature df;
444  df.setType<DataType>();
445  this->_status |= _ddict->setAllFeatures(df);
446 
447  if( memoryAllocationFlag == doAllocate ) this->_status |= allocateDataMemoryImpl();
448  }
449 
459  static services::SharedPtr<HomogenNumericTable<DataType> > create(DictionaryIface::FeaturesEqual featuresEqual,
460  size_t nColumns, size_t nRows, AllocationFlag memoryAllocationFlag,
461  services::Status *stat = NULL)
462  {
463  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(HomogenNumericTable, DataType, featuresEqual, nColumns, nRows, memoryAllocationFlag);
464  }
465 
474  HomogenNumericTable( size_t nColumns, size_t nRows, NumericTable::AllocationFlag memoryAllocationFlag,
475  const DataType &constValue ):
476  NumericTable( nColumns, nRows )
477  {
478  _layout = aos;
479 
480  NumericTableFeature df;
481  df.setType<DataType>();
482 
483  this->_status |= _ddict->setAllFeatures(df);
484 
485  if( memoryAllocationFlag == doAllocate ) this->_status |= allocateDataMemoryImpl();
486 
487  this->_status |= assign<DataType>(constValue);
488  }
489 
499  static services::SharedPtr<HomogenNumericTable<DataType> > create(size_t nColumns, size_t nRows, AllocationFlag memoryAllocationFlag,
500  const DataType &constValue, services::Status *stat = NULL)
501  {
502  return create(DictionaryIface::notEqual, nColumns, nRows, memoryAllocationFlag, constValue, stat);
503  }
504 
514  HomogenNumericTable( DictionaryIface::FeaturesEqual featuresEqual, size_t nColumns, size_t nRows, NumericTable::AllocationFlag memoryAllocationFlag,
515  const DataType &constValue ):
516  NumericTable( nColumns, nRows, featuresEqual )
517  {
518  _layout = aos;
519 
520  NumericTableFeature df;
521  df.setType<DataType>();
522 
523  this->_status |= _ddict->setAllFeatures(df);
524 
525  if( memoryAllocationFlag == doAllocate ) { this->_status |= allocateDataMemoryImpl(); }
526 
527  this->_status |= assign<DataType>(constValue);
528  }
529 
540  static services::SharedPtr<HomogenNumericTable<DataType> > create(DictionaryIface::FeaturesEqual featuresEqual,
541  size_t nColumns, size_t nRows, AllocationFlag memoryAllocationFlag,
542  const DataType &constValue, services::Status *stat = NULL)
543  {
544  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(HomogenNumericTable, DataType, featuresEqual, nColumns, nRows, memoryAllocationFlag, constValue);
545  }
546 
547  virtual ~HomogenNumericTable()
548  {
549  freeDataMemoryImpl();
550  }
551 
556  DataType *getArray() const
557  {
558  return (DataType*)_ptr.get();
559  }
560 
565  services::SharedPtr<DataType> getArraySharedPtr() const
566  {
567  return services::reinterpretPointerCast<DataType, byte>(_ptr);
568  }
569 
575  DAAL_DEPRECATED services::Status setArray( DataType *const ptr )
576  {
577  freeDataMemoryImpl();
578 
579  _ptr = services::SharedPtr<byte>((byte*)ptr, services::EmptyDeleter());
580 
581  if(_ptr)
582  {
583  _memStatus = userAllocated;
584  }
585  else
586  {
587  _memStatus = notAllocated;
588  }
589  return services::Status();
590  }
591 
597  DAAL_DEPRECATED services::Status setArray( const services::SharedPtr<DataType> &ptr )
598  {
599  freeDataMemoryImpl();
600 
601  _ptr = services::reinterpretPointerCast<byte, DataType>(ptr);
602 
603  if(_ptr)
604  {
605  _memStatus = userAllocated;
606  }
607  else
608  {
609  _memStatus = notAllocated;
610  }
611  return services::Status();
612  }
613 
619  services::Status setArray( DataType *const ptr, size_t nRows )
620  {
621  freeDataMemoryImpl();
622 
623  _ptr = services::SharedPtr<byte>((byte*)ptr, services::EmptyDeleter());
624  _obsnum = nRows;
625 
626  if(_ptr)
627  {
628  _memStatus = userAllocated;
629  }
630  else
631  {
632  _memStatus = notAllocated;
633  }
634  return services::Status();
635  }
636 
642  services::Status setArray( services::SharedPtr<DataType> ptr, size_t nRows )
643  {
644  freeDataMemoryImpl();
645 
646  _ptr = services::reinterpretPointerCast<byte, DataType>(ptr);
647  _obsnum = nRows;
648 
649  if(_ptr)
650  {
651  _memStatus = userAllocated;
652  }
653  else
654  {
655  _memStatus = notAllocated;
656  }
657  return services::Status();
658  }
659 
664  template <typename T>
665  services::Status assign(T value)
666  {
667  if( _memStatus == notAllocated )
668  return services::Status(services::ErrorEmptyHomogenNumericTable);
669 
670  size_t nColumns = getNumberOfColumns();
671  size_t nRows = getNumberOfRows();
672 
673  size_t i;
674  DataType *ptr = (DataType*)_ptr.get();
675  DataType valueDataType = (DataType)value;
676  for( i = 0; i < nColumns * nRows; i++ )
677  {
678  ptr[i] = valueDataType;
679  }
680  return services::Status();
681  }
682 
688  DataType *operator[](size_t i)
689  {
690  size_t nColumns = getNumberOfColumns();
691  return (DataType*)_ptr.get() + i * nColumns;
692  }
693 
697  virtual services::Status assign(float value) DAAL_C11_OVERRIDE {return assign<DataType>((DataType)value);}
698 
702  virtual services::Status assign(double value) DAAL_C11_OVERRIDE {return assign<DataType>((DataType)value);}
703 
707  virtual services::Status assign(int value) DAAL_C11_OVERRIDE {return assign<DataType>((DataType)value);}
708 
709  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
710  {
711  return getTBlock<double>(vector_idx, vector_num, rwflag, block);
712  }
713  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
714  {
715  return getTBlock<float>(vector_idx, vector_num, rwflag, block);
716  }
717  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
718  {
719  return getTBlock<int>(vector_idx, vector_num, rwflag, block);
720  }
721 
722  services::Status releaseBlockOfRows(BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
723  {
724  return releaseTBlock<double>(block);
725  }
726  services::Status releaseBlockOfRows(BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
727  {
728  return releaseTBlock<float>(block);
729  }
730  services::Status releaseBlockOfRows(BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
731  {
732  return releaseTBlock<int>(block);
733  }
734 
735  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
736  ReadWriteMode rwflag, BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
737  {
738  return getTFeature<double>(feature_idx, vector_idx, value_num, rwflag, block);
739  }
740  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
741  ReadWriteMode rwflag, BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
742  {
743  return getTFeature<float>(feature_idx, vector_idx, value_num, rwflag, block);
744  }
745  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
746  ReadWriteMode rwflag, BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
747  {
748  return getTFeature<int>(feature_idx, vector_idx, value_num, rwflag, block);
749  }
750 
751  services::Status releaseBlockOfColumnValues(BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
752  {
753  return releaseTFeature<double>(block);
754  }
755  services::Status releaseBlockOfColumnValues(BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
756  {
757  return releaseTFeature<float>(block);
758  }
759  services::Status releaseBlockOfColumnValues(BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
760  {
761  return releaseTFeature<int>(block);
762  }
763 
764 protected:
765  services::SharedPtr<byte> _ptr;
766 
767  HomogenNumericTable(services::Status &st):
768  NumericTable(0, 0, DictionaryIface::notEqual, st)
769  {}
770 
771  HomogenNumericTable(NumericTableDictionaryPtr ddictForHomogenNumericTable, services::Status &st):
772  NumericTable(ddictForHomogenNumericTable, st)
773  {
774  _layout = aos;
775  }
776 
777  HomogenNumericTable(DictionaryIface::FeaturesEqual featuresEqual, const services::SharedPtr<DataType> &ptr,
778  size_t nColumns, size_t nRows, services::Status &st):
779  NumericTable(nColumns, nRows, featuresEqual, st)
780  {
781  _layout = aos;
782  st |= setArray( ptr, nRows );
783 
784  NumericTableFeature df;
785  df.setType<DataType>();
786  st |= _ddict->setAllFeatures(df);
787  }
788 
789  HomogenNumericTable(DictionaryIface::FeaturesEqual featuresEqual, const services::SharedPtr<DataType> &ptr,
790  size_t nColumns, size_t nRows, const DataType &constValue, services::Status &st):
791  NumericTable(nColumns, nRows, featuresEqual, st)
792  {
793  _layout = aos;
794  st |= setArray( ptr, nRows );
795 
796  NumericTableFeature df;
797  df.setType<DataType>();
798  st |= _ddict->setAllFeatures(df);
799  st |= assign<DataType>(constValue);
800  }
801 
802  HomogenNumericTable(DictionaryIface::FeaturesEqual featuresEqual,
803  size_t nColumns, size_t nRows, AllocationFlag memoryAllocationFlag, services::Status &st):
804  NumericTable(nColumns, nRows, featuresEqual, st)
805  {
806  _layout = aos;
807 
808  NumericTableFeature df;
809  df.setType<DataType>();
810  st |= _ddict->setAllFeatures(df);
811 
812  if( memoryAllocationFlag == doAllocate ) st |= allocateDataMemoryImpl();
813  }
814 
815  HomogenNumericTable(DictionaryIface::FeaturesEqual featuresEqual, size_t nColumns, size_t nRows,
816  NumericTable::AllocationFlag memoryAllocationFlag,
817  const DataType &constValue, services::Status &st):
818  NumericTable(nColumns, nRows, featuresEqual, st)
819  {
820  _layout = aos;
821 
822  NumericTableFeature df;
823  df.setType<DataType>();
824 
825  st |= _ddict->setAllFeatures(df);
826 
827  if( memoryAllocationFlag == doAllocate ) { st |= allocateDataMemoryImpl(); }
828 
829  st |= assign<DataType>(constValue);
830  }
831 
832  services::Status allocateDataMemoryImpl(daal::MemType type = daal::dram) DAAL_C11_OVERRIDE
833  {
834  freeDataMemoryImpl();
835 
836  size_t size = getNumberOfColumns() * getNumberOfRows();
837 
838  if( size == 0 )
839  {
840  return services::Status(getNumberOfColumns() == 0 ? services::ErrorIncorrectNumberOfFeatures :
841  services::ErrorIncorrectNumberOfObservations);
842  }
843 
844  _ptr = services::SharedPtr<byte>((byte *)daal::services::daal_malloc(size * sizeof(DataType)), services::ServiceDeleter());
845 
846  if(!_ptr)
847  return services::Status(services::ErrorMemoryAllocationFailed);
848 
849  _memStatus = internallyAllocated;
850  return services::Status();
851  }
852 
853  void freeDataMemoryImpl() DAAL_C11_OVERRIDE
854  {
855  _ptr = services::SharedPtr<byte>();
856  _memStatus = notAllocated;
857  }
858 
859  template<typename Archive, bool onDeserialize>
860  services::Status serialImpl( Archive *archive )
861  {
862  NumericTable::serialImpl<Archive, onDeserialize>( archive );
863 
864  if( onDeserialize )
865  {
866  allocateDataMemoryImpl();
867  }
868 
869  size_t size = getNumberOfColumns() * getNumberOfRows();
870 
871  archive->set( (DataType*)_ptr.get(), size );
872 
873  return services::Status();
874  }
875 
876 private:
877  byte *internal_getBlockOfRows( size_t idx )
878  {
879  size_t _featnum = _ddict->getNumberOfFeatures();
880  return _ptr.get() + _featnum * idx * sizeof(DataType);
881  }
882 
883  byte *internal_getBlockOfRows( size_t idx, size_t feat_idx )
884  {
885  size_t _featnum = _ddict->getNumberOfFeatures();
886  return _ptr.get() + _featnum * idx * sizeof(DataType) + feat_idx * sizeof(DataType);
887  }
888 
889 protected:
890 
891  template <typename T>
892  services::Status getTBlock( size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T> &block )
893  {
894  size_t ncols = getNumberOfColumns();
895  size_t nobs = getNumberOfRows();
896  block.setDetails( 0, idx, rwFlag );
897 
898  if (idx >= nobs)
899  {
900  block.resizeBuffer( ncols, 0 );
901  return services::Status();
902  }
903 
904  nrows = ( idx + nrows < nobs ) ? nrows : nobs - idx;
905 
906  if( IsSameType<T, DataType>::value )
907  {
908  block.setPtr(&_ptr, internal_getBlockOfRows(idx) , ncols, nrows );
909  }
910  else
911  {
912  if( !block.resizeBuffer( ncols, nrows ) )
913  return services::Status(services::ErrorMemoryAllocationFailed);
914 
915  if( rwFlag & (int)readOnly )
916  {
917  byte *location = internal_getBlockOfRows(idx);
918 
919  for(size_t i = 0; i < nrows; i++)
920  {
921  data_feature_utils::getVectorUpCast(data_feature_utils::getIndexNumType<DataType>(), data_feature_utils::getInternalNumType<T>())
922  ( ncols, ((DataType*)location) + i * ncols, ((T*)block.getBlockPtr()) + i * ncols );
923  }
924  }
925  }
926  return services::Status();
927  }
928 
929  template <typename T>
930  services::Status releaseTBlock( BlockDescriptor<T> &block )
931  {
932  if(block.getRWFlag() & (int)writeOnly)
933  {
934  byte *location = internal_getBlockOfRows( block.getRowsOffset() );
935  size_t ncols = getNumberOfColumns();
936  size_t nrows = block.getNumberOfRows();
937 
938  if( IsSameType<T, DataType>::value )
939  {
940  if( (T*)block.getBlockPtr() != (T *)location )
941  {
942  daal::services::daal_memcpy_s(location, nrows * ncols * sizeof(T), block.getBlockPtr(), nrows * ncols * sizeof(T));
943  }
944  }
945  else
946  {
947  for(size_t i = 0; i < nrows; i++)
948  {
949  data_feature_utils::getVectorDownCast(data_feature_utils::getIndexNumType<DataType>(), data_feature_utils::getInternalNumType<T>())
950  ( ncols, ((T*)block.getBlockPtr()) + i * ncols, ((DataType*)location) + i * ncols );
951  }
952  }
953  }
954  block.reset();
955  return services::Status();
956  }
957 
958  template <typename T>
959  services::Status getTFeature(size_t feat_idx, size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T> &block)
960  {
961  size_t ncols = getNumberOfColumns();
962  size_t nobs = getNumberOfRows();
963  block.setDetails( feat_idx, idx, rwFlag );
964 
965  if (idx >= nobs)
966  {
967  block.resizeBuffer( 1, 0 );
968  return services::Status();
969  }
970 
971  nrows = ( idx + nrows < nobs ) ? nrows : nobs - idx;
972 
973  if( ( IsSameType<T, DataType>::value ) && (ncols == 1) )
974  {
975  block.setPtr(&_ptr, internal_getBlockOfRows(idx) , ncols, nrows );
976  }
977  else
978  {
979  if( !block.resizeBuffer( 1, nrows ) )
980  return services::Status(services::ErrorMemoryAllocationFailed);
981 
982  if( rwFlag & (int)readOnly )
983  {
984  DataType *location = (DataType *)internal_getBlockOfRows(idx, feat_idx);
985  T *buffer = block.getBlockPtr();
986  data_feature_utils::getVectorStrideUpCast(data_feature_utils::getIndexNumType<DataType>(), data_feature_utils::getInternalNumType<T>())
987  ( nrows, location, sizeof(DataType)*ncols, buffer, sizeof(T) );
988  }
989  }
990  return services::Status();
991  }
992 
993  template <typename T>
994  services::Status releaseTFeature( BlockDescriptor<T> &block )
995  {
996  if (block.getRWFlag() & (int)writeOnly)
997  {
998  size_t ncols = getNumberOfColumns();
999  DataType *location = (DataType *)internal_getBlockOfRows(block.getRowsOffset(), block.getColumnsOffset());
1000  data_feature_utils::getVectorStrideDownCast(data_feature_utils::getIndexNumType<DataType>(), data_feature_utils::getInternalNumType<T>())
1001  ( block.getNumberOfRows(), block.getBlockPtr(), sizeof(T), location, ncols * sizeof(DataType) );
1002  }
1003  block.reset();
1004  return services::Status();
1005  }
1006 
1007  services::Status setNumberOfColumnsImpl(size_t ncol) DAAL_C11_OVERRIDE
1008  {
1009  if( _ddict->getNumberOfFeatures() != ncol )
1010  {
1011  _ddict->resetDictionary();
1012  _ddict->setNumberOfFeatures(ncol);
1013 
1014  NumericTableFeature df;
1015  df.setType<DataType>();
1016  _ddict->setAllFeatures(df);
1017  }
1018  return services::Status();
1019  }
1020 
1021 };
1023 } // namespace interface1
1024 using interface1::HomogenNumericTable;
1025 
1026 }
1027 } // namespace daal
1028 #endif
daal::data_management::interface1::HomogenNumericTable::create
static services::SharedPtr< HomogenNumericTable< DataType > > create(size_t nColumns, size_t nRows, AllocationFlag memoryAllocationFlag, const DataType &constValue, services::Status *stat=NULL)
Definition: homogen_numeric_table.h:499
daal::data_management::interface1::NumericTableIface::AllocationFlag
AllocationFlag
Enumeration to specify whether the Numeric Table must allocate memory.
Definition: numeric_table.h:283
daal
Definition: algorithm_base_common.h:31
daal::data_management::interface1::HomogenNumericTable::HomogenNumericTable
HomogenNumericTable(DictionaryIface::FeaturesEqual featuresEqual, DataType *const ptr=0, size_t nColumns=0, size_t nRows=0)
Definition: homogen_numeric_table.h:188
daal::data_management::interface1::HomogenNumericTable::HomogenNumericTable
HomogenNumericTable(DataType *const ptr, size_t nColumns=0, size_t nRows=0)
Definition: homogen_numeric_table.h:121
daal::data_management::interface1::HomogenNumericTable::baseDataType
DataType baseDataType
Definition: homogen_numeric_table.h:60
daal::data_management::interface1::HomogenNumericTable::HomogenNumericTable
HomogenNumericTable(const services::SharedPtr< DataType > &ptr, size_t nColumns, size_t nRows)
Definition: homogen_numeric_table.h:154
daal::data_management::interface1::HomogenNumericTable::setArray
DAAL_DEPRECATED services::Status setArray(const services::SharedPtr< DataType > &ptr)
Definition: homogen_numeric_table.h:597
daal::data_management::interface1::HomogenNumericTable::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: homogen_numeric_table.h:759
daal::data_management::interface1::HomogenNumericTable::HomogenNumericTable
HomogenNumericTable(DictionaryIface::FeaturesEqual featuresEqual, const services::SharedPtr< DataType > &ptr, size_t nColumns, size_t nRows)
Definition: homogen_numeric_table.h:223
daal::data_management::interface1::HomogenNumericTable::assign
services::Status assign(T value)
Definition: homogen_numeric_table.h:665
daal::data_management::interface1::HomogenNumericTable::HomogenNumericTable
HomogenNumericTable(DictionaryIface::FeaturesEqual featuresEqual, const services::SharedPtr< DataType > &ptr, size_t nColumns, size_t nRows, const DataType &constValue)
Definition: homogen_numeric_table.h:367
daal::data_management::interface1::HomogenNumericTable::HomogenNumericTable
HomogenNumericTable(DictionaryIface::FeaturesEqual featuresEqual, DataType *const ptr, size_t nColumns, size_t nRows, const DataType &constValue)
Definition: homogen_numeric_table.h:329
daal::data_management::interface1::HomogenNumericTable::HomogenNumericTable
HomogenNumericTable(DictionaryIface::FeaturesEqual featuresEqual, size_t nColumns, size_t nRows, NumericTable::AllocationFlag memoryAllocationFlag, const DataType &constValue)
Definition: homogen_numeric_table.h:514
daal::data_management::interface1::HomogenNumericTable::setArray
services::Status setArray(services::SharedPtr< DataType > ptr, size_t nRows)
Definition: homogen_numeric_table.h:642
daal::services::ErrorMemoryAllocationFailed
Definition: error_indexes.h:146
daal::dram
Definition: daal_defines.h:133
daal::data_management::interface1::HomogenNumericTable::HomogenNumericTable
HomogenNumericTable(DictionaryIface::FeaturesEqual featuresEqual, size_t nColumns, size_t nRows, AllocationFlag memoryAllocationFlag)
Definition: homogen_numeric_table.h:438
daal::data_management::interface1::HomogenNumericTable::HomogenNumericTable
HomogenNumericTable(size_t nColumns, size_t nRows, NumericTable::AllocationFlag memoryAllocationFlag, const DataType &constValue)
Definition: homogen_numeric_table.h:474
daal::data_management::interface1::HomogenNumericTable::assign
virtual services::Status assign(double value) DAAL_C11_OVERRIDE
Definition: homogen_numeric_table.h:702
daal::data_management::interface1::HomogenNumericTable::HomogenNumericTable
HomogenNumericTable(const services::SharedPtr< DataType > &ptr, size_t nColumns, size_t nRows, const DataType &constValue)
Definition: homogen_numeric_table.h:293
daal::data_management::interface1::HomogenNumericTable::create
static services::SharedPtr< HomogenNumericTable< DataType > > create(DictionaryIface::FeaturesEqual featuresEqual, DataType *const ptr, size_t nColumns, size_t nRows, const DataType &constValue, services::Status *stat=NULL)
Definition: homogen_numeric_table.h:351
daal::data_management::interface1::HomogenNumericTable::HomogenNumericTable
HomogenNumericTable()
Definition: homogen_numeric_table.h:100
daal::data_management::interface1::HomogenNumericTable::getBlockOfRows
services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: homogen_numeric_table.h:713
daal::services::ErrorIncorrectNumberOfFeatures
Definition: error_indexes.h:70
daal_defines.h
daal::algorithms::multivariate_outlier_detection::location
Definition: outlier_detection_multivariate_types.h:72
daal::data_management::interface1::HomogenNumericTable::create
static services::SharedPtr< HomogenNumericTable< DataType > > create(DictionaryIface::FeaturesEqual featuresEqual, const services::SharedPtr< DataType > &ptr, size_t nColumns, size_t nRows, const DataType &constValue, services::Status *stat=NULL)
Definition: homogen_numeric_table.h:389
daal::services::daal_memcpy_s
DAAL_EXPORT void daal_memcpy_s(void *dest, size_t numberOfElements, const void *src, size_t count)
daal::data_management::interface1::HomogenNumericTable::create
static services::SharedPtr< HomogenNumericTable< DataType > > create(DictionaryIface::FeaturesEqual featuresEqual, size_t nColumns, size_t nRows, AllocationFlag memoryAllocationFlag, const DataType &constValue, services::Status *stat=NULL)
Definition: homogen_numeric_table.h:540
daal::data_management::interface1::HomogenNumericTable::HomogenNumericTable
HomogenNumericTable(DataType *const ptr, size_t nColumns, size_t nRows, const DataType &constValue)
Definition: homogen_numeric_table.h:258
daal::data_management::interface1::HomogenNumericTable::create
static services::SharedPtr< HomogenNumericTable< DataType > > create(DataType *const ptr, size_t nColumns=0, size_t nRows=0, services::Status *stat=NULL)
Definition: homogen_numeric_table.h:140
daal::data_management::interface1::HomogenNumericTable::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: homogen_numeric_table.h:755
daal::services::daal_malloc
DAAL_EXPORT void * daal_malloc(size_t size, size_t alignment=DAAL_MALLOC_DEFAULT_ALIGNMENT)
daal::data_management::interface1::HomogenNumericTable::getBlockOfRows
services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: homogen_numeric_table.h:717
daal::data_management::interface1::HomogenNumericTable::create
static services::SharedPtr< HomogenNumericTable< DataType > > create(NumericTableDictionaryPtr ddictForHomogenNumericTable, services::Status *stat=NULL)
Definition: homogen_numeric_table.h:91
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::HomogenNumericTable::create
static services::SharedPtr< HomogenNumericTable< DataType > > create(const services::SharedPtr< DataType > &ptr, size_t nColumns, size_t nRows, services::Status *stat=NULL)
Definition: homogen_numeric_table.h:173
daal::data_management::interface1::HomogenNumericTable::getArray
DataType * getArray() const
Definition: homogen_numeric_table.h:556
daal::data_management::interface1::HomogenNumericTable::operator[]
DataType * operator[](size_t i)
Definition: homogen_numeric_table.h:688
daal::data_management::interface1::HomogenNumericTable::setArray
DAAL_DEPRECATED services::Status setArray(DataType *const ptr)
Definition: homogen_numeric_table.h:575
daal::data_management::interface1::HomogenNumericTable::assign
virtual services::Status assign(float value) DAAL_C11_OVERRIDE
Definition: homogen_numeric_table.h:697
daal::data_management::interface1::HomogenNumericTable::create
static services::SharedPtr< HomogenNumericTable< DataType > > create(DictionaryIface::FeaturesEqual featuresEqual, DataType *const ptr=0, size_t nColumns=0, size_t nRows=0, services::Status *stat=NULL)
Definition: homogen_numeric_table.h:208
daal::data_management::interface1::HomogenNumericTable::getBlockOfColumnValues
services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num, ReadWriteMode rwflag, BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: homogen_numeric_table.h:745
daal::data_management::interface1::HomogenNumericTable::HomogenNumericTable
HomogenNumericTable(size_t nColumns, size_t nRows, AllocationFlag memoryAllocationFlag)
Definition: homogen_numeric_table.h:404
daal::data_management::interface1::HomogenNumericTable::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: homogen_numeric_table.h:726
daal::data_management::interface1::HomogenNumericTable::getArraySharedPtr
services::SharedPtr< DataType > getArraySharedPtr() const
Definition: homogen_numeric_table.h:565
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::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::HomogenNumericTable::create
static services::SharedPtr< HomogenNumericTable< DataType > > create(const services::SharedPtr< DataType > &ptr, size_t nColumns, size_t nRows, const DataType &constValue, services::Status *stat=NULL)
Definition: homogen_numeric_table.h:314
daal::data_management::interface1::NumericTableFeature::setType
void setType()
Definition: data_dictionary.h:91
daal::data_management::interface1::HomogenNumericTable::assign
virtual services::Status assign(int value) DAAL_C11_OVERRIDE
Definition: homogen_numeric_table.h:707
daal::services::ErrorIncorrectNumberOfObservations
Definition: error_indexes.h:71
daal::data_management::interface1::HomogenNumericTable::create
static services::SharedPtr< HomogenNumericTable< DataType > > create(DataType *const ptr, size_t nColumns, size_t nRows, const DataType &constValue, services::Status *stat=NULL)
Definition: homogen_numeric_table.h:279
daal::data_management::interface1::HomogenNumericTable::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: homogen_numeric_table.h:722
daal::data_management::interface1::HomogenNumericTable::create
static services::SharedPtr< HomogenNumericTable< DataType > > create(DictionaryIface::FeaturesEqual featuresEqual, size_t nColumns, size_t nRows, AllocationFlag memoryAllocationFlag, services::Status *stat=NULL)
Definition: homogen_numeric_table.h:459
daal::data_management::interface1::HomogenNumericTable::getBlockOfColumnValues
services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num, ReadWriteMode rwflag, BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: homogen_numeric_table.h:735
daal::data_management::interface1::HomogenNumericTable::getBlockOfRows
services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: homogen_numeric_table.h:709
daal::data_management::interface1::HomogenNumericTable::getBlockOfColumnValues
services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num, ReadWriteMode rwflag, BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: homogen_numeric_table.h:740
daal::data_management::interface1::HomogenNumericTable::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: homogen_numeric_table.h:751
daal::data_management::interface1::HomogenNumericTable::setArray
services::Status setArray(DataType *const ptr, size_t nRows)
Definition: homogen_numeric_table.h:619
daal::data_management::interface1::NumericTableFeature
Data structure describes the Numeric Table feature.
Definition: data_dictionary.h:48
daal::data_management::interface1::HomogenNumericTable::HomogenNumericTable
HomogenNumericTable(NumericTableDictionaryPtr ddictForHomogenNumericTable)
Definition: homogen_numeric_table.h:79
daal::data_management::interface1::HomogenNumericTable
Class that provides methods to access data stored as a contiguous array of homogeneous feature vector...
Definition: homogen_numeric_table.h:50
daal::MemType
MemType
Definition: daal_defines.h:131
daal::data_management::interface1::HomogenNumericTable::create
static services::SharedPtr< HomogenNumericTable< DataType > > create(services::Status *stat=NULL)
Definition: homogen_numeric_table.h:109
daal::services::ErrorEmptyHomogenNumericTable
Definition: error_indexes.h:161
daal::data_management::interface1::HomogenNumericTable::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: homogen_numeric_table.h:730
daal::data_management::interface1::HomogenNumericTable::create
static services::SharedPtr< HomogenNumericTable< DataType > > create(size_t nColumns, size_t nRows, AllocationFlag memoryAllocationFlag, services::Status *stat=NULL)
Definition: homogen_numeric_table.h:424
daal::data_management::interface1::HomogenNumericTable::create
static services::SharedPtr< HomogenNumericTable< DataType > > create(DictionaryIface::FeaturesEqual featuresEqual, const services::SharedPtr< DataType > &ptr, size_t nColumns, size_t nRows, services::Status *stat=NULL)
Definition: homogen_numeric_table.h:243
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.