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) 2025 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);
37inline da_status da_handle_get_result(da_handle handle, da_result query, da_int *dim,
38 double *result) {
39 return da_handle_get_result_d(handle, query, dim, result);
40}
41inline da_status da_handle_get_result(da_handle handle, da_result query, da_int *dim,
42 float *result) {
43 return da_handle_get_result_s(handle, query, dim, result);
44}
45inline da_status da_handle_get_result(da_handle handle, da_result query, da_int *dim,
46 da_int *result) {
47 return da_handle_get_result_int(handle, query, dim, result);
48}
49
50/* Options overloaded functions */
51inline da_status da_options_set(da_handle handle, const char *option, float value) {
52 return da_options_set_real_s(handle, option, value);
53}
54inline da_status da_options_set(da_handle handle, const char *option, double value) {
55 return da_options_set_real_d(handle, option, value);
56}
57inline da_status da_options_set(da_handle handle, const char *option, da_int value) {
58 return da_options_set_int(handle, option, value);
59}
60inline da_status da_options_set(da_handle handle, const char *option, const char *value) {
61 return da_options_set_string(handle, option, value);
62}
63inline da_status da_options_get(da_handle handle, const char *option, double *value) {
64 return da_options_get_real_d(handle, option, value);
65}
66inline da_status da_options_get(da_handle handle, const char *option, float *value) {
67 return da_options_get_real_s(handle, option, value);
68}
69inline da_status da_options_get(da_handle handle, const char *option, da_int *value) {
70 return da_options_get_int(handle, option, value);
71}
72inline da_status da_options_get(da_handle handle, const char *option, char *value,
73 da_int *lvalue) {
74 return da_options_get_string(handle, option, value, lvalue);
75}
76inline da_status da_options_get(da_handle handle, const char *option, char *value,
77 da_int *lvalue, da_int *key) {
78 return da_options_get_string_key(handle, option, value, lvalue, key);
79}
80
81inline da_status da_read_csv(da_datastore store, const char *filename, double **A,
82 da_int *n_rows, da_int *n_cols, char ***headings) {
83 return da_read_csv_d(store, filename, A, n_rows, n_cols, headings);
84}
85
86inline da_status da_read_csv(da_datastore store, const char *filename, float **A,
87 da_int *n_rows, da_int *n_cols, char ***headings) {
88 return da_read_csv_s(store, filename, A, n_rows, n_cols, headings);
89}
90
91inline da_status da_read_csv(da_datastore store, const char *filename, da_int **A,
92 da_int *n_rows, da_int *n_cols, char ***headings) {
93 return da_read_csv_int(store, filename, A, n_rows, n_cols, headings);
94}
95
96inline da_status da_read_csv(da_datastore store, const char *filename, uint8_t **A,
97 da_int *n_rows, da_int *n_cols, char ***headings) {
98 return da_read_csv_uint8(store, filename, A, n_rows, n_cols, headings);
99}
100
101inline da_status da_read_csv(da_datastore store, const char *filename, char ***A,
102 da_int *n_rows, da_int *n_cols, char ***headings) {
103 return da_read_csv_string(store, filename, A, n_rows, n_cols, headings);
104}
105
106/* Basic statistics overloaded functions */
107inline da_status da_mean(da_order order, da_axis axis, da_int n_rows, da_int n_cols,
108 const double *X, da_int ldx, double *mean) {
109 return da_mean_d(order, axis, n_rows, n_cols, X, ldx, mean);
110}
111
112inline da_status da_mean(da_order order, da_axis axis, da_int n_rows, da_int n_cols,
113 const float *X, da_int ldx, float *mean) {
114 return da_mean_s(order, axis, n_rows, n_cols, X, ldx, mean);
115}
116
117inline da_status da_harmonic_mean(da_order order, da_axis axis, da_int n_rows,
118 da_int n_cols, const double *X, da_int ldx,
119 double *harmonic_mean) {
120 return da_harmonic_mean_d(order, axis, n_rows, n_cols, X, ldx, harmonic_mean);
121}
122
123inline da_status da_harmonic_mean(da_order order, da_axis axis, da_int n_rows,
124 da_int n_cols, const float *X, da_int ldx,
125 float *harmonic_mean) {
126 return da_harmonic_mean_s(order, axis, n_rows, n_cols, X, ldx, harmonic_mean);
127}
128
129inline da_status da_geometric_mean(da_order order, da_axis axis, da_int n_rows,
130 da_int n_cols, const double *X, da_int ldx,
131 double *geometric_mean) {
132 return da_geometric_mean_d(order, axis, n_rows, n_cols, X, ldx, geometric_mean);
133}
134
135inline da_status da_geometric_mean(da_order order, da_axis axis, da_int n_rows,
136 da_int n_cols, const float *X, da_int ldx,
137 float *geometric_mean) {
138 return da_geometric_mean_s(order, axis, n_rows, n_cols, X, ldx, geometric_mean);
139}
140
141inline da_status da_variance(da_order order, da_axis axis, da_int n_rows, da_int n_cols,
142 const double *X, da_int ldx, da_int dof, double *mean,
143 double *variance) {
144 return da_variance_d(order, axis, n_rows, n_cols, X, ldx, dof, mean, variance);
145}
146
147inline da_status da_variance(da_order order, da_axis axis, da_int n_rows, da_int n_cols,
148 const float *X, da_int ldx, da_int dof, float *mean,
149 float *variance) {
150 return da_variance_s(order, axis, n_rows, n_cols, X, ldx, dof, mean, variance);
151}
152
153inline da_status da_skewness(da_order order, da_axis axis, da_int n_rows, da_int n_cols,
154 const double *X, da_int ldx, double *mean, double *variance,
155 double *skewness) {
156 return da_skewness_d(order, axis, n_rows, n_cols, X, ldx, mean, variance, skewness);
157}
158
159inline da_status da_skewness(da_order order, da_axis axis, da_int n_rows, da_int n_cols,
160 const float *X, da_int ldx, float *mean, float *variance,
161 float *skewness) {
162 return da_skewness_s(order, axis, n_rows, n_cols, X, ldx, mean, variance, skewness);
163}
164
165inline da_status da_kurtosis(da_order order, da_axis axis, da_int n_rows, da_int n_cols,
166 const double *X, da_int ldx, double *mean, double *variance,
167 double *kurtosis) {
168 return da_kurtosis_d(order, axis, n_rows, n_cols, X, ldx, mean, variance, kurtosis);
169}
170
171inline da_status da_kurtosis(da_order order, da_axis axis, da_int n_rows, da_int n_cols,
172 const float *X, da_int ldx, float *mean, float *variance,
173 float *kurtosis) {
174 return da_kurtosis_s(order, axis, n_rows, n_cols, X, ldx, mean, variance, kurtosis);
175}
176
177inline da_status da_moment(da_order order, da_axis axis, da_int n_rows, da_int n_cols,
178 const double *X, da_int ldx, da_int k,
179 da_int use_precomputed_mean, double *mean, double *moment) {
180 return da_moment_d(order, axis, n_rows, n_cols, X, ldx, k, use_precomputed_mean, mean,
181 moment);
182}
183
184inline da_status da_moment(da_order order, da_axis axis, da_int n_rows, da_int n_cols,
185 const float *X, da_int ldx, da_int k,
186 da_int use_precomputed_mean, float *mean, float *moment) {
187 return da_moment_s(order, axis, n_rows, n_cols, X, ldx, k, use_precomputed_mean, mean,
188 moment);
189}
190
191inline da_status da_quantile(da_order order, da_axis axis, da_int n_rows, da_int n_cols,
192 const double *X, da_int ldx, double q, double *quantile,
193 da_quantile_type quantile_type) {
194 return da_quantile_d(order, axis, n_rows, n_cols, X, ldx, q, quantile, quantile_type);
195}
196
197inline da_status da_quantile(da_order order, da_axis axis, da_int n_rows, da_int n_cols,
198 const float *X, da_int ldx, float q, float *quantile,
199 da_quantile_type quantile_type) {
200 return da_quantile_s(order, axis, n_rows, n_cols, X, ldx, q, quantile, quantile_type);
201}
202
203inline da_status da_five_point_summary(da_order order, da_axis axis, da_int n_rows,
204 da_int n_cols, const double *X, da_int ldx,
205 double *minimum, double *lower_hinge,
206 double *median, double *upper_hinge,
207 double *maximum) {
208 return da_five_point_summary_d(order, axis, n_rows, n_cols, X, ldx, minimum,
209 lower_hinge, median, upper_hinge, maximum);
210}
211
212inline da_status da_five_point_summary(da_order order, da_axis axis, da_int n_rows,
213 da_int n_cols, const float *X, da_int ldx,
214 float *minimum, float *lower_hinge, float *median,
215 float *upper_hinge, float *maximum) {
216 return da_five_point_summary_s(order, axis, n_rows, n_cols, X, ldx, minimum,
217 lower_hinge, median, upper_hinge, maximum);
218}
219
220inline da_status da_standardize(da_order order, da_axis axis, da_int n_rows,
221 da_int n_cols, double *X, da_int ldx, da_int dof,
222 da_int mode, double *shift, double *scale) {
223 return da_standardize_d(order, axis, n_rows, n_cols, X, ldx, dof, mode, shift, scale);
224}
225
226inline da_status da_standardize(da_order order, da_axis axis, da_int n_rows,
227 da_int n_cols, float *X, da_int ldx, da_int dof,
228 da_int mode, float *shift, float *scale) {
229 return da_standardize_s(order, axis, n_rows, n_cols, X, ldx, dof, mode, shift, scale);
230}
231
232inline da_status da_covariance_matrix(da_order order, da_int n_rows, da_int n_cols,
233 const float *X, da_int ldx, da_int dof, float *cov,
234 da_int ldcov, da_int assume_centered) {
235 return da_covariance_matrix_s(order, n_rows, n_cols, X, ldx, dof, cov, ldcov,
236 assume_centered);
237}
238
239inline da_status da_covariance_matrix(da_order order, da_int n_rows, da_int n_cols,
240 const double *X, da_int ldx, da_int dof,
241 double *cov, da_int ldcov, da_int assume_centered) {
242 return da_covariance_matrix_d(order, n_rows, n_cols, X, ldx, dof, cov, ldcov,
243 assume_centered);
244}
245
246inline da_status da_correlation_matrix(da_order order, da_int n_rows, da_int n_cols,
247 const float *X, da_int ldx, float *corr,
248 da_int ldcorr) {
249 return da_correlation_matrix_s(order, n_rows, n_cols, X, ldx, corr, ldcorr);
250}
251
252inline da_status da_correlation_matrix(da_order order, da_int n_rows, da_int n_cols,
253 const double *X, da_int ldx, double *corr,
254 da_int ldcorr) {
255 return da_correlation_matrix_d(order, n_rows, n_cols, X, ldx, corr, ldcorr);
256}
257
258/* Linear model overloaded functions */
259template <class T> da_status da_linmod_select_model(da_handle handle, linmod_model mod);
260
261inline da_status da_linmod_define_features(da_handle handle, da_int n_samples,
262 da_int n_features, const float *X, da_int ldx,
263 const float *y) {
264 return da_linmod_define_features_s(handle, n_samples, n_features, X, ldx, y);
265}
266inline da_status da_linmod_define_features(da_handle handle, da_int n_samples,
267 da_int n_features, const double *X, da_int ldx,
268 const double *y) {
269 return da_linmod_define_features_d(handle, n_samples, n_features, X, ldx, y);
270}
271
272template <class T> da_status da_linmod_fit(da_handle handle);
273
274template <class T>
275da_status da_linmod_fit_start(da_handle handle, da_int ncoef, const T *coefs);
276
277inline da_status da_linmod_evaluate_model(da_handle handle, da_int n_samples,
278 da_int n_features, const double *X, da_int ldx,
279 double *predictions,
280 double *observations = nullptr,
281 double *loss = nullptr) {
282 return da_linmod_evaluate_model_d(handle, n_samples, n_features, X, ldx, predictions,
283 observations, loss);
284}
285
286inline da_status da_linmod_evaluate_model(da_handle handle, da_int n_samples,
287 da_int n_features, const float *X, da_int ldx,
288 float *predictions,
289 float *observations = nullptr,
290 float *loss = nullptr) {
291 return da_linmod_evaluate_model_s(handle, n_samples, n_features, X, ldx, predictions,
292 observations, loss);
293}
294
295/* Datastore overloaded functions */
296inline da_status da_data_extract_column(da_datastore store, da_int idx, da_int dim,
297 da_int *col) {
298 return da_data_extract_column_int(store, idx, dim, col);
299}
300inline da_status da_data_extract_column(da_datastore store, da_int idx, da_int dim,
301 float *col) {
302 return da_data_extract_column_real_s(store, idx, dim, col);
303}
304inline da_status da_data_extract_column(da_datastore store, da_int idx, da_int dim,
305 double *col) {
306 return da_data_extract_column_real_d(store, idx, dim, col);
307}
308inline da_status da_data_extract_column(da_datastore store, da_int idx, da_int dim,
309 uint8_t *col) {
310 return da_data_extract_column_uint8(store, idx, dim, col);
311}
312inline da_status da_data_extract_column(da_datastore store, da_int idx, da_int dim,
313 char **col) {
314 return da_data_extract_column_str(store, idx, dim, col);
315}
316
317inline da_status da_data_extract_selection(da_datastore store, const char *key,
318 da_order order, da_int *data, da_int lddata) {
319 return da_data_extract_selection_int(store, key, order, data, lddata);
320}
321inline da_status da_data_extract_selection(da_datastore store, const char *key,
322 da_order order, float *data, da_int lddata) {
323 return da_data_extract_selection_real_s(store, key, order, data, lddata);
324}
325inline da_status da_data_extract_selection(da_datastore store, const char *key,
326 da_order order, double *data, da_int lddata) {
327 return da_data_extract_selection_real_d(store, key, order, data, lddata);
328}
329inline da_status da_data_extract_selection(da_datastore store, const char *key,
330 da_order order, uint8_t *data, da_int lddata) {
331 return da_data_extract_selection_uint8(store, key, order, data, lddata);
332}
333
334/* PCA overloaded functions */
335inline da_status da_pca_set_data(da_handle handle, da_int n_samples, da_int n_features,
336 const double *A, da_int lda) {
337 return da_pca_set_data_d(handle, n_samples, n_features, A, lda);
338}
339
340inline da_status da_pca_set_data(da_handle handle, da_int n_samples, da_int n_features,
341 const float *A, da_int lda) {
342 return da_pca_set_data_s(handle, n_samples, n_features, A, lda);
343}
344
345template <class T> da_status da_pca_compute(da_handle handle);
346
347inline da_status da_pca_transform(da_handle handle, da_int m_samples, da_int m_features,
348 const double *X, da_int ldx, double *X_transform,
349 da_int ldx_transform) {
350 return da_pca_transform_d(handle, m_samples, m_features, X, ldx, X_transform,
351 ldx_transform);
352}
353
354inline da_status da_pca_transform(da_handle handle, da_int m_samples, da_int m_features,
355 const float *X, da_int ldx, float *X_transform,
356 da_int ldx_transform) {
357 return da_pca_transform_s(handle, m_samples, m_features, X, ldx, X_transform,
358 ldx_transform);
359}
360
361inline da_status da_pca_inverse_transform(da_handle handle, da_int k_samples,
362 da_int k_features, const double *Y, da_int ldy,
363 double *Y_inv_transform,
364 da_int ldy_inv_transform) {
365 return da_pca_inverse_transform_d(handle, k_samples, k_features, Y, ldy,
366 Y_inv_transform, ldy_inv_transform);
367}
368
369inline da_status da_pca_inverse_transform(da_handle handle, da_int k_samples,
370 da_int k_features, const float *Y, da_int ldy,
371 float *Y_inv_transform,
372 da_int ldy_inv_transform) {
373 return da_pca_inverse_transform_s(handle, k_samples, k_features, Y, ldy,
374 Y_inv_transform, ldy_inv_transform);
375}
376
377/* k-means overloaded functions */
378inline da_status da_kmeans_set_data(da_handle handle, da_int n_samples, da_int n_features,
379 const double *A, da_int lda) {
380 return da_kmeans_set_data_d(handle, n_samples, n_features, A, lda);
381}
382
383inline da_status da_kmeans_set_data(da_handle handle, da_int n_samples, da_int n_features,
384 const float *A, da_int lda) {
385 return da_kmeans_set_data_s(handle, n_samples, n_features, A, lda);
386}
387
388inline da_status da_kmeans_set_init_centres(da_handle handle, const float *C,
389 da_int ldc) {
390 return da_kmeans_set_init_centres_s(handle, C, ldc);
391}
392
393inline da_status da_kmeans_set_init_centres(da_handle handle, const double *C,
394 da_int ldc) {
395 return da_kmeans_set_init_centres_d(handle, C, ldc);
396}
397
398template <class T> da_status da_kmeans_compute(da_handle handle);
399
400inline da_status da_kmeans_transform(da_handle handle, da_int m_samples,
401 da_int m_features, const double *X, da_int ldx,
402 double *X_transform, da_int ldx_transform) {
403 return da_kmeans_transform_d(handle, m_samples, m_features, X, ldx, X_transform,
404 ldx_transform);
405}
406
407inline da_status da_kmeans_transform(da_handle handle, da_int m_samples,
408 da_int m_features, const float *X, da_int ldx,
409 float *X_transform, da_int ldx_transform) {
410 return da_kmeans_transform_s(handle, m_samples, m_features, X, ldx, X_transform,
411 ldx_transform);
412}
413
414inline da_status da_kmeans_predict(da_handle handle, da_int k_samples, da_int k_features,
415 const double *Y, da_int ldy, da_int *Y_labels) {
416 return da_kmeans_predict_d(handle, k_samples, k_features, Y, ldy, Y_labels);
417}
418
419inline da_status da_kmeans_predict(da_handle handle, da_int k_samples, da_int k_features,
420 const float *Y, da_int ldy, da_int *Y_labels) {
421 return da_kmeans_predict_s(handle, k_samples, k_features, Y, ldy, Y_labels);
422}
423
424/* DBSCAN overloaded functions */
425inline da_status da_dbscan_set_data(da_handle handle, da_int n_samples, da_int n_features,
426 const double *A, da_int lda) {
427 return da_dbscan_set_data_d(handle, n_samples, n_features, A, lda);
428}
429
430inline da_status da_dbscan_set_data(da_handle handle, da_int n_samples, da_int n_features,
431 const float *A, da_int lda) {
432 return da_dbscan_set_data_s(handle, n_samples, n_features, A, lda);
433}
434
435template <class T> da_status da_dbscan_compute(da_handle handle);
436
437/* Decision Forest overloaded functions */
438/* Decision tree */
439inline da_status da_tree_set_training_data(da_handle handle, da_int n_samples,
440 da_int n_features, da_int n_class,
441 const double *X, da_int ldx, const da_int *y,
442 const da_int *categorical_feat = nullptr) {
443 return da_tree_set_training_data_d(handle, n_samples, n_features, n_class, X, ldx, y,
444 categorical_feat);
445}
446inline da_status da_tree_set_training_data(da_handle handle, da_int n_samples,
447 da_int n_features, da_int n_class,
448 const float *X, da_int ldx, const da_int *y,
449 const da_int *categorical_feat = nullptr) {
450 return da_tree_set_training_data_s(handle, n_samples, n_features, n_class, X, ldx, y,
451 categorical_feat);
452}
453
454template <typename T> da_status da_tree_fit(da_handle handle);
455
456inline da_status da_tree_predict(da_handle handle, da_int n_samples, da_int n_features,
457 const double *X_test, da_int ldx_test, da_int *y_pred) {
458 return da_tree_predict_d(handle, n_samples, n_features, X_test, ldx_test, y_pred);
459}
460inline da_status da_tree_predict(da_handle handle, da_int n_samples, da_int n_features,
461 const float *X_test, da_int ldx_test, da_int *y_pred) {
462 return da_tree_predict_s(handle, n_samples, n_features, X_test, ldx_test, y_pred);
463}
464
465inline da_status da_tree_predict_proba(da_handle handle, da_int n_obs, da_int n_features,
466 const double *X_test, da_int ldx_test,
467 double *y_pred, da_int n_class, da_int ldy) {
468 return da_tree_predict_proba_d(handle, n_obs, n_features, X_test, ldx_test, y_pred,
469 n_class, ldy);
470}
471
472inline da_status da_tree_predict_proba(da_handle handle, da_int n_obs, da_int n_features,
473 const float *X_test, da_int ldx_test,
474 float *y_pred, da_int n_class, da_int ldy) {
475 return da_tree_predict_proba_s(handle, n_obs, n_features, X_test, ldx_test, y_pred,
476 n_class, ldy);
477}
478
479inline da_status da_tree_predict_log_proba(da_handle handle, da_int n_obs,
480 da_int n_features, const double *X_test,
481 da_int ldx_test, double *y_pred,
482 da_int n_class, da_int ldy) {
483 return da_tree_predict_log_proba_d(handle, n_obs, n_features, X_test, ldx_test,
484 y_pred, n_class, ldy);
485}
486
487inline da_status da_tree_predict_log_proba(da_handle handle, da_int n_obs,
488 da_int n_features, const float *X_test,
489 da_int ldx_test, float *y_pred, da_int n_class,
490 da_int ldy) {
491 return da_tree_predict_log_proba_s(handle, n_obs, n_features, X_test, ldx_test,
492 y_pred, n_class, ldy);
493}
494
495inline da_status da_tree_score(da_handle handle, da_int n_samples, da_int n_features,
496 const double *X_test, da_int ldx_test,
497 const da_int *y_test, double *mean_accuracy) {
498 return da_tree_score_d(handle, n_samples, n_features, X_test, ldx_test, y_test,
499 mean_accuracy);
500}
501inline da_status da_tree_score(da_handle handle, da_int n_samples, da_int n_features,
502 const float *X_test, da_int ldx_test, const da_int *y_test,
503 float *mean_accuracy) {
504 return da_tree_score_s(handle, n_samples, n_features, X_test, ldx_test, y_test,
505 mean_accuracy);
506}
507
508/* Random forest */
509inline da_status da_forest_set_training_data(da_handle handle, da_int n_samples,
510 da_int n_features, da_int n_class,
511 const double *X, da_int ldx, const da_int *y,
512 const da_int *categorical_feat = nullptr) {
513 return da_forest_set_training_data_d(handle, n_samples, n_features, n_class, X, ldx,
514 y, categorical_feat);
515}
516inline da_status da_forest_set_training_data(da_handle handle, da_int n_samples,
517 da_int n_features, da_int n_class,
518 const float *X, da_int ldx, const da_int *y,
519 const da_int *categorical_feat = nullptr) {
520 return da_forest_set_training_data_s(handle, n_samples, n_features, n_class, X, ldx,
521 y, categorical_feat);
522}
523
524template <typename T> da_status da_forest_fit(da_handle handle);
525
526inline da_status da_forest_predict(da_handle handle, da_int n_samples, da_int n_features,
527 const double *X_test, da_int ldx_test,
528 da_int *y_pred) {
529 return da_forest_predict_d(handle, n_samples, n_features, X_test, ldx_test, y_pred);
530}
531inline da_status da_forest_predict(da_handle handle, da_int n_samples, da_int n_features,
532 const float *X_test, da_int ldx_test, da_int *y_pred) {
533 return da_forest_predict_s(handle, n_samples, n_features, X_test, ldx_test, y_pred);
534}
535
536inline da_status da_forest_predict_proba(da_handle handle, da_int n_obs,
537 da_int n_features, const double *X_test,
538 da_int ldx_test, double *y_pred, da_int n_class,
539 da_int ldy) {
540 return da_forest_predict_proba_d(handle, n_obs, n_features, X_test, ldx_test, y_pred,
541 n_class, ldy);
542}
543
544inline da_status da_forest_predict_proba(da_handle handle, da_int n_obs,
545 da_int n_features, const float *X_test,
546 da_int ldx_test, float *y_pred, da_int n_class,
547 da_int ldy) {
548 return da_forest_predict_proba_s(handle, n_obs, n_features, X_test, ldx_test, y_pred,
549 n_class, ldy);
550}
551
552inline da_status da_forest_predict_log_proba(da_handle handle, da_int n_obs,
553 da_int n_features, const double *X_test,
554 da_int ldx_test, double *y_pred,
555 da_int n_class, da_int ldy) {
556 return da_forest_predict_log_proba_d(handle, n_obs, n_features, X_test, ldx_test,
557 y_pred, n_class, ldy);
558}
559
560inline da_status da_forest_predict_log_proba(da_handle handle, da_int n_obs,
561 da_int n_features, const float *X_test,
562 da_int ldx_test, float *y_pred,
563 da_int n_class, da_int ldy) {
564 return da_forest_predict_log_proba_s(handle, n_obs, n_features, X_test, ldx_test,
565 y_pred, n_class, ldy);
566}
567
568inline da_status da_forest_score(da_handle handle, da_int n_samples, da_int n_features,
569 const double *X_test, da_int ldx_test,
570 const da_int *y_test, double *mean_accuracy) {
571 return da_forest_score_d(handle, n_samples, n_features, X_test, ldx_test, y_test,
572 mean_accuracy);
573}
574inline da_status da_forest_score(da_handle handle, da_int n_samples, da_int n_features,
575 const float *X_test, da_int ldx_test,
576 const da_int *y_test, float *mean_accuracy) {
577 return da_forest_score_s(handle, n_samples, n_features, X_test, ldx_test, y_test,
578 mean_accuracy);
579}
580
581inline da_status da_nlls_define_residuals(da_handle handle, da_int n_coef, da_int n_res,
582 da_resfun_t_d *resfun, da_resgrd_t_d *resgrd,
583 da_reshes_t_d *reshes, da_reshp_t_d *reshp) {
584 return da_nlls_define_residuals_d(handle, n_coef, n_res, resfun, resgrd, *reshes,
585 *reshp);
586}
587
588inline da_status da_nlls_define_residuals(da_handle handle, da_int n_coef, da_int n_res,
589 da_resfun_t_s *resfun, da_resgrd_t_s *resgrd,
590 da_reshes_t_s *reshes, da_reshp_t_s *reshp) {
591 return da_nlls_define_residuals_s(handle, n_coef, n_res, resfun, resgrd, reshes,
592 reshp);
593}
594
595inline da_status da_nlls_define_bounds(da_handle handle, da_int n_coef, double *lower,
596 double *upper) {
597 return da_nlls_define_bounds_d(handle, n_coef, lower, upper);
598}
599
600inline da_status da_nlls_define_bounds(da_handle handle, da_int n_coef, float *lower,
601 float *upper) {
602 return da_nlls_define_bounds_s(handle, n_coef, lower, upper);
603}
604
605inline da_status da_nlls_define_weights(da_handle handle, da_int n_coef,
606 double *weights) {
607 return da_nlls_define_weights_d(handle, n_coef, weights);
608}
609
610inline da_status da_nlls_define_weights(da_handle handle, da_int n_coef, float *weights) {
611 return da_nlls_define_weights_s(handle, n_coef, weights);
612}
613
614inline da_status da_nlls_fit(da_handle handle, da_int n_coef, double *coef, void *udata) {
615 return da_nlls_fit_d(handle, n_coef, coef, udata);
616}
617
618inline da_status da_nlls_fit(da_handle handle, da_int n_coefs, float *coefs,
619 void *udata) {
620 return da_nlls_fit_s(handle, n_coefs, coefs, udata);
621}
622
623/* Pairwise distances overloaded functions */
624inline da_status da_pairwise_distances(da_order order, da_int m, da_int n, da_int k,
625 const double *X, da_int ldx, const double *Y,
626 da_int ldy, double *D, da_int ldd, double p,
627 da_metric metric = da_euclidean) {
628 return da_pairwise_distances_d(order, m, n, k, X, ldx, Y, ldy, D, ldd, p, metric);
629}
630
631inline da_status da_pairwise_distances(da_order order, da_int m, da_int n, da_int k,
632 const float *X, da_int ldx, const float *Y,
633 da_int ldy, float *D, da_int ldd, float p,
634 da_metric metric = da_euclidean) {
635 return da_pairwise_distances_s(order, m, n, k, X, ldx, Y, ldy, D, ldd, p, metric);
636}
637
638/* k-NN for classification and regression functions */
639inline da_status da_nn_classifier_set_training_data(da_handle handle, da_int n_samples,
640 da_int n_features,
641 const double *X_train,
642 da_int ldx_train,
643 const da_int *y_train) {
644 return da_nn_classifier_set_training_data_d(handle, n_samples, n_features, X_train,
645 ldx_train, y_train);
646}
647inline da_status da_nn_classifier_set_training_data(da_handle handle, da_int n_samples,
648 da_int n_features,
649 const float *X_train,
650 da_int ldx_train,
651 const da_int *y_train) {
652 return da_nn_classifier_set_training_data_s(handle, n_samples, n_features, X_train,
653 ldx_train, y_train);
654}
655inline da_status da_nn_regressor_set_training_data(da_handle handle, da_int n_samples,
656 da_int n_features,
657 const double *X_train,
658 da_int ldx_train,
659 const double *y_train) {
660 return da_nn_regressor_set_training_data_d(handle, n_samples, n_features, X_train,
661 ldx_train, y_train);
662}
663inline da_status da_nn_regressor_set_training_data(da_handle handle, da_int n_samples,
664 da_int n_features,
665 const float *X_train, da_int ldx_train,
666 const float *y_train) {
667 return da_nn_regressor_set_training_data_s(handle, n_samples, n_features, X_train,
668 ldx_train, y_train);
669}
670inline da_status da_nn_kneighbors(da_handle handle, da_int n_queries, da_int n_features,
671 const double *X_test, da_int ldx_test, da_int *n_ind,
672 double *n_dist, da_int k, da_int return_distance) {
673 return da_nn_kneighbors_d(handle, n_queries, n_features, X_test, ldx_test, n_ind,
674 n_dist, k, return_distance);
675}
676
677inline da_status da_nn_kneighbors(da_handle handle, da_int n_queries, da_int n_features,
678 const float *X_test, da_int ldx_test, da_int *n_ind,
679 float *n_dist, da_int k, da_int return_distance) {
680 return da_nn_kneighbors_s(handle, n_queries, n_features, X_test, ldx_test, n_ind,
681 n_dist, k, return_distance);
682}
683
684template <class T>
685da_status da_nn_classes(da_handle handle, da_int *n_classes, da_int *classes);
686
687inline da_status da_nn_classifier_predict_proba(da_handle handle, da_int n_queries,
688 da_int n_features, const double *X_test,
689 da_int ldx_test, double *proba) {
690 return da_nn_classifier_predict_proba_d(handle, n_queries, n_features, X_test,
691 ldx_test, proba);
692}
693
694inline da_status da_nn_classifier_predict_proba(da_handle handle, da_int n_queries,
695 da_int n_features, const float *X_test,
696 da_int ldx_test, float *proba) {
697 return da_nn_classifier_predict_proba_s(handle, n_queries, n_features, X_test,
698 ldx_test, proba);
699}
700
701inline da_status da_nn_classifier_predict(da_handle handle, da_int n_queries,
702 da_int n_features, const double *X_test,
703 da_int ldx_test, da_int *y_test) {
704 return da_nn_classifier_predict_d(handle, n_queries, n_features, X_test, ldx_test,
705 y_test);
706}
707
708inline da_status da_nn_classifier_predict(da_handle handle, da_int n_queries,
709 da_int n_features, const float *X_test,
710 da_int ldx_test, da_int *y_test) {
711 return da_nn_classifier_predict_s(handle, n_queries, n_features, X_test, ldx_test,
712 y_test);
713}
714inline da_status da_nn_regressor_predict(da_handle handle, da_int n_queries,
715 da_int n_features, const double *X_test,
716 da_int ldx_test, double *y_test) {
717 return da_nn_regressor_predict_d(handle, n_queries, n_features, X_test, ldx_test,
718 y_test);
719}
720
721inline da_status da_nn_regressor_predict(da_handle handle, da_int n_queries,
722 da_int n_features, const float *X_test,
723 da_int ldx_test, float *y_test) {
724 return da_nn_regressor_predict_s(handle, n_queries, n_features, X_test, ldx_test,
725 y_test);
726}
727
728inline da_status da_nn_radius_neighbors(da_handle handle, da_int n_queries,
729 da_int n_features, const double *X_test,
730 da_int ldx_test, double radius,
731 da_int return_distance, da_int sort_results) {
732 return da_nn_radius_neighbors_d(handle, n_queries, n_features, X_test, ldx_test,
733 radius, return_distance, sort_results);
734}
735
736inline da_status da_nn_radius_neighbors(da_handle handle, da_int n_queries,
737 da_int n_features, const float *X_test,
738 da_int ldx_test, float radius,
739 da_int return_distance, da_int sort_results) {
740 return da_nn_radius_neighbors_s(handle, n_queries, n_features, X_test, ldx_test,
741 radius, return_distance, sort_results);
742}
743
744/* Utility overloaded functions */
745inline da_status da_check_data(da_order order, da_int n_rows, da_int n_cols,
746 const double *X, da_int ldx) {
747 return da_check_data_d(order, n_rows, n_cols, X, ldx);
748}
749inline da_status da_check_data(da_order order, da_int n_rows, da_int n_cols,
750 const float *X, da_int ldx) {
751 return da_check_data_s(order, n_rows, n_cols, X, ldx);
752}
753inline da_status da_switch_order_copy(da_order order_X, da_int n_rows, da_int n_cols,
754 const float *X, da_int ldx, float *Y, da_int ldy) {
755 return da_switch_order_copy_s(order_X, n_rows, n_cols, X, ldx, Y, ldy);
756}
757inline da_status da_switch_order_copy(da_order order_X, da_int n_rows, da_int n_cols,
758 const double *X, da_int ldx, double *Y,
759 da_int ldy) {
760 return da_switch_order_copy_d(order_X, n_rows, n_cols, X, ldx, Y, ldy);
761}
762inline da_status da_switch_order_in_place(da_order order_X_in, da_int n_rows,
763 da_int n_cols, float *X, da_int ldx_in,
764 da_int ldx_out) {
765 return da_switch_order_in_place_s(order_X_in, n_rows, n_cols, X, ldx_in, ldx_out);
766}
767inline da_status da_switch_order_in_place(da_order order_X_in, da_int n_rows,
768 da_int n_cols, double *X, da_int ldx_in,
769 da_int ldx_out) {
770 return da_switch_order_in_place_d(order_X_in, n_rows, n_cols, X, ldx_in, ldx_out);
771}
772
773inline da_status da_get_shuffled_indices(da_int m, da_int seed, da_int train_size,
774 da_int test_size, da_int fp_precision,
775 const da_int *classes, da_int *shuffle_array) {
776 return da_get_shuffled_indices_int(m, seed, train_size, test_size, fp_precision,
777 classes, shuffle_array);
778};
779inline da_status da_get_shuffled_indices(da_int m, da_int seed, da_int train_size,
780 da_int test_size, da_int fp_precision,
781 const float *classes, da_int *shuffle_array) {
782 return da_get_shuffled_indices_s(m, seed, train_size, test_size, fp_precision,
783 classes, shuffle_array);
784};
785inline da_status da_get_shuffled_indices(da_int m, da_int seed, da_int train_size,
786 da_int test_size, da_int fp_precision,
787 const double *classes, da_int *shuffle_array) {
788 return da_get_shuffled_indices_d(m, seed, train_size, test_size, fp_precision,
789 classes, shuffle_array);
790};
791
792inline da_status da_train_test_split(da_order order, da_int m, da_int n, const da_int *X,
793 da_int ldx, da_int train_size, da_int test_size,
794 const da_int *shuffle_array, da_int *X_train,
795 da_int ldx_train, da_int *X_test, da_int ldx_test) {
796 return da_train_test_split_int(order, m, n, X, ldx, train_size, test_size,
797 shuffle_array, X_train, ldx_train, X_test, ldx_test);
798}
799inline da_status da_train_test_split(da_order order, da_int m, da_int n, const double *X,
800 da_int ldx, da_int train_size, da_int test_size,
801 const da_int *shuffle_array, double *X_train,
802 da_int ldx_train, double *X_test, da_int ldx_test) {
803 return da_train_test_split_d(order, m, n, X, ldx, train_size, test_size,
804 shuffle_array, X_train, ldx_train, X_test, ldx_test);
805}
806inline da_status da_train_test_split(da_order order, da_int m, da_int n, const float *X,
807 da_int ldx, da_int train_size, da_int test_size,
808 const da_int *shuffle_array, float *X_train,
809 da_int ldx_train, float *X_test, da_int ldx_test) {
810 return da_train_test_split_s(order, m, n, X, ldx, train_size, test_size,
811 shuffle_array, X_train, ldx_train, X_test, ldx_test);
812}
813
814/* Kernel functions */
815inline da_status da_rbf_kernel(da_order order, da_int m, da_int n, da_int k,
816 const double *X, da_int ldx, const double *Y, da_int ldy,
817 double *D, da_int ldd, double gamma) {
818 return da_rbf_kernel_d(order, m, n, k, X, ldx, Y, ldy, D, ldd, gamma);
819}
820
821inline da_status da_rbf_kernel(da_order order, da_int m, da_int n, da_int k,
822 const float *X, da_int ldx, const float *Y, da_int ldy,
823 float *D, da_int ldd, float gamma) {
824 return da_rbf_kernel_s(order, m, n, k, X, ldx, Y, ldy, D, ldd, gamma);
825}
826inline da_status da_linear_kernel(da_order order, da_int m, da_int n, da_int k,
827 const double *X, da_int ldx, const double *Y,
828 da_int ldy, double *D, da_int ldd) {
829 return da_linear_kernel_d(order, m, n, k, X, ldx, Y, ldy, D, ldd);
830}
831
832inline da_status da_linear_kernel(da_order order, da_int m, da_int n, da_int k,
833 const float *X, da_int ldx, const float *Y, da_int ldy,
834 float *D, da_int ldd) {
835 return da_linear_kernel_s(order, m, n, k, X, ldx, Y, ldy, D, ldd);
836}
837inline da_status da_polynomial_kernel(da_order order, da_int m, da_int n, da_int k,
838 const double *X, da_int ldx, const double *Y,
839 da_int ldy, double *D, da_int ldd, double gamma,
840 da_int degree, double coef0) {
841 return da_polynomial_kernel_d(order, m, n, k, X, ldx, Y, ldy, D, ldd, gamma, degree,
842 coef0);
843}
844inline da_status da_polynomial_kernel(da_order order, da_int m, da_int n, da_int k,
845 const float *X, da_int ldx, const float *Y,
846 da_int ldy, float *D, da_int ldd, float gamma,
847 da_int degree, float coef0) {
848 return da_polynomial_kernel_s(order, m, n, k, X, ldx, Y, ldy, D, ldd, gamma, degree,
849 coef0);
850}
851inline da_status da_sigmoid_kernel(da_order order, da_int m, da_int n, da_int k,
852 const double *X, da_int ldx, const double *Y,
853 da_int ldy, double *D, da_int ldd, double gamma,
854 double coef0) {
855 return da_sigmoid_kernel_d(order, m, n, k, X, ldx, Y, ldy, D, ldd, gamma, coef0);
856}
857inline da_status da_sigmoid_kernel(da_order order, da_int m, da_int n, da_int k,
858 const float *X, da_int ldx, const float *Y, da_int ldy,
859 float *D, da_int ldd, float gamma, float coef0) {
860 return da_sigmoid_kernel_s(order, m, n, k, X, ldx, Y, ldy, D, ldd, gamma, coef0);
861}
862
863/* SVM functions */
864template <class T> da_status da_svm_select_model(da_handle handle, da_svm_model mod);
865
866inline da_status da_svm_set_data(da_handle handle, da_int n_samples, da_int n_features,
867 const double *X, da_int ldx, const double *y) {
868 return da_svm_set_data_d(handle, n_samples, n_features, X, ldx, y);
869}
870
871inline da_status da_svm_set_data(da_handle handle, da_int n_samples, da_int n_features,
872 const float *X, da_int ldx, const float *y) {
873 return da_svm_set_data_s(handle, n_samples, n_features, X, ldx, y);
874}
875template <class T> da_status da_svm_compute(da_handle handle);
876
877inline da_status da_svm_predict(da_handle handle, da_int n_samples, da_int n_features,
878 const double *X_test, da_int ldx_test,
879 double *predictions) {
880 return da_svm_predict_d(handle, n_samples, n_features, X_test, ldx_test, predictions);
881}
882
883inline da_status da_svm_predict(da_handle handle, da_int n_samples, da_int n_features,
884 const float *X_test, da_int ldx_test,
885 float *predictions) {
886 return da_svm_predict_s(handle, n_samples, n_features, X_test, ldx_test, predictions);
887}
888
889inline da_status da_svm_decision_function(da_handle handle, da_int n_samples,
890 da_int n_features, const double *X_test,
891 da_int ldx_test,
892 da_svm_decision_function_shape shape,
893 double *decision_values, da_int ldd) {
894 return da_svm_decision_function_d(handle, n_samples, n_features, X_test, ldx_test,
895 shape, decision_values, ldd);
896}
897
898inline da_status da_svm_decision_function(da_handle handle, da_int n_samples,
899 da_int n_features, const float *X_test,
900 da_int ldx_test,
901 da_svm_decision_function_shape shape,
902 float *decision_values, da_int ldd) {
903 return da_svm_decision_function_s(handle, n_samples, n_features, X_test, ldx_test,
904 shape, decision_values, ldd);
905}
906
907inline da_status da_svm_score(da_handle handle, da_int n_samples, da_int n_features,
908 const double *X_test, da_int ldx_test, const double *y_test,
909 double *score) {
910 return da_svm_score_d(handle, n_samples, n_features, X_test, ldx_test, y_test, score);
911}
912
913inline da_status da_svm_score(da_handle handle, da_int n_samples, da_int n_features,
914 const float *X_test, da_int ldx_test, const float *y_test,
915 float *score) {
916 return da_svm_score_s(handle, n_samples, n_features, X_test, ldx_test, y_test, score);
917}
918
919inline da_status da_svm_predict_proba(da_handle handle, da_int n_samples,
920 da_int n_features, const double *X_test,
921 da_int ldx_test, double *y_proba, da_int ldy) {
922 return da_svm_predict_proba_d(handle, n_samples, n_features, X_test, ldx_test,
923 y_proba, ldy);
924}
925
926inline da_status da_svm_predict_proba(da_handle handle, da_int n_samples,
927 da_int n_features, const float *X_test,
928 da_int ldx_test, float *y_proba, da_int ldy) {
929 return da_svm_predict_proba_s(handle, n_samples, n_features, X_test, ldx_test,
930 y_proba, ldy);
931}
932
933inline da_status da_svm_predict_log_proba(da_handle handle, da_int n_samples,
934 da_int n_features, const double *X_test,
935 da_int ldx_test, double *y_log_proba,
936 da_int ldy) {
937 return da_svm_predict_log_proba_d(handle, n_samples, n_features, X_test, ldx_test,
938 y_log_proba, ldy);
939}
940
941inline da_status da_svm_predict_log_proba(da_handle handle, da_int n_samples,
942 da_int n_features, const float *X_test,
943 da_int ldx_test, float *y_log_proba,
944 da_int ldy) {
945 return da_svm_predict_log_proba_s(handle, n_samples, n_features, X_test, ldx_test,
946 y_log_proba, ldy);
947}
948
949#endif // AOCLDA_CPP_OVERLOADS