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

soa_numeric_table.h
1 /* file: soa_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 __SOA_NUMERIC_TABLE_H__
49 #define __SOA_NUMERIC_TABLE_H__
50 
51 #include "data_management/data/numeric_table.h"
52 
53 namespace daal
54 {
55 namespace data_management
56 {
57 
58 namespace interface1
59 {
69 class DAAL_EXPORT SOANumericTable : public NumericTable
70 {
71 public:
72  DECLARE_SERIALIZABLE_TAG();
73  DECLARE_SERIALIZABLE_IMPL();
74 
82  SOANumericTable(size_t nColumns = 0, size_t nRows = 0, DictionaryIface::FeaturesEqual featuresEqual = DictionaryIface::notEqual);
83 
92  static services::SharedPtr<SOANumericTable> create(size_t nColumns = 0, size_t nRows = 0,
93  DictionaryIface::FeaturesEqual featuresEqual = DictionaryIface::notEqual,
94  services::Status *stat = NULL);
95 
103  DAAL_DEPRECATED SOANumericTable( NumericTableDictionary *ddict, size_t nRows, AllocationFlag memoryAllocationFlag = notAllocate ):
104  NumericTable(NumericTableDictionaryPtr(ddict, services::EmptyDeleter())),
105  _arraysInitialized(0), _partialMemStatus(notAllocated)
106  {
107  _layout = soa;
108  this->_status |= setNumberOfRowsImpl( nRows );
109  if( !resizePointersArray( getNumberOfColumns() ) )
110  {
111  this->_status.add(services::ErrorMemoryAllocationFailed);
112  return;
113  }
114  if( memoryAllocationFlag == doAllocate )
115  {
116  this->_status |= allocateDataMemoryImpl();
117  }
118  }
119 
127  SOANumericTable( NumericTableDictionaryPtr ddict, size_t nRows, AllocationFlag memoryAllocationFlag = notAllocate );
128 
137  static services::SharedPtr<SOANumericTable> create(NumericTableDictionaryPtr ddict, size_t nRows,
138  AllocationFlag memoryAllocationFlag = notAllocate,
139  services::Status *stat = NULL);
140 
141  virtual ~SOANumericTable()
142  {
143  freeDataMemoryImpl();
144  }
145 
152  template<typename T>
153  services::Status setArray(const services::SharedPtr<T> &ptr, size_t idx)
154  {
155  if( _partialMemStatus != notAllocated && _partialMemStatus != userAllocated )
156  {
157  return services::Status(services::ErrorIncorrectNumberOfFeatures);
158  }
159 
160  if( idx < getNumberOfColumns() && idx < _arrays.size() )
161  {
162  _ddict->setFeature<T>(idx);
163 
164  if( !_arrays[idx] && ptr )
165  {
166  _arraysInitialized++;
167  }
168 
169  if( _arrays[idx] && !ptr )
170  {
171  _arraysInitialized--;
172  }
173 
174  _arrays[idx] = services::reinterpretPointerCast<byte, T>(ptr);
175  }
176  else
177  {
178  return services::Status(services::ErrorIncorrectNumberOfFeatures);
179  }
180 
181  _partialMemStatus = userAllocated;
182 
183  if(_arraysInitialized == getNumberOfColumns())
184  {
185  _memStatus = userAllocated;
186  }
187  return services::Status();
188  }
189 
196  template<typename T>
197  services::Status setArray(T *ptr, size_t idx)
198  {
199  return setArray(services::SharedPtr<T>(ptr, services::EmptyDeleter()), idx);
200  }
201 
207  services::SharedPtr<byte> getArraySharedPtr(size_t idx)
208  {
209  if( idx < _ddict->getNumberOfFeatures() )
210  {
211  return _arrays[idx];
212  }
213  else
214  {
215  this->_status.add(services::ErrorIncorrectNumberOfFeatures);
216  return services::SharedPtr<byte>();
217  }
218  }
219 
225  void *getArray(size_t idx)
226  {
227  return getArraySharedPtr(idx).get();
228  }
229 
230  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<double>& block) DAAL_C11_OVERRIDE
231  {
232  return getTBlock<double>(vector_idx, vector_num, rwflag, block);
233  }
234  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<float>& block) DAAL_C11_OVERRIDE
235  {
236  return getTBlock<float>(vector_idx, vector_num, rwflag, block);
237  }
238  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<int>& block) DAAL_C11_OVERRIDE
239  {
240  return getTBlock<int>(vector_idx, vector_num, rwflag, block);
241  }
242 
243  services::Status releaseBlockOfRows(BlockDescriptor<double>& block) DAAL_C11_OVERRIDE
244  {
245  return releaseTBlock<double>(block);
246  }
247  services::Status releaseBlockOfRows(BlockDescriptor<float>& block) DAAL_C11_OVERRIDE
248  {
249  return releaseTBlock<float>(block);
250  }
251  services::Status releaseBlockOfRows(BlockDescriptor<int>& block) DAAL_C11_OVERRIDE
252  {
253  return releaseTBlock<int>(block);
254  }
255 
256  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
257  ReadWriteMode rwflag, BlockDescriptor<double>& block) DAAL_C11_OVERRIDE
258  {
259  return getTFeature<double>(feature_idx, vector_idx, value_num, rwflag, block);
260  }
261  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
262  ReadWriteMode rwflag, BlockDescriptor<float>& block) DAAL_C11_OVERRIDE
263  {
264  return getTFeature<float>(feature_idx, vector_idx, value_num, rwflag, block);
265  }
266  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
267  ReadWriteMode rwflag, BlockDescriptor<int>& block) DAAL_C11_OVERRIDE
268  {
269  return getTFeature<int>(feature_idx, vector_idx, value_num, rwflag, block);
270  }
271 
272  services::Status releaseBlockOfColumnValues(BlockDescriptor<double>& block) DAAL_C11_OVERRIDE
273  {
274  return releaseTFeature<double>(block);
275  }
276  services::Status releaseBlockOfColumnValues(BlockDescriptor<float>& block) DAAL_C11_OVERRIDE
277  {
278  return releaseTFeature<float>(block);
279  }
280  services::Status releaseBlockOfColumnValues(BlockDescriptor<int>& block) DAAL_C11_OVERRIDE
281  {
282  return releaseTFeature<int>(block);
283  }
284 
285  DAAL_DEPRECATED_VIRTUAL services::Status setDictionary( NumericTableDictionary *ddict ) DAAL_C11_OVERRIDE
286  {
287  services::Status s;
288  DAAL_CHECK_STATUS(s, NumericTable::setDictionary( ddict ));
289 
290  size_t ncol = ddict->getNumberOfFeatures();
291 
292  if( !resizePointersArray( ncol ) )
293  {
294  return services::Status(services::ErrorMemoryAllocationFailed);
295  }
296  return s;
297  }
298 
299 protected:
300 
301  SOANumericTable( size_t nColumns, size_t nRows, DictionaryIface::FeaturesEqual featuresEqual, services::Status &st );
302 
303  SOANumericTable( NumericTableDictionaryPtr ddict, size_t nRows, AllocationFlag memoryAllocationFlag, services::Status &st );
304 
305  services::Collection<services::SharedPtr<byte> > _arrays;
306  size_t _arraysInitialized;
307  MemoryStatus _partialMemStatus;
308 
309  bool resizePointersArray(size_t nColumns)
310  {
311  if( _arrays.size() >= nColumns )
312  {
313  size_t counter = 0;
314  for(size_t i = 0; i < nColumns; i++)
315  {
316  counter += (_arrays[i] != 0);
317  }
318  _arraysInitialized = counter;
319 
320  if( _arraysInitialized == nColumns )
321  {
322  _memStatus = _partialMemStatus;
323  }
324  else
325  {
326  _memStatus = notAllocated;
327  }
328 
329  return true;
330  }
331  _arrays.resize(nColumns);
332  _memStatus = notAllocated;
333 
334  return true;
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  return services::Status();
393  }
394 
395  void freeDataMemoryImpl() DAAL_C11_OVERRIDE
396  {
397  _arrays.clear();
398  _arrays.resize(_ddict->getNumberOfFeatures());
399  _arraysInitialized = 0;
400 
401  _partialMemStatus = notAllocated;
402  _memStatus = notAllocated;
403  }
404 
405  template<typename Archive, bool onDeserialize>
406  services::Status serialImpl( Archive *arch )
407  {
408  NumericTable::serialImpl<Archive, onDeserialize>( arch );
409 
410  if( onDeserialize )
411  {
412  allocateDataMemoryImpl();
413  }
414 
415  size_t ncol = _ddict->getNumberOfFeatures();
416  size_t nrows = getNumberOfRows();
417 
418  for(size_t i = 0; i < ncol; i++)
419  {
420  NumericTableFeature f = (*_ddict)[i];
421  void *ptr = getArraySharedPtr(i).get();
422 
423  arch->set( (char *)ptr, nrows * f.typeSize );
424  }
425 
426  return services::Status();
427  }
428 
429 private:
430 
431  template <typename T>
432  services::Status getTBlock( size_t idx, size_t nrows, ReadWriteMode rwFlag, BlockDescriptor<T>& block )
433  {
434  size_t ncols = getNumberOfColumns();
435  size_t nobs = getNumberOfRows();
436  block.setDetails( 0, idx, rwFlag );
437 
438  if (idx >= nobs)
439  {
440  block.resizeBuffer( ncols, 0 );
441  return services::Status();
442  }
443 
444  nrows = ( idx + nrows < nobs ) ? nrows : nobs - idx;
445 
446  if( !block.resizeBuffer( ncols, nrows ) )
447  {
448  return services::Status(services::ErrorMemoryAllocationFailed);
449  }
450 
451  if( !(block.getRWFlag() & (int)readOnly) ) return services::Status();
452 
453  T lbuf[32];
454 
455  size_t di = 32;
456 
457  T *buffer = block.getBlockPtr();
458 
459  for( size_t i = 0 ; i < nrows ; i += di )
460  {
461  if( i + di > nrows ) { di = nrows - i; }
462 
463  for( size_t j = 0 ; j < ncols ; j++ )
464  {
465  NumericTableFeature &f = (*_ddict)[j];
466 
467  char *ptr = (char *)_arrays[j].get() + (idx + i) * f.typeSize;
468 
469  data_feature_utils::getVectorUpCast(f.indexType, data_feature_utils::getInternalNumType<T>())
470  ( di, ptr, lbuf );
471 
472  for( size_t ii = 0 ; ii < di; ii++ )
473  {
474  buffer[ (i + ii)*ncols + j ] = lbuf[ii];
475  }
476  }
477  }
478  return services::Status();
479  }
480 
481  template <typename T>
482  services::Status releaseTBlock( BlockDescriptor<T>& block )
483  {
484  if(block.getRWFlag() & (int)writeOnly)
485  {
486  size_t ncols = getNumberOfColumns();
487  size_t nrows = block.getNumberOfRows();
488  size_t idx = block.getRowsOffset();
489  T lbuf[32];
490 
491  size_t di = 32;
492 
493  T *blockPtr = block.getBlockPtr();
494 
495  for( size_t i = 0 ; i < nrows ; i += di )
496  {
497  if( i + di > nrows ) { di = nrows - i; }
498 
499  for( size_t j = 0 ; j < ncols ; j++ )
500  {
501  NumericTableFeature &f = (*_ddict)[j];
502 
503  char *ptr = (char *)_arrays[j].get() + (idx + i) * f.typeSize;
504 
505  for( size_t ii = 0 ; ii < di; ii++ )
506  {
507  lbuf[ii] = blockPtr[ (i + ii) * ncols + j ];
508  }
509 
510  data_feature_utils::getVectorDownCast(f.indexType, data_feature_utils::getInternalNumType<T>())
511  ( di, lbuf, ptr );
512  }
513  }
514  }
515  block.reset();
516  return services::Status();
517  }
518 
519  template <typename T>
520  services::Status getTFeature( size_t feat_idx, size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T>& block )
521  {
522  size_t ncols = getNumberOfColumns();
523  size_t nobs = getNumberOfRows();
524  block.setDetails( feat_idx, idx, rwFlag );
525 
526  if (idx >= nobs)
527  {
528  block.resizeBuffer( 1, 0 );
529  return services::Status();
530  }
531 
532  nrows = ( idx + nrows < nobs ) ? nrows : nobs - idx;
533 
534  NumericTableFeature &f = (*_ddict)[feat_idx];
535 
536  if( data_feature_utils::getIndexNumType<T>() == f.indexType )
537  {
538  block.setPtr(&(_arrays[feat_idx]), _arrays[feat_idx].get() + idx * f.typeSize , 1, nrows );
539  }
540  else
541  {
542  byte *location = _arrays[feat_idx].get() + idx * f.typeSize;
543 
544  if( !block.resizeBuffer( 1, nrows ) )
545  {
546  return services::Status(services::ErrorMemoryAllocationFailed);
547  }
548 
549  if( !(block.getRWFlag() & (int)readOnly) ) return services::Status();
550 
551  data_feature_utils::getVectorUpCast(f.indexType, data_feature_utils::getInternalNumType<T>())
552  ( nrows, location, block.getBlockPtr() );
553  }
554  return services::Status();
555  }
556 
557  template <typename T>
558  services::Status releaseTFeature( BlockDescriptor<T>& block )
559  {
560  if (block.getRWFlag() & (int)writeOnly)
561  {
562  size_t feat_idx = block.getColumnsOffset();
563 
564  NumericTableFeature &f = (*_ddict)[feat_idx];
565 
566  if( data_feature_utils::getIndexNumType<T>() != f.indexType )
567  {
568  char *ptr = (char *)_arrays[feat_idx].get() + block.getRowsOffset() * f.typeSize;
569 
570  data_feature_utils::getVectorDownCast(f.indexType, data_feature_utils::getInternalNumType<T>())
571  ( block.getNumberOfRows(), block.getBlockPtr(), ptr );
572  }
573  }
574  block.reset();
575  return services::Status();
576  }
577 };
578 typedef services::SharedPtr<SOANumericTable> SOANumericTablePtr;
580 } // namespace interface1
581 using interface1::SOANumericTable;
582 using interface1::SOANumericTablePtr;
583 
584 }
585 } // namespace daal
586 #endif
daal::services::interface1::Collection::get
T & get(size_t index)
Definition: collection.h:177
daal::data_management::interface1::NumericTableIface::AllocationFlag
AllocationFlag
Enumeration to specify whether the Numeric Table must allocate memory.
Definition: numeric_table.h:309
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::data_management::interface1::SOANumericTable::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: soa_numeric_table.h:272
daal
Definition: algorithm_base_common.h:57
daal::data_management::interface1::SOANumericTable::setArray
services::Status setArray(T *ptr, size_t idx)
Definition: soa_numeric_table.h:197
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:69
daal::data_management::interface1::SOANumericTable::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: soa_numeric_table.h:276
daal::services::ErrorMemoryAllocationFailed
Definition: error_indexes.h:172
daal::data_management::interface1::SOANumericTable::getArray
void * getArray(size_t idx)
Definition: soa_numeric_table.h:225
daal::dram
Definition: daal_defines.h:159
daal::data_management::interface1::BlockDescriptor::getBlockPtr
DataType * getBlockPtr() const
Definition: numeric_table.h:95
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:230
daal::data_management::interface1::SOANumericTable::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: soa_numeric_table.h:251
daal::services::ErrorIncorrectNumberOfFeatures
Definition: error_indexes.h:96
daal::algorithms::multivariate_outlier_detection::location
Definition: outlier_detection_multivariate_types.h:98
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:261
daal::data_management::interface1::BlockDescriptor::resizeBuffer
bool resizeBuffer(size_t nColumns, size_t nRows, size_t auxMemorySize=0)
Definition: numeric_table.h:177
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:238
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::services::daal_malloc
DAAL_EXPORT void * daal_malloc(size_t size, size_t alignment=DAAL_MALLOC_DEFAULT_ALIGNMENT)
daal::data_management::interface1::NumericTableIface::MemoryStatus
MemoryStatus
Enumeration to specify the status of memory related to the Numeric Table.
Definition: numeric_table.h:298
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::SOANumericTable::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: soa_numeric_table.h:243
daal::data_management::interface1::SOANumericTable::setArray
services::Status setArray(const services::SharedPtr< T > &ptr, size_t idx)
Definition: soa_numeric_table.h:153
daal::services::interface1::Collection::clear
void clear()
Definition: collection.h:253
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:256
daal::data_management::interface1::BlockDescriptor::getRWFlag
size_t getRWFlag() const
Definition: numeric_table.h:244
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:234
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::SOANumericTable::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: soa_numeric_table.h:280
daal::services::interface1::Collection::size
size_t size() const
Definition: collection.h:144
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::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:266
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::BlockDescriptor::getNumberOfRows
size_t getNumberOfRows() const
Definition: numeric_table.h:127
daal::data_management::interface1::SOANumericTable::getArraySharedPtr
services::SharedPtr< byte > getArraySharedPtr(size_t idx)
Definition: soa_numeric_table.h:207
daal::data_management::interface1::SOANumericTable::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: soa_numeric_table.h:247
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::NumericTable::setDictionary
virtual DAAL_DEPRECATED_VIRTUAL services::Status setDictionary(NumericTableDictionary *ddict) DAAL_C11_OVERRIDE
Definition: numeric_table.h:650
daal::data_management::interface1::BlockDescriptor::setPtr
void setPtr(DataType *ptr, size_t nColumns, size_t nRows)
Definition: numeric_table.h:148
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::services::interface1::Collection::resize
bool resize(size_t newCapacity)
Definition: collection.h:222
daal::services::interface1::Collection
Class that implements functionality of the Collection container.
Definition: collection.h:69
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:184

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