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

homogen_tensor.h
1 /* file: homogen_tensor.h */
2 /*******************************************************************************
3 * Copyright 2014-2017 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 the base class for numeric n-cubes.
45 //--
46 */
47 
48 
49 #ifndef __HOMOGEN_TENSOR_H__
50 #define __HOMOGEN_TENSOR_H__
51 
52 #include "services/daal_defines.h"
53 #include "data_management/data/tensor.h"
54 #include "data_management/data/data_serialize.h"
55 
56 namespace daal
57 {
58 namespace data_management
59 {
60 namespace interface1
61 {
72 template<typename DataType = DAAL_DATA_TYPE>
73 class DAAL_EXPORT HomogenTensor : public Tensor
74 {
75 public:
76  DECLARE_SERIALIZABLE_TAG();
77  DECLARE_SERIALIZABLE_IMPL();
78 
79  DAAL_CAST_OPERATOR(HomogenTensor<DataType>);
80 
85  HomogenTensor() :
86  Tensor(&_layout), _allocatedSize(0), _layout(services::Collection<size_t>(0, 0))
87  {}
88 
94  static services::SharedPtr<HomogenTensor<DataType> > create(services::Status *stat = NULL)
95  {
96  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL(HomogenTensor, DataType);
97  }
98 
106  HomogenTensor(size_t nDim, const size_t *dimSizes, DataType *data) : Tensor(&_layout), _layout(services::Collection<size_t>(nDim, dimSizes))
107  {
108  _ptr = services::SharedPtr<byte>((byte*)data, services::EmptyDeleter());
109  _allocatedSize = 0;
110 
111  if( data )
112  {
113  _allocatedSize = getSize();
114  _memStatus = userAllocated;
115  }
116 
117  if(!dimSizes)
118  {
119  this->_status |= services::ErrorNullParameterNotSupported;
120  return;
121  }
122  }
123 
132  static services::SharedPtr<HomogenTensor<DataType> > create(size_t nDim, const size_t *dimSizes, DataType *data,
133  services::Status *stat = NULL)
134  {
135  return create(nDim, dimSizes, services::SharedPtr<DataType>(data, services::EmptyDeleter()), stat);
136  }
137 
145  HomogenTensor(size_t nDim, const size_t *dimSizes, const services::SharedPtr<DataType>& data) : Tensor(&_layout), _layout(services::Collection<size_t>(nDim, dimSizes))
146  {
147  _ptr = services::reinterpretPointerCast<byte, DataType>(data);
148  _allocatedSize = 0;
149 
150  if( data )
151  {
152  _allocatedSize = getSize();
153  _memStatus = userAllocated;
154  }
155 
156  if(!dimSizes)
157  {
158  this->_status |= services::ErrorNullParameterNotSupported;
159  return;
160  }
161  }
162 
171  static services::SharedPtr<HomogenTensor<DataType> > create(size_t nDim, const size_t *dimSizes,
172  const services::SharedPtr<DataType>& data,
173  services::Status *stat = NULL)
174  {
175  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(HomogenTensor, DataType, nDim, dimSizes, data);
176  }
177 
184  HomogenTensor(const services::Collection<size_t> &dims, DataType *data);
185 
193  static services::SharedPtr<HomogenTensor<DataType> > create(const services::Collection<size_t> &dims, DataType *data,
194  services::Status *stat = NULL)
195  {
196  return create(dims, services::SharedPtr<DataType>(data, services::EmptyDeleter()), stat);
197  }
198 
205  HomogenTensor(const services::Collection<size_t> &dims, const services::SharedPtr<DataType> &data);
206 
214  static services::SharedPtr<HomogenTensor<DataType> > create(const services::Collection<size_t> &dims,
215  const services::SharedPtr<DataType> &data,
216  services::Status *stat = NULL)
217  {
218  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(HomogenTensor, DataType, dims, data);
219  }
220 
227  HomogenTensor(const TensorOffsetLayout &layout, DataType *data) : Tensor(&_layout), _layout(layout)
228  {
229  const services::Collection<size_t>& dims = layout.getDimensions();
230  _ptr = services::SharedPtr<byte>((byte*)data, services::EmptyDeleter());
231  _allocatedSize = 0;
232 
233  if( data )
234  {
235  _allocatedSize = getSize();
236  _memStatus = userAllocated;
237  }
238 
239  size_t nDim = dims.size();
240 
241  if(nDim == 0)
242  {
243  this->_status |= services::ErrorNullParameterNotSupported;
244  return;
245  }
246  }
247 
255  static services::SharedPtr<HomogenTensor<DataType> > create(const TensorOffsetLayout &layout, DataType *data,
256  services::Status *stat = NULL)
257  {
258  return create(layout, services::SharedPtr<DataType>(data, services::EmptyDeleter()), stat);
259  }
260 
267  HomogenTensor(const TensorOffsetLayout &layout, const services::SharedPtr<DataType> &data) : Tensor(&_layout), _layout(layout)
268  {
269  const services::Collection<size_t>& dims = layout.getDimensions();
270  _ptr = services::reinterpretPointerCast<byte, DataType>(data);
271  _allocatedSize = 0;
272 
273  if( data )
274  {
275  _allocatedSize = getSize();
276  _memStatus = userAllocated;
277  }
278 
279  size_t nDim = dims.size();
280 
281  if(nDim == 0)
282  {
283  this->_status |= services::ErrorNullParameterNotSupported;
284  return;
285  }
286  }
287 
295  static services::SharedPtr<HomogenTensor<DataType> > create(const TensorOffsetLayout &layout, const services::SharedPtr<DataType> &data,
296  services::Status *stat = NULL)
297  {
298  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(HomogenTensor, DataType, layout, data);
299  }
300 
307  HomogenTensor(const services::Collection<size_t> &dims, AllocationFlag memoryAllocationFlag) : Tensor(&_layout),
308  _allocatedSize(0), _layout(dims)
309  {
310  if( memoryAllocationFlag == doAllocate )
311  {
312  this->_status |= allocateDataMemoryImpl();
313  }
314  }
315 
323  static services::SharedPtr<HomogenTensor<DataType> > create(const services::Collection<size_t> &dims, AllocationFlag memoryAllocationFlag,
324  services::Status *stat = NULL)
325  {
326  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(HomogenTensor, DataType, dims, memoryAllocationFlag);
327  }
328 
336  HomogenTensor(const services::Collection<size_t> &dims, AllocationFlag memoryAllocationFlag, const DataType initValue):
337  Tensor(&_layout), _allocatedSize(0), _layout(dims)
338  {
339  if( memoryAllocationFlag == doAllocate )
340  {
341  this->_status |= allocateDataMemoryImpl();
342  this->_status |= assign(initValue);
343  }
344  }
345 
354  static services::SharedPtr<HomogenTensor<DataType> > create(const services::Collection<size_t> &dims, AllocationFlag memoryAllocationFlag,
355  const DataType initValue, services::Status *stat = NULL)
356  {
357  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(HomogenTensor, DataType, dims, memoryAllocationFlag, initValue);
358  }
359 
361  virtual ~HomogenTensor()
362  {
363  freeDataMemoryImpl();
364  }
365 
366 public:
371  DataType *getArray() const
372  {
373  return (DataType*)_ptr.get();
374  }
375 
380  services::SharedPtr<DataType> getArraySharedPtr() const
381  {
382  return services::reinterpretPointerCast<DataType, byte>(_ptr);
383  }
384 
389  services::Status setArray( DataType *const ptr )
390  {
391  services::Status s;
392  DAAL_CHECK_STATUS(s, freeDataMemoryImpl());
393  if(!ptr)
394  {
395  return services::Status(services::ErrorNullParameterNotSupported);
396  }
397  _ptr = services::SharedPtr<byte>((byte*)ptr, services::EmptyDeleter());
398  _memStatus = userAllocated;
399  return s;
400  }
401 
406  services::Status setArray( const services::SharedPtr<DataType>& ptr )
407  {
408  services::Status s;
409  DAAL_CHECK_STATUS(s, freeDataMemoryImpl());
410  if(!ptr)
411  {
412  return services::Status(services::ErrorNullParameterNotSupported);
413  }
414  _ptr = ptr;
415  _memStatus = userAllocated;
416  return s;
417  }
418 
423  TensorOffsetLayout& getTensorLayout()
424  {
425  return _layout;
426  }
427 
432  virtual TensorOffsetLayout createDefaultSubtensorLayout() const DAAL_C11_OVERRIDE
433  {
434  return TensorOffsetLayout(_layout);
435  }
436 
441  virtual TensorOffsetLayout createRawSubtensorLayout() const DAAL_C11_OVERRIDE
442  {
443  TensorOffsetLayout layout(_layout);
444  layout.sortOffsets();
445  return layout;
446  }
447 
448  //the descriptions of the methods below are inherited from the base class
449  virtual services::Status setDimensions(size_t nDim, const size_t *dimSizes) DAAL_C11_OVERRIDE
450  {
451  if(!dimSizes)
452  {
453  return services::Status(services::ErrorNullParameterNotSupported);
454  }
455 
456  _layout = TensorOffsetLayout(services::Collection<size_t>(nDim, dimSizes));
457  return services::Status();
458  }
459 
460  virtual services::Status setDimensions(const services::Collection<size_t>& dimensions) DAAL_C11_OVERRIDE
461  {
462  if(!dimensions.size())
463  {
464  return services::Status(services::ErrorNullParameterNotSupported);
465  }
466 
467  _layout = TensorOffsetLayout(dimensions);
468  return services::Status();
469  }
470 
475  services::Status assign(const DataType initValue)
476  {
477  size_t size = getSize();
478 
479  DataType * ptr = (DataType*)_ptr.get();
480  for(size_t i = 0; i < size; i++)
481  {
482  ptr[i] = initValue;
483  }
484  return services::Status();
485  }
486 
487  services::Status getSubtensorEx(size_t fixedDims, const size_t *fixedDimNums, size_t rangeDimIdx, size_t rangeDimNum,
488  ReadWriteMode rwflag, SubtensorDescriptor<double> &block,
489  const TensorOffsetLayout& layout) DAAL_C11_OVERRIDE;
490  services::Status getSubtensorEx(size_t fixedDims, const size_t *fixedDimNums, size_t rangeDimIdx, size_t rangeDimNum,
491  ReadWriteMode rwflag, SubtensorDescriptor<float> &block,
492  const TensorOffsetLayout& layout) DAAL_C11_OVERRIDE;
493  services::Status getSubtensorEx(size_t fixedDims, const size_t *fixedDimNums, size_t rangeDimIdx, size_t rangeDimNum,
494  ReadWriteMode rwflag, SubtensorDescriptor<int> &block,
495  const TensorOffsetLayout& layout) DAAL_C11_OVERRIDE;
496 
497  services::Status getSubtensor(size_t fixedDims, const size_t* fixedDimNums, size_t rangeDimIdx, size_t rangeDimNum,
498  ReadWriteMode rwflag, SubtensorDescriptor<double>& subtensor ) DAAL_C11_OVERRIDE
499  {
500  return getSubtensorEx(fixedDims, fixedDimNums, rangeDimIdx, rangeDimNum, rwflag, subtensor, _layout );
501  }
502 
503  services::Status getSubtensor(size_t fixedDims, const size_t* fixedDimNums, size_t rangeDimIdx, size_t rangeDimNum,
504  ReadWriteMode rwflag, SubtensorDescriptor<float>& subtensor ) DAAL_C11_OVERRIDE
505  {
506  return getSubtensorEx(fixedDims, fixedDimNums, rangeDimIdx, rangeDimNum, rwflag, subtensor, _layout );
507  }
508 
509  services::Status getSubtensor(size_t fixedDims, const size_t* fixedDimNums, size_t rangeDimIdx, size_t rangeDimNum,
510  ReadWriteMode rwflag, SubtensorDescriptor<int>& subtensor ) DAAL_C11_OVERRIDE
511  {
512  return getSubtensorEx(fixedDims, fixedDimNums, rangeDimIdx, rangeDimNum, rwflag, subtensor, _layout );
513  }
514 
515  services::Status releaseSubtensor(SubtensorDescriptor<double> &block) DAAL_C11_OVERRIDE;
516  services::Status releaseSubtensor(SubtensorDescriptor<float> &block) DAAL_C11_OVERRIDE;
517  services::Status releaseSubtensor(SubtensorDescriptor<int> &block) DAAL_C11_OVERRIDE;
518 
519  DAAL_DEPRECATED_VIRTUAL virtual services::SharedPtr<Tensor> getSampleTensor(size_t firstDimIndex) DAAL_C11_OVERRIDE
520  {
521  services::Collection<size_t> newDims = getDimensions();
522  if(!_ptr || newDims.size() == 0 || newDims[0] <= firstDimIndex) { return services::SharedPtr<Tensor>(); }
523  newDims[0] = 1;
524  const size_t *_dimOffsets = &((_layout.getOffsets())[0]);
525  services::SharedPtr<DataType> shiftedPtr(services::reinterpretPointerCast<DataType, byte>(_ptr), (DataType*)_ptr.get() + _dimOffsets[0] * firstDimIndex);
526  services::Status st;
527  return HomogenTensor<DataType>::create(newDims, shiftedPtr, &st);
528  }
529 
530 protected:
531 
532  HomogenTensor(services::Status &st) :
533  Tensor(&_layout, st), _allocatedSize(0), _layout(services::Collection<size_t>(0, 0))
534  {}
535 
536  HomogenTensor(size_t nDim, const size_t *dimSizes, const services::SharedPtr<DataType>& data, services::Status &st) :
537  Tensor(&_layout, st), _layout(services::Collection<size_t>(nDim, dimSizes))
538  {
539  _ptr = services::reinterpretPointerCast<byte, DataType>(data);
540  _allocatedSize = 0;
541 
542  if( data )
543  {
544  _allocatedSize = getSize();
545  _memStatus = userAllocated;
546  }
547 
548  if(!dimSizes)
549  {
550  st |= services::ErrorNullParameterNotSupported;
551  return;
552  }
553  }
554 
555  HomogenTensor(const services::Collection<size_t> &dims, const services::SharedPtr<DataType> &data, services::Status &st);
556 
557  HomogenTensor(const TensorOffsetLayout &layout, const services::SharedPtr<DataType> &data,
558  services::Status &st) :
559  Tensor(&_layout, st), _layout(layout)
560  {
561  const services::Collection<size_t>& dims = layout.getDimensions();
562  _ptr = services::reinterpretPointerCast<byte, DataType>(data);
563  _allocatedSize = 0;
564 
565  if(data)
566  {
567  _allocatedSize = getSize();
568  _memStatus = userAllocated;
569  }
570 
571  size_t nDim = dims.size();
572 
573  if(nDim == 0)
574  {
575  st |= services::ErrorNullParameterNotSupported;
576  return;
577  }
578  }
579 
580  HomogenTensor(const services::Collection<size_t> &dims, AllocationFlag memoryAllocationFlag,
581  services::Status &st) :
582  Tensor(&_layout, st), _allocatedSize(0), _layout(dims)
583  {
584  if( memoryAllocationFlag == doAllocate )
585  {
586  st |= allocateDataMemoryImpl();
587  }
588  }
589 
590  HomogenTensor(const services::Collection<size_t> &dims, AllocationFlag memoryAllocationFlag, const DataType initValue,
591  services::Status &st):
592  Tensor(&_layout, st), _allocatedSize(0), _layout(dims)
593  {
594  if(memoryAllocationFlag == doAllocate)
595  {
596  st |= allocateDataMemoryImpl();
597  if (!st)
598  return;
599  st |= assign(initValue);
600  }
601  }
602 
603  template<typename Archive, bool onDeserialize>
604  services::Status serialImpl( Archive *archive )
605  {
606  Tensor::serialImpl<Archive, onDeserialize>( archive );
607 
608  archive->setObj( &_layout );
609 
610  bool isAllocated = (_memStatus != notAllocated);
611  archive->set( isAllocated );
612 
613  if( onDeserialize )
614  {
615  freeDataMemoryImpl();
616 
617  if( isAllocated )
618  {
619  allocateDataMemoryImpl();
620  }
621  }
622 
623  if(_memStatus != notAllocated)
624  {
625  archive->set( (DataType*)_ptr.get(), getSize() );
626  }
627 
628  return services::Status();
629  }
630 
631  virtual services::Status allocateDataMemoryImpl(daal::MemType type = daal::dram) DAAL_C11_OVERRIDE
632  {
633  services::Status s;
634  DAAL_CHECK_STATUS(s, freeDataMemoryImpl());
635 
636  size_t size = getSize();
637 
638  if( size == 0 )
639  {
640  return services::Status();
641  }
642 
643  _ptr = services::SharedPtr<byte>((byte *)daal::services::daal_malloc(size * sizeof(DataType)), services::ServiceDeleter());
644 
645  if( _ptr == 0 )
646  {
647  return services::Status(services::ErrorMemoryAllocationFailed);
648  }
649 
650  _allocatedSize = getSize();
651  _memStatus = internallyAllocated;
652  return services::Status();
653  }
654 
655  //the descriptions of the methods below are inherited from the base class
656  virtual services::Status freeDataMemoryImpl() DAAL_C11_OVERRIDE
657  {
658  if(_ptr)
659  _ptr = services::SharedPtr<byte>();
660  _allocatedSize = 0;
661  _memStatus = notAllocated;
662  return services::Status();
663  }
664 
665 private:
666  template <typename T>
667  services::Status getTSubtensor( size_t fixedDims, const size_t *fixedDimNums, size_t rangeDimIdx, size_t rangeDimNum, int rwFlag,
668  SubtensorDescriptor<T> &block, const TensorOffsetLayout& layout );
669  template <typename T>
670  services::Status releaseTSubtensor( SubtensorDescriptor<T> &block );
671 
672 private:
673  services::SharedPtr<byte> _ptr;
674  size_t _allocatedSize;
675  TensorOffsetLayout _layout;
676 };
679 }
680 using interface1::HomogenTensor;
681 
682 }
683 } // namespace daal
684 
685 #endif
daal::data_management::interface1::HomogenTensor::createDefaultSubtensorLayout
virtual TensorOffsetLayout createDefaultSubtensorLayout() const DAAL_C11_OVERRIDE
Definition: homogen_tensor.h:432
daal::data_management::interface1::HomogenTensor::HomogenTensor
HomogenTensor(const TensorOffsetLayout &layout, const services::SharedPtr< DataType > &data)
Definition: homogen_tensor.h:267
daal
Definition: algorithm_base_common.h:57
daal::data_management::interface1::Tensor
Class for a data management component responsible for representation of data in the n-dimensions nume...
Definition: tensor.h:481
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:171
daal::data_management::interface1::HomogenTensor::createRawSubtensorLayout
virtual TensorOffsetLayout createRawSubtensorLayout() const DAAL_C11_OVERRIDE
Definition: homogen_tensor.h:441
daal::data_management::interface1::HomogenTensor::setDimensions
virtual services::Status setDimensions(size_t nDim, const size_t *dimSizes) DAAL_C11_OVERRIDE
Definition: homogen_tensor.h:449
daal::data_management::interface1::HomogenTensor::getTensorLayout
TensorOffsetLayout & getTensorLayout()
Definition: homogen_tensor.h:423
daal::data_management::interface1::HomogenTensor::assign
services::Status assign(const DataType initValue)
Definition: homogen_tensor.h:475
daal::data_management::interface1::HomogenTensor::HomogenTensor
HomogenTensor()
Definition: homogen_tensor.h:85
daal::services::ErrorMemoryAllocationFailed
Definition: error_indexes.h:170
daal::dram
Definition: daal_defines.h:158
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:509
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:323
daal::data_management::interface1::HomogenTensor::getArraySharedPtr
services::SharedPtr< DataType > getArraySharedPtr() const
Definition: homogen_tensor.h:380
daal_defines.h
daal::data_management::interface1::HomogenTensor::HomogenTensor
HomogenTensor(size_t nDim, const size_t *dimSizes, DataType *data)
Definition: homogen_tensor.h:106
daal::data_management::interface1::HomogenTensor::setArray
services::Status setArray(const services::SharedPtr< DataType > &ptr)
Definition: homogen_tensor.h:406
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:354
daal::data_management::interface1::HomogenTensor::getArray
DataType * getArray() const
Definition: homogen_tensor.h:371
daal::data_management::interface1::HomogenTensor::HomogenTensor
HomogenTensor(const services::Collection< size_t > &dims, AllocationFlag memoryAllocationFlag, const DataType initValue)
Definition: homogen_tensor.h:336
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:255
daal::services::ErrorNullParameterNotSupported
Definition: error_indexes.h:99
daal::data_management::interface1::HomogenTensor::setArray
services::Status setArray(DataType *const ptr)
Definition: homogen_tensor.h:389
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:519
daal::algorithms::association_rules::data
Definition: apriori_types.h:107
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:503
daal::data_management::interface1::TensorIface::AllocationFlag
AllocationFlag
Enumeration to specify whether the Numeric Table must allocate memory.
Definition: tensor.h:103
daal::data_management::interface1::TensorOffsetLayout
Class for a data management component responsible for representation of data layout in the HomogenTen...
Definition: tensor.h:215
daal::data_management::interface1::HomogenTensor::HomogenTensor
HomogenTensor(const TensorOffsetLayout &layout, DataType *data)
Definition: homogen_tensor.h:227
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:497
daal::data_management::interface1::HomogenTensor::HomogenTensor
HomogenTensor(size_t nDim, const size_t *dimSizes, const services::SharedPtr< DataType > &data)
Definition: homogen_tensor.h:145
daal::data_management::interface1::HomogenTensor::setDimensions
virtual services::Status setDimensions(const services::Collection< size_t > &dimensions) DAAL_C11_OVERRIDE
Definition: homogen_tensor.h:460
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:73
daal::data_management::interface1::HomogenTensor::HomogenTensor
HomogenTensor(const services::Collection< size_t > &dims, AllocationFlag memoryAllocationFlag)
Definition: homogen_tensor.h:307
daal::data_management::interface1::SubtensorDescriptor
Class with descriptor of the subtensor retrieved from Tensor getSubTensor function.
Definition: subtensor.h:73
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:193
daal::data_management::interface1::HomogenTensor::create
static services::SharedPtr< HomogenTensor< DataType > > create(services::Status *stat=NULL)
Definition: homogen_tensor.h:94
daal::data_management::interface1::TensorLayout::getDimensions
const services::Collection< size_t > & getDimensions() const
Definition: tensor.h:188
daal::MemType
MemType
Definition: daal_defines.h:156
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:132
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:295
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:214

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