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