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

homogen_tensor.h
1 /* file: homogen_tensor.h */
2 /*******************************************************************************
3 * Copyright 2014-2018 Intel Corporation.
4 *
5 * This software and the related documents are Intel copyrighted materials, and
6 * your use of them is governed by the express license under which they were
7 * provided to you (License). Unless the License provides otherwise, you may not
8 * use, modify, copy, publish, distribute, disclose or transmit this software or
9 * the related documents without Intel's prior written permission.
10 *
11 * This software and the related documents are provided as is, with no express
12 * or implied warranties, other than those that are expressly stated in the
13 * License.
14 *******************************************************************************/
15 
16 /*
17 //++
18 // Declaration and implementation of the base class for numeric n-cubes.
19 //--
20 */
21 
22 
23 #ifndef __HOMOGEN_TENSOR_H__
24 #define __HOMOGEN_TENSOR_H__
25 
26 #include "services/daal_defines.h"
27 #include "data_management/data/tensor.h"
28 #include "data_management/data/data_serialize.h"
29 
30 namespace daal
31 {
32 namespace data_management
33 {
34 namespace interface1
35 {
46 template<typename DataType = DAAL_DATA_TYPE>
47 class DAAL_EXPORT HomogenTensor : public Tensor
48 {
49 public:
50  DECLARE_SERIALIZABLE_TAG();
51  DECLARE_SERIALIZABLE_IMPL();
52 
53  DAAL_CAST_OPERATOR(HomogenTensor<DataType>);
54 
59  HomogenTensor() :
60  Tensor(&_layout), _allocatedSize(0), _layout(services::Collection<size_t>(0, 0))
61  {}
62 
68  static services::SharedPtr<HomogenTensor<DataType> > create(services::Status *stat = NULL)
69  {
70  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL(HomogenTensor, DataType);
71  }
72 
80  HomogenTensor(size_t nDim, const size_t *dimSizes, DataType *data) : Tensor(&_layout), _layout(services::Collection<size_t>(nDim, dimSizes))
81  {
82  _ptr = services::SharedPtr<byte>((byte*)data, services::EmptyDeleter());
83  _allocatedSize = 0;
84 
85  if( data )
86  {
87  _allocatedSize = getSize();
88  _memStatus = userAllocated;
89  }
90 
91  if(!dimSizes)
92  {
93  this->_status |= services::ErrorNullParameterNotSupported;
94  return;
95  }
96  }
97 
106  static services::SharedPtr<HomogenTensor<DataType> > create(size_t nDim, const size_t *dimSizes, DataType *data,
107  services::Status *stat = NULL)
108  {
109  return create(nDim, dimSizes, services::SharedPtr<DataType>(data, services::EmptyDeleter()), stat);
110  }
111 
119  HomogenTensor(size_t nDim, const size_t *dimSizes, const services::SharedPtr<DataType>& data) : Tensor(&_layout), _layout(services::Collection<size_t>(nDim, dimSizes))
120  {
121  _ptr = services::reinterpretPointerCast<byte, DataType>(data);
122  _allocatedSize = 0;
123 
124  if( data )
125  {
126  _allocatedSize = getSize();
127  _memStatus = userAllocated;
128  }
129 
130  if(!dimSizes)
131  {
132  this->_status |= services::ErrorNullParameterNotSupported;
133  return;
134  }
135  }
136 
145  static services::SharedPtr<HomogenTensor<DataType> > create(size_t nDim, const size_t *dimSizes,
146  const services::SharedPtr<DataType>& data,
147  services::Status *stat = NULL)
148  {
149  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(HomogenTensor, DataType, nDim, dimSizes, data);
150  }
151 
158  HomogenTensor(const services::Collection<size_t> &dims, DataType *data);
159 
167  static services::SharedPtr<HomogenTensor<DataType> > create(const services::Collection<size_t> &dims, DataType *data,
168  services::Status *stat = NULL)
169  {
170  return create(dims, services::SharedPtr<DataType>(data, services::EmptyDeleter()), stat);
171  }
172 
179  HomogenTensor(const services::Collection<size_t> &dims, const services::SharedPtr<DataType> &data);
180 
188  static services::SharedPtr<HomogenTensor<DataType> > create(const services::Collection<size_t> &dims,
189  const services::SharedPtr<DataType> &data,
190  services::Status *stat = NULL)
191  {
192  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(HomogenTensor, DataType, dims, data);
193  }
194 
201  HomogenTensor(const TensorOffsetLayout &layout, DataType *data) : Tensor(&_layout), _layout(layout)
202  {
203  const services::Collection<size_t>& dims = layout.getDimensions();
204  _ptr = services::SharedPtr<byte>((byte*)data, services::EmptyDeleter());
205  _allocatedSize = 0;
206 
207  if( data )
208  {
209  _allocatedSize = getSize();
210  _memStatus = userAllocated;
211  }
212 
213  size_t nDim = dims.size();
214 
215  if(nDim == 0)
216  {
217  this->_status |= services::ErrorNullParameterNotSupported;
218  return;
219  }
220  }
221 
229  static services::SharedPtr<HomogenTensor<DataType> > create(const TensorOffsetLayout &layout, DataType *data,
230  services::Status *stat = NULL)
231  {
232  return create(layout, services::SharedPtr<DataType>(data, services::EmptyDeleter()), stat);
233  }
234 
241  HomogenTensor(const TensorOffsetLayout &layout, const services::SharedPtr<DataType> &data) : Tensor(&_layout), _layout(layout)
242  {
243  const services::Collection<size_t>& dims = layout.getDimensions();
244  _ptr = services::reinterpretPointerCast<byte, DataType>(data);
245  _allocatedSize = 0;
246 
247  if( data )
248  {
249  _allocatedSize = getSize();
250  _memStatus = userAllocated;
251  }
252 
253  size_t nDim = dims.size();
254 
255  if(nDim == 0)
256  {
257  this->_status |= services::ErrorNullParameterNotSupported;
258  return;
259  }
260  }
261 
269  static services::SharedPtr<HomogenTensor<DataType> > create(const TensorOffsetLayout &layout, const services::SharedPtr<DataType> &data,
270  services::Status *stat = NULL)
271  {
272  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(HomogenTensor, DataType, layout, data);
273  }
274 
281  HomogenTensor(const services::Collection<size_t> &dims, AllocationFlag memoryAllocationFlag) : Tensor(&_layout),
282  _allocatedSize(0), _layout(dims)
283  {
284  if( memoryAllocationFlag == doAllocate )
285  {
286  this->_status |= allocateDataMemoryImpl();
287  }
288  }
289 
297  static services::SharedPtr<HomogenTensor<DataType> > create(const services::Collection<size_t> &dims, AllocationFlag memoryAllocationFlag,
298  services::Status *stat = NULL)
299  {
300  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(HomogenTensor, DataType, dims, memoryAllocationFlag);
301  }
302 
310  HomogenTensor(const services::Collection<size_t> &dims, AllocationFlag memoryAllocationFlag, const DataType initValue):
311  Tensor(&_layout), _allocatedSize(0), _layout(dims)
312  {
313  if( memoryAllocationFlag == doAllocate )
314  {
315  this->_status |= allocateDataMemoryImpl();
316  this->_status |= assign(initValue);
317  }
318  }
319 
328  static services::SharedPtr<HomogenTensor<DataType> > create(const services::Collection<size_t> &dims, AllocationFlag memoryAllocationFlag,
329  const DataType initValue, services::Status *stat = NULL)
330  {
331  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(HomogenTensor, DataType, dims, memoryAllocationFlag, initValue);
332  }
333 
335  virtual ~HomogenTensor()
336  {
337  freeDataMemoryImpl();
338  }
339 
340 public:
345  DataType *getArray() const
346  {
347  return (DataType*)_ptr.get();
348  }
349 
354  services::SharedPtr<DataType> getArraySharedPtr() const
355  {
356  return services::reinterpretPointerCast<DataType, byte>(_ptr);
357  }
358 
363  services::Status setArray( DataType *const ptr )
364  {
365  services::Status s;
366  DAAL_CHECK_STATUS(s, freeDataMemoryImpl());
367  if(!ptr)
368  {
369  return services::Status(services::ErrorNullParameterNotSupported);
370  }
371  _ptr = services::SharedPtr<byte>((byte*)ptr, services::EmptyDeleter());
372  _memStatus = userAllocated;
373  return s;
374  }
375 
380  services::Status setArray( const services::SharedPtr<DataType>& ptr )
381  {
382  services::Status s;
383  DAAL_CHECK_STATUS(s, freeDataMemoryImpl());
384  if(!ptr)
385  {
386  return services::Status(services::ErrorNullParameterNotSupported);
387  }
388  _ptr = ptr;
389  _memStatus = userAllocated;
390  return s;
391  }
392 
397  TensorOffsetLayout& getTensorLayout()
398  {
399  return _layout;
400  }
401 
406  virtual TensorOffsetLayout createDefaultSubtensorLayout() const DAAL_C11_OVERRIDE
407  {
408  return TensorOffsetLayout(_layout);
409  }
410 
415  virtual TensorOffsetLayout createRawSubtensorLayout() const DAAL_C11_OVERRIDE
416  {
417  TensorOffsetLayout layout(_layout);
418  layout.sortOffsets();
419  return layout;
420  }
421 
422  //the descriptions of the methods below are inherited from the base class
423  virtual services::Status setDimensions(size_t nDim, const size_t *dimSizes) DAAL_C11_OVERRIDE
424  {
425  if(!dimSizes)
426  {
427  return services::Status(services::ErrorNullParameterNotSupported);
428  }
429 
430  _layout = TensorOffsetLayout(services::Collection<size_t>(nDim, dimSizes));
431  return services::Status();
432  }
433 
434  virtual services::Status setDimensions(const services::Collection<size_t>& dimensions) DAAL_C11_OVERRIDE
435  {
436  if(!dimensions.size())
437  {
438  return services::Status(services::ErrorNullParameterNotSupported);
439  }
440 
441  _layout = TensorOffsetLayout(dimensions);
442  return services::Status();
443  }
444 
449  services::Status assign(const DataType initValue)
450  {
451  size_t size = getSize();
452 
453  DataType * ptr = (DataType*)_ptr.get();
454  for(size_t i = 0; i < size; i++)
455  {
456  ptr[i] = initValue;
457  }
458  return services::Status();
459  }
460 
461  services::Status getSubtensorEx(size_t fixedDims, const size_t *fixedDimNums, size_t rangeDimIdx, size_t rangeDimNum,
462  ReadWriteMode rwflag, SubtensorDescriptor<double> &block,
463  const TensorOffsetLayout& layout) DAAL_C11_OVERRIDE;
464  services::Status getSubtensorEx(size_t fixedDims, const size_t *fixedDimNums, size_t rangeDimIdx, size_t rangeDimNum,
465  ReadWriteMode rwflag, SubtensorDescriptor<float> &block,
466  const TensorOffsetLayout& layout) DAAL_C11_OVERRIDE;
467  services::Status getSubtensorEx(size_t fixedDims, const size_t *fixedDimNums, size_t rangeDimIdx, size_t rangeDimNum,
468  ReadWriteMode rwflag, SubtensorDescriptor<int> &block,
469  const TensorOffsetLayout& layout) DAAL_C11_OVERRIDE;
470 
471  services::Status getSubtensor(size_t fixedDims, const size_t* fixedDimNums, size_t rangeDimIdx, size_t rangeDimNum,
472  ReadWriteMode rwflag, SubtensorDescriptor<double>& subtensor ) DAAL_C11_OVERRIDE
473  {
474  return getSubtensorEx(fixedDims, fixedDimNums, rangeDimIdx, rangeDimNum, rwflag, subtensor, _layout );
475  }
476 
477  services::Status getSubtensor(size_t fixedDims, const size_t* fixedDimNums, size_t rangeDimIdx, size_t rangeDimNum,
478  ReadWriteMode rwflag, SubtensorDescriptor<float>& 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<int>& subtensor ) DAAL_C11_OVERRIDE
485  {
486  return getSubtensorEx(fixedDims, fixedDimNums, rangeDimIdx, rangeDimNum, rwflag, subtensor, _layout );
487  }
488 
489  services::Status releaseSubtensor(SubtensorDescriptor<double> &block) DAAL_C11_OVERRIDE;
490  services::Status releaseSubtensor(SubtensorDescriptor<float> &block) DAAL_C11_OVERRIDE;
491  services::Status releaseSubtensor(SubtensorDescriptor<int> &block) DAAL_C11_OVERRIDE;
492 
493  DAAL_DEPRECATED_VIRTUAL virtual services::SharedPtr<Tensor> getSampleTensor(size_t firstDimIndex) DAAL_C11_OVERRIDE
494  {
495  services::Collection<size_t> newDims = getDimensions();
496  if(!_ptr || newDims.size() == 0 || newDims[0] <= firstDimIndex) { return services::SharedPtr<Tensor>(); }
497  newDims[0] = 1;
498  const size_t *_dimOffsets = &((_layout.getOffsets())[0]);
499  services::SharedPtr<DataType> shiftedPtr(services::reinterpretPointerCast<DataType, byte>(_ptr), (DataType*)_ptr.get() + _dimOffsets[0] * firstDimIndex);
500  services::Status st;
501  return HomogenTensor<DataType>::create(newDims, shiftedPtr, &st);
502  }
503 
504 protected:
505 
506  HomogenTensor(services::Status &st) :
507  Tensor(&_layout, st), _allocatedSize(0), _layout(services::Collection<size_t>(0, 0))
508  {}
509 
510  HomogenTensor(size_t nDim, const size_t *dimSizes, const services::SharedPtr<DataType>& data, services::Status &st) :
511  Tensor(&_layout, st), _layout(services::Collection<size_t>(nDim, dimSizes))
512  {
513  _ptr = services::reinterpretPointerCast<byte, DataType>(data);
514  _allocatedSize = 0;
515 
516  if( data )
517  {
518  _allocatedSize = getSize();
519  _memStatus = userAllocated;
520  }
521 
522  if(!dimSizes)
523  {
524  st |= services::ErrorNullParameterNotSupported;
525  return;
526  }
527  }
528 
529  HomogenTensor(const services::Collection<size_t> &dims, const services::SharedPtr<DataType> &data, services::Status &st);
530 
531  HomogenTensor(const TensorOffsetLayout &layout, const services::SharedPtr<DataType> &data,
532  services::Status &st) :
533  Tensor(&_layout, st), _layout(layout)
534  {
535  const services::Collection<size_t>& dims = layout.getDimensions();
536  _ptr = services::reinterpretPointerCast<byte, DataType>(data);
537  _allocatedSize = 0;
538 
539  if(data)
540  {
541  _allocatedSize = getSize();
542  _memStatus = userAllocated;
543  }
544 
545  size_t nDim = dims.size();
546 
547  if(nDim == 0)
548  {
549  st |= services::ErrorNullParameterNotSupported;
550  return;
551  }
552  }
553 
554  HomogenTensor(const services::Collection<size_t> &dims, AllocationFlag memoryAllocationFlag,
555  services::Status &st) :
556  Tensor(&_layout, st), _allocatedSize(0), _layout(dims)
557  {
558  if( memoryAllocationFlag == doAllocate )
559  {
560  st |= allocateDataMemoryImpl();
561  }
562  }
563 
564  HomogenTensor(const services::Collection<size_t> &dims, AllocationFlag memoryAllocationFlag, const DataType initValue,
565  services::Status &st):
566  Tensor(&_layout, st), _allocatedSize(0), _layout(dims)
567  {
568  if(memoryAllocationFlag == doAllocate)
569  {
570  st |= allocateDataMemoryImpl();
571  if (!st)
572  return;
573  st |= assign(initValue);
574  }
575  }
576 
577  template<typename Archive, bool onDeserialize>
578  services::Status serialImpl( Archive *archive )
579  {
580  Tensor::serialImpl<Archive, onDeserialize>( archive );
581 
582  archive->setObj( &_layout );
583 
584  bool isAllocated = (_memStatus != notAllocated);
585  archive->set( isAllocated );
586 
587  if( onDeserialize )
588  {
589  freeDataMemoryImpl();
590 
591  if( isAllocated )
592  {
593  allocateDataMemoryImpl();
594  }
595  }
596 
597  if(_memStatus != notAllocated)
598  {
599  archive->set( (DataType*)_ptr.get(), getSize() );
600  }
601 
602  return services::Status();
603  }
604 
605  virtual services::Status allocateDataMemoryImpl(daal::MemType type = daal::dram) DAAL_C11_OVERRIDE
606  {
607  services::Status s;
608  DAAL_CHECK_STATUS(s, freeDataMemoryImpl());
609 
610  size_t size = getSize();
611 
612  if( size == 0 )
613  {
614  return services::Status();
615  }
616 
617  _ptr = services::SharedPtr<byte>((byte *)daal::services::daal_malloc(size * sizeof(DataType)), services::ServiceDeleter());
618 
619  if( _ptr == 0 )
620  {
621  return services::Status(services::ErrorMemoryAllocationFailed);
622  }
623 
624  _allocatedSize = getSize();
625  _memStatus = internallyAllocated;
626  return services::Status();
627  }
628 
629  //the descriptions of the methods below are inherited from the base class
630  virtual services::Status freeDataMemoryImpl() DAAL_C11_OVERRIDE
631  {
632  if(_ptr)
633  _ptr = services::SharedPtr<byte>();
634  _allocatedSize = 0;
635  _memStatus = notAllocated;
636  return services::Status();
637  }
638 
639 private:
640  template <typename T>
641  services::Status getTSubtensor( size_t fixedDims, const size_t *fixedDimNums, size_t rangeDimIdx, size_t rangeDimNum, int rwFlag,
642  SubtensorDescriptor<T> &block, const TensorOffsetLayout& layout );
643  template <typename T>
644  services::Status releaseTSubtensor( SubtensorDescriptor<T> &block );
645 
646 private:
647  services::SharedPtr<byte> _ptr;
648  size_t _allocatedSize;
649  TensorOffsetLayout _layout;
650 };
653 }
654 using interface1::HomogenTensor;
655 
656 }
657 } // namespace daal
658 
659 #endif
daal::data_management::interface1::HomogenTensor::createDefaultSubtensorLayout
virtual TensorOffsetLayout createDefaultSubtensorLayout() const DAAL_C11_OVERRIDE
Definition: homogen_tensor.h:406
daal::data_management::interface1::HomogenTensor::HomogenTensor
HomogenTensor(const TensorOffsetLayout &layout, const services::SharedPtr< DataType > &data)
Definition: homogen_tensor.h:241
daal
Definition: algorithm_base_common.h:31
daal::data_management::interface1::Tensor
Class for a data management component responsible for representation of data in the n-dimensions nume...
Definition: tensor.h:455
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:145
daal::data_management::interface1::HomogenTensor::createRawSubtensorLayout
virtual TensorOffsetLayout createRawSubtensorLayout() const DAAL_C11_OVERRIDE
Definition: homogen_tensor.h:415
daal::data_management::interface1::HomogenTensor::setDimensions
virtual services::Status setDimensions(size_t nDim, const size_t *dimSizes) DAAL_C11_OVERRIDE
Definition: homogen_tensor.h:423
daal::data_management::interface1::HomogenTensor::getTensorLayout
TensorOffsetLayout & getTensorLayout()
Definition: homogen_tensor.h:397
daal::data_management::interface1::HomogenTensor::assign
services::Status assign(const DataType initValue)
Definition: homogen_tensor.h:449
daal::data_management::interface1::HomogenTensor::HomogenTensor
HomogenTensor()
Definition: homogen_tensor.h:59
daal::services::ErrorMemoryAllocationFailed
Definition: error_indexes.h:146
daal::dram
Definition: daal_defines.h:133
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:483
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:297
daal::data_management::interface1::HomogenTensor::getArraySharedPtr
services::SharedPtr< DataType > getArraySharedPtr() const
Definition: homogen_tensor.h:354
daal_defines.h
daal::data_management::interface1::HomogenTensor::HomogenTensor
HomogenTensor(size_t nDim, const size_t *dimSizes, DataType *data)
Definition: homogen_tensor.h:80
daal::data_management::interface1::HomogenTensor::setArray
services::Status setArray(const services::SharedPtr< DataType > &ptr)
Definition: homogen_tensor.h:380
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:328
daal::data_management::interface1::HomogenTensor::getArray
DataType * getArray() const
Definition: homogen_tensor.h:345
daal::data_management::interface1::HomogenTensor::HomogenTensor
HomogenTensor(const services::Collection< size_t > &dims, AllocationFlag memoryAllocationFlag, const DataType initValue)
Definition: homogen_tensor.h:310
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:229
daal::services::ErrorNullParameterNotSupported
Definition: error_indexes.h:73
daal::data_management::interface1::HomogenTensor::setArray
services::Status setArray(DataType *const ptr)
Definition: homogen_tensor.h:363
daal::services::daal_malloc
DAAL_EXPORT void * daal_malloc(size_t size, size_t alignment=DAAL_MALLOC_DEFAULT_ALIGNMENT)
daal::data_management::interface1::HomogenTensor::getSampleTensor
virtual DAAL_DEPRECATED_VIRTUAL services::SharedPtr< Tensor > getSampleTensor(size_t firstDimIndex) DAAL_C11_OVERRIDE
Definition: homogen_tensor.h:493
daal::algorithms::association_rules::data
Definition: apriori_types.h:81
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:477
daal::data_management::interface1::TensorIface::AllocationFlag
AllocationFlag
Enumeration to specify whether the Numeric Table must allocate memory.
Definition: tensor.h:77
daal::data_management::interface1::TensorOffsetLayout
Class for a data management component responsible for representation of data layout in the HomogenTen...
Definition: tensor.h:189
daal::data_management::interface1::HomogenTensor::HomogenTensor
HomogenTensor(const TensorOffsetLayout &layout, DataType *data)
Definition: homogen_tensor.h:201
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:471
daal::data_management::interface1::HomogenTensor::HomogenTensor
HomogenTensor(size_t nDim, const size_t *dimSizes, const services::SharedPtr< DataType > &data)
Definition: homogen_tensor.h:119
daal::data_management::interface1::HomogenTensor::setDimensions
virtual services::Status setDimensions(const services::Collection< size_t > &dimensions) DAAL_C11_OVERRIDE
Definition: homogen_tensor.h:434
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:47
daal::data_management::interface1::HomogenTensor::HomogenTensor
HomogenTensor(const services::Collection< size_t > &dims, AllocationFlag memoryAllocationFlag)
Definition: homogen_tensor.h:281
daal::data_management::interface1::SubtensorDescriptor
Class with descriptor of the subtensor retrieved from Tensor getSubTensor function.
Definition: subtensor.h:47
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:167
daal::data_management::interface1::HomogenTensor::create
static services::SharedPtr< HomogenTensor< DataType > > create(services::Status *stat=NULL)
Definition: homogen_tensor.h:68
daal::data_management::interface1::TensorLayout::getDimensions
const services::Collection< size_t > & getDimensions() const
Definition: tensor.h:162
daal::MemType
MemType
Definition: daal_defines.h:131
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:106
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:269
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:188

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