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

row_merged_numeric_table.h
1 /* file: row_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 row merged numeric table.
21 //--
22 */
23 
24 
25 #ifndef __ROW_MERGED_NUMERIC_TABLE_H__
26 #define __ROW_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 RowMergedNumericTable : public NumericTable
49 {
50 public:
51  DECLARE_SERIALIZABLE_TAG();
52  DECLARE_SERIALIZABLE_IMPL();
53 
58  RowMergedNumericTable();
59 
65  RowMergedNumericTable(NumericTablePtr table);
66 
71  static services::SharedPtr<RowMergedNumericTable> create(services::Status *stat = NULL);
72 
78  static services::SharedPtr<RowMergedNumericTable> create(const NumericTablePtr &nestedTable,
79  services::Status *stat = NULL);
80 
85  services::Status addNumericTable(NumericTablePtr table)
86  {
87  if (table->getDataLayout() & csrArray)
88  return services::Status(services::ErrorIncorrectTypeOfInputNumericTable);
89 
90  size_t ncols = getNumberOfColumns();
91  size_t cols = table->getNumberOfColumns();
92 
93  if (ncols != 0 && ncols != cols)
94  return services::Status(services::ErrorIncorrectNumberOfFeatures);
95 
96  _tables->push_back(table);
97 
98  if (ncols == 0)
99  {
100  DictionaryIface::FeaturesEqual featuresEqual = table->getDictionarySharedPtr()->getFeaturesEqual();
101  services::Status s;
102  _ddict = NumericTableDictionary::create(ncols, featuresEqual, &s);
103  if(!s)
104  return s;
105  s = setNumberOfColumnsImpl(cols);
106  if(!s)
107  return s;
108  if (featuresEqual == DictionaryIface::equal)
109  {
110  NumericTableFeature &f = table->getDictionarySharedPtr()->operator[](0);
111  _ddict->setFeature(f, 0);
112  }
113  else
114  {
115  for (size_t i = 0; i < cols; i++)
116  {
117  NumericTableFeature &f = table->getDictionarySharedPtr()->operator[](i);
118  _ddict->setFeature(f, i);
119  }
120  }
121  }
122 
123  size_t obs = table->getNumberOfRows();
124  return setNumberOfRowsImpl(_obsnum + obs);
125  }
126 
127  services::Status resize(size_t nrows) DAAL_C11_OVERRIDE
128  {
129  return services::Status(services::throwIfPossible(services::ErrorMethodNotSupported));
130  }
131 
132  MemoryStatus getDataMemoryStatus() const DAAL_C11_OVERRIDE
133  {
134  if (_tables->size() == 0)
135  {
136  return notAllocated;
137  }
138 
139  for (size_t i = 0;i < _tables->size(); i++)
140  {
141  NumericTable* nt = (NumericTable*)(_tables->operator[](i).get());
142  if (nt->getDataMemoryStatus() == notAllocated)
143  {
144  return notAllocated;
145  }
146  }
147 
148  return internallyAllocated;
149  }
150 
151  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num,
152  ReadWriteMode rwflag, BlockDescriptor<double>& block) DAAL_C11_OVERRIDE
153  {
154  return getTBlock<double>(vector_idx, vector_num, rwflag, block);
155  }
156  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num,
157  ReadWriteMode rwflag, BlockDescriptor<float>& block) DAAL_C11_OVERRIDE
158  {
159  return getTBlock<float>(vector_idx, vector_num, rwflag, block);
160  }
161  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num,
162  ReadWriteMode rwflag, BlockDescriptor<int>& block) DAAL_C11_OVERRIDE
163  {
164  return getTBlock<int>(vector_idx, vector_num, rwflag, block);
165  }
166 
167  services::Status releaseBlockOfRows(BlockDescriptor<double>& block) DAAL_C11_OVERRIDE
168  {
169  return releaseTBlock<double>(block);
170  }
171  services::Status releaseBlockOfRows(BlockDescriptor<float>& block) DAAL_C11_OVERRIDE
172  {
173  return releaseTBlock<float>(block);
174  }
175  services::Status releaseBlockOfRows(BlockDescriptor<int>& block) DAAL_C11_OVERRIDE
176  {
177  return releaseTBlock<int>(block);
178  }
179 
180  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
181  ReadWriteMode rwflag, BlockDescriptor<double>& block) DAAL_C11_OVERRIDE
182  {
183  return getTFeature<double>(feature_idx, vector_idx, value_num, rwflag, block);
184  }
185  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
186  ReadWriteMode rwflag, BlockDescriptor<float>& block) DAAL_C11_OVERRIDE
187  {
188  return getTFeature<float>(feature_idx, vector_idx, value_num, rwflag, block);
189  }
190  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
191  ReadWriteMode rwflag, BlockDescriptor<int>& block) DAAL_C11_OVERRIDE
192  {
193  return getTFeature<int>(feature_idx, vector_idx, value_num, rwflag, block);
194  }
195 
196  services::Status releaseBlockOfColumnValues(BlockDescriptor<double>& block) DAAL_C11_OVERRIDE
197  {
198  return releaseTFeature<double>(block);
199  }
200  services::Status releaseBlockOfColumnValues(BlockDescriptor<float>& block) DAAL_C11_OVERRIDE
201  {
202  return releaseTFeature<float>(block);
203  }
204  services::Status releaseBlockOfColumnValues(BlockDescriptor<int>& block) DAAL_C11_OVERRIDE
205  {
206  return releaseTFeature<int>(block);
207  }
208 
209 protected:
210 
211  template<typename Archive, bool onDeserialize>
212  services::Status serialImpl( Archive *arch )
213  {
214  NumericTable::serialImpl<Archive, onDeserialize>( arch );
215 
216  arch->setSharedPtrObj(_tables);
217 
218  return services::Status();
219  }
220 
221 private:
222  template<typename T>
223  void internal_inner_repack( size_t idx, size_t rows, size_t ncols, T *src, T *dst )
224  {
225  size_t i, j;
226 
227  for(i = 0; i < rows; i++)
228  {
229  for(j = 0; j < ncols; j++)
230  {
231  dst[(idx + i) * ncols + j] = src[i * ncols + j];
232  }
233  }
234  }
235 
236  template<typename T>
237  void internal_outer_repack( size_t idx, size_t rows, size_t ncols, T *src, T *dst )
238  {
239  size_t i, j;
240 
241  for(i = 0; i < rows; i++)
242  {
243  for(j = 0; j < ncols; j++)
244  {
245  dst[i * ncols + j] = src[(i + idx) * ncols + j];
246  }
247  }
248  }
249 
250 protected:
251  template <typename T>
252  services::Status getTBlock(size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T>& block)
253  {
254  services::Status s;
255  size_t ncols = getNumberOfColumns();
256  size_t nobs = getNumberOfRows();
257  block.setDetails( 0, idx, rwFlag );
258 
259  if (idx >= nobs)
260  {
261  block.resizeBuffer( ncols, 0 );
262  return services::Status();
263  }
264 
265  nrows = ( idx + nrows < nobs ) ? nrows : nobs - idx;
266 
267  if( !block.resizeBuffer( ncols, nrows ) )
268  return services::Status(services::ErrorMemoryAllocationFailed);
269 
270  if( rwFlag & (int)readOnly )
271  {
272  size_t rows = 0;
273  BlockDescriptor<T> innerBlock;
274  for (size_t k = 0; k < _tables->size() && rows < idx + nrows; k++)
275  {
276  NumericTable* nt = (NumericTable*)(_tables->operator[](k).get());
277  size_t lrows = nt->getNumberOfRows();
278 
279  if (rows + lrows > idx)
280  {
281  size_t idxBegin = (rows < idx) ? idx : rows;
282  size_t idxEnd = (rows + lrows < idx + nrows) ? rows + lrows : idx + nrows;
283  s |= nt->getBlockOfRows(idxBegin - rows, idxEnd - idxBegin, readOnly, innerBlock);
284 
285  internal_inner_repack<T>( idxBegin - idx, idxEnd - idxBegin, ncols, innerBlock.getBlockPtr(), block.getBlockPtr());
286 
287  s |= nt->releaseBlockOfRows(innerBlock);
288  }
289 
290  rows += lrows;
291  }
292  }
293  return s;
294  }
295 
296  template <typename T>
297  services::Status releaseTBlock(BlockDescriptor<T>& block)
298  {
299  services::Status s;
300  if(block.getRWFlag() & (int)writeOnly)
301  {
302  size_t ncols = getNumberOfColumns();
303  size_t nrows = block.getNumberOfRows();
304  size_t idx = block.getRowsOffset();
305  size_t rows = 0;
306  BlockDescriptor<T> innerBlock;
307  for (size_t k = 0; k < _tables->size() && rows < idx + nrows; k++)
308  {
309  NumericTable* nt = (NumericTable*)(_tables->operator[](k).get());
310  size_t lrows = nt->getNumberOfRows();
311 
312  if (rows + lrows > idx)
313  {
314  size_t idxBegin = (rows < idx) ? idx : rows;
315  size_t idxEnd = (rows + lrows < idx + nrows) ? rows + lrows : idx + nrows;
316  s |= nt->getBlockOfRows(idxBegin - rows, idxEnd - idxBegin, writeOnly, innerBlock);
317 
318  internal_outer_repack<T>( idxBegin - idx, idxEnd - idxBegin, ncols, block.getBlockPtr(), innerBlock.getBlockPtr());
319 
320  s |= nt->releaseBlockOfRows(innerBlock);
321  }
322 
323  rows += lrows;
324  }
325  }
326  block.reset();
327  return s;
328  }
329 
330  template <typename T>
331  services::Status getTFeature(size_t feat_idx, size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T>& block)
332  {
333  services::Status s;
334  size_t ncols = getNumberOfColumns();
335  size_t nobs = getNumberOfRows();
336  block.setDetails( feat_idx, idx, rwFlag );
337 
338  if (idx >= nobs)
339  {
340  block.resizeBuffer( 1, 0 );
341  return services::Status();
342  }
343 
344  nrows = ( idx + nrows < nobs ) ? nrows : nobs - idx;
345  if( !block.resizeBuffer( 1, nrows ) )
346  return services::Status(services::ErrorMemoryAllocationFailed);
347 
348  if( rwFlag & (int)readOnly )
349  {
350  T* buffer = block.getBlockPtr();
351  size_t rows = 0;
352  for (size_t k = 0; k < _tables->size() && rows < idx + nrows; k++)
353  {
354  NumericTable* nt = (NumericTable*)(_tables->operator[](k).get());
355  size_t lrows = nt->getNumberOfRows();
356 
357  if (rows + lrows > idx)
358  {
359  size_t idxBegin = (rows < idx) ? idx : rows;
360  size_t idxEnd = (rows + lrows < idx + nrows) ? rows + lrows : idx + nrows;
361 
362  BlockDescriptor<T> innerBlock;
363  s |= nt->getBlockOfColumnValues(feat_idx, idxBegin - rows, idxEnd - idxBegin, readOnly, innerBlock);
364  T* location = innerBlock.getBlockPtr();
365  for (size_t i = idxBegin; i < idxEnd; i++)
366  {
367  buffer[i] = location[i - idxBegin];
368  }
369  s |= nt->releaseBlockOfColumnValues(innerBlock);
370  }
371 
372  rows += lrows;
373  }
374  }
375  return s;
376  }
377 
378  template <typename T>
379  services::Status releaseTFeature( BlockDescriptor<T>& block )
380  {
381  services::Status s;
382  if (block.getRWFlag() & (int)writeOnly)
383  {
384  size_t feat_idx = block.getColumnsOffset();
385  size_t idx = block.getRowsOffset();
386  size_t nrows = block.getNumberOfRows();
387  size_t rows = 0;
388  T* buffer = block.getBlockPtr();
389  for (size_t k = 0; k < _tables->size() && rows < idx + nrows; k++)
390  {
391  NumericTable* nt = (NumericTable*)(_tables->operator[](k).get());
392  size_t lrows = nt->getNumberOfRows();
393 
394  if (rows + lrows > idx)
395  {
396  size_t idxBegin = (rows < idx) ? idx : rows;
397  size_t idxEnd = (rows + lrows < idx + nrows) ? rows + lrows : idx + nrows;
398 
399  BlockDescriptor<T> innerBlock;
400  s |= nt->getBlockOfColumnValues(feat_idx, idxBegin - rows, idxEnd - idxBegin, writeOnly, innerBlock);
401  T* location = innerBlock.getBlockPtr();
402  for (size_t i = idxBegin; i < idxEnd; i++)
403  {
404  location[i - idxBegin] = buffer[i];
405  }
406  s |= nt->releaseBlockOfColumnValues(innerBlock);
407  }
408 
409  rows += lrows;
410  }
411  }
412  block.reset();
413  return s;
414  }
415 
416  services::Status setNumberOfColumnsImpl(size_t ncols) DAAL_C11_OVERRIDE;
417  services::Status allocateDataMemoryImpl(daal::MemType type = daal::dram) DAAL_C11_OVERRIDE;
418  void freeDataMemoryImpl() DAAL_C11_OVERRIDE;
419 
420 protected:
421  DataCollectionPtr _tables;
422 
423  RowMergedNumericTable(services::Status &st);
424 
425  RowMergedNumericTable(const NumericTablePtr &table, services::Status &st);
426 };
427 typedef services::SharedPtr<RowMergedNumericTable> RowMergedNumericTablePtr;
429 } // namespace interface1
430 using interface1::RowMergedNumericTable;
431 using interface1::RowMergedNumericTablePtr;
432 
433 } // namespace data_management
434 } // namespace daal
435 
436 #endif
daal::services::ErrorMethodNotSupported
Definition: error_indexes.h:71
daal::data_management::interface1::NumericTable::getDataMemoryStatus
virtual MemoryStatus getDataMemoryStatus() const
Definition: numeric_table.h:722
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:185
daal::algorithms::multivariate_outlier_detection::location
Definition: outlier_detection_multivariate_types.h:74
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:161
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:48
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::MemType
MemType
Definition: daal_defines.h:147
daal::data_management::interface1::RowMergedNumericTable::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: row_merged_numeric_table.h:204
daal_defines.h
daal::data_management::interface1::RowMergedNumericTable::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: row_merged_numeric_table.h:171
daal::data_management::interface1::RowMergedNumericTable::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: row_merged_numeric_table.h:175
daal::data_management::interface1::RowMergedNumericTable::addNumericTable
services::Status addNumericTable(NumericTablePtr table)
Definition: row_merged_numeric_table.h:85
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::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:190
daal::dram
Definition: daal_defines.h:149
daal::data_management::interface1::RowMergedNumericTable::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: row_merged_numeric_table.h:200
daal::data_management::interface1::RowMergedNumericTable::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: row_merged_numeric_table.h:196
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:188
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:180
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::services::ErrorIncorrectNumberOfFeatures
Definition: error_indexes.h:72
daal::data_management::interface1::NumericTableFeature
Data structure describes the Numeric Table feature.
Definition: data_dictionary.h:53
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:151
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:156
daal::data_management::interface1::RowMergedNumericTable::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: row_merged_numeric_table.h:167
daal::services::ErrorIncorrectTypeOfInputNumericTable
Definition: error_indexes.h:93
daal::data_management::interface1::RowMergedNumericTable::resize
services::Status resize(size_t nrows) DAAL_C11_OVERRIDE
Definition: row_merged_numeric_table.h:127
daal::data_management::interface1::RowMergedNumericTable::getDataMemoryStatus
MemoryStatus getDataMemoryStatus() const DAAL_C11_OVERRIDE
Definition: row_merged_numeric_table.h:132

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