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

symmetric_matrix.h
1 /* file: symmetric_matrix.h */
2 /*******************************************************************************
3 * Copyright 2014-2019 Intel Corporation.
4 *
5 * This software and the related documents are Intel copyrighted materials, and
6 * your use of them is governed by the express license under which they were
7 * provided to you (License). Unless the License provides otherwise, you may not
8 * use, modify, copy, publish, distribute, disclose or transmit this software or
9 * the related documents without Intel's prior written permission.
10 *
11 * This software and the related documents are provided as is, with no express
12 * or implied warranties, other than those that are expressly stated in the
13 * License.
14 *******************************************************************************/
15 
16 /*
17 //++
18 // Declaration and implementation of a symmetric matrix.
19 //--
20 */
21 
22 
23 #ifndef __SYMMETRIC_MATRIX_H__
24 #define __SYMMETRIC_MATRIX_H__
25 
26 #include "data_management/data/numeric_table.h"
27 #include "services/daal_memory.h"
28 #include "services/daal_defines.h"
29 #include "data_management/data/data_serialize.h"
30 
31 namespace daal
32 {
33 namespace data_management
34 {
35 
36 namespace interface1
37 {
46 class PackedArrayNumericTableIface
47 {
48 public:
49  virtual ~PackedArrayNumericTableIface()
50  {}
59  virtual services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor<double> &block) = 0;
60 
69  virtual services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor<float> &block) = 0;
70 
79  virtual services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor<int> &block) = 0;
80 
85  virtual services::Status releasePackedArray(BlockDescriptor<double> &block) = 0;
86 
91  virtual services::Status releasePackedArray(BlockDescriptor<float> &block) = 0;
92 
97  virtual services::Status releasePackedArray(BlockDescriptor<int> &block) = 0;
98 };
99 
105 template<NumericTableIface::StorageLayout packedLayout, typename DataType = DAAL_DATA_TYPE>
106 class DAAL_EXPORT PackedSymmetricMatrix : public NumericTable, public PackedArrayNumericTableIface
107 {
108 public:
109  DECLARE_SERIALIZABLE_TAG();
110  DECLARE_SERIALIZABLE_IMPL();
111 
115  typedef DataType baseDataType;
116 
117 public:
124  PackedSymmetricMatrix( DataType *const ptr = 0, size_t nDim = 0 ):
125  NumericTable( nDim, nDim )
126  {
127  _layout = packedLayout;
128  this->_status |= setArray( services::SharedPtr<DataType>(ptr, services::EmptyDeleter()) );
129 
130  NumericTableFeature df;
131  df.setType<DataType>();
132  this->_status |= _ddict->setAllFeatures(df);
133  }
134 
141  PackedSymmetricMatrix( const services::SharedPtr<DataType> &ptr, size_t nDim ):
142  NumericTable( nDim, nDim )
143  {
144  _layout = packedLayout;
145  this->_status |= setArray( ptr );
146 
147  NumericTableFeature df;
148  df.setType<DataType>();
149  this->_status |= _ddict->setAllFeatures(df);
150  }
151 
152  PackedSymmetricMatrix( size_t nDim /*= 0*/ ):
153  NumericTable( nDim, nDim )
154  {
155  _layout = packedLayout;
156 
157  NumericTableFeature df;
158  df.setType<DataType>();
159  this->_status |= _ddict->setAllFeatures(df);
160  }
161 
169  static services::SharedPtr<PackedSymmetricMatrix> create(DataType *const ptr = 0, size_t nDim = 0,
170  services::Status* stat = NULL)
171  {
172  return create(services::SharedPtr<DataType>(ptr, services::EmptyDeleter()), nDim, stat);
173  }
174 
182  static services::SharedPtr<PackedSymmetricMatrix> create(const services::SharedPtr<DataType> &ptr, size_t nDim,
183  services::Status* stat = NULL)
184  {
185  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(PackedSymmetricMatrix, DAAL_TEMPLATE_ARGUMENTS(packedLayout,DataType), ptr, nDim);
186  }
187 
195  PackedSymmetricMatrix( DataType *const ptr, size_t nDim, const DataType &constValue ):
196  NumericTable( nDim, nDim )
197  {
198  _layout = packedLayout;
199  this->_status |= setArray( services::SharedPtr<DataType>(ptr, services::EmptyDeleter()) );
200 
201  NumericTableFeature df;
202  df.setType<DataType>();
203  this->_status |= _ddict->setAllFeatures(df);
204 
205  this->_status |= assign( constValue );
206  }
207 
215  PackedSymmetricMatrix( const services::SharedPtr<DataType>& ptr, size_t nDim, const DataType &constValue ) :
216  NumericTable( nDim, nDim )
217  {
218  _layout = packedLayout;
219  this->_status |= setArray( ptr );
220 
221  NumericTableFeature df;
222  df.setType<DataType>();
223  this->_status |= _ddict->setAllFeatures(df);
224 
225  this->_status |= assign( constValue );
226  }
227 
236  static services::SharedPtr<PackedSymmetricMatrix> create(DataType *const ptr, size_t nDim, const DataType &constValue,
237  services::Status* stat = NULL)
238  {
239  return create(services::SharedPtr<DataType>(ptr, services::EmptyDeleter()), nDim, constValue, stat);
240  }
241 
250  static services::SharedPtr<PackedSymmetricMatrix> create(const services::SharedPtr<DataType> &ptr, size_t nDim, const DataType &constValue,
251  services::Status* stat = NULL)
252  {
253  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(PackedSymmetricMatrix, DAAL_TEMPLATE_ARGUMENTS(packedLayout,DataType), ptr, nDim, constValue);
254  }
255 
262  PackedSymmetricMatrix( size_t nDim, AllocationFlag memoryAllocationFlag ):
263  NumericTable( nDim, nDim )
264  {
265  _layout = packedLayout;
266 
267  NumericTableFeature df;
268  df.setType<DataType>();
269  this->_status |= _ddict->setAllFeatures(df);
270 
271  if( memoryAllocationFlag == doAllocate ) this->_status |= allocateDataMemoryImpl();
272  }
273 
281  static services::SharedPtr<PackedSymmetricMatrix> create(size_t nDim, AllocationFlag memoryAllocationFlag,
282  services::Status* stat = NULL)
283  {
284  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(PackedSymmetricMatrix, DAAL_TEMPLATE_ARGUMENTS(packedLayout,DataType), nDim, memoryAllocationFlag);
285  }
286 
294  PackedSymmetricMatrix( size_t nDim, NumericTable::AllocationFlag memoryAllocationFlag,
295  const DataType &constValue ):
296  NumericTable( nDim, nDim )
297  {
298  _layout = packedLayout;
299 
300  NumericTableFeature df;
301  df.setType<DataType>();
302  this->_status |= _ddict->setAllFeatures(df);
303 
304  if( memoryAllocationFlag == doAllocate ) this->_status |= allocateDataMemoryImpl();
305  this->_status |= assign(constValue);
306  }
307 
316  static services::SharedPtr<PackedSymmetricMatrix> create(size_t nDim, NumericTable::AllocationFlag memoryAllocationFlag,
317  const DataType &constValue, services::Status* stat = NULL)
318  {
319  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(PackedSymmetricMatrix, DAAL_TEMPLATE_ARGUMENTS(packedLayout,DataType), \
320  nDim, memoryAllocationFlag, constValue);
321  }
322 
324  virtual ~PackedSymmetricMatrix()
325  {
326  freeDataMemoryImpl();
327  }
328 
333  DataType *getArray() const
334  {
335  return (DataType*)_ptr.get();
336  }
337 
342  services::SharedPtr<DataType> getArraySharedPtr() const
343  {
344  return services::reinterpretPointerCast<DataType, byte>(_ptr);
345  }
346 
351  services::Status setArray( DataType *const ptr )
352  {
353  freeDataMemoryImpl();
354  if( ptr == 0 )
355  return services::Status(services::ErrorEmptyHomogenNumericTable);
356 
357  _ptr = services::SharedPtr<byte>((byte*)ptr, services::EmptyDeleter());
358  _memStatus = userAllocated;
359  return services::Status();
360  }
361 
366  services::Status setArray( const services::SharedPtr<DataType>& ptr )
367  {
368  freeDataMemoryImpl();
369  if( ptr == 0 )
370  return services::Status(services::ErrorEmptyHomogenNumericTable);
371 
372  _ptr = services::reinterpretPointerCast<byte, DataType>(ptr);
373  _memStatus = userAllocated;
374  return services::Status();
375  }
376 
381  template <typename T>
382  services::Status assign(T value)
383  {
384  if( _memStatus == notAllocated )
385  return services::Status(services::ErrorEmptyHomogenNumericTable);
386 
387  size_t nDim = getNumberOfColumns();
388 
389  DataType * ptr = (DataType*)_ptr.get();
390  DataType valueDataType = (DataType)value;
391  for( size_t i = 0; i < (nDim * (nDim + 1)) / 2 ; i++ )
392  {
393  ptr[i] = valueDataType;
394  }
395  return services::Status();
396  }
397 
401  virtual services::Status assign(float value) DAAL_C11_OVERRIDE {return assign<DataType>((DataType)value);}
402 
406  virtual services::Status assign(double value) DAAL_C11_OVERRIDE {return assign<DataType>((DataType)value);}
407 
411  virtual services::Status assign(int value) DAAL_C11_OVERRIDE {return assign<DataType>((DataType)value);}
412 
413  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
414  {
415  return getTBlock<double>(vector_idx, vector_num, rwflag, block);
416  }
417  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
418  {
419  return getTBlock<float>(vector_idx, vector_num, rwflag, block);
420  }
421  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
422  {
423  return getTBlock<int>(vector_idx, vector_num, rwflag, block);
424  }
425 
426  services::Status releaseBlockOfRows(BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
427  {
428  return releaseTBlock<double>(block);
429  }
430  services::Status releaseBlockOfRows(BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
431  {
432  return releaseTBlock<float>(block);
433  }
434  services::Status releaseBlockOfRows(BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
435  {
436  return releaseTBlock<int>(block);
437  }
438 
439  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
440  ReadWriteMode rwflag, BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
441  {
442  return getTFeature<double>(feature_idx, vector_idx, value_num, rwflag, block);
443  }
444  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
445  ReadWriteMode rwflag, BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
446  {
447  return getTFeature<float>(feature_idx, vector_idx, value_num, rwflag, block);
448  }
449  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
450  ReadWriteMode rwflag, BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
451  {
452  return getTFeature<int>(feature_idx, vector_idx, value_num, rwflag, block);
453  }
454 
455  services::Status releaseBlockOfColumnValues(BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
456  {
457  return releaseTFeature<double>(block);
458  }
459  services::Status releaseBlockOfColumnValues(BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
460  {
461  return releaseTFeature<float>(block);
462  }
463  services::Status releaseBlockOfColumnValues(BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
464  {
465  return releaseTFeature<int>(block);
466  }
467 
468 
469  services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
470  {
471  return getTPackedArray<double>(rwflag, block);
472  }
473  services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
474  {
475  return getTPackedArray<float>(rwflag, block);
476  }
477  services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
478  {
479  return getTPackedArray<int>(rwflag, block);
480  }
481 
482  services::Status releasePackedArray(BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
483  {
484  return releaseTPackedArray<double>(block);
485  }
486  services::Status releasePackedArray(BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
487  {
488  return releaseTPackedArray<float>(block);
489  }
490  services::Status releasePackedArray(BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
491  {
492  return releaseTPackedArray<int>(block);
493  }
494 
495 protected:
496  services::SharedPtr<byte> _ptr;
497 
498  PackedSymmetricMatrix(const services::SharedPtr<DataType> &ptr, size_t nDim, services::Status &st):
499  NumericTable(nDim, nDim, DictionaryIface::notEqual, st)
500  {
501  _layout = packedLayout;
502  st |= setArray( ptr );
503 
504  NumericTableFeature df;
505  df.setType<DataType>();
506  st |= _ddict->setAllFeatures(df);
507  }
508 
509  PackedSymmetricMatrix(const services::SharedPtr<DataType>& ptr, size_t nDim, const DataType &constValue,
510  services::Status &st) :
511  NumericTable(nDim, nDim, DictionaryIface::notEqual, st)
512  {
513  _layout = packedLayout;
514  st |= setArray( ptr );
515 
516  NumericTableFeature df;
517  df.setType<DataType>();
518  st |= _ddict->setAllFeatures(df);
519 
520  st |= assign( constValue );
521  }
522 
523  PackedSymmetricMatrix(size_t nDim, AllocationFlag memoryAllocationFlag, services::Status &st):
524  NumericTable(nDim, nDim, DictionaryIface::notEqual, st)
525  {
526  _layout = packedLayout;
527 
528  NumericTableFeature df;
529  df.setType<DataType>();
530  st |= _ddict->setAllFeatures(df);
531 
532  if( memoryAllocationFlag == doAllocate ) st |= allocateDataMemoryImpl();
533  }
534 
535  PackedSymmetricMatrix(size_t nDim, NumericTable::AllocationFlag memoryAllocationFlag,
536  const DataType &constValue, services::Status &st):
537  NumericTable(nDim, nDim, DictionaryIface::notEqual, st)
538  {
539  _layout = packedLayout;
540 
541  NumericTableFeature df;
542  df.setType<DataType>();
543  st |= _ddict->setAllFeatures(df);
544 
545  if( memoryAllocationFlag == doAllocate ) st |= allocateDataMemoryImpl();
546  st |= assign(constValue);
547  }
548 
549  services::Status allocateDataMemoryImpl(daal::MemType type = daal::dram) DAAL_C11_OVERRIDE
550  {
551  freeDataMemoryImpl();
552 
553  size_t nDim = getNumberOfColumns();
554  size_t size = (nDim * (nDim + 1)) / 2;
555 
556  if( size == 0 )
557  return services::Status(getNumberOfColumns() == 0 ? services::ErrorIncorrectNumberOfFeatures :
558  services::ErrorIncorrectNumberOfObservations);
559 
560  _ptr = services::SharedPtr<byte>((byte *)daal::services::daal_malloc( size * sizeof(DataType) ), services::ServiceDeleter());
561 
562  if( _ptr == 0 )
563  return services::Status(services::ErrorMemoryAllocationFailed);
564 
565  _memStatus = internallyAllocated;
566  return services::Status();
567  }
568 
569  void freeDataMemoryImpl() DAAL_C11_OVERRIDE
570  {
571  _ptr.reset();
572  _memStatus = notAllocated;
573  }
574 
576  template<typename Archive, bool onDeserialize>
577  services::Status serialImpl( Archive *arch )
578  {
579  NumericTable::serialImpl<Archive, onDeserialize>( arch );
580 
581  if( onDeserialize )
582  {
583  allocateDataMemoryImpl();
584  }
585 
586  size_t nDim = getNumberOfColumns();
587  size_t size = (nDim * (nDim + 1)) / 2;
588 
589  arch->set( (DataType*)_ptr.get(), size );
590 
591  return services::Status();
592  }
593 
594 private:
595  template<typename T1, typename T2>
596  void internal_repack( size_t p, size_t n, T1 *src, T2 *dst )
597  {
598  if( IsSameType<T1, T2>::value )
599  {
600  if( src != (T1 *)dst )
601  {
602  daal::services::daal_memcpy_s(dst, n * p * sizeof(T1), src, n * p * sizeof(T1));
603  }
604  }
605  else
606  {
607  size_t i, j;
608 
609  for(i = 0; i < n; i++)
610  {
611  for(j = 0; j < p; j++)
612  {
613  dst[i * p + j] = static_cast<T2>(src[i * p + j]);
614  }
615  }
616  }
617  }
618 
619  template<typename T1, typename T2>
620  void internal_set_col_repack( size_t p, size_t n, T1 *src, T2 *dst )
621  {
622  size_t i;
623 
624  for(i = 0; i < n; i++)
625  {
626  dst[i * p] = static_cast<T2>(src[i]);
627  }
628  }
629 
630 protected:
631  baseDataType &getBaseValue( size_t dim, size_t rowIdx, size_t colIdx )
632  {
633  size_t offset;
634 
635  if( packedLayout == upperPackedSymmetricMatrix )
636  {
637  if( colIdx < rowIdx )
638  {
639  size_t tmp;
640  tmp = colIdx;
641  colIdx = rowIdx;
642  rowIdx = tmp;
643  }
644 
645  offset = (2 * dim - rowIdx) * (rowIdx + 1) / 2 - (dim - colIdx);
646  }
647  else /* here lowerPackedSymmetricMatrix is supposed */
648  {
649  if( colIdx > rowIdx )
650  {
651  size_t tmp;
652  tmp = colIdx;
653  colIdx = rowIdx;
654  rowIdx = tmp;
655  }
656 
657  offset = (2 + rowIdx) * (rowIdx + 1) / 2 - (rowIdx - colIdx) - 1;
658  }
659  return *((DataType*)_ptr.get() + offset);
660  }
661 
662  template <typename T>
663  T getValue( size_t dim, size_t rowIdx, size_t colIdx )
664  {
665  return static_cast<T>( getBaseValue( dim, rowIdx, colIdx ) );
666  }
667 
668  template <typename T>
669  services::Status setValue( size_t dim, size_t rowIdx, size_t colIdx, T value )
670  {
671  getBaseValue( dim, rowIdx, colIdx ) = static_cast<baseDataType>( value );
672  return services::Status();
673  }
674 
675  template <typename T>
676  services::Status getTBlock(size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T> &block)
677  {
678  size_t nDim = getNumberOfColumns();
679  block.setDetails( 0, idx, rwFlag );
680 
681  if (idx >= nDim)
682  {
683  block.resizeBuffer( nDim, 0 );
684  return services::Status();
685  }
686 
687  nrows = ( idx + nrows < nDim ) ? nrows : nDim - idx;
688 
689  if( !block.resizeBuffer( nDim, nrows ) )
690  return services::Status(services::ErrorMemoryAllocationFailed);
691 
692  if((rwFlag & (int)readOnly))
693  {
694  T *buffer = block.getBlockPtr();
695 
696  for(size_t iRow = 0; iRow < nrows; iRow++)
697  {
698  for(size_t iCol = 0; iCol < nDim; iCol++)
699  {
700  buffer[iRow * nDim + iCol] = getValue<T>(nDim, iRow + idx, iCol);
701  }
702  }
703  }
704  return services::Status();
705  }
706 
707  template <typename T>
708  services::Status releaseTBlock( BlockDescriptor<T> &block )
709  {
710  services::Status s;
711  if(block.getRWFlag() & (int)writeOnly)
712  {
713  size_t nDim = getNumberOfColumns();
714  size_t nrows = block.getNumberOfRows();
715  size_t idx = block.getRowsOffset();
716  T *buffer = block.getBlockPtr();
717 
718  for( size_t iRow = 0; iRow < nrows; iRow++ )
719  {
720  for( size_t iCol = 0; iCol < nDim; iCol++ )
721  {
722  s |= setValue<T>( nDim, idx + iRow, iCol, buffer[ iRow * nDim + iCol ] );
723  }
724  }
725  }
726  block.reset();
727  return s;
728  }
729 
730  template <typename T>
731  services::Status getTFeature(size_t feat_idx, size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T> &block)
732  {
733  size_t nDim = getNumberOfColumns();
734  block.setDetails( feat_idx, idx, rwFlag );
735 
736  if (idx >= nDim)
737  {
738  block.resizeBuffer( nDim, 0 );
739  return services::Status();
740  }
741 
742  nrows = ( idx + nrows < nDim ) ? nrows : nDim - idx;
743 
744  if( !block.resizeBuffer( 1, nrows ) )
745  return services::Status();
746 
747  if((block.getRWFlag() & (int)readOnly))
748  {
749  T *buffer = block.getBlockPtr();
750 
751  for(size_t iRow = 0; iRow < nrows; iRow++)
752  {
753  buffer[iRow] = getValue<T>(nDim, iRow + idx, feat_idx);
754  }
755  }
756  return services::Status();
757  }
758 
759  template <typename T>
760  services::Status releaseTFeature( BlockDescriptor<T> &block )
761  {
762  services::Status s;
763  if (block.getRWFlag() & (int)writeOnly)
764  {
765  size_t nDim = getNumberOfColumns();
766  size_t nrows = block.getNumberOfRows();
767  size_t idx = block.getRowsOffset();
768  size_t feat_idx = block.getColumnsOffset();
769  T *buffer = block.getBlockPtr();
770 
771  for( size_t iRow = 0; iRow < nrows; iRow++ )
772  {
773  s |= setValue<T>( nDim, iRow + idx, feat_idx, buffer[ iRow ] );
774  }
775  }
776  block.reset();
777  return s;
778  }
779 
780  template <typename T>
781  services::Status getTPackedArray( int rwFlag, BlockDescriptor<T> &block )
782  {
783  size_t nDim = getNumberOfColumns();
784  block.setDetails( 0, 0, rwFlag );
785 
786  size_t nSize = (nDim * (nDim + 1)) / 2;
787 
788  if( IsSameType<T, DataType>::value )
789  {
790  block.setPtr( &_ptr, _ptr.get(), 1, nSize );
791  return services::Status();
792  }
793 
794  if( !block.resizeBuffer( 1, nSize ) ) return services::Status();
795 
796  if( !(rwFlag & (int)readOnly) ) return services::Status();
797 
798  T *buffer = block.getBlockPtr();
799  DataType * ptr = (DataType*) _ptr.get();
800  for( size_t i = 0; i < nSize; i++ )
801  {
802  buffer[ i ] = static_cast<T>(*(ptr + i));
803  }
804  return services::Status();
805  }
806 
807  template <typename T>
808  services::Status releaseTPackedArray( BlockDescriptor<T> &block )
809  {
810  if( (block.getRWFlag() & (int)writeOnly) && !IsSameType<T, DataType>::value )
811  {
812  size_t nDim = getNumberOfColumns();
813  size_t nSize = (nDim * (nDim + 1)) / 2;
814  T *buffer = block.getBlockPtr();
815  DataType * ptr = (DataType*) _ptr.get();
816 
817  for( size_t i = 0; i < nSize; i++ )
818  {
819  *(ptr + i) = static_cast<baseDataType>(buffer[ i ]);
820  }
821  }
822  block.reset();
823  return services::Status();
824  }
825 
826  virtual services::Status setNumberOfColumnsImpl(size_t nDim) DAAL_C11_OVERRIDE
827  {
828  if( _ddict->getNumberOfFeatures() != nDim )
829  {
830  _ddict->setNumberOfFeatures( nDim );
831 
832  NumericTableFeature df;
833  df.setType<DataType>();
834  _ddict->setAllFeatures(df);
835  }
836 
837  _obsnum = nDim;
838  return services::Status();
839  }
840 
841  virtual services::Status setNumberOfRowsImpl(size_t nDim) DAAL_C11_OVERRIDE
842  {
843  setNumberOfColumnsImpl( nDim );
844  _obsnum = nDim;
845  return services::Status();
846  }
847 };
848 
854 template<NumericTableIface::StorageLayout packedLayout, typename DataType = DAAL_DATA_TYPE>
855 class DAAL_EXPORT PackedTriangularMatrix : public NumericTable, public PackedArrayNumericTableIface
856 {
857 public:
858  DECLARE_SERIALIZABLE_TAG();
859 
863  typedef DataType baseDataType;
864 
865 public:
871  PackedTriangularMatrix( DataType *const ptr = 0, size_t nDim = 0 ):
872  NumericTable( nDim, nDim )
873  {
874  _layout = packedLayout;
875  this->_status |= setArray( services::SharedPtr<DataType>(ptr, services::EmptyDeleter()) );
876 
877  NumericTableFeature df;
878  df.setType<DataType>();
879  this->_status |= _ddict->setAllFeatures(df);
880  }
881 
887  PackedTriangularMatrix( const services::SharedPtr<DataType> &ptr, size_t nDim ):
888  NumericTable( nDim, nDim )
889  {
890  _layout = packedLayout;
891  this->_status |= setArray( ptr );
892 
893  NumericTableFeature df;
894  df.setType<DataType>();
895  this->_status |= _ddict->setAllFeatures(df);
896  }
897 
898  PackedTriangularMatrix( size_t nDim /*= 0*/ ):
899  NumericTable( nDim, nDim )
900  {
901  _layout = packedLayout;
902 
903  NumericTableFeature df;
904  df.setType<DataType>();
905  this->_status |= _ddict->setAllFeatures(df);
906  }
907 
908  static services::SharedPtr<PackedTriangularMatrix> create(DataType *const ptr = 0, size_t nDim = 0,
909  services::Status* stat = NULL)
910  {
911  return create(services::SharedPtr<DataType>(ptr, services::EmptyDeleter()), nDim, stat);
912  }
913 
914  static services::SharedPtr<PackedTriangularMatrix> create(const services::SharedPtr<DataType> &ptr, size_t nDim,
915  services::Status* stat = NULL)
916  {
917  services::SharedPtr<PackedTriangularMatrix> ntPtr(new PackedTriangularMatrix(nDim));
918  if(ntPtr.get())
919  {
920  services::Status s = ntPtr->setArray(ptr);
921  if(!s)
922  ntPtr = services::SharedPtr<PackedTriangularMatrix>();
923  if(stat)
924  *stat = s;
925  }
926  else
927  {
928  if(stat)
929  *stat = services::Status(services::ErrorMemoryAllocationFailed);
930  }
931  return ntPtr;
932  }
933 
940  PackedTriangularMatrix( DataType *const ptr, size_t nDim, const DataType &constValue ):
941  NumericTable( nDim, nDim )
942  {
943  _layout = packedLayout;
944  this->_status |= setArray( services::SharedPtr<DataType>(ptr, services::EmptyDeleter()) );
945 
946  NumericTableFeature df;
947  df.setType<DataType>();
948  this->_status |= _ddict->setAllFeatures(df);
949 
950  this->_status |= assign( constValue );
951  }
952 
959  PackedTriangularMatrix( const services::SharedPtr<DataType>& ptr, size_t nDim, const DataType &constValue ) :
960  NumericTable( nDim, nDim )
961  {
962  _layout = packedLayout;
963  this->_status |= setArray( ptr );
964 
965  NumericTableFeature df;
966  df.setType<DataType>();
967  this->_status |= _ddict->setAllFeatures(df);
968 
969  this->_status |= assign( constValue );
970  }
971 
972  static services::SharedPtr<PackedTriangularMatrix> create(DataType *const ptr, size_t nDim, const DataType &constValue,
973  services::Status* stat = NULL)
974  {
975  services::SharedPtr<PackedTriangularMatrix> ntPtr(new PackedTriangularMatrix(nDim));
976  if(ntPtr.get())
977  {
978  services::Status s = ntPtr->setArray( services::SharedPtr<DataType>(ptr, services::EmptyDeleter()) );
979  s.add(ntPtr->assign(constValue));
980  if(!s)
981  ntPtr = services::SharedPtr<PackedTriangularMatrix>();
982  if(stat)
983  *stat = s;
984  }
985  else
986  {
987  if(stat)
988  *stat = services::Status(services::ErrorMemoryAllocationFailed);
989  }
990  return ntPtr;
991  }
992 
993  static services::SharedPtr<PackedTriangularMatrix> create(services::SharedPtr<DataType> &ptr, size_t nDim, const DataType &constValue,
994  services::Status* stat = NULL)
995  {
996  services::SharedPtr<PackedTriangularMatrix> ntPtr(new PackedTriangularMatrix(nDim));
997  if(ntPtr.get())
998  {
999  services::Status s = ntPtr->setArray(ptr);
1000  s.add(ntPtr->assign(constValue));
1001  if(!s)
1002  ntPtr = services::SharedPtr<PackedTriangularMatrix>();
1003  if(stat)
1004  *stat = s;
1005  }
1006  else
1007  {
1008  if(stat)
1009  *stat = services::Status(services::ErrorMemoryAllocationFailed);
1010  }
1011  return ntPtr;
1012  }
1013 
1019  PackedTriangularMatrix( size_t nDim, AllocationFlag memoryAllocationFlag ):
1020  NumericTable( nDim, nDim )
1021  {
1022  _layout = packedLayout;
1023 
1024  NumericTableFeature df;
1025  df.setType<DataType>();
1026  this->_status |= _ddict->setAllFeatures(df);
1027 
1028  if( memoryAllocationFlag == doAllocate ) this->_status |= allocateDataMemoryImpl();
1029  }
1030 
1031  static services::SharedPtr<PackedTriangularMatrix> create(size_t nDim, AllocationFlag memoryAllocationFlag,
1032  services::Status* stat = NULL)
1033  {
1034  services::SharedPtr<PackedTriangularMatrix> ntPtr(new PackedTriangularMatrix(nDim));
1035  if(ntPtr.get())
1036  {
1037  services::Status s;
1038  if(memoryAllocationFlag == doAllocate)
1039  {
1040  s = ntPtr->allocateDataMemoryImpl();
1041  if(!s)
1042  ntPtr = services::SharedPtr<PackedTriangularMatrix>();
1043  }
1044  if(!s)
1045  ntPtr = services::SharedPtr<PackedTriangularMatrix>();
1046  if(stat)
1047  *stat = s;
1048  }
1049  else
1050  {
1051  if(stat)
1052  *stat = services::Status(services::ErrorMemoryAllocationFailed);
1053  }
1054  return ntPtr;
1055  }
1056 
1063  PackedTriangularMatrix( size_t nDim, NumericTable::AllocationFlag memoryAllocationFlag,
1064  const DataType &constValue ):
1065  NumericTable( nDim, nDim )
1066  {
1067  _layout = packedLayout;
1068 
1069  NumericTableFeature df;
1070  df.setType<DataType>();
1071  this->_status |= _ddict->setAllFeatures(df);
1072 
1073  if( memoryAllocationFlag == doAllocate ) this->_status |= allocateDataMemoryImpl();
1074  this->_status |= assign(constValue);
1075  }
1076 
1077  static services::SharedPtr<PackedTriangularMatrix> create(size_t nDim, NumericTable::AllocationFlag memoryAllocationFlag,
1078  const DataType &constValue, services::Status* stat = NULL)
1079  {
1080  services::SharedPtr<PackedTriangularMatrix> ntPtr(new PackedTriangularMatrix(nDim));
1081  if(ntPtr.get())
1082  {
1083  services::Status s;
1084  if(memoryAllocationFlag == doAllocate)
1085  {
1086  s = ntPtr->allocateDataMemoryImpl();
1087  s.add(ntPtr->assign(constValue));
1088  if(!s)
1089  ntPtr = services::SharedPtr<PackedTriangularMatrix>();
1090  }
1091  if(!s)
1092  ntPtr = services::SharedPtr<PackedTriangularMatrix>();
1093  if(stat)
1094  *stat = s;
1095  }
1096  else
1097  {
1098  if(stat)
1099  *stat = services::Status(services::ErrorMemoryAllocationFailed);
1100  }
1101  return ntPtr;
1102  }
1103 
1105  virtual ~PackedTriangularMatrix()
1106  {
1107  freeDataMemoryImpl();
1108  }
1109 
1110  virtual services::Status setNumberOfColumns(size_t nDim) DAAL_C11_OVERRIDE
1111  {
1112  if( _ddict->getNumberOfFeatures() != nDim )
1113  {
1114  _ddict->setNumberOfFeatures( nDim );
1115 
1116  NumericTableFeature df;
1117  df.setType<DataType>();
1118  _ddict->setAllFeatures(df);
1119  }
1120 
1121  _obsnum = nDim;
1122  return services::Status();
1123  }
1124 
1125  virtual services::Status setNumberOfRows(size_t nDim) DAAL_C11_OVERRIDE
1126  {
1127  return setNumberOfColumns( nDim );
1128  }
1129 
1134  DataType *getArray() const
1135  {
1136  return (DataType*)_ptr.get();
1137  }
1138 
1143  services::SharedPtr<DataType> getArraySharedPtr() const
1144  {
1145  return services::reinterpretPointerCast<DataType, byte>(_ptr);
1146  }
1147 
1152  services::Status setArray( DataType *const ptr )
1153  {
1154  freeDataMemoryImpl();
1155  if( ptr == 0 )
1156  return services::Status(services::ErrorEmptyHomogenNumericTable);
1157 
1158  _ptr = services::SharedPtr<byte>((DataType*)ptr, services::EmptyDeleter());
1159  _memStatus = userAllocated;
1160  return services::Status();
1161  }
1162 
1167  services::Status setArray( const services::SharedPtr<DataType>& ptr )
1168  {
1169  freeDataMemoryImpl();
1170  if( ptr == 0 )
1171  return services::Status(services::ErrorEmptyHomogenNumericTable);
1172 
1173  _ptr = services::reinterpretPointerCast<byte, DataType>(ptr);
1174  _memStatus = userAllocated;
1175  return services::Status();
1176  }
1177 
1182  template <typename T>
1183  services::Status assign(T value)
1184  {
1185  if( _memStatus == notAllocated )
1186  return services::Status(services::ErrorEmptyHomogenNumericTable);
1187 
1188  size_t nDim = getNumberOfColumns();
1189 
1190  DataType * ptr = (DataType*)_ptr.get();
1191  DataType valueDataType = (DataType)value;
1192  for( size_t i = 0; i < (nDim * (nDim + 1)) / 2 ; i++ )
1193  {
1194  ptr[i] = valueDataType;
1195  }
1196  return services::Status();
1197  }
1198 
1202  virtual services::Status assign(float value) DAAL_C11_OVERRIDE {return assign<DataType>((DataType)value);}
1203 
1207  virtual services::Status assign(double value) DAAL_C11_OVERRIDE {return assign<DataType>((DataType)value);}
1208 
1212  virtual services::Status assign(int value) DAAL_C11_OVERRIDE {return assign<DataType>((DataType)value);}
1213 
1214  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
1215  {
1216  return getTBlock<double>(vector_idx, vector_num, rwflag, block);
1217  }
1218  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
1219  {
1220  return getTBlock<float>(vector_idx, vector_num, rwflag, block);
1221  }
1222  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
1223  {
1224  return getTBlock<int>(vector_idx, vector_num, rwflag, block);
1225  }
1226 
1227  services::Status releaseBlockOfRows(BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
1228  {
1229  return releaseTBlock<double>(block);
1230  }
1231  services::Status releaseBlockOfRows(BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
1232  {
1233  return releaseTBlock<float>(block);
1234  }
1235  services::Status releaseBlockOfRows(BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
1236  {
1237  return releaseTBlock<int>(block);
1238  }
1239 
1240  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
1241  ReadWriteMode rwflag, BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
1242  {
1243  return getTFeature<double>(feature_idx, vector_idx, value_num, rwflag, block);
1244  }
1245  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
1246  ReadWriteMode rwflag, BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
1247  {
1248  return getTFeature<float>(feature_idx, vector_idx, value_num, rwflag, block);
1249  }
1250  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
1251  ReadWriteMode rwflag, BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
1252  {
1253  return getTFeature<int>(feature_idx, vector_idx, value_num, rwflag, block);
1254  }
1255 
1256  services::Status releaseBlockOfColumnValues(BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
1257  {
1258  return releaseTFeature<double>(block);
1259  }
1260  services::Status releaseBlockOfColumnValues(BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
1261  {
1262  return releaseTFeature<float>(block);
1263  }
1264  services::Status releaseBlockOfColumnValues(BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
1265  {
1266  return releaseTFeature<int>(block);
1267  }
1268 
1269  services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
1270  {
1271  return getTPackedArray<double>(rwflag, block);
1272  }
1273  services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
1274  {
1275  return getTPackedArray<float>(rwflag, block);
1276  }
1277  services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
1278  {
1279  return getTPackedArray<int>(rwflag, block);
1280  }
1281 
1282  services::Status releasePackedArray(BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
1283  {
1284  return releaseTPackedArray<double>(block);
1285  }
1286  services::Status releasePackedArray(BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
1287  {
1288  return releaseTPackedArray<float>(block);
1289  }
1290  services::Status releasePackedArray(BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
1291  {
1292  return releaseTPackedArray<int>(block);
1293  }
1294 
1296  services::Status serializeImpl (InputDataArchive *arch) DAAL_C11_OVERRIDE
1297  {
1298  serialImpl<InputDataArchive, false>( arch );
1299 
1300  return services::Status();
1301  }
1302 
1304  services::Status deserializeImpl(const OutputDataArchive *arch) DAAL_C11_OVERRIDE
1305  {
1306  serialImpl<const OutputDataArchive, true>( arch );
1307 
1308  return services::Status();
1309  }
1310 
1311 protected:
1312  services::SharedPtr<byte> _ptr;
1313 
1314  services::Status allocateDataMemoryImpl(daal::MemType type = daal::dram) DAAL_C11_OVERRIDE
1315  {
1316  freeDataMemoryImpl();
1317 
1318  size_t nDim = getNumberOfColumns();
1319  size_t size = (nDim * (nDim + 1)) / 2;
1320 
1321  if( size == 0 )
1322  return services::Status(getNumberOfColumns() == 0 ? services::ErrorIncorrectNumberOfFeatures :
1323  services::ErrorIncorrectNumberOfObservations);
1324 
1325  _ptr = services::SharedPtr<byte>((byte *)daal::services::daal_malloc( size * sizeof(DataType) ), services::ServiceDeleter());
1326 
1327  if( _ptr == 0 )
1328  return services::Status(services::ErrorMemoryAllocationFailed);
1329 
1330  _memStatus = internallyAllocated;
1331  return services::Status();
1332  }
1333 
1334  void freeDataMemoryImpl() DAAL_C11_OVERRIDE
1335  {
1336  _ptr.reset();
1337  _memStatus = notAllocated;
1338  }
1339 
1341  template<typename Archive, bool onDeserialize>
1342  services::Status serialImpl( Archive *arch )
1343  {
1344  NumericTable::serialImpl<Archive, onDeserialize>( arch );
1345 
1346  if( onDeserialize )
1347  {
1348  allocateDataMemoryImpl();
1349  }
1350 
1351  size_t nDim = getNumberOfColumns();
1352  size_t size = (nDim * (nDim + 1)) / 2;
1353 
1354  arch->set( (DataType*)_ptr.get(), size );
1355 
1356  return services::Status();
1357  }
1358 
1359 private:
1360  template<typename T1, typename T2>
1361  void internal_repack( size_t p, size_t n, T1 *src, T2 *dst )
1362  {
1363  if( IsSameType<T1, T2>::value )
1364  {
1365  if( src != (T1 *)dst )
1366  {
1367  daal::services::daal_memcpy_s(dst, n * p * sizeof(T1), src, n * p * sizeof(T1));
1368  }
1369  }
1370  else
1371  {
1372  size_t i, j;
1373 
1374  for(i = 0; i < n; i++)
1375  {
1376  for(j = 0; j < p; j++)
1377  {
1378  dst[i * p + j] = static_cast<T2>(src[i * p + j]);
1379  }
1380  }
1381  }
1382  }
1383 
1384  template<typename T1, typename T2>
1385  void internal_set_col_repack( size_t p, size_t n, T1 *src, T2 *dst )
1386  {
1387  size_t i;
1388 
1389  for(i = 0; i < n; i++)
1390  {
1391  dst[i * p] = static_cast<T2>(src[i]);
1392  }
1393  }
1394 
1395 protected:
1396  baseDataType &getBaseValue( size_t dim, size_t rowIdx, size_t colIdx, baseDataType &zero )
1397  {
1398  size_t offset;
1399 
1400  if( packedLayout == upperPackedTriangularMatrix )
1401  {
1402  if( colIdx < rowIdx )
1403  {
1404  return zero;
1405  }
1406 
1407  offset = (2 * dim - rowIdx) * (rowIdx + 1) / 2 - (dim - colIdx);
1408  }
1409  else /* here lowerPackedTriangularMatrix is supposed */
1410  {
1411  if( colIdx > rowIdx )
1412  {
1413  return zero;
1414  }
1415 
1416  offset = (2 + rowIdx) * (rowIdx + 1) / 2 - (rowIdx - colIdx) - 1;
1417  }
1418  return *((DataType*)_ptr.get() + offset);
1419  }
1420 
1421  template <typename T>
1422  T getValue( size_t dim, size_t rowIdx, size_t colIdx )
1423  {
1424  baseDataType zero = (baseDataType)0;
1425  return static_cast<T>( getBaseValue( dim, rowIdx, colIdx, zero ) );
1426  }
1427 
1428  template <typename T>
1429  services::Status setValue( size_t dim, size_t rowIdx, size_t colIdx, T value )
1430  {
1431  baseDataType zero = (baseDataType)0;
1432  getBaseValue( dim, rowIdx, colIdx, zero ) = static_cast<baseDataType>( value );
1433  return services::Status();
1434  }
1435 
1436  template <typename T>
1437  services::Status getTBlock(size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T> &block)
1438  {
1439  size_t nDim = getNumberOfColumns();
1440  block.setDetails( 0, idx, rwFlag );
1441 
1442  if (idx >= nDim)
1443  {
1444  block.resizeBuffer( nDim, 0 );
1445  return services::Status();
1446  }
1447 
1448  nrows = ( idx + nrows < nDim ) ? nrows : nDim - idx;
1449 
1450  if( !block.resizeBuffer( nDim, nrows ) )
1451  return services::Status(services::ErrorMemoryAllocationFailed);
1452 
1453  if((rwFlag & (int)readOnly))
1454  {
1455  T *buffer = block.getBlockPtr();
1456 
1457  for(size_t iRow = 0; iRow < nrows; iRow++)
1458  {
1459  for(size_t iCol = 0; iCol < nDim; iCol++)
1460  {
1461  buffer[iRow * nDim + iCol] = getValue<T>(nDim, iRow + idx, iCol);
1462  }
1463  }
1464  }
1465  return services::Status();
1466  }
1467 
1468  template <typename T>
1469  services::Status releaseTBlock( BlockDescriptor<T> &block )
1470  {
1471  services::Status s;
1472  if(block.getRWFlag() & (int)writeOnly)
1473  {
1474  size_t nDim = getNumberOfColumns();
1475  size_t nrows = block.getNumberOfRows();
1476  size_t idx = block.getRowsOffset();
1477  T *buffer = block.getBlockPtr();
1478 
1479  for( size_t iRow = 0; iRow < nrows; iRow++ )
1480  {
1481  for( size_t iCol = 0; iCol < nDim; iCol++ )
1482  {
1483  s |= setValue<T>( nDim, iRow + idx, iCol, buffer[ iRow * nDim + iCol ] );
1484  }
1485  }
1486  }
1487  block.reset();
1488  return s;
1489  }
1490 
1491  template <typename T>
1492  services::Status getTFeature(size_t feat_idx, size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T> &block)
1493  {
1494  size_t nDim = getNumberOfColumns();
1495  block.setDetails( feat_idx, idx, rwFlag );
1496 
1497  if (idx >= nDim)
1498  {
1499  block.resizeBuffer( nDim, 0 );
1500  return services::Status();
1501  }
1502 
1503  nrows = ( idx + nrows < nDim ) ? nrows : nDim - idx;
1504 
1505  if( !block.resizeBuffer( 1, nrows ) )
1506  return services::Status();
1507 
1508  if((block.getRWFlag() & (int)readOnly))
1509  {
1510  T *buffer = block.getBlockPtr();
1511  for( size_t iRow = 0; iRow < nrows; iRow++ )
1512  {
1513  buffer[ iRow ] = getValue<T>( nDim, iRow + idx, feat_idx );
1514  }
1515  }
1516  return services::Status();
1517  }
1518 
1519  template <typename T>
1520  services::Status releaseTFeature( BlockDescriptor<T> &block )
1521  {
1522  services::Status s;
1523  if (block.getRWFlag() & (int)writeOnly)
1524  {
1525  size_t nDim = getNumberOfColumns();
1526  size_t nrows = block.getNumberOfRows();
1527  size_t idx = block.getRowsOffset();
1528  size_t feat_idx = block.getColumnsOffset();
1529  T *buffer = block.getBlockPtr();
1530 
1531  for( size_t iRow = 0; iRow < nrows; iRow++ )
1532  {
1533  s |= setValue<T>( nDim, iRow + idx, feat_idx, buffer[ iRow ] );
1534  }
1535  }
1536  block.reset();
1537  return s;
1538  }
1539 
1540  template <typename T>
1541  services::Status getTPackedArray( int rwFlag, BlockDescriptor<T> &block )
1542  {
1543  size_t nDim = getNumberOfColumns();
1544  block.setDetails( 0, 0, rwFlag );
1545 
1546  size_t nSize = (nDim * (nDim + 1)) / 2;
1547 
1548  if( IsSameType<T, DataType>::value )
1549  {
1550  block.setPtr( &_ptr, _ptr.get(), 1, nSize );
1551  return services::Status();
1552  }
1553 
1554  if( !block.resizeBuffer( 1, nSize ) ) return services::Status();
1555 
1556  if( !(rwFlag & (int)readOnly) ) return services::Status();
1557 
1558  T *buffer = block.getBlockPtr();
1559  DataType * ptr = (DataType*)_ptr.get();
1560  for( size_t i = 0; i < nSize; i++ )
1561  {
1562  buffer[ i ] = static_cast<T>(*(ptr + i));
1563  }
1564  return services::Status();
1565  }
1566 
1567  template <typename T>
1568  services::Status releaseTPackedArray( BlockDescriptor<T> &block )
1569  {
1570  if( (block.getRWFlag() & (int)writeOnly) && !IsSameType<T, DataType>::value )
1571  {
1572  size_t nDim = getNumberOfColumns();
1573  size_t nSize = (nDim * (nDim + 1)) / 2;
1574  T *buffer = block.getBlockPtr();
1575  DataType * ptr = (DataType*)_ptr.get();
1576 
1577  for( size_t i = 0; i < nSize; i++ )
1578  {
1579  *(ptr + i) = static_cast<baseDataType>(buffer[ i ]);
1580  }
1581  }
1582  block.reset();
1583  return services::Status();
1584  }
1585 
1586  virtual services::Status setNumberOfColumnsImpl(size_t nDim) DAAL_C11_OVERRIDE
1587  {
1588  if( _ddict->getNumberOfFeatures() != nDim )
1589  {
1590  _ddict->setNumberOfFeatures( nDim );
1591 
1592  NumericTableFeature df;
1593  df.setType<DataType>();
1594  _ddict->setAllFeatures(df);
1595  }
1596 
1597  _obsnum = nDim;
1598  return services::Status();
1599  }
1600 
1601  virtual services::Status setNumberOfRowsImpl(size_t nDim) DAAL_C11_OVERRIDE
1602  {
1603  setNumberOfColumnsImpl( nDim );
1604  _obsnum = nDim;
1605  return services::Status();
1606  }
1607 };
1609 } // namespace interface1
1610 using interface1::PackedArrayNumericTableIface;
1611 using interface1::PackedSymmetricMatrix;
1612 using interface1::PackedTriangularMatrix;
1613 
1614 }
1615 } // namespace daal
1616 #endif
daal::data_management::interface1::PackedSymmetricMatrix::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: symmetric_matrix.h:444
daal::data_management::interface1::PackedTriangularMatrix::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: symmetric_matrix.h:1245
daal::data_management::interface1::NumericTableIface::AllocationFlag
AllocationFlag
Enumeration to specify whether the Numeric Table must allocate memory.
Definition: numeric_table.h:283
daal::data_management::interface1::PackedTriangularMatrix::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: symmetric_matrix.h:1240
daal::data_management::interface1::PackedSymmetricMatrix::getArray
DataType * getArray() const
Definition: symmetric_matrix.h:333
daal::data_management::interface1::PackedSymmetricMatrix::releasePackedArray
services::Status releasePackedArray(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:486
daal
Definition: algorithm_base_common.h:31
daal::data_management::interface1::InputDataArchive
Provides methods to create an archive data object (serialized) and access this object.
Definition: data_archive.h:689
daal::data_management::interface1::PackedSymmetricMatrix::getBlockOfRows
services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:417
daal::data_management::interface1::PackedTriangularMatrix::PackedTriangularMatrix
PackedTriangularMatrix(DataType *const ptr=0, size_t nDim=0)
Definition: symmetric_matrix.h:871
daal::data_management::interface1::PackedSymmetricMatrix::releasePackedArray
services::Status releasePackedArray(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:482
daal::data_management::interface1::PackedSymmetricMatrix::getBlockOfRows
services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:413
daal::data_management::interface1::PackedSymmetricMatrix::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: symmetric_matrix.h:449
daal::data_management::interface1::PackedTriangularMatrix::setArray
services::Status setArray(DataType *const ptr)
Definition: symmetric_matrix.h:1152
daal::data_management::interface1::PackedSymmetricMatrix::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:463
daal::data_management::interface1::PackedTriangularMatrix::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1260
daal::data_management::interface1::PackedSymmetricMatrix::setArray
services::Status setArray(DataType *const ptr)
Definition: symmetric_matrix.h:351
daal::data_management::interface1::PackedTriangularMatrix::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: symmetric_matrix.h:1250
daal::data_management::interface1::PackedArrayNumericTableIface
Abstract class that defines the interface of symmetric matrices stored as a one-dimensional array...
Definition: symmetric_matrix.h:46
daal::data_management::interface1::PackedSymmetricMatrix::PackedSymmetricMatrix
PackedSymmetricMatrix(size_t nDim, NumericTable::AllocationFlag memoryAllocationFlag, const DataType &constValue)
Definition: symmetric_matrix.h:294
daal::data_management::interface1::PackedTriangularMatrix::getPackedArray
services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1269
daal::data_management::interface1::PackedTriangularMatrix::baseDataType
DataType baseDataType
Definition: symmetric_matrix.h:863
daal::data_management::interface1::PackedSymmetricMatrix::setArray
services::Status setArray(const services::SharedPtr< DataType > &ptr)
Definition: symmetric_matrix.h:366
daal::data_management::interface1::PackedTriangularMatrix::releasePackedArray
services::Status releasePackedArray(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1282
daal::data_management::interface1::PackedTriangularMatrix::PackedTriangularMatrix
PackedTriangularMatrix(DataType *const ptr, size_t nDim, const DataType &constValue)
Definition: symmetric_matrix.h:940
daal::services::ErrorMemoryAllocationFailed
Definition: error_indexes.h:147
daal::dram
Definition: daal_defines.h:147
daal::data_management::interface1::PackedTriangularMatrix::getPackedArray
services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1277
daal::data_management::interface1::PackedTriangularMatrix::PackedTriangularMatrix
PackedTriangularMatrix(const services::SharedPtr< DataType > &ptr, size_t nDim)
Definition: symmetric_matrix.h:887
daal::data_management::interface1::PackedTriangularMatrix::getArray
DataType * getArray() const
Definition: symmetric_matrix.h:1134
daal::data_management::interface1::PackedSymmetricMatrix::getPackedArray
services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:469
daal::services::ErrorIncorrectNumberOfFeatures
Definition: error_indexes.h:70
daal::data_management::interface1::PackedSymmetricMatrix::baseDataType
DataType baseDataType
Definition: symmetric_matrix.h:115
daal::data_management::interface1::PackedSymmetricMatrix::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:426
daal_defines.h
daal::data_management::interface1::PackedSymmetricMatrix::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:455
daal::data_management::interface1::PackedTriangularMatrix::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1264
daal::data_management::interface1::PackedSymmetricMatrix::getBlockOfRows
services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:421
daal::data_management::interface1::PackedSymmetricMatrix::getArraySharedPtr
services::SharedPtr< DataType > getArraySharedPtr() const
Definition: symmetric_matrix.h:342
daal::data_management::interface1::PackedSymmetricMatrix::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: symmetric_matrix.h:439
daal::data_management::interface1::PackedTriangularMatrix::getPackedArray
services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1273
daal::data_management::interface1::PackedTriangularMatrix::setNumberOfRows
virtual services::Status setNumberOfRows(size_t nDim) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1125
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::PackedTriangularMatrix::assign
virtual services::Status assign(double value) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1207
daal::data_management::interface1::PackedTriangularMatrix::setArray
services::Status setArray(const services::SharedPtr< DataType > &ptr)
Definition: symmetric_matrix.h:1167
daal::data_management::interface1::PackedTriangularMatrix::assign
virtual services::Status assign(int value) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1212
daal::data_management::interface1::PackedSymmetricMatrix::PackedSymmetricMatrix
PackedSymmetricMatrix(DataType *const ptr=0, size_t nDim=0)
Definition: symmetric_matrix.h:124
daal::services::daal_malloc
DAAL_EXPORT void * daal_malloc(size_t size, size_t alignment=DAAL_MALLOC_DEFAULT_ALIGNMENT)
daal::data_management::interface1::PackedSymmetricMatrix
Class that provides methods to access symmetric matrices stored as a one-dimensional array...
Definition: symmetric_matrix.h:106
daal::data_management::interface1::PackedSymmetricMatrix::getPackedArray
services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:477
daal::data_management::interface1::PackedTriangularMatrix::setNumberOfColumns
virtual services::Status setNumberOfColumns(size_t nDim) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1110
daal::data_management::interface1::NumericTable
Class for a data management component responsible for representation of data in the numeric format...
Definition: numeric_table.h:575
daal::data_management::interface1::PackedSymmetricMatrix::PackedSymmetricMatrix
PackedSymmetricMatrix(const services::SharedPtr< DataType > &ptr, size_t nDim)
Definition: symmetric_matrix.h:141
daal::data_management::interface1::PackedSymmetricMatrix::PackedSymmetricMatrix
PackedSymmetricMatrix(size_t nDim, AllocationFlag memoryAllocationFlag)
Definition: symmetric_matrix.h:262
daal::data_management::interface1::PackedTriangularMatrix::getBlockOfRows
services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1222
daal::data_management::interface1::PackedSymmetricMatrix::assign
services::Status assign(T value)
Definition: symmetric_matrix.h:382
daal::data_management::interface1::PackedSymmetricMatrix::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:434
daal::data_management::interface1::PackedSymmetricMatrix::create
static services::SharedPtr< PackedSymmetricMatrix > create(DataType *const ptr, size_t nDim, const DataType &constValue, services::Status *stat=NULL)
Definition: symmetric_matrix.h:236
daal::data_management::interface1::PackedSymmetricMatrix::PackedSymmetricMatrix
PackedSymmetricMatrix(DataType *const ptr, size_t nDim, const DataType &constValue)
Definition: symmetric_matrix.h:195
daal::data_management::interface1::PackedSymmetricMatrix::assign
virtual services::Status assign(int value) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:411
daal::data_management::interface1::PackedSymmetricMatrix::create
static services::SharedPtr< PackedSymmetricMatrix > create(DataType *const ptr=0, size_t nDim=0, services::Status *stat=NULL)
Definition: symmetric_matrix.h:169
daal::data_management::interface1::PackedTriangularMatrix::assign
virtual services::Status assign(float value) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1202
daal::data_management::interface1::PackedSymmetricMatrix::assign
virtual services::Status assign(double value) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:406
daal::data_management::interface1::PackedSymmetricMatrix::create
static services::SharedPtr< PackedSymmetricMatrix > create(const services::SharedPtr< DataType > &ptr, size_t nDim, const DataType &constValue, services::Status *stat=NULL)
Definition: symmetric_matrix.h:250
daal::data_management::interface1::PackedTriangularMatrix::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1227
daal::data_management::interface1::PackedTriangularMatrix::getBlockOfRows
services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1218
daal::data_management::interface1::PackedSymmetricMatrix::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:459
daal::data_management::interface1::PackedSymmetricMatrix::create
static services::SharedPtr< PackedSymmetricMatrix > create(const services::SharedPtr< DataType > &ptr, size_t nDim, services::Status *stat=NULL)
Definition: symmetric_matrix.h:182
daal::data_management::interface1::PackedSymmetricMatrix::getPackedArray
services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:473
daal::data_management::interface1::PackedTriangularMatrix::PackedTriangularMatrix
PackedTriangularMatrix(const services::SharedPtr< DataType > &ptr, size_t nDim, const DataType &constValue)
Definition: symmetric_matrix.h:959
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::algorithms::math::abs::value
Definition: abs_types.h:86
daal::data_management::interface1::NumericTableFeature::setType
void setType()
Definition: data_dictionary.h:94
daal::data_management::interface1::PackedSymmetricMatrix::create
static services::SharedPtr< PackedSymmetricMatrix > create(size_t nDim, AllocationFlag memoryAllocationFlag, services::Status *stat=NULL)
Definition: symmetric_matrix.h:281
daal::services::ErrorIncorrectNumberOfObservations
Definition: error_indexes.h:71
daal::algorithms::implicit_als::training::offset
Definition: implicit_als_training_types.h:148
daal::data_management::interface1::PackedSymmetricMatrix::PackedSymmetricMatrix
PackedSymmetricMatrix(const services::SharedPtr< DataType > &ptr, size_t nDim, const DataType &constValue)
Definition: symmetric_matrix.h:215
daal::data_management::interface1::PackedArrayNumericTableIface::getPackedArray
virtual services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor< double > &block)=0
daal::data_management::interface1::PackedTriangularMatrix::assign
services::Status assign(T value)
Definition: symmetric_matrix.h:1183
daal::data_management::interface1::PackedSymmetricMatrix::releasePackedArray
services::Status releasePackedArray(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:490
daal::data_management::interface1::PackedTriangularMatrix
Class that provides methods to access a packed triangular matrix stored as a one-dimensional array...
Definition: symmetric_matrix.h:855
daal::data_management::interface1::PackedTriangularMatrix::getArraySharedPtr
services::SharedPtr< DataType > getArraySharedPtr() const
Definition: symmetric_matrix.h:1143
daal::data_management::interface1::PackedTriangularMatrix::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1231
daal::data_management::interface1::PackedTriangularMatrix::getBlockOfRows
services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1214
daal::data_management::interface1::PackedSymmetricMatrix::create
static services::SharedPtr< PackedSymmetricMatrix > create(size_t nDim, NumericTable::AllocationFlag memoryAllocationFlag, const DataType &constValue, services::Status *stat=NULL)
Definition: symmetric_matrix.h:316
daal::data_management::interface1::NumericTableFeature
Data structure describes the Numeric Table feature.
Definition: data_dictionary.h:51
daal::data_management::interface1::PackedSymmetricMatrix::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:430
daal::data_management::interface1::PackedTriangularMatrix::releasePackedArray
services::Status releasePackedArray(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1290
daal::MemType
MemType
Definition: daal_defines.h:145
daal::data_management::interface1::PackedTriangularMatrix::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1256
daal::services::ErrorEmptyHomogenNumericTable
Definition: error_indexes.h:162
daal::data_management::interface1::PackedTriangularMatrix::PackedTriangularMatrix
PackedTriangularMatrix(size_t nDim, AllocationFlag memoryAllocationFlag)
Definition: symmetric_matrix.h:1019
daal::data_management::interface1::PackedArrayNumericTableIface::releasePackedArray
virtual services::Status releasePackedArray(BlockDescriptor< double > &block)=0
daal::data_management::interface1::PackedTriangularMatrix::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1235
daal::data_management::interface1::PackedTriangularMatrix::releasePackedArray
services::Status releasePackedArray(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1286
daal::data_management::interface1::PackedTriangularMatrix::PackedTriangularMatrix
PackedTriangularMatrix(size_t nDim, NumericTable::AllocationFlag memoryAllocationFlag, const DataType &constValue)
Definition: symmetric_matrix.h:1063
daal::data_management::interface1::PackedSymmetricMatrix::assign
virtual services::Status assign(float value) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:401

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