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

symmetric_matrix.h
1 /* file: symmetric_matrix.h */
2 /*******************************************************************************
3 * Copyright 2014-2018 Intel Corporation
4 * All Rights Reserved.
5 *
6 * If this software was obtained under the Intel Simplified Software License,
7 * the following terms apply:
8 *
9 * The source code, information and material ("Material") contained herein is
10 * owned by Intel Corporation or its suppliers or licensors, and title to such
11 * Material remains with Intel Corporation or its suppliers or licensors. The
12 * Material contains proprietary information of Intel or its suppliers and
13 * licensors. The Material is protected by worldwide copyright laws and treaty
14 * provisions. No part of the Material may be used, copied, reproduced,
15 * modified, published, uploaded, posted, transmitted, distributed or disclosed
16 * in any way without Intel's prior express written permission. No license under
17 * any patent, copyright or other intellectual property rights in the Material
18 * is granted to or conferred upon you, either expressly, by implication,
19 * inducement, estoppel or otherwise. Any license under such intellectual
20 * property rights must be express and approved by Intel in writing.
21 *
22 * Unless otherwise agreed by Intel in writing, you may not remove or alter this
23 * notice or any other notice embedded in Materials by Intel or Intel's
24 * suppliers or licensors in any way.
25 *
26 *
27 * If this software was obtained under the Apache License, Version 2.0 (the
28 * "License"), the following terms apply:
29 *
30 * You may not use this file except in compliance with the License. You may
31 * obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
32 *
33 *
34 * Unless required by applicable law or agreed to in writing, software
35 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
36 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
37 *
38 * See the License for the specific language governing permissions and
39 * limitations under the License.
40 *******************************************************************************/
41 
42 /*
43 //++
44 // Declaration and implementation of a symmetric matrix.
45 //--
46 */
47 
48 
49 #ifndef __SYMMETRIC_MATRIX_H__
50 #define __SYMMETRIC_MATRIX_H__
51 
52 #include "data_management/data/numeric_table.h"
53 #include "services/daal_memory.h"
54 #include "services/daal_defines.h"
55 #include "data_management/data/data_serialize.h"
56 
57 namespace daal
58 {
59 namespace data_management
60 {
61 
62 namespace interface1
63 {
72 class PackedArrayNumericTableIface
73 {
74 public:
75  virtual ~PackedArrayNumericTableIface()
76  {}
85  virtual services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor<double> &block) = 0;
86 
95  virtual services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor<float> &block) = 0;
96 
105  virtual services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor<int> &block) = 0;
106 
111  virtual services::Status releasePackedArray(BlockDescriptor<double> &block) = 0;
112 
117  virtual services::Status releasePackedArray(BlockDescriptor<float> &block) = 0;
118 
123  virtual services::Status releasePackedArray(BlockDescriptor<int> &block) = 0;
124 };
125 
131 template<NumericTableIface::StorageLayout packedLayout, typename DataType = DAAL_DATA_TYPE>
132 class DAAL_EXPORT PackedSymmetricMatrix : public NumericTable, public PackedArrayNumericTableIface
133 {
134 public:
135  DECLARE_SERIALIZABLE_TAG();
136  DECLARE_SERIALIZABLE_IMPL();
137 
141  typedef DataType baseDataType;
142 
143 public:
150  PackedSymmetricMatrix( DataType *const ptr = 0, size_t nDim = 0 ):
151  NumericTable( nDim, nDim )
152  {
153  _layout = packedLayout;
154  this->_status |= setArray( services::SharedPtr<DataType>(ptr, services::EmptyDeleter()) );
155 
156  NumericTableFeature df;
157  df.setType<DataType>();
158  this->_status |= _ddict->setAllFeatures(df);
159  }
160 
167  PackedSymmetricMatrix( const services::SharedPtr<DataType> &ptr, size_t nDim ):
168  NumericTable( nDim, nDim )
169  {
170  _layout = packedLayout;
171  this->_status |= setArray( ptr );
172 
173  NumericTableFeature df;
174  df.setType<DataType>();
175  this->_status |= _ddict->setAllFeatures(df);
176  }
177 
178  PackedSymmetricMatrix( size_t nDim /*= 0*/ ):
179  NumericTable( nDim, nDim )
180  {
181  _layout = packedLayout;
182 
183  NumericTableFeature df;
184  df.setType<DataType>();
185  this->_status |= _ddict->setAllFeatures(df);
186  }
187 
195  static services::SharedPtr<PackedSymmetricMatrix> create(DataType *const ptr = 0, size_t nDim = 0,
196  services::Status* stat = NULL)
197  {
198  return create(services::SharedPtr<DataType>(ptr, services::EmptyDeleter()), nDim, stat);
199  }
200 
208  static services::SharedPtr<PackedSymmetricMatrix> create(const services::SharedPtr<DataType> &ptr, size_t nDim,
209  services::Status* stat = NULL)
210  {
211  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(PackedSymmetricMatrix, DAAL_TEMPLATE_ARGUMENTS(packedLayout,DataType), ptr, nDim);
212  }
213 
221  PackedSymmetricMatrix( DataType *const ptr, size_t nDim, const DataType &constValue ):
222  NumericTable( nDim, nDim )
223  {
224  _layout = packedLayout;
225  this->_status |= setArray( services::SharedPtr<DataType>(ptr, services::EmptyDeleter()) );
226 
227  NumericTableFeature df;
228  df.setType<DataType>();
229  this->_status |= _ddict->setAllFeatures(df);
230 
231  this->_status |= assign( constValue );
232  }
233 
241  PackedSymmetricMatrix( const services::SharedPtr<DataType>& ptr, size_t nDim, const DataType &constValue ) :
242  NumericTable( nDim, nDim )
243  {
244  _layout = packedLayout;
245  this->_status |= setArray( ptr );
246 
247  NumericTableFeature df;
248  df.setType<DataType>();
249  this->_status |= _ddict->setAllFeatures(df);
250 
251  this->_status |= assign( constValue );
252  }
253 
262  static services::SharedPtr<PackedSymmetricMatrix> create(DataType *const ptr, size_t nDim, const DataType &constValue,
263  services::Status* stat = NULL)
264  {
265  return create(services::SharedPtr<DataType>(ptr, services::EmptyDeleter()), nDim, constValue, stat);
266  }
267 
276  static services::SharedPtr<PackedSymmetricMatrix> create(const services::SharedPtr<DataType> &ptr, size_t nDim, const DataType &constValue,
277  services::Status* stat = NULL)
278  {
279  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(PackedSymmetricMatrix, DAAL_TEMPLATE_ARGUMENTS(packedLayout,DataType), ptr, nDim, constValue);
280  }
281 
288  PackedSymmetricMatrix( size_t nDim, AllocationFlag memoryAllocationFlag ):
289  NumericTable( nDim, nDim )
290  {
291  _layout = packedLayout;
292 
293  NumericTableFeature df;
294  df.setType<DataType>();
295  this->_status |= _ddict->setAllFeatures(df);
296 
297  if( memoryAllocationFlag == doAllocate ) this->_status |= allocateDataMemoryImpl();
298  }
299 
307  static services::SharedPtr<PackedSymmetricMatrix> create(size_t nDim, AllocationFlag memoryAllocationFlag,
308  services::Status* stat = NULL)
309  {
310  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(PackedSymmetricMatrix, DAAL_TEMPLATE_ARGUMENTS(packedLayout,DataType), nDim, memoryAllocationFlag);
311  }
312 
320  PackedSymmetricMatrix( size_t nDim, NumericTable::AllocationFlag memoryAllocationFlag,
321  const DataType &constValue ):
322  NumericTable( nDim, nDim )
323  {
324  _layout = packedLayout;
325 
326  NumericTableFeature df;
327  df.setType<DataType>();
328  this->_status |= _ddict->setAllFeatures(df);
329 
330  if( memoryAllocationFlag == doAllocate ) this->_status |= allocateDataMemoryImpl();
331  this->_status |= assign(constValue);
332  }
333 
342  static services::SharedPtr<PackedSymmetricMatrix> create(size_t nDim, NumericTable::AllocationFlag memoryAllocationFlag,
343  const DataType &constValue, services::Status* stat = NULL)
344  {
345  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(PackedSymmetricMatrix, DAAL_TEMPLATE_ARGUMENTS(packedLayout,DataType), \
346  nDim, memoryAllocationFlag, constValue);
347  }
348 
350  virtual ~PackedSymmetricMatrix()
351  {
352  freeDataMemoryImpl();
353  }
354 
359  DataType *getArray() const
360  {
361  return (DataType*)_ptr.get();
362  }
363 
368  services::SharedPtr<DataType> getArraySharedPtr() const
369  {
370  return services::reinterpretPointerCast<DataType, byte>(_ptr);
371  }
372 
377  services::Status setArray( DataType *const ptr )
378  {
379  freeDataMemoryImpl();
380  if( ptr == 0 )
381  return services::Status(services::ErrorEmptyHomogenNumericTable);
382 
383  _ptr = services::SharedPtr<byte>((byte*)ptr, services::EmptyDeleter());
384  _memStatus = userAllocated;
385  return services::Status();
386  }
387 
392  services::Status setArray( const services::SharedPtr<DataType>& ptr )
393  {
394  freeDataMemoryImpl();
395  if( ptr == 0 )
396  return services::Status(services::ErrorEmptyHomogenNumericTable);
397 
398  _ptr = services::reinterpretPointerCast<byte, DataType>(ptr);
399  _memStatus = userAllocated;
400  return services::Status();
401  }
402 
407  template <typename T>
408  services::Status assign(T value)
409  {
410  if( _memStatus == notAllocated )
411  return services::Status(services::ErrorEmptyHomogenNumericTable);
412 
413  size_t nDim = getNumberOfColumns();
414 
415  DataType * ptr = (DataType*)_ptr.get();
416  DataType valueDataType = (DataType)value;
417  for( size_t i = 0; i < (nDim * (nDim + 1)) / 2 ; i++ )
418  {
419  ptr[i] = valueDataType;
420  }
421  return services::Status();
422  }
423 
427  virtual services::Status assign(float value) DAAL_C11_OVERRIDE {return assign<DataType>((DataType)value);}
428 
432  virtual services::Status assign(double value) DAAL_C11_OVERRIDE {return assign<DataType>((DataType)value);}
433 
437  virtual services::Status assign(int value) DAAL_C11_OVERRIDE {return assign<DataType>((DataType)value);}
438 
439  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
440  {
441  return getTBlock<double>(vector_idx, vector_num, rwflag, block);
442  }
443  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
444  {
445  return getTBlock<float>(vector_idx, vector_num, rwflag, block);
446  }
447  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
448  {
449  return getTBlock<int>(vector_idx, vector_num, rwflag, block);
450  }
451 
452  services::Status releaseBlockOfRows(BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
453  {
454  return releaseTBlock<double>(block);
455  }
456  services::Status releaseBlockOfRows(BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
457  {
458  return releaseTBlock<float>(block);
459  }
460  services::Status releaseBlockOfRows(BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
461  {
462  return releaseTBlock<int>(block);
463  }
464 
465  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
466  ReadWriteMode rwflag, BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
467  {
468  return getTFeature<double>(feature_idx, vector_idx, value_num, rwflag, block);
469  }
470  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
471  ReadWriteMode rwflag, BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
472  {
473  return getTFeature<float>(feature_idx, vector_idx, value_num, rwflag, block);
474  }
475  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
476  ReadWriteMode rwflag, BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
477  {
478  return getTFeature<int>(feature_idx, vector_idx, value_num, rwflag, block);
479  }
480 
481  services::Status releaseBlockOfColumnValues(BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
482  {
483  return releaseTFeature<double>(block);
484  }
485  services::Status releaseBlockOfColumnValues(BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
486  {
487  return releaseTFeature<float>(block);
488  }
489  services::Status releaseBlockOfColumnValues(BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
490  {
491  return releaseTFeature<int>(block);
492  }
493 
494 
495  services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
496  {
497  return getTPackedArray<double>(rwflag, block);
498  }
499  services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
500  {
501  return getTPackedArray<float>(rwflag, block);
502  }
503  services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
504  {
505  return getTPackedArray<int>(rwflag, block);
506  }
507 
508  services::Status releasePackedArray(BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
509  {
510  return releaseTPackedArray<double>(block);
511  }
512  services::Status releasePackedArray(BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
513  {
514  return releaseTPackedArray<float>(block);
515  }
516  services::Status releasePackedArray(BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
517  {
518  return releaseTPackedArray<int>(block);
519  }
520 
521 protected:
522  services::SharedPtr<byte> _ptr;
523 
524  PackedSymmetricMatrix(const services::SharedPtr<DataType> &ptr, size_t nDim, services::Status &st):
525  NumericTable(nDim, nDim, DictionaryIface::notEqual, st)
526  {
527  _layout = packedLayout;
528  st |= setArray( ptr );
529 
530  NumericTableFeature df;
531  df.setType<DataType>();
532  st |= _ddict->setAllFeatures(df);
533  }
534 
535  PackedSymmetricMatrix(const services::SharedPtr<DataType>& ptr, size_t nDim, const DataType &constValue,
536  services::Status &st) :
537  NumericTable(nDim, nDim, DictionaryIface::notEqual, st)
538  {
539  _layout = packedLayout;
540  st |= setArray( ptr );
541 
542  NumericTableFeature df;
543  df.setType<DataType>();
544  st |= _ddict->setAllFeatures(df);
545 
546  st |= assign( constValue );
547  }
548 
549  PackedSymmetricMatrix(size_t nDim, AllocationFlag memoryAllocationFlag, services::Status &st):
550  NumericTable(nDim, nDim, DictionaryIface::notEqual, st)
551  {
552  _layout = packedLayout;
553 
554  NumericTableFeature df;
555  df.setType<DataType>();
556  st |= _ddict->setAllFeatures(df);
557 
558  if( memoryAllocationFlag == doAllocate ) st |= allocateDataMemoryImpl();
559  }
560 
561  PackedSymmetricMatrix(size_t nDim, NumericTable::AllocationFlag memoryAllocationFlag,
562  const DataType &constValue, services::Status &st):
563  NumericTable(nDim, nDim, DictionaryIface::notEqual, st)
564  {
565  _layout = packedLayout;
566 
567  NumericTableFeature df;
568  df.setType<DataType>();
569  st |= _ddict->setAllFeatures(df);
570 
571  if( memoryAllocationFlag == doAllocate ) st |= allocateDataMemoryImpl();
572  st |= assign(constValue);
573  }
574 
575  services::Status allocateDataMemoryImpl(daal::MemType type = daal::dram) DAAL_C11_OVERRIDE
576  {
577  freeDataMemoryImpl();
578 
579  size_t nDim = getNumberOfColumns();
580  size_t size = (nDim * (nDim + 1)) / 2;
581 
582  if( size == 0 )
583  return services::Status(getNumberOfColumns() == 0 ? services::ErrorIncorrectNumberOfFeatures :
584  services::ErrorIncorrectNumberOfObservations);
585 
586  _ptr = services::SharedPtr<byte>((byte *)daal::services::daal_malloc( size * sizeof(DataType) ), services::ServiceDeleter());
587 
588  if( _ptr == 0 )
589  return services::Status(services::ErrorMemoryAllocationFailed);
590 
591  _memStatus = internallyAllocated;
592  return services::Status();
593  }
594 
595  void freeDataMemoryImpl() DAAL_C11_OVERRIDE
596  {
597  _ptr.reset();
598  _memStatus = notAllocated;
599  }
600 
602  template<typename Archive, bool onDeserialize>
603  services::Status serialImpl( Archive *arch )
604  {
605  NumericTable::serialImpl<Archive, onDeserialize>( arch );
606 
607  if( onDeserialize )
608  {
609  allocateDataMemoryImpl();
610  }
611 
612  size_t nDim = getNumberOfColumns();
613  size_t size = (nDim * (nDim + 1)) / 2;
614 
615  arch->set( (DataType*)_ptr.get(), size );
616 
617  return services::Status();
618  }
619 
620 private:
621  template<typename T1, typename T2>
622  void internal_repack( size_t p, size_t n, T1 *src, T2 *dst )
623  {
624  if( IsSameType<T1, T2>::value )
625  {
626  if( src != (T1 *)dst )
627  {
628  daal::services::daal_memcpy_s(dst, n * p * sizeof(T1), src, n * p * sizeof(T1));
629  }
630  }
631  else
632  {
633  size_t i, j;
634 
635  for(i = 0; i < n; i++)
636  {
637  for(j = 0; j < p; j++)
638  {
639  dst[i * p + j] = static_cast<T2>(src[i * p + j]);
640  }
641  }
642  }
643  }
644 
645  template<typename T1, typename T2>
646  void internal_set_col_repack( size_t p, size_t n, T1 *src, T2 *dst )
647  {
648  size_t i;
649 
650  for(i = 0; i < n; i++)
651  {
652  dst[i * p] = static_cast<T2>(src[i]);
653  }
654  }
655 
656 protected:
657  baseDataType &getBaseValue( size_t dim, size_t rowIdx, size_t colIdx )
658  {
659  size_t rowStartOffset, colStartOffset;
660 
661  if( packedLayout == upperPackedSymmetricMatrix )
662  {
663  if( colIdx < rowIdx )
664  {
665  size_t tmp;
666  tmp = colIdx;
667  colIdx = rowIdx;
668  rowIdx = tmp;
669  }
670 
671  rowStartOffset = ((2 * dim - 1 * (rowIdx - 1)) * rowIdx) / 2; /* Arithmetic progression sum */
672  colStartOffset = colIdx - rowIdx;
673  }
674  else /* here lowerPackedSymmetricMatrix is supposed */
675  {
676  if( colIdx > rowIdx )
677  {
678  size_t tmp;
679  tmp = colIdx;
680  colIdx = rowIdx;
681  rowIdx = tmp;
682  }
683 
684  rowStartOffset = ((2 + 1 * (rowIdx - 1)) * rowIdx) / 2; /* Arithmetic progression sum */
685  colStartOffset = colIdx;
686 
687  }
688  return *((DataType*)_ptr.get() + rowStartOffset + colStartOffset);
689  }
690 
691  template <typename T>
692  T getValue( size_t dim, size_t rowIdx, size_t colIdx )
693  {
694  return static_cast<T>( getBaseValue( dim, rowIdx, colIdx ) );
695  }
696 
697  template <typename T>
698  services::Status setValue( size_t dim, size_t rowIdx, size_t colIdx, T value )
699  {
700  getBaseValue( dim, rowIdx, colIdx ) = static_cast<baseDataType>( value );
701  return services::Status();
702  }
703 
704  template <typename T>
705  services::Status getTBlock(size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T> &block)
706  {
707  size_t nDim = getNumberOfColumns();
708  block.setDetails( 0, idx, rwFlag );
709 
710  if (idx >= nDim)
711  {
712  block.resizeBuffer( nDim, 0 );
713  return services::Status();
714  }
715 
716  nrows = ( idx + nrows < nDim ) ? nrows : nDim - idx;
717 
718  if( !block.resizeBuffer( nDim, nrows ) )
719  return services::Status(services::ErrorMemoryAllocationFailed);
720 
721  if((rwFlag & (int)readOnly))
722  {
723  T *buffer = block.getBlockPtr();
724 
725  for(size_t iRow = 0; iRow < nrows; iRow++)
726  {
727  for(size_t iCol = 0; iCol < nDim; iCol++)
728  {
729  buffer[iRow * nDim + iCol] = getValue<T>(nDim, iRow + idx, iCol);
730  }
731  }
732  }
733  return services::Status();
734  }
735 
736  template <typename T>
737  services::Status releaseTBlock( BlockDescriptor<T> &block )
738  {
739  services::Status s;
740  if(block.getRWFlag() & (int)writeOnly)
741  {
742  size_t nDim = getNumberOfColumns();
743  size_t nrows = block.getNumberOfRows();
744  size_t idx = block.getRowsOffset();
745  T *buffer = block.getBlockPtr();
746 
747  for( size_t iRow = 0; iRow < nrows; iRow++ )
748  {
749  for( size_t iCol = 0; iCol < nDim; iCol++ )
750  {
751  s |= setValue<T>( nDim, idx + iRow, iCol, buffer[ iRow * nDim + iCol ] );
752  }
753  }
754  }
755  block.reset();
756  return s;
757  }
758 
759  template <typename T>
760  services::Status getTFeature(size_t feat_idx, size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T> &block)
761  {
762  size_t nDim = getNumberOfColumns();
763  block.setDetails( feat_idx, idx, rwFlag );
764 
765  if (idx >= nDim)
766  {
767  block.resizeBuffer( nDim, 0 );
768  return services::Status();
769  }
770 
771  nrows = ( idx + nrows < nDim ) ? nrows : nDim - idx;
772 
773  if( !block.resizeBuffer( 1, nrows ) )
774  return services::Status();
775 
776  if((block.getRWFlag() & (int)readOnly))
777  {
778  T *buffer = block.getBlockPtr();
779 
780  for(size_t iRow = 0; iRow < nrows; iRow++)
781  {
782  buffer[iRow] = getValue<T>(nDim, iRow + idx, feat_idx);
783  }
784  }
785  return services::Status();
786  }
787 
788  template <typename T>
789  services::Status releaseTFeature( BlockDescriptor<T> &block )
790  {
791  services::Status s;
792  if (block.getRWFlag() & (int)writeOnly)
793  {
794  size_t nDim = getNumberOfColumns();
795  size_t nrows = block.getNumberOfRows();
796  size_t idx = block.getRowsOffset();
797  size_t feat_idx = block.getColumnsOffset();
798  T *buffer = block.getBlockPtr();
799 
800  for( size_t iRow = 0; iRow < nrows; iRow++ )
801  {
802  s |= setValue<T>( nDim, iRow + idx, feat_idx, buffer[ iRow ] );
803  }
804  }
805  block.reset();
806  return s;
807  }
808 
809  template <typename T>
810  services::Status getTPackedArray( int rwFlag, BlockDescriptor<T> &block )
811  {
812  size_t nDim = getNumberOfColumns();
813  block.setDetails( 0, 0, rwFlag );
814 
815  size_t nSize = (nDim * (nDim + 1)) / 2;
816 
817  if( IsSameType<T, DataType>::value )
818  {
819  block.setPtr( &_ptr, _ptr.get(), 1, nSize );
820  return services::Status();
821  }
822 
823  if( !block.resizeBuffer( 1, nSize ) ) return services::Status();
824 
825  if( !(rwFlag & (int)readOnly) ) return services::Status();
826 
827  T *buffer = block.getBlockPtr();
828  DataType * ptr = (DataType*) _ptr.get();
829  for( size_t i = 0; i < nSize; i++ )
830  {
831  buffer[ i ] = static_cast<T>(*(ptr + i));
832  }
833  return services::Status();
834  }
835 
836  template <typename T>
837  services::Status releaseTPackedArray( BlockDescriptor<T> &block )
838  {
839  if( (block.getRWFlag() & (int)writeOnly) && !IsSameType<T, DataType>::value )
840  {
841  size_t nDim = getNumberOfColumns();
842  size_t nSize = (nDim * (nDim + 1)) / 2;
843  T *buffer = block.getBlockPtr();
844  DataType * ptr = (DataType*) _ptr.get();
845 
846  for( size_t i = 0; i < nSize; i++ )
847  {
848  *(ptr + i) = static_cast<baseDataType>(buffer[ i ]);
849  }
850  }
851  block.reset();
852  return services::Status();
853  }
854 
855  virtual services::Status setNumberOfColumnsImpl(size_t nDim) DAAL_C11_OVERRIDE
856  {
857  if( _ddict->getNumberOfFeatures() != nDim )
858  {
859  _ddict->setNumberOfFeatures( nDim );
860 
861  NumericTableFeature df;
862  df.setType<DataType>();
863  _ddict->setAllFeatures(df);
864  }
865 
866  _obsnum = nDim;
867  return services::Status();
868  }
869 
870  virtual services::Status setNumberOfRowsImpl(size_t nDim) DAAL_C11_OVERRIDE
871  {
872  setNumberOfColumnsImpl( nDim );
873  _obsnum = nDim;
874  return services::Status();
875  }
876 };
877 
883 template<NumericTableIface::StorageLayout packedLayout, typename DataType = DAAL_DATA_TYPE>
884 class DAAL_EXPORT PackedTriangularMatrix : public NumericTable, public PackedArrayNumericTableIface
885 {
886 public:
887  DECLARE_SERIALIZABLE_TAG();
888 
892  typedef DataType baseDataType;
893 
894 public:
900  PackedTriangularMatrix( DataType *const ptr = 0, size_t nDim = 0 ):
901  NumericTable( nDim, nDim )
902  {
903  _layout = packedLayout;
904  this->_status |= setArray( services::SharedPtr<DataType>(ptr, services::EmptyDeleter()) );
905 
906  NumericTableFeature df;
907  df.setType<DataType>();
908  this->_status |= _ddict->setAllFeatures(df);
909  }
910 
916  PackedTriangularMatrix( const services::SharedPtr<DataType> &ptr, size_t nDim ):
917  NumericTable( nDim, nDim )
918  {
919  _layout = packedLayout;
920  this->_status |= setArray( ptr );
921 
922  NumericTableFeature df;
923  df.setType<DataType>();
924  this->_status |= _ddict->setAllFeatures(df);
925  }
926 
927  PackedTriangularMatrix( size_t nDim /*= 0*/ ):
928  NumericTable( nDim, nDim )
929  {
930  _layout = packedLayout;
931 
932  NumericTableFeature df;
933  df.setType<DataType>();
934  this->_status |= _ddict->setAllFeatures(df);
935  }
936 
937  static services::SharedPtr<PackedTriangularMatrix> create(DataType *const ptr = 0, size_t nDim = 0,
938  services::Status* stat = NULL)
939  {
940  return create(services::SharedPtr<DataType>(ptr, services::EmptyDeleter()), nDim, stat);
941  }
942 
943  static services::SharedPtr<PackedTriangularMatrix> create(const services::SharedPtr<DataType> &ptr, size_t nDim,
944  services::Status* stat = NULL)
945  {
946  services::SharedPtr<PackedTriangularMatrix> ntPtr(new PackedTriangularMatrix(nDim));
947  if(ntPtr.get())
948  {
949  services::Status s = ntPtr->setArray(ptr);
950  if(!s)
951  ntPtr = services::SharedPtr<PackedTriangularMatrix>();
952  if(stat)
953  *stat = s;
954  }
955  else
956  {
957  if(stat)
958  *stat = services::Status(services::ErrorMemoryAllocationFailed);
959  }
960  return ntPtr;
961  }
962 
969  PackedTriangularMatrix( DataType *const ptr, size_t nDim, const DataType &constValue ):
970  NumericTable( nDim, nDim )
971  {
972  _layout = packedLayout;
973  this->_status |= setArray( services::SharedPtr<DataType>(ptr, services::EmptyDeleter()) );
974 
975  NumericTableFeature df;
976  df.setType<DataType>();
977  this->_status |= _ddict->setAllFeatures(df);
978 
979  this->_status |= assign( constValue );
980  }
981 
988  PackedTriangularMatrix( const services::SharedPtr<DataType>& ptr, size_t nDim, const DataType &constValue ) :
989  NumericTable( nDim, nDim )
990  {
991  _layout = packedLayout;
992  this->_status |= setArray( ptr );
993 
994  NumericTableFeature df;
995  df.setType<DataType>();
996  this->_status |= _ddict->setAllFeatures(df);
997 
998  this->_status |= assign( constValue );
999  }
1000 
1001  static services::SharedPtr<PackedTriangularMatrix> create(DataType *const ptr, size_t nDim, const DataType &constValue,
1002  services::Status* stat = NULL)
1003  {
1004  services::SharedPtr<PackedTriangularMatrix> ntPtr(new PackedTriangularMatrix(nDim));
1005  if(ntPtr.get())
1006  {
1007  services::Status s = ntPtr->setArray( services::SharedPtr<DataType>(ptr, services::EmptyDeleter()) );
1008  s.add(ntPtr->assign(constValue));
1009  if(!s)
1010  ntPtr = services::SharedPtr<PackedTriangularMatrix>();
1011  if(stat)
1012  *stat = s;
1013  }
1014  else
1015  {
1016  if(stat)
1017  *stat = services::Status(services::ErrorMemoryAllocationFailed);
1018  }
1019  return ntPtr;
1020  }
1021 
1022  static services::SharedPtr<PackedTriangularMatrix> create(services::SharedPtr<DataType> &ptr, size_t nDim, const DataType &constValue,
1023  services::Status* stat = NULL)
1024  {
1025  services::SharedPtr<PackedTriangularMatrix> ntPtr(new PackedTriangularMatrix(nDim));
1026  if(ntPtr.get())
1027  {
1028  services::Status s = ntPtr->setArray(ptr);
1029  s.add(ntPtr->assign(constValue));
1030  if(!s)
1031  ntPtr = services::SharedPtr<PackedTriangularMatrix>();
1032  if(stat)
1033  *stat = s;
1034  }
1035  else
1036  {
1037  if(stat)
1038  *stat = services::Status(services::ErrorMemoryAllocationFailed);
1039  }
1040  return ntPtr;
1041  }
1042 
1048  PackedTriangularMatrix( size_t nDim, AllocationFlag memoryAllocationFlag ):
1049  NumericTable( nDim, nDim )
1050  {
1051  _layout = packedLayout;
1052 
1053  NumericTableFeature df;
1054  df.setType<DataType>();
1055  this->_status |= _ddict->setAllFeatures(df);
1056 
1057  if( memoryAllocationFlag == doAllocate ) this->_status |= allocateDataMemoryImpl();
1058  }
1059 
1060  static services::SharedPtr<PackedTriangularMatrix> create(size_t nDim, AllocationFlag memoryAllocationFlag,
1061  services::Status* stat = NULL)
1062  {
1063  services::SharedPtr<PackedTriangularMatrix> ntPtr(new PackedTriangularMatrix(nDim));
1064  if(ntPtr.get())
1065  {
1066  services::Status s;
1067  if(memoryAllocationFlag == doAllocate)
1068  {
1069  s = ntPtr->allocateDataMemoryImpl();
1070  if(!s)
1071  ntPtr = services::SharedPtr<PackedTriangularMatrix>();
1072  }
1073  if(!s)
1074  ntPtr = services::SharedPtr<PackedTriangularMatrix>();
1075  if(stat)
1076  *stat = s;
1077  }
1078  else
1079  {
1080  if(stat)
1081  *stat = services::Status(services::ErrorMemoryAllocationFailed);
1082  }
1083  return ntPtr;
1084  }
1085 
1092  PackedTriangularMatrix( size_t nDim, NumericTable::AllocationFlag memoryAllocationFlag,
1093  const DataType &constValue ):
1094  NumericTable( nDim, nDim )
1095  {
1096  _layout = packedLayout;
1097 
1098  NumericTableFeature df;
1099  df.setType<DataType>();
1100  this->_status |= _ddict->setAllFeatures(df);
1101 
1102  if( memoryAllocationFlag == doAllocate ) this->_status |= allocateDataMemoryImpl();
1103  this->_status |= assign(constValue);
1104  }
1105 
1106  static services::SharedPtr<PackedTriangularMatrix> create(size_t nDim, NumericTable::AllocationFlag memoryAllocationFlag,
1107  const DataType &constValue, services::Status* stat = NULL)
1108  {
1109  services::SharedPtr<PackedTriangularMatrix> ntPtr(new PackedTriangularMatrix(nDim));
1110  if(ntPtr.get())
1111  {
1112  services::Status s;
1113  if(memoryAllocationFlag == doAllocate)
1114  {
1115  s = ntPtr->allocateDataMemoryImpl();
1116  s.add(ntPtr->assign(constValue));
1117  if(!s)
1118  ntPtr = services::SharedPtr<PackedTriangularMatrix>();
1119  }
1120  if(!s)
1121  ntPtr = services::SharedPtr<PackedTriangularMatrix>();
1122  if(stat)
1123  *stat = s;
1124  }
1125  else
1126  {
1127  if(stat)
1128  *stat = services::Status(services::ErrorMemoryAllocationFailed);
1129  }
1130  return ntPtr;
1131  }
1132 
1134  virtual ~PackedTriangularMatrix()
1135  {
1136  freeDataMemoryImpl();
1137  }
1138 
1139  virtual services::Status setNumberOfColumns(size_t nDim) DAAL_C11_OVERRIDE
1140  {
1141  if( _ddict->getNumberOfFeatures() != nDim )
1142  {
1143  _ddict->setNumberOfFeatures( nDim );
1144 
1145  NumericTableFeature df;
1146  df.setType<DataType>();
1147  _ddict->setAllFeatures(df);
1148  }
1149 
1150  _obsnum = nDim;
1151  return services::Status();
1152  }
1153 
1154  virtual services::Status setNumberOfRows(size_t nDim) DAAL_C11_OVERRIDE
1155  {
1156  return setNumberOfColumns( nDim );
1157  }
1158 
1163  DataType *getArray() const
1164  {
1165  return (DataType*)_ptr.get();
1166  }
1167 
1172  services::SharedPtr<DataType> getArraySharedPtr() const
1173  {
1174  return services::reinterpretPointerCast<DataType, byte>(_ptr);
1175  }
1176 
1181  services::Status setArray( DataType *const ptr )
1182  {
1183  freeDataMemoryImpl();
1184  if( ptr == 0 )
1185  return services::Status(services::ErrorEmptyHomogenNumericTable);
1186 
1187  _ptr = services::SharedPtr<byte>((DataType*)ptr, services::EmptyDeleter());
1188  _memStatus = userAllocated;
1189  return services::Status();
1190  }
1191 
1196  services::Status setArray( const services::SharedPtr<DataType>& ptr )
1197  {
1198  freeDataMemoryImpl();
1199  if( ptr == 0 )
1200  return services::Status(services::ErrorEmptyHomogenNumericTable);
1201 
1202  _ptr = services::reinterpretPointerCast<byte, DataType>(ptr);
1203  _memStatus = userAllocated;
1204  return services::Status();
1205  }
1206 
1211  template <typename T>
1212  services::Status assign(T value)
1213  {
1214  if( _memStatus == notAllocated )
1215  return services::Status(services::ErrorEmptyHomogenNumericTable);
1216 
1217  size_t nDim = getNumberOfColumns();
1218 
1219  DataType * ptr = (DataType*)_ptr.get();
1220  DataType valueDataType = (DataType)value;
1221  for( size_t i = 0; i < (nDim * (nDim + 1)) / 2 ; i++ )
1222  {
1223  ptr[i] = valueDataType;
1224  }
1225  return services::Status();
1226  }
1227 
1231  virtual services::Status assign(float value) DAAL_C11_OVERRIDE {return assign<DataType>((DataType)value);}
1232 
1236  virtual services::Status assign(double value) DAAL_C11_OVERRIDE {return assign<DataType>((DataType)value);}
1237 
1241  virtual services::Status assign(int value) DAAL_C11_OVERRIDE {return assign<DataType>((DataType)value);}
1242 
1243  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
1244  {
1245  return getTBlock<double>(vector_idx, vector_num, rwflag, block);
1246  }
1247  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
1248  {
1249  return getTBlock<float>(vector_idx, vector_num, rwflag, block);
1250  }
1251  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
1252  {
1253  return getTBlock<int>(vector_idx, vector_num, rwflag, block);
1254  }
1255 
1256  services::Status releaseBlockOfRows(BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
1257  {
1258  return releaseTBlock<double>(block);
1259  }
1260  services::Status releaseBlockOfRows(BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
1261  {
1262  return releaseTBlock<float>(block);
1263  }
1264  services::Status releaseBlockOfRows(BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
1265  {
1266  return releaseTBlock<int>(block);
1267  }
1268 
1269  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
1270  ReadWriteMode rwflag, BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
1271  {
1272  return getTFeature<double>(feature_idx, vector_idx, value_num, rwflag, block);
1273  }
1274  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
1275  ReadWriteMode rwflag, BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
1276  {
1277  return getTFeature<float>(feature_idx, vector_idx, value_num, rwflag, block);
1278  }
1279  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
1280  ReadWriteMode rwflag, BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
1281  {
1282  return getTFeature<int>(feature_idx, vector_idx, value_num, rwflag, block);
1283  }
1284 
1285  services::Status releaseBlockOfColumnValues(BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
1286  {
1287  return releaseTFeature<double>(block);
1288  }
1289  services::Status releaseBlockOfColumnValues(BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
1290  {
1291  return releaseTFeature<float>(block);
1292  }
1293  services::Status releaseBlockOfColumnValues(BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
1294  {
1295  return releaseTFeature<int>(block);
1296  }
1297 
1298  services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
1299  {
1300  return getTPackedArray<double>(rwflag, block);
1301  }
1302  services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
1303  {
1304  return getTPackedArray<float>(rwflag, block);
1305  }
1306  services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
1307  {
1308  return getTPackedArray<int>(rwflag, block);
1309  }
1310 
1311  services::Status releasePackedArray(BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
1312  {
1313  return releaseTPackedArray<double>(block);
1314  }
1315  services::Status releasePackedArray(BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
1316  {
1317  return releaseTPackedArray<float>(block);
1318  }
1319  services::Status releasePackedArray(BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
1320  {
1321  return releaseTPackedArray<int>(block);
1322  }
1323 
1325  services::Status serializeImpl (InputDataArchive *arch) DAAL_C11_OVERRIDE
1326  {
1327  serialImpl<InputDataArchive, false>( arch );
1328 
1329  return services::Status();
1330  }
1331 
1333  services::Status deserializeImpl(const OutputDataArchive *arch) DAAL_C11_OVERRIDE
1334  {
1335  serialImpl<const OutputDataArchive, true>( arch );
1336 
1337  return services::Status();
1338  }
1339 
1340 protected:
1341  services::SharedPtr<byte> _ptr;
1342 
1343  services::Status allocateDataMemoryImpl(daal::MemType type = daal::dram) DAAL_C11_OVERRIDE
1344  {
1345  freeDataMemoryImpl();
1346 
1347  size_t nDim = getNumberOfColumns();
1348  size_t size = (nDim * (nDim + 1)) / 2;
1349 
1350  if( size == 0 )
1351  return services::Status(getNumberOfColumns() == 0 ? services::ErrorIncorrectNumberOfFeatures :
1352  services::ErrorIncorrectNumberOfObservations);
1353 
1354  _ptr = services::SharedPtr<byte>((byte *)daal::services::daal_malloc( size * sizeof(DataType) ), services::ServiceDeleter());
1355 
1356  if( _ptr == 0 )
1357  return services::Status(services::ErrorMemoryAllocationFailed);
1358 
1359  _memStatus = internallyAllocated;
1360  return services::Status();
1361  }
1362 
1363  void freeDataMemoryImpl() DAAL_C11_OVERRIDE
1364  {
1365  _ptr.reset();
1366  _memStatus = notAllocated;
1367  }
1368 
1370  template<typename Archive, bool onDeserialize>
1371  services::Status serialImpl( Archive *arch )
1372  {
1373  NumericTable::serialImpl<Archive, onDeserialize>( arch );
1374 
1375  if( onDeserialize )
1376  {
1377  allocateDataMemoryImpl();
1378  }
1379 
1380  size_t nDim = getNumberOfColumns();
1381  size_t size = (nDim * (nDim + 1)) / 2;
1382 
1383  arch->set( (DataType*)_ptr.get(), size );
1384 
1385  return services::Status();
1386  }
1387 
1388 private:
1389  template<typename T1, typename T2>
1390  void internal_repack( size_t p, size_t n, T1 *src, T2 *dst )
1391  {
1392  if( IsSameType<T1, T2>::value )
1393  {
1394  if( src != (T1 *)dst )
1395  {
1396  daal::services::daal_memcpy_s(dst, n * p * sizeof(T1), src, n * p * sizeof(T1));
1397  }
1398  }
1399  else
1400  {
1401  size_t i, j;
1402 
1403  for(i = 0; i < n; i++)
1404  {
1405  for(j = 0; j < p; j++)
1406  {
1407  dst[i * p + j] = static_cast<T2>(src[i * p + j]);
1408  }
1409  }
1410  }
1411  }
1412 
1413  template<typename T1, typename T2>
1414  void internal_set_col_repack( size_t p, size_t n, T1 *src, T2 *dst )
1415  {
1416  size_t i;
1417 
1418  for(i = 0; i < n; i++)
1419  {
1420  dst[i * p] = static_cast<T2>(src[i]);
1421  }
1422  }
1423 
1424 protected:
1425  baseDataType &getBaseValue( size_t dim, size_t rowIdx, size_t colIdx, baseDataType &zero )
1426  {
1427  size_t rowStartOffset, colStartOffset;
1428 
1429  if( packedLayout == upperPackedTriangularMatrix )
1430  {
1431  if( colIdx < rowIdx )
1432  {
1433  return zero;
1434  }
1435 
1436  rowStartOffset = ((2 * dim - 1 * (rowIdx - 1)) * rowIdx) / 2; /* Arithmetic progression sum */
1437  colStartOffset = colIdx - rowIdx;
1438  }
1439  else /* here lowerPackedTriangularMatrix is supposed */
1440  {
1441  if( colIdx > rowIdx )
1442  {
1443  return zero;
1444  }
1445 
1446  rowStartOffset = ((2 + 1 * (rowIdx - 1)) * rowIdx) / 2; /* Arithmetic progression sum */
1447  colStartOffset = colIdx;
1448 
1449  }
1450  return *((DataType*)_ptr.get() + rowStartOffset + colStartOffset);
1451  }
1452 
1453  template <typename T>
1454  T getValue( size_t dim, size_t rowIdx, size_t colIdx )
1455  {
1456  baseDataType zero = (baseDataType)0;
1457  return static_cast<T>( getBaseValue( dim, rowIdx, colIdx, zero ) );
1458  }
1459 
1460  template <typename T>
1461  services::Status setValue( size_t dim, size_t rowIdx, size_t colIdx, T value )
1462  {
1463  baseDataType zero = (baseDataType)0;
1464  getBaseValue( dim, rowIdx, colIdx, zero ) = static_cast<baseDataType>( value );
1465  return services::Status();
1466  }
1467 
1468  template <typename T>
1469  services::Status getTBlock(size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T> &block)
1470  {
1471  size_t nDim = getNumberOfColumns();
1472  block.setDetails( 0, idx, rwFlag );
1473 
1474  if (idx >= nDim)
1475  {
1476  block.resizeBuffer( nDim, 0 );
1477  return services::Status();
1478  }
1479 
1480  nrows = ( idx + nrows < nDim ) ? nrows : nDim - idx;
1481 
1482  if( !block.resizeBuffer( nDim, nrows ) )
1483  return services::Status(services::ErrorMemoryAllocationFailed);
1484 
1485  if((rwFlag & (int)readOnly))
1486  {
1487  T *buffer = block.getBlockPtr();
1488 
1489  for(size_t iRow = 0; iRow < nrows; iRow++)
1490  {
1491  for(size_t iCol = 0; iCol < nDim; iCol++)
1492  {
1493  buffer[iRow * nDim + iCol] = getValue<T>(nDim, iRow + idx, iCol);
1494  }
1495  }
1496  }
1497  return services::Status();
1498  }
1499 
1500  template <typename T>
1501  services::Status releaseTBlock( BlockDescriptor<T> &block )
1502  {
1503  services::Status s;
1504  if(block.getRWFlag() & (int)writeOnly)
1505  {
1506  size_t nDim = getNumberOfColumns();
1507  size_t nrows = block.getNumberOfRows();
1508  size_t idx = block.getRowsOffset();
1509  T *buffer = block.getBlockPtr();
1510 
1511  for( size_t iRow = 0; iRow < nrows; iRow++ )
1512  {
1513  for( size_t iCol = 0; iCol < nDim; iCol++ )
1514  {
1515  s |= setValue<T>( nDim, iRow + idx, iCol, buffer[ iRow * nDim + iCol ] );
1516  }
1517  }
1518  }
1519  block.reset();
1520  return s;
1521  }
1522 
1523  template <typename T>
1524  services::Status getTFeature(size_t feat_idx, size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T> &block)
1525  {
1526  size_t nDim = getNumberOfColumns();
1527  block.setDetails( feat_idx, idx, rwFlag );
1528 
1529  if (idx >= nDim)
1530  {
1531  block.resizeBuffer( nDim, 0 );
1532  return services::Status();
1533  }
1534 
1535  nrows = ( idx + nrows < nDim ) ? nrows : nDim - idx;
1536 
1537  if( !block.resizeBuffer( 1, nrows ) )
1538  return services::Status();
1539 
1540  if((block.getRWFlag() & (int)readOnly))
1541  {
1542  T *buffer = block.getBlockPtr();
1543  for( size_t iRow = 0; iRow < nrows; iRow++ )
1544  {
1545  buffer[ iRow ] = getValue<T>( nDim, iRow + idx, feat_idx );
1546  }
1547  }
1548  return services::Status();
1549  }
1550 
1551  template <typename T>
1552  services::Status releaseTFeature( BlockDescriptor<T> &block )
1553  {
1554  services::Status s;
1555  if (block.getRWFlag() & (int)writeOnly)
1556  {
1557  size_t nDim = getNumberOfColumns();
1558  size_t nrows = block.getNumberOfRows();
1559  size_t idx = block.getRowsOffset();
1560  size_t feat_idx = block.getColumnsOffset();
1561  T *buffer = block.getBlockPtr();
1562 
1563  for( size_t iRow = 0; iRow < nrows; iRow++ )
1564  {
1565  s |= setValue<T>( nDim, iRow + idx, feat_idx, buffer[ iRow ] );
1566  }
1567  }
1568  block.reset();
1569  return s;
1570  }
1571 
1572  template <typename T>
1573  services::Status getTPackedArray( int rwFlag, BlockDescriptor<T> &block )
1574  {
1575  size_t nDim = getNumberOfColumns();
1576  block.setDetails( 0, 0, rwFlag );
1577 
1578  size_t nSize = (nDim * (nDim + 1)) / 2;
1579 
1580  if( IsSameType<T, DataType>::value )
1581  {
1582  block.setPtr( &_ptr, _ptr.get(), 1, nSize );
1583  return services::Status();
1584  }
1585 
1586  if( !block.resizeBuffer( 1, nSize ) ) return services::Status();
1587 
1588  if( !(rwFlag & (int)readOnly) ) return services::Status();
1589 
1590  T *buffer = block.getBlockPtr();
1591  DataType * ptr = (DataType*)_ptr.get();
1592  for( size_t i = 0; i < nSize; i++ )
1593  {
1594  buffer[ i ] = static_cast<T>(*(ptr + i));
1595  }
1596  return services::Status();
1597  }
1598 
1599  template <typename T>
1600  services::Status releaseTPackedArray( BlockDescriptor<T> &block )
1601  {
1602  if( (block.getRWFlag() & (int)writeOnly) && !IsSameType<T, DataType>::value )
1603  {
1604  size_t nDim = getNumberOfColumns();
1605  size_t nSize = (nDim * (nDim + 1)) / 2;
1606  T *buffer = block.getBlockPtr();
1607  DataType * ptr = (DataType*)_ptr.get();
1608 
1609  for( size_t i = 0; i < nSize; i++ )
1610  {
1611  *(ptr + i) = static_cast<baseDataType>(buffer[ i ]);
1612  }
1613  }
1614  block.reset();
1615  return services::Status();
1616  }
1617 
1618  virtual services::Status setNumberOfColumnsImpl(size_t nDim) DAAL_C11_OVERRIDE
1619  {
1620  if( _ddict->getNumberOfFeatures() != nDim )
1621  {
1622  _ddict->setNumberOfFeatures( nDim );
1623 
1624  NumericTableFeature df;
1625  df.setType<DataType>();
1626  _ddict->setAllFeatures(df);
1627  }
1628 
1629  _obsnum = nDim;
1630  return services::Status();
1631  }
1632 
1633  virtual services::Status setNumberOfRowsImpl(size_t nDim) DAAL_C11_OVERRIDE
1634  {
1635  setNumberOfColumnsImpl( nDim );
1636  _obsnum = nDim;
1637  return services::Status();
1638  }
1639 };
1641 } // namespace interface1
1642 using interface1::PackedArrayNumericTableIface;
1643 using interface1::PackedSymmetricMatrix;
1644 using interface1::PackedTriangularMatrix;
1645 
1646 }
1647 } // namespace daal
1648 #endif
daal::IsSameType
Definition: daal_defines.h:169
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:470
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:1274
daal::data_management::interface1::NumericTableIface::AllocationFlag
AllocationFlag
Enumeration to specify whether the Numeric Table must allocate memory.
Definition: numeric_table.h:309
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:1269
daal::data_management::interface1::PackedSymmetricMatrix::releasePackedArray
services::Status releasePackedArray(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:512
daal::services::interface1::Status
Class that holds the results of API calls. In case of API routine failure it contains the list of err...
Definition: error_handling.h:491
daal
Definition: algorithm_base_common.h:57
daal::data_management::interface1::InputDataArchive
Provides methods to create an archive data object (serialized) and access this object.
Definition: data_archive.h:715
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:443
daal::data_management::interface1::PackedTriangularMatrix::PackedTriangularMatrix
PackedTriangularMatrix(DataType *const ptr=0, size_t nDim=0)
Definition: symmetric_matrix.h:900
daal::data_management::interface1::PackedSymmetricMatrix::releasePackedArray
services::Status releasePackedArray(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:508
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:439
daal::services::interface1::Status::add
Status & add(ErrorID id)
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:475
daal::data_management::interface1::PackedTriangularMatrix::setArray
services::Status setArray(DataType *const ptr)
Definition: symmetric_matrix.h:1181
daal::data_management::interface1::PackedSymmetricMatrix::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:489
daal::data_management::interface1::PackedTriangularMatrix::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1289
daal::data_management::interface1::PackedSymmetricMatrix::setArray
services::Status setArray(DataType *const ptr)
Definition: symmetric_matrix.h:377
daal::data_management::interface1::PackedTriangularMatrix::getArray
DataType * getArray() const
Definition: symmetric_matrix.h:1163
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:1279
daal::data_management::interface1::PackedArrayNumericTableIface
Abstract class that defines the interface of symmetric matrices stored as a one-dimensional array...
Definition: symmetric_matrix.h:72
daal::data_management::interface1::PackedSymmetricMatrix::getArraySharedPtr
services::SharedPtr< DataType > getArraySharedPtr() const
Definition: symmetric_matrix.h:368
daal::data_management::interface1::PackedSymmetricMatrix::PackedSymmetricMatrix
PackedSymmetricMatrix(size_t nDim, NumericTable::AllocationFlag memoryAllocationFlag, const DataType &constValue)
Definition: symmetric_matrix.h:320
daal::data_management::interface1::PackedTriangularMatrix::getPackedArray
services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1298
daal::data_management::interface1::PackedTriangularMatrix::baseDataType
DataType baseDataType
Definition: symmetric_matrix.h:892
daal::data_management::interface1::PackedSymmetricMatrix::setArray
services::Status setArray(const services::SharedPtr< DataType > &ptr)
Definition: symmetric_matrix.h:392
daal::data_management::interface1::PackedTriangularMatrix::releasePackedArray
services::Status releasePackedArray(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1311
daal::data_management::interface1::PackedTriangularMatrix::PackedTriangularMatrix
PackedTriangularMatrix(DataType *const ptr, size_t nDim, const DataType &constValue)
Definition: symmetric_matrix.h:969
daal::services::ErrorMemoryAllocationFailed
Definition: error_indexes.h:172
daal::dram
Definition: daal_defines.h:159
daal::data_management::interface1::PackedTriangularMatrix::getPackedArray
services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1306
daal::data_management::interface1::BlockDescriptor::getBlockPtr
DataType * getBlockPtr() const
Definition: numeric_table.h:95
daal::data_management::interface1::PackedTriangularMatrix::PackedTriangularMatrix
PackedTriangularMatrix(const services::SharedPtr< DataType > &ptr, size_t nDim)
Definition: symmetric_matrix.h:916
daal::data_management::interface1::PackedSymmetricMatrix::getPackedArray
services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:495
daal::services::ErrorIncorrectNumberOfFeatures
Definition: error_indexes.h:96
daal::data_management::interface1::PackedSymmetricMatrix::baseDataType
DataType baseDataType
Definition: symmetric_matrix.h:141
daal::data_management::interface1::PackedSymmetricMatrix::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:452
daal_defines.h
daal::data_management::interface1::PackedSymmetricMatrix::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:481
daal::data_management::interface1::PackedTriangularMatrix::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1293
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:447
daal::data_management::interface1::BlockDescriptor::resizeBuffer
bool resizeBuffer(size_t nColumns, size_t nRows, size_t auxMemorySize=0)
Definition: numeric_table.h:177
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:465
daal::data_management::interface1::PackedTriangularMatrix::getPackedArray
services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1302
daal::data_management::interface1::PackedTriangularMatrix::setNumberOfRows
virtual services::Status setNumberOfRows(size_t nDim) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1154
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:1236
daal::data_management::interface1::PackedTriangularMatrix::setArray
services::Status setArray(const services::SharedPtr< DataType > &ptr)
Definition: symmetric_matrix.h:1196
daal::data_management::interface1::PackedTriangularMatrix::assign
virtual services::Status assign(int value) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1241
daal::services::interface1::SharedPtr
Shared pointer that retains shared ownership of an object through a pointer. Several SharedPtr object...
Definition: daal_shared_ptr.h:187
daal::data_management::interface1::PackedTriangularMatrix::getArraySharedPtr
services::SharedPtr< DataType > getArraySharedPtr() const
Definition: symmetric_matrix.h:1172
daal::data_management::interface1::PackedSymmetricMatrix::PackedSymmetricMatrix
PackedSymmetricMatrix(DataType *const ptr=0, size_t nDim=0)
Definition: symmetric_matrix.h:150
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:132
daal::data_management::interface1::PackedSymmetricMatrix::getPackedArray
services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:503
daal::data_management::interface1::PackedTriangularMatrix::setNumberOfColumns
virtual services::Status setNumberOfColumns(size_t nDim) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1139
daal::services::interface1::SharedPtr::get
T * get() const
Definition: daal_shared_ptr.h:332
daal::data_management::interface1::NumericTable
Class for a data management component responsible for representation of data in the numeric format...
Definition: numeric_table.h:600
daal::data_management::interface1::PackedSymmetricMatrix::PackedSymmetricMatrix
PackedSymmetricMatrix(const services::SharedPtr< DataType > &ptr, size_t nDim)
Definition: symmetric_matrix.h:167
daal::data_management::interface1::PackedSymmetricMatrix::PackedSymmetricMatrix
PackedSymmetricMatrix(size_t nDim, AllocationFlag memoryAllocationFlag)
Definition: symmetric_matrix.h:288
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:1251
daal::data_management::interface1::PackedSymmetricMatrix::assign
services::Status assign(T value)
Definition: symmetric_matrix.h:408
daal::data_management::interface1::PackedSymmetricMatrix::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:460
daal::services::interface1::SharedPtr::reset
void reset()
Definition: daal_shared_ptr.h:265
daal::data_management::interface1::OutputDataArchive
Provides methods to restore an object from its serialized counterpart and access the restored object...
Definition: data_archive.h:978
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:262
daal::data_management::interface1::PackedSymmetricMatrix::PackedSymmetricMatrix
PackedSymmetricMatrix(DataType *const ptr, size_t nDim, const DataType &constValue)
Definition: symmetric_matrix.h:221
daal::data_management::interface1::PackedSymmetricMatrix::assign
virtual services::Status assign(int value) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:437
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:195
daal::data_management::interface1::PackedTriangularMatrix::assign
virtual services::Status assign(float value) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1231
daal::data_management::interface1::BlockDescriptor::getRWFlag
size_t getRWFlag() const
Definition: numeric_table.h:244
daal::data_management::interface1::PackedSymmetricMatrix::assign
virtual services::Status assign(double value) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:432
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:276
daal::data_management::interface1::PackedTriangularMatrix::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1256
daal::services::interface1::ServiceDeleter
Implementation of DeleterIface to destroy a pointer by the daal_free function.
Definition: daal_shared_ptr.h:110
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:1247
daal::data_management::interface1::PackedSymmetricMatrix::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:485
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:208
daal::data_management::interface1::PackedSymmetricMatrix::getPackedArray
services::Status getPackedArray(ReadWriteMode rwflag, BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:499
daal::data_management::interface1::BlockDescriptor::reset
void reset()
Definition: numeric_table.h:132
daal::data_management::interface1::PackedTriangularMatrix::PackedTriangularMatrix
PackedTriangularMatrix(const services::SharedPtr< DataType > &ptr, size_t nDim, const DataType &constValue)
Definition: symmetric_matrix.h:988
daal::data_management::interface1::BlockDescriptor::getColumnsOffset
size_t getColumnsOffset() const
Definition: numeric_table.h:232
daal::data_management::interface1::PackedSymmetricMatrix::getArray
DataType * getArray() const
Definition: symmetric_matrix.h:359
daal::data_management::interface1::BlockDescriptor
Base class that manages buffer memory for read/write operations required by numeric tables...
Definition: numeric_table.h:81
daal::algorithms::math::abs::value
Definition: abs_types.h:112
daal::data_management::interface1::NumericTableFeature::setType
void setType()
Definition: data_dictionary.h:117
daal::data_management::interface1::PackedSymmetricMatrix::create
static services::SharedPtr< PackedSymmetricMatrix > create(size_t nDim, AllocationFlag memoryAllocationFlag, services::Status *stat=NULL)
Definition: symmetric_matrix.h:307
daal::services::ErrorIncorrectNumberOfObservations
Definition: error_indexes.h:97
daal::data_management::interface1::BlockDescriptor::getNumberOfRows
size_t getNumberOfRows() const
Definition: numeric_table.h:127
daal::data_management::interface1::PackedSymmetricMatrix::PackedSymmetricMatrix
PackedSymmetricMatrix(const services::SharedPtr< DataType > &ptr, size_t nDim, const DataType &constValue)
Definition: symmetric_matrix.h:241
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:1212
daal::data_management::interface1::BlockDescriptor::setDetails
void setDetails(size_t columnIdx, size_t rowIdx, int rwFlag)
Definition: numeric_table.h:221
daal::data_management::interface1::PackedSymmetricMatrix::releasePackedArray
services::Status releasePackedArray(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:516
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:884
daal::data_management::interface1::PackedTriangularMatrix::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1260
daal::data_management::interface1::BlockDescriptor::setPtr
void setPtr(DataType *ptr, size_t nColumns, size_t nRows)
Definition: numeric_table.h:148
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:1243
daal::services::interface1::EmptyDeleter
Implementation of DeleterIface without pointer destroying.
Definition: daal_shared_ptr.h:125
daal::data_management::interface1::BlockDescriptor::getRowsOffset
size_t getRowsOffset() const
Definition: numeric_table.h:238
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:342
daal::data_management::interface1::NumericTableFeature
Data structure describes the Numeric Table feature.
Definition: data_dictionary.h:74
daal::data_management::interface1::PackedSymmetricMatrix::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:456
daal::data_management::interface1::PackedTriangularMatrix::releasePackedArray
services::Status releasePackedArray(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1319
daal::MemType
MemType
Definition: daal_defines.h:157
daal::data_management::interface1::PackedTriangularMatrix::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1285
daal::services::ErrorEmptyHomogenNumericTable
Definition: error_indexes.h:187
daal::data_management::interface1::PackedTriangularMatrix::PackedTriangularMatrix
PackedTriangularMatrix(size_t nDim, AllocationFlag memoryAllocationFlag)
Definition: symmetric_matrix.h:1048
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:1264
daal::data_management::interface1::PackedTriangularMatrix::releasePackedArray
services::Status releasePackedArray(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:1315
daal::data_management::interface1::PackedTriangularMatrix::PackedTriangularMatrix
PackedTriangularMatrix(size_t nDim, NumericTable::AllocationFlag memoryAllocationFlag, const DataType &constValue)
Definition: symmetric_matrix.h:1092
daal::data_management::interface1::PackedSymmetricMatrix::assign
virtual services::Status assign(float value) DAAL_C11_OVERRIDE
Definition: symmetric_matrix.h:427

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