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

row_merged_numeric_table.h
1 /* file: row_merged_numeric_table.h */
2 /*******************************************************************************
3 * Copyright 2014-2018 Intel Corporation.
4 *
5 * This software and the related documents are Intel copyrighted materials, and
6 * your use of them is governed by the express license under which they were
7 * provided to you (License). Unless the License provides otherwise, you may not
8 * use, modify, copy, publish, distribute, disclose or transmit this software or
9 * the related documents without Intel's prior written permission.
10 *
11 * This software and the related documents are provided as is, with no express
12 * or implied warranties, other than those that are expressly stated in the
13 * License.
14 *******************************************************************************/
15 
16 /*
17 //++
18 // Implementation of row merged numeric table.
19 //--
20 */
21 
22 
23 #ifndef __ROW_MERGED_NUMERIC_TABLE_H__
24 #define __ROW_MERGED_NUMERIC_TABLE_H__
25 
26 #include "data_management/data/numeric_table.h"
27 #include "services/daal_memory.h"
28 #include "services/daal_defines.h"
29 #include "data_management/data/data_serialize.h"
30 
31 namespace daal
32 {
33 namespace data_management
34 {
35 
36 namespace interface1
37 {
46 class DAAL_EXPORT RowMergedNumericTable : public NumericTable
47 {
48 public:
49  DECLARE_SERIALIZABLE_TAG();
50  DECLARE_SERIALIZABLE_IMPL();
51 
56  RowMergedNumericTable();
57 
63  RowMergedNumericTable(NumericTablePtr table);
64 
69  static services::SharedPtr<RowMergedNumericTable> create(services::Status *stat = NULL);
70 
76  static services::SharedPtr<RowMergedNumericTable> create(const NumericTablePtr &nestedTable,
77  services::Status *stat = NULL);
78 
83  services::Status addNumericTable(NumericTablePtr table)
84  {
85  if (table->getDataLayout() & csrArray)
86  return services::Status(services::ErrorIncorrectTypeOfInputNumericTable);
87 
88  size_t ncols = getNumberOfColumns();
89  size_t cols = table->getNumberOfColumns();
90 
91  if (ncols != 0 && ncols != cols)
92  return services::Status(services::ErrorIncorrectNumberOfFeatures);
93 
94  _tables->push_back(table);
95 
96  if (ncols == 0)
97  {
98  DictionaryIface::FeaturesEqual featuresEqual = table->getDictionarySharedPtr()->getFeaturesEqual();
99  services::Status s;
100  _ddict = NumericTableDictionary::create(ncols, featuresEqual, &s);
101  if(!s)
102  return s;
103  s = setNumberOfColumnsImpl(cols);
104  if(!s)
105  return s;
106  if (featuresEqual == DictionaryIface::equal)
107  {
108  NumericTableFeature &f = table->getDictionarySharedPtr()->operator[](0);
109  _ddict->setFeature(f, 0);
110  }
111  else
112  {
113  for (size_t i = 0; i < cols; i++)
114  {
115  NumericTableFeature &f = table->getDictionarySharedPtr()->operator[](i);
116  _ddict->setFeature(f, i);
117  }
118  }
119  }
120 
121  size_t obs = table->getNumberOfRows();
122  return setNumberOfRowsImpl(_obsnum + obs);
123  }
124 
125  services::Status resize(size_t nrows) DAAL_C11_OVERRIDE
126  {
127  return services::Status(services::throwIfPossible(services::ErrorMethodNotSupported));
128  }
129 
130  MemoryStatus getDataMemoryStatus() const DAAL_C11_OVERRIDE
131  {
132  if (_tables->size() == 0)
133  {
134  return notAllocated;
135  }
136 
137  for (size_t i = 0;i < _tables->size(); i++)
138  {
139  NumericTable* nt = (NumericTable*)(_tables->operator[](i).get());
140  if (nt->getDataMemoryStatus() == notAllocated)
141  {
142  return notAllocated;
143  }
144  }
145 
146  return internallyAllocated;
147  }
148 
149  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num,
150  ReadWriteMode rwflag, BlockDescriptor<double>& block) DAAL_C11_OVERRIDE
151  {
152  return getTBlock<double>(vector_idx, vector_num, rwflag, block);
153  }
154  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num,
155  ReadWriteMode rwflag, BlockDescriptor<float>& block) DAAL_C11_OVERRIDE
156  {
157  return getTBlock<float>(vector_idx, vector_num, rwflag, block);
158  }
159  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num,
160  ReadWriteMode rwflag, BlockDescriptor<int>& block) DAAL_C11_OVERRIDE
161  {
162  return getTBlock<int>(vector_idx, vector_num, rwflag, block);
163  }
164 
165  services::Status releaseBlockOfRows(BlockDescriptor<double>& block) DAAL_C11_OVERRIDE
166  {
167  return releaseTBlock<double>(block);
168  }
169  services::Status releaseBlockOfRows(BlockDescriptor<float>& block) DAAL_C11_OVERRIDE
170  {
171  return releaseTBlock<float>(block);
172  }
173  services::Status releaseBlockOfRows(BlockDescriptor<int>& block) DAAL_C11_OVERRIDE
174  {
175  return releaseTBlock<int>(block);
176  }
177 
178  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
179  ReadWriteMode rwflag, BlockDescriptor<double>& block) DAAL_C11_OVERRIDE
180  {
181  return getTFeature<double>(feature_idx, vector_idx, value_num, rwflag, block);
182  }
183  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
184  ReadWriteMode rwflag, BlockDescriptor<float>& block) DAAL_C11_OVERRIDE
185  {
186  return getTFeature<float>(feature_idx, vector_idx, value_num, rwflag, block);
187  }
188  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
189  ReadWriteMode rwflag, BlockDescriptor<int>& block) DAAL_C11_OVERRIDE
190  {
191  return getTFeature<int>(feature_idx, vector_idx, value_num, rwflag, block);
192  }
193 
194  services::Status releaseBlockOfColumnValues(BlockDescriptor<double>& block) DAAL_C11_OVERRIDE
195  {
196  return releaseTFeature<double>(block);
197  }
198  services::Status releaseBlockOfColumnValues(BlockDescriptor<float>& block) DAAL_C11_OVERRIDE
199  {
200  return releaseTFeature<float>(block);
201  }
202  services::Status releaseBlockOfColumnValues(BlockDescriptor<int>& block) DAAL_C11_OVERRIDE
203  {
204  return releaseTFeature<int>(block);
205  }
206 
207 protected:
208 
209  template<typename Archive, bool onDeserialize>
210  services::Status serialImpl( Archive *arch )
211  {
212  NumericTable::serialImpl<Archive, onDeserialize>( arch );
213 
214  arch->setSharedPtrObj(_tables);
215 
216  return services::Status();
217  }
218 
219 private:
220  template<typename T>
221  void internal_inner_repack( size_t idx, size_t rows, size_t ncols, T *src, T *dst )
222  {
223  size_t i, j;
224 
225  for(i = 0; i < rows; i++)
226  {
227  for(j = 0; j < ncols; j++)
228  {
229  dst[(idx + i) * ncols + j] = src[i * ncols + j];
230  }
231  }
232  }
233 
234  template<typename T>
235  void internal_outer_repack( size_t idx, size_t rows, size_t ncols, T *src, T *dst )
236  {
237  size_t i, j;
238 
239  for(i = 0; i < rows; i++)
240  {
241  for(j = 0; j < ncols; j++)
242  {
243  dst[i * ncols + j] = src[(i + idx) * ncols + j];
244  }
245  }
246  }
247 
248 protected:
249  template <typename T>
250  services::Status getTBlock(size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T>& block)
251  {
252  services::Status s;
253  size_t ncols = getNumberOfColumns();
254  size_t nobs = getNumberOfRows();
255  block.setDetails( 0, idx, rwFlag );
256 
257  if (idx >= nobs)
258  {
259  block.resizeBuffer( ncols, 0 );
260  return services::Status();
261  }
262 
263  nrows = ( idx + nrows < nobs ) ? nrows : nobs - idx;
264 
265  if( !block.resizeBuffer( ncols, nrows ) )
266  return services::Status(services::ErrorMemoryAllocationFailed);
267 
268  if( rwFlag & (int)readOnly )
269  {
270  size_t rows = 0;
271  BlockDescriptor<T> innerBlock;
272  for (size_t k = 0; k < _tables->size() && rows < idx + nrows; k++)
273  {
274  NumericTable* nt = (NumericTable*)(_tables->operator[](k).get());
275  size_t lrows = nt->getNumberOfRows();
276 
277  if (rows + lrows > idx)
278  {
279  size_t idxBegin = (rows < idx) ? idx : rows;
280  size_t idxEnd = (rows + lrows < idx + nrows) ? rows + lrows : idx + nrows;
281  s |= nt->getBlockOfRows(idxBegin - rows, idxEnd - idxBegin, readOnly, innerBlock);
282 
283  internal_inner_repack<T>( idxBegin - idx, idxEnd - idxBegin, ncols, innerBlock.getBlockPtr(), block.getBlockPtr());
284 
285  s |= nt->releaseBlockOfRows(innerBlock);
286  }
287 
288  rows += lrows;
289  }
290  }
291  return s;
292  }
293 
294  template <typename T>
295  services::Status releaseTBlock(BlockDescriptor<T>& block)
296  {
297  services::Status s;
298  if(block.getRWFlag() & (int)writeOnly)
299  {
300  size_t ncols = getNumberOfColumns();
301  size_t nrows = block.getNumberOfRows();
302  size_t idx = block.getRowsOffset();
303  size_t rows = 0;
304  BlockDescriptor<T> innerBlock;
305  for (size_t k = 0; k < _tables->size() && rows < idx + nrows; k++)
306  {
307  NumericTable* nt = (NumericTable*)(_tables->operator[](k).get());
308  size_t lrows = nt->getNumberOfRows();
309 
310  if (rows + lrows > idx)
311  {
312  size_t idxBegin = (rows < idx) ? idx : rows;
313  size_t idxEnd = (rows + lrows < idx + nrows) ? rows + lrows : idx + nrows;
314  s |= nt->getBlockOfRows(idxBegin - rows, idxEnd - idxBegin, writeOnly, innerBlock);
315 
316  internal_outer_repack<T>( idxBegin - idx, idxEnd - idxBegin, ncols, block.getBlockPtr(), innerBlock.getBlockPtr());
317 
318  s |= nt->releaseBlockOfRows(innerBlock);
319  }
320 
321  rows += lrows;
322  }
323  }
324  block.reset();
325  return s;
326  }
327 
328  template <typename T>
329  services::Status getTFeature(size_t feat_idx, size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T>& block)
330  {
331  services::Status s;
332  size_t ncols = getNumberOfColumns();
333  size_t nobs = getNumberOfRows();
334  block.setDetails( feat_idx, idx, rwFlag );
335 
336  if (idx >= nobs)
337  {
338  block.resizeBuffer( 1, 0 );
339  return services::Status();
340  }
341 
342  nrows = ( idx + nrows < nobs ) ? nrows : nobs - idx;
343  if( !block.resizeBuffer( 1, nrows ) )
344  return services::Status(services::ErrorMemoryAllocationFailed);
345 
346  if( rwFlag & (int)readOnly )
347  {
348  T* buffer = block.getBlockPtr();
349  size_t rows = 0;
350  for (size_t k = 0; k < _tables->size() && rows < idx + nrows; k++)
351  {
352  NumericTable* nt = (NumericTable*)(_tables->operator[](k).get());
353  size_t lrows = nt->getNumberOfRows();
354 
355  if (rows + lrows > idx)
356  {
357  size_t idxBegin = (rows < idx) ? idx : rows;
358  size_t idxEnd = (rows + lrows < idx + nrows) ? rows + lrows : idx + nrows;
359 
360  BlockDescriptor<T> innerBlock;
361  s |= nt->getBlockOfColumnValues(feat_idx, idxBegin - rows, idxEnd - idxBegin, readOnly, innerBlock);
362  T* location = innerBlock.getBlockPtr();
363  for (size_t i = idxBegin; i < idxEnd; i++)
364  {
365  buffer[i] = location[i - idxBegin];
366  }
367  s |= nt->releaseBlockOfColumnValues(innerBlock);
368  }
369 
370  rows += lrows;
371  }
372  }
373  return s;
374  }
375 
376  template <typename T>
377  services::Status releaseTFeature( BlockDescriptor<T>& block )
378  {
379  services::Status s;
380  if (block.getRWFlag() & (int)writeOnly)
381  {
382  size_t feat_idx = block.getColumnsOffset();
383  size_t idx = block.getRowsOffset();
384  size_t nrows = block.getNumberOfRows();
385  size_t rows = 0;
386  T* buffer = block.getBlockPtr();
387  for (size_t k = 0; k < _tables->size() && rows < idx + nrows; k++)
388  {
389  NumericTable* nt = (NumericTable*)(_tables->operator[](k).get());
390  size_t lrows = nt->getNumberOfRows();
391 
392  if (rows + lrows > idx)
393  {
394  size_t idxBegin = (rows < idx) ? idx : rows;
395  size_t idxEnd = (rows + lrows < idx + nrows) ? rows + lrows : idx + nrows;
396 
397  BlockDescriptor<T> innerBlock;
398  s |= nt->getBlockOfColumnValues(feat_idx, idxBegin - rows, idxEnd - idxBegin, writeOnly, innerBlock);
399  T* location = innerBlock.getBlockPtr();
400  for (size_t i = idxBegin; i < idxEnd; i++)
401  {
402  location[i - idxBegin] = buffer[i];
403  }
404  s |= nt->releaseBlockOfColumnValues(innerBlock);
405  }
406 
407  rows += lrows;
408  }
409  }
410  block.reset();
411  return s;
412  }
413 
414  services::Status setNumberOfColumnsImpl(size_t ncols) DAAL_C11_OVERRIDE;
415  services::Status allocateDataMemoryImpl(daal::MemType type = daal::dram) DAAL_C11_OVERRIDE;
416  void freeDataMemoryImpl() DAAL_C11_OVERRIDE;
417 
418 protected:
419  DataCollectionPtr _tables;
420 
421  RowMergedNumericTable(services::Status &st);
422 
423  RowMergedNumericTable(const NumericTablePtr &table, services::Status &st);
424 };
425 typedef services::SharedPtr<RowMergedNumericTable> RowMergedNumericTablePtr;
427 } // namespace interface1
428 using interface1::RowMergedNumericTable;
429 using interface1::RowMergedNumericTablePtr;
430 
431 } // namespace data_management
432 } // namespace daal
433 
434 #endif
daal
Definition: algorithm_base_common.h:31
daal::data_management::interface1::RowMergedNumericTable::getBlockOfRows
services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: row_merged_numeric_table.h:159
daal::data_management::interface1::RowMergedNumericTable::addNumericTable
services::Status addNumericTable(NumericTablePtr table)
Definition: row_merged_numeric_table.h:83
daal::data_management::interface1::RowMergedNumericTable::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: row_merged_numeric_table.h:194
daal::services::ErrorMemoryAllocationFailed
Definition: error_indexes.h:146
daal::data_management::interface1::RowMergedNumericTable::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: row_merged_numeric_table.h:178
daal::dram
Definition: daal_defines.h:133
daal::services::ErrorIncorrectNumberOfFeatures
Definition: error_indexes.h:70
daal_defines.h
daal::algorithms::multivariate_outlier_detection::location
Definition: outlier_detection_multivariate_types.h:72
daal::data_management::interface1::RowMergedNumericTable::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: row_merged_numeric_table.h:188
daal::data_management::interface1::RowMergedNumericTable::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: row_merged_numeric_table.h:202
daal::data_management::interface1::NumericTableIface::MemoryStatus
MemoryStatus
Enumeration to specify the status of memory related to the Numeric Table.
Definition: numeric_table.h:272
daal::data_management::interface1::NumericTable
Class for a data management component responsible for representation of data in the numeric format...
Definition: numeric_table.h:574
daal::data_management::interface1::RowMergedNumericTable::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: row_merged_numeric_table.h:173
daal::data_management::interface1::RowMergedNumericTable::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: row_merged_numeric_table.h:183
daal::data_management::interface1::RowMergedNumericTable::getDataMemoryStatus
MemoryStatus getDataMemoryStatus() const DAAL_C11_OVERRIDE
Definition: row_merged_numeric_table.h:130
daal::services::ErrorIncorrectTypeOfInputNumericTable
Definition: error_indexes.h:91
daal::data_management::interface1::RowMergedNumericTable::getBlockOfRows
services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: row_merged_numeric_table.h:154
daal::data_management::interface1::BlockDescriptor
Base class that manages buffer memory for read/write operations required by numeric tables...
Definition: numeric_table.h:55
daal::data_management::interface1::DictionaryIface::FeaturesEqual
FeaturesEqual
Enumeration to specify whether the Data Dictionary contains equal features.
Definition: data_dictionary.h:145
daal::data_management::interface1::RowMergedNumericTable::getBlockOfRows
services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: row_merged_numeric_table.h:149
daal::data_management::interface1::RowMergedNumericTable
Class that provides methods to access a collection of numeric tables as if they are joined by rows...
Definition: row_merged_numeric_table.h:46
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:183
daal::data_management::interface1::RowMergedNumericTable::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: row_merged_numeric_table.h:169
daal::data_management::interface1::NumericTableFeature
Data structure describes the Numeric Table feature.
Definition: data_dictionary.h:48
daal::data_management::interface1::NumericTable::getDataMemoryStatus
virtual MemoryStatus getDataMemoryStatus() const
Definition: numeric_table.h:719
daal::MemType
MemType
Definition: daal_defines.h:131
daal::data_management::interface1::RowMergedNumericTable::resize
services::Status resize(size_t nrows) DAAL_C11_OVERRIDE
Definition: row_merged_numeric_table.h:125
daal::data_management::interface1::RowMergedNumericTable::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: row_merged_numeric_table.h:198
daal::services::ErrorMethodNotSupported
Definition: error_indexes.h:69
daal::data_management::interface1::RowMergedNumericTable::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: row_merged_numeric_table.h:165

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