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:

  1. 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.

  1. 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.

  1. Data processing. This is often split into several function calls:

  • initialize a da_handle struct, 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