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

homogen_tensor.h
1 /* file: homogen_tensor.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 the base class for numeric n-cubes.
21 //--
22 */
23 
24 
25 #ifndef __HOMOGEN_TENSOR_H__
26 #define __HOMOGEN_TENSOR_H__
27 
28 #include "services/daal_defines.h"
29 #include "data_management/data/tensor.h"
30 #include "data_management/data/data_serialize.h"
31 
32 namespace daal
33 {
34 namespace data_management
35 {
36 namespace interface1
37 {
49 template<typename DataType = DAAL_DATA_TYPE>
50 class DAAL_EXPORT HomogenTensor : public Tensor
51 {
52 public:
53  DECLARE_SERIALIZABLE_TAG();
54  DECLARE_SERIALIZABLE_IMPL();
55 
56  DAAL_CAST_OPERATOR(HomogenTensor<DataType>);
57 
62  HomogenTensor() :
63  Tensor(&_layout), _allocatedSize(0), _layout(services::Collection<size_t>(0, 0))
64  {}
65 
71  static services::SharedPtr<HomogenTensor<DataType> > create(services::Status *stat = NULL)
72  {
73  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL(HomogenTensor, DataType);
74  }
75 
83  HomogenTensor(size_t nDim, const size_t *dimSizes, DataType *data) : Tensor(&_layout), _layout(services::Collection<size_t>(nDim, dimSizes))
84  {
85  _ptr = services::SharedPtr<byte>((byte*)data, services::EmptyDeleter());
86  _allocatedSize = 0;
87 
88  if( data )
89  {
90  _allocatedSize = getSize();
91  _memStatus = userAllocated;
92  }
93 
94  if(!dimSizes)
95  {
96  this->_status |= services::ErrorNullParameterNotSupported;
97  return;
98  }
99  }
100 
109  static services::SharedPtr<HomogenTensor<DataType> > create(size_t nDim, const size_t *dimSizes, DataType *data,
110  services::Status *stat = NULL)
111  {
112  return create(nDim, dimSizes, services::SharedPtr<DataType>(data, services::EmptyDeleter()), stat);
113  }
114 
122  HomogenTensor(size_t nDim, const size_t *dimSizes, const services::SharedPtr<DataType>& data) : Tensor(&_layout), _layout(services::Collection<size_t>(nDim, dimSizes))
123  {
124  _ptr = services::reinterpretPointerCast<byte, DataType>(data);
125  _allocatedSize = 0;
126 
127  if( data )
128  {
129  _allocatedSize = getSize();
130  _memStatus = userAllocated;
131  }
132 
133  if(!dimSizes)
134  {
135  this->_status |= services::ErrorNullParameterNotSupported;
136  return;
137  }
138  }
139 
148  static services::SharedPtr<HomogenTensor<DataType> > create(size_t nDim, const size_t *dimSizes,
149  const services::SharedPtr<DataType>& data,
150  services::Status *stat = NULL)
151  {
152  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(HomogenTensor, DataType, nDim, dimSizes, data);
153  }
154 
161  HomogenTensor(const services::Collection<size_t> &dims, DataType *data);
162 
170  static services::SharedPtr<HomogenTensor<DataType> > create(const services::Collection<size_t> &dims, DataType *data,
171  services::Status *stat = NULL)
172  {
173  return create(dims, services::SharedPtr<DataType>(data, services::EmptyDeleter()), stat);
174  }
175 
182  HomogenTensor(const services::Collection<size_t> &dims, const services::SharedPtr<DataType> &data);
183 
191  static services::SharedPtr<HomogenTensor<DataType> > create(const services::Collection<size_t> &dims,
192  const services::SharedPtr<DataType> &data,
193  services::Status *stat = NULL)
194  {
195  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(HomogenTensor, DataType, dims, data);
196  }
197 
204  HomogenTensor(const TensorOffsetLayout &layout, DataType *data) : Tensor(&_layout), _layout(layout)
205  {
206  const services::Collection<size_t>& dims = layout.getDimensions();
207  _ptr = services::SharedPtr<byte>((byte*)data, services::EmptyDeleter());
208  _allocatedSize = 0;
209 
210  if( data )
211  {
212  _allocatedSize = getSize();
213  _memStatus = userAllocated;
214  }
215 
216  size_t nDim = dims.size();
217 
218  if(nDim == 0)
219  {
220  this->_status |= services::ErrorNullParameterNotSupported;
221  return;
222  }
223  }
224 
232  static services::SharedPtr<HomogenTensor<DataType> > create(const TensorOffsetLayout &layout, DataType *data,
233  services::Status *stat = NULL)
234  {
235  return create(layout, services::SharedPtr<DataType>(data, services::EmptyDeleter()), stat);
236  }
237 
244  HomogenTensor(const TensorOffsetLayout &layout, const services::SharedPtr<DataType> &data) : Tensor(&_layout), _layout(layout)
245  {
246  const services::Collection<size_t>& dims = layout.getDimensions();
247  _ptr = services::reinterpretPointerCast<byte, DataType>(data);
248  _allocatedSize = 0;
249 
250  if( data )
251  {
252  _allocatedSize = getSize();
253  _memStatus = userAllocated;
254  }
255 
256  size_t nDim = dims.size();
257 
258  if(nDim == 0)
259  {
260  this->_status |= services::ErrorNullParameterNotSupported;
261  return;
262  }
263  }
264 
272  static services::SharedPtr<HomogenTensor<DataType> > create(const TensorOffsetLayout &layout, const services::SharedPtr<DataType> &data,
273  services::Status *stat = NULL)
274  {
275  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(HomogenTensor, DataType, layout, data);
276  }
277 
284  HomogenTensor(const services::Collection<size_t> &dims, AllocationFlag memoryAllocationFlag) : Tensor(&_layout),
285  _allocatedSize(0), _layout(dims)
286  {
287  if( memoryAllocationFlag == doAllocate )
288  {
289  this->_status |= allocateDataMemoryImpl();
290  }
291  }
292 
300  static services::SharedPtr<HomogenTensor<DataType> > create(const services::Collection<size_t> &dims, AllocationFlag memoryAllocationFlag,
301  services::Status *stat = NULL)
302  {
303  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(HomogenTensor, DataType, dims, memoryAllocationFlag);
304  }
305 
313  HomogenTensor(const services::Collection<size_t> &dims, AllocationFlag memoryAllocationFlag, const DataType initValue):
314  Tensor(&_layout), _allocatedSize(0), _layout(dims)
315  {
316  if( memoryAllocationFlag == doAllocate )
317  {
318  this->_status |= allocateDataMemoryImpl();
319  this->_status |= assign(initValue);
320  }
321  }
322 
331  static services::SharedPtr<HomogenTensor<DataType> > create(const services::Collection<size_t> &dims, AllocationFlag memoryAllocationFlag,
332  const DataType initValue, services::Status *stat = NULL)
333  {
334  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(HomogenTensor, DataType, dims, memoryAllocationFlag, initValue);
335  }
336 
338  /*
339  * \DAAL_DEPRECATED
340  */
341  virtual ~HomogenTensor()
342  {
343  freeDataMemoryImpl();
344  }
345 
346 public:
351  DataType *getArray() const
352  {
353  return (DataType*)_ptr.get();
354  }
355 
360  services::SharedPtr<DataType> getArraySharedPtr() const
361  {
362  return services::reinterpretPointerCast<DataType, byte>(_ptr);
363  }
364 
369  services::Status setArray( DataType *const ptr )
370  {
371  services::Status s;
372  DAAL_CHECK_STATUS(s, freeDataMemoryImpl());
373  if(!ptr)
374  {
375  return services::Status(services::ErrorNullParameterNotSupported);
376  }
377  _ptr = services::SharedPtr<byte>((byte*)ptr, services::EmptyDeleter());
378  _memStatus = userAllocated;
379  return s;
380  }
381 
386  services::Status setArray( const services::SharedPtr<DataType>& ptr )
387  {
388  services::Status s;
389  DAAL_CHECK_STATUS(s, freeDataMemoryImpl());
390  if(!ptr)
391  {
392  return services::Status(services::ErrorNullParameterNotSupported);
393  }
394  _ptr = ptr;
395  _memStatus = userAllocated;
396  return s;
397  }
398 
403  TensorOffsetLayout& getTensorLayout()
404  {
405  return _layout;
406  }
407 
412  virtual TensorOffsetLayout createDefaultSubtensorLayout() const DAAL_C11_OVERRIDE
413  {
414  return TensorOffsetLayout(_layout);
415  }
416 
421  virtual TensorOffsetLayout createRawSubtensorLayout() const DAAL_C11_OVERRIDE
422  {
423  TensorOffsetLayout layout(_layout);
424  layout.sortOffsets();
425  return layout;
426  }
427 
428  //the descriptions of the methods below are inherited from the base class
429  virtual services::Status setDimensions(size_t nDim, const size_t *dimSizes) DAAL_C11_OVERRIDE
430  {
431  if(!dimSizes)
432  {
433  return services::Status(services::ErrorNullParameterNotSupported);
434  }
435 
436  _layout = TensorOffsetLayout(services::Collection<size_t>(nDim, dimSizes));
437  return services::Status();
438  }
439 
440  virtual services::Status setDimensions(const services::Collection<size_t>& dimensions) DAAL_C11_OVERRIDE
441  {
442  if(!dimensions.size())
443  {
444  return services::Status(services::ErrorNullParameterNotSupported);
445  }
446 
447  _layout = TensorOffsetLayout(dimensions);
448  return services::Status();
449  }
450 
455  services::Status assign(const DataType initValue)
456  {
457  size_t size = getSize();
458 
459  DataType * ptr = (DataType*)_ptr.get();
460  for(size_t i = 0; i < size; i++)
461  {
462  ptr[i] = initValue;
463  }
464  return services::Status();
465  }
466 
467  services::Status getSubtensorEx(size_t fixedDims, const size_t *fixedDimNums, size_t rangeDimIdx, size_t rangeDimNum,
468  ReadWriteMode rwflag, SubtensorDescriptor<double> &block,
469  const TensorOffsetLayout& layout) DAAL_C11_OVERRIDE;
470  services::Status getSubtensorEx(size_t fixedDims, const size_t *fixedDimNums, size_t rangeDimIdx, size_t rangeDimNum,
471  ReadWriteMode rwflag, SubtensorDescriptor<float> &block,
472  const TensorOffsetLayout& layout) DAAL_C11_OVERRIDE;
473  services::Status getSubtensorEx(size_t fixedDims, const size_t *fixedDimNums, size_t rangeDimIdx, size_t rangeDimNum,
474  ReadWriteMode rwflag, SubtensorDescriptor<int> &block,
475  const TensorOffsetLayout& layout) DAAL_C11_OVERRIDE;
476 
477  services::Status getSubtensor(size_t fixedDims, const size_t* fixedDimNums, size_t rangeDimIdx, size_t rangeDimNum,
478  ReadWriteMode rwflag, SubtensorDescriptor<double>& subtensor ) DAAL_C11_OVERRIDE
479  {
480  return getSubtensorEx(fixedDims, fixedDimNums, rangeDimIdx, rangeDimNum, rwflag, subtensor, _layout );
481  }
482 
483  services::Status getSubtensor(size_t fixedDims, const size_t* fixedDimNums, size_t rangeDimIdx, size_t rangeDimNum,
484  ReadWriteMode rwflag, SubtensorDescriptor<float>& subtensor ) DAAL_C11_OVERRIDE
485  {
486  return getSubtensorEx(fixedDims, fixedDimNums, rangeDimIdx, rangeDimNum, rwflag, subtensor, _layout );
487  }
488 
489  services::Status getSubtensor(size_t fixedDims, const size_t* fixedDimNums, size_t rangeDimIdx, size_t rangeDimNum,
490  ReadWriteMode rwflag, SubtensorDescriptor<int>& subtensor ) DAAL_C11_OVERRIDE
491  {
492  return getSubtensorEx(fixedDims, fixedDimNums, rangeDimIdx, rangeDimNum, rwflag, subtensor, _layout );
493  }
494 
495  services::Status releaseSubtensor(SubtensorDescriptor<double> &block) DAAL_C11_OVERRIDE;
496  services::Status releaseSubtensor(SubtensorDescriptor<float> &block) DAAL_C11_OVERRIDE;
497  services::Status releaseSubtensor(SubtensorDescriptor<int> &block) DAAL_C11_OVERRIDE;
498 
499  DAAL_DEPRECATED_VIRTUAL virtual services::SharedPtr<Tensor> getSampleTensor(size_t firstDimIndex) DAAL_C11_OVERRIDE
500  {
501  services::Collection<size_t> newDims = getDimensions();
502  if(!_ptr || newDims.size() == 0 || newDims[0] <= firstDimIndex) { return services::SharedPtr<Tensor>(); }
503  newDims[0] = 1;
504  const size_t *_dimOffsets = &((_layout.getOffsets())[0]);
505  services::SharedPtr<DataType> shiftedPtr(services::reinterpretPointerCast<DataType, byte>(_ptr), (DataType*)_ptr.get() + _dimOffsets[0] * firstDimIndex);
506  services::Status st;
507  return HomogenTensor<DataType>::create(newDims, shiftedPtr, &st);
508  }
509 
510 protected:
511  /*
512  * \DAAL_DEPRECATED
513  */
514  HomogenTensor(services::Status &st) :
515  Tensor(&_layout, st), _allocatedSize(0), _layout(services::Collection<size_t>(0, 0))
516  {}
517 
518  /*
519  * \DAAL_DEPRECATED
520  */
521  HomogenTensor(size_t nDim, const size_t *dimSizes, const services::SharedPtr<DataType>& data, services::Status &st) :
522  Tensor(&_layout, st), _layout(services::Collection<size_t>(nDim, dimSizes))
523  {
524  _ptr = services::reinterpretPointerCast<byte, DataType>(data);
525  _allocatedSize = 0;
526 
527  if( data )
528  {
529  _allocatedSize = getSize();
530  _memStatus = userAllocated;
531  }
532 
533  if(!dimSizes)
534  {
535  st |= services::ErrorNullParameterNotSupported;
536  return;
537  }
538  }
539 
540  /*
541  * \DAAL_DEPRECATED
542  */
543  HomogenTensor(const services::Collection<size_t> &dims, const services::SharedPtr<DataType> &data, services::Status &st);
544 
545  /*
546  * \DAAL_DEPRECATED
547  */
548  HomogenTensor(const TensorOffsetLayout &layout, const services::SharedPtr<DataType> &data,
549  services::Status &st) :
550  Tensor(&_layout, st), _layout(layout)
551  {
552  const services::Collection<size_t>& dims = layout.getDimensions();
553  _ptr = services::reinterpretPointerCast<byte, DataType>(data);
554  _allocatedSize = 0;
555 
556  if(data)
557  {
558  _allocatedSize = getSize();
559  _memStatus = userAllocated;
560  }
561 
562  size_t nDim = dims.size();
563 
564  if(nDim == 0)
565  {
566  st |= services::ErrorNullParameterNotSupported;
567  return;
568  }
569  }
570 
571  /*
572  * \DAAL_DEPRECATED
573  */
574  HomogenTensor(const services::Collection<size_t> &dims, AllocationFlag memoryAllocationFlag,
575  services::Status &st) :
576  Tensor(&_layout, st), _allocatedSize(0), _layout(dims)
577  {
578  if( memoryAllocationFlag == doAllocate )
579  {
580  st |= allocateDataMemoryImpl();
581  }
582  }
583 
584  /*
585  * \DAAL_DEPRECATED
586  */
587  HomogenTensor(const services::Collection<size_t> &dims, AllocationFlag memoryAllocationFlag, const DataType initValue,
588  services::Status &st):
589  Tensor(&_layout, st), _allocatedSize(0), _layout(dims)
590  {
591  if(memoryAllocationFlag == doAllocate)
592  {
593  st |= allocateDataMemoryImpl();
594  if (!st)
595  return;
596  st |= assign(initValue);
597  }
598  }
599 
600  template<typename Archive, bool onDeserialize>
601  services::Status serialImpl( Archive *archive )
602  {
603  Tensor::serialImpl<Archive, onDeserialize>( archive );
604 
605  archive->setObj( &_layout );
606 
607  bool isAllocated = (_memStatus != notAllocated);
608  archive->set( isAllocated );
609 
610  if( onDeserialize )
611  {
612  freeDataMemoryImpl();
613 
614  if( isAllocated )
615  {
616  allocateDataMemoryImpl();
617  }
618  }
619 
620  if(_memStatus != notAllocated)
621  {
622  archive->set( (DataType*)_ptr.get(), getSize() );
623  }
624 
625  return services::Status();
626  }
627 
628  virtual services::Status allocateDataMemoryImpl(daal::MemType type = daal::dram) DAAL_C11_OVERRIDE
629  {
630  services::Status s;
631  DAAL_CHECK_STATUS(s, freeDataMemoryImpl());
632 
633  size_t size = getSize();
634 
635  if( size == 0 )
636  {
637  return services::Status();
638  }
639 
640  _ptr = services::SharedPtr<byte>((byte *)daal::services::daal_malloc(size * sizeof(DataType)), services::ServiceDeleter());
641 
642  if( _ptr == 0 )
643  {
644  return services::Status(services::ErrorMemoryAllocationFailed);
645  }
646 
647  _allocatedSize = getSize();
648  _memStatus = internallyAllocated;
649  return services::Status();
650  }
651 
652  //the descriptions of the methods below are inherited from the base class
653  virtual services::Status freeDataMemoryImpl() DAAL_C11_OVERRIDE
654  {
655  if(_ptr)
656  _ptr = services::SharedPtr<byte>();
657  _allocatedSize = 0;
658  _memStatus = notAllocated;
659  return services::Status();
660  }
661 
662 private:
663  template <typename T>
664  services::Status getTSubtensor( size_t fixedDims, const size_t *fixedDimNums, size_t rangeDimIdx, size_t rangeDimNum, int rwFlag,
665  SubtensorDescriptor<T> &block, const TensorOffsetLayout& layout );
666  template <typename T>
667  services::Status releaseTSubtensor( SubtensorDescriptor<T> &block );
668 
669 private:
670  services::SharedPtr<byte> _ptr;
671  size_t _allocatedSize;
672  TensorOffsetLayout _layout;
673 };
676 }
677 using interface1::HomogenTensor;
678 
679 }
680 } // namespace daal
681 
682 #endif
daal::data_management::interface1::HomogenTensor::setArray
services::Status setArray(const services::SharedPtr< DataType > &ptr)
Definition: homogen_tensor.h:386
daal::data_management::interface1::TensorLayout::getDimensions
const services::Collection< size_t > & getDimensions() const
Definition: tensor.h:177
daal::data_management::interface1::HomogenTensor::getTensorLayout
TensorOffsetLayout & getTensorLayout()
Definition: homogen_tensor.h:403
daal::data_management::interface1::HomogenTensor::HomogenTensor
HomogenTensor(size_t nDim, const size_t *dimSizes, const services::SharedPtr< DataType > &data)
Definition: homogen_tensor.h:122
daal::data_management::interface1::HomogenTensor::getSubtensor
services::Status getSubtensor(size_t fixedDims, const size_t *fixedDimNums, size_t rangeDimIdx, size_t rangeDimNum, ReadWriteMode rwflag, SubtensorDescriptor< float > &subtensor) DAAL_C11_OVERRIDE
Definition: homogen_tensor.h:483
daal::data_management::interface1::HomogenTensor::getSampleTensor
virtual DAAL_DEPRECATED_VIRTUAL services::SharedPtr< Tensor > getSampleTensor(size_t firstDimIndex) DAAL_C11_OVERRIDE
Definition: homogen_tensor.h:499
daal::data_management::interface1::HomogenTensor
Class that provides methods to access data stored as a contiguous array of homogeneous data in rows-m...
Definition: homogen_tensor.h:50
daal::data_management::interface1::HomogenTensor::assign
services::Status assign(const DataType initValue)
Definition: homogen_tensor.h:455
daal::algorithms::association_rules::data
Definition: apriori_types.h:83
daal::services::ErrorNullParameterNotSupported
Definition: error_indexes.h:75
daal::data_management::interface1::HomogenTensor::create
static services::SharedPtr< HomogenTensor< DataType > > create(size_t nDim, const size_t *dimSizes, const services::SharedPtr< DataType > &data, services::Status *stat=NULL)
Definition: homogen_tensor.h:148
daal::data_management::interface1::HomogenTensor::create
static services::SharedPtr< HomogenTensor< DataType > > create(const services::Collection< size_t > &dims, AllocationFlag memoryAllocationFlag, const DataType initValue, services::Status *stat=NULL)
Definition: homogen_tensor.h:331
daal::data_management::interface1::HomogenTensor::setArray
services::Status setArray(DataType *const ptr)
Definition: homogen_tensor.h:369
daal::data_management::interface1::HomogenTensor::create
static services::SharedPtr< HomogenTensor< DataType > > create(const TensorOffsetLayout &layout, const services::SharedPtr< DataType > &data, services::Status *stat=NULL)
Definition: homogen_tensor.h:272
daal::data_management::interface1::HomogenTensor::getArraySharedPtr
services::SharedPtr< DataType > getArraySharedPtr() const
Definition: homogen_tensor.h:360
daal::data_management::interface1::HomogenTensor::getSubtensor
services::Status getSubtensor(size_t fixedDims, const size_t *fixedDimNums, size_t rangeDimIdx, size_t rangeDimNum, ReadWriteMode rwflag, SubtensorDescriptor< int > &subtensor) DAAL_C11_OVERRIDE
Definition: homogen_tensor.h:489
daal::data_management::interface1::HomogenTensor::getSubtensor
services::Status getSubtensor(size_t fixedDims, const size_t *fixedDimNums, size_t rangeDimIdx, size_t rangeDimNum, ReadWriteMode rwflag, SubtensorDescriptor< double > &subtensor) DAAL_C11_OVERRIDE
Definition: homogen_tensor.h:477
daal::data_management::interface1::TensorIface::AllocationFlag
AllocationFlag
Enumeration to specify whether the Numeric Table must allocate memory.
Definition: tensor.h:81
daal::data_management::interface1::HomogenTensor::getArray
DataType * getArray() const
Definition: homogen_tensor.h:351
daal::MemType
MemType
Definition: daal_defines.h:147
daal::data_management::interface1::HomogenTensor::setDimensions
virtual services::Status setDimensions(size_t nDim, const size_t *dimSizes) DAAL_C11_OVERRIDE
Definition: homogen_tensor.h:429
daal_defines.h
daal::data_management::interface1::HomogenTensor::HomogenTensor
HomogenTensor(const services::Collection< size_t > &dims, AllocationFlag memoryAllocationFlag)
Definition: homogen_tensor.h:284
daal::data_management::interface1::HomogenTensor::create
static services::SharedPtr< HomogenTensor< DataType > > create(const services::Collection< size_t > &dims, AllocationFlag memoryAllocationFlag, services::Status *stat=NULL)
Definition: homogen_tensor.h:300
daal::data_management::interface1::TensorOffsetLayout
Class for a data management component responsible for representation of data layout in the HomogenTen...
Definition: tensor.h:205
daal::data_management::interface1::HomogenTensor::create
static services::SharedPtr< HomogenTensor< DataType > > create(size_t nDim, const size_t *dimSizes, DataType *data, services::Status *stat=NULL)
Definition: homogen_tensor.h:109
daal::data_management::interface1::HomogenTensor::HomogenTensor
HomogenTensor(const TensorOffsetLayout &layout, DataType *data)
Definition: homogen_tensor.h:204
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::SubtensorDescriptor
Class with descriptor of the subtensor retrieved from Tensor getSubTensor function.
Definition: subtensor.h:49
daal::data_management::interface1::HomogenTensor::create
static services::SharedPtr< HomogenTensor< DataType > > create(const services::Collection< size_t > &dims, DataType *data, services::Status *stat=NULL)
Definition: homogen_tensor.h:170
daal::services::ErrorMemoryAllocationFailed
Definition: error_indexes.h:150
daal::data_management::interface1::HomogenTensor::createRawSubtensorLayout
virtual TensorOffsetLayout createRawSubtensorLayout() const DAAL_C11_OVERRIDE
Definition: homogen_tensor.h:421
daal::data_management::interface1::HomogenTensor::setDimensions
virtual services::Status setDimensions(const services::Collection< size_t > &dimensions) DAAL_C11_OVERRIDE
Definition: homogen_tensor.h:440
daal::data_management::interface1::Tensor
Class for a data management component responsible for representation of data in the n-dimensions nume...
Definition: tensor.h:484
daal::data_management::interface1::HomogenTensor::create
static services::SharedPtr< HomogenTensor< DataType > > create(const TensorOffsetLayout &layout, DataType *data, services::Status *stat=NULL)
Definition: homogen_tensor.h:232
daal::data_management::interface1::HomogenTensor::HomogenTensor
HomogenTensor(size_t nDim, const size_t *dimSizes, DataType *data)
Definition: homogen_tensor.h:83
daal::data_management::interface1::HomogenTensor::createDefaultSubtensorLayout
virtual TensorOffsetLayout createDefaultSubtensorLayout() const DAAL_C11_OVERRIDE
Definition: homogen_tensor.h:412
daal::data_management::interface1::HomogenTensor::HomogenTensor
HomogenTensor(const services::Collection< size_t > &dims, AllocationFlag memoryAllocationFlag, const DataType initValue)
Definition: homogen_tensor.h:313
daal::data_management::interface1::HomogenTensor::create
static services::SharedPtr< HomogenTensor< DataType > > create(const services::Collection< size_t > &dims, const services::SharedPtr< DataType > &data, services::Status *stat=NULL)
Definition: homogen_tensor.h:191
daal::data_management::interface1::HomogenTensor::create
static services::SharedPtr< HomogenTensor< DataType > > create(services::Status *stat=NULL)
Definition: homogen_tensor.h:71
daal::data_management::interface1::HomogenTensor::HomogenTensor
HomogenTensor(const TensorOffsetLayout &layout, const services::SharedPtr< DataType > &data)
Definition: homogen_tensor.h:244
daal::data_management::interface1::HomogenTensor::HomogenTensor
HomogenTensor()
Definition: homogen_tensor.h:62

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