C++ API Reference for Intel® Data Analytics Acceleration Library 2019 Update 4

homogen_numeric_table.h
1 /* file: homogen_numeric_table.h */
2 /*******************************************************************************
3 * Copyright 2014-2019 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 "services/daal_memory.h"
27 #include "services/daal_defines.h"
28 
29 #include "data_management/data/numeric_table.h"
30 #include "data_management/data/data_serialize.h"
31 #include "data_management/data/internal/conversion.h"
32 
33 namespace daal
34 {
35 namespace data_management
36 {
37 
38 namespace interface1
39 {
51 template<typename DataType = DAAL_DATA_TYPE>
52 class DAAL_EXPORT HomogenNumericTable : public NumericTable
53 {
54 public:
55  DECLARE_SERIALIZABLE_TAG();
56  DECLARE_SERIALIZABLE_IMPL();
57 
58  DAAL_CAST_OPERATOR(HomogenNumericTable)
62  typedef DataType baseDataType;
63 
64 public:
70  DAAL_DEPRECATED HomogenNumericTable( NumericTableDictionary *ddict ):
71  NumericTable(ddict)
72  {
73  _layout = aos;
74  }
75 
81  HomogenNumericTable( NumericTableDictionaryPtr ddictForHomogenNumericTable ):
82  NumericTable(ddictForHomogenNumericTable)
83  {
84  _layout = aos;
85  }
86 
93  static services::SharedPtr<HomogenNumericTable<DataType> > create(NumericTableDictionaryPtr ddictForHomogenNumericTable, services::Status *stat = NULL)
94  {
95  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(HomogenNumericTable, DataType, ddictForHomogenNumericTable);
96  }
97 
102  HomogenNumericTable():
103  NumericTable(0, 0)
104  {}
105 
111  static services::SharedPtr<HomogenNumericTable<DataType> > create(services::Status *stat = NULL)
112  {
113  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL(HomogenNumericTable, DataType);
114  }
115 
123  HomogenNumericTable( DataType *const ptr, size_t nColumns = 0, size_t nRows = 0 ):
124  NumericTable( nColumns, nRows )
125  {
126  _layout = aos;
127  this->_status |= setArray( ptr, nRows );
128 
129  NumericTableFeature df;
130  df.setType<DataType>();
131  this->_status |= _ddict->setAllFeatures(df);
132  }
133 
142  static services::SharedPtr<HomogenNumericTable<DataType> > create(DataType *const ptr,
143  size_t nColumns = 0, size_t nRows = 0,
144  services::Status *stat = NULL)
145  {
146  return create(services::SharedPtr<DataType>(ptr, services::EmptyDeleter()), nColumns, nRows, stat);
147  }
148 
156  HomogenNumericTable( const services::SharedPtr<DataType> &ptr, size_t nColumns, size_t nRows ):
157  NumericTable( nColumns, nRows )
158  {
159  _layout = aos;
160  this->_status |= setArray( ptr, nRows );
161 
162  NumericTableFeature df;
163  df.setType<DataType>();
164  this->_status |= _ddict->setAllFeatures(df);
165  }
166 
175  static services::SharedPtr<HomogenNumericTable<DataType> > create(const services::SharedPtr<DataType> &ptr,
176  size_t nColumns, size_t nRows,
177  services::Status *stat = NULL)
178  {
179  return create(DictionaryIface::notEqual, ptr, nColumns, nRows, stat);
180  }
181 
190  HomogenNumericTable( DictionaryIface::FeaturesEqual featuresEqual, DataType *const ptr = 0, size_t nColumns = 0, size_t nRows = 0):
191  NumericTable( nColumns, nRows, featuresEqual )
192  {
193  _layout = aos;
194  this->_status |= setArray( ptr, nRows );
195 
196  NumericTableFeature df;
197  df.setType<DataType>();
198  this->_status |= _ddict->setAllFeatures(df);
199  }
200 
210  static services::SharedPtr<HomogenNumericTable<DataType> > create(DictionaryIface::FeaturesEqual featuresEqual,
211  DataType *const ptr = 0, size_t nColumns = 0, size_t nRows = 0,
212  services::Status *stat = NULL)
213  {
214  return create(featuresEqual, services::SharedPtr<DataType>(ptr, services::EmptyDeleter()), nColumns, nRows, stat);
215  }
216 
225  HomogenNumericTable( DictionaryIface::FeaturesEqual featuresEqual, const services::SharedPtr<DataType> &ptr, size_t nColumns, size_t nRows ):
226  NumericTable( nColumns, nRows, featuresEqual )
227  {
228  _layout = aos;
229  this->_status |= setArray( ptr, nRows );
230 
231  NumericTableFeature df;
232  df.setType<DataType>();
233  this->_status |= _ddict->setAllFeatures(df);
234  }
235 
245  static services::SharedPtr<HomogenNumericTable<DataType> > create(DictionaryIface::FeaturesEqual featuresEqual,
246  const services::SharedPtr<DataType> &ptr,
247  size_t nColumns, size_t nRows, services::Status *stat = NULL)
248  {
249  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(HomogenNumericTable, DataType, featuresEqual, ptr, nColumns, nRows);
250  }
251 
260  HomogenNumericTable( DataType *const ptr, size_t nColumns, size_t nRows, const DataType &constValue ):
261  NumericTable( nColumns, nRows )
262  {
263  _layout = aos;
264  this->_status |= setArray( ptr, nRows );
265 
266  NumericTableFeature df;
267  df.setType<DataType>();
268  this->_status |= _ddict->setAllFeatures(df);
269  this->_status |= assign<DataType>(constValue);
270  }
271 
281  static services::SharedPtr<HomogenNumericTable<DataType> > create(DataType *const ptr, size_t nColumns, size_t nRows, const DataType &constValue,
282  services::Status *stat = NULL)
283  {
284  return create(services::SharedPtr<DataType>(ptr, services::EmptyDeleter()), nColumns, nRows, constValue, stat);
285  }
286 
295  HomogenNumericTable(const services::SharedPtr<DataType> &ptr, size_t nColumns, size_t nRows, const DataType &constValue ):
296  NumericTable( nColumns, nRows )
297  {
298  _layout = aos;
299  this->_status |= setArray( ptr, nRows );
300 
301  NumericTableFeature df;
302  df.setType<DataType>();
303  this->_status |= _ddict->setAllFeatures(df);
304  this->_status |= assign<DataType>(constValue);
305  }
306 
316  static services::SharedPtr<HomogenNumericTable<DataType> > create(const services::SharedPtr<DataType> &ptr, size_t nColumns, size_t nRows,
317  const DataType &constValue, services::Status *stat = NULL)
318  {
319  return create(DictionaryIface::notEqual, ptr, nColumns, nRows, constValue, stat);
320  }
321 
331  HomogenNumericTable( DictionaryIface::FeaturesEqual featuresEqual, DataType *const ptr, size_t nColumns, size_t nRows, const DataType &constValue ):
332  NumericTable( nColumns, nRows, featuresEqual )
333  {
334  _layout = aos;
335  this->_status |= setArray( ptr, nRows );
336 
337  NumericTableFeature df;
338  df.setType<DataType>();
339  this->_status |= _ddict->setAllFeatures(df);
340  this->_status |= assign<DataType>(constValue);
341  }
342 
353  static services::SharedPtr<HomogenNumericTable<DataType> > create(DictionaryIface::FeaturesEqual featuresEqual, DataType *const ptr,
354  size_t nColumns, size_t nRows, const DataType &constValue,
355  services::Status *stat = NULL)
356  {
357  return create(featuresEqual, services::SharedPtr<DataType>(ptr, services::EmptyDeleter()), nColumns, nRows, constValue, stat);
358  }
359 
369  HomogenNumericTable( DictionaryIface::FeaturesEqual featuresEqual, const services::SharedPtr<DataType> &ptr, size_t nColumns, size_t nRows, const DataType &constValue ):
370  NumericTable( nColumns, nRows, featuresEqual )
371  {
372  _layout = aos;
373  this->_status |= setArray( ptr, nRows );
374 
375  NumericTableFeature df;
376  df.setType<DataType>();
377  this->_status |= _ddict->setAllFeatures(df);
378  this->_status |= assign<DataType>(constValue);
379  }
380 
391  static services::SharedPtr<HomogenNumericTable<DataType> > create(DictionaryIface::FeaturesEqual featuresEqual,
392  const services::SharedPtr<DataType> &ptr,
393  size_t nColumns, size_t nRows, const DataType &constValue,
394  services::Status *stat = NULL)
395  {
396  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(HomogenNumericTable, DataType, featuresEqual, ptr, nColumns, nRows, constValue);
397  }
398 
406  HomogenNumericTable( size_t nColumns, size_t nRows, AllocationFlag memoryAllocationFlag ):
407  NumericTable( nColumns, nRows )
408  {
409  _layout = aos;
410 
411  NumericTableFeature df;
412  df.setType<DataType>();
413  this->_status |= _ddict->setAllFeatures(df);
414 
415  if( memoryAllocationFlag == doAllocate ) this->_status |= allocateDataMemoryImpl();
416  }
417 
426  static services::SharedPtr<HomogenNumericTable<DataType> > create(size_t nColumns, size_t nRows, AllocationFlag memoryAllocationFlag,
427  services::Status *stat = NULL)
428  {
429  return create(DictionaryIface::notEqual, nColumns, nRows, memoryAllocationFlag, stat);
430  }
431 
440  HomogenNumericTable( DictionaryIface::FeaturesEqual featuresEqual, size_t nColumns, size_t nRows, AllocationFlag memoryAllocationFlag ):
441  NumericTable( nColumns, nRows, featuresEqual )
442  {
443  _layout = aos;
444 
445  NumericTableFeature df;
446  df.setType<DataType>();
447  this->_status |= _ddict->setAllFeatures(df);
448 
449  if( memoryAllocationFlag == doAllocate ) this->_status |= allocateDataMemoryImpl();
450  }
451 
461  static services::SharedPtr<HomogenNumericTable<DataType> > create(DictionaryIface::FeaturesEqual featuresEqual,
462  size_t nColumns, size_t nRows, AllocationFlag memoryAllocationFlag,
463  services::Status *stat = NULL)
464  {
465  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(HomogenNumericTable, DataType, featuresEqual, nColumns, nRows, memoryAllocationFlag);
466  }
467 
476  HomogenNumericTable( size_t nColumns, size_t nRows, NumericTable::AllocationFlag memoryAllocationFlag,
477  const DataType &constValue ):
478  NumericTable( nColumns, nRows )
479  {
480  _layout = aos;
481 
482  NumericTableFeature df;
483  df.setType<DataType>();
484 
485  this->_status |= _ddict->setAllFeatures(df);
486 
487  if( memoryAllocationFlag == doAllocate ) this->_status |= allocateDataMemoryImpl();
488 
489  this->_status |= assign<DataType>(constValue);
490  }
491 
501  static services::SharedPtr<HomogenNumericTable<DataType> > create(size_t nColumns, size_t nRows, AllocationFlag memoryAllocationFlag,
502  const DataType &constValue, services::Status *stat = NULL)
503  {
504  return create(DictionaryIface::notEqual, nColumns, nRows, memoryAllocationFlag, constValue, stat);
505  }
506 
516  HomogenNumericTable( DictionaryIface::FeaturesEqual featuresEqual, size_t nColumns, size_t nRows, NumericTable::AllocationFlag memoryAllocationFlag,
517  const DataType &constValue ):
518  NumericTable( nColumns, nRows, featuresEqual )
519  {
520  _layout = aos;
521 
522  NumericTableFeature df;
523  df.setType<DataType>();
524 
525  this->_status |= _ddict->setAllFeatures(df);
526 
527  if( memoryAllocationFlag == doAllocate ) { this->_status |= allocateDataMemoryImpl(); }
528 
529  this->_status |= assign<DataType>(constValue);
530  }
531 
542  static services::SharedPtr<HomogenNumericTable<DataType> > create(DictionaryIface::FeaturesEqual featuresEqual,
543  size_t nColumns, size_t nRows, AllocationFlag memoryAllocationFlag,
544  const DataType &constValue, services::Status *stat = NULL)
545  {
546  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(HomogenNumericTable, DataType, featuresEqual, nColumns, nRows, memoryAllocationFlag, constValue);
547  }
548 
549  virtual ~HomogenNumericTable()
550  {
551  freeDataMemoryImpl();
552  }
553 
558  DataType *getArray() const
559  {
560  return (DataType*)_ptr.get();
561  }
562 
567  services::SharedPtr<DataType> getArraySharedPtr() const
568  {
569  return services::reinterpretPointerCast<DataType, byte>(_ptr);
570  }
571 
577  DAAL_DEPRECATED services::Status setArray( DataType *const ptr )
578  {
579  freeDataMemoryImpl();
580 
581  _ptr = services::SharedPtr<byte>((byte*)ptr, services::EmptyDeleter());
582 
583  if(_ptr)
584  {
585  _memStatus = userAllocated;
586  }
587  else
588  {
589  _memStatus = notAllocated;
590  }
591  return services::Status();
592  }
593 
599  DAAL_DEPRECATED services::Status setArray( const services::SharedPtr<DataType> &ptr )
600  {
601  freeDataMemoryImpl();
602 
603  _ptr = services::reinterpretPointerCast<byte, DataType>(ptr);
604 
605  if(_ptr)
606  {
607  _memStatus = userAllocated;
608  }
609  else
610  {
611  _memStatus = notAllocated;
612  }
613  return services::Status();
614  }
615 
621  services::Status setArray( DataType *const ptr, size_t nRows )
622  {
623  freeDataMemoryImpl();
624 
625  _ptr = services::SharedPtr<byte>((byte*)ptr, services::EmptyDeleter());
626  _obsnum = nRows;
627 
628  if(_ptr)
629  {
630  _memStatus = userAllocated;
631  }
632  else
633  {
634  _memStatus = notAllocated;
635  }
636  return services::Status();
637  }
638 
644  services::Status setArray( services::SharedPtr<DataType> ptr, size_t nRows )
645  {
646  freeDataMemoryImpl();
647 
648  _ptr = services::reinterpretPointerCast<byte, DataType>(ptr);
649  _obsnum = nRows;
650 
651  if(_ptr)
652  {
653  _memStatus = userAllocated;
654  }
655  else
656  {
657  _memStatus = notAllocated;
658  }
659  return services::Status();
660  }
661 
666  template <typename T>
667  services::Status assign(T value)
668  {
669  if( _memStatus == notAllocated )
670  return services::Status(services::ErrorEmptyHomogenNumericTable);
671 
672  size_t nColumns = getNumberOfColumns();
673  size_t nRows = getNumberOfRows();
674 
675  DataType *ptr = (DataType*)_ptr.get();
676  DataType valueDataType = (DataType)value;
677 
678  internal::vectorAssignValueToArray<DataType>(ptr, nColumns*nRows, 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  internal::getVectorUpCast(features::internal::getIndexNumType<DataType>(), internal::getConversionDataType<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  internal::getVectorDownCast(features::internal::getIndexNumType<DataType>(), internal::getConversionDataType<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  internal::getVectorStrideUpCast(features::internal::getIndexNumType<DataType>(), internal::getConversionDataType<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  internal::getVectorStrideDownCast(features::internal::getIndexNumType<DataType>(), internal::getConversionDataType<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:501
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:190
daal::data_management::interface1::HomogenNumericTable::HomogenNumericTable
HomogenNumericTable(DataType *const ptr, size_t nColumns=0, size_t nRows=0)
Definition: homogen_numeric_table.h:123
daal::data_management::interface1::HomogenNumericTable::baseDataType
DataType baseDataType
Definition: homogen_numeric_table.h:62
daal::data_management::interface1::HomogenNumericTable::HomogenNumericTable
HomogenNumericTable(const services::SharedPtr< DataType > &ptr, size_t nColumns, size_t nRows)
Definition: homogen_numeric_table.h:156
daal::data_management::interface1::HomogenNumericTable::setArray
DAAL_DEPRECATED services::Status setArray(const services::SharedPtr< DataType > &ptr)
Definition: homogen_numeric_table.h:599
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:225
daal::data_management::interface1::HomogenNumericTable::assign
services::Status assign(T value)
Definition: homogen_numeric_table.h:667
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:369
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:331
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:516
daal::data_management::interface1::HomogenNumericTable::setArray
services::Status setArray(services::SharedPtr< DataType > ptr, size_t nRows)
Definition: homogen_numeric_table.h:644
daal::services::ErrorMemoryAllocationFailed
Definition: error_indexes.h:146
daal::dram
Definition: daal_defines.h:137
daal::data_management::interface1::HomogenNumericTable::HomogenNumericTable
HomogenNumericTable(DictionaryIface::FeaturesEqual featuresEqual, size_t nColumns, size_t nRows, AllocationFlag memoryAllocationFlag)
Definition: homogen_numeric_table.h:440
daal::data_management::interface1::HomogenNumericTable::HomogenNumericTable
HomogenNumericTable(size_t nColumns, size_t nRows, NumericTable::AllocationFlag memoryAllocationFlag, const DataType &constValue)
Definition: homogen_numeric_table.h:476
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:295
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:353
daal::data_management::interface1::HomogenNumericTable::HomogenNumericTable
HomogenNumericTable()
Definition: homogen_numeric_table.h:102
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:391
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:542
daal::data_management::interface1::HomogenNumericTable::HomogenNumericTable
HomogenNumericTable(DataType *const ptr, size_t nColumns, size_t nRows, const DataType &constValue)
Definition: homogen_numeric_table.h:260
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:142
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:93
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:175
daal::data_management::interface1::HomogenNumericTable::getArray
DataType * getArray() const
Definition: homogen_numeric_table.h:558
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:577
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:210
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:406
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:567
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:148
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:316
daal::data_management::interface1::NumericTableFeature::setType
void setType()
Definition: data_dictionary.h:94
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:281
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:461
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:621
daal::data_management::interface1::NumericTableFeature
Data structure describes the Numeric Table feature.
Definition: data_dictionary.h:51
daal::data_management::interface1::HomogenNumericTable::HomogenNumericTable
HomogenNumericTable(NumericTableDictionaryPtr ddictForHomogenNumericTable)
Definition: homogen_numeric_table.h:81
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:52
daal::MemType
MemType
Definition: daal_defines.h:135
daal::data_management::interface1::HomogenNumericTable::create
static services::SharedPtr< HomogenNumericTable< DataType > > create(services::Status *stat=NULL)
Definition: homogen_numeric_table.h:111
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:426
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:245
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:161

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