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

matrix.h
1 /* file: matrix.h */
2 /*******************************************************************************
3 * Copyright 2014-2017 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 matrix numeric table.
45 //--
46 */
47 
48 #ifndef __MATRIX_H__
49 #define __MATRIX_H__
50 
51 #include "services/daal_memory.h"
52 #include "data_management/data/numeric_table.h"
53 #include "data_management/data/homogen_numeric_table.h"
54 #include "services/daal_shared_ptr.h"
55 #include "data_management/data/data_serialize.h"
56 
57 namespace daal
58 {
59 namespace data_management
60 {
61 
62 namespace interface1
63 {
73 template<typename DataType = DAAL_DATA_TYPE>
74 class DAAL_EXPORT Matrix : public HomogenNumericTable<DataType>
75 {
76 public:
77  DECLARE_SERIALIZABLE_TAG();
78 
85  Matrix( size_t nColumns = 0, size_t nRows = 0, DataType *const ptr = 0 ):
86  HomogenNumericTable<DataType>( services::SharedPtr<DataType>(ptr, services::EmptyDeleter()), nColumns, nRows ) { }
87 
96  static services::SharedPtr<Matrix<DataType> > create(size_t nColumns = 0, size_t nRows = 0, DataType *const ptr = 0,
97  services::Status *stat = NULL)
98  {
99  return create(DictionaryIface::notEqual, nColumns, nRows, services::SharedPtr<DataType>(ptr, services::EmptyDeleter()), stat);
100  }
101 
109  Matrix( size_t nColumns, size_t nRows, const services::SharedPtr<DataType> &ptr):
110  HomogenNumericTable<DataType>( ptr, nColumns, nRows ) { }
111 
120  static services::SharedPtr<Matrix<DataType> > create(size_t nColumns, size_t nRows, services::SharedPtr<DataType> &ptr,
121  services::Status *stat = NULL)
122  {
123  return create(DictionaryIface::notEqual, nColumns, nRows, ptr, stat);
124  }
125 
133  Matrix( DictionaryIface::FeaturesEqual featuresEqual, size_t nColumns = 0, size_t nRows = 0, DataType *const ptr = 0 ):
134  HomogenNumericTable<DataType>( featuresEqual, services::SharedPtr<DataType>(ptr, services::EmptyDeleter()), nColumns, nRows ) { }
135 
145  static services::SharedPtr<Matrix<DataType> > create(DictionaryIface::FeaturesEqual featuresEqual,
146  size_t nColumns = 0, size_t nRows = 0, DataType *const ptr = 0,
147  services::Status *stat = NULL)
148  {
149  return create(featuresEqual, nColumns, nRows, services::SharedPtr<DataType>(ptr, services::EmptyDeleter()), stat);
150  }
151 
159  Matrix( DictionaryIface::FeaturesEqual featuresEqual, size_t nColumns, size_t nRows, const services::SharedPtr<DataType> &ptr ):
160  HomogenNumericTable<DataType>( featuresEqual, ptr, nColumns, nRows ) { }
161 
171  static services::SharedPtr<Matrix<DataType> > create(DictionaryIface::FeaturesEqual featuresEqual,
172  size_t nColumns, size_t nRows, const services::SharedPtr<DataType> &ptr,
173  services::Status *stat = NULL)
174  {
175  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(Matrix, DataType, featuresEqual, nColumns, nRows, ptr);
176  }
177 
184  Matrix( size_t nColumns, size_t nRows, NumericTable::AllocationFlag memoryAllocationFlag ):
185  HomogenNumericTable<DataType>( nColumns, nRows, memoryAllocationFlag ) { }
186 
195  static services::SharedPtr<Matrix<DataType> > create(size_t nColumns, size_t nRows, NumericTable::AllocationFlag memoryAllocationFlag,
196  services::Status *stat = NULL)
197  {
198  return create(DictionaryIface::notEqual, nColumns, nRows, memoryAllocationFlag, stat);
199  }
200 
208  Matrix( DictionaryIface::FeaturesEqual featuresEqual, size_t nColumns, size_t nRows, NumericTable::AllocationFlag memoryAllocationFlag ):
209  HomogenNumericTable<DataType>( featuresEqual, nColumns, nRows, memoryAllocationFlag ) { }
210 
220  static services::SharedPtr<Matrix<DataType> > create(DictionaryIface::FeaturesEqual featuresEqual,
221  size_t nColumns, size_t nRows, NumericTable::AllocationFlag memoryAllocationFlag,
222  services::Status *stat = NULL)
223  {
224  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(Matrix, DataType, featuresEqual, nColumns, nRows, memoryAllocationFlag);
225  }
226 
234  Matrix( size_t nColumns, size_t nRows, DataType *const ptr, const DataType &constValue ):
235  HomogenNumericTable<DataType>( services::SharedPtr<DataType>(ptr, services::EmptyDeleter()), nColumns, nRows, constValue ) { }
236 
246  static services::SharedPtr<Matrix<DataType> > create(size_t nColumns, size_t nRows, DataType *const ptr,
247  const DataType &constValue, services::Status *stat = NULL)
248  {
249  return create(DictionaryIface::notEqual, nColumns, nRows, services::SharedPtr<DataType>(ptr, services::EmptyDeleter()), constValue, stat);
250  }
251 
259  Matrix( size_t nColumns, size_t nRows, const services::SharedPtr<DataType> &ptr, const DataType &constValue ):
260  HomogenNumericTable<DataType>( ptr, nColumns, nRows, constValue ) { }
261 
271  static services::SharedPtr<Matrix<DataType> > create(size_t nColumns, size_t nRows, const services::SharedPtr<DataType> &ptr,
272  const DataType &constValue, services::Status *stat = NULL)
273  {
274  return create(DictionaryIface::notEqual, nColumns, nRows, ptr, constValue, stat);
275  }
276 
285  Matrix( DictionaryIface::FeaturesEqual featuresEqual, size_t nColumns, size_t nRows, DataType *const ptr, const DataType &constValue ):
286  HomogenNumericTable<DataType>( featuresEqual, services::SharedPtr<DataType>(ptr, services::EmptyDeleter()), nColumns, nRows, constValue ) { }
287 
298  static services::SharedPtr<Matrix<DataType> > create(DictionaryIface::FeaturesEqual featuresEqual,
299  size_t nColumns, size_t nRows, DataType *const ptr,
300  const DataType &constValue, services::Status *stat = NULL)
301  {
302  return create(featuresEqual, nColumns, nRows, services::SharedPtr<DataType>(ptr, services::EmptyDeleter()), constValue, stat);
303  }
304 
313  Matrix( DictionaryIface::FeaturesEqual featuresEqual, size_t nColumns, size_t nRows, const services::SharedPtr<DataType> &ptr, const DataType &constValue ):
314  HomogenNumericTable<DataType>( featuresEqual, ptr, nColumns, nRows, constValue ) { }
315 
326  static services::SharedPtr<Matrix<DataType> > create(DictionaryIface::FeaturesEqual featuresEqual,
327  size_t nColumns, size_t nRows, const services::SharedPtr<DataType> &ptr,
328  const DataType &constValue, services::Status *stat = NULL)
329  {
330  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(Matrix, DataType, featuresEqual, nColumns, nRows, ptr, constValue);
331  }
332 
340  Matrix( size_t nColumns, size_t nRows, NumericTable::AllocationFlag memoryAllocationFlag,
341  const DataType &constValue ):
342  HomogenNumericTable<DataType>( nColumns, nRows, memoryAllocationFlag, constValue ) { }
343 
353  static services::SharedPtr<Matrix<DataType> > create(size_t nColumns, size_t nRows, NumericTable::AllocationFlag memoryAllocationFlag,
354  const DataType &constValue, services::Status *stat = NULL)
355  {
356  return create(DictionaryIface::notEqual, nColumns, nRows, memoryAllocationFlag, constValue, stat);
357  }
358 
367  Matrix( DictionaryIface::FeaturesEqual featuresEqual, size_t nColumns, size_t nRows,
368  NumericTable::AllocationFlag memoryAllocationFlag, const DataType &constValue ):
369  HomogenNumericTable<DataType>( featuresEqual, nColumns, nRows, memoryAllocationFlag, constValue ) { }
370 
381  static services::SharedPtr<Matrix<DataType> > create(DictionaryIface::FeaturesEqual featuresEqual,
382  size_t nColumns, size_t nRows, NumericTable::AllocationFlag memoryAllocationFlag,
383  const DataType &constValue, services::Status *stat = NULL)
384  {
385  DAAL_DEFAULT_CREATE_TEMPLATE_IMPL_EX(Matrix, DataType, featuresEqual, nColumns, nRows, memoryAllocationFlag, constValue);
386  }
387 
389  virtual ~Matrix() { }
390 
391 protected:
392 
393  Matrix(DictionaryIface::FeaturesEqual featuresEqual, size_t nColumns, size_t nRows,
394  const services::SharedPtr<DataType> &ptr, services::Status &st):
395  HomogenNumericTable<DataType>(featuresEqual, ptr, nColumns, nRows, st) { }
396 
397  Matrix(DictionaryIface::FeaturesEqual featuresEqual, size_t nColumns, size_t nRows,
398  NumericTable::AllocationFlag memoryAllocationFlag, services::Status &st):
399  HomogenNumericTable<DataType>(featuresEqual, nColumns, nRows, memoryAllocationFlag, st) { }
400 
401  Matrix(DictionaryIface::FeaturesEqual featuresEqual, size_t nColumns, size_t nRows,
402  const services::SharedPtr<DataType> &ptr, const DataType &constValue,
403  services::Status &st):
404  HomogenNumericTable<DataType>(featuresEqual, ptr, nColumns, nRows, constValue, st) { }
405 
406  Matrix(DictionaryIface::FeaturesEqual featuresEqual, size_t nColumns, size_t nRows,
407  NumericTable::AllocationFlag memoryAllocationFlag, const DataType &constValue, services::Status &st):
408  HomogenNumericTable<DataType>(featuresEqual, nColumns, nRows, memoryAllocationFlag, constValue, st) { }
409 };
411 } // namespace interface1
412 using interface1::Matrix;
413 
414 }
415 } // namespace daal
416 #endif
daal::data_management::interface1::NumericTableIface::AllocationFlag
AllocationFlag
Enumeration to specify whether the Numeric Table must allocate memory.
Definition: numeric_table.h:309
daal::data_management::interface1::Matrix::Matrix
Matrix(DictionaryIface::FeaturesEqual featuresEqual, size_t nColumns, size_t nRows, NumericTable::AllocationFlag memoryAllocationFlag, const DataType &constValue)
Definition: matrix.h:367
daal::data_management::interface1::Matrix::create
static services::SharedPtr< Matrix< DataType > > create(size_t nColumns=0, size_t nRows=0, DataType *const ptr=0, services::Status *stat=NULL)
Definition: matrix.h:96
daal
Definition: algorithm_base_common.h:57
daal::data_management::interface1::Matrix::Matrix
Matrix(DictionaryIface::FeaturesEqual featuresEqual, size_t nColumns, size_t nRows, DataType *const ptr, const DataType &constValue)
Definition: matrix.h:285
daal::data_management::interface1::Matrix
Represents a two-dimensional table of numbers of the same type.
Definition: matrix.h:74
daal::data_management::interface1::Matrix::Matrix
Matrix(size_t nColumns, size_t nRows, NumericTable::AllocationFlag memoryAllocationFlag)
Definition: matrix.h:184
daal::data_management::interface1::Matrix::create
static services::SharedPtr< Matrix< DataType > > create(size_t nColumns, size_t nRows, services::SharedPtr< DataType > &ptr, services::Status *stat=NULL)
Definition: matrix.h:120
daal::data_management::interface1::Matrix::Matrix
Matrix(DictionaryIface::FeaturesEqual featuresEqual, size_t nColumns, size_t nRows, const services::SharedPtr< DataType > &ptr, const DataType &constValue)
Definition: matrix.h:313
daal::data_management::interface1::Matrix::Matrix
Matrix(size_t nColumns=0, size_t nRows=0, DataType *const ptr=0)
Definition: matrix.h:85
daal::data_management::interface1::Matrix::create
static services::SharedPtr< Matrix< DataType > > create(DictionaryIface::FeaturesEqual featuresEqual, size_t nColumns, size_t nRows, const services::SharedPtr< DataType > &ptr, const DataType &constValue, services::Status *stat=NULL)
Definition: matrix.h:326
daal::data_management::interface1::Matrix::Matrix
Matrix(DictionaryIface::FeaturesEqual featuresEqual, size_t nColumns, size_t nRows, NumericTable::AllocationFlag memoryAllocationFlag)
Definition: matrix.h:208
daal::data_management::interface1::Matrix::create
static services::SharedPtr< Matrix< DataType > > create(DictionaryIface::FeaturesEqual featuresEqual, size_t nColumns, size_t nRows, NumericTable::AllocationFlag memoryAllocationFlag, const DataType &constValue, services::Status *stat=NULL)
Definition: matrix.h:381
daal::data_management::interface1::Matrix::create
static services::SharedPtr< Matrix< DataType > > create(size_t nColumns, size_t nRows, DataType *const ptr, const DataType &constValue, services::Status *stat=NULL)
Definition: matrix.h:246
daal::data_management::interface1::Matrix::Matrix
Matrix(size_t nColumns, size_t nRows, NumericTable::AllocationFlag memoryAllocationFlag, const DataType &constValue)
Definition: matrix.h:340
daal::data_management::interface1::Matrix::Matrix
Matrix(size_t nColumns, size_t nRows, const services::SharedPtr< DataType > &ptr, const DataType &constValue)
Definition: matrix.h:259
daal::data_management::interface1::Matrix::Matrix
Matrix(size_t nColumns, size_t nRows, const services::SharedPtr< DataType > &ptr)
Definition: matrix.h:109
daal::data_management::interface1::Matrix::Matrix
Matrix(size_t nColumns, size_t nRows, DataType *const ptr, const DataType &constValue)
Definition: matrix.h:234
daal::data_management::interface1::Matrix::create
static services::SharedPtr< Matrix< DataType > > create(size_t nColumns, size_t nRows, NumericTable::AllocationFlag memoryAllocationFlag, services::Status *stat=NULL)
Definition: matrix.h:195
daal::data_management::interface1::Matrix::create
static services::SharedPtr< Matrix< DataType > > create(DictionaryIface::FeaturesEqual featuresEqual, size_t nColumns, size_t nRows, const services::SharedPtr< DataType > &ptr, services::Status *stat=NULL)
Definition: matrix.h:171
daal::data_management::interface1::Matrix::Matrix
Matrix(DictionaryIface::FeaturesEqual featuresEqual, size_t nColumns=0, size_t nRows=0, DataType *const ptr=0)
Definition: matrix.h:133
daal::data_management::interface1::Matrix::create
static services::SharedPtr< Matrix< DataType > > create(DictionaryIface::FeaturesEqual featuresEqual, size_t nColumns=0, size_t nRows=0, DataType *const ptr=0, services::Status *stat=NULL)
Definition: matrix.h:145
daal::data_management::interface1::Matrix::create
static services::SharedPtr< Matrix< DataType > > create(DictionaryIface::FeaturesEqual featuresEqual, size_t nColumns, size_t nRows, DataType *const ptr, const DataType &constValue, services::Status *stat=NULL)
Definition: matrix.h:298
daal::data_management::interface1::DictionaryIface::FeaturesEqual
FeaturesEqual
Enumeration to specify whether the Data Dictionary contains equal features.
Definition: data_dictionary.h:171
daal::data_management::interface1::Matrix::create
static services::SharedPtr< Matrix< DataType > > create(size_t nColumns, size_t nRows, const services::SharedPtr< DataType > &ptr, const DataType &constValue, services::Status *stat=NULL)
Definition: matrix.h:271
daal::data_management::interface1::Matrix::create
static services::SharedPtr< Matrix< DataType > > create(size_t nColumns, size_t nRows, NumericTable::AllocationFlag memoryAllocationFlag, const DataType &constValue, services::Status *stat=NULL)
Definition: matrix.h:353
daal::data_management::interface1::HomogenNumericTable
Class that provides methods to access data stored as a contiguous array of homogeneous feature vector...
Definition: homogen_numeric_table.h:76
daal::data_management::interface1::Matrix::Matrix
Matrix(DictionaryIface::FeaturesEqual featuresEqual, size_t nColumns, size_t nRows, const services::SharedPtr< DataType > &ptr)
Definition: matrix.h:159
daal::data_management::interface1::Matrix::create
static services::SharedPtr< Matrix< DataType > > create(DictionaryIface::FeaturesEqual featuresEqual, size_t nColumns, size_t nRows, NumericTable::AllocationFlag memoryAllocationFlag, services::Status *stat=NULL)
Definition: matrix.h:220

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