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

symmetric_matrix.h
1 /* file: symmetric_matrix.h */
2 /*******************************************************************************
3 * Copyright 2014-2018 Intel Corporation.
4 *
5 * This software and the related documents are Intel copyrighted materials, and
6 * your use of them is governed by the express license under which they were
7 * provided to you (License). Unless the License provides otherwise, you may not
8 * use, modify, copy, publish, distribute, disclose or transmit this software or
9 * the related documents without Intel's prior written permission.
10 *
11 * This software and the related documents are provided as is, with no express
12 * or implied warranties, other than those that are expressly stated in the
13 * License.
14 *******************************************************************************/
15 
16 /*
17 //++
18 // 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 rowStartOffset, colStartOffset;
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  rowStartOffset = ((2 * dim - 1 * (rowIdx - 1)) * rowIdx) / 2; /* Arithmetic progression sum */
646  colStartOffset = colIdx - rowIdx;
647  }
648  else /* here lowerPackedSymmetricMatrix is supposed */
649  {
650  if( colIdx > rowIdx )
651  {
652  size_t tmp;
653  tmp = colIdx;
654  colIdx = rowIdx;
655  rowIdx = tmp;
656  }
657 
658  rowStartOffset = ((2 + 1 * (rowIdx - 1)) * rowIdx) / 2; /* Arithmetic progression sum */
659  colStartOffset = colIdx;
660 
661  }
662  return *((DataType*)_ptr.get() + rowStartOffset + colStartOffset);
663  }
664 
665  template <typename T>
666  T getValue( size_t dim, size_t rowIdx, size_t colIdx )
667  {
668  return static_cast<T>( getBaseValue( dim, rowIdx, colIdx ) );
669  }
670 
671  template <typename T>
672  services::Status setValue( size_t dim, size_t rowIdx, size_t colIdx, T value )
673  {
674  getBaseValue( dim, rowIdx, colIdx ) = static_cast<baseDataType>( value );
675  return services::Status();
676  }
677 
678  template <typename T>
679  services::Status getTBlock(size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T> &block)
680  {
681  size_t nDim = getNumberOfColumns();
682  block.setDetails( 0, idx, rwFlag );
683 
684  if (idx >= nDim)
685  {
686  block.resizeBuffer( nDim, 0 );
687  return services::Status();
688  }
689 
690  nrows = ( idx + nrows < nDim ) ? nrows : nDim - idx;
691 
692  if( !block.resizeBuffer( nDim, nrows ) )
693  return services::Status(services::ErrorMemoryAllocationFailed);
694 
695  if((rwFlag & (int)readOnly))
696  {
697  T *buffer = block.getBlockPtr();
698 
699  for(size_t iRow = 0; iRow < nrows; iRow++)
700  {
701  for(size_t iCol = 0; iCol < nDim; iCol++)
702  {
703  buffer[iRow * nDim + iCol] = getValue<T>(nDim, iRow + idx, iCol);
704  }
705  }
706  }
707  return services::Status();
708  }
709 
710  template <typename T>
711  services::Status releaseTBlock( BlockDescriptor<T> &block )
712  {
713  services::Status s;
714  if(block.getRWFlag() & (int)writeOnly)
715  {
716  size_t nDim = getNumberOfColumns();
717  size_t nrows = block.getNumberOfRows();
718  size_t idx = block.getRowsOffset();
719  T *buffer = block.getBlockPtr();
720 
721  for( size_t iRow = 0; iRow < nrows; iRow++ )
722  {
723  for( size_t iCol = 0; iCol < nDim; iCol++ )
724  {
725  s |= setValue<T>( nDim, idx + iRow, iCol, buffer[ iRow * nDim + iCol ] );
726  }
727  }
728  }
729  block.reset();
730  return s;
731  }
732 
733  template <typename T>
734  services::Status getTFeature(size_t feat_idx, size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T> &block)
735  {
736  size_t nDim = getNumberOfColumns();
737  block.setDetails( feat_idx, idx, rwFlag );
738 
739  if (idx >= nDim)
740  {
741  block.resizeBuffer( nDim, 0 );
742  return services::Status();
743  }
744 
745  nrows = ( idx + nrows < nDim ) ? nrows : nDim - idx;
746 
747  if( !block.resizeBuffer( 1, nrows ) )
748  return services::Status();
749 
750  if((block.getRWFlag() & (int)readOnly))
751  {
752  T *buffer = block.getBlockPtr();
753 
754  for(size_t iRow = 0; iRow < nrows; iRow++)
755  {
756  buffer[iRow] = getValue<T>(nDim, iRow + idx, feat_idx);
757  }
758  }
759  return services::Status();
760  }
761 
762  template <typename T>
763  services::Status releaseTFeature( BlockDescriptor<T> &block )
764  {
765  services::Status s;
766  if (block.getRWFlag() & (int)writeOnly)
767  {
768  size_t nDim = getNumberOfColumns();
769  size_t nrows = block.getNumberOfRows();
770  size_t idx = block.getRowsOffset();
771  size_t feat_idx = block.getColumnsOffset();
772  T *buffer = block.getBlockPtr();
773 
774  for( size_t iRow = 0; iRow < nrows; iRow++ )
775  {
776  s |= setValue<T>( nDim, iRow + idx, feat_idx, buffer[ iRow ] );
777  }
778  }
779  block.reset();
780  return s;
781  }
782 
783  template <typename T>
784  services::Status getTPackedArray( int rwFlag, BlockDescriptor<T> &block )
785  {
786  size_t nDim = getNumberOfColumns();
787  block.setDetails( 0, 0, rwFlag );
788 
789  size_t nSize = (nDim * (nDim + 1)) / 2;
790 
791  if( IsSameType<T, DataType>::value )
792  {
793  block.setPtr( &_ptr, _ptr.get(), 1, nSize );
794  return services::Status();
795  }
796 
797  if( !block.resizeBuffer( 1, nSize ) ) return services::Status();
798 
799  if( !(rwFlag & (int)readOnly) ) return services::Status();
800 
801  T *buffer = block.getBlockPtr();
802  DataType * ptr = (DataType*) _ptr.get();
803  for( size_t i = 0; i < nSize; i++ )
804  {
805  buffer[ i ] = static_cast<T>(*(ptr + i));
806  }
807  return services::Status();
808  }
809 
810  template <typename T>
811  services::Status releaseTPackedArray( BlockDescriptor<T> &block )
812  {
813  if( (block.getRWFlag() & (int)writeOnly) && !IsSameType<T, DataType>::value )
814  {
815  size_t nDim = getNumberOfColumns();
816  size_t nSize = (nDim * (nDim + 1)) / 2;
817  T *buffer = block.getBlockPtr();
818  DataType * ptr = (DataType*) _ptr.get();
819 
820  for( size_t i = 0; i < nSize; i++ )
821  {
822  *(ptr + i) = static_cast<baseDataType>(buffer[ i ]);
823  }
824  }
825  block.reset();
826  return services::Status();
827  }
828 
829  virtual services::Status setNumberOfColumnsImpl(size_t nDim) DAAL_C11_OVERRIDE
830  {
831  if( _ddict->getNumberOfFeatures() != nDim )
832  {
833  _ddict->setNumberOfFeatures( nDim );
834 
835  NumericTableFeature df;
836  df.setType<DataType>();
837  _ddict->setAllFeatures(df);
838  }
839 
840  _obsnum = nDim;
841  return services::Status();
842  }
843 
844  virtual services::Status setNumberOfRowsImpl(size_t nDim) DAAL_C11_OVERRIDE
845  {
846  setNumberOfColumnsImpl( nDim );
847  _obsnum = nDim;
848  return services::Status();
849  }
850 };
851 
857 template<NumericTableIface::StorageLayout packedLayout, typename DataType = DAAL_DATA_TYPE>
858 class DAAL_EXPORT PackedTriangularMatrix : public NumericTable, public PackedArrayNumericTableIface
859 {
860 public:
861  DECLARE_SERIALIZABLE_TAG();
862 
866  typedef DataType baseDataType;
867 
868 public:
874  PackedTriangularMatrix( DataType *const ptr = 0, size_t nDim = 0 ):
875  NumericTable( nDim, nDim )
876  {
877  _layout = packedLayout;
878  this->_status |= setArray( services::SharedPtr<DataType>(ptr, services::EmptyDeleter()) );
879 
880  NumericTableFeature df;
881  df.setType<DataType>();
882  this->_status |= _ddict->setAllFeatures(df);
883  }
884 
890  PackedTriangularMatrix( const services::SharedPtr<DataType> &ptr, size_t nDim ):
891  NumericTable( nDim, nDim )
892  {
893  _layout = packedLayout;
894  this->_status |= setArray( ptr );
895 
896  NumericTableFeature df;
897  df.setType<DataType>();
898  this->_status |= _ddict->setAllFeatures(df);
899  }
900 
901  PackedTriangularMatrix( size_t nDim /*= 0*/ ):
902  NumericTable( nDim, nDim )
903  {
904  _layout = packedLayout;
905 
906  NumericTableFeature df;
907  df.setType<DataType>();
908  this->_status |= _ddict->setAllFeatures(df);
909  }
910 
911  static services::SharedPtr<PackedTriangularMatrix> create(DataType *const ptr = 0, size_t nDim = 0,
912  services::Status* stat = NULL)
913  {
914  return create(services::SharedPtr<DataType>(ptr, services::EmptyDeleter()), nDim, stat);
915  }
916 
917  static services::SharedPtr<PackedTriangularMatrix> create(const services::SharedPtr<DataType> &ptr, size_t nDim,
918  services::Status* stat = NULL)
919  {
920  services::SharedPtr<PackedTriangularMatrix> ntPtr(new PackedTriangularMatrix(nDim));
921  if(ntPtr.get())
922  {
923  services::Status s = ntPtr->setArray(ptr);
924  if(!s)
925  ntPtr = services::SharedPtr<PackedTriangularMatrix>();
926  if(stat)
927  *stat = s;
928  }
929  else
930  {
931  if(stat)
932  *stat = services::Status(services::ErrorMemoryAllocationFailed);
933  }
934  return ntPtr;
935  }
936 
943  PackedTriangularMatrix( DataType *const ptr, size_t nDim, const DataType &constValue ):
944  NumericTable( nDim, nDim )
945  {
946  _layout = packedLayout;
947  this->_status |= setArray( services::SharedPtr<DataType>(ptr, services::EmptyDeleter()) );
948 
949  NumericTableFeature df;
950  df.setType<DataType>();
951  this->_status |= _ddict->setAllFeatures(df);
952 
953  this->_status |= assign( constValue );
954  }
955 
962  PackedTriangularMatrix( const services::SharedPtr<DataType>& ptr, size_t nDim, const DataType &constValue ) :
963  NumericTable( nDim, nDim )
964  {
965  _layout = packedLayout;
966  this->_status |= setArray( ptr );
967 
968  NumericTableFeature df;
969  df.setType<DataType>();
970  this->_status |= _ddict->setAllFeatures(df);
971 
972  this->_status |= assign( constValue );
973  }
974 
975  static services::SharedPtr<PackedTriangularMatrix> create(DataType *const ptr, size_t nDim, const DataType &constValue,
976  services::Status* stat = NULL)
977  {
978  services::SharedPtr<PackedTriangularMatrix> ntPtr(new PackedTriangularMatrix(nDim));
979  if(ntPtr.get())
980  {
981  services::Status s = ntPtr->setArray( services::SharedPtr<DataType>(ptr, services::EmptyDeleter()) );
982  s.add(ntPtr->assign(constValue));
983  if(!s)
984  ntPtr = services::SharedPtr<PackedTriangularMatrix>();
985  if(stat)
986  *stat = s;
987  }
988  else
989  {
990  if(stat)
991  *stat = services::Status(services::ErrorMemoryAllocationFailed);
992  }
993  return ntPtr;
994  }
995 
996  static services::SharedPtr<PackedTriangularMatrix> create(services::SharedPtr<DataType> &ptr, size_t nDim, const DataType &constValue,
997  services::Status* stat = NULL)
998  {
999  services::SharedPtr<PackedTriangularMatrix> ntPtr(new PackedTriangularMatrix(nDim));
1000  if(ntPtr.get())
1001  {
1002  services::Status s = ntPtr->setArray(ptr);
1003  s.add(ntPtr->assign(constValue));
1004  if(!s)
1005  ntPtr = services::SharedPtr<PackedTriangularMatrix>();
1006  if(stat)
1007  *stat = s;
1008  }
1009  else
1010  {
1011  if(stat)
1012  *stat = services::Status(services::ErrorMemoryAllocationFailed);
1013  }
1014  return ntPtr;
1015  }
1016 
1022  PackedTriangularMatrix( size_t nDim, AllocationFlag memoryAllocationFlag ):
1023  NumericTable( nDim, nDim )
1024  {
1025  _layout = packedLayout;
1026 
1027  NumericTableFeature df;
1028  df.setType<DataType>();
1029  this->_status |= _ddict->setAllFeatures(df);
1030 
1031  if( memoryAllocationFlag == doAllocate ) this->_status |= allocateDataMemoryImpl();
1032  }
1033 
1034  static services::SharedPtr<PackedTriangularMatrix> create(size_t nDim, AllocationFlag memoryAllocationFlag,
1035  services::Status* stat = NULL)
1036  {
1037  services::SharedPtr<PackedTriangularMatrix> ntPtr(new PackedTriangularMatrix(nDim));
1038  if(ntPtr.get())
1039  {
1040  services::Status s;
1041  if(memoryAllocationFlag == doAllocate)
1042  {
1043  s = ntPtr->allocateDataMemoryImpl();
1044  if(!s)
1045  ntPtr = services::SharedPtr<PackedTriangularMatrix>();
1046  }
1047  if(!s)
1048  ntPtr = services::SharedPtr<PackedTriangularMatrix>();
1049  if(stat)
1050  *stat = s;
1051  }
1052  else
1053  {
1054  if(stat)
1055  *stat = services::Status(services::ErrorMemoryAllocationFailed);
1056  }
1057  return ntPtr;
1058  }
1059 
1066  PackedTriangularMatrix( size_t nDim, NumericTable::AllocationFlag memoryAllocationFlag,
1067  const DataType &constValue ):
1068  NumericTable( nDim, nDim )
1069  {
1070  _layout = packedLayout;
1071 
1072  NumericTableFeature df;
1073  df.setType<DataType>();
1074  this->_status |= _ddict->setAllFeatures(df);
1075 
1076  if( memoryAllocationFlag == doAllocate ) this->_status |= allocateDataMemoryImpl();
1077  this->_status |= assign(constValue);
1078  }
1079 
1080  static services::SharedPtr<PackedTriangularMatrix> create(size_t nDim, NumericTable::AllocationFlag memoryAllocationFlag,
1081  const DataType &constValue, services::Status* stat = NULL)
1082  {
1083  services::SharedPtr<PackedTriangularMatrix> ntPtr(new PackedTriangularMatrix(nDim));
1084  if(ntPtr.get())
1085  {
1086  services::Status s;
1087  if(memoryAllocationFlag == doAllocate)
1088  {
1089  s = ntPtr->allocateDataMemoryImpl();
1090  s.add(ntPtr->assign(constValue));
1091  if(!s)
1092  ntPtr = services::SharedPtr<PackedTriangularMatrix>();
1093  }
1094  if(!s)
1095  ntPtr = services::SharedPtr<PackedTriangularMatrix>();
1096  if(stat)
1097  *stat = s;
1098  }
1099  else
1100  {
1101  if(stat)
1102  *stat = services::Status(services::ErrorMemoryAllocationFailed);
1103  }
1104  return ntPtr;
1105  }
1106 
1108  virtual ~PackedTriangularMatrix()
1109  {
1110  freeDataMemoryImpl();
1111  }
1112 
1113  virtual services::Status setNumberOfColumns(size_t nDim) DAAL_C11_OVERRIDE
1114  {
1115  if( _ddict->getNumberOfFeatures() != nDim )
1116  {
1117  _ddict->setNumberOfFeatures( nDim );
1118 
1119  NumericTableFeature df;
1120  df.setType<DataType>();
1121  _ddict->setAllFeatures(df);
1122  }
1123 
1124  _obsnum = nDim;
1125  return services::Status();
1126  }
1127 
1128  virtual services::Status setNumberOfRows(size_t nDim) DAAL_C11_OVERRIDE
1129  {
1130  return setNumberOfColumns( nDim );
1131  }
1132 
1137  DataType *getArray() const
1138  {
1139  return (DataType*)_ptr.get();
1140  }
1141 
1146  services::SharedPtr<DataType> getArraySharedPtr() const
1147  {
1148  return services::reinterpretPointerCast<DataType, byte>(_ptr);
1149  }
1150 
1155  services::Status setArray( DataType *const ptr )
1156  {
1157  freeDataMemoryImpl();
1158  if( ptr == 0 )
1159  return services::Status(services::ErrorEmptyHomogenNumericTable);
1160 
1161  _ptr = services::SharedPtr<byte>((DataType*)ptr, services::EmptyDeleter());
1162  _memStatus = userAllocated;
1163  return services::Status();
1164  }
1165 
1170  services::Status setArray( const services::SharedPtr<DataType>& ptr )
1171  {
1172  freeDataMemoryImpl();
1173  if( ptr == 0 )
1174  return services::Status(services::ErrorEmptyHomogenNumericTable);
1175 
1176  _ptr = services::reinterpretPointerCast<byte, DataType>(ptr);
1177  _memStatus = userAllocated;
1178  return services::Status();
1179  }
1180 
1185  template <typename T>
1186  services::Status assign(T value)
1187  {
1188  if( _memStatus == notAllocated )
1189  return services::Status(services::ErrorEmptyHomogenNumericTable);
1190 
1191  size_t nDim = getNumberOfColumns();
1192 
1193  DataType * ptr = (DataType*)_ptr.get();
1194  DataType valueDataType = (DataType)value;
1195  for( size_t i = 0; i < (nDim * (nDim + 1)) / 2 ; i++ )
1196  {
1197  ptr[i] = valueDataType;
1198  }
1199  return services::Status();
1200  }
1201 
1205  virtual services::Status assign(float value) DAAL_C11_OVERRIDE {return assign<DataType>((DataType)value);}
1206 
1210  virtual services::Status assign(double value) DAAL_C11_OVERRIDE {return assign<DataType>((DataType)value);}
1211 
1215  virtual services::Status assign(int value) DAAL_C11_OVERRIDE {return assign<DataType>((DataType)value);}
1216 
1217  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
1218  {
1219  return getTBlock<double>(vector_idx, vector_num, rwflag, block);
1220  }
1221  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
1222  {
1223  return getTBlock<float>(vector_idx, vector_num, rwflag, block);
1224  }
1225  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
1226  {
1227  return getTBlock<int>(vector_idx, vector_num, rwflag, block);
1228  }
1229 
1230  services::Status releaseBlockOfRows(BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
1231  {
1232  return releaseTBlock<double>(block);
1233  }
1234  services::Status releaseBlockOfRows(BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
1235  {
1236  return releaseTBlock<float>(block);
1237  }
1238  services::Status releaseBlockOfRows(BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
1239  {
1240  return releaseTBlock<int>(block);
1241  }
1242 
1243  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
1244  ReadWriteMode rwflag, BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
1245  {
1246  return getTFeature<double>(feature_idx, vector_idx, value_num, rwflag, block);
1247  }
1248  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
1249  ReadWriteMode rwflag, BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
1250  {
1251  return getTFeature<float>(feature_idx, vector_idx, value_num, rwflag, block);
1252  }
1253  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
1254  ReadWriteMode rwflag, BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
1255  {
1256  return getTFeature<int>(feature_idx, vector_idx, value_num, rwflag, block);
1257  }
1258 
1259  services::Status releaseBlockOfColumnValues(BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
1260  {
1261  return releaseTFeature<double>(block);
1262  }
1263  services::Status releaseBlockOfColumnValues(BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
1264  {
1265  return releaseTFeature<float>(block);
1266  }
1267  services::Status releaseBlockOfColumnValues(BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
1268  {
1269  return releaseTFeature<int>(block);
1270  }
1271 
1272  services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
1273  {
1274  return getTPackedArray<double>(rwflag, block);
1275  }
1276  services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
1277  {
1278  return getTPackedArray<float>(rwflag, block);
1279  }
1280  services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
1281  {
1282  return getTPackedArray<int>(rwflag, block);
1283  }
1284 
1285  services::Status releasePackedArray(BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
1286  {
1287  return releaseTPackedArray<double>(block);
1288  }
1289  services::Status releasePackedArray(BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
1290  {
1291  return releaseTPackedArray<float>(block);
1292  }
1293  services::Status releasePackedArray(BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
1294  {
1295  return releaseTPackedArray<int>(block);
1296  }
1297 
1299  services::Status serializeImpl (InputDataArchive *arch) DAAL_C11_OVERRIDE
1300  {
1301  serialImpl<InputDataArchive, false>( arch );
1302 
1303  return services::Status();
1304  }
1305 
1307  services::Status deserializeImpl(const OutputDataArchive *arch) DAAL_C11_OVERRIDE
1308  {
1309  serialImpl<const OutputDataArchive, true>( arch );
1310 
1311  return services::Status();
1312  }
1313 
1314 protected:
1315  services::SharedPtr<byte> _ptr;
1316 
1317  services::Status allocateDataMemoryImpl(daal::MemType type = daal::dram) DAAL_C11_OVERRIDE
1318  {
1319  freeDataMemoryImpl();
1320 
1321  size_t nDim = getNumberOfColumns();
1322  size_t size = (nDim * (nDim + 1)) / 2;
1323 
1324  if( size == 0 )
1325  return services::Status(getNumberOfColumns() == 0 ? services::ErrorIncorrectNumberOfFeatures :
1326  services::ErrorIncorrectNumberOfObservations);
1327 
1328  _ptr = services::SharedPtr<byte>((byte *)daal::services::daal_malloc( size * sizeof(DataType) ), services::ServiceDeleter());
1329 
1330  if( _ptr == 0 )
1331  return services::Status(services::ErrorMemoryAllocationFailed);
1332 
1333  _memStatus = internallyAllocated;
1334  return services::Status();
1335  }
1336 
1337  void freeDataMemoryImpl() DAAL_C11_OVERRIDE
1338  {
1339  _ptr.reset();
1340  _memStatus = notAllocated;
1341  }
1342 
1344  template<typename Archive, bool onDeserialize>
1345  services::Status serialImpl( Archive *arch )
1346  {
1347  NumericTable::serialImpl<Archive, onDeserialize>( arch );
1348 
1349  if( onDeserialize )
1350  {
1351  allocateDataMemoryImpl();
1352  }
1353 
1354  size_t nDim = getNumberOfColumns();
1355  size_t size = (nDim * (nDim + 1)) / 2;
1356 
1357  arch->set( (DataType*)_ptr.get(), size );
1358 
1359  return services::Status();
1360  }
1361 
1362 private:
1363  template<typename T1, typename T2>
1364  void internal_repack( size_t p, size_t n, T1 *src, T2 *dst )
1365  {
1366  if( IsSameType<T1, T2>::value )
1367  {
1368  if( src != (T1 *)dst )
1369  {
1370  daal::services::daal_memcpy_s(dst, n * p * sizeof(T1), src, n * p * sizeof(T1));
1371  }
1372  }
1373  else
1374  {
1375  size_t i, j;
1376 
1377  for(i = 0; i < n; i++)
1378  {
1379  for(j = 0; j < p; j++)
1380  {
1381  dst[i * p + j] = static_cast<T2>(src[i * p + j]);
1382  }
1383  }
1384  }
1385  }
1386 
1387  template<typename T1, typename T2>
1388  void internal_set_col_repack( size_t p, size_t n, T1 *src, T2 *dst )
1389  {
1390  size_t i;
1391 
1392  for(i = 0; i < n; i++)
1393  {
1394  dst[i * p] = static_cast<T2>(src[i]);
1395  }
1396  }
1397 
1398 protected:
1399  baseDataType &getBaseValue( size_t dim, size_t rowIdx, size_t colIdx, baseDataType &zero )
1400  {
1401  size_t rowStartOffset, colStartOffset;
1402 
1403  if( packedLayout == upperPackedTriangularMatrix )
1404  {
1405  if( colIdx < rowIdx )
1406  {
1407  return zero;
1408  }
1409 
1410  rowStartOffset = ((2 * dim - 1 * (rowIdx - 1)) * rowIdx) / 2; /* Arithmetic progression sum */
1411  colStartOffset = colIdx - rowIdx;
1412  }
1413  else /* here lowerPackedTriangularMatrix is supposed */
1414  {
1415  if( colIdx > rowIdx )
1416  {
1417  return zero;
1418  }
1419 
1420  rowStartOffset = ((2 + 1 * (rowIdx - 1)) * rowIdx) / 2; /* Arithmetic progression sum */
1421  colStartOffset = colIdx;
1422 
1423  }
1424  return *((DataType*)_ptr.get() + rowStartOffset + colStartOffset);
1425  }
1426 
1427  template <typename T>
1428  T getValue( size_t dim, size_t rowIdx, size_t colIdx )
1429  {
1430  baseDataType zero = (baseDataType)0;
1431  return static_cast<T>( getBaseValue( dim, rowIdx, colIdx, zero ) );
1432  }
1433 
1434  template <typename T>
1435  services::Status setValue( size_t dim, size_t rowIdx, size_t colIdx, T value )
1436  {
1437  baseDataType zero = (baseDataType)0;
1438  getBaseValue( dim, rowIdx, colIdx, zero ) = static_cast<baseDataType>( value );
1439  return services::Status();
1440  }
1441 
1442  template <typename T>
1443  services::Status getTBlock(size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T> &block)
1444  {
1445  size_t nDim = getNumberOfColumns();
1446  block.setDetails( 0, idx, rwFlag );
1447 
1448  if (idx >= nDim)
1449  {
1450  block.resizeBuffer( nDim, 0 );
1451  return services::Status();
1452  }
1453 
1454  nrows = ( idx + nrows < nDim ) ? nrows : nDim - idx;
1455 
1456  if( !block.resizeBuffer( nDim, nrows ) )
1457  return services::Status(services::ErrorMemoryAllocationFailed);
1458 
1459  if((rwFlag & (int)readOnly))
1460  {
1461  T *buffer = block.getBlockPtr();
1462 
1463  for(size_t iRow = 0; iRow < nrows; iRow++)
1464  {
1465  for(size_t iCol = 0; iCol < nDim; iCol++)
1466  {
1467  buffer[iRow * nDim + iCol] = getValue<T>(nDim, iRow + idx, iCol);
1468  }
1469  }
1470  }
1471  return services::Status();
1472  }
1473 
1474  template <typename T>
1475  services::Status releaseTBlock( BlockDescriptor<T> &block )
1476  {
1477  services::Status s;
1478  if(block.getRWFlag() & (int)writeOnly)
1479  {
1480  size_t nDim = getNumberOfColumns();
1481  size_t nrows = block.getNumberOfRows();
1482  size_t idx = block.getRowsOffset();
1483  T *buffer = block.getBlockPtr();
1484 
1485  for( size_t iRow = 0; iRow < nrows; iRow++ )
1486  {
1487  for( size_t iCol = 0; iCol < nDim; iCol++ )
1488  {
1489  s |= setValue<T>( nDim, iRow + idx, iCol, buffer[ iRow * nDim + iCol ] );
1490  }
1491  }
1492  }
1493  block.reset();
1494  return s;
1495  }
1496 
1497  template <typename T>
1498  services::Status getTFeature(size_t feat_idx, size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T> &block)
1499  {
1500  size_t nDim = getNumberOfColumns();
1501  block.setDetails( feat_idx, idx, rwFlag );
1502 
1503  if (idx >= nDim)
1504  {
1505  block.resizeBuffer( nDim, 0 );
1506  return services::Status();
1507  }
1508 
1509  nrows = ( idx + nrows < nDim ) ? nrows : nDim - idx;
1510 
1511  if( !block.resizeBuffer( 1, nrows ) )
1512  return services::Status();
1513 
1514  if((block.getRWFlag() & (int)readOnly))
1515  {
1516  T *buffer = block.getBlockPtr();
1517  for( size_t iRow = 0; iRow < nrows; iRow++ )
1518  {
1519  buffer[ iRow ] = getValue<T>( nDim, iRow + idx, feat_idx );
1520  }
1521  }
1522  return services::Status();
1523  }
1524 
1525  template <typename T>
1526  services::Status releaseTFeature( BlockDescriptor<T> &block )
1527  {
1528  services::Status s;
1529  if (block.getRWFlag() & (int)writeOnly)
1530  {
1531  size_t nDim = getNumberOfColumns();
1532  size_t nrows = block.getNumberOfRows();
1533  size_t idx = block.getRowsOffset();
1534  size_t feat_idx = block.getColumnsOffset();
1535  T *buffer = block.getBlockPtr();
1536 
1537  for( size_t iRow = 0; iRow < nrows; iRow++ )
1538  {
1539  s |= setValue<T>( nDim, iRow + idx, feat_idx, buffer[ iRow ] );
1540  }
1541  }
1542  block.reset();
1543  return s;
1544  }
1545 
1546  template <typename T>
1547  services::Status getTPackedArray( int rwFlag, BlockDescriptor<T> &block )
1548  {
1549  size_t nDim = getNumberOfColumns();
1550  block.setDetails( 0, 0, rwFlag );
1551 
1552  size_t nSize = (nDim * (nDim + 1)) / 2;
1553 
1554  if( IsSameType<T, DataType>::value )
1555  {
1556  block.setPtr( &_ptr, _ptr.get(), 1, nSize );
1557  return services::Status();
1558  }
1559 
1560  if( !block.resizeBuffer( 1, nSize ) ) return services::Status();
1561 
1562  if( !(rwFlag & (int)readOnly) ) return services::Status();
1563 
1564  T *buffer = block.getBlockPtr();
1565  DataType * ptr = (DataType*)_ptr.get();
1566  for( size_t i = 0; i < nSize; i++ )
1567  {
1568  buffer[ i ] = static_cast<T>(*(ptr + i));
1569  }
1570  return services::Status();
1571  }
1572 
1573  template <typename T>
1574  services::Status releaseTPackedArray( BlockDescriptor<T> &block )
1575  {
1576  if( (block.getRWFlag() & (int)writeOnly) && !IsSameType<T, DataType>::value )
1577  {
1578  size_t nDim = getNumberOfColumns();
1579  size_t nSize = (nDim * (nDim + 1)) / 2;
1580  T *buffer = block.getBlockPtr();
1581  DataType * ptr = (DataType*)_ptr.get();
1582 
1583  for( size_t i = 0; i < nSize; i++ )
1584  {
1585  *(ptr + i) = static_cast<baseDataType>(buffer[ i ]);
1586  }
1587  }
1588  block.reset();
1589  return services::Status();
1590  }
1591 
1592  virtual services::Status setNumberOfColumnsImpl(size_t nDim) DAAL_C11_OVERRIDE
1593  {
1594  if( _ddict->getNumberOfFeatures() != nDim )
1595  {
1596  _ddict->setNumberOfFeatures( nDim );
1597 
1598  NumericTableFeature df;
1599  df.setType<DataType>();
1600  _ddict->setAllFeatures(df);
1601  }
1602 
1603  _obsnum = nDim;
1604  return services::Status();
1605  }
1606 
1607  virtual services::Status setNumberOfRowsImpl(size_t nDim) DAAL_C11_OVERRIDE
1608  {
1609  setNumberOfColumnsImpl( nDim );
1610  _obsnum = nDim;
1611  return services::Status();
1612  }
1613 };
1615 } // namespace interface1
1616 using interface1::PackedArrayNumericTableIface;
1617 using interface1::PackedSymmetricMatrix;
1618 using interface1::PackedTriangularMatrix;
1619 
1620 }
1621 } // namespace daal
1622 #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:1248
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:1243
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:874
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:1155
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:1263
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:1253
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:1272
daal::data_management::interface1::PackedTriangularMatrix::baseDataType
DataType baseDataType
Definition: symmetric_matrix.h:866
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:1285
daal::data_management::interface1::PackedTriangularMatrix::PackedTriangularMatrix
PackedTriangularMatrix(DataType *const ptr, size_t nDim, const DataType &constValue)
Definition: symmetric_matrix.h:943
daal::services::ErrorMemoryAllocationFailed
Definition: error_indexes.h:146
daal::dram
Definition: daal_defines.h:133
daal::data_management::interface1::PackedTriangularMatrix::getPackedArray
services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1280
daal::data_management::interface1::PackedTriangularMatrix::PackedTriangularMatrix
PackedTriangularMatrix(const services::SharedPtr< DataType > &ptr, size_t nDim)
Definition: symmetric_matrix.h:890
daal::data_management::interface1::PackedTriangularMatrix::getArray
DataType * getArray() const
Definition: symmetric_matrix.h:1137
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:1267
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:1276
daal::data_management::interface1::PackedTriangularMatrix::setNumberOfRows
virtual services::Status setNumberOfRows(size_t nDim) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1128
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:1210
daal::data_management::interface1::PackedTriangularMatrix::setArray
services::Status setArray(const services::SharedPtr< DataType > &ptr)
Definition: symmetric_matrix.h:1170
daal::data_management::interface1::PackedTriangularMatrix::assign
virtual services::Status assign(int value) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1215
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:1113
daal::data_management::interface1::NumericTable
Class for a data management component responsible for representation of data in the numeric format...
Definition: numeric_table.h:574
daal::data_management::interface1::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:1225
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:1205
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:1230
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:1221
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:962
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:91
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::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:1186
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:858
daal::data_management::interface1::PackedTriangularMatrix::getArraySharedPtr
services::SharedPtr< DataType > getArraySharedPtr() const
Definition: symmetric_matrix.h:1146
daal::data_management::interface1::PackedTriangularMatrix::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1234
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:1217
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:48
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:1293
daal::MemType
MemType
Definition: daal_defines.h:131
daal::data_management::interface1::PackedTriangularMatrix::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1259
daal::services::ErrorEmptyHomogenNumericTable
Definition: error_indexes.h:161
daal::data_management::interface1::PackedTriangularMatrix::PackedTriangularMatrix
PackedTriangularMatrix(size_t nDim, AllocationFlag memoryAllocationFlag)
Definition: symmetric_matrix.h:1022
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:1238
daal::data_management::interface1::PackedTriangularMatrix::releasePackedArray
services::Status releasePackedArray(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1289
daal::data_management::interface1::PackedTriangularMatrix::PackedTriangularMatrix
PackedTriangularMatrix(size_t nDim, NumericTable::AllocationFlag memoryAllocationFlag, const DataType &constValue)
Definition: symmetric_matrix.h:1066
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.