algorithm.h

Go to the documentation of this file.

/*******************************************************
 * Copyright (c) 2014, ArrayFire
 * All rights reserved.
 *
 * This file is distributed under 3-clause BSD license.
 * The complete license agreement can be obtained at:
 * http://arrayfire.com/licenses/BSD-3-Clause
 ********************************************************/
 
#pragma once
#include <af/defines.h>
 
#ifdef __cplusplus
namespace af
{
    class array;
 
    AFAPI array sum(const array &in, const int dim = -1);
 
#if AF_API_VERSION >= 31
    AFAPI array sum(const array &in, const int dim, const double nanval);
#endif
 
#if AF_API_VERSION >= 37
    AFAPI void sumByKey(array &keys_out, array &vals_out,
                        const array &keys, const array &vals,
                        const int dim = -1);
 
    AFAPI void sumByKey(array &keys_out, array &vals_out,
                        const array &keys, const array &vals,
                        const int dim, const double nanval);
#endif
 
    AFAPI array product(const array &in, const int dim = -1);
 
#if AF_API_VERSION >= 31
    AFAPI array product(const array &in, const int dim, const double nanval);
#endif
 
#if AF_API_VERSION >= 37
    AFAPI void productByKey(array &keys_out, array &vals_out,
                            const array &keys, const array &vals,
                            const int dim = -1);
 
    AFAPI void productByKey(array &keys_out, array &vals_out,
                            const array &keys, const array &vals,
                            const int dim, const double nanval);
#endif
 
    AFAPI array min(const array &in, const int dim = -1);
 
#if AF_API_VERSION >= 37
    AFAPI void minByKey(array &keys_out, array &vals_out,
                        const array &keys, const array &vals,
                        const int dim = -1);
#endif
 
    AFAPI array max(const array &in, const int dim = -1);
 
#if AF_API_VERSION >= 37
    AFAPI void maxByKey(array &keys_out, array &vals_out,
                        const array &keys, const array &vals,
                        const int dim = -1);
#endif
 
#if AF_API_VERSION >= 38
    AFAPI void max(array &val, array &idx, const array &in, const array &ragged_len, const int dim);
#endif
 
    AFAPI array allTrue(const array &in, const int dim = -1);
 
#if AF_API_VERSION >= 37
    AFAPI void allTrueByKey(array &keys_out, array &vals_out,
                            const array &keys, const array &vals,
                            const int dim = -1);
#endif
 
    AFAPI array anyTrue(const array &in, const int dim = -1);
 
#if AF_API_VERSION >= 37
    AFAPI void anyTrueByKey(array &keys_out, array &vals_out,
                            const array &keys, const array &vals,
                            const int dim = -1);
#endif
 
    AFAPI array count(const array &in, const int dim = -1);
 
#if AF_API_VERSION >= 37
    AFAPI void countByKey(array &keys_out, array &vals_out,
                          const array &keys, const array &vals,
                          const int dim = -1);
#endif
 
    template<typename T> T sum(const array &in);
 
#if AF_API_VERSION >= 31
    template<typename T> T sum(const array &in, double nanval);
#endif
 
    template<typename T> T product(const array &in);
 
#if AF_API_VERSION >= 31
    template<typename T> T product(const array &in, double nanval);
#endif
 
    template<typename T> T min(const array &in);
 
    template<typename T> T max(const array &in);
 
    template<typename T> T allTrue(const array &in);
 
    template<typename T> T anyTrue(const array &in);
 
    template<typename T> T count(const array &in);
 
    AFAPI void min(array &val, array &idx, const array &in, const int dim = -1);
 
    AFAPI void max(array &val, array &idx, const array &in, const int dim = -1);
 
    template<typename T> void min(T *val, unsigned *idx, const array &in);
 
    template<typename T> void max(T *val, unsigned *idx, const array &in);
 
    AFAPI array accum(const array &in, const int dim = 0);
 
#if AF_API_VERSION >=34
    AFAPI array scan(const array &in, const int dim = 0,
                     binaryOp op = AF_BINARY_ADD, bool inclusive_scan = true);
 
    AFAPI array scanByKey(const array &key, const array& in, const int dim = 0,
                          binaryOp op = AF_BINARY_ADD, bool inclusive_scan = true);
#endif
 
    AFAPI array where(const array &in);
 
    AFAPI array diff1(const array &in, const int dim = 0);
 
    AFAPI array diff2(const array &in, const int dim = 0);
 
    AFAPI array sort(const array &in, const unsigned dim = 0,
                     const bool isAscending = true);
 
    AFAPI void  sort(array &out, array &indices, const array &in, const unsigned dim = 0,
                     const bool isAscending = true);
 
    AFAPI void  sort(array &out_keys, array &out_values, const array &keys,
                     const array &values, const unsigned dim = 0,
                     const bool isAscending = true);
 
    AFAPI array setUnique(const array &in, const bool is_sorted=false);
 
    AFAPI array setUnion(const array &first, const array &second,
                         const bool is_unique=false);
 
    AFAPI array setIntersect(const array &first, const array &second,
                             const bool is_unique=false);
}
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
    AFAPI af_err af_sum(af_array *out, const af_array in, const int dim);
 
#if AF_API_VERSION >= 39
    AFAPI af_err af_sum_all_array(af_array *out, const af_array in);
#endif
 
#if AF_API_VERSION >= 31
    AFAPI af_err af_sum_nan(af_array *out, const af_array in,
                            const int dim, const double nanval);
#endif
 
#if AF_API_VERSION >= 39
    AFAPI af_err af_sum_nan_all_array(af_array *out, const af_array in, const double nanval);
#endif
 
#if AF_API_VERSION >= 37
    AFAPI af_err af_sum_by_key(af_array *keys_out, af_array *vals_out,
                               const af_array keys, const af_array vals, const int dim);
 
    AFAPI af_err af_sum_by_key_nan(af_array *keys_out, af_array *vals_out,
                                   const af_array keys, const af_array vals,
                                   const int dim, const double nanval);
#endif
 
    AFAPI af_err af_product(af_array *out, const af_array in, const int dim);
 
#if AF_API_VERSION >= 39
    AFAPI af_err af_product_all_array(af_array *out, const af_array in);
#endif
 
#if AF_API_VERSION >= 31
    AFAPI af_err af_product_nan(af_array *out, const af_array in, const int dim, const double nanval);
#endif
 
#if AF_API_VERSION >= 39
    AFAPI af_err af_product_nan_all_array(af_array *out, const af_array in, const double nanval);
#endif
 
#if AF_API_VERSION >= 37
    AFAPI af_err af_product_by_key(af_array *keys_out, af_array *vals_out,
                                   const af_array keys, const af_array vals, const int dim);
 
    AFAPI af_err af_product_by_key_nan(af_array *keys_out, af_array *vals_out,
                                       const af_array keys, const af_array vals,
                                       const int dim, const double nanval);
#endif
 
    AFAPI af_err af_min(af_array *out, const af_array in, const int dim);
 
#if AF_API_VERSION >= 37
    AFAPI af_err af_min_by_key(af_array *keys_out, af_array *vals_out,
                               const af_array keys, const af_array vals,
                               const int dim);
#endif
 
    AFAPI af_err af_max(af_array *out, const af_array in, const int dim);
 
#if AF_API_VERSION >= 37
    AFAPI af_err af_max_by_key(af_array *keys_out, af_array *vals_out,
                               const af_array keys, const af_array vals,
                               const int dim);
#endif
 
#if AF_API_VERSION >= 38
    AFAPI af_err af_max_ragged(af_array *val, af_array *idx, const af_array in, const af_array ragged_len, const int dim);
#endif
 
    AFAPI af_err af_all_true(af_array *out, const af_array in, const int dim);
 
#if AF_API_VERSION >= 37
    AFAPI af_err af_all_true_by_key(af_array *keys_out, af_array *vals_out,
                                    const af_array keys, const af_array vals,
                                    const int dim);
#endif
 
    AFAPI af_err af_any_true(af_array *out, const af_array in, const int dim);
 
#if AF_API_VERSION >= 37
    AFAPI af_err af_any_true_by_key(af_array *keys_out, af_array *vals_out,
                                    const af_array keys, const af_array vals,
                                    const int dim);
#endif
 
    AFAPI af_err af_count(af_array *out, const af_array in, const int dim);
 
#if AF_API_VERSION >= 37
    AFAPI af_err af_count_by_key(af_array *keys_out, af_array *vals_out,
                                 const af_array keys, const af_array vals,
                                 const int dim);
#endif
 
    AFAPI af_err af_sum_all(double *real, double *imag, const af_array in);
 
#if AF_API_VERSION >= 31
    AFAPI af_err af_sum_nan_all(double *real, double *imag,
                                const af_array in, const double nanval);
#endif
 
    AFAPI af_err af_product_all(double *real, double *imag, const af_array in);
 
#if AF_API_VERSION >= 31
    AFAPI af_err af_product_nan_all(double *real, double *imag,
                                    const af_array in, const double nanval);
#endif
 
    AFAPI af_err af_min_all(double *real, double *imag, const af_array in);
 
#if AF_API_VERSION >= 39
    AFAPI af_err af_min_all_array(af_array *out, const af_array in);
#endif
 
    AFAPI af_err af_max_all(double *real, double *imag, const af_array in);
 
#if AF_API_VERSION >= 39
    AFAPI af_err af_max_all_array(af_array *out, const af_array in);
#endif
 
    AFAPI af_err af_all_true_all(double *real, double *imag, const af_array in);
 
#if AF_API_VERSION >= 39
    AFAPI af_err af_all_true_all_array(af_array *out, const af_array in);
#endif
 
    AFAPI af_err af_any_true_all(double *real, double *imag, const af_array in);
 
#if AF_API_VERSION >= 39
    AFAPI af_err af_any_true_all_array(af_array *out, const af_array in);
#endif
 
    AFAPI af_err af_count_all(double *real, double *imag, const af_array in);
 
#if AF_API_VERSION >= 39
    AFAPI af_err af_count_all_array(af_array *out, const af_array in);
#endif
 
    AFAPI af_err af_imin(af_array *out, af_array *idx, const af_array in,
                         const int dim);
 
    AFAPI af_err af_imax(af_array *out, af_array *idx, const af_array in,
                         const int dim);
 
    AFAPI af_err af_imin_all(double *real, double *imag, unsigned *idx,
                             const af_array in);
 
    AFAPI af_err af_imax_all(double *real, double *imag, unsigned *idx, const af_array in);
 
    AFAPI af_err af_accum(af_array *out, const af_array in, const int dim);
 
#if AF_API_VERSION >=34
    AFAPI af_err af_scan(af_array *out, const af_array in, const int dim,
                         af_binary_op op, bool inclusive_scan);
 
    AFAPI af_err af_scan_by_key(af_array *out, const af_array key,
                                const af_array in, const int dim,
                                af_binary_op op, bool inclusive_scan);
 
#endif
 
    AFAPI af_err af_where(af_array *idx, const af_array in);
 
    AFAPI af_err af_diff1(af_array *out, const af_array in, const int dim);
 
    AFAPI af_err af_diff2(af_array *out, const af_array in, const int dim);
 
    AFAPI af_err af_sort(af_array *out, const af_array in, const unsigned dim,
                         const bool isAscending);
 
    AFAPI af_err af_sort_index(af_array *out, af_array *indices, const af_array in,
                               const unsigned dim, const bool isAscending);
    AFAPI af_err af_sort_by_key(af_array *out_keys, af_array *out_values,
                                const af_array keys, const af_array values,
                                const unsigned dim, const bool isAscending);
 
    AFAPI af_err af_set_unique(af_array *out, const af_array in, const bool is_sorted);
 
    AFAPI af_err af_set_union(af_array *out, const af_array first,
                              const af_array second, const bool is_unique);
 
    AFAPI af_err af_set_intersect(af_array *out, const af_array first,
                                  const af_array second, const bool is_unique);
 
#ifdef __cplusplus
}
#endif