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

soa_numeric_table.h
1 /* file: soa_numeric_table.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 // Implementation of a heterogeneous table stored as a structure of arrays.
21 //--
22 */
23 
24 #ifndef __SOA_NUMERIC_TABLE_H__
25 #define __SOA_NUMERIC_TABLE_H__
26 
27 #include "data_management/data/numeric_table.h"
28 #include "data_management/data/internal/conversion.h"
29 
30 namespace daal
31 {
32 namespace data_management
33 {
34 
35 namespace interface1
36 {
46 class DAAL_EXPORT SOANumericTable : public NumericTable
47 {
48 public:
49  DECLARE_SERIALIZABLE_TAG();
50  DECLARE_SERIALIZABLE_IMPL();
51 
59  SOANumericTable(size_t nColumns = 0, size_t nRows = 0, DictionaryIface::FeaturesEqual featuresEqual = DictionaryIface::notEqual);
60 
69  static services::SharedPtr<SOANumericTable> create(size_t nColumns = 0, size_t nRows = 0,
70  DictionaryIface::FeaturesEqual featuresEqual = DictionaryIface::notEqual,
71  services::Status *stat = NULL);
72 
80  DAAL_DEPRECATED SOANumericTable( NumericTableDictionary *ddict, size_t nRows, AllocationFlag memoryAllocationFlag = notAllocate ):
81  NumericTable(NumericTableDictionaryPtr(ddict, services::EmptyDeleter())),
82  _arraysInitialized(0), _partialMemStatus(notAllocated)
83  {
84  _layout = soa;
85  _arrOffsets = NULL;
86  _index = 0;
87  this->_status |= setNumberOfRowsImpl(nRows);
88  if (!resizePointersArray(getNumberOfColumns()))
89  {
90  this->_status.add(services::ErrorMemoryAllocationFailed);
91  return;
92  }
93  if( memoryAllocationFlag == doAllocate )
94  {
95  this->_status |= allocateDataMemoryImpl();
96  }
97  }
98 
106  SOANumericTable( NumericTableDictionaryPtr ddict, size_t nRows, AllocationFlag memoryAllocationFlag = notAllocate );
107 
116  static services::SharedPtr<SOANumericTable> create(NumericTableDictionaryPtr ddict, size_t nRows,
117  AllocationFlag memoryAllocationFlag = notAllocate,
118  services::Status *stat = NULL);
119 
120  virtual ~SOANumericTable()
121  {
122  freeDataMemoryImpl();
123  if (_arrOffsets)
124  {
125  daal::services::daal_free(_arrOffsets);
126  _arrOffsets = NULL;
127  }
128  }
129 
136  template<typename T>
137  services::Status setArray(const services::SharedPtr<T> &ptr, size_t idx)
138  {
139  if( _partialMemStatus != notAllocated && _partialMemStatus != userAllocated )
140  {
141  return services::Status(services::ErrorIncorrectNumberOfFeatures);
142  }
143 
144  if( idx < getNumberOfColumns() && idx < _arrays.size() )
145  {
146  _ddict->setFeature<T>(idx);
147 
148  if( !_arrays[idx] && ptr )
149  {
150  _arraysInitialized++;
151  }
152 
153  if( _arrays[idx] && !ptr )
154  {
155  _arraysInitialized--;
156  }
157 
158  _arrays[idx] = services::reinterpretPointerCast<byte, T>(ptr);
159  }
160  else
161  {
162  return services::Status(services::ErrorIncorrectNumberOfFeatures);
163  }
164 
165  _partialMemStatus = userAllocated;
166 
167  if(_arraysInitialized == getNumberOfColumns())
168  {
169  _memStatus = userAllocated;
170  }
171  DAAL_CHECK_STATUS_VAR(generatesOffsets())
172  return services::Status();
173  }
174 
181  template<typename T>
182  services::Status setArray(T *ptr, size_t idx)
183  {
184  return setArray(services::SharedPtr<T>(ptr, services::EmptyDeleter()), idx);
185  }
186 
192  services::SharedPtr<byte> getArraySharedPtr(size_t idx)
193  {
194  if( idx < _ddict->getNumberOfFeatures() )
195  {
196  return _arrays[idx];
197  }
198  else
199  {
200  this->_status.add(services::ErrorIncorrectNumberOfFeatures);
201  return services::SharedPtr<byte>();
202  }
203  }
204 
210  void *getArray(size_t idx)
211  {
212  return getArraySharedPtr(idx).get();
213  }
214 
215  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<double>& block) DAAL_C11_OVERRIDE
216  {
217  return getTBlock<double>(vector_idx, vector_num, rwflag, block);
218  }
219  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<float>& block) DAAL_C11_OVERRIDE
220  {
221  return getTBlock<float>(vector_idx, vector_num, rwflag, block);
222  }
223  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<int>& block) DAAL_C11_OVERRIDE
224  {
225  return getTBlock<int>(vector_idx, vector_num, rwflag, block);
226  }
227 
228  services::Status releaseBlockOfRows(BlockDescriptor<double>& block) DAAL_C11_OVERRIDE
229  {
230  return releaseTBlock<double>(block);
231  }
232  services::Status releaseBlockOfRows(BlockDescriptor<float>& block) DAAL_C11_OVERRIDE
233  {
234  return releaseTBlock<float>(block);
235  }
236  services::Status releaseBlockOfRows(BlockDescriptor<int>& block) DAAL_C11_OVERRIDE
237  {
238  return releaseTBlock<int>(block);
239  }
240 
241  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
242  ReadWriteMode rwflag, BlockDescriptor<double>& block) DAAL_C11_OVERRIDE
243  {
244  return getTFeature<double>(feature_idx, vector_idx, value_num, rwflag, block);
245  }
246  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
247  ReadWriteMode rwflag, BlockDescriptor<float>& block) DAAL_C11_OVERRIDE
248  {
249  return getTFeature<float>(feature_idx, vector_idx, value_num, rwflag, block);
250  }
251  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
252  ReadWriteMode rwflag, BlockDescriptor<int>& block) DAAL_C11_OVERRIDE
253  {
254  return getTFeature<int>(feature_idx, vector_idx, value_num, rwflag, block);
255  }
256 
257  services::Status releaseBlockOfColumnValues(BlockDescriptor<double>& block) DAAL_C11_OVERRIDE
258  {
259  return releaseTFeature<double>(block);
260  }
261  services::Status releaseBlockOfColumnValues(BlockDescriptor<float>& block) DAAL_C11_OVERRIDE
262  {
263  return releaseTFeature<float>(block);
264  }
265  services::Status releaseBlockOfColumnValues(BlockDescriptor<int>& block) DAAL_C11_OVERRIDE
266  {
267  return releaseTFeature<int>(block);
268  }
269 
270  DAAL_DEPRECATED_VIRTUAL services::Status setDictionary( NumericTableDictionary *ddict ) DAAL_C11_OVERRIDE
271  {
272  services::Status s;
273  DAAL_CHECK_STATUS(s, NumericTable::setDictionary( ddict ));
274 
275  size_t ncol = ddict->getNumberOfFeatures();
276 
277  if( !resizePointersArray( ncol ) )
278  {
279  return services::Status(services::ErrorMemoryAllocationFailed);
280  }
281  return s;
282  }
283 
284 protected:
285 
286  SOANumericTable( size_t nColumns, size_t nRows, DictionaryIface::FeaturesEqual featuresEqual, services::Status &st );
287 
288  SOANumericTable( NumericTableDictionaryPtr ddict, size_t nRows, AllocationFlag memoryAllocationFlag, services::Status &st );
289 
290  services::Collection<services::SharedPtr<byte> > _arrays;
291  size_t _arraysInitialized;
292  MemoryStatus _partialMemStatus;
293  DAAL_INT64 * _arrOffsets;
294  size_t _index;
295 
296  bool resizePointersArray(size_t nColumns)
297  {
298  if( _arrays.size() >= nColumns )
299  {
300  size_t counter = 0;
301  for(size_t i = 0; i < nColumns; i++)
302  {
303  counter += (_arrays[i] != 0);
304  }
305  _arraysInitialized = counter;
306 
307  if( _arraysInitialized == nColumns )
308  {
309  _memStatus = _partialMemStatus;
310  }
311  else
312  {
313  _memStatus = notAllocated;
314  }
315 
316  return true;
317  }
318  _arrays.resize(nColumns);
319  _memStatus = notAllocated;
320 
321  bool is_resized = _arrays.resize(nColumns);
322  if (is_resized)
323  {
324  _memStatus = notAllocated;
325  }
326 
327  if (_arrOffsets)
328  {
329  daal::services::daal_free(_arrOffsets);
330  _arrOffsets = NULL;
331  _index = 0;
332  }
333 
334  return is_resized;
335  }
336 
337  services::Status setNumberOfColumnsImpl(size_t ncol) DAAL_C11_OVERRIDE
338  {
339  services::Status s;
340  DAAL_CHECK_STATUS(s, NumericTable::setNumberOfColumnsImpl(ncol));
341 
342  if( !resizePointersArray( ncol ) )
343  {
344  return services::Status(services::ErrorMemoryAllocationFailed);
345  }
346  return s;
347  }
348 
349  services::Status allocateDataMemoryImpl(daal::MemType type = daal::dram) DAAL_C11_OVERRIDE
350  {
351  freeDataMemoryImpl();
352 
353  size_t ncol = _ddict->getNumberOfFeatures();
354  size_t nrows = getNumberOfRows();
355 
356  if( ncol * nrows == 0 )
357  {
358  if( nrows == 0 )
359  {
360  return services::Status(services::ErrorIncorrectNumberOfObservations);
361  }
362  else
363  {
364  return services::Status(services::ErrorIncorrectNumberOfFeatures);
365  }
366  }
367 
368  for(size_t i = 0; i < ncol; i++)
369  {
370  NumericTableFeature f = (*_ddict)[i];
371  if( f.typeSize != 0 )
372  {
373  _arrays[i] = services::SharedPtr<byte>((byte *)daal::services::daal_malloc( f.typeSize * nrows ), services::ServiceDeleter());
374  _arraysInitialized++;
375  }
376  if( !_arrays[i] )
377  {
378  freeDataMemoryImpl();
379  return services::Status(services::ErrorMemoryAllocationFailed);
380  }
381  }
382 
383  if(_arraysInitialized > 0)
384  {
385  _partialMemStatus = internallyAllocated;
386  }
387 
388  if(_arraysInitialized == ncol)
389  {
390  _memStatus = internallyAllocated;
391  }
392  DAAL_CHECK_STATUS_VAR(generatesOffsets())
393  return services::Status();
394  }
395 
396  void freeDataMemoryImpl() DAAL_C11_OVERRIDE
397  {
398  _arrays.clear();
399  _arrays.resize(_ddict->getNumberOfFeatures());
400  _arraysInitialized = 0;
401 
402  _partialMemStatus = notAllocated;
403  _memStatus = notAllocated;
404  }
405 
406  template<typename Archive, bool onDeserialize>
407  services::Status serialImpl( Archive *arch )
408  {
409  NumericTable::serialImpl<Archive, onDeserialize>( arch );
410 
411  if( onDeserialize )
412  {
413  allocateDataMemoryImpl();
414  }
415 
416  size_t ncol = _ddict->getNumberOfFeatures();
417  size_t nrows = getNumberOfRows();
418 
419  for(size_t i = 0; i < ncol; i++)
420  {
421  NumericTableFeature f = (*_ddict)[i];
422  void *ptr = getArraySharedPtr(i).get();
423 
424  arch->set( (char *)ptr, nrows * f.typeSize );
425  }
426 
427  return services::Status();
428  }
429 
430 private:
431  services::Status generatesOffsets()
432  {
433  if (isHomogeneous())
434  {
435  if (isAllCompleted()) DAAL_CHECK_STATUS_VAR(searchMinPointer());
436  }
437 
438  return services::Status();
439  }
440 
441  bool isAllCompleted() const
442  {
443  size_t ncols = getNumberOfColumns();
444 
445  for (size_t i = 0; i < ncols; ++i)
446  {
447  if (!_arrays[i].get()) return false;
448  }
449 
450  return true;
451  }
452 
453  services::Status searchMinPointer()
454  {
455  size_t ncols = getNumberOfColumns();
456 
457  if (_arrOffsets) daal::services::daal_free(_arrOffsets);
458 
459  _arrOffsets = (DAAL_INT64 *)daal::services::daal_malloc(ncols * sizeof(DAAL_INT64));
460  DAAL_CHECK_MALLOC(_arrOffsets)
461  _index = 0;
462  char * ptrMin = (char *)_arrays[0].get();
463 
464  /* search index for min pointer */
465  for (size_t i = 1; i < ncols; ++i)
466  {
467  if ((char *)_arrays[i].get() < ptrMin)
468  {
469  _index = i;
470  ptrMin = (char *)_arrays[i].get();
471  }
472  }
473 
474  /* compute offsets */
475  for (size_t i = 0; i < ncols; ++i)
476  {
477  char * pv = (char *)(_arrays[i].get());
478  _arrOffsets[i] = (DAAL_INT64)(pv - ptrMin);
479  DAAL_ASSERT(_arrOffsets[i] >= 0)
480  }
481 
482  return services::Status();
483  }
484 
485  /* the method checks for the fact that all columns have the same data type. */
486  bool isHomogeneous() const
487  {
488  size_t ncols = getNumberOfColumns();
489 
490  NumericTableFeature & f0 = (*_ddict)[0];
491 
492  for (size_t i = 0; i < ncols; ++i)
493  {
494  NumericTableFeature & f1 = (*_ddict)[i];
495 
496  if (f1.indexType != f0.indexType) return false;
497  }
498 
499  return (int)f0.indexType == (int)internal::getConversionDataType<float>()
500  || (int)f0.indexType == (int)internal::getConversionDataType<double>();
501  }
502 
503  template <typename T>
504  services::Status getTBlock(size_t idx, size_t nrows, ReadWriteMode rwFlag, BlockDescriptor<T> & block)
505  {
506  size_t ncols = getNumberOfColumns();
507  size_t nobs = getNumberOfRows();
508  block.setDetails(0, idx, rwFlag);
509 
510  if (idx >= nobs)
511  {
512  block.resizeBuffer(ncols, 0);
513  return services::Status();
514  }
515 
516  nrows = (idx + nrows < nobs) ? nrows : nobs - idx;
517 
518  if (!block.resizeBuffer(ncols, nrows))
519  {
520  return services::Status(services::ErrorMemoryAllocationFailed);
521  }
522 
523  if (!(block.getRWFlag() & (int)readOnly)) return services::Status();
524 
525  T * buffer = block.getBlockPtr();
526  bool computed = false;
527 
528  if (isHomogeneous())
529  {
530  NumericTableFeature & f = (*_ddict)[0];
531 
532  if ((int)internal::getConversionDataType<T>() == (int)f.indexType)
533  {
534  DAAL_CHECK(_arrOffsets, services::ErrorNullPtr)
535  T const * ptrMin = (T *)(_arrays[_index].get()) + idx;
536  computed = data_management::internal::getVector<T>()(nrows, ncols, buffer, ptrMin, _arrOffsets);
537  }
538  }
539  if (!computed)
540  {
541  size_t di = 32;
542  T lbuf[32];
543 
544  for (size_t i = 0; i < nrows; i += di)
545  {
546  if (i + di > nrows)
547  {
548  di = nrows - i;
549  }
550 
551  for (size_t j = 0; j < ncols; ++j)
552  {
553  NumericTableFeature & f = (*_ddict)[j];
554 
555  char * ptr = (char *)_arrays[j].get() + (idx + i) * f.typeSize;
556 
557  internal::getVectorUpCast(f.indexType, internal::getConversionDataType<T>())(di, ptr, lbuf);
558 
559  for (size_t k = 0; k < di; ++k)
560  {
561  buffer[(i + k) * ncols + j] = lbuf[k];
562  }
563  }
564  }
565  }
566 
567  return services::Status();
568  }
569 
570  template <typename T>
571  services::Status releaseTBlock( BlockDescriptor<T>& block )
572  {
573  if(block.getRWFlag() & (int)writeOnly)
574  {
575  size_t ncols = getNumberOfColumns();
576  size_t nrows = block.getNumberOfRows();
577  size_t idx = block.getRowsOffset();
578  T lbuf[32];
579 
580  size_t di = 32;
581 
582  T *blockPtr = block.getBlockPtr();
583 
584  for( size_t i = 0 ; i < nrows ; i += di )
585  {
586  if( i + di > nrows ) { di = nrows - i; }
587 
588  for( size_t j = 0 ; j < ncols ; j++ )
589  {
590  NumericTableFeature &f = (*_ddict)[j];
591 
592  char *ptr = (char *)_arrays[j].get() + (idx + i) * f.typeSize;
593 
594  for( size_t ii = 0 ; ii < di; ii++ )
595  {
596  lbuf[ii] = blockPtr[ (i + ii) * ncols + j ];
597  }
598 
599  internal::getVectorDownCast(f.indexType, internal::getConversionDataType<T>())
600  ( di, lbuf, ptr );
601  }
602  }
603  }
604  block.reset();
605  return services::Status();
606  }
607 
608  template <typename T>
609  services::Status getTFeature( size_t feat_idx, size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T>& block )
610  {
611  size_t ncols = getNumberOfColumns();
612  size_t nobs = getNumberOfRows();
613  block.setDetails( feat_idx, idx, rwFlag );
614 
615  if (idx >= nobs)
616  {
617  block.resizeBuffer( 1, 0 );
618  return services::Status();
619  }
620 
621  nrows = ( idx + nrows < nobs ) ? nrows : nobs - idx;
622 
623  NumericTableFeature &f = (*_ddict)[feat_idx];
624 
625  if( features::internal::getIndexNumType<T>() == f.indexType )
626  {
627  block.setPtr(&(_arrays[feat_idx]), _arrays[feat_idx].get() + idx * f.typeSize , 1, nrows );
628  }
629  else
630  {
631  byte *location = _arrays[feat_idx].get() + idx * f.typeSize;
632 
633  if( !block.resizeBuffer( 1, nrows ) )
634  {
635  return services::Status(services::ErrorMemoryAllocationFailed);
636  }
637 
638  if( !(block.getRWFlag() & (int)readOnly) ) return services::Status();
639 
640  internal::getVectorUpCast(f.indexType, internal::getConversionDataType<T>())
641  ( nrows, location, block.getBlockPtr() );
642  }
643  return services::Status();
644  }
645 
646  template <typename T>
647  services::Status releaseTFeature( BlockDescriptor<T>& block )
648  {
649  if (block.getRWFlag() & (int)writeOnly)
650  {
651  size_t feat_idx = block.getColumnsOffset();
652 
653  NumericTableFeature &f = (*_ddict)[feat_idx];
654 
655  if( features::internal::getIndexNumType<T>() != f.indexType )
656  {
657  char *ptr = (char *)_arrays[feat_idx].get() + block.getRowsOffset() * f.typeSize;
658 
659  internal::getVectorDownCast(f.indexType, internal::getConversionDataType<T>())
660  ( block.getNumberOfRows(), block.getBlockPtr(), ptr );
661  }
662  }
663  block.reset();
664  return services::Status();
665  }
666 };
667 typedef services::SharedPtr<SOANumericTable> SOANumericTablePtr;
669 } // namespace interface1
670 using interface1::SOANumericTable;
671 using interface1::SOANumericTablePtr;
672 
673 }
674 } // namespace daal
675 #endif
daal::data_management::interface1::SOANumericTable::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: soa_numeric_table.h:232
daal::data_management::interface1::SOANumericTable::setDictionary
DAAL_DEPRECATED_VIRTUAL services::Status setDictionary(NumericTableDictionary *ddict) DAAL_C11_OVERRIDE
Definition: soa_numeric_table.h:270
daal::data_management::interface1::SOANumericTable
Class that provides methods to access data stored as a structure of arrays, where each (contiguous) a...
Definition: soa_numeric_table.h:46
daal::algorithms::multivariate_outlier_detection::location
Definition: outlier_detection_multivariate_types.h:74
daal::services::ErrorIncorrectNumberOfObservations
Definition: error_indexes.h:73
daal::data_management::interface1::SOANumericTable::getArraySharedPtr
services::SharedPtr< byte > getArraySharedPtr(size_t idx)
Definition: soa_numeric_table.h:192
daal::data_management::interface1::SOANumericTable::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: soa_numeric_table.h:251
daal::data_management::interface1::Dictionary
Class that represents a dictionary of a data set and provides methods to work with the data dictionar...
Definition: data_dictionary.h:163
daal::data_management::interface1::NumericTable
Class for a data management component responsible for representation of data in the numeric format...
Definition: numeric_table.h:577
daal::services::ErrorNullPtr
Definition: error_indexes.h:141
daal::data_management::interface1::SOANumericTable::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: soa_numeric_table.h:246
daal::data_management::interface1::SOANumericTable::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: soa_numeric_table.h:265
daal::data_management::interface1::SOANumericTable::setArray
services::Status setArray(T *ptr, size_t idx)
Definition: soa_numeric_table.h:182
daal::MemType
MemType
Definition: daal_defines.h:147
daal::data_management::interface1::NumericTable::setDictionary
virtual DAAL_DEPRECATED_VIRTUAL services::Status setDictionary(NumericTableDictionary *ddict) DAAL_C11_OVERRIDE
Definition: numeric_table.h:627
daal::data_management::interface1::SOANumericTable::getArray
void * getArray(size_t idx)
Definition: soa_numeric_table.h:210
daal::data_management::interface1::SOANumericTable::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: soa_numeric_table.h:241
daal::data_management::interface1::SOANumericTable::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: soa_numeric_table.h:261
daal::data_management::interface1::NumericTableIface::AllocationFlag
AllocationFlag
Enumeration to specify whether the Numeric Table must allocate memory.
Definition: numeric_table.h:285
daal::data_management::interface1::SOANumericTable::getBlockOfRows
services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: soa_numeric_table.h:215
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::BlockDescriptor
Base class that manages buffer memory for read/write operations required by numeric tables...
Definition: numeric_table.h:57
daal::data_management::interface1::SOANumericTable::SOANumericTable
DAAL_DEPRECATED SOANumericTable(NumericTableDictionary *ddict, size_t nRows, AllocationFlag memoryAllocationFlag=notAllocate)
Definition: soa_numeric_table.h:80
daal::services::daal_free
DAAL_EXPORT void daal_free(void *ptr)
daal::services::ErrorMemoryAllocationFailed
Definition: error_indexes.h:150
daal::services::ErrorIncorrectNumberOfFeatures
Definition: error_indexes.h:72
daal::data_management::interface1::SOANumericTable::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: soa_numeric_table.h:228
daal::data_management::interface1::SOANumericTable::setArray
services::Status setArray(const services::SharedPtr< T > &ptr, size_t idx)
Definition: soa_numeric_table.h:137
daal::data_management::interface1::SOANumericTable::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: soa_numeric_table.h:236
daal::data_management::interface1::SOANumericTable::getBlockOfRows
services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: soa_numeric_table.h:219
daal::data_management::interface1::SOANumericTable::getBlockOfRows
services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: soa_numeric_table.h:223
daal::data_management::interface1::SOANumericTable::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: soa_numeric_table.h:257

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