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

homogen_numeric_table.h
1 /* file: homogen_numeric_table.h */
2 /*******************************************************************************
3 * Copyright 2014-2020 Intel Corporation
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *******************************************************************************/
17 
18 /*
19 //++
20 // Implementation of a homogeneous numeric table.
21 //--
22 */
23 
24 
25 #ifndef __HOMOGEN_NUMERIC_TABLE_H__
26 #define __HOMOGEN_NUMERIC_TABLE_H__
27 
28 #include "services/daal_memory.h"
29 #include "services/daal_defines.h"
30 
31 #include "data_management/data/numeric_table.h"
32 #include "data_management/data/data_serialize.h"
33 #include "data_management/data/internal/conversion.h"
34 
35 namespace daal
36 {
37 namespace data_management
38 {
39 
40 namespace interface1
41 {
53 template<typename DataType = DAAL_DATA_TYPE>
54 class DAAL_EXPORT HomogenNumericTable : public NumericTable
55 {
56 public:
57  DECLARE_SERIALIZABLE_TAG();
58  DECLARE_SERIALIZABLE_IMPL();
59 
60  DAAL_CAST_OPERATOR(HomogenNumericTable)
64  typedef DataType baseDataType;
65 
66 public:
72  DAAL_DEPRECATED HomogenNumericTable( NumericTableDictionary *ddict ):
73  NumericTable(ddict)
74  {
75  _layout = aos;
76  }
77 
83  HomogenNumericTable( NumericTableDictionaryPtr ddictForHomogenNumericTable ):
84  NumericTable(ddictForHomogenNumericTable)
85  {
86  _layout = aos;
87  }
88 
95  static services::SharedPtr<HomogenNumericTable<DataType> > create(NumericTableDictionaryPtr ddictForHomogenNumericTable, services::Status *stat = NULL)
96  {
97  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(HomogenNumericTable, DataType, ddictForHomogenNumericTable);
98  }
99 
104  HomogenNumericTable():
105  NumericTable(0, 0)
106  {}
107 
113  static services::SharedPtr<HomogenNumericTable<DataType> > create(services::Status *stat = NULL)
114  {
115  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL(HomogenNumericTable, DataType);
116  }
117 
125  HomogenNumericTable( DataType *const ptr, size_t nColumns = 0, size_t nRows = 0 ):
126  NumericTable( nColumns, nRows )
127  {
128  _layout = aos;
129  this->_status |= setArray( ptr, nRows );
130 
131  NumericTableFeature df;
132  df.setType<DataType>();
133  this->_status |= _ddict->setAllFeatures(df);
134  }
135 
144  static services::SharedPtr<HomogenNumericTable<DataType> > create(DataType *const ptr,
145  size_t nColumns = 0, size_t nRows = 0,
146  services::Status *stat = NULL)
147  {
148  return create(services::SharedPtr<DataType>(ptr, services::EmptyDeleter()), nColumns, nRows, stat);
149  }
150 
158  HomogenNumericTable( const services::SharedPtr<DataType> &ptr, size_t nColumns, size_t nRows ):
159  NumericTable( nColumns, nRows )
160  {
161  _layout = aos;
162  this->_status |= setArray( ptr, nRows );
163 
164  NumericTableFeature df;
165  df.setType<DataType>();
166  this->_status |= _ddict->setAllFeatures(df);
167  }
168 
177  static services::SharedPtr<HomogenNumericTable<DataType> > create(const services::SharedPtr<DataType> &ptr,
178  size_t nColumns, size_t nRows,
179  services::Status *stat = NULL)
180  {
181  return create(DictionaryIface::notEqual, ptr, nColumns, nRows, stat);
182  }
183 
192  HomogenNumericTable( DictionaryIface::FeaturesEqual featuresEqual, DataType *const ptr = 0, size_t nColumns = 0, size_t nRows = 0):
193  NumericTable( nColumns, nRows, featuresEqual )
194  {
195  _layout = aos;
196  this->_status |= setArray( ptr, nRows );
197 
198  NumericTableFeature df;
199  df.setType<DataType>();
200  this->_status |= _ddict->setAllFeatures(df);
201  }
202 
212  static services::SharedPtr<HomogenNumericTable<DataType> > create(DictionaryIface::FeaturesEqual featuresEqual,
213  DataType *const ptr = 0, size_t nColumns = 0, size_t nRows = 0,
214  services::Status *stat = NULL)
215  {
216  return create(featuresEqual, services::SharedPtr<DataType>(ptr, services::EmptyDeleter()), nColumns, nRows, stat);
217  }
218 
227  HomogenNumericTable( DictionaryIface::FeaturesEqual featuresEqual, const services::SharedPtr<DataType> &ptr, size_t nColumns, size_t nRows ):
228  NumericTable( nColumns, nRows, featuresEqual )
229  {
230  _layout = aos;
231  this->_status |= setArray( ptr, nRows );
232 
233  NumericTableFeature df;
234  df.setType<DataType>();
235  this->_status |= _ddict->setAllFeatures(df);
236  }
237 
247  static services::SharedPtr<HomogenNumericTable<DataType> > create(DictionaryIface::FeaturesEqual featuresEqual,
248  const services::SharedPtr<DataType> &ptr,
249  size_t nColumns, size_t nRows, services::Status *stat = NULL)
250  {
251  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(HomogenNumericTable, DataType, featuresEqual, ptr, nColumns, nRows);
252  }
253 
262  HomogenNumericTable( DataType *const ptr, size_t nColumns, size_t nRows, const DataType &constValue ):
263  NumericTable( nColumns, nRows )
264  {
265  _layout = aos;
266  this->_status |= setArray( ptr, nRows );
267 
268  NumericTableFeature df;
269  df.setType<DataType>();
270  this->_status |= _ddict->setAllFeatures(df);
271  this->_status |= assign<DataType>(constValue);
272  }
273 
283  static services::SharedPtr<HomogenNumericTable<DataType> > create(DataType *const ptr, size_t nColumns, size_t nRows, const DataType &constValue,
284  services::Status *stat = NULL)
285  {
286  return create(services::SharedPtr<DataType>(ptr, services::EmptyDeleter()), nColumns, nRows, constValue, stat);
287  }
288 
297  HomogenNumericTable(const services::SharedPtr<DataType> &ptr, size_t nColumns, size_t nRows, const DataType &constValue ):
298  NumericTable( nColumns, nRows )
299  {
300  _layout = aos;
301  this->_status |= setArray( ptr, nRows );
302 
303  NumericTableFeature df;
304  df.setType<DataType>();
305  this->_status |= _ddict->setAllFeatures(df);
306  this->_status |= assign<DataType>(constValue);
307  }
308 
318  static services::SharedPtr<HomogenNumericTable<DataType> > create(const services::SharedPtr<DataType> &ptr, size_t nColumns, size_t nRows,
319  const DataType &constValue, services::Status *stat = NULL)
320  {
321  return create(DictionaryIface::notEqual, ptr, nColumns, nRows, constValue, stat);
322  }
323 
333  HomogenNumericTable( DictionaryIface::FeaturesEqual featuresEqual, DataType *const ptr, size_t nColumns, size_t nRows, const DataType &constValue ):
334  NumericTable( nColumns, nRows, featuresEqual )
335  {
336  _layout = aos;
337  this->_status |= setArray( ptr, nRows );
338 
339  NumericTableFeature df;
340  df.setType<DataType>();
341  this->_status |= _ddict->setAllFeatures(df);
342  this->_status |= assign<DataType>(constValue);
343  }
344 
355  static services::SharedPtr<HomogenNumericTable<DataType> > create(DictionaryIface::FeaturesEqual featuresEqual, DataType *const ptr,
356  size_t nColumns, size_t nRows, const DataType &constValue,
357  services::Status *stat = NULL)
358  {
359  return create(featuresEqual, services::SharedPtr<DataType>(ptr, services::EmptyDeleter()), nColumns, nRows, constValue, stat);
360  }
361 
371  HomogenNumericTable( DictionaryIface::FeaturesEqual featuresEqual, const services::SharedPtr<DataType> &ptr, size_t nColumns, size_t nRows, const DataType &constValue ):
372  NumericTable( nColumns, nRows, featuresEqual )
373  {
374  _layout = aos;
375  this->_status |= setArray( ptr, nRows );
376 
377  NumericTableFeature df;
378  df.setType<DataType>();
379  this->_status |= _ddict->setAllFeatures(df);
380  this->_status |= assign<DataType>(constValue);
381  }
382 
393  static services::SharedPtr<HomogenNumericTable<DataType> > create(DictionaryIface::FeaturesEqual featuresEqual,
394  const services::SharedPtr<DataType> &ptr,
395  size_t nColumns, size_t nRows, const DataType &constValue,
396  services::Status *stat = NULL)
397  {
398  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(HomogenNumericTable, DataType, featuresEqual, ptr, nColumns, nRows, constValue);
399  }
400 
408  HomogenNumericTable( size_t nColumns, size_t nRows, AllocationFlag memoryAllocationFlag ):
409  NumericTable( nColumns, nRows )
410  {
411  _layout = aos;
412 
413  NumericTableFeature df;
414  df.setType<DataType>();
415  this->_status |= _ddict->setAllFeatures(df);
416 
417  if( memoryAllocationFlag == doAllocate ) this->_status |= allocateDataMemoryImpl();
418  }
419 
428  static services::SharedPtr<HomogenNumericTable<DataType> > create(size_t nColumns, size_t nRows, AllocationFlag memoryAllocationFlag,
429  services::Status *stat = NULL)
430  {
431  return create(DictionaryIface::notEqual, nColumns, nRows, memoryAllocationFlag, stat);
432  }
433 
442  HomogenNumericTable( DictionaryIface::FeaturesEqual featuresEqual, size_t nColumns, size_t nRows, AllocationFlag memoryAllocationFlag ):
443  NumericTable( nColumns, nRows, featuresEqual )
444  {
445  _layout = aos;
446 
447  NumericTableFeature df;
448  df.setType<DataType>();
449  this->_status |= _ddict->setAllFeatures(df);
450 
451  if( memoryAllocationFlag == doAllocate ) this->_status |= allocateDataMemoryImpl();
452  }
453 
463  static services::SharedPtr<HomogenNumericTable<DataType> > create(DictionaryIface::FeaturesEqual featuresEqual,
464  size_t nColumns, size_t nRows, AllocationFlag memoryAllocationFlag,
465  services::Status *stat = NULL)
466  {
467  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(HomogenNumericTable, DataType, featuresEqual, nColumns, nRows, memoryAllocationFlag);
468  }
469 
478  HomogenNumericTable( size_t nColumns, size_t nRows, NumericTable::AllocationFlag memoryAllocationFlag,
479  const DataType &constValue ):
480  NumericTable( nColumns, nRows )
481  {
482  _layout = aos;
483 
484  NumericTableFeature df;
485  df.setType<DataType>();
486 
487  this->_status |= _ddict->setAllFeatures(df);
488 
489  if( memoryAllocationFlag == doAllocate ) this->_status |= allocateDataMemoryImpl();
490 
491  this->_status |= assign<DataType>(constValue);
492  }
493 
503  static services::SharedPtr<HomogenNumericTable<DataType> > create(size_t nColumns, size_t nRows, AllocationFlag memoryAllocationFlag,
504  const DataType &constValue, services::Status *stat = NULL)
505  {
506  return create(DictionaryIface::notEqual, nColumns, nRows, memoryAllocationFlag, constValue, stat);
507  }
508 
518  HomogenNumericTable( DictionaryIface::FeaturesEqual featuresEqual, size_t nColumns, size_t nRows, NumericTable::AllocationFlag memoryAllocationFlag,
519  const DataType &constValue ):
520  NumericTable( nColumns, nRows, featuresEqual )
521  {
522  _layout = aos;
523 
524  NumericTableFeature df;
525  df.setType<DataType>();
526 
527  this->_status |= _ddict->setAllFeatures(df);
528 
529  if( memoryAllocationFlag == doAllocate ) { this->_status |= allocateDataMemoryImpl(); }
530 
531  this->_status |= assign<DataType>(constValue);
532  }
533 
544  static services::SharedPtr<HomogenNumericTable<DataType> > create(DictionaryIface::FeaturesEqual featuresEqual,
545  size_t nColumns, size_t nRows, AllocationFlag memoryAllocationFlag,
546  const DataType &constValue, services::Status *stat = NULL)
547  {
548  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(HomogenNumericTable, DataType, featuresEqual, nColumns, nRows, memoryAllocationFlag, constValue);
549  }
550 
551  virtual ~HomogenNumericTable()
552  {
553  freeDataMemoryImpl();
554  }
555 
560  DataType *getArray() const
561  {
562  return (DataType*)_ptr.get();
563  }
564 
569  services::SharedPtr<DataType> getArraySharedPtr() const
570  {
571  return services::reinterpretPointerCast<DataType, byte>(_ptr);
572  }
573 
579  DAAL_DEPRECATED services::Status setArray( DataType *const ptr )
580  {
581  freeDataMemoryImpl();
582 
583  _ptr = services::SharedPtr<byte>((byte*)ptr, services::EmptyDeleter());
584 
585  if(_ptr)
586  {
587  _memStatus = userAllocated;
588  }
589  else
590  {
591  _memStatus = notAllocated;
592  }
593  return services::Status();
594  }
595 
601  DAAL_DEPRECATED services::Status setArray( const services::SharedPtr<DataType> &ptr )
602  {
603  freeDataMemoryImpl();
604 
605  _ptr = services::reinterpretPointerCast<byte, DataType>(ptr);
606 
607  if(_ptr)
608  {
609  _memStatus = userAllocated;
610  }
611  else
612  {
613  _memStatus = notAllocated;
614  }
615  return services::Status();
616  }
617 
623  services::Status setArray( DataType *const ptr, size_t nRows )
624  {
625  freeDataMemoryImpl();
626 
627  _ptr = services::SharedPtr<byte>((byte*)ptr, services::EmptyDeleter());
628  _obsnum = nRows;
629 
630  if(_ptr)
631  {
632  _memStatus = userAllocated;
633  }
634  else
635  {
636  _memStatus = notAllocated;
637  }
638  return services::Status();
639  }
640 
646  services::Status setArray( services::SharedPtr<DataType> ptr, size_t nRows )
647  {
648  freeDataMemoryImpl();
649 
650  _ptr = services::reinterpretPointerCast<byte, DataType>(ptr);
651  _obsnum = nRows;
652 
653  if(_ptr)
654  {
655  _memStatus = userAllocated;
656  }
657  else
658  {
659  _memStatus = notAllocated;
660  }
661  return services::Status();
662  }
663 
668  template <typename T>
669  services::Status assign(T value)
670  {
671  if( _memStatus == notAllocated )
672  return services::Status(services::ErrorEmptyHomogenNumericTable);
673 
674  size_t nColumns = getNumberOfColumns();
675  size_t nRows = getNumberOfRows();
676 
677  DataType *ptr = (DataType*)_ptr.get();
678  DataType valueDataType = (DataType)value;
679 
680  internal::vectorAssignValueToArray<DataType>(ptr, nColumns*nRows, 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 (!(0 == getNumberOfColumns()) && !(0 == getNumberOfRows()))
841  {
842  DAAL_CHECK((getNumberOfColumns() == size / getNumberOfRows()),
843  services::throwIfPossible(services::Status(services::ErrorBufferSizeIntegerOverflow)));
844 
845  size_t sizeEx = size * sizeof(DataType);
846  DAAL_CHECK((size == sizeEx / sizeof(DataType)),
847  services::throwIfPossible(services::Status(services::ErrorBufferSizeIntegerOverflow)));
848  }
849 
850  if( size == 0 )
851  {
852  return services::Status(getNumberOfColumns() == 0 ? services::ErrorIncorrectNumberOfFeatures :
853  services::ErrorIncorrectNumberOfObservations);
854  }
855 
856  _ptr = services::SharedPtr<byte>((byte *)daal::services::daal_malloc(size * sizeof(DataType)), services::ServiceDeleter());
857 
858  if(!_ptr)
859  return services::Status(services::ErrorMemoryAllocationFailed);
860 
861  _memStatus = internallyAllocated;
862  return services::Status();
863  }
864 
865  void freeDataMemoryImpl() DAAL_C11_OVERRIDE
866  {
867  _ptr = services::SharedPtr<byte>();
868  _memStatus = notAllocated;
869  }
870 
871  template<typename Archive, bool onDeserialize>
872  services::Status serialImpl( Archive *archive )
873  {
874  NumericTable::serialImpl<Archive, onDeserialize>( archive );
875 
876  if( onDeserialize )
877  {
878  allocateDataMemoryImpl();
879  }
880 
881  size_t size = getNumberOfColumns() * getNumberOfRows();
882 
883  archive->set( (DataType*)_ptr.get(), size );
884 
885  return services::Status();
886  }
887 
888 private:
889  byte *internal_getBlockOfRows( size_t idx )
890  {
891  size_t _featnum = _ddict->getNumberOfFeatures();
892  return _ptr.get() + _featnum * idx * sizeof(DataType);
893  }
894 
895  byte *internal_getBlockOfRows( size_t idx, size_t feat_idx )
896  {
897  size_t _featnum = _ddict->getNumberOfFeatures();
898  return _ptr.get() + _featnum * idx * sizeof(DataType) + feat_idx * sizeof(DataType);
899  }
900 
901 protected:
902 
903  template <typename T>
904  services::Status getTBlock( size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T> &block )
905  {
906  size_t ncols = getNumberOfColumns();
907  size_t nobs = getNumberOfRows();
908  block.setDetails( 0, idx, rwFlag );
909 
910  if (idx >= nobs)
911  {
912  block.resizeBuffer( ncols, 0 );
913  return services::Status();
914  }
915 
916  nrows = ( idx + nrows < nobs ) ? nrows : nobs - idx;
917 
918  if( IsSameType<T, DataType>::value )
919  {
920  block.setPtr(&_ptr, internal_getBlockOfRows(idx) , ncols, nrows );
921  }
922  else
923  {
924  if( !block.resizeBuffer( ncols, nrows ) )
925  return services::Status(services::ErrorMemoryAllocationFailed);
926 
927  if( rwFlag & (int)readOnly )
928  {
929  byte *location = internal_getBlockOfRows(idx);
930 
931  for(size_t i = 0; i < nrows; i++)
932  {
933  internal::getVectorUpCast(features::internal::getIndexNumType<DataType>(), internal::getConversionDataType<T>())
934  ( ncols, ((DataType*)location) + i * ncols, ((T*)block.getBlockPtr()) + i * ncols );
935  }
936  }
937  }
938  return services::Status();
939  }
940 
941  template <typename T>
942  services::Status releaseTBlock( BlockDescriptor<T> &block )
943  {
944  if(block.getRWFlag() & (int)writeOnly)
945  {
946  byte *location = internal_getBlockOfRows( block.getRowsOffset() );
947  size_t ncols = getNumberOfColumns();
948  size_t nrows = block.getNumberOfRows();
949 
950  if( IsSameType<T, DataType>::value )
951  {
952  if( (T*)block.getBlockPtr() != (T *)location )
953  {
954  int result = daal::services::internal::daal_memcpy_s(location, nrows * ncols * sizeof(T),
955  block.getBlockPtr(), nrows * ncols * sizeof(T));
956  DAAL_CHECK(!result, services::ErrorMemoryCopyFailedInternal);
957  }
958  }
959  else
960  {
961  for(size_t i = 0; i < nrows; i++)
962  {
963  internal::getVectorDownCast(features::internal::getIndexNumType<DataType>(), internal::getConversionDataType<T>())
964  ( ncols, ((T*)block.getBlockPtr()) + i * ncols, ((DataType*)location) + i * ncols );
965  }
966  }
967  }
968  block.reset();
969  return services::Status();
970  }
971 
972  template <typename T>
973  services::Status getTFeature(size_t feat_idx, size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T> &block)
974  {
975  size_t ncols = getNumberOfColumns();
976  size_t nobs = getNumberOfRows();
977  block.setDetails( feat_idx, idx, rwFlag );
978 
979  if (idx >= nobs)
980  {
981  block.resizeBuffer( 1, 0 );
982  return services::Status();
983  }
984 
985  nrows = ( idx + nrows < nobs ) ? nrows : nobs - idx;
986 
987  if( ( IsSameType<T, DataType>::value ) && (ncols == 1) )
988  {
989  block.setPtr(&_ptr, internal_getBlockOfRows(idx) , ncols, nrows );
990  }
991  else
992  {
993  if( !block.resizeBuffer( 1, nrows ) )
994  return services::Status(services::ErrorMemoryAllocationFailed);
995 
996  if( rwFlag & (int)readOnly )
997  {
998  DataType *location = (DataType *)internal_getBlockOfRows(idx, feat_idx);
999  T *buffer = block.getBlockPtr();
1000  internal::getVectorStrideUpCast(features::internal::getIndexNumType<DataType>(), internal::getConversionDataType<T>())
1001  ( nrows, location, sizeof(DataType)*ncols, buffer, sizeof(T) );
1002  }
1003  }
1004  return services::Status();
1005  }
1006 
1007  template <typename T>
1008  services::Status releaseTFeature( BlockDescriptor<T> &block )
1009  {
1010  if (block.getRWFlag() & (int)writeOnly)
1011  {
1012  size_t ncols = getNumberOfColumns();
1013  DataType *location = (DataType *)internal_getBlockOfRows(block.getRowsOffset(), block.getColumnsOffset());
1014  internal::getVectorStrideDownCast(features::internal::getIndexNumType<DataType>(), internal::getConversionDataType<T>())
1015  ( block.getNumberOfRows(), block.getBlockPtr(), sizeof(T), location, ncols * sizeof(DataType) );
1016  }
1017  block.reset();
1018  return services::Status();
1019  }
1020 
1021  services::Status setNumberOfColumnsImpl(size_t ncol) DAAL_C11_OVERRIDE
1022  {
1023  if( _ddict->getNumberOfFeatures() != ncol )
1024  {
1025  _ddict->resetDictionary();
1026  _ddict->setNumberOfFeatures(ncol);
1027 
1028  NumericTableFeature df;
1029  df.setType<DataType>();
1030  _ddict->setAllFeatures(df);
1031  }
1032  return services::Status();
1033  }
1034 
1035 };
1037 } // namespace interface1
1038 using interface1::HomogenNumericTable;
1039 
1040 }
1041 } // namespace daal
1042 #endif
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::HomogenNumericTable
HomogenNumericTable(DataType *const ptr, size_t nColumns=0, size_t nRows=0)
Definition: homogen_numeric_table.h:125
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::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: homogen_numeric_table.h:753
daal::data_management::interface1::HomogenNumericTable::HomogenNumericTable
HomogenNumericTable(NumericTableDictionaryPtr ddictForHomogenNumericTable)
Definition: homogen_numeric_table.h:83
daal::algorithms::multivariate_outlier_detection::location
Definition: outlier_detection_multivariate_types.h:74
daal::services::ErrorIncorrectNumberOfObservations
Definition: error_indexes.h:73
daal::data_management::interface1::HomogenNumericTable::HomogenNumericTable
HomogenNumericTable(size_t nColumns, size_t nRows, NumericTable::AllocationFlag memoryAllocationFlag, const DataType &constValue)
Definition: homogen_numeric_table.h:478
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:393
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::data_management::interface1::HomogenNumericTable::HomogenNumericTable
HomogenNumericTable(DataType *const ptr, size_t nColumns, size_t nRows, const DataType &constValue)
Definition: homogen_numeric_table.h:262
daal::data_management::interface1::HomogenNumericTable::HomogenNumericTable
HomogenNumericTable(size_t nColumns, size_t nRows, AllocationFlag memoryAllocationFlag)
Definition: homogen_numeric_table.h:408
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::Dictionary
Class that represents a dictionary of a data set and provides methods to work with the data dictionar...
Definition: data_dictionary.h:163
daal::data_management::interface1::NumericTable
Class for a data management component responsible for representation of data in the numeric format...
Definition: numeric_table.h:577
daal::data_management::interface1::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::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:355
daal::data_management::interface1::HomogenNumericTable::getArraySharedPtr
services::SharedPtr< DataType > getArraySharedPtr() const
Definition: homogen_numeric_table.h:569
daal::data_management::interface1::HomogenNumericTable::baseDataType
DataType baseDataType
Definition: homogen_numeric_table.h:64
daal::data_management::interface1::HomogenNumericTable::HomogenNumericTable
HomogenNumericTable(DictionaryIface::FeaturesEqual featuresEqual, size_t nColumns, size_t nRows, AllocationFlag memoryAllocationFlag)
Definition: homogen_numeric_table.h:442
daal::data_management::interface1::HomogenNumericTable::setArray
services::Status setArray(DataType *const ptr, size_t nRows)
Definition: homogen_numeric_table.h:623
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::NumericTableFeature::setType
void setType()
Definition: data_dictionary.h:96
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:227
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:544
daal::data_management::interface1::HomogenNumericTable::setArray
DAAL_DEPRECATED services::Status setArray(const services::SharedPtr< DataType > &ptr)
Definition: homogen_numeric_table.h:601
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::create
static services::SharedPtr< HomogenNumericTable< DataType > > create(size_t nColumns, size_t nRows, AllocationFlag memoryAllocationFlag, services::Status *stat=NULL)
Definition: homogen_numeric_table.h:428
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:247
daal::services::ErrorBufferSizeIntegerOverflow
Definition: error_indexes.h:145
daal::data_management::interface1::HomogenNumericTable::create
static services::SharedPtr< HomogenNumericTable< DataType > > create(NumericTableDictionaryPtr ddictForHomogenNumericTable, services::Status *stat=NULL)
Definition: homogen_numeric_table.h:95
daal::MemType
MemType
Definition: daal_defines.h:147
daal::data_management::interface1::HomogenNumericTable::getArray
DataType * getArray() const
Definition: homogen_numeric_table.h:560
daal::data_management::interface1::HomogenNumericTable::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: homogen_numeric_table.h:757
daal_defines.h
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:463
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:318
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:144
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:371
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(DataType *const ptr, size_t nColumns, size_t nRows, const DataType &constValue, services::Status *stat=NULL)
Definition: homogen_numeric_table.h:283
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:54
daal::services::daal_memcpy_s
DAAL_DEPRECATED 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(const services::SharedPtr< DataType > &ptr, size_t nColumns, size_t nRows, services::Status *stat=NULL)
Definition: homogen_numeric_table.h:177
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::HomogenNumericTable
HomogenNumericTable(const services::SharedPtr< DataType > &ptr, size_t nColumns, size_t nRows)
Definition: homogen_numeric_table.h:158
daal::data_management::interface1::NumericTableIface::AllocationFlag
AllocationFlag
Enumeration to specify whether the Numeric Table must allocate memory.
Definition: numeric_table.h:285
daal::data_management::interface1::HomogenNumericTable::create
static services::SharedPtr< HomogenNumericTable< DataType > > create(services::Status *stat=NULL)
Definition: homogen_numeric_table.h:113
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:212
daal::data_management::interface1::HomogenNumericTable::setArray
DAAL_DEPRECATED services::Status setArray(DataType *const ptr)
Definition: homogen_numeric_table.h:579
daal::dram
Definition: daal_defines.h:149
daal::services::daal_malloc
DAAL_EXPORT void * daal_malloc(size_t size, size_t alignment=DAAL_MALLOC_DEFAULT_ALIGNMENT)
daal::data_management::interface1::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:503
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:518
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::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: homogen_numeric_table.h:724
daal::data_management::interface1::BlockDescriptor
Base class that manages buffer memory for read/write operations required by numeric tables...
Definition: numeric_table.h:57
daal::data_management::interface1::HomogenNumericTable::assign
virtual services::Status assign(double value) DAAL_C11_OVERRIDE
Definition: homogen_numeric_table.h:704
daal::services::ErrorMemoryAllocationFailed
Definition: error_indexes.h:150
daal::services::ErrorIncorrectNumberOfFeatures
Definition: error_indexes.h:72
daal::services::ErrorMemoryCopyFailedInternal
Definition: error_indexes.h:152
daal::data_management::interface1::NumericTableFeature
Data structure describes the Numeric Table feature.
Definition: data_dictionary.h:53
daal::data_management::interface1::HomogenNumericTable::operator[]
DataType * operator[](size_t i)
Definition: homogen_numeric_table.h:690
daal::data_management::interface1::HomogenNumericTable::setArray
services::Status setArray(services::SharedPtr< DataType > ptr, size_t nRows)
Definition: homogen_numeric_table.h:646
daal::data_management::interface1::HomogenNumericTable::HomogenNumericTable
HomogenNumericTable()
Definition: homogen_numeric_table.h:104
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:192
daal::algorithms::math::abs::value
Definition: abs_types.h:88
daal::data_management::interface1::HomogenNumericTable::assign
virtual services::Status assign(int value) DAAL_C11_OVERRIDE
Definition: homogen_numeric_table.h:709
daal::data_management::interface1::HomogenNumericTable::assign
services::Status assign(T value)
Definition: homogen_numeric_table.h:669
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:297
daal::services::ErrorEmptyHomogenNumericTable
Definition: error_indexes.h:166
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:333

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