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

aos_numeric_table.h
1 /* file: aos_numeric_table.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 // Implementation of a heterogeneous table stored as a structure of arrays.
45 //--
46 */
47 
48 #ifndef __AOS_NUMERIC_TABLE_H__
49 #define __AOS_NUMERIC_TABLE_H__
50 
51 #include "data_management/data/data_serialize.h"
52 #include "data_management/data/numeric_table.h"
53 #include "services/daal_defines.h"
54 
55 namespace daal
56 {
57 namespace data_management
58 {
59 
60 // Extended variant of the standard offsetof() macro (not limited to only POD types)
61 /* Not sure if it's standard-compliant; most likely, it only works in certain environments.
62  The constant 0x1000 (not NULL) is necessary to appease GCC. */
63 #define DAAL_STRUCT_MEMBER_OFFSET(class_name, member_name) \
64  ((ptrdiff_t)&(reinterpret_cast<class_name*>(0x1000)->member_name) - 0x1000)
65 
66 namespace interface1
67 {
79 class DAAL_EXPORT AOSNumericTable : public NumericTable
80 {
81 public:
82  DECLARE_SERIALIZABLE_TAG();
83  DECLARE_SERIALIZABLE_IMPL();
84 
92  AOSNumericTable( size_t structSize = 0, size_t ncol = 0, size_t nrow = 0 );
93 
102  static services::SharedPtr<AOSNumericTable> create( size_t structSize = 0, size_t ncol = 0, size_t nrow = 0, services::Status *stat = NULL);
103 
111  template<typename StructDataType>
112  AOSNumericTable(const services::SharedPtr<StructDataType> &ptr, size_t ncol, size_t nrow = 0 ): NumericTable(ncol, nrow)
113  {
114  _ptr = services::reinterpretPointerCast<byte, StructDataType>(ptr);
115  _layout = aos;
116  _structSize = sizeof(StructDataType);
117 
118  initOffsets();
119  }
120 
129  template<typename StructDataType>
130  static services::SharedPtr<AOSNumericTable> create(const services::SharedPtr<StructDataType> &ptr, size_t ncol, size_t nrow = 0, services::Status *stat = NULL )
131  {
132  DAAL_DEFAULT_CREATE_IMPL_EX(AOSNumericTable, ptr, ncol, nrow);
133  }
134 
142  template<typename StructDataType>
143  AOSNumericTable( StructDataType *ptr, size_t ncol, size_t nrow = 0 ): NumericTable(ncol, nrow)
144  {
145  _ptr = services::SharedPtr<byte>((byte*)ptr, services::EmptyDeleter());
146  _layout = aos;
147  _structSize = sizeof(StructDataType);
148 
149  initOffsets();
150  }
151 
160  template<typename StructDataType>
161  static services::SharedPtr<AOSNumericTable> create( StructDataType *ptr, size_t ncol, size_t nrow = 0, services::Status *stat = NULL )
162  {
163  return create(services::SharedPtr<StructDataType>(ptr, services::EmptyDeleter()), ncol, nrow);
164  }
165 
167  virtual ~AOSNumericTable()
168  {
169  if (_offsets)
170  daal::services::daal_free(_offsets);
171  freeDataMemoryImpl();
172  }
173 
179  services::Status setArray(void *const ptr, size_t obsnum = 0)
180  {
181  _ptr = services::SharedPtr<byte>((byte*)ptr, services::EmptyDeleter());
182  _memStatus = userAllocated;
183  return setNumberOfRowsImpl( obsnum );
184  }
185 
191  services::Status setArray(const services::SharedPtr<byte>& ptr, size_t obsnum = 0)
192  {
193  _ptr = ptr;
194  _memStatus = userAllocated;
195  return setNumberOfRowsImpl( obsnum );
196  }
197 
202  void *getArray()
203  {
204  return (void *)(_ptr.get());
205  }
206 
211  const void *getArray() const
212  {
213  return (void *)(_ptr.get());
214  }
215 
220  services::SharedPtr<byte> getArraySharedPtr()
221  {
222  return _ptr;
223  }
224 
233  template<typename T>
234  services::Status setFeature(size_t idx, size_t offset, data_feature_utils::FeatureType featureType = data_feature_utils::DAAL_CONTINUOUS, size_t categoryNumber=0)
235  {
236  services::Status s;
237  if( _ddict.get() == NULL )
238  {
239  _ddict = NumericTableDictionary::create(&s);
240  }
241  if(!s) return s;
242 
243  s = _ddict->setFeature<T>(idx);
244  if(!s) return s;
245  (*_ddict)[idx].featureType = featureType;
246  (*_ddict)[idx].categoryNumber = categoryNumber;
247 
248  _offsets[idx] = offset;
249  return s;
250  }
251 
257  void setOffset(size_t idx, size_t offset)
258  {
259  _offsets[idx] = offset;
260  }
261 
262  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<double>& block) DAAL_C11_OVERRIDE
263  {
264  return getTBlock<double>(vector_idx, vector_num, rwflag, block);
265  }
266  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<float>& block) DAAL_C11_OVERRIDE
267  {
268  return getTBlock<float>(vector_idx, vector_num, rwflag, block);
269  }
270  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<int>& block) DAAL_C11_OVERRIDE
271  {
272  return getTBlock<int>(vector_idx, vector_num, rwflag, block);
273  }
274 
275  services::Status releaseBlockOfRows(BlockDescriptor<double>& block) DAAL_C11_OVERRIDE
276  {
277  return releaseTBlock<double>(block);
278  }
279  services::Status releaseBlockOfRows(BlockDescriptor<float>& block) DAAL_C11_OVERRIDE
280  {
281  return releaseTBlock<float>(block);
282  }
283  services::Status releaseBlockOfRows(BlockDescriptor<int>& block) DAAL_C11_OVERRIDE
284  {
285  return releaseTBlock<int>(block);
286  }
287 
288  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
289  ReadWriteMode rwflag, BlockDescriptor<double>& block) DAAL_C11_OVERRIDE
290  {
291  return getTFeature<double>(feature_idx, vector_idx, value_num, rwflag, block);
292  }
293  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
294  ReadWriteMode rwflag, BlockDescriptor<float>& block) DAAL_C11_OVERRIDE
295  {
296  return getTFeature<float>(feature_idx, vector_idx, value_num, rwflag, block);
297  }
298  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
299  ReadWriteMode rwflag, BlockDescriptor<int>& block) DAAL_C11_OVERRIDE
300  {
301  return getTFeature<int>(feature_idx, vector_idx, value_num, rwflag, block);
302  }
303 
304  services::Status releaseBlockOfColumnValues(BlockDescriptor<double>& block) DAAL_C11_OVERRIDE
305  {
306  return releaseTFeature<double>(block);
307  }
308  services::Status releaseBlockOfColumnValues(BlockDescriptor<float>& block) DAAL_C11_OVERRIDE
309  {
310  return releaseTFeature<float>(block);
311  }
312  services::Status releaseBlockOfColumnValues(BlockDescriptor<int>& block) DAAL_C11_OVERRIDE
313  {
314  return releaseTFeature<int>(block);
315  }
316 
317 protected:
318  services::SharedPtr<byte> _ptr;
319  size_t _structSize;
320  size_t *_offsets;
321 
322  AOSNumericTable( size_t structSize, size_t ncol, size_t nrow, services::Status &st );
323 
324  template<typename StructDataType>
325  AOSNumericTable(const services::SharedPtr<StructDataType> &ptr, size_t ncol, size_t nrow, services::Status &st) : NumericTable(ncol, nrow, DictionaryIface::notEqual, st)
326  {
327  _ptr = services::reinterpretPointerCast<byte, StructDataType>(ptr);
328  _layout = aos;
329  _structSize = sizeof(StructDataType);
330 
331  st |= initOffsets();
332  }
333 
334  services::Status allocateDataMemoryImpl(daal::MemType type = daal::dram) DAAL_C11_OVERRIDE
335  {
336  if (checkOffsets())
337  {
338  services::Status s = createOffsetsFromDictionary();
339  if (!s) return s;
340  }
341 
342  freeDataMemoryImpl();
343 
344  const size_t size = _structSize * getNumberOfRows();
345 
346  if( size == 0 )
347  return services::Status(getNumberOfRows() == 0 ? services::ErrorIncorrectNumberOfObservations :
348  services::ErrorIncorrectNumberOfFeatures);
349 
350  _ptr = services::SharedPtr<byte>((byte *)daal::services::daal_malloc(size), services::ServiceDeleter());
351  if(!_ptr)
352  return services::Status(services::ErrorMemoryAllocationFailed);
353 
354  _memStatus = internallyAllocated;
355  return services::Status();
356  }
357 
358  bool checkOffsets() const
359  {
360  if (!_offsets) return true;
361 
362  const size_t ncols = getNumberOfColumns();
363 
364  size_t sizeOfRowInDict = 0;
365  for( size_t i = 0; i < ncols; ++i )
366  {
367  if (!(*_ddict)[i].typeSize)
368  {
369  return false;
370  }
371  sizeOfRowInDict += (*_ddict)[i].typeSize;
372  }
373  if (sizeOfRowInDict > _structSize)
374  {
375  return true;
376  }
377 
378  for( size_t i = 1; i < ncols; ++i )
379  {
380  if ( _offsets[i-1] >= _offsets[i] )
381  {
382  return true;
383  }
384  }
385  return false;
386  }
387 
388  services::Status createOffsetsFromDictionary()
389  {
390  const size_t ncols = getNumberOfColumns();
391 
392  if (_offsets)
393  daal::services::daal_free(_offsets);
394 
395  _offsets = (size_t *)daal::services::daal_malloc(sizeof(size_t) * (ncols));
396  if(!_offsets)
397  return services::Status(services::ErrorMemoryAllocationFailed);
398 
399  size_t offset = 0;
400  for( size_t i = 0; i < ncols; ++i )
401  {
402  _offsets[i] = offset;
403  offset += (*_ddict)[i].typeSize;
404  }
405  _structSize = offset;
406 
407  return services::Status();
408  }
409 
410  void freeDataMemoryImpl() DAAL_C11_OVERRIDE
411  {
412  _ptr = services::SharedPtr<byte>();
413  _memStatus = notAllocated;
414  }
415 
417  template<typename Archive, bool onDeserialize>
418  services::Status serialImpl( Archive *arch )
419  {
420  NumericTable::serialImpl<Archive, onDeserialize>( arch );
421  arch->set(_structSize);
422 
423  if( onDeserialize )
424  {
425  initOffsets();
426  }
427  arch->set((char*)_offsets, getNumberOfColumns() * sizeof(size_t));
428 
429  if( onDeserialize )
430  {
431  allocateDataMemoryImpl();
432  }
433 
434  size_t size = getNumberOfRows();
435 
436  arch->set( (char *)_ptr.get(), size * _structSize );
437 
438  return services::Status();
439  }
440 
441 private:
442 
443  template <typename T>
444  services::Status getTBlock(size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T>& block)
445  {
446  size_t ncols = getNumberOfColumns();
447  size_t nobs = getNumberOfRows();
448  block.setDetails( 0, idx, rwFlag );
449 
450  if (idx >= nobs)
451  {
452  block.resizeBuffer( ncols, 0 );
453  return services::Status();
454  }
455 
456  nrows = ( idx + nrows < nobs ) ? nrows : nobs - idx;
457 
458  if( !block.resizeBuffer( ncols, nrows ) )
459  return services::Status(services::ErrorMemoryAllocationFailed);
460 
461  if( !(rwFlag & (int)readOnly) )
462  return services::Status();
463 
464  char *ptr = (char *)(_ptr.get()) + _structSize * idx;
465 
466  for( size_t j = 0 ; j < ncols ; j++ )
467  {
468  NumericTableFeature &f = (*_ddict)[j];
469 
470  char *location = ptr + _offsets[j];
471 
472  T* blockPtr = block.getBlockPtr();
473 
474  data_feature_utils::getVectorStrideUpCast(f.indexType, data_feature_utils::getInternalNumType<T>())
475  ( nrows, location, _structSize, blockPtr + j, sizeof(T)*ncols );
476  }
477  return services::Status();
478  }
479 
480  template <typename T>
481  services::Status releaseTBlock( BlockDescriptor<T>& block )
482  {
483  if(block.getRWFlag() & (int)writeOnly)
484  {
485  size_t ncols = getNumberOfColumns();
486 
487  char *ptr = (char *)(_ptr.get()) + _structSize * block.getRowsOffset();
488 
489  T* blockPtr = block.getBlockPtr();
490 
491  for( size_t j = 0 ; j < ncols ; j++ )
492  {
493  NumericTableFeature &f = (*_ddict)[j];
494 
495  char *location = ptr + _offsets[j];
496 
497  data_feature_utils::getVectorStrideDownCast(f.indexType, data_feature_utils::getInternalNumType<T>())
498  ( block.getNumberOfRows(), blockPtr + j, sizeof(T)*ncols, location, _structSize );
499  }
500  }
501  block.reset();
502  return services::Status();
503  }
504 
505  template <typename T>
506  services::Status getTFeature(size_t feat_idx, size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T>& block)
507  {
508  size_t ncols = getNumberOfColumns();
509  size_t nobs = getNumberOfRows();
510  block.setDetails( feat_idx, idx, rwFlag );
511 
512  if (idx >= nobs)
513  {
514  block.resizeBuffer( 1, 0 );
515  return services::Status();
516  }
517 
518  nrows = ( idx + nrows < nobs ) ? nrows : nobs - idx;
519 
520  if( !block.resizeBuffer( 1, nrows ) )
521  return services::Status(services::ErrorMemoryAllocationFailed);
522 
523  if((block.getRWFlag() & (int)readOnly))
524  {
525  NumericTableFeature &f = (*_ddict)[feat_idx];
526  char *ptr = (char *)(_ptr.get()) + _structSize * idx + _offsets[feat_idx];
527  data_feature_utils::getVectorStrideUpCast(f.indexType, data_feature_utils::getInternalNumType<T>())
528  (nrows, ptr, _structSize, block.getBlockPtr(), sizeof(T));
529  }
530  return services::Status();
531  }
532 
533  template <typename T>
534  services::Status releaseTFeature( BlockDescriptor<T>& block )
535  {
536  if (block.getRWFlag() & (int)writeOnly)
537  {
538  size_t feat_idx = block.getColumnsOffset();
539 
540  NumericTableFeature &f = (*_ddict)[feat_idx];
541 
542  char *ptr = (char *)(_ptr.get()) + _structSize * block.getRowsOffset() + _offsets[feat_idx];
543 
544  data_feature_utils::getVectorStrideDownCast(f.indexType, data_feature_utils::getInternalNumType<T>())
545  ( block.getNumberOfRows(), block.getBlockPtr(), sizeof(T), ptr, _structSize );
546  }
547  block.reset();
548  return services::Status();
549  }
550 
551  services::Status initOffsets()
552  {
553  const size_t ncols = getNumberOfColumns();
554  if( ncols > 0 )
555  {
556  _offsets = (size_t *)daal::services::daal_malloc(sizeof(size_t) * (ncols));
557  if(!_offsets)
558  return services::Status(services::ErrorMemoryAllocationFailed);
559  for( size_t i = 0; i < ncols; ++i ) _offsets[i] = 0;
560  }
561  else
562  {
563  _offsets = 0;
564  }
565  return services::Status();
566  }
567 };
568 typedef services::SharedPtr<AOSNumericTable> AOSNumericTablePtr;
570 } // namespace interface1
571 using interface1::AOSNumericTable;
572 using interface1::AOSNumericTablePtr;
573 
574 }
575 } // namespace daal
576 #endif
daal::data_management::interface1::AOSNumericTable::AOSNumericTable
AOSNumericTable(StructDataType *ptr, size_t ncol, size_t nrow=0)
Definition: aos_numeric_table.h:143
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::AOSNumericTable::AOSNumericTable
AOSNumericTable(const services::SharedPtr< StructDataType > &ptr, size_t ncol, size_t nrow=0)
Definition: aos_numeric_table.h:112
daal::data_management::interface1::AOSNumericTable::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: aos_numeric_table.h:288
daal::data_management::interface1::AOSNumericTable::getBlockOfRows
services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: aos_numeric_table.h:270
daal::services::ErrorMemoryAllocationFailed
Definition: error_indexes.h:172
daal::data_management::interface1::AOSNumericTable::setFeature
services::Status setFeature(size_t idx, size_t offset, data_feature_utils::FeatureType featureType=data_feature_utils::DAAL_CONTINUOUS, size_t categoryNumber=0)
Definition: aos_numeric_table.h:234
daal::data_management::interface1::AOSNumericTable::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: aos_numeric_table.h:298
daal::dram
Definition: daal_defines.h:159
daal::data_management::interface1::AOSNumericTable::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: aos_numeric_table.h:308
daal::data_management::interface1::BlockDescriptor::getBlockPtr
DataType * getBlockPtr() const
Definition: numeric_table.h:95
daal::services::ErrorIncorrectNumberOfFeatures
Definition: error_indexes.h:96
daal_defines.h
daal::algorithms::multivariate_outlier_detection::location
Definition: outlier_detection_multivariate_types.h:98
daal::data_management::interface1::BlockDescriptor::resizeBuffer
bool resizeBuffer(size_t nColumns, size_t nRows, size_t auxMemorySize=0)
Definition: numeric_table.h:177
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::AOSNumericTable::setArray
services::Status setArray(const services::SharedPtr< byte > &ptr, size_t obsnum=0)
Definition: aos_numeric_table.h:191
daal::services::daal_malloc
DAAL_EXPORT void * daal_malloc(size_t size, size_t alignment=DAAL_MALLOC_DEFAULT_ALIGNMENT)
daal::data_management::interface1::AOSNumericTable::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: aos_numeric_table.h:304
daal::data_management::interface1::AOSNumericTable::getArray
const void * getArray() const
Definition: aos_numeric_table.h:211
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::AOSNumericTable::getArray
void * getArray()
Definition: aos_numeric_table.h:202
daal::data_management::interface1::AOSNumericTable::setOffset
void setOffset(size_t idx, size_t offset)
Definition: aos_numeric_table.h:257
daal::data_management::interface1::BlockDescriptor::getRWFlag
size_t getRWFlag() const
Definition: numeric_table.h:244
daal::data_management::interface1::AOSNumericTable
Class that provides methods to access data stored as a contiguous array of heterogeneous feature vect...
Definition: aos_numeric_table.h:79
daal::services::daal_free
DAAL_EXPORT void daal_free(void *ptr)
daal::data_management::interface1::AOSNumericTable::getArraySharedPtr
services::SharedPtr< byte > getArraySharedPtr()
Definition: aos_numeric_table.h:220
daal::data_management::interface1::AOSNumericTable::create
static services::SharedPtr< AOSNumericTable > create(StructDataType *ptr, size_t ncol, size_t nrow=0, services::Status *stat=NULL)
Definition: aos_numeric_table.h:161
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::AOSNumericTable::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: aos_numeric_table.h:279
daal::data_management::interface1::AOSNumericTable::setArray
services::Status setArray(void *const ptr, size_t obsnum=0)
Definition: aos_numeric_table.h:179
daal::data_management::interface1::AOSNumericTable::create
static services::SharedPtr< AOSNumericTable > create(const services::SharedPtr< StructDataType > &ptr, size_t ncol, size_t nrow=0, services::Status *stat=NULL)
Definition: aos_numeric_table.h:130
daal::data_management::interface1::AOSNumericTable::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: aos_numeric_table.h:275
daal::data_management::interface1::BlockDescriptor::reset
void reset()
Definition: numeric_table.h:132
daal::data_management::interface1::BlockDescriptor::getColumnsOffset
size_t getColumnsOffset() const
Definition: numeric_table.h:232
daal::data_management::interface1::AOSNumericTable::getBlockOfRows
services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: aos_numeric_table.h:262
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::services::ErrorIncorrectNumberOfObservations
Definition: error_indexes.h:97
daal::data_management::interface1::AOSNumericTable::getBlockOfRows
services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: aos_numeric_table.h:266
daal::data_management::interface1::BlockDescriptor::getNumberOfRows
size_t getNumberOfRows() const
Definition: numeric_table.h:127
daal::data_management::interface1::Dictionary::create
static services::SharedPtr< Dictionary > create(size_t nfeat, FeaturesEqual featuresEqual=notEqual, services::Status *stat=NULL)
Definition: data_dictionary.h:209
daal::data_management::interface1::AOSNumericTable::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: aos_numeric_table.h:312
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::AOSNumericTable::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: aos_numeric_table.h:293
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::NumericTableFeature
Data structure describes the Numeric Table feature.
Definition: data_dictionary.h:74
daal::MemType
MemType
Definition: daal_defines.h:157
daal::data_management::interface1::AOSNumericTable::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: aos_numeric_table.h:283

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