Introduction#
This section contains instructions for writing code that calls AOCL-DA using the C APIs and for building
applications that link to the library.
Numerous example programs are also provided in the examples folder within your
AOCL-DA installation directory.
The C interface has been designed to make it as seamless as possible to integrate with the library from whatever programming language you are using. In addition, a header file containing C++ overloads is available for C++ users who wish to abstract away the floating-point data type.
Library workflow#
The intended workflow for using the AOCL-DA C APIs is as follows:
Load data from memory. Data can be obtained from various sources:
pass arrays of data directly from another part of your application;
read directly from CSV files into floating-point or integer arrays;
read mixed data from CSV files into a
da_datastore.
Data preprocessing. Functions are available for:
standardizing, scaling and shifting arrays of floating point data;
removing missing data from a
da_datastore;selecting certain subsets of the data in a
da_datastore;extracting contiguous arrays of data from a
da_datastore.
Data processing. This is often split into several function calls:
initialize a
da_handlestruct, which is used internally to store algorithmic information;pass arrays of data, or data extracted from a
da_datastore, to the handle (for best possible performance, algorithmic functions typically operate on two-dimensional arrays stored in column major format);computation (e.g. clustering, linear model, principal component analysis);
extract results from the
da_handle.
Linking your application to AOCL-DA#
Linking on Linux#
These instructions assume your application is written in C++, but the AOCL-DA C APIs have been
designed to make calling from other languages as straightforward as possible.
In the example compilation commands below, INT_LIB is either LP64 or
ILP64 for 32 and 64 bit integers respectively.
To compile and link to static AOCL libraries using g++:
g++ <your_source_code>.cpp -I /<path to aocl-da headers>/include_<INT_LIB>
/<path to aocl-da>/lib_<INT_LIB>/libaocl-da.a
/<path to amd-sparse>/lib_<INT_LIB>/libaoclsparse.a
/<path to amd-libflame>/lib_<INT_LIB>/libflame.a
/<path to amd-blis>/lib_<INT_LIB>/libblis-mt.a
/<path to libaoclutils>/lib_<INT_LIB>/libaoclutils.a -lgfortran -lgomp
To compile and link to static AOCL libraries using clang++:
clang++ <your_source_code>.cpp -I /<path to aocl-da headers>/include_<INT_LIB>
/<path to aocl-da>/lib_<INT_LIB>/libaocl-da.a
/<path to amd-sparse>/lib_<INT_LIB>/libaoclsparse.a
/<path to amd-libflame>/lib_<INT_LIB>/libflame.a
/<path to amd-blis>/lib_<INT_LIB>/libblis-mt.a
/<path to libaoclutils>/lib_<INT_LIB>/libaoclutils.a -lflang -lomp -lpgmath
To compile and link to dynamic AOCL libraries using g++:
g++ <your_source_code>.cpp -I /<path to aocl-da headers>/include_<INT_LIB>
-L /<path to aocl-da>/lib_<INT_LIB> -L /<path to amd-sparse>/lib_<INT_LIB>
-L /<path to amd-libflame>/lib_<INT_LIB> -L /<path to amd-blis>/lib_<INT_LIB>
-L /<path to amd-utils>/lib -laocl-da -laoclsparse -lflame -lblis-mt -laoclutils
-lgfortran -lgomp
To compile and link to dynamic AOCL libraries using clang++:
clang++ <your_source_code>.cpp -I /<path to aocl-da headers>/include_<INT_LIB>
-L /<path to aocl-da>/lib_<INT_LIB> -L /<path to amd-sparse>/lib_<INT_LIB>
-L /<path to amd-libflame>/lib_<INT_LIB> -L /<path to amd-blis>/lib_<INT_LIB>
-L /<path to amd-utils>/lib -laocl-da -laoclsparse -lflame -lblis-mt -laoclutils
-lflang -lomp -lpgmath
Note that for dynamic linking you will need to update your LD_LIBRARY_PATH environment
variable, e.g. export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:<AOCL_ROOT>/lib_<INT_LIB>.
If you wish to call AOCL-DA from a C code, then you should compile using your C compiler
(e.g. gcc), but link separately, using a C++ linker (e.g. g++).
Linking on Windows#
In the example compilation command below, INT_LIB is either LP64 or ILP64
for 32 and 64 bit integers respectively.
cl <example_name>.cpp /I \<path to aocl-da headers>\include\<INT_LIB> /EHsc /MD
\<path to aocl-da>\lib\<INT_LIB>\aocl-da.lib
\<path to amd-sparse>\lib\<INT_LIB>\shared\aoclsparse.lib
\<path to amd-libflame>\lib\<INT_LIB>\AOCL-LibFlame-Win-MT-dll.lib
\<path to amd-blis>\lib\<INT_LIB>\AOCL-LibBlis-Win-MT-dll.lib
\<path to amd-utils>\lib\libaoclutils.lib /openmp:llvm
The same command will work with cl replaced by clang-cl (in which case, simply use /openmp) and linking statically using /MT.
Note
You should ensure the folders containing the libraries to be linked are on your
Windows PATH environment variable e.g. using set PATH=%PATH%;C:\<path_to_BLAS_and_LAPACK>.
Depending on how your system is set up, and which functions you are using, you may also need to
link to some Fortran runtime libraries such as libfifcore-mt.lib.
The easiest way to do this is to source the ifort compiler using e.g. C:\Program Files (x86)\Intel\oneAPI\setvars.bat.
Compiling using CMake#
A CMakeLists.txt file is supplied in the examples folder of your installation. You will need to set AOCL_ROOT to point to your AOCL installation.
On Windows, you may also need to source the ifort compiler using e.g. C:\Program Files (x86)\Intel\oneAPI\setvars.bat.
To configure cmake and compile, you can then use commands such as:
mkdir build
cd build
cmake -G Ninja -DCMAKE_CXX_COMPILER=clang-cl ..
cmake --build .
Miscellaneous topics#
Data types in AOCL-DA#
AOCL-DA uses the da_int integer type throughout the library.
For the 32 bit integer library (LP64), this is defined to be a 32 bit signed integer.
For the 64 bit integer library (ILP64, compiled with the CMake flag -DBUILD_ILP64=On), this is defined to be a 64 bit signed integer.
When compiling your own code to use the 64 bit integer library, you must ensure that the AOCLDA_ILP64 build variable is set.
Algorithmic routines operating on floating-point data are typically available in both
single and double precision.
Routines expecting single precision data have _s appended onto their names.
Routines expecting double precision data have _d appended onto their names.
Some routines (such as option setting routines) may expect other data types, and will have _int or _string appended onto their names accordingly.
In this documentation we frequently use _? at the end of routine names to indicate a suite of routines that differ only in the expected data type.
Array storage#
Algorithmic routines in the library expect two-dimensional arrays to be in column major format.
Interpreting missing data#
When using a da_datastore for data management, the special convention for floating point not a number (NaN) can be used to denote missing
data. See Data Management Functionalities for further details.
In order to provide the best possible performance, the algorithmic functions will not check for
NaN data. If a NaN is passed into an algorithmic function, its behaviour is undefined.
It is therefore the user’s responsibility to ensure data is sanitized (for example, by using
da_data_select_non_missing()) before passing it to one of the algorithms.
Error handling#
Functions in AOCL-DA return da_status, which provides basic information about whether
the function call was successful.
Further information about errors can be obtained by querying da_datastore and
da_handle types. For further details, see the error handling pages.
Version string#
To get the version string of AOCL-DA, call the function const char* da_get_version().
C++ overloads#
To facilitate calling AOCL-DA from C++, a set of overloaded functions has been made available.
These are identical to the C interface, except that none of the functions have data type indicators such as _s or _d appended onto their names.
Your C++ compiler will instead call the correct function based on the floating point precision you are using.
For some functions, overloading is not possible (for example, functions such as da_handle_init_s() and da_handle_init_d() do not use double or float arguments).
In these cases, templated functions are available (e.g. da_handle_init<T>, where T can be double or float).
The complete list of available C++ functions is found in aoclda_cpp_overloads.hpp in the include folder of your installation (and reproduced below).
1/*
2 * Copyright (C) 2023-2024 Advanced Micro Devices, Inc. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without modification,
5 * are permitted provided that the following conditions are met:
6 * 1. Redistributions of source code must retain the above copyright notice,
7 * this list of conditions and the following disclaimer.
8 * 2. Redistributions in binary form must reproduce the above copyright notice,
9 * this list of conditions and the following disclaimer in the documentation
10 * and/or other materials provided with the distribution.
11 * 3. Neither the name of the copyright holder nor the names of its contributors
12 * may be used to endorse or promote products derived from this software without
13 * specific prior written permission.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
17 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
19 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
20 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
21 * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
22 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
23 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
24 * POSSIBILITY OF SUCH DAMAGE.
25 *
26 */
27
28#ifndef AOCLDA_CPP_OVERLOADS
29#define AOCLDA_CPP_OVERLOADS
30
31#include "aoclda.h"
32#include <iostream>
33
34/* da_handle overloaded functions */
35template <class T>
36da_status da_handle_init(da_handle *handle, da_handle_type handle_type);
37template <>
38da_status da_handle_init<double>(da_handle *handle, da_handle_type handle_type) {
39 return da_handle_init_d(handle, handle_type);
40}
41template <>
42da_status da_handle_init<float>(da_handle *handle, da_handle_type handle_type) {
43 return da_handle_init_s(handle, handle_type);
44}
45
46inline da_status da_handle_get_result(da_handle handle, da_result query, da_int *dim,
47 double *result) {
48 return da_handle_get_result_d(handle, query, dim, result);
49}
50inline da_status da_handle_get_result(da_handle handle, da_result query, da_int *dim,
51 float *result) {
52 return da_handle_get_result_s(handle, query, dim, result);
53}
54inline da_status da_handle_get_result(da_handle handle, da_result query, da_int *dim,
55 da_int *result) {
56 return da_handle_get_result_int(handle, query, dim, result);
57}
58
59/* Options overloaded functions */
60inline da_status da_options_set(da_handle handle, const char *option, float value) {
61 return da_options_set_real_s(handle, option, value);
62}
63inline da_status da_options_set(da_handle handle, const char *option, double value) {
64 return da_options_set_real_d(handle, option, value);
65}
66inline da_status da_options_set(da_handle handle, const char *option, da_int value) {
67 return da_options_set_int(handle, option, value);
68}
69inline da_status da_options_set(da_handle handle, const char *option, const char *value) {
70 return da_options_set_string(handle, option, value);
71}
72inline da_status da_options_get(da_handle handle, const char *option, double *value) {
73 return da_options_get_real_d(handle, option, value);
74}
75inline da_status da_options_get(da_handle handle, const char *option, float *value) {
76 return da_options_get_real_s(handle, option, value);
77}
78inline da_status da_options_get(da_handle handle, const char *option, da_int *value) {
79 return da_options_get_int(handle, option, value);
80}
81inline da_status da_options_get(da_handle handle, const char *option, char *value,
82 da_int *lvalue) {
83 return da_options_get_string(handle, option, value, lvalue);
84}
85inline da_status da_options_get(da_handle handle, const char *option, char *value,
86 da_int *lvalue, da_int *key) {
87 return da_options_get_string_key(handle, option, value, lvalue, key);
88}
89
90inline da_status da_read_csv(da_datastore store, const char *filename, double **A,
91 da_int *n_rows, da_int *n_cols, char ***headings) {
92 return da_read_csv_d(store, filename, A, n_rows, n_cols, headings);
93}
94
95inline da_status da_read_csv(da_datastore store, const char *filename, float **A,
96 da_int *n_rows, da_int *n_cols, char ***headings) {
97 return da_read_csv_s(store, filename, A, n_rows, n_cols, headings);
98}
99
100inline da_status da_read_csv(da_datastore store, const char *filename, da_int **A,
101 da_int *n_rows, da_int *n_cols, char ***headings) {
102 return da_read_csv_int(store, filename, A, n_rows, n_cols, headings);
103}
104
105inline da_status da_read_csv(da_datastore store, const char *filename, uint8_t **A,
106 da_int *n_rows, da_int *n_cols, char ***headings) {
107 return da_read_csv_uint8(store, filename, A, n_rows, n_cols, headings);
108}
109
110inline da_status da_read_csv(da_datastore store, const char *filename, char ***A,
111 da_int *n_rows, da_int *n_cols, char ***headings) {
112 return da_read_csv_string(store, filename, A, n_rows, n_cols, headings);
113}
114
115/* Basic statistics overloaded functions */
116inline da_status da_mean(da_axis axis, da_int n_rows, da_int n_cols, const double *X,
117 da_int ldx, double *mean) {
118 return da_mean_d(axis, n_rows, n_cols, X, ldx, mean);
119}
120
121inline da_status da_mean(da_axis axis, da_int n_rows, da_int n_cols, const float *X,
122 da_int ldx, float *mean) {
123 return da_mean_s(axis, n_rows, n_cols, X, ldx, mean);
124}
125
126inline da_status da_harmonic_mean(da_axis axis, da_int n_rows, da_int n_cols,
127 const double *X, da_int ldx, double *harmonic_mean) {
128 return da_harmonic_mean_d(axis, n_rows, n_cols, X, ldx, harmonic_mean);
129}
130
131inline da_status da_harmonic_mean(da_axis axis, da_int n_rows, da_int n_cols,
132 const float *X, da_int ldx, float *harmonic_mean) {
133 return da_harmonic_mean_s(axis, n_rows, n_cols, X, ldx, harmonic_mean);
134}
135
136inline da_status da_geometric_mean(da_axis axis, da_int n_rows, da_int n_cols,
137 const double *X, da_int ldx, double *geometric_mean) {
138 return da_geometric_mean_d(axis, n_rows, n_cols, X, ldx, geometric_mean);
139}
140
141inline da_status da_geometric_mean(da_axis axis, da_int n_rows, da_int n_cols,
142 const float *X, da_int ldx, float *geometric_mean) {
143 return da_geometric_mean_s(axis, n_rows, n_cols, X, ldx, geometric_mean);
144}
145
146inline da_status da_variance(da_axis axis, da_int n_rows, da_int n_cols, const double *X,
147 da_int ldx, da_int dof, double *mean, double *variance) {
148 return da_variance_d(axis, n_rows, n_cols, X, ldx, dof, mean, variance);
149}
150
151inline da_status da_variance(da_axis axis, da_int n_rows, da_int n_cols, const float *X,
152 da_int ldx, da_int dof, float *mean, float *variance) {
153 return da_variance_s(axis, n_rows, n_cols, X, ldx, dof, mean, variance);
154}
155
156inline da_status da_skewness(da_axis axis, da_int n_rows, da_int n_cols, const double *X,
157 da_int ldx, double *mean, double *variance,
158 double *skewness) {
159 return da_skewness_d(axis, n_rows, n_cols, X, ldx, mean, variance, skewness);
160}
161
162inline da_status da_skewness(da_axis axis, da_int n_rows, da_int n_cols, const float *X,
163 da_int ldx, float *mean, float *variance, float *skewness) {
164 return da_skewness_s(axis, n_rows, n_cols, X, ldx, mean, variance, skewness);
165}
166
167inline da_status da_kurtosis(da_axis axis, da_int n_rows, da_int n_cols, const double *X,
168 da_int ldx, double *mean, double *variance,
169 double *kurtosis) {
170 return da_kurtosis_d(axis, n_rows, n_cols, X, ldx, mean, variance, kurtosis);
171}
172
173inline da_status da_kurtosis(da_axis axis, da_int n_rows, da_int n_cols, const float *X,
174 da_int ldx, float *mean, float *variance, float *kurtosis) {
175 return da_kurtosis_s(axis, n_rows, n_cols, X, ldx, mean, variance, kurtosis);
176}
177
178inline da_status da_moment(da_axis axis, da_int n_rows, da_int n_cols, const double *X,
179 da_int ldx, da_int k, da_int use_precomputed_mean,
180 double *mean, double *moment) {
181 return da_moment_d(axis, n_rows, n_cols, X, ldx, k, use_precomputed_mean, mean,
182 moment);
183}
184
185inline da_status da_moment(da_axis axis, da_int n_rows, da_int n_cols, const float *X,
186 da_int ldx, da_int k, da_int use_precomputed_mean, float *mean,
187 float *moment) {
188 return da_moment_s(axis, n_rows, n_cols, X, ldx, k, use_precomputed_mean, mean,
189 moment);
190}
191
192inline da_status da_quantile(da_axis axis, da_int n_rows, da_int n_cols, const double *X,
193 da_int ldx, double q, double *quantile,
194 da_quantile_type quantile_type) {
195 return da_quantile_d(axis, n_rows, n_cols, X, ldx, q, quantile, quantile_type);
196}
197
198inline da_status da_quantile(da_axis axis, da_int n_rows, da_int n_cols, const float *X,
199 da_int ldx, float q, float *quantile,
200 da_quantile_type quantile_type) {
201 return da_quantile_s(axis, n_rows, n_cols, X, ldx, q, quantile, quantile_type);
202}
203
204inline da_status da_five_point_summary(da_axis axis, da_int n_rows, da_int n_cols,
205 const double *X, da_int ldx, double *minimum,
206 double *lower_hinge, double *median,
207 double *upper_hinge, double *maximum) {
208 return da_five_point_summary_d(axis, n_rows, n_cols, X, ldx, minimum, lower_hinge,
209 median, upper_hinge, maximum);
210}
211
212inline da_status da_five_point_summary(da_axis axis, da_int n_rows, da_int n_cols,
213 const float *X, da_int ldx, float *minimum,
214 float *lower_hinge, float *median,
215 float *upper_hinge, float *maximum) {
216 return da_five_point_summary_s(axis, n_rows, n_cols, X, ldx, minimum, lower_hinge,
217 median, upper_hinge, maximum);
218}
219
220inline da_status da_standardize(da_axis axis, da_int n_rows, da_int n_cols, double *X,
221 da_int ldx, da_int dof, da_int mode, double *shift,
222 double *scale) {
223 return da_standardize_d(axis, n_rows, n_cols, X, ldx, dof, mode, shift, scale);
224}
225
226inline da_status da_standardize(da_axis axis, da_int n_rows, da_int n_cols, float *X,
227 da_int ldx, da_int dof, da_int mode, float *shift,
228 float *scale) {
229 return da_standardize_s(axis, n_rows, n_cols, X, ldx, dof, mode, shift, scale);
230}
231
232inline da_status da_covariance_matrix(da_int n_rows, da_int n_cols, const float *X,
233 da_int ldx, da_int dof, float *cov, da_int ldcov) {
234 return da_covariance_matrix_s(n_rows, n_cols, X, ldx, dof, cov, ldcov);
235}
236
237inline da_status da_covariance_matrix(da_int n_rows, da_int n_cols, const double *X,
238 da_int ldx, da_int dof, double *cov, da_int ldcov) {
239 return da_covariance_matrix_d(n_rows, n_cols, X, ldx, dof, cov, ldcov);
240}
241
242inline da_status da_correlation_matrix(da_int n_rows, da_int n_cols, const float *X,
243 da_int ldx, float *corr, da_int ldcorr) {
244 return da_correlation_matrix_s(n_rows, n_cols, X, ldx, corr, ldcorr);
245}
246
247inline da_status da_correlation_matrix(da_int n_rows, da_int n_cols, const double *X,
248 da_int ldx, double *corr, da_int ldcorr) {
249 return da_correlation_matrix_d(n_rows, n_cols, X, ldx, corr, ldcorr);
250}
251
252/* Linear model overloaded functions */
253template <class T> da_status da_linmod_select_model(da_handle handle, linmod_model mod);
254template <> da_status da_linmod_select_model<double>(da_handle handle, linmod_model mod) {
255 return da_linmod_select_model_d(handle, mod);
256}
257template <> da_status da_linmod_select_model<float>(da_handle handle, linmod_model mod) {
258 return da_linmod_select_model_s(handle, mod);
259}
260
261inline da_status da_linmod_define_features(da_handle handle, da_int n_samples,
262 da_int n_features, float *X, float *y) {
263 return da_linmod_define_features_s(handle, n_samples, n_features, X, y);
264}
265inline da_status da_linmod_define_features(da_handle handle, da_int n_samples,
266 da_int n_features, double *X, double *y) {
267 return da_linmod_define_features_d(handle, n_samples, n_features, X, y);
268}
269
270template <class T> da_status da_linmod_fit(da_handle handle);
271template <> da_status da_linmod_fit<double>(da_handle handle) {
272 return da_linmod_fit_d(handle);
273}
274template <> da_status da_linmod_fit<float>(da_handle handle) {
275 return da_linmod_fit_s(handle);
276}
277
278template <class T>
279da_status da_linmod_fit_start(da_handle handle, da_int ncoef, T *coefs);
280template <>
281da_status da_linmod_fit_start<double>(da_handle handle, da_int ncoef, double *coefs) {
282 return da_linmod_fit_start_d(handle, ncoef, coefs);
283}
284template <>
285da_status da_linmod_fit_start<float>(da_handle handle, da_int ncoef, float *coefs) {
286 return da_linmod_fit_start_s(handle, ncoef, coefs);
287}
288
289inline da_status da_linmod_evaluate_model(da_handle handle, da_int nsamples, da_int nfeat,
290 double *X, double *predictions,
291 double *observations = nullptr,
292 double *loss = nullptr) {
293 return da_linmod_evaluate_model_d(handle, nsamples, nfeat, X, predictions,
294 observations, loss);
295}
296
297inline da_status da_linmod_evaluate_model(da_handle handle, da_int nsamples, da_int nfeat,
298 float *X, float *predictions,
299 float *observations = nullptr,
300 float *loss = nullptr) {
301 return da_linmod_evaluate_model_s(handle, nsamples, nfeat, X, predictions,
302 observations, loss);
303}
304
305/* Datastore overloaded functions */
306inline da_status da_data_extract_column(da_datastore store, da_int idx, da_int dim,
307 da_int *col) {
308 return da_data_extract_column_int(store, idx, dim, col);
309}
310inline da_status da_data_extract_column(da_datastore store, da_int idx, da_int dim,
311 float *col) {
312 return da_data_extract_column_real_s(store, idx, dim, col);
313}
314inline da_status da_data_extract_column(da_datastore store, da_int idx, da_int dim,
315 double *col) {
316 return da_data_extract_column_real_d(store, idx, dim, col);
317}
318inline da_status da_data_extract_column(da_datastore store, da_int idx, da_int dim,
319 uint8_t *col) {
320 return da_data_extract_column_uint8(store, idx, dim, col);
321}
322inline da_status da_data_extract_column(da_datastore store, da_int idx, da_int dim,
323 char **col) {
324 return da_data_extract_column_str(store, idx, dim, col);
325}
326
327inline da_status da_data_extract_selection(da_datastore store, const char *key,
328 da_int *data, da_int lddata) {
329 return da_data_extract_selection_int(store, key, data, lddata);
330}
331inline da_status da_data_extract_selection(da_datastore store, const char *key,
332 float *data, da_int lddata) {
333 return da_data_extract_selection_real_s(store, key, data, lddata);
334}
335inline da_status da_data_extract_selection(da_datastore store, const char *key,
336 double *data, da_int lddata) {
337 return da_data_extract_selection_real_d(store, key, data, lddata);
338}
339inline da_status da_data_extract_selection(da_datastore store, const char *key,
340 uint8_t *data, da_int lddata) {
341 return da_data_extract_selection_uint8(store, key, data, lddata);
342}
343
344/* PCA overloaded functions */
345inline da_status da_pca_set_data(da_handle handle, da_int n_samples, da_int n_features,
346 const double *A, da_int lda) {
347 return da_pca_set_data_d(handle, n_samples, n_features, A, lda);
348}
349
350inline da_status da_pca_set_data(da_handle handle, da_int n_samples, da_int n_features,
351 const float *A, da_int lda) {
352 return da_pca_set_data_s(handle, n_samples, n_features, A, lda);
353}
354
355template <class T> inline da_status da_pca_compute(da_handle handle);
356
357template <> inline da_status da_pca_compute<double>(da_handle handle) {
358 return da_pca_compute_d(handle);
359}
360
361template <> inline da_status da_pca_compute<float>(da_handle handle) {
362 return da_pca_compute_s(handle);
363}
364
365inline da_status da_pca_transform(da_handle handle, da_int m_samples, da_int m_features,
366 const double *X, da_int ldx, double *X_transform,
367 da_int ldx_transform) {
368 return da_pca_transform_d(handle, m_samples, m_features, X, ldx, X_transform,
369 ldx_transform);
370}
371
372inline da_status da_pca_transform(da_handle handle, da_int m_samples, da_int m_features,
373 const float *X, da_int ldx, float *X_transform,
374 da_int ldx_transform) {
375 return da_pca_transform_s(handle, m_samples, m_features, X, ldx, X_transform,
376 ldx_transform);
377}
378
379inline da_status da_pca_inverse_transform(da_handle handle, da_int k_samples,
380 da_int k_features, const double *Y, da_int ldy,
381 double *Y_inv_transform,
382 da_int ldy_inv_transform) {
383 return da_pca_inverse_transform_d(handle, k_samples, k_features, Y, ldy,
384 Y_inv_transform, ldy_inv_transform);
385}
386
387inline da_status da_pca_inverse_transform(da_handle handle, da_int k_samples,
388 da_int k_features, const float *Y, da_int ldy,
389 float *Y_inv_transform,
390 da_int ldy_inv_transform) {
391 return da_pca_inverse_transform_s(handle, k_samples, k_features, Y, ldy,
392 Y_inv_transform, ldy_inv_transform);
393}
394
395/* k-means overloaded functions */
396inline da_status da_kmeans_set_data(da_handle handle, da_int n_samples, da_int n_features,
397 const double *A, da_int lda) {
398 return da_kmeans_set_data_d(handle, n_samples, n_features, A, lda);
399}
400
401inline da_status da_kmeans_set_data(da_handle handle, da_int n_samples, da_int n_features,
402 const float *A, da_int lda) {
403 return da_kmeans_set_data_s(handle, n_samples, n_features, A, lda);
404}
405
406inline da_status da_kmeans_set_init_centres(da_handle handle, const float *C,
407 da_int ldc) {
408 return da_kmeans_set_init_centres_s(handle, C, ldc);
409}
410
411inline da_status da_kmeans_set_init_centres(da_handle handle, const double *C,
412 da_int ldc) {
413 return da_kmeans_set_init_centres_d(handle, C, ldc);
414}
415
416template <class T> inline da_status da_kmeans_compute(da_handle handle);
417
418template <> inline da_status da_kmeans_compute<double>(da_handle handle) {
419 return da_kmeans_compute_d(handle);
420}
421
422template <> inline da_status da_kmeans_compute<float>(da_handle handle) {
423 return da_kmeans_compute_s(handle);
424}
425
426inline da_status da_kmeans_transform(da_handle handle, da_int m_samples,
427 da_int m_features, const double *X, da_int ldx,
428 double *X_transform, da_int ldx_transform) {
429 return da_kmeans_transform_d(handle, m_samples, m_features, X, ldx, X_transform,
430 ldx_transform);
431}
432
433inline da_status da_kmeans_transform(da_handle handle, da_int m_samples,
434 da_int m_features, const float *X, da_int ldx,
435 float *X_transform, da_int ldx_transform) {
436 return da_kmeans_transform_s(handle, m_samples, m_features, X, ldx, X_transform,
437 ldx_transform);
438}
439
440inline da_status da_kmeans_predict(da_handle handle, da_int k_samples, da_int k_features,
441 const double *Y, da_int ldy, da_int *Y_labels) {
442 return da_kmeans_predict_d(handle, k_samples, k_features, Y, ldy, Y_labels);
443}
444
445inline da_status da_kmeans_predict(da_handle handle, da_int k_samples, da_int k_features,
446 const float *Y, da_int ldy, da_int *Y_labels) {
447 return da_kmeans_predict_s(handle, k_samples, k_features, Y, ldy, Y_labels);
448}
449
450/* Decision Forest overloaded functions */
451/* Decision tree */
452inline da_status da_tree_set_training_data(da_handle handle, da_int n_samples,
453 da_int n_features, da_int n_class, double *X,
454 da_int ldx, da_int *y) {
455 return da_tree_set_training_data_d(handle, n_samples, n_features, n_class, X, ldx, y);
456}
457inline da_status da_tree_set_training_data(da_handle handle, da_int n_samples,
458 da_int n_features, da_int n_class, float *X,
459 da_int ldx, da_int *y) {
460 return da_tree_set_training_data_s(handle, n_samples, n_features, n_class, X, ldx, y);
461}
462
463template <typename T> inline da_status da_tree_fit(da_handle handle);
464template <> inline da_status da_tree_fit<double>(da_handle handle) {
465 return da_tree_fit_d(handle);
466}
467template <> inline da_status da_tree_fit<float>(da_handle handle) {
468 return da_tree_fit_s(handle);
469}
470
471inline da_status da_tree_predict(da_handle handle, da_int n_samples, da_int n_features,
472 double *X_test, da_int ldx_test, da_int *y_pred) {
473 return da_tree_predict_d(handle, n_samples, n_features, X_test, ldx_test, y_pred);
474}
475inline da_status da_tree_predict(da_handle handle, da_int n_samples, da_int n_features,
476 float *X_test, da_int ldx_test, da_int *y_pred) {
477 return da_tree_predict_s(handle, n_samples, n_features, X_test, ldx_test, y_pred);
478}
479
480inline da_status da_tree_predict_proba(da_handle handle, da_int n_obs, da_int n_features,
481 double *X_test, da_int ldx_test, double *y_pred,
482 da_int n_class, da_int ldy) {
483 return da_tree_predict_proba_d(handle, n_obs, n_features, X_test, ldx_test, y_pred,
484 n_class, ldy);
485}
486
487inline da_status da_tree_predict_proba(da_handle handle, da_int n_obs, da_int n_features,
488 float *X_test, da_int ldx_test, float *y_pred,
489 da_int n_class, da_int ldy) {
490 return da_tree_predict_proba_s(handle, n_obs, n_features, X_test, ldx_test, y_pred,
491 n_class, ldy);
492}
493
494inline da_status da_tree_predict_log_proba(da_handle handle, da_int n_obs,
495 da_int n_features, double *X_test,
496 da_int ldx_test, double *y_pred,
497 da_int n_class, da_int ldy) {
498 return da_tree_predict_log_proba_d(handle, n_obs, n_features, X_test, ldx_test,
499 y_pred, n_class, ldy);
500}
501
502inline da_status da_tree_predict_log_proba(da_handle handle, da_int n_obs,
503 da_int n_features, float *X_test,
504 da_int ldx_test, float *y_pred, da_int n_class,
505 da_int ldy) {
506 return da_tree_predict_log_proba_s(handle, n_obs, n_features, X_test, ldx_test,
507 y_pred, n_class, ldy);
508}
509
510inline da_status da_tree_score(da_handle handle, da_int n_samples, da_int n_features,
511 double *X_test, da_int ldx_test, da_int *y_test,
512 double *mean_accuracy) {
513 return da_tree_score_d(handle, n_samples, n_features, X_test, ldx_test, y_test,
514 mean_accuracy);
515}
516inline da_status da_tree_score(da_handle handle, da_int n_samples, da_int n_features,
517 float *X_test, da_int ldx_test, da_int *y_test,
518 float *mean_accuracy) {
519 return da_tree_score_s(handle, n_samples, n_features, X_test, ldx_test, y_test,
520 mean_accuracy);
521}
522
523/* Random forest */
524inline da_status da_forest_set_training_data(da_handle handle, da_int n_samples,
525 da_int n_features, da_int n_class, double *X,
526 da_int ldx, da_int *y) {
527 return da_forest_set_training_data_d(handle, n_samples, n_features, n_class, X, ldx,
528 y);
529}
530inline da_status da_forest_set_training_data(da_handle handle, da_int n_samples,
531 da_int n_features, da_int n_class, float *X,
532 da_int ldx, da_int *y) {
533 return da_forest_set_training_data_s(handle, n_samples, n_features, n_class, X, ldx,
534 y);
535}
536
537template <typename T> inline da_status da_forest_fit(da_handle handle);
538template <> inline da_status da_forest_fit<double>(da_handle handle) {
539 return da_forest_fit_d(handle);
540}
541template <> inline da_status da_forest_fit<float>(da_handle handle) {
542 return da_forest_fit_s(handle);
543}
544
545inline da_status da_forest_predict(da_handle handle, da_int n_samples, da_int n_features,
546 double *X_test, da_int ldx_test, da_int *y_pred) {
547 return da_forest_predict_d(handle, n_samples, n_features, X_test, ldx_test, y_pred);
548}
549inline da_status da_forest_predict(da_handle handle, da_int n_samples, da_int n_features,
550 float *X_test, da_int ldx_test, da_int *y_pred) {
551 return da_forest_predict_s(handle, n_samples, n_features, X_test, ldx_test, y_pred);
552}
553
554inline da_status da_forest_predict_proba(da_handle handle, da_int n_obs,
555 da_int n_features, double *X_test,
556 da_int ldx_test, double *y_pred, da_int n_class,
557 da_int ldy) {
558 return da_forest_predict_proba_d(handle, n_obs, n_features, X_test, ldx_test, y_pred,
559 n_class, ldy);
560}
561
562inline da_status da_forest_predict_proba(da_handle handle, da_int n_obs,
563 da_int n_features, float *X_test,
564 da_int ldx_test, float *y_pred, da_int n_class,
565 da_int ldy) {
566 return da_forest_predict_proba_s(handle, n_obs, n_features, X_test, ldx_test, y_pred,
567 n_class, ldy);
568}
569
570inline da_status da_forest_predict_log_proba(da_handle handle, da_int n_obs,
571 da_int n_features, double *X_test,
572 da_int ldx_test, double *y_pred,
573 da_int n_class, da_int ldy) {
574 return da_forest_predict_log_proba_d(handle, n_obs, n_features, X_test, ldx_test,
575 y_pred, n_class, ldy);
576}
577
578inline da_status da_forest_predict_log_proba(da_handle handle, da_int n_obs,
579 da_int n_features, float *X_test,
580 da_int ldx_test, float *y_pred,
581 da_int n_class, da_int ldy) {
582 return da_forest_predict_log_proba_s(handle, n_obs, n_features, X_test, ldx_test,
583 y_pred, n_class, ldy);
584}
585
586inline da_status da_forest_score(da_handle handle, da_int n_samples, da_int n_features,
587 double *X_test, da_int ldx_test, da_int *y_test,
588 double *mean_accuracy) {
589 return da_forest_score_d(handle, n_samples, n_features, X_test, ldx_test, y_test,
590 mean_accuracy);
591}
592inline da_status da_forest_score(da_handle handle, da_int n_samples, da_int n_features,
593 float *X_test, da_int ldx_test, da_int *y_test,
594 float *mean_accuracy) {
595 return da_forest_score_s(handle, n_samples, n_features, X_test, ldx_test, y_test,
596 mean_accuracy);
597}
598
599inline da_status da_nlls_define_residuals(da_handle handle, da_int n_coef, da_int n_res,
600 da_resfun_t_d *resfun, da_resgrd_t_d *resgrd,
601 da_reshes_t_d *reshes, da_reshp_t_d *reshp) {
602 return da_nlls_define_residuals_d(handle, n_coef, n_res, resfun, resgrd, *reshes,
603 *reshp);
604}
605
606inline da_status da_nlls_define_residuals(da_handle handle, da_int n_coef, da_int n_res,
607 da_resfun_t_s *resfun, da_resgrd_t_s *resgrd,
608 da_reshes_t_s *reshes, da_reshp_t_s *reshp) {
609 return da_nlls_define_residuals_s(handle, n_coef, n_res, resfun, resgrd, reshes,
610 reshp);
611}
612
613inline da_status da_nlls_define_bounds(da_handle handle, da_int n_coef, double *lower,
614 double *upper) {
615 return da_nlls_define_bounds_d(handle, n_coef, lower, upper);
616}
617
618inline da_status da_nlls_define_bounds(da_handle handle, da_int n_coef, float *lower,
619 float *upper) {
620 return da_nlls_define_bounds_s(handle, n_coef, lower, upper);
621}
622
623inline da_status da_nlls_define_weights(da_handle handle, da_int n_coef,
624 double *weights) {
625 return da_nlls_define_weights_d(handle, n_coef, weights);
626}
627
628inline da_status da_nlls_define_weights(da_handle handle, da_int n_coef, float *weights) {
629 return da_nlls_define_weights_s(handle, n_coef, weights);
630}
631
632inline da_status da_nlls_fit(da_handle handle, da_int n_coef, double *coef, void *udata) {
633 return da_nlls_fit_d(handle, n_coef, coef, udata);
634}
635
636inline da_status da_nlls_fit(da_handle handle, da_int n_coefs, float *coefs,
637 void *udata) {
638 return da_nlls_fit_s(handle, n_coefs, coefs, udata);
639}
640
641/* Pairwise distances overloaded functions */
642inline da_status
643da_pairwise_distances(da_int m, da_int n, da_int k, const double *X, da_int ldx,
644 const double *Y, da_int ldy, double *D, da_int ldd,
645 da_metric metric = da_euclidean,
646 da_data_types force_all_finite = da_allow_infinite) {
647 return da_pairwise_distances_d(m, n, k, X, ldx, Y, ldy, D, ldd, metric,
648 force_all_finite);
649}
650
651inline da_status
652da_pairwise_distances(da_int m, da_int n, da_int k, const float *X, da_int ldx,
653 const float *Y, da_int ldy, float *D, da_int ldd,
654 da_metric metric = da_euclidean,
655 da_data_types force_all_finite = da_allow_infinite) {
656 return da_pairwise_distances_s(m, n, k, X, ldx, Y, ldy, D, ldd, metric,
657 force_all_finite);
658}
659
660/* k-NN for classification functions */
661inline da_status da_knn_set_training_data(da_handle handle, da_int n_samples,
662 da_int n_features, const double *X_train,
663 da_int ldx_train, const da_int *y_train) {
664 return da_knn_set_training_data_d(handle, n_samples, n_features, X_train, ldx_train,
665 y_train);
666}
667inline da_status da_knn_set_training_data(da_handle handle, da_int n_samples,
668 da_int n_features, const float *X_train,
669 da_int ldx_train, const da_int *y_train) {
670 return da_knn_set_training_data_s(handle, n_samples, n_features, X_train, ldx_train,
671 y_train);
672}
673inline da_status da_knn_kneighbors(da_handle handle, da_int n_queries, da_int n_features,
674 const double *X_test, da_int ldx_test, da_int *n_ind,
675 double *n_dist, da_int k, da_int return_distance) {
676 return da_knn_kneighbors_d(handle, n_queries, n_features, X_test, ldx_test, n_ind,
677 n_dist, k, return_distance);
678}
679
680inline da_status da_knn_kneighbors(da_handle handle, da_int n_queries, da_int n_features,
681 const float *X_test, da_int ldx_test, da_int *n_ind,
682 float *n_dist, da_int k, da_int return_distance) {
683 return da_knn_kneighbors_s(handle, n_queries, n_features, X_test, ldx_test, n_ind,
684 n_dist, k, return_distance);
685}
686
687template <class T>
688da_status da_knn_classes(da_handle handle, da_int *n_classes, da_int *classes);
689template <>
690da_status da_knn_classes<double>(da_handle handle, da_int *n_classes, da_int *classes) {
691 return da_knn_classes_d(handle, n_classes, classes);
692}
693template <>
694da_status da_knn_classes<float>(da_handle handle, da_int *n_classes, da_int *classes) {
695 return da_knn_classes_s(handle, n_classes, classes);
696}
697
698inline da_status da_knn_predict_proba(da_handle handle, da_int n_queries,
699 da_int n_features, const double *X_test,
700 da_int ldx_test, double *proba) {
701 return da_knn_predict_proba_d(handle, n_queries, n_features, X_test, ldx_test, proba);
702}
703
704inline da_status da_knn_predict_proba(da_handle handle, da_int n_queries,
705 da_int n_features, const float *X_test,
706 da_int ldx_test, float *proba) {
707 return da_knn_predict_proba_s(handle, n_queries, n_features, X_test, ldx_test, proba);
708}
709
710inline da_status da_knn_predict(da_handle handle, da_int n_queries, da_int n_features,
711 const double *X_test, da_int ldx_test, da_int *y_test) {
712 return da_knn_predict_d(handle, n_queries, n_features, X_test, ldx_test, y_test);
713}
714
715inline da_status da_knn_predict(da_handle handle, da_int n_queries, da_int n_features,
716 const float *X_test, da_int ldx_test, da_int *y_test) {
717 return da_knn_predict_s(handle, n_queries, n_features, X_test, ldx_test, y_test);
718}
719
720#endif // AOCLDA_CPP_OVERLOADS