C++ API Reference for Intel® Data Analytics Acceleration Library 2019 Update 4

merged_numeric_table.h
1 /* file: merged_numeric_table.h */
2 /*******************************************************************************
3 * Copyright 2014-2019 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 merge numeric table.
19 //--
20 */
21 
22 
23 #ifndef __MERGED_NUMERIC_TABLE_H__
24 #define __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 MergedNumericTable : public NumericTable
47 {
48 public:
49  DECLARE_SERIALIZABLE_TAG();
50  DECLARE_SERIALIZABLE_IMPL();
51 
56  MergedNumericTable();
57 
63  MergedNumericTable(NumericTablePtr table);
64 
71  MergedNumericTable(NumericTablePtr first, NumericTablePtr second);
72 
77  static services::SharedPtr<MergedNumericTable> create(services::Status *stat = NULL);
78 
85  static services::SharedPtr<MergedNumericTable> create(const NumericTablePtr &nestedTable,
86  services::Status *stat = NULL);
87 
95  static services::SharedPtr<MergedNumericTable> create(const NumericTablePtr &first,
96  const NumericTablePtr &second,
97  services::Status *stat = NULL);
98 
103  services::Status addNumericTable(NumericTablePtr table)
104  {
105  if (table->getDataLayout() & csrArray)
106  return services::Status(services::ErrorIncorrectTypeOfInputNumericTable);
107 
108  _tables->push_back(table);
109 
110  size_t ncols = getNumberOfColumns();
111  size_t cols = table->getNumberOfColumns();
112 
113  services::Status s;
114  DAAL_CHECK_STATUS(s, setNumberOfColumnsImpl(ncols + cols));
115 
116  for (size_t i = 0; i < cols; i++)
117  {
118  NumericTableFeature &f = table->getDictionarySharedPtr()->operator[](i);
119  _ddict->setFeature(f, ncols + i);
120  }
121 
122  size_t obs = table->getNumberOfRows();
123  if (obs != _obsnum)
124  {
125  if (obs < _obsnum || _tables->size() == 1)
126  {
127  _obsnum = obs;
128  }
129  DAAL_CHECK_STATUS(s, setNumberOfRowsImpl(_obsnum));
130  }
131  return s;
132  }
133 
134  //the descriptions of the methods below are inherited from the base class
135  services::Status resize(size_t nrow) DAAL_C11_OVERRIDE
136  {
137  for (size_t i = 0;i < _tables->size(); i++)
138  {
139  NumericTable* nt = (NumericTable*)(_tables->operator[](i).get());
140  services::Status s = nt->resize(nrow);
141  if(!s)
142  return s;
143  }
144  _obsnum = nrow;
145  return services::Status();
146  }
147 
148  MemoryStatus getDataMemoryStatus() const DAAL_C11_OVERRIDE
149  {
150  if (_tables->size() == 0)
151  {
152  return notAllocated;
153  }
154 
155  for (size_t i = 0;i < _tables->size(); i++)
156  {
157  NumericTable* nt = (NumericTable*)(_tables->operator[](i).get());
158  if (nt->getDataMemoryStatus() == notAllocated)
159  {
160  return notAllocated;
161  }
162  }
163 
164  return internallyAllocated;
165  }
166 
167  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num,
168  ReadWriteMode rwflag, BlockDescriptor<double>& block) DAAL_C11_OVERRIDE
169  {
170  return getTBlock<double>(vector_idx, vector_num, rwflag, block);
171  }
172  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num,
173  ReadWriteMode rwflag, BlockDescriptor<float>& block) DAAL_C11_OVERRIDE
174  {
175  return getTBlock<float>(vector_idx, vector_num, rwflag, block);
176  }
177  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num,
178  ReadWriteMode rwflag, BlockDescriptor<int>& block) DAAL_C11_OVERRIDE
179  {
180  return getTBlock<int>(vector_idx, vector_num, rwflag, block);
181  }
182 
183  services::Status releaseBlockOfRows(BlockDescriptor<double>& block) DAAL_C11_OVERRIDE
184  {
185  return releaseTBlock<double>(block);
186  }
187  services::Status releaseBlockOfRows(BlockDescriptor<float>& block) DAAL_C11_OVERRIDE
188  {
189  return releaseTBlock<float>(block);
190  }
191  services::Status releaseBlockOfRows(BlockDescriptor<int>& block) DAAL_C11_OVERRIDE
192  {
193  return releaseTBlock<int>(block);
194  }
195 
196  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
197  ReadWriteMode rwflag, BlockDescriptor<double>& block) DAAL_C11_OVERRIDE
198  {
199  return getTFeature<double>(feature_idx, vector_idx, value_num, rwflag, block);
200  }
201  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
202  ReadWriteMode rwflag, BlockDescriptor<float>& block) DAAL_C11_OVERRIDE
203  {
204  return getTFeature<float>(feature_idx, vector_idx, value_num, rwflag, block);
205  }
206  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
207  ReadWriteMode rwflag, BlockDescriptor<int>& block) DAAL_C11_OVERRIDE
208  {
209  return getTFeature<int>(feature_idx, vector_idx, value_num, rwflag, block);
210  }
211 
212  services::Status releaseBlockOfColumnValues(BlockDescriptor<double>& block) DAAL_C11_OVERRIDE
213  {
214  return releaseTFeature<double>(block);
215  }
216  services::Status releaseBlockOfColumnValues(BlockDescriptor<float>& block) DAAL_C11_OVERRIDE
217  {
218  return releaseTFeature<float>(block);
219  }
220  services::Status releaseBlockOfColumnValues(BlockDescriptor<int>& block) DAAL_C11_OVERRIDE
221  {
222  return releaseTFeature<int>(block);
223  }
224 
225  services::Status allocateBasicStatistics() DAAL_C11_OVERRIDE
226  {
227  size_t ncols = getNumberOfColumns();
228  size_t ntables = _tables->size();
229  services::SharedPtr<MergedNumericTable> minMergeNT (new MergedNumericTable());
230  services::SharedPtr<MergedNumericTable> maxMergeNT (new MergedNumericTable());
231  services::SharedPtr<MergedNumericTable> sumMergeNT (new MergedNumericTable());
232  services::SharedPtr<MergedNumericTable> sumSqMergeNT (new MergedNumericTable());
233  for (size_t i = 0; i < ntables; i++) {
234  NumericTable* nt = (NumericTable*)(_tables->operator[](i).get());
235  nt->allocateBasicStatistics();
236  minMergeNT->addNumericTable(nt->basicStatistics.get(NumericTable::minimum));
237  maxMergeNT->addNumericTable(nt->basicStatistics.get(NumericTable::maximum));
238  sumMergeNT->addNumericTable(nt->basicStatistics.get(NumericTable::sum));
239  sumSqMergeNT->addNumericTable(nt->basicStatistics.get(NumericTable::sumSquares));
240  }
241  if (basicStatistics.get(NumericTable::minimum).get() == NULL ||
242  basicStatistics.get(NumericTable::minimum)->getNumberOfColumns() != ncols)
243  {
244  basicStatistics.set(NumericTable::minimum, minMergeNT);
245  }
246  if (basicStatistics.get(NumericTable::maximum).get() == NULL ||
247  basicStatistics.get(NumericTable::maximum)->getNumberOfColumns() != ncols)
248  {
249  basicStatistics.set(NumericTable::maximum, maxMergeNT);
250  }
251  if (basicStatistics.get(NumericTable::sum).get() == NULL ||
252  basicStatistics.get(NumericTable::sum)->getNumberOfColumns() != ncols)
253  {
254  basicStatistics.set(NumericTable::sum, sumMergeNT);
255  }
256  if (basicStatistics.get(NumericTable::sumSquares).get() == NULL ||
257  basicStatistics.get(NumericTable::sumSquares)->getNumberOfColumns() != ncols)
258  {
259  basicStatistics.set(NumericTable::sumSquares, sumSqMergeNT);
260  }
261  return services::Status();
262  }
263 
264 protected:
265  template<typename Archive, bool onDeserialize>
266  services::Status serialImpl( Archive *arch )
267  {
268  NumericTable::serialImpl<Archive, onDeserialize>( arch );
269 
270  arch->setSharedPtrObj(_tables);
271 
272  return services::Status();
273  }
274 
275 
276 private:
277  template<typename T>
278  void internal_inner_repack( size_t pos, size_t cols, size_t rows, size_t ncols, T *src, T *dst )
279  {
280  size_t i, j;
281 
282  for(i = 0; i < rows; i++)
283  {
284  for(j = 0; j < cols; j++)
285  {
286  dst[i * ncols + j + pos] = src[i * cols + j];
287  }
288  }
289  }
290 
291  template<typename T>
292  void internal_outer_repack( size_t pos, size_t cols, size_t rows, size_t ncols, T *src, T *dst )
293  {
294  size_t i, j;
295 
296  for(i = 0; i < rows; i++)
297  {
298  for(j = 0; j < cols; j++)
299  {
300  dst[i * cols + j] = src[i * ncols + j + pos];
301  }
302  }
303  }
304 
305 protected:
306 
307  template <typename T>
308  services::Status getTBlock( size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T>& block )
309  {
310  services::Status s;
311  size_t ncols = getNumberOfColumns();
312  size_t nobs = getNumberOfRows();
313  block.setDetails( 0, idx, rwFlag );
314 
315  if (idx >= nobs)
316  {
317  block.resizeBuffer( ncols, 0 );
318  return services::Status();
319  }
320 
321  nrows = ( idx + nrows < nobs ) ? nrows : nobs - idx;
322 
323  if( !block.resizeBuffer( ncols, nrows ) )
324  return services::Status(services::ErrorMemoryAllocationFailed);
325 
326  if( rwFlag & (int)readOnly )
327  {
328  size_t cols = 0;
329  BlockDescriptor<T> innerBlock;
330  for (size_t k = 0; k < _tables->size(); k++)
331  {
332  NumericTable* nt = (NumericTable*)(_tables->operator[](k).get());
333  size_t lcols = nt->getNumberOfColumns();
334 
335  s |= nt->getBlockOfRows(idx, nrows, readOnly, innerBlock);
336 
337  internal_inner_repack<T>( cols, lcols, nrows, ncols, innerBlock.getBlockPtr(), block.getBlockPtr());
338 
339  s |= nt->releaseBlockOfRows(innerBlock);
340 
341  cols += lcols;
342  }
343  }
344  return s;
345  }
346 
347  template <typename T>
348  services::Status releaseTBlock(BlockDescriptor<T>& block)
349  {
350  services::Status s;
351  if(block.getRWFlag() & (int)writeOnly)
352  {
353  size_t ncols = getNumberOfColumns();
354  size_t nrows = block.getNumberOfRows();
355  size_t offset = block.getRowsOffset();
356  size_t cols = 0;
357  BlockDescriptor<T> innerBlock;
358  for (size_t k = 0; k < _tables->size(); k++)
359  {
360  NumericTable* nt = (NumericTable*)(_tables->operator[](k).get());
361  size_t lcols = nt->getNumberOfColumns();
362 
363  s |= nt->getBlockOfRows(offset, nrows, writeOnly, innerBlock);
364 
365  internal_outer_repack<T>( cols, lcols, nrows, ncols, block.getBlockPtr(), innerBlock.getBlockPtr());
366 
367  s |= nt->releaseBlockOfRows(innerBlock);
368 
369  cols += lcols;
370  }
371  }
372  block.reset();
373  return s;
374  }
375 
376  template <typename T>
377  services::Status getTFeature(size_t feat_idx, size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T>& block)
378  {
379  services::Status s;
380  size_t ncols = getNumberOfColumns();
381  size_t nobs = getNumberOfRows();
382  block.setDetails( feat_idx, idx, rwFlag );
383 
384  if (idx >= nobs)
385  {
386  block.resizeBuffer( 1, 0 );
387  return services::Status();
388  }
389 
390  nrows = ( idx + nrows < nobs ) ? nrows : nobs - idx;
391  if( !block.resizeBuffer( 1, nrows ) )
392  return services::Status(services::ErrorMemoryAllocationFailed);
393 
394  if( rwFlag & (int)readOnly )
395  {
396  T* buffer = block.getBlockPtr();
397  for (size_t k = 0; k < _tables->size(); k++)
398  {
399  NumericTable* nt = (NumericTable*)(_tables->operator[](k).get());
400  size_t lcols = nt->getNumberOfColumns();
401 
402  if (lcols > feat_idx)
403  {
404  BlockDescriptor<T> innerBlock;
405  s |= nt->getBlockOfColumnValues(feat_idx, idx, nrows, readOnly, innerBlock);
406  T* location = innerBlock.getBlockPtr();
407  for (size_t i = 0; i < nrows; i++)
408  {
409  buffer[i] = location[i];
410  }
411  s |= nt->releaseBlockOfColumnValues(innerBlock);
412  break;
413  }
414 
415  feat_idx -= lcols;
416  }
417  }
418  return s;
419  }
420 
421  template <typename T>
422  services::Status releaseTFeature( BlockDescriptor<T>& block )
423  {
424  services::Status s;
425  if (block.getRWFlag() & (int)writeOnly)
426  {
427  size_t feat_idx = block.getColumnsOffset();
428  size_t idx = block.getRowsOffset();
429  size_t nrows = block.getNumberOfRows();
430  T* buffer = block.getBlockPtr();
431  for (size_t k = 0; k < _tables->size(); k++)
432  {
433  NumericTable* nt = (NumericTable*)(_tables->operator[](k).get());
434  size_t lcols = nt->getNumberOfColumns();
435 
436  if (lcols > feat_idx)
437  {
438  BlockDescriptor<T> innerBlock;
439  s |= nt->getBlockOfColumnValues(feat_idx, idx, nrows, writeOnly, innerBlock);
440  T* location = innerBlock.getBlockPtr();
441  for (size_t i = 0; i < nrows; i++)
442  {
443  location[i] = buffer[i];
444  }
445  s |= nt->releaseBlockOfColumnValues(innerBlock);
446  break;
447  }
448 
449  feat_idx -= lcols;
450  }
451  }
452  block.reset();
453  return s;
454  }
455 
456  services::Status setNumberOfRowsImpl(size_t nrow) DAAL_C11_OVERRIDE;
457 
458  services::Status allocateDataMemoryImpl(daal::MemType type = daal::dram) DAAL_C11_OVERRIDE;
459 
460  void freeDataMemoryImpl() DAAL_C11_OVERRIDE;
461 
462 protected:
463  DataCollectionPtr _tables;
464 
465  MergedNumericTable(services::Status &st);
466 
467  MergedNumericTable(const NumericTablePtr &table, services::Status &st);
468 
469  MergedNumericTable(const NumericTablePtr &first, const NumericTablePtr &second, services::Status &st);
470 };
471 typedef services::SharedPtr<MergedNumericTable> MergedNumericTablePtr;
473 } // namespace interface1
474 using interface1::MergedNumericTable;
475 using interface1::MergedNumericTablePtr;
476 
477 } // namespace data_management
478 } // namespace daal
479 
480 #endif
daal::data_management::interface1::MergedNumericTable::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: merged_numeric_table.h:220
daal::data_management::interface1::MergedNumericTable::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: merged_numeric_table.h:191
daal
Definition: algorithm_base_common.h:31
daal::services::ErrorMemoryAllocationFailed
Definition: error_indexes.h:146
daal::dram
Definition: daal_defines.h:137
daal::data_management::interface1::MergedNumericTable::getBlockOfRows
services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: merged_numeric_table.h:172
daal::data_management::interface1::MergedNumericTable::allocateBasicStatistics
services::Status allocateBasicStatistics() DAAL_C11_OVERRIDE
Definition: merged_numeric_table.h:225
daal_defines.h
daal::algorithms::multivariate_outlier_detection::location
Definition: outlier_detection_multivariate_types.h:72
daal::data_management::interface1::NumericTableIface::minimum
Definition: numeric_table.h:296
daal::data_management::interface1::NumericTable::allocateBasicStatistics
virtual services::Status allocateBasicStatistics() DAAL_C11_OVERRIDE
daal::data_management::interface1::MergedNumericTable::resize
services::Status resize(size_t nrow) DAAL_C11_OVERRIDE
Definition: merged_numeric_table.h:135
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::MergedNumericTable::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: merged_numeric_table.h:212
daal::data_management::interface1::NumericTable::resize
virtual services::Status resize(size_t nrows) DAAL_C11_OVERRIDE
Definition: numeric_table.h:636
daal::data_management::interface1::MergedNumericTable::getBlockOfRows
services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: merged_numeric_table.h:177
daal::data_management::interface1::MergedNumericTable::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: merged_numeric_table.h:187
daal::services::ErrorIncorrectTypeOfInputNumericTable
Definition: error_indexes.h:91
daal::data_management::interface1::NumericTableIface::maximum
Definition: numeric_table.h:297
daal::data_management::interface1::MergedNumericTable
Class that provides methods to access a collection of numeric tables as if they are joined by columns...
Definition: merged_numeric_table.h:46
daal::data_management::interface1::MergedNumericTable::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: merged_numeric_table.h:216
daal::data_management::interface1::MergedNumericTable::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: merged_numeric_table.h:183
daal::data_management::interface1::MergedNumericTable::getBlockOfRows
services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: merged_numeric_table.h:167
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::MergedNumericTable::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: merged_numeric_table.h:196
daal::data_management::interface1::NumericTableIface::sum
Definition: numeric_table.h:298
daal::algorithms::implicit_als::training::offset
Definition: implicit_als_training_types.h:148
daal::data_management::interface1::NumericTableIface::sumSquares
Definition: numeric_table.h:299
daal::data_management::interface1::MergedNumericTable::addNumericTable
services::Status addNumericTable(NumericTablePtr table)
Definition: merged_numeric_table.h:103
daal::data_management::interface1::MergedNumericTable::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: merged_numeric_table.h:206
daal::data_management::interface1::MergedNumericTable::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: merged_numeric_table.h:201
daal::data_management::interface1::MergedNumericTable::getDataMemoryStatus
MemoryStatus getDataMemoryStatus() const DAAL_C11_OVERRIDE
Definition: merged_numeric_table.h:148
daal::data_management::interface1::NumericTableFeature
Data structure describes the Numeric Table feature.
Definition: data_dictionary.h:51
daal::data_management::interface1::NumericTable::getDataMemoryStatus
virtual MemoryStatus getDataMemoryStatus() const
Definition: numeric_table.h:719
daal::MemType
MemType
Definition: daal_defines.h:135

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