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

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

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