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

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 "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  size_t i;
676  DataType *ptr = (DataType*)_ptr.get();
677  DataType valueDataType = (DataType)value;
678  for( i = 0; i < nColumns * nRows; i++ )
679  {
680  ptr[i] = valueDataType;
681  }
682  return services::Status();
683  }
684 
690  DataType *operator[](size_t i)
691  {
692  size_t nColumns = getNumberOfColumns();
693  return (DataType*)_ptr.get() + i * nColumns;
694  }
695 
699  virtual services::Status assign(float value) DAAL_C11_OVERRIDE {return assign<DataType>((DataType)value);}
700 
704  virtual services::Status assign(double value) DAAL_C11_OVERRIDE {return assign<DataType>((DataType)value);}
705 
709  virtual services::Status assign(int value) DAAL_C11_OVERRIDE {return assign<DataType>((DataType)value);}
710 
711  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
712  {
713  return getTBlock<double>(vector_idx, vector_num, rwflag, block);
714  }
715  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
716  {
717  return getTBlock<float>(vector_idx, vector_num, rwflag, block);
718  }
719  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
720  {
721  return getTBlock<int>(vector_idx, vector_num, rwflag, block);
722  }
723 
724  services::Status releaseBlockOfRows(BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
725  {
726  return releaseTBlock<double>(block);
727  }
728  services::Status releaseBlockOfRows(BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
729  {
730  return releaseTBlock<float>(block);
731  }
732  services::Status releaseBlockOfRows(BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
733  {
734  return releaseTBlock<int>(block);
735  }
736 
737  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
738  ReadWriteMode rwflag, BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
739  {
740  return getTFeature<double>(feature_idx, vector_idx, value_num, rwflag, block);
741  }
742  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
743  ReadWriteMode rwflag, BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
744  {
745  return getTFeature<float>(feature_idx, vector_idx, value_num, rwflag, block);
746  }
747  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
748  ReadWriteMode rwflag, BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
749  {
750  return getTFeature<int>(feature_idx, vector_idx, value_num, rwflag, block);
751  }
752 
753  services::Status releaseBlockOfColumnValues(BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
754  {
755  return releaseTFeature<double>(block);
756  }
757  services::Status releaseBlockOfColumnValues(BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
758  {
759  return releaseTFeature<float>(block);
760  }
761  services::Status releaseBlockOfColumnValues(BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
762  {
763  return releaseTFeature<int>(block);
764  }
765 
766 protected:
767  services::SharedPtr<byte> _ptr;
768 
769  HomogenNumericTable(services::Status &st):
770  NumericTable(0, 0, DictionaryIface::notEqual, st)
771  {}
772 
773  HomogenNumericTable(NumericTableDictionaryPtr ddictForHomogenNumericTable, services::Status &st):
774  NumericTable(ddictForHomogenNumericTable, st)
775  {
776  _layout = aos;
777  }
778 
779  HomogenNumericTable(DictionaryIface::FeaturesEqual featuresEqual, const services::SharedPtr<DataType> &ptr,
780  size_t nColumns, size_t nRows, services::Status &st):
781  NumericTable(nColumns, nRows, featuresEqual, st)
782  {
783  _layout = aos;
784  st |= setArray( ptr, nRows );
785 
786  NumericTableFeature df;
787  df.setType<DataType>();
788  st |= _ddict->setAllFeatures(df);
789  }
790 
791  HomogenNumericTable(DictionaryIface::FeaturesEqual featuresEqual, const services::SharedPtr<DataType> &ptr,
792  size_t nColumns, size_t nRows, const DataType &constValue, services::Status &st):
793  NumericTable(nColumns, nRows, featuresEqual, st)
794  {
795  _layout = aos;
796  st |= setArray( ptr, nRows );
797 
798  NumericTableFeature df;
799  df.setType<DataType>();
800  st |= _ddict->setAllFeatures(df);
801  st |= assign<DataType>(constValue);
802  }
803 
804  HomogenNumericTable(DictionaryIface::FeaturesEqual featuresEqual,
805  size_t nColumns, size_t nRows, AllocationFlag memoryAllocationFlag, services::Status &st):
806  NumericTable(nColumns, nRows, featuresEqual, st)
807  {
808  _layout = aos;
809 
810  NumericTableFeature df;
811  df.setType<DataType>();
812  st |= _ddict->setAllFeatures(df);
813 
814  if( memoryAllocationFlag == doAllocate ) st |= allocateDataMemoryImpl();
815  }
816 
817  HomogenNumericTable(DictionaryIface::FeaturesEqual featuresEqual, size_t nColumns, size_t nRows,
818  NumericTable::AllocationFlag memoryAllocationFlag,
819  const DataType &constValue, services::Status &st):
820  NumericTable(nColumns, nRows, featuresEqual, st)
821  {
822  _layout = aos;
823 
824  NumericTableFeature df;
825  df.setType<DataType>();
826 
827  st |= _ddict->setAllFeatures(df);
828 
829  if( memoryAllocationFlag == doAllocate ) { st |= allocateDataMemoryImpl(); }
830 
831  st |= assign<DataType>(constValue);
832  }
833 
834  services::Status allocateDataMemoryImpl(daal::MemType type = daal::dram) DAAL_C11_OVERRIDE
835  {
836  freeDataMemoryImpl();
837 
838  size_t size = getNumberOfColumns() * getNumberOfRows();
839 
840  if( size == 0 )
841  {
842  return services::Status(getNumberOfColumns() == 0 ? services::ErrorIncorrectNumberOfFeatures :
843  services::ErrorIncorrectNumberOfObservations);
844  }
845 
846  _ptr = services::SharedPtr<byte>((byte *)daal::services::daal_malloc(size * sizeof(DataType)), services::ServiceDeleter());
847 
848  if(!_ptr)
849  return services::Status(services::ErrorMemoryAllocationFailed);
850 
851  _memStatus = internallyAllocated;
852  return services::Status();
853  }
854 
855  void freeDataMemoryImpl() DAAL_C11_OVERRIDE
856  {
857  _ptr = services::SharedPtr<byte>();
858  _memStatus = notAllocated;
859  }
860 
861  template<typename Archive, bool onDeserialize>
862  services::Status serialImpl( Archive *archive )
863  {
864  NumericTable::serialImpl<Archive, onDeserialize>( archive );
865 
866  if( onDeserialize )
867  {
868  allocateDataMemoryImpl();
869  }
870 
871  size_t size = getNumberOfColumns() * getNumberOfRows();
872 
873  archive->set( (DataType*)_ptr.get(), size );
874 
875  return services::Status();
876  }
877 
878 private:
879  byte *internal_getBlockOfRows( size_t idx )
880  {
881  size_t _featnum = _ddict->getNumberOfFeatures();
882  return _ptr.get() + _featnum * idx * sizeof(DataType);
883  }
884 
885  byte *internal_getBlockOfRows( size_t idx, size_t feat_idx )
886  {
887  size_t _featnum = _ddict->getNumberOfFeatures();
888  return _ptr.get() + _featnum * idx * sizeof(DataType) + feat_idx * sizeof(DataType);
889  }
890 
891 protected:
892 
893  template <typename T>
894  services::Status getTBlock( size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T> &block )
895  {
896  size_t ncols = getNumberOfColumns();
897  size_t nobs = getNumberOfRows();
898  block.setDetails( 0, idx, rwFlag );
899 
900  if (idx >= nobs)
901  {
902  block.resizeBuffer( ncols, 0 );
903  return services::Status();
904  }
905 
906  nrows = ( idx + nrows < nobs ) ? nrows : nobs - idx;
907 
908  if( IsSameType<T, DataType>::value )
909  {
910  block.setPtr(&_ptr, internal_getBlockOfRows(idx) , ncols, nrows );
911  }
912  else
913  {
914  if( !block.resizeBuffer( ncols, nrows ) )
915  return services::Status(services::ErrorMemoryAllocationFailed);
916 
917  if( rwFlag & (int)readOnly )
918  {
919  byte *location = internal_getBlockOfRows(idx);
920 
921  for(size_t i = 0; i < nrows; i++)
922  {
923  internal::getVectorUpCast(features::internal::getIndexNumType<DataType>(), internal::getConversionDataType<T>())
924  ( ncols, ((DataType*)location) + i * ncols, ((T*)block.getBlockPtr()) + i * ncols );
925  }
926  }
927  }
928  return services::Status();
929  }
930 
931  template <typename T>
932  services::Status releaseTBlock( BlockDescriptor<T> &block )
933  {
934  if(block.getRWFlag() & (int)writeOnly)
935  {
936  byte *location = internal_getBlockOfRows( block.getRowsOffset() );
937  size_t ncols = getNumberOfColumns();
938  size_t nrows = block.getNumberOfRows();
939 
940  if( IsSameType<T, DataType>::value )
941  {
942  if( (T*)block.getBlockPtr() != (T *)location )
943  {
944  daal::services::daal_memcpy_s(location, nrows * ncols * sizeof(T), block.getBlockPtr(), nrows * ncols * sizeof(T));
945  }
946  }
947  else
948  {
949  for(size_t i = 0; i < nrows; i++)
950  {
951  internal::getVectorDownCast(features::internal::getIndexNumType<DataType>(), internal::getConversionDataType<T>())
952  ( ncols, ((T*)block.getBlockPtr()) + i * ncols, ((DataType*)location) + i * ncols );
953  }
954  }
955  }
956  block.reset();
957  return services::Status();
958  }
959 
960  template <typename T>
961  services::Status getTFeature(size_t feat_idx, size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T> &block)
962  {
963  size_t ncols = getNumberOfColumns();
964  size_t nobs = getNumberOfRows();
965  block.setDetails( feat_idx, idx, rwFlag );
966 
967  if (idx >= nobs)
968  {
969  block.resizeBuffer( 1, 0 );
970  return services::Status();
971  }
972 
973  nrows = ( idx + nrows < nobs ) ? nrows : nobs - idx;
974 
975  if( ( IsSameType<T, DataType>::value ) && (ncols == 1) )
976  {
977  block.setPtr(&_ptr, internal_getBlockOfRows(idx) , ncols, nrows );
978  }
979  else
980  {
981  if( !block.resizeBuffer( 1, nrows ) )
982  return services::Status(services::ErrorMemoryAllocationFailed);
983 
984  if( rwFlag & (int)readOnly )
985  {
986  DataType *location = (DataType *)internal_getBlockOfRows(idx, feat_idx);
987  T *buffer = block.getBlockPtr();
988  internal::getVectorStrideUpCast(features::internal::getIndexNumType<DataType>(), internal::getConversionDataType<T>())
989  ( nrows, location, sizeof(DataType)*ncols, buffer, sizeof(T) );
990  }
991  }
992  return services::Status();
993  }
994 
995  template <typename T>
996  services::Status releaseTFeature( BlockDescriptor<T> &block )
997  {
998  if (block.getRWFlag() & (int)writeOnly)
999  {
1000  size_t ncols = getNumberOfColumns();
1001  DataType *location = (DataType *)internal_getBlockOfRows(block.getRowsOffset(), block.getColumnsOffset());
1002  internal::getVectorStrideDownCast(features::internal::getIndexNumType<DataType>(), internal::getConversionDataType<T>())
1003  ( block.getNumberOfRows(), block.getBlockPtr(), sizeof(T), location, ncols * sizeof(DataType) );
1004  }
1005  block.reset();
1006  return services::Status();
1007  }
1008 
1009  services::Status setNumberOfColumnsImpl(size_t ncol) DAAL_C11_OVERRIDE
1010  {
1011  if( _ddict->getNumberOfFeatures() != ncol )
1012  {
1013  _ddict->resetDictionary();
1014  _ddict->setNumberOfFeatures(ncol);
1015 
1016  NumericTableFeature df;
1017  df.setType<DataType>();
1018  _ddict->setAllFeatures(df);
1019  }
1020  return services::Status();
1021  }
1022 
1023 };
1025 } // namespace interface1
1026 using interface1::HomogenNumericTable;
1027 
1028 }
1029 } // namespace daal
1030 #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:761
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:133
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:704
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:715
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:757
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:719
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:690
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:699
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:747
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:728
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:709
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:724
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:737
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:711
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:742
daal::data_management::interface1::HomogenNumericTable::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: homogen_numeric_table.h:753
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:131
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:732
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.