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

symmetric_matrix.h
1 /* file: symmetric_matrix.h */
2 /*******************************************************************************
3 * Copyright 2014-2020 Intel Corporation
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *******************************************************************************/
17 
18 /*
19 //++
20 // Declaration and implementation of a symmetric matrix.
21 //--
22 */
23 
24 
25 #ifndef __SYMMETRIC_MATRIX_H__
26 #define __SYMMETRIC_MATRIX_H__
27 
28 #include "services/daal_memory.h"
29 #include "services/daal_defines.h"
30 
31 #include "data_management/data/data_serialize.h"
32 #include "data_management/data/numeric_table.h"
33 
34 namespace daal
35 {
36 namespace data_management
37 {
38 
39 namespace interface1
40 {
49 class PackedArrayNumericTableIface
50 {
51 public:
52  virtual ~PackedArrayNumericTableIface()
53  {}
62  virtual services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor<double> &block) = 0;
63 
72  virtual services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor<float> &block) = 0;
73 
82  virtual services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor<int> &block) = 0;
83 
88  virtual services::Status releasePackedArray(BlockDescriptor<double> &block) = 0;
89 
94  virtual services::Status releasePackedArray(BlockDescriptor<float> &block) = 0;
95 
100  virtual services::Status releasePackedArray(BlockDescriptor<int> &block) = 0;
101 };
102 
108 template<NumericTableIface::StorageLayout packedLayout, typename DataType = DAAL_DATA_TYPE>
109 class DAAL_EXPORT PackedSymmetricMatrix : public NumericTable, public PackedArrayNumericTableIface
110 {
111 public:
112  DECLARE_SERIALIZABLE_TAG();
113  DECLARE_SERIALIZABLE_IMPL();
114 
118  typedef DataType baseDataType;
119 
120 public:
127  PackedSymmetricMatrix( DataType *const ptr = 0, size_t nDim = 0 ):
128  NumericTable( nDim, nDim )
129  {
130  _layout = packedLayout;
131  this->_status |= setArray( services::SharedPtr<DataType>(ptr, services::EmptyDeleter()) );
132 
133  NumericTableFeature df;
134  df.setType<DataType>();
135  this->_status |= _ddict->setAllFeatures(df);
136  }
137 
144  PackedSymmetricMatrix( const services::SharedPtr<DataType> &ptr, size_t nDim ):
145  NumericTable( nDim, nDim )
146  {
147  _layout = packedLayout;
148  this->_status |= setArray( ptr );
149 
150  NumericTableFeature df;
151  df.setType<DataType>();
152  this->_status |= _ddict->setAllFeatures(df);
153  }
154 
155  PackedSymmetricMatrix( size_t nDim /*= 0*/ ):
156  NumericTable( nDim, nDim )
157  {
158  _layout = packedLayout;
159 
160  NumericTableFeature df;
161  df.setType<DataType>();
162  this->_status |= _ddict->setAllFeatures(df);
163  }
164 
172  static services::SharedPtr<PackedSymmetricMatrix> create(DataType *const ptr = 0, size_t nDim = 0,
173  services::Status* stat = NULL)
174  {
175  return create(services::SharedPtr<DataType>(ptr, services::EmptyDeleter()), nDim, stat);
176  }
177 
185  static services::SharedPtr<PackedSymmetricMatrix> create(const services::SharedPtr<DataType> &ptr, size_t nDim,
186  services::Status* stat = NULL)
187  {
188  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(PackedSymmetricMatrix, DAAL_TEMPLATE_ARGUMENTS(packedLayout,DataType), ptr, nDim);
189  }
190 
198  PackedSymmetricMatrix( DataType *const ptr, size_t nDim, const DataType &constValue ):
199  NumericTable( nDim, nDim )
200  {
201  _layout = packedLayout;
202  this->_status |= setArray( services::SharedPtr<DataType>(ptr, services::EmptyDeleter()) );
203 
204  NumericTableFeature df;
205  df.setType<DataType>();
206  this->_status |= _ddict->setAllFeatures(df);
207 
208  this->_status |= assign( constValue );
209  }
210 
218  PackedSymmetricMatrix( const services::SharedPtr<DataType>& ptr, size_t nDim, const DataType &constValue ) :
219  NumericTable( nDim, nDim )
220  {
221  _layout = packedLayout;
222  this->_status |= setArray( ptr );
223 
224  NumericTableFeature df;
225  df.setType<DataType>();
226  this->_status |= _ddict->setAllFeatures(df);
227 
228  this->_status |= assign( constValue );
229  }
230 
239  static services::SharedPtr<PackedSymmetricMatrix> create(DataType *const ptr, size_t nDim, const DataType &constValue,
240  services::Status* stat = NULL)
241  {
242  return create(services::SharedPtr<DataType>(ptr, services::EmptyDeleter()), nDim, constValue, stat);
243  }
244 
253  static services::SharedPtr<PackedSymmetricMatrix> create(const services::SharedPtr<DataType> &ptr, size_t nDim, const DataType &constValue,
254  services::Status* stat = NULL)
255  {
256  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(PackedSymmetricMatrix, DAAL_TEMPLATE_ARGUMENTS(packedLayout,DataType), ptr, nDim, constValue);
257  }
258 
265  PackedSymmetricMatrix( size_t nDim, AllocationFlag memoryAllocationFlag ):
266  NumericTable( nDim, nDim )
267  {
268  _layout = packedLayout;
269 
270  NumericTableFeature df;
271  df.setType<DataType>();
272  this->_status |= _ddict->setAllFeatures(df);
273 
274  if( memoryAllocationFlag == doAllocate ) this->_status |= allocateDataMemoryImpl();
275  }
276 
284  static services::SharedPtr<PackedSymmetricMatrix> create(size_t nDim, AllocationFlag memoryAllocationFlag,
285  services::Status* stat = NULL)
286  {
287  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(PackedSymmetricMatrix, DAAL_TEMPLATE_ARGUMENTS(packedLayout,DataType), nDim, memoryAllocationFlag);
288  }
289 
297  PackedSymmetricMatrix( size_t nDim, NumericTable::AllocationFlag memoryAllocationFlag,
298  const DataType &constValue ):
299  NumericTable( nDim, nDim )
300  {
301  _layout = packedLayout;
302 
303  NumericTableFeature df;
304  df.setType<DataType>();
305  this->_status |= _ddict->setAllFeatures(df);
306 
307  if( memoryAllocationFlag == doAllocate ) this->_status |= allocateDataMemoryImpl();
308  this->_status |= assign(constValue);
309  }
310 
319  static services::SharedPtr<PackedSymmetricMatrix> create(size_t nDim, NumericTable::AllocationFlag memoryAllocationFlag,
320  const DataType &constValue, services::Status* stat = NULL)
321  {
322  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(PackedSymmetricMatrix, DAAL_TEMPLATE_ARGUMENTS(packedLayout,DataType), \
323  nDim, memoryAllocationFlag, constValue);
324  }
325 
327  virtual ~PackedSymmetricMatrix()
328  {
329  freeDataMemoryImpl();
330  }
331 
336  DataType *getArray() const
337  {
338  return (DataType*)_ptr.get();
339  }
340 
345  services::SharedPtr<DataType> getArraySharedPtr() const
346  {
347  return services::reinterpretPointerCast<DataType, byte>(_ptr);
348  }
349 
354  services::Status setArray( DataType *const ptr )
355  {
356  freeDataMemoryImpl();
357  if( ptr == 0 )
358  return services::Status(services::ErrorEmptyHomogenNumericTable);
359 
360  _ptr = services::SharedPtr<byte>((byte*)ptr, services::EmptyDeleter());
361  _memStatus = userAllocated;
362  return services::Status();
363  }
364 
369  services::Status setArray( const services::SharedPtr<DataType>& ptr )
370  {
371  freeDataMemoryImpl();
372  if( ptr == 0 )
373  return services::Status(services::ErrorEmptyHomogenNumericTable);
374 
375  _ptr = services::reinterpretPointerCast<byte, DataType>(ptr);
376  _memStatus = userAllocated;
377  return services::Status();
378  }
379 
384  template <typename T>
385  services::Status assign(T value)
386  {
387  if( _memStatus == notAllocated )
388  return services::Status(services::ErrorEmptyHomogenNumericTable);
389 
390  size_t nDim = getNumberOfColumns();
391 
392  DataType * ptr = (DataType*)_ptr.get();
393  DataType valueDataType = (DataType)value;
394  for( size_t i = 0; i < (nDim * (nDim + 1)) / 2 ; i++ )
395  {
396  ptr[i] = valueDataType;
397  }
398  return services::Status();
399  }
400 
404  virtual services::Status assign(float value) DAAL_C11_OVERRIDE {return assign<DataType>((DataType)value);}
405 
409  virtual services::Status assign(double value) DAAL_C11_OVERRIDE {return assign<DataType>((DataType)value);}
410 
414  virtual services::Status assign(int value) DAAL_C11_OVERRIDE {return assign<DataType>((DataType)value);}
415 
416  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
417  {
418  return getTBlock<double>(vector_idx, vector_num, rwflag, block);
419  }
420  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
421  {
422  return getTBlock<float>(vector_idx, vector_num, rwflag, block);
423  }
424  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
425  {
426  return getTBlock<int>(vector_idx, vector_num, rwflag, block);
427  }
428 
429  services::Status releaseBlockOfRows(BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
430  {
431  return releaseTBlock<double>(block);
432  }
433  services::Status releaseBlockOfRows(BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
434  {
435  return releaseTBlock<float>(block);
436  }
437  services::Status releaseBlockOfRows(BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
438  {
439  return releaseTBlock<int>(block);
440  }
441 
442  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
443  ReadWriteMode rwflag, BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
444  {
445  return getTFeature<double>(feature_idx, vector_idx, value_num, rwflag, block);
446  }
447  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
448  ReadWriteMode rwflag, BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
449  {
450  return getTFeature<float>(feature_idx, vector_idx, value_num, rwflag, block);
451  }
452  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
453  ReadWriteMode rwflag, BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
454  {
455  return getTFeature<int>(feature_idx, vector_idx, value_num, rwflag, block);
456  }
457 
458  services::Status releaseBlockOfColumnValues(BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
459  {
460  return releaseTFeature<double>(block);
461  }
462  services::Status releaseBlockOfColumnValues(BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
463  {
464  return releaseTFeature<float>(block);
465  }
466  services::Status releaseBlockOfColumnValues(BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
467  {
468  return releaseTFeature<int>(block);
469  }
470 
471 
472  services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
473  {
474  return getTPackedArray<double>(rwflag, block);
475  }
476  services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
477  {
478  return getTPackedArray<float>(rwflag, block);
479  }
480  services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
481  {
482  return getTPackedArray<int>(rwflag, block);
483  }
484 
485  services::Status releasePackedArray(BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
486  {
487  return releaseTPackedArray<double>(block);
488  }
489  services::Status releasePackedArray(BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
490  {
491  return releaseTPackedArray<float>(block);
492  }
493  services::Status releasePackedArray(BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
494  {
495  return releaseTPackedArray<int>(block);
496  }
497 
498 protected:
499  services::SharedPtr<byte> _ptr;
500 
501  PackedSymmetricMatrix(const services::SharedPtr<DataType> &ptr, size_t nDim, services::Status &st):
502  NumericTable(nDim, nDim, DictionaryIface::notEqual, st)
503  {
504  _layout = packedLayout;
505  st |= setArray( ptr );
506 
507  NumericTableFeature df;
508  df.setType<DataType>();
509  st |= _ddict->setAllFeatures(df);
510  }
511 
512  PackedSymmetricMatrix(const services::SharedPtr<DataType>& ptr, size_t nDim, const DataType &constValue,
513  services::Status &st) :
514  NumericTable(nDim, nDim, DictionaryIface::notEqual, st)
515  {
516  _layout = packedLayout;
517  st |= setArray( ptr );
518 
519  NumericTableFeature df;
520  df.setType<DataType>();
521  st |= _ddict->setAllFeatures(df);
522 
523  st |= assign( constValue );
524  }
525 
526  PackedSymmetricMatrix(size_t nDim, AllocationFlag memoryAllocationFlag, services::Status &st):
527  NumericTable(nDim, nDim, DictionaryIface::notEqual, st)
528  {
529  _layout = packedLayout;
530 
531  NumericTableFeature df;
532  df.setType<DataType>();
533  st |= _ddict->setAllFeatures(df);
534 
535  if( memoryAllocationFlag == doAllocate ) st |= allocateDataMemoryImpl();
536  }
537 
538  PackedSymmetricMatrix(size_t nDim, NumericTable::AllocationFlag memoryAllocationFlag,
539  const DataType &constValue, services::Status &st):
540  NumericTable(nDim, nDim, DictionaryIface::notEqual, st)
541  {
542  _layout = packedLayout;
543 
544  NumericTableFeature df;
545  df.setType<DataType>();
546  st |= _ddict->setAllFeatures(df);
547 
548  if( memoryAllocationFlag == doAllocate ) st |= allocateDataMemoryImpl();
549  st |= assign(constValue);
550  }
551 
552  services::Status allocateDataMemoryImpl(daal::MemType type = daal::dram) DAAL_C11_OVERRIDE
553  {
554  freeDataMemoryImpl();
555 
556  size_t nDim = getNumberOfColumns();
557  size_t size = (nDim * (nDim + 1)) / 2;
558 
559  if( size == 0 )
560  return services::Status(getNumberOfColumns() == 0 ? services::ErrorIncorrectNumberOfFeatures :
561  services::ErrorIncorrectNumberOfObservations);
562 
563  _ptr = services::SharedPtr<byte>((byte *)daal::services::daal_malloc( size * sizeof(DataType) ), services::ServiceDeleter());
564 
565  if( _ptr == 0 )
566  return services::Status(services::ErrorMemoryAllocationFailed);
567 
568  _memStatus = internallyAllocated;
569  return services::Status();
570  }
571 
572  void freeDataMemoryImpl() DAAL_C11_OVERRIDE
573  {
574  _ptr.reset();
575  _memStatus = notAllocated;
576  }
577 
579  template<typename Archive, bool onDeserialize>
580  services::Status serialImpl( Archive *arch )
581  {
582  NumericTable::serialImpl<Archive, onDeserialize>( arch );
583 
584  if( onDeserialize )
585  {
586  allocateDataMemoryImpl();
587  }
588 
589  size_t nDim = getNumberOfColumns();
590  size_t size = (nDim * (nDim + 1)) / 2;
591 
592  arch->set( (DataType*)_ptr.get(), size );
593 
594  return services::Status();
595  }
596 
597 private:
598  template<typename T1, typename T2>
599  services::Status internal_repack( size_t p, size_t n, T1 *src, T2 *dst )
600  {
601  if( IsSameType<T1, T2>::value )
602  {
603  if( src != (T1 *)dst )
604  {
605  int result = daal::services::internal::daal_memcpy_s(dst, n * p * sizeof(T1), src, n * p * sizeof(T1));
606  DAAL_CHECK(!result, services::ErrorMemoryCopyFailedInternal);
607  }
608  }
609  else
610  {
611  size_t i, j;
612 
613  for(i = 0; i < n; i++)
614  {
615  for(j = 0; j < p; j++)
616  {
617  dst[i * p + j] = static_cast<T2>(src[i * p + j]);
618  }
619  }
620  }
621  return services::Status();
622  }
623 
624  template<typename T1, typename T2>
625  void internal_set_col_repack( size_t p, size_t n, T1 *src, T2 *dst )
626  {
627  size_t i;
628 
629  for(i = 0; i < n; i++)
630  {
631  dst[i * p] = static_cast<T2>(src[i]);
632  }
633  }
634 
635 protected:
636  baseDataType &getBaseValue( size_t dim, size_t rowIdx, size_t colIdx )
637  {
638  size_t offset;
639 
640  if( packedLayout == upperPackedSymmetricMatrix )
641  {
642  if( colIdx < rowIdx )
643  {
644  size_t tmp;
645  tmp = colIdx;
646  colIdx = rowIdx;
647  rowIdx = tmp;
648  }
649 
650  offset = (2 * dim - rowIdx) * (rowIdx + 1) / 2 - (dim - colIdx);
651  }
652  else /* here lowerPackedSymmetricMatrix is supposed */
653  {
654  if( colIdx > rowIdx )
655  {
656  size_t tmp;
657  tmp = colIdx;
658  colIdx = rowIdx;
659  rowIdx = tmp;
660  }
661 
662  offset = (2 + rowIdx) * (rowIdx + 1) / 2 - (rowIdx - colIdx) - 1;
663  }
664  return *((DataType*)_ptr.get() + offset);
665  }
666 
667  template <typename T>
668  T getValue( size_t dim, size_t rowIdx, size_t colIdx )
669  {
670  return static_cast<T>( getBaseValue( dim, rowIdx, colIdx ) );
671  }
672 
673  template <typename T>
674  services::Status setValue( size_t dim, size_t rowIdx, size_t colIdx, T value )
675  {
676  getBaseValue( dim, rowIdx, colIdx ) = static_cast<baseDataType>( value );
677  return services::Status();
678  }
679 
680  template <typename T>
681  services::Status getTBlock(size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T> &block)
682  {
683  size_t nDim = getNumberOfColumns();
684  block.setDetails( 0, idx, rwFlag );
685 
686  if (idx >= nDim)
687  {
688  block.resizeBuffer( nDim, 0 );
689  return services::Status();
690  }
691 
692  nrows = ( idx + nrows < nDim ) ? nrows : nDim - idx;
693 
694  if( !block.resizeBuffer( nDim, nrows ) )
695  return services::Status(services::ErrorMemoryAllocationFailed);
696 
697  if((rwFlag & (int)readOnly))
698  {
699  T *buffer = block.getBlockPtr();
700 
701  for(size_t iRow = 0; iRow < nrows; iRow++)
702  {
703  for(size_t iCol = 0; iCol < nDim; iCol++)
704  {
705  buffer[iRow * nDim + iCol] = getValue<T>(nDim, iRow + idx, iCol);
706  }
707  }
708  }
709  return services::Status();
710  }
711 
712  template <typename T>
713  services::Status releaseTBlock( BlockDescriptor<T> &block )
714  {
715  services::Status s;
716  if(block.getRWFlag() & (int)writeOnly)
717  {
718  size_t nDim = getNumberOfColumns();
719  size_t nrows = block.getNumberOfRows();
720  size_t idx = block.getRowsOffset();
721  T *buffer = block.getBlockPtr();
722 
723  for( size_t iRow = 0; iRow < nrows; iRow++ )
724  {
725  for( size_t iCol = 0; iCol < nDim; iCol++ )
726  {
727  s |= setValue<T>( nDim, idx + iRow, iCol, buffer[ iRow * nDim + iCol ] );
728  }
729  }
730  }
731  block.reset();
732  return s;
733  }
734 
735  template <typename T>
736  services::Status getTFeature(size_t feat_idx, size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T> &block)
737  {
738  size_t nDim = getNumberOfColumns();
739  block.setDetails( feat_idx, idx, rwFlag );
740 
741  if (idx >= nDim)
742  {
743  block.resizeBuffer( nDim, 0 );
744  return services::Status();
745  }
746 
747  nrows = ( idx + nrows < nDim ) ? nrows : nDim - idx;
748 
749  if( !block.resizeBuffer( 1, nrows ) )
750  return services::Status();
751 
752  if((block.getRWFlag() & (int)readOnly))
753  {
754  T *buffer = block.getBlockPtr();
755 
756  for(size_t iRow = 0; iRow < nrows; iRow++)
757  {
758  buffer[iRow] = getValue<T>(nDim, iRow + idx, feat_idx);
759  }
760  }
761  return services::Status();
762  }
763 
764  template <typename T>
765  services::Status releaseTFeature( BlockDescriptor<T> &block )
766  {
767  services::Status s;
768  if (block.getRWFlag() & (int)writeOnly)
769  {
770  size_t nDim = getNumberOfColumns();
771  size_t nrows = block.getNumberOfRows();
772  size_t idx = block.getRowsOffset();
773  size_t feat_idx = block.getColumnsOffset();
774  T *buffer = block.getBlockPtr();
775 
776  for( size_t iRow = 0; iRow < nrows; iRow++ )
777  {
778  s |= setValue<T>( nDim, iRow + idx, feat_idx, buffer[ iRow ] );
779  }
780  }
781  block.reset();
782  return s;
783  }
784 
785  template <typename T>
786  services::Status getTPackedArray( int rwFlag, BlockDescriptor<T> &block )
787  {
788  size_t nDim = getNumberOfColumns();
789  block.setDetails( 0, 0, rwFlag );
790 
791  size_t nSize = (nDim * (nDim + 1)) / 2;
792 
793  if( IsSameType<T, DataType>::value )
794  {
795  block.setPtr( &_ptr, _ptr.get(), 1, nSize );
796  return services::Status();
797  }
798 
799  if( !block.resizeBuffer( 1, nSize ) ) return services::Status();
800 
801  if( !(rwFlag & (int)readOnly) ) return services::Status();
802 
803  T *buffer = block.getBlockPtr();
804  DataType * ptr = (DataType*) _ptr.get();
805  for( size_t i = 0; i < nSize; i++ )
806  {
807  buffer[ i ] = static_cast<T>(*(ptr + i));
808  }
809  return services::Status();
810  }
811 
812  template <typename T>
813  services::Status releaseTPackedArray( BlockDescriptor<T> &block )
814  {
815  if( (block.getRWFlag() & (int)writeOnly) && !IsSameType<T, DataType>::value )
816  {
817  size_t nDim = getNumberOfColumns();
818  size_t nSize = (nDim * (nDim + 1)) / 2;
819  T *buffer = block.getBlockPtr();
820  DataType * ptr = (DataType*) _ptr.get();
821 
822  for( size_t i = 0; i < nSize; i++ )
823  {
824  *(ptr + i) = static_cast<baseDataType>(buffer[ i ]);
825  }
826  }
827  block.reset();
828  return services::Status();
829  }
830 
831  virtual services::Status setNumberOfColumnsImpl(size_t nDim) DAAL_C11_OVERRIDE
832  {
833  if( _ddict->getNumberOfFeatures() != nDim )
834  {
835  _ddict->setNumberOfFeatures( nDim );
836 
837  NumericTableFeature df;
838  df.setType<DataType>();
839  _ddict->setAllFeatures(df);
840  }
841 
842  _obsnum = nDim;
843  return services::Status();
844  }
845 
846  virtual services::Status setNumberOfRowsImpl(size_t nDim) DAAL_C11_OVERRIDE
847  {
848  setNumberOfColumnsImpl( nDim );
849  _obsnum = nDim;
850  return services::Status();
851  }
852 };
853 
859 template<NumericTableIface::StorageLayout packedLayout, typename DataType = DAAL_DATA_TYPE>
860 class DAAL_EXPORT PackedTriangularMatrix : public NumericTable, public PackedArrayNumericTableIface
861 {
862 public:
863  DECLARE_SERIALIZABLE_TAG();
864 
868  typedef DataType baseDataType;
869 
870 public:
876  PackedTriangularMatrix( DataType *const ptr = 0, size_t nDim = 0 ):
877  NumericTable( nDim, nDim )
878  {
879  _layout = packedLayout;
880  this->_status |= setArray( services::SharedPtr<DataType>(ptr, services::EmptyDeleter()) );
881 
882  NumericTableFeature df;
883  df.setType<DataType>();
884  this->_status |= _ddict->setAllFeatures(df);
885  }
886 
892  PackedTriangularMatrix( const services::SharedPtr<DataType> &ptr, size_t nDim ):
893  NumericTable( nDim, nDim )
894  {
895  _layout = packedLayout;
896  this->_status |= setArray( ptr );
897 
898  NumericTableFeature df;
899  df.setType<DataType>();
900  this->_status |= _ddict->setAllFeatures(df);
901  }
902 
903  PackedTriangularMatrix( size_t nDim /*= 0*/ ):
904  NumericTable( nDim, nDim )
905  {
906  _layout = packedLayout;
907 
908  NumericTableFeature df;
909  df.setType<DataType>();
910  this->_status |= _ddict->setAllFeatures(df);
911  }
912 
913  static services::SharedPtr<PackedTriangularMatrix> create(DataType *const ptr = 0, size_t nDim = 0,
914  services::Status* stat = NULL)
915  {
916  return create(services::SharedPtr<DataType>(ptr, services::EmptyDeleter()), nDim, stat);
917  }
918 
919  static services::SharedPtr<PackedTriangularMatrix> create(const services::SharedPtr<DataType> &ptr, size_t nDim,
920  services::Status* stat = NULL)
921  {
922  services::SharedPtr<PackedTriangularMatrix> ntPtr(new PackedTriangularMatrix(nDim));
923  if(ntPtr.get())
924  {
925  services::Status s = ntPtr->setArray(ptr);
926  if(!s)
927  ntPtr = services::SharedPtr<PackedTriangularMatrix>();
928  if(stat)
929  *stat = s;
930  }
931  else
932  {
933  if(stat)
934  *stat = services::Status(services::ErrorMemoryAllocationFailed);
935  }
936  return ntPtr;
937  }
938 
945  PackedTriangularMatrix( DataType *const ptr, size_t nDim, const DataType &constValue ):
946  NumericTable( nDim, nDim )
947  {
948  _layout = packedLayout;
949  this->_status |= setArray( services::SharedPtr<DataType>(ptr, services::EmptyDeleter()) );
950 
951  NumericTableFeature df;
952  df.setType<DataType>();
953  this->_status |= _ddict->setAllFeatures(df);
954 
955  this->_status |= assign( constValue );
956  }
957 
964  PackedTriangularMatrix( const services::SharedPtr<DataType>& ptr, size_t nDim, const DataType &constValue ) :
965  NumericTable( nDim, nDim )
966  {
967  _layout = packedLayout;
968  this->_status |= setArray( ptr );
969 
970  NumericTableFeature df;
971  df.setType<DataType>();
972  this->_status |= _ddict->setAllFeatures(df);
973 
974  this->_status |= assign( constValue );
975  }
976 
977  static services::SharedPtr<PackedTriangularMatrix> create(DataType *const ptr, size_t nDim, const DataType &constValue,
978  services::Status* stat = NULL)
979  {
980  services::SharedPtr<PackedTriangularMatrix> ntPtr(new PackedTriangularMatrix(nDim));
981  if(ntPtr.get())
982  {
983  services::Status s = ntPtr->setArray( services::SharedPtr<DataType>(ptr, services::EmptyDeleter()) );
984  s.add(ntPtr->assign(constValue));
985  if(!s)
986  ntPtr = services::SharedPtr<PackedTriangularMatrix>();
987  if(stat)
988  *stat = s;
989  }
990  else
991  {
992  if(stat)
993  *stat = services::Status(services::ErrorMemoryAllocationFailed);
994  }
995  return ntPtr;
996  }
997 
998  static services::SharedPtr<PackedTriangularMatrix> create(services::SharedPtr<DataType> &ptr, size_t nDim, const DataType &constValue,
999  services::Status* stat = NULL)
1000  {
1001  services::SharedPtr<PackedTriangularMatrix> ntPtr(new PackedTriangularMatrix(nDim));
1002  if(ntPtr.get())
1003  {
1004  services::Status s = ntPtr->setArray(ptr);
1005  s.add(ntPtr->assign(constValue));
1006  if(!s)
1007  ntPtr = services::SharedPtr<PackedTriangularMatrix>();
1008  if(stat)
1009  *stat = s;
1010  }
1011  else
1012  {
1013  if(stat)
1014  *stat = services::Status(services::ErrorMemoryAllocationFailed);
1015  }
1016  return ntPtr;
1017  }
1018 
1024  PackedTriangularMatrix( size_t nDim, AllocationFlag memoryAllocationFlag ):
1025  NumericTable( nDim, nDim )
1026  {
1027  _layout = packedLayout;
1028 
1029  NumericTableFeature df;
1030  df.setType<DataType>();
1031  this->_status |= _ddict->setAllFeatures(df);
1032 
1033  if( memoryAllocationFlag == doAllocate ) this->_status |= allocateDataMemoryImpl();
1034  }
1035 
1036  static services::SharedPtr<PackedTriangularMatrix> create(size_t nDim, AllocationFlag memoryAllocationFlag,
1037  services::Status* stat = NULL)
1038  {
1039  services::SharedPtr<PackedTriangularMatrix> ntPtr(new PackedTriangularMatrix(nDim));
1040  if(ntPtr.get())
1041  {
1042  services::Status s;
1043  if(memoryAllocationFlag == doAllocate)
1044  {
1045  s = ntPtr->allocateDataMemoryImpl();
1046  if(!s)
1047  ntPtr = services::SharedPtr<PackedTriangularMatrix>();
1048  }
1049  if(!s)
1050  ntPtr = services::SharedPtr<PackedTriangularMatrix>();
1051  if(stat)
1052  *stat = s;
1053  }
1054  else
1055  {
1056  if(stat)
1057  *stat = services::Status(services::ErrorMemoryAllocationFailed);
1058  }
1059  return ntPtr;
1060  }
1061 
1068  PackedTriangularMatrix( size_t nDim, NumericTable::AllocationFlag memoryAllocationFlag,
1069  const DataType &constValue ):
1070  NumericTable( nDim, nDim )
1071  {
1072  _layout = packedLayout;
1073 
1074  NumericTableFeature df;
1075  df.setType<DataType>();
1076  this->_status |= _ddict->setAllFeatures(df);
1077 
1078  if( memoryAllocationFlag == doAllocate ) this->_status |= allocateDataMemoryImpl();
1079  this->_status |= assign(constValue);
1080  }
1081 
1082  static services::SharedPtr<PackedTriangularMatrix> create(size_t nDim, NumericTable::AllocationFlag memoryAllocationFlag,
1083  const DataType &constValue, services::Status* stat = NULL)
1084  {
1085  services::SharedPtr<PackedTriangularMatrix> ntPtr(new PackedTriangularMatrix(nDim));
1086  if(ntPtr.get())
1087  {
1088  services::Status s;
1089  if(memoryAllocationFlag == doAllocate)
1090  {
1091  s = ntPtr->allocateDataMemoryImpl();
1092  s.add(ntPtr->assign(constValue));
1093  if(!s)
1094  ntPtr = services::SharedPtr<PackedTriangularMatrix>();
1095  }
1096  if(!s)
1097  ntPtr = services::SharedPtr<PackedTriangularMatrix>();
1098  if(stat)
1099  *stat = s;
1100  }
1101  else
1102  {
1103  if(stat)
1104  *stat = services::Status(services::ErrorMemoryAllocationFailed);
1105  }
1106  return ntPtr;
1107  }
1108 
1110  virtual ~PackedTriangularMatrix()
1111  {
1112  freeDataMemoryImpl();
1113  }
1114 
1115  virtual services::Status setNumberOfColumns(size_t nDim) DAAL_C11_OVERRIDE
1116  {
1117  if( _ddict->getNumberOfFeatures() != nDim )
1118  {
1119  _ddict->setNumberOfFeatures( nDim );
1120 
1121  NumericTableFeature df;
1122  df.setType<DataType>();
1123  _ddict->setAllFeatures(df);
1124  }
1125 
1126  _obsnum = nDim;
1127  return services::Status();
1128  }
1129 
1130  virtual services::Status setNumberOfRows(size_t nDim) DAAL_C11_OVERRIDE
1131  {
1132  return setNumberOfColumns( nDim );
1133  }
1134 
1139  DataType *getArray() const
1140  {
1141  return (DataType*)_ptr.get();
1142  }
1143 
1148  services::SharedPtr<DataType> getArraySharedPtr() const
1149  {
1150  return services::reinterpretPointerCast<DataType, byte>(_ptr);
1151  }
1152 
1157  services::Status setArray( DataType *const ptr )
1158  {
1159  freeDataMemoryImpl();
1160  if( ptr == 0 )
1161  return services::Status(services::ErrorEmptyHomogenNumericTable);
1162 
1163  _ptr = services::SharedPtr<byte>((DataType*)ptr, services::EmptyDeleter());
1164  _memStatus = userAllocated;
1165  return services::Status();
1166  }
1167 
1172  services::Status setArray( const services::SharedPtr<DataType>& ptr )
1173  {
1174  freeDataMemoryImpl();
1175  if( ptr == 0 )
1176  return services::Status(services::ErrorEmptyHomogenNumericTable);
1177 
1178  _ptr = services::reinterpretPointerCast<byte, DataType>(ptr);
1179  _memStatus = userAllocated;
1180  return services::Status();
1181  }
1182 
1187  template <typename T>
1188  services::Status assign(T value)
1189  {
1190  if( _memStatus == notAllocated )
1191  return services::Status(services::ErrorEmptyHomogenNumericTable);
1192 
1193  size_t nDim = getNumberOfColumns();
1194 
1195  DataType * ptr = (DataType*)_ptr.get();
1196  DataType valueDataType = (DataType)value;
1197  for( size_t i = 0; i < (nDim * (nDim + 1)) / 2 ; i++ )
1198  {
1199  ptr[i] = valueDataType;
1200  }
1201  return services::Status();
1202  }
1203 
1207  virtual services::Status assign(float value) DAAL_C11_OVERRIDE {return assign<DataType>((DataType)value);}
1208 
1212  virtual services::Status assign(double value) DAAL_C11_OVERRIDE {return assign<DataType>((DataType)value);}
1213 
1217  virtual services::Status assign(int value) DAAL_C11_OVERRIDE {return assign<DataType>((DataType)value);}
1218 
1219  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
1220  {
1221  return getTBlock<double>(vector_idx, vector_num, rwflag, block);
1222  }
1223  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
1224  {
1225  return getTBlock<float>(vector_idx, vector_num, rwflag, block);
1226  }
1227  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
1228  {
1229  return getTBlock<int>(vector_idx, vector_num, rwflag, block);
1230  }
1231 
1232  services::Status releaseBlockOfRows(BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
1233  {
1234  return releaseTBlock<double>(block);
1235  }
1236  services::Status releaseBlockOfRows(BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
1237  {
1238  return releaseTBlock<float>(block);
1239  }
1240  services::Status releaseBlockOfRows(BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
1241  {
1242  return releaseTBlock<int>(block);
1243  }
1244 
1245  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
1246  ReadWriteMode rwflag, BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
1247  {
1248  return getTFeature<double>(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<float> &block) DAAL_C11_OVERRIDE
1252  {
1253  return getTFeature<float>(feature_idx, vector_idx, value_num, rwflag, block);
1254  }
1255  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
1256  ReadWriteMode rwflag, BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
1257  {
1258  return getTFeature<int>(feature_idx, vector_idx, value_num, rwflag, block);
1259  }
1260 
1261  services::Status releaseBlockOfColumnValues(BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
1262  {
1263  return releaseTFeature<double>(block);
1264  }
1265  services::Status releaseBlockOfColumnValues(BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
1266  {
1267  return releaseTFeature<float>(block);
1268  }
1269  services::Status releaseBlockOfColumnValues(BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
1270  {
1271  return releaseTFeature<int>(block);
1272  }
1273 
1274  services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
1275  {
1276  return getTPackedArray<double>(rwflag, block);
1277  }
1278  services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
1279  {
1280  return getTPackedArray<float>(rwflag, block);
1281  }
1282  services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
1283  {
1284  return getTPackedArray<int>(rwflag, block);
1285  }
1286 
1287  services::Status releasePackedArray(BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
1288  {
1289  return releaseTPackedArray<double>(block);
1290  }
1291  services::Status releasePackedArray(BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
1292  {
1293  return releaseTPackedArray<float>(block);
1294  }
1295  services::Status releasePackedArray(BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
1296  {
1297  return releaseTPackedArray<int>(block);
1298  }
1299 
1301  services::Status serializeImpl (InputDataArchive *arch) DAAL_C11_OVERRIDE
1302  {
1303  serialImpl<InputDataArchive, false>( arch );
1304 
1305  return services::Status();
1306  }
1307 
1309  services::Status deserializeImpl(const OutputDataArchive *arch) DAAL_C11_OVERRIDE
1310  {
1311  serialImpl<const OutputDataArchive, true>( arch );
1312 
1313  return services::Status();
1314  }
1315 
1316 protected:
1317  services::SharedPtr<byte> _ptr;
1318 
1319  services::Status allocateDataMemoryImpl(daal::MemType type = daal::dram) DAAL_C11_OVERRIDE
1320  {
1321  freeDataMemoryImpl();
1322 
1323  size_t nDim = getNumberOfColumns();
1324  size_t size = (nDim * (nDim + 1)) / 2;
1325 
1326  if( size == 0 )
1327  return services::Status(getNumberOfColumns() == 0 ? services::ErrorIncorrectNumberOfFeatures :
1328  services::ErrorIncorrectNumberOfObservations);
1329 
1330  _ptr = services::SharedPtr<byte>((byte *)daal::services::daal_malloc( size * sizeof(DataType) ), services::ServiceDeleter());
1331 
1332  if( _ptr == 0 )
1333  return services::Status(services::ErrorMemoryAllocationFailed);
1334 
1335  _memStatus = internallyAllocated;
1336  return services::Status();
1337  }
1338 
1339  void freeDataMemoryImpl() DAAL_C11_OVERRIDE
1340  {
1341  _ptr.reset();
1342  _memStatus = notAllocated;
1343  }
1344 
1346  template<typename Archive, bool onDeserialize>
1347  services::Status serialImpl( Archive *arch )
1348  {
1349  NumericTable::serialImpl<Archive, onDeserialize>( arch );
1350 
1351  if( onDeserialize )
1352  {
1353  allocateDataMemoryImpl();
1354  }
1355 
1356  size_t nDim = getNumberOfColumns();
1357  size_t size = (nDim * (nDim + 1)) / 2;
1358 
1359  arch->set( (DataType*)_ptr.get(), size );
1360 
1361  return services::Status();
1362  }
1363 
1364 private:
1365  template<typename T1, typename T2>
1366  services::Status internal_repack( size_t p, size_t n, T1 *src, T2 *dst )
1367  {
1368  if( IsSameType<T1, T2>::value )
1369  {
1370  if( src != (T1 *)dst )
1371  {
1372  int result = daal::services::internal::daal_memcpy_s(dst, n * p * sizeof(T1), src, n * p * sizeof(T1));
1373  DAAL_CHECK(!result, services::ErrorMemoryCopyFailedInternal);
1374  }
1375  }
1376  else
1377  {
1378  size_t i, j;
1379 
1380  for(i = 0; i < n; i++)
1381  {
1382  for(j = 0; j < p; j++)
1383  {
1384  dst[i * p + j] = static_cast<T2>(src[i * p + j]);
1385  }
1386  }
1387  }
1388  return services::Status();
1389  }
1390 
1391  template<typename T1, typename T2>
1392  void internal_set_col_repack( size_t p, size_t n, T1 *src, T2 *dst )
1393  {
1394  size_t i;
1395 
1396  for(i = 0; i < n; i++)
1397  {
1398  dst[i * p] = static_cast<T2>(src[i]);
1399  }
1400  }
1401 
1402 protected:
1403  baseDataType &getBaseValue( size_t dim, size_t rowIdx, size_t colIdx, baseDataType &zero )
1404  {
1405  size_t offset;
1406 
1407  if( packedLayout == upperPackedTriangularMatrix )
1408  {
1409  if( colIdx < rowIdx )
1410  {
1411  return zero;
1412  }
1413 
1414  offset = (2 * dim - rowIdx) * (rowIdx + 1) / 2 - (dim - colIdx);
1415  }
1416  else /* here lowerPackedTriangularMatrix is supposed */
1417  {
1418  if( colIdx > rowIdx )
1419  {
1420  return zero;
1421  }
1422 
1423  offset = (2 + rowIdx) * (rowIdx + 1) / 2 - (rowIdx - colIdx) - 1;
1424  }
1425  return *((DataType*)_ptr.get() + offset);
1426  }
1427 
1428  template <typename T>
1429  T getValue( size_t dim, size_t rowIdx, size_t colIdx )
1430  {
1431  baseDataType zero = (baseDataType)0;
1432  return static_cast<T>( getBaseValue( dim, rowIdx, colIdx, zero ) );
1433  }
1434 
1435  template <typename T>
1436  services::Status setValue( size_t dim, size_t rowIdx, size_t colIdx, T value )
1437  {
1438  baseDataType zero = (baseDataType)0;
1439  getBaseValue( dim, rowIdx, colIdx, zero ) = static_cast<baseDataType>( value );
1440  return services::Status();
1441  }
1442 
1443  template <typename T>
1444  services::Status getTBlock(size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T> &block)
1445  {
1446  size_t nDim = getNumberOfColumns();
1447  block.setDetails( 0, idx, rwFlag );
1448 
1449  if (idx >= nDim)
1450  {
1451  block.resizeBuffer( nDim, 0 );
1452  return services::Status();
1453  }
1454 
1455  nrows = ( idx + nrows < nDim ) ? nrows : nDim - idx;
1456 
1457  if( !block.resizeBuffer( nDim, nrows ) )
1458  return services::Status(services::ErrorMemoryAllocationFailed);
1459 
1460  if((rwFlag & (int)readOnly))
1461  {
1462  T *buffer = block.getBlockPtr();
1463 
1464  for(size_t iRow = 0; iRow < nrows; iRow++)
1465  {
1466  for(size_t iCol = 0; iCol < nDim; iCol++)
1467  {
1468  buffer[iRow * nDim + iCol] = getValue<T>(nDim, iRow + idx, iCol);
1469  }
1470  }
1471  }
1472  return services::Status();
1473  }
1474 
1475  template <typename T>
1476  services::Status releaseTBlock( BlockDescriptor<T> &block )
1477  {
1478  services::Status s;
1479  if(block.getRWFlag() & (int)writeOnly)
1480  {
1481  size_t nDim = getNumberOfColumns();
1482  size_t nrows = block.getNumberOfRows();
1483  size_t idx = block.getRowsOffset();
1484  T *buffer = block.getBlockPtr();
1485 
1486  for( size_t iRow = 0; iRow < nrows; iRow++ )
1487  {
1488  for( size_t iCol = 0; iCol < nDim; iCol++ )
1489  {
1490  s |= setValue<T>( nDim, iRow + idx, iCol, buffer[ iRow * nDim + iCol ] );
1491  }
1492  }
1493  }
1494  block.reset();
1495  return s;
1496  }
1497 
1498  template <typename T>
1499  services::Status getTFeature(size_t feat_idx, size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T> &block)
1500  {
1501  size_t nDim = getNumberOfColumns();
1502  block.setDetails( feat_idx, idx, rwFlag );
1503 
1504  if (idx >= nDim)
1505  {
1506  block.resizeBuffer( nDim, 0 );
1507  return services::Status();
1508  }
1509 
1510  nrows = ( idx + nrows < nDim ) ? nrows : nDim - idx;
1511 
1512  if( !block.resizeBuffer( 1, nrows ) )
1513  return services::Status();
1514 
1515  if((block.getRWFlag() & (int)readOnly))
1516  {
1517  T *buffer = block.getBlockPtr();
1518  for( size_t iRow = 0; iRow < nrows; iRow++ )
1519  {
1520  buffer[ iRow ] = getValue<T>( nDim, iRow + idx, feat_idx );
1521  }
1522  }
1523  return services::Status();
1524  }
1525 
1526  template <typename T>
1527  services::Status releaseTFeature( BlockDescriptor<T> &block )
1528  {
1529  services::Status s;
1530  if (block.getRWFlag() & (int)writeOnly)
1531  {
1532  size_t nDim = getNumberOfColumns();
1533  size_t nrows = block.getNumberOfRows();
1534  size_t idx = block.getRowsOffset();
1535  size_t feat_idx = block.getColumnsOffset();
1536  T *buffer = block.getBlockPtr();
1537 
1538  for( size_t iRow = 0; iRow < nrows; iRow++ )
1539  {
1540  s |= setValue<T>( nDim, iRow + idx, feat_idx, buffer[ iRow ] );
1541  }
1542  }
1543  block.reset();
1544  return s;
1545  }
1546 
1547  template <typename T>
1548  services::Status getTPackedArray( int rwFlag, BlockDescriptor<T> &block )
1549  {
1550  size_t nDim = getNumberOfColumns();
1551  block.setDetails( 0, 0, rwFlag );
1552 
1553  size_t nSize = (nDim * (nDim + 1)) / 2;
1554 
1555  if( IsSameType<T, DataType>::value )
1556  {
1557  block.setPtr( &_ptr, _ptr.get(), 1, nSize );
1558  return services::Status();
1559  }
1560 
1561  if( !block.resizeBuffer( 1, nSize ) ) return services::Status();
1562 
1563  if( !(rwFlag & (int)readOnly) ) return services::Status();
1564 
1565  T *buffer = block.getBlockPtr();
1566  DataType * ptr = (DataType*)_ptr.get();
1567  for( size_t i = 0; i < nSize; i++ )
1568  {
1569  buffer[ i ] = static_cast<T>(*(ptr + i));
1570  }
1571  return services::Status();
1572  }
1573 
1574  template <typename T>
1575  services::Status releaseTPackedArray( BlockDescriptor<T> &block )
1576  {
1577  if( (block.getRWFlag() & (int)writeOnly) && !IsSameType<T, DataType>::value )
1578  {
1579  size_t nDim = getNumberOfColumns();
1580  size_t nSize = (nDim * (nDim + 1)) / 2;
1581  T *buffer = block.getBlockPtr();
1582  DataType * ptr = (DataType*)_ptr.get();
1583 
1584  for( size_t i = 0; i < nSize; i++ )
1585  {
1586  *(ptr + i) = static_cast<baseDataType>(buffer[ i ]);
1587  }
1588  }
1589  block.reset();
1590  return services::Status();
1591  }
1592 
1593  virtual services::Status setNumberOfColumnsImpl(size_t nDim) DAAL_C11_OVERRIDE
1594  {
1595  if( _ddict->getNumberOfFeatures() != nDim )
1596  {
1597  _ddict->setNumberOfFeatures( nDim );
1598 
1599  NumericTableFeature df;
1600  df.setType<DataType>();
1601  _ddict->setAllFeatures(df);
1602  }
1603 
1604  _obsnum = nDim;
1605  return services::Status();
1606  }
1607 
1608  virtual services::Status setNumberOfRowsImpl(size_t nDim) DAAL_C11_OVERRIDE
1609  {
1610  setNumberOfColumnsImpl( nDim );
1611  _obsnum = nDim;
1612  return services::Status();
1613  }
1614 };
1616 } // namespace interface1
1617 using interface1::PackedArrayNumericTableIface;
1618 using interface1::PackedSymmetricMatrix;
1619 using interface1::PackedTriangularMatrix;
1620 
1621 }
1622 } // namespace daal
1623 #endif
daal::data_management::interface1::PackedTriangularMatrix::assign
virtual services::Status assign(int value) 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:319
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:172
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:1227
daal::data_management::interface1::PackedTriangularMatrix::setNumberOfRows
virtual services::Status setNumberOfRows(size_t nDim) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1130
daal::data_management::interface1::PackedTriangularMatrix::PackedTriangularMatrix
PackedTriangularMatrix(size_t nDim, AllocationFlag memoryAllocationFlag)
Definition: symmetric_matrix.h:1024
daal::data_management::interface1::PackedSymmetricMatrix::assign
virtual services::Status assign(float value) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:404
daal::data_management::interface1::PackedSymmetricMatrix::getArraySharedPtr
services::SharedPtr< DataType > getArraySharedPtr() const
Definition: symmetric_matrix.h:345
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:452
daal::data_management::interface1::PackedSymmetricMatrix::getArray
DataType * getArray() const
Definition: symmetric_matrix.h:336
daal::data_management::interface1::PackedSymmetricMatrix::PackedSymmetricMatrix
PackedSymmetricMatrix(DataType *const ptr, size_t nDim, const DataType &constValue)
Definition: symmetric_matrix.h:198
daal::data_management::interface1::PackedTriangularMatrix::getArraySharedPtr
services::SharedPtr< DataType > getArraySharedPtr() const
Definition: symmetric_matrix.h:1148
daal::data_management::interface1::PackedSymmetricMatrix::PackedSymmetricMatrix
PackedSymmetricMatrix(const services::SharedPtr< DataType > &ptr, size_t nDim, const DataType &constValue)
Definition: symmetric_matrix.h:218
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:253
daal::data_management::interface1::PackedTriangularMatrix::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1265
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:447
daal::data_management::interface1::PackedSymmetricMatrix::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:462
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:239
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:1250
daal::data_management::interface1::PackedSymmetricMatrix::PackedSymmetricMatrix
PackedSymmetricMatrix(size_t nDim, NumericTable::AllocationFlag memoryAllocationFlag, const DataType &constValue)
Definition: symmetric_matrix.h:297
daal::services::ErrorIncorrectNumberOfObservations
Definition: error_indexes.h:73
daal::data_management::interface1::PackedSymmetricMatrix::setArray
services::Status setArray(DataType *const ptr)
Definition: symmetric_matrix.h:354
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:860
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:424
daal::data_management::interface1::NumericTable
Class for a data management component responsible for representation of data in the numeric format...
Definition: numeric_table.h:577
daal::data_management::interface1::PackedTriangularMatrix::setArray
services::Status setArray(DataType *const ptr)
Definition: symmetric_matrix.h:1157
daal::data_management::interface1::PackedTriangularMatrix::getArray
DataType * getArray() const
Definition: symmetric_matrix.h:1139
daal::data_management::interface1::PackedTriangularMatrix::PackedTriangularMatrix
PackedTriangularMatrix(const services::SharedPtr< DataType > &ptr, size_t nDim, const DataType &constValue)
Definition: symmetric_matrix.h:964
daal::data_management::interface1::PackedArrayNumericTableIface
Abstract class that defines the interface of symmetric matrices stored as a one-dimensional array...
Definition: symmetric_matrix.h:49
daal::data_management::interface1::PackedSymmetricMatrix::getPackedArray
services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:476
daal::data_management::interface1::NumericTableFeature::setType
void setType()
Definition: data_dictionary.h:96
daal::data_management::interface1::PackedTriangularMatrix::PackedTriangularMatrix
PackedTriangularMatrix(DataType *const ptr=0, size_t nDim=0)
Definition: symmetric_matrix.h:876
daal::data_management::interface1::PackedSymmetricMatrix::create
static services::SharedPtr< PackedSymmetricMatrix > create(size_t nDim, AllocationFlag memoryAllocationFlag, services::Status *stat=NULL)
Definition: symmetric_matrix.h:284
daal::data_management::interface1::PackedTriangularMatrix::getPackedArray
services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1278
daal::data_management::interface1::PackedTriangularMatrix::getPackedArray
services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1282
daal::data_management::interface1::PackedTriangularMatrix::setNumberOfColumns
virtual services::Status setNumberOfColumns(size_t nDim) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1115
daal::data_management::interface1::PackedTriangularMatrix::assign
virtual services::Status assign(double value) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1212
daal::MemType
MemType
Definition: daal_defines.h:147
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:1188
daal_defines.h
daal::data_management::interface1::PackedSymmetricMatrix::getPackedArray
services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:480
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:420
daal::data_management::interface1::PackedSymmetricMatrix::setArray
services::Status setArray(const services::SharedPtr< DataType > &ptr)
Definition: symmetric_matrix.h:369
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:1223
daal::data_management::interface1::PackedArrayNumericTableIface::releasePackedArray
virtual services::Status releasePackedArray(BlockDescriptor< double > &block)=0
daal::data_management::interface1::PackedTriangularMatrix::setArray
services::Status setArray(const services::SharedPtr< DataType > &ptr)
Definition: symmetric_matrix.h:1172
daal::data_management::interface1::PackedSymmetricMatrix::assign
virtual services::Status assign(double value) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:409
daal::data_management::interface1::PackedTriangularMatrix::PackedTriangularMatrix
PackedTriangularMatrix(DataType *const ptr, size_t nDim, const DataType &constValue)
Definition: symmetric_matrix.h:945
daal::data_management::interface1::PackedSymmetricMatrix::PackedSymmetricMatrix
PackedSymmetricMatrix(DataType *const ptr=0, size_t nDim=0)
Definition: symmetric_matrix.h:127
daal::data_management::interface1::PackedSymmetricMatrix::releasePackedArray
services::Status releasePackedArray(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:489
daal::data_management::interface1::PackedTriangularMatrix::releasePackedArray
services::Status releasePackedArray(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1291
daal::services::daal_memcpy_s
DAAL_DEPRECATED DAAL_EXPORT void daal_memcpy_s(void *dest, size_t numberOfElements, const void *src, size_t count)
daal::data_management::interface1::NumericTableIface::AllocationFlag
AllocationFlag
Enumeration to specify whether the Numeric Table must allocate memory.
Definition: numeric_table.h:285
daal::data_management::interface1::PackedSymmetricMatrix::baseDataType
DataType baseDataType
Definition: symmetric_matrix.h:118
daal::data_management::interface1::PackedTriangularMatrix::releasePackedArray
services::Status releasePackedArray(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1287
daal::data_management::interface1::PackedSymmetricMatrix::assign
services::Status assign(T value)
Definition: symmetric_matrix.h:385
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:185
daal::data_management::interface1::PackedSymmetricMatrix::releasePackedArray
services::Status releasePackedArray(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:485
daal::data_management::interface1::PackedSymmetricMatrix
Class that provides methods to access symmetric matrices stored as a one-dimensional array...
Definition: symmetric_matrix.h:109
daal::data_management::interface1::PackedSymmetricMatrix::PackedSymmetricMatrix
PackedSymmetricMatrix(size_t nDim, AllocationFlag memoryAllocationFlag)
Definition: symmetric_matrix.h:265
daal::dram
Definition: daal_defines.h:149
daal::services::daal_malloc
DAAL_EXPORT void * daal_malloc(size_t size, size_t alignment=DAAL_MALLOC_DEFAULT_ALIGNMENT)
daal::data_management::interface1::PackedTriangularMatrix::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1232
daal::data_management::interface1::PackedTriangularMatrix::baseDataType
DataType baseDataType
Definition: symmetric_matrix.h:868
daal::data_management::interface1::PackedTriangularMatrix::getPackedArray
services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1274
daal::data_management::interface1::BlockDescriptor
Base class that manages buffer memory for read/write operations required by numeric tables...
Definition: numeric_table.h:57
daal::data_management::interface1::PackedSymmetricMatrix::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:466
daal::data_management::interface1::PackedTriangularMatrix::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1269
daal::data_management::interface1::PackedSymmetricMatrix::PackedSymmetricMatrix
PackedSymmetricMatrix(const services::SharedPtr< DataType > &ptr, size_t nDim)
Definition: symmetric_matrix.h:144
daal::services::ErrorMemoryAllocationFailed
Definition: error_indexes.h:150
daal::data_management::interface1::PackedSymmetricMatrix::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:437
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:1219
daal::services::ErrorIncorrectNumberOfFeatures
Definition: error_indexes.h:72
daal::data_management::interface1::PackedSymmetricMatrix::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:429
daal::services::ErrorMemoryCopyFailedInternal
Definition: error_indexes.h:152
daal::data_management::interface1::NumericTableFeature
Data structure describes the Numeric Table feature.
Definition: data_dictionary.h:53
daal::data_management::interface1::PackedTriangularMatrix::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1240
daal::data_management::interface1::PackedSymmetricMatrix::releasePackedArray
services::Status releasePackedArray(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:493
daal::data_management::interface1::PackedTriangularMatrix::releasePackedArray
services::Status releasePackedArray(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1295
daal::data_management::interface1::PackedTriangularMatrix::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1236
daal::data_management::interface1::PackedTriangularMatrix::PackedTriangularMatrix
PackedTriangularMatrix(size_t nDim, NumericTable::AllocationFlag memoryAllocationFlag, const DataType &constValue)
Definition: symmetric_matrix.h:1068
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:442
daal::data_management::interface1::InputDataArchive
Provides methods to create an archive data object (serialized) and access this object.
Definition: data_archive.h:725
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:416
daal::data_management::interface1::PackedSymmetricMatrix::assign
virtual services::Status assign(int value) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:414
daal::data_management::interface1::PackedSymmetricMatrix::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:458
daal::algorithms::math::abs::value
Definition: abs_types.h:88
daal::data_management::interface1::PackedSymmetricMatrix::getPackedArray
services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:472
daal::algorithms::implicit_als::training::offset
Definition: implicit_als_training_types.h:150
daal::data_management::interface1::PackedTriangularMatrix::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1261
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:1245
daal::services::ErrorEmptyHomogenNumericTable
Definition: error_indexes.h:166
daal::data_management::interface1::PackedTriangularMatrix::PackedTriangularMatrix
PackedTriangularMatrix(const services::SharedPtr< DataType > &ptr, size_t nDim)
Definition: symmetric_matrix.h:892
daal::data_management::interface1::PackedTriangularMatrix::assign
virtual services::Status assign(float value) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1207
daal::data_management::interface1::PackedSymmetricMatrix::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:433
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:1255

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