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

homogen_numeric_table.h
1 /* file: homogen_numeric_table.h */
2 /*******************************************************************************
3 * Copyright 2014-2017 Intel Corporation
4 * All Rights Reserved.
5 *
6 * If this software was obtained under the Intel Simplified Software License,
7 * the following terms apply:
8 *
9 * The source code, information and material ("Material") contained herein is
10 * owned by Intel Corporation or its suppliers or licensors, and title to such
11 * Material remains with Intel Corporation or its suppliers or licensors. The
12 * Material contains proprietary information of Intel or its suppliers and
13 * licensors. The Material is protected by worldwide copyright laws and treaty
14 * provisions. No part of the Material may be used, copied, reproduced,
15 * modified, published, uploaded, posted, transmitted, distributed or disclosed
16 * in any way without Intel's prior express written permission. No license under
17 * any patent, copyright or other intellectual property rights in the Material
18 * is granted to or conferred upon you, either expressly, by implication,
19 * inducement, estoppel or otherwise. Any license under such intellectual
20 * property rights must be express and approved by Intel in writing.
21 *
22 * Unless otherwise agreed by Intel in writing, you may not remove or alter this
23 * notice or any other notice embedded in Materials by Intel or Intel's
24 * suppliers or licensors in any way.
25 *
26 *
27 * If this software was obtained under the Apache License, Version 2.0 (the
28 * "License"), the following terms apply:
29 *
30 * You may not use this file except in compliance with the License. You may
31 * obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
32 *
33 *
34 * Unless required by applicable law or agreed to in writing, software
35 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
36 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
37 *
38 * See the License for the specific language governing permissions and
39 * limitations under the License.
40 *******************************************************************************/
41 
42 /*
43 //++
44 // Implementation of a homogeneous numeric table.
45 //--
46 */
47 
48 
49 #ifndef __HOMOGEN_NUMERIC_TABLE_H__
50 #define __HOMOGEN_NUMERIC_TABLE_H__
51 
52 #include "data_management/data/numeric_table.h"
53 #include "services/daal_memory.h"
54 #include "services/daal_defines.h"
55 #include "data_management/data/data_serialize.h"
56 
57 namespace daal
58 {
59 namespace data_management
60 {
61 
62 namespace interface1
63 {
75 template<typename DataType = DAAL_DATA_TYPE>
76 class DAAL_EXPORT HomogenNumericTable : public NumericTable
77 {
78 public:
79  DECLARE_SERIALIZABLE_TAG();
80  DECLARE_SERIALIZABLE_IMPL();
81 
82  DAAL_CAST_OPERATOR(HomogenNumericTable)
86  typedef DataType baseDataType;
87 
88 public:
94  DAAL_DEPRECATED HomogenNumericTable( NumericTableDictionary *ddict ):
95  NumericTable(ddict)
96  {
97  _layout = aos;
98  }
99 
105  HomogenNumericTable( NumericTableDictionaryPtr ddictForHomogenNumericTable ):
106  NumericTable(ddictForHomogenNumericTable)
107  {
108  _layout = aos;
109  }
110 
117  static services::SharedPtr<HomogenNumericTable<DataType> > create(NumericTableDictionaryPtr ddictForHomogenNumericTable, services::Status *stat = NULL)
118  {
119  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(HomogenNumericTable, DataType, ddictForHomogenNumericTable);
120  }
121 
126  HomogenNumericTable():
127  NumericTable(0, 0)
128  {}
129 
135  static services::SharedPtr<HomogenNumericTable<DataType> > create(services::Status *stat = NULL)
136  {
137  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL(HomogenNumericTable, DataType);
138  }
139 
147  HomogenNumericTable( DataType *const ptr, size_t nColumns = 0, size_t nRows = 0 ):
148  NumericTable( nColumns, nRows )
149  {
150  _layout = aos;
151  this->_status |= setArray( ptr, nRows );
152 
153  NumericTableFeature df;
154  df.setType<DataType>();
155  this->_status |= _ddict->setAllFeatures(df);
156  }
157 
166  static services::SharedPtr<HomogenNumericTable<DataType> > create(DataType *const ptr,
167  size_t nColumns = 0, size_t nRows = 0,
168  services::Status *stat = NULL)
169  {
170  return create(services::SharedPtr<DataType>(ptr, services::EmptyDeleter()), nColumns, nRows, stat);
171  }
172 
180  HomogenNumericTable( const services::SharedPtr<DataType> &ptr, size_t nColumns, size_t nRows ):
181  NumericTable( nColumns, nRows )
182  {
183  _layout = aos;
184  this->_status |= setArray( ptr, nRows );
185 
186  NumericTableFeature df;
187  df.setType<DataType>();
188  this->_status |= _ddict->setAllFeatures(df);
189  }
190 
199  static services::SharedPtr<HomogenNumericTable<DataType> > create(const services::SharedPtr<DataType> &ptr,
200  size_t nColumns, size_t nRows,
201  services::Status *stat = NULL)
202  {
203  return create(DictionaryIface::notEqual, ptr, nColumns, nRows, stat);
204  }
205 
214  HomogenNumericTable( DictionaryIface::FeaturesEqual featuresEqual, DataType *const ptr = 0, size_t nColumns = 0, size_t nRows = 0):
215  NumericTable( nColumns, nRows, featuresEqual )
216  {
217  _layout = aos;
218  this->_status |= setArray( ptr, nRows );
219 
220  NumericTableFeature df;
221  df.setType<DataType>();
222  this->_status |= _ddict->setAllFeatures(df);
223  }
224 
234  static services::SharedPtr<HomogenNumericTable<DataType> > create(DictionaryIface::FeaturesEqual featuresEqual,
235  DataType *const ptr = 0, size_t nColumns = 0, size_t nRows = 0,
236  services::Status *stat = NULL)
237  {
238  return create(featuresEqual, services::SharedPtr<DataType>(ptr, services::EmptyDeleter()), nColumns, nRows, stat);
239  }
240 
249  HomogenNumericTable( DictionaryIface::FeaturesEqual featuresEqual, const services::SharedPtr<DataType> &ptr, size_t nColumns, size_t nRows ):
250  NumericTable( nColumns, nRows, featuresEqual )
251  {
252  _layout = aos;
253  this->_status |= setArray( ptr, nRows );
254 
255  NumericTableFeature df;
256  df.setType<DataType>();
257  this->_status |= _ddict->setAllFeatures(df);
258  }
259 
269  static services::SharedPtr<HomogenNumericTable<DataType> > create(DictionaryIface::FeaturesEqual featuresEqual,
270  const services::SharedPtr<DataType> &ptr,
271  size_t nColumns, size_t nRows, services::Status *stat = NULL)
272  {
273  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(HomogenNumericTable, DataType, featuresEqual, ptr, nColumns, nRows);
274  }
275 
284  HomogenNumericTable( DataType *const ptr, size_t nColumns, size_t nRows, const DataType &constValue ):
285  NumericTable( nColumns, nRows )
286  {
287  _layout = aos;
288  this->_status |= setArray( ptr, nRows );
289 
290  NumericTableFeature df;
291  df.setType<DataType>();
292  this->_status |= _ddict->setAllFeatures(df);
293  this->_status |= assign<DataType>(constValue);
294  }
295 
305  static services::SharedPtr<HomogenNumericTable<DataType> > create(DataType *const ptr, size_t nColumns, size_t nRows, const DataType &constValue,
306  services::Status *stat = NULL)
307  {
308  return create(services::SharedPtr<DataType>(ptr, services::EmptyDeleter()), nColumns, nRows, constValue, stat);
309  }
310 
319  HomogenNumericTable(const services::SharedPtr<DataType> &ptr, size_t nColumns, size_t nRows, const DataType &constValue ):
320  NumericTable( nColumns, nRows )
321  {
322  _layout = aos;
323  this->_status |= setArray( ptr, nRows );
324 
325  NumericTableFeature df;
326  df.setType<DataType>();
327  this->_status |= _ddict->setAllFeatures(df);
328  this->_status |= assign<DataType>(constValue);
329  }
330 
340  static services::SharedPtr<HomogenNumericTable<DataType> > create(const services::SharedPtr<DataType> &ptr, size_t nColumns, size_t nRows,
341  const DataType &constValue, services::Status *stat = NULL)
342  {
343  return create(DictionaryIface::notEqual, ptr, nColumns, nRows, constValue, stat);
344  }
345 
355  HomogenNumericTable( DictionaryIface::FeaturesEqual featuresEqual, DataType *const ptr, size_t nColumns, size_t nRows, const DataType &constValue ):
356  NumericTable( nColumns, nRows, featuresEqual )
357  {
358  _layout = aos;
359  this->_status |= setArray( ptr, nRows );
360 
361  NumericTableFeature df;
362  df.setType<DataType>();
363  this->_status |= _ddict->setAllFeatures(df);
364  this->_status |= assign<DataType>(constValue);
365  }
366 
377  static services::SharedPtr<HomogenNumericTable<DataType> > create(DictionaryIface::FeaturesEqual featuresEqual, DataType *const ptr,
378  size_t nColumns, size_t nRows, const DataType &constValue,
379  services::Status *stat = NULL)
380  {
381  return create(featuresEqual, services::SharedPtr<DataType>(ptr, services::EmptyDeleter()), nColumns, nRows, constValue, stat);
382  }
383 
393  HomogenNumericTable( DictionaryIface::FeaturesEqual featuresEqual, const services::SharedPtr<DataType> &ptr, size_t nColumns, size_t nRows, const DataType &constValue ):
394  NumericTable( nColumns, nRows, featuresEqual )
395  {
396  _layout = aos;
397  this->_status |= setArray( ptr, nRows );
398 
399  NumericTableFeature df;
400  df.setType<DataType>();
401  this->_status |= _ddict->setAllFeatures(df);
402  this->_status |= assign<DataType>(constValue);
403  }
404 
415  static services::SharedPtr<HomogenNumericTable<DataType> > create(DictionaryIface::FeaturesEqual featuresEqual,
416  const services::SharedPtr<DataType> &ptr,
417  size_t nColumns, size_t nRows, const DataType &constValue,
418  services::Status *stat = NULL)
419  {
420  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(HomogenNumericTable, DataType, featuresEqual, ptr, nColumns, nRows, constValue);
421  }
422 
430  HomogenNumericTable( size_t nColumns, size_t nRows, AllocationFlag memoryAllocationFlag ):
431  NumericTable( nColumns, nRows )
432  {
433  _layout = aos;
434 
435  NumericTableFeature df;
436  df.setType<DataType>();
437  this->_status |= _ddict->setAllFeatures(df);
438 
439  if( memoryAllocationFlag == doAllocate ) this->_status |= allocateDataMemoryImpl();
440  }
441 
450  static services::SharedPtr<HomogenNumericTable<DataType> > create(size_t nColumns, size_t nRows, AllocationFlag memoryAllocationFlag,
451  services::Status *stat = NULL)
452  {
453  return create(DictionaryIface::notEqual, nColumns, nRows, memoryAllocationFlag, stat);
454  }
455 
464  HomogenNumericTable( DictionaryIface::FeaturesEqual featuresEqual, size_t nColumns, size_t nRows, AllocationFlag memoryAllocationFlag ):
465  NumericTable( nColumns, nRows, featuresEqual )
466  {
467  _layout = aos;
468 
469  NumericTableFeature df;
470  df.setType<DataType>();
471  this->_status |= _ddict->setAllFeatures(df);
472 
473  if( memoryAllocationFlag == doAllocate ) this->_status |= allocateDataMemoryImpl();
474  }
475 
485  static services::SharedPtr<HomogenNumericTable<DataType> > create(DictionaryIface::FeaturesEqual featuresEqual,
486  size_t nColumns, size_t nRows, AllocationFlag memoryAllocationFlag,
487  services::Status *stat = NULL)
488  {
489  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(HomogenNumericTable, DataType, featuresEqual, nColumns, nRows, memoryAllocationFlag);
490  }
491 
500  HomogenNumericTable( size_t nColumns, size_t nRows, NumericTable::AllocationFlag memoryAllocationFlag,
501  const DataType &constValue ):
502  NumericTable( nColumns, nRows )
503  {
504  _layout = aos;
505 
506  NumericTableFeature df;
507  df.setType<DataType>();
508 
509  this->_status |= _ddict->setAllFeatures(df);
510 
511  if( memoryAllocationFlag == doAllocate ) this->_status |= allocateDataMemoryImpl();
512 
513  this->_status |= assign<DataType>(constValue);
514  }
515 
525  static services::SharedPtr<HomogenNumericTable<DataType> > create(size_t nColumns, size_t nRows, AllocationFlag memoryAllocationFlag,
526  const DataType &constValue, services::Status *stat = NULL)
527  {
528  return create(DictionaryIface::notEqual, nColumns, nRows, memoryAllocationFlag, constValue, stat);
529  }
530 
540  HomogenNumericTable( DictionaryIface::FeaturesEqual featuresEqual, size_t nColumns, size_t nRows, NumericTable::AllocationFlag memoryAllocationFlag,
541  const DataType &constValue ):
542  NumericTable( nColumns, nRows, featuresEqual )
543  {
544  _layout = aos;
545 
546  NumericTableFeature df;
547  df.setType<DataType>();
548 
549  this->_status |= _ddict->setAllFeatures(df);
550 
551  if( memoryAllocationFlag == doAllocate ) { this->_status |= allocateDataMemoryImpl(); }
552 
553  this->_status |= assign<DataType>(constValue);
554  }
555 
566  static services::SharedPtr<HomogenNumericTable<DataType> > create(DictionaryIface::FeaturesEqual featuresEqual,
567  size_t nColumns, size_t nRows, AllocationFlag memoryAllocationFlag,
568  const DataType &constValue, services::Status *stat = NULL)
569  {
570  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(HomogenNumericTable, DataType, featuresEqual, nColumns, nRows, memoryAllocationFlag, constValue);
571  }
572 
573  virtual ~HomogenNumericTable()
574  {
575  freeDataMemoryImpl();
576  }
577 
582  DataType *getArray() const
583  {
584  return (DataType*)_ptr.get();
585  }
586 
591  services::SharedPtr<DataType> getArraySharedPtr() const
592  {
593  return services::reinterpretPointerCast<DataType, byte>(_ptr);
594  }
595 
601  DAAL_DEPRECATED services::Status setArray( DataType *const ptr )
602  {
603  freeDataMemoryImpl();
604 
605  _ptr = services::SharedPtr<byte>((byte*)ptr, services::EmptyDeleter());
606 
607  if(_ptr)
608  {
609  _memStatus = userAllocated;
610  }
611  else
612  {
613  _memStatus = notAllocated;
614  }
615  return services::Status();
616  }
617 
623  DAAL_DEPRECATED services::Status setArray( const services::SharedPtr<DataType> &ptr )
624  {
625  freeDataMemoryImpl();
626 
627  _ptr = services::reinterpretPointerCast<byte, DataType>(ptr);
628 
629  if(_ptr)
630  {
631  _memStatus = userAllocated;
632  }
633  else
634  {
635  _memStatus = notAllocated;
636  }
637  return services::Status();
638  }
639 
645  services::Status setArray( DataType *const ptr, size_t nRows )
646  {
647  freeDataMemoryImpl();
648 
649  _ptr = services::SharedPtr<byte>((byte*)ptr, services::EmptyDeleter());
650  _obsnum = nRows;
651 
652  if(_ptr)
653  {
654  _memStatus = userAllocated;
655  }
656  else
657  {
658  _memStatus = notAllocated;
659  }
660  return services::Status();
661  }
662 
668  services::Status setArray( services::SharedPtr<DataType> ptr, size_t nRows )
669  {
670  freeDataMemoryImpl();
671 
672  _ptr = services::reinterpretPointerCast<byte, DataType>(ptr);
673  _obsnum = nRows;
674 
675  if(_ptr)
676  {
677  _memStatus = userAllocated;
678  }
679  else
680  {
681  _memStatus = notAllocated;
682  }
683  return services::Status();
684  }
685 
690  template <typename T>
691  services::Status assign(T value)
692  {
693  if( _memStatus == notAllocated )
694  return services::Status(services::ErrorEmptyHomogenNumericTable);
695 
696  size_t nColumns = getNumberOfColumns();
697  size_t nRows = getNumberOfRows();
698 
699  size_t i;
700  DataType *ptr = (DataType*)_ptr.get();
701  DataType valueDataType = (DataType)value;
702  for( i = 0; i < nColumns * nRows; i++ )
703  {
704  ptr[i] = valueDataType;
705  }
706  return services::Status();
707  }
708 
714  DataType *operator[](size_t i)
715  {
716  size_t nColumns = getNumberOfColumns();
717  return (DataType*)_ptr.get() + i * nColumns;
718  }
719 
723  virtual services::Status assign(float value) DAAL_C11_OVERRIDE {return assign<DataType>((DataType)value);}
724 
728  virtual services::Status assign(double value) DAAL_C11_OVERRIDE {return assign<DataType>((DataType)value);}
729 
733  virtual services::Status assign(int value) DAAL_C11_OVERRIDE {return assign<DataType>((DataType)value);}
734 
735  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
736  {
737  return getTBlock<double>(vector_idx, vector_num, rwflag, block);
738  }
739  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
740  {
741  return getTBlock<float>(vector_idx, vector_num, rwflag, block);
742  }
743  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
744  {
745  return getTBlock<int>(vector_idx, vector_num, rwflag, block);
746  }
747 
748  services::Status releaseBlockOfRows(BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
749  {
750  return releaseTBlock<double>(block);
751  }
752  services::Status releaseBlockOfRows(BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
753  {
754  return releaseTBlock<float>(block);
755  }
756  services::Status releaseBlockOfRows(BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
757  {
758  return releaseTBlock<int>(block);
759  }
760 
761  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
762  ReadWriteMode rwflag, BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
763  {
764  return getTFeature<double>(feature_idx, vector_idx, value_num, rwflag, block);
765  }
766  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
767  ReadWriteMode rwflag, BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
768  {
769  return getTFeature<float>(feature_idx, vector_idx, value_num, rwflag, block);
770  }
771  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
772  ReadWriteMode rwflag, BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
773  {
774  return getTFeature<int>(feature_idx, vector_idx, value_num, rwflag, block);
775  }
776 
777  services::Status releaseBlockOfColumnValues(BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
778  {
779  return releaseTFeature<double>(block);
780  }
781  services::Status releaseBlockOfColumnValues(BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
782  {
783  return releaseTFeature<float>(block);
784  }
785  services::Status releaseBlockOfColumnValues(BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
786  {
787  return releaseTFeature<int>(block);
788  }
789 
790 protected:
791  services::SharedPtr<byte> _ptr;
792 
793  HomogenNumericTable(services::Status &st):
794  NumericTable(0, 0, DictionaryIface::notEqual, st)
795  {}
796 
797  HomogenNumericTable(NumericTableDictionaryPtr ddictForHomogenNumericTable, services::Status &st):
798  NumericTable(ddictForHomogenNumericTable, st)
799  {
800  _layout = aos;
801  }
802 
803  HomogenNumericTable(DictionaryIface::FeaturesEqual featuresEqual, const services::SharedPtr<DataType> &ptr,
804  size_t nColumns, size_t nRows, services::Status &st):
805  NumericTable(nColumns, nRows, featuresEqual, st)
806  {
807  _layout = aos;
808  st |= setArray( ptr, nRows );
809 
810  NumericTableFeature df;
811  df.setType<DataType>();
812  st |= _ddict->setAllFeatures(df);
813  }
814 
815  HomogenNumericTable(DictionaryIface::FeaturesEqual featuresEqual, const services::SharedPtr<DataType> &ptr,
816  size_t nColumns, size_t nRows, const DataType &constValue, services::Status &st):
817  NumericTable(nColumns, nRows, featuresEqual, st)
818  {
819  _layout = aos;
820  st |= setArray( ptr, nRows );
821 
822  NumericTableFeature df;
823  df.setType<DataType>();
824  st |= _ddict->setAllFeatures(df);
825  st |= assign<DataType>(constValue);
826  }
827 
828  HomogenNumericTable(DictionaryIface::FeaturesEqual featuresEqual,
829  size_t nColumns, size_t nRows, AllocationFlag memoryAllocationFlag, services::Status &st):
830  NumericTable(nColumns, nRows, featuresEqual, st)
831  {
832  _layout = aos;
833 
834  NumericTableFeature df;
835  df.setType<DataType>();
836  st |= _ddict->setAllFeatures(df);
837 
838  if( memoryAllocationFlag == doAllocate ) st |= allocateDataMemoryImpl();
839  }
840 
841  HomogenNumericTable(DictionaryIface::FeaturesEqual featuresEqual, size_t nColumns, size_t nRows,
842  NumericTable::AllocationFlag memoryAllocationFlag,
843  const DataType &constValue, services::Status &st):
844  NumericTable(nColumns, nRows, featuresEqual, st)
845  {
846  _layout = aos;
847 
848  NumericTableFeature df;
849  df.setType<DataType>();
850 
851  st |= _ddict->setAllFeatures(df);
852 
853  if( memoryAllocationFlag == doAllocate ) { st |= allocateDataMemoryImpl(); }
854 
855  st |= assign<DataType>(constValue);
856  }
857 
858  services::Status allocateDataMemoryImpl(daal::MemType type = daal::dram) DAAL_C11_OVERRIDE
859  {
860  freeDataMemoryImpl();
861 
862  size_t size = getNumberOfColumns() * getNumberOfRows();
863 
864  if( size == 0 )
865  {
866  return services::Status(getNumberOfColumns() == 0 ? services::ErrorIncorrectNumberOfFeatures :
867  services::ErrorIncorrectNumberOfObservations);
868  }
869 
870  _ptr = services::SharedPtr<byte>((byte *)daal::services::daal_malloc(size * sizeof(DataType)), services::ServiceDeleter());
871 
872  if(!_ptr)
873  return services::Status(services::ErrorMemoryAllocationFailed);
874 
875  _memStatus = internallyAllocated;
876  return services::Status();
877  }
878 
879  void freeDataMemoryImpl() DAAL_C11_OVERRIDE
880  {
881  _ptr = services::SharedPtr<byte>();
882  _memStatus = notAllocated;
883  }
884 
885  template<typename Archive, bool onDeserialize>
886  services::Status serialImpl( Archive *archive )
887  {
888  NumericTable::serialImpl<Archive, onDeserialize>( archive );
889 
890  if( onDeserialize )
891  {
892  allocateDataMemoryImpl();
893  }
894 
895  size_t size = getNumberOfColumns() * getNumberOfRows();
896 
897  archive->set( (DataType*)_ptr.get(), size );
898 
899  return services::Status();
900  }
901 
902 private:
903  byte *internal_getBlockOfRows( size_t idx )
904  {
905  size_t _featnum = _ddict->getNumberOfFeatures();
906  return _ptr.get() + _featnum * idx * sizeof(DataType);
907  }
908 
909  byte *internal_getBlockOfRows( size_t idx, size_t feat_idx )
910  {
911  size_t _featnum = _ddict->getNumberOfFeatures();
912  return _ptr.get() + _featnum * idx * sizeof(DataType) + feat_idx * sizeof(DataType);
913  }
914 
915 protected:
916 
917  template <typename T>
918  services::Status getTBlock( size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T> &block )
919  {
920  size_t ncols = getNumberOfColumns();
921  size_t nobs = getNumberOfRows();
922  block.setDetails( 0, idx, rwFlag );
923 
924  if (idx >= nobs)
925  {
926  block.resizeBuffer( ncols, 0 );
927  return services::Status();
928  }
929 
930  nrows = ( idx + nrows < nobs ) ? nrows : nobs - idx;
931 
932  if( IsSameType<T, DataType>::value )
933  {
934  block.setPtr(&_ptr, internal_getBlockOfRows(idx) , ncols, nrows );
935  }
936  else
937  {
938  if( !block.resizeBuffer( ncols, nrows ) )
939  return services::Status(services::ErrorMemoryAllocationFailed);
940 
941  if( rwFlag & (int)readOnly )
942  {
943  byte *location = internal_getBlockOfRows(idx);
944 
945  for(size_t i = 0; i < nrows; i++)
946  {
947  data_feature_utils::getVectorUpCast(data_feature_utils::getIndexNumType<DataType>(), data_feature_utils::getInternalNumType<T>())
948  ( ncols, ((DataType*)location) + i * ncols, ((T*)block.getBlockPtr()) + i * ncols );
949  }
950  }
951  }
952  return services::Status();
953  }
954 
955  template <typename T>
956  services::Status releaseTBlock( BlockDescriptor<T> &block )
957  {
958  if(block.getRWFlag() & (int)writeOnly)
959  {
960  byte *location = internal_getBlockOfRows( block.getRowsOffset() );
961  size_t ncols = getNumberOfColumns();
962  size_t nrows = block.getNumberOfRows();
963 
964  if( IsSameType<T, DataType>::value )
965  {
966  if( (T*)block.getBlockPtr() != (T *)location )
967  {
968  daal::services::daal_memcpy_s(location, nrows * ncols * sizeof(T), block.getBlockPtr(), nrows * ncols * sizeof(T));
969  }
970  }
971  else
972  {
973  for(size_t i = 0; i < nrows; i++)
974  {
975  data_feature_utils::getVectorDownCast(data_feature_utils::getIndexNumType<DataType>(), data_feature_utils::getInternalNumType<T>())
976  ( ncols, ((T*)block.getBlockPtr()) + i * ncols, ((DataType*)location) + i * ncols );
977  }
978  }
979  }
980  block.reset();
981  return services::Status();
982  }
983 
984  template <typename T>
985  services::Status getTFeature(size_t feat_idx, size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T> &block)
986  {
987  size_t ncols = getNumberOfColumns();
988  size_t nobs = getNumberOfRows();
989  block.setDetails( feat_idx, idx, rwFlag );
990 
991  if (idx >= nobs)
992  {
993  block.resizeBuffer( 1, 0 );
994  return services::Status();
995  }
996 
997  nrows = ( idx + nrows < nobs ) ? nrows : nobs - idx;
998 
999  if( ( IsSameType<T, DataType>::value ) && (ncols == 1) )
1000  {
1001  block.setPtr(&_ptr, internal_getBlockOfRows(idx) , ncols, nrows );
1002  }
1003  else
1004  {
1005  if( !block.resizeBuffer( 1, nrows ) )
1006  return services::Status(services::ErrorMemoryAllocationFailed);
1007 
1008  if( rwFlag & (int)readOnly )
1009  {
1010  DataType *location = (DataType *)internal_getBlockOfRows(idx, feat_idx);
1011  T *buffer = block.getBlockPtr();
1012  data_feature_utils::getVectorStrideUpCast(data_feature_utils::getIndexNumType<DataType>(), data_feature_utils::getInternalNumType<T>())
1013  ( nrows, location, sizeof(DataType)*ncols, buffer, sizeof(T) );
1014  }
1015  }
1016  return services::Status();
1017  }
1018 
1019  template <typename T>
1020  services::Status releaseTFeature( BlockDescriptor<T> &block )
1021  {
1022  if (block.getRWFlag() & (int)writeOnly)
1023  {
1024  size_t ncols = getNumberOfColumns();
1025  DataType *location = (DataType *)internal_getBlockOfRows(block.getRowsOffset(), block.getColumnsOffset());
1026  data_feature_utils::getVectorStrideDownCast(data_feature_utils::getIndexNumType<DataType>(), data_feature_utils::getInternalNumType<T>())
1027  ( block.getNumberOfRows(), block.getBlockPtr(), sizeof(T), location, ncols * sizeof(DataType) );
1028  }
1029  block.reset();
1030  return services::Status();
1031  }
1032 
1033  services::Status setNumberOfColumnsImpl(size_t ncol) DAAL_C11_OVERRIDE
1034  {
1035  if( _ddict->getNumberOfFeatures() != ncol )
1036  {
1037  _ddict->resetDictionary();
1038  _ddict->setNumberOfFeatures(ncol);
1039 
1040  NumericTableFeature df;
1041  df.setType<DataType>();
1042  _ddict->setAllFeatures(df);
1043  }
1044  return services::Status();
1045  }
1046 
1047 };
1049 } // namespace interface1
1050 using interface1::HomogenNumericTable;
1051 
1052 }
1053 } // namespace daal
1054 #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:525
daal::data_management::interface1::NumericTableIface::AllocationFlag
AllocationFlag
Enumeration to specify whether the Numeric Table must allocate memory.
Definition: numeric_table.h:309
daal
Definition: algorithm_base_common.h:57
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:214
daal::data_management::interface1::HomogenNumericTable::HomogenNumericTable
HomogenNumericTable(DataType *const ptr, size_t nColumns=0, size_t nRows=0)
Definition: homogen_numeric_table.h:147
daal::data_management::interface1::HomogenNumericTable::baseDataType
DataType baseDataType
Definition: homogen_numeric_table.h:86
daal::data_management::interface1::HomogenNumericTable::HomogenNumericTable
HomogenNumericTable(const services::SharedPtr< DataType > &ptr, size_t nColumns, size_t nRows)
Definition: homogen_numeric_table.h:180
daal::data_management::interface1::HomogenNumericTable::setArray
DAAL_DEPRECATED services::Status setArray(const services::SharedPtr< DataType > &ptr)
Definition: homogen_numeric_table.h:623
daal::data_management::interface1::HomogenNumericTable::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: homogen_numeric_table.h:785
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:249
daal::data_management::interface1::HomogenNumericTable::assign
services::Status assign(T value)
Definition: homogen_numeric_table.h:691
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:393
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:355
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:540
daal::data_management::interface1::HomogenNumericTable::setArray
services::Status setArray(services::SharedPtr< DataType > ptr, size_t nRows)
Definition: homogen_numeric_table.h:668
daal::services::ErrorMemoryAllocationFailed
Definition: error_indexes.h:170
daal::dram
Definition: daal_defines.h:158
daal::data_management::interface1::HomogenNumericTable::HomogenNumericTable
HomogenNumericTable(DictionaryIface::FeaturesEqual featuresEqual, size_t nColumns, size_t nRows, AllocationFlag memoryAllocationFlag)
Definition: homogen_numeric_table.h:464
daal::data_management::interface1::HomogenNumericTable::HomogenNumericTable
HomogenNumericTable(size_t nColumns, size_t nRows, NumericTable::AllocationFlag memoryAllocationFlag, const DataType &constValue)
Definition: homogen_numeric_table.h:500
daal::data_management::interface1::HomogenNumericTable::assign
virtual services::Status assign(double value) DAAL_C11_OVERRIDE
Definition: homogen_numeric_table.h:728
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:319
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:377
daal::data_management::interface1::HomogenNumericTable::HomogenNumericTable
HomogenNumericTable()
Definition: homogen_numeric_table.h:126
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:739
daal::services::ErrorIncorrectNumberOfFeatures
Definition: error_indexes.h:96
daal_defines.h
daal::algorithms::multivariate_outlier_detection::location
Definition: outlier_detection_multivariate_types.h:98
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:415
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:566
daal::data_management::interface1::HomogenNumericTable::HomogenNumericTable
HomogenNumericTable(DataType *const ptr, size_t nColumns, size_t nRows, const DataType &constValue)
Definition: homogen_numeric_table.h:284
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:166
daal::data_management::interface1::HomogenNumericTable::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: homogen_numeric_table.h:781
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:743
daal::data_management::interface1::HomogenNumericTable::create
static services::SharedPtr< HomogenNumericTable< DataType > > create(NumericTableDictionaryPtr ddictForHomogenNumericTable, services::Status *stat=NULL)
Definition: homogen_numeric_table.h:117
daal::data_management::interface1::NumericTable
Class for a data management component responsible for representation of data in the numeric format...
Definition: numeric_table.h:600
daal::data_management::interface1::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:199
daal::data_management::interface1::HomogenNumericTable::getArray
DataType * getArray() const
Definition: homogen_numeric_table.h:582
daal::data_management::interface1::HomogenNumericTable::operator[]
DataType * operator[](size_t i)
Definition: homogen_numeric_table.h:714
daal::data_management::interface1::HomogenNumericTable::setArray
DAAL_DEPRECATED services::Status setArray(DataType *const ptr)
Definition: homogen_numeric_table.h:601
daal::data_management::interface1::HomogenNumericTable::assign
virtual services::Status assign(float value) DAAL_C11_OVERRIDE
Definition: homogen_numeric_table.h:723
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:234
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:771
daal::data_management::interface1::HomogenNumericTable::HomogenNumericTable
HomogenNumericTable(size_t nColumns, size_t nRows, AllocationFlag memoryAllocationFlag)
Definition: homogen_numeric_table.h:430
daal::data_management::interface1::HomogenNumericTable::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: homogen_numeric_table.h:752
daal::data_management::interface1::HomogenNumericTable::getArraySharedPtr
services::SharedPtr< DataType > getArraySharedPtr() const
Definition: homogen_numeric_table.h:591
daal::data_management::interface1::BlockDescriptor
Base class that manages buffer memory for read/write operations required by numeric tables...
Definition: numeric_table.h:81
daal::data_management::interface1::DictionaryIface::FeaturesEqual
FeaturesEqual
Enumeration to specify whether the Data Dictionary contains equal features.
Definition: data_dictionary.h:171
daal::algorithms::math::abs::value
Definition: abs_types.h:112
daal::data_management::interface1::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:340
daal::data_management::interface1::NumericTableFeature::setType
void setType()
Definition: data_dictionary.h:117
daal::data_management::interface1::HomogenNumericTable::assign
virtual services::Status assign(int value) DAAL_C11_OVERRIDE
Definition: homogen_numeric_table.h:733
daal::services::ErrorIncorrectNumberOfObservations
Definition: error_indexes.h:97
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:305
daal::data_management::interface1::HomogenNumericTable::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: homogen_numeric_table.h:748
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:485
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:761
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:735
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:766
daal::data_management::interface1::HomogenNumericTable::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: homogen_numeric_table.h:777
daal::data_management::interface1::HomogenNumericTable::setArray
services::Status setArray(DataType *const ptr, size_t nRows)
Definition: homogen_numeric_table.h:645
daal::data_management::interface1::NumericTableFeature
Data structure describes the Numeric Table feature.
Definition: data_dictionary.h:74
daal::data_management::interface1::HomogenNumericTable::HomogenNumericTable
HomogenNumericTable(NumericTableDictionaryPtr ddictForHomogenNumericTable)
Definition: homogen_numeric_table.h:105
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:76
daal::MemType
MemType
Definition: daal_defines.h:156
daal::data_management::interface1::HomogenNumericTable::create
static services::SharedPtr< HomogenNumericTable< DataType > > create(services::Status *stat=NULL)
Definition: homogen_numeric_table.h:135
daal::services::ErrorEmptyHomogenNumericTable
Definition: error_indexes.h:185
daal::data_management::interface1::HomogenNumericTable::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: homogen_numeric_table.h:756
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:450
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:269
daal::data_management::interface1::Dictionary
Class that represents a dictionary of a data set and provides methods to work with the data dictionar...
Definition: data_dictionary.h:184

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