[arrayfire] 13/41: Moving all functions related to af_array handling to api/c/array.cpp
Ghislain Vaillant
ghisvail-guest at moszumanska.debian.org
Mon Mar 21 14:56:22 UTC 2016
This is an automated email from the git hooks/post-receive script.
ghisvail-guest pushed a commit to branch debian/experimental
in repository arrayfire.
commit 00131de43a8f04b7097337eab70a40398671e359
Author: Pavan Yalamanchili <pavan at arrayfire.com>
Date: Sun Mar 6 02:54:35 2016 -0500
Moving all functions related to af_array handling to api/c/array.cpp
---
src/api/c/array.cpp | 263 +++++++++++++++++++++++++++++++++++++++++++++
src/api/c/data.cpp | 294 +--------------------------------------------------
src/api/c/device.cpp | 33 ++++++
src/api/c/handle.hpp | 3 +
4 files changed, 300 insertions(+), 293 deletions(-)
diff --git a/src/api/c/array.cpp b/src/api/c/array.cpp
index cefdde1..80b0d85 100644
--- a/src/api/c/array.cpp
+++ b/src/api/c/array.cpp
@@ -9,6 +9,10 @@
#include <handle.hpp>
#include <ArrayInfo.hpp>
#include <platform.hpp>
+#include <handle.hpp>
+#include <backend.hpp>
+
+using namespace detail;
const ArrayInfo&
getInfo(const af_array arr, bool check)
@@ -22,6 +26,265 @@ getInfo(const af_array arr, bool check)
return *info;
}
+af_err af_get_data_ptr(void *data, const af_array arr)
+{
+ try {
+ af_dtype type = getInfo(arr).getType();
+ switch(type) {
+ case f32: copyData(static_cast<float *>(data), arr); break;
+ case c32: copyData(static_cast<cfloat *>(data), arr); break;
+ case f64: copyData(static_cast<double *>(data), arr); break;
+ case c64: copyData(static_cast<cdouble *>(data), arr); break;
+ case b8: copyData(static_cast<char *>(data), arr); break;
+ case s32: copyData(static_cast<int *>(data), arr); break;
+ case u32: copyData(static_cast<unsigned *>(data), arr); break;
+ case u8: copyData(static_cast<uchar *>(data), arr); break;
+ case s64: copyData(static_cast<intl *>(data), arr); break;
+ case u64: copyData(static_cast<uintl *>(data), arr); break;
+ case s16: copyData(static_cast<short *>(data), arr); break;
+ case u16: copyData(static_cast<ushort *>(data), arr); break;
+ default: TYPE_ERROR(1, type);
+ }
+ }
+ CATCHALL
+ return AF_SUCCESS;
+}
+
+//Strong Exception Guarantee
+af_err af_create_array(af_array *result, const void * const data,
+ const unsigned ndims, const dim_t * const dims,
+ const af_dtype type)
+{
+ try {
+ af_array out;
+ AF_CHECK(af_init());
+
+ dim4 d = verifyDims(ndims, dims);
+
+ switch(type) {
+ case f32: out = createHandleFromData(d, static_cast<const float *>(data)); break;
+ case c32: out = createHandleFromData(d, static_cast<const cfloat *>(data)); break;
+ case f64: out = createHandleFromData(d, static_cast<const double *>(data)); break;
+ case c64: out = createHandleFromData(d, static_cast<const cdouble *>(data)); break;
+ case b8: out = createHandleFromData(d, static_cast<const char *>(data)); break;
+ case s32: out = createHandleFromData(d, static_cast<const int *>(data)); break;
+ case u32: out = createHandleFromData(d, static_cast<const uint *>(data)); break;
+ case u8: out = createHandleFromData(d, static_cast<const uchar *>(data)); break;
+ case s64: out = createHandleFromData(d, static_cast<const intl *>(data)); break;
+ case u64: out = createHandleFromData(d, static_cast<const uintl *>(data)); break;
+ case s16: out = createHandleFromData(d, static_cast<const short *>(data)); break;
+ case u16: out = createHandleFromData(d, static_cast<const ushort *>(data)); break;
+ default: TYPE_ERROR(4, type);
+ }
+ std::swap(*result, out);
+ }
+ CATCHALL
+ return AF_SUCCESS;
+}
+
+//Strong Exception Guarantee
+af_err af_create_handle(af_array *result, const unsigned ndims, const dim_t * const dims,
+ const af_dtype type)
+{
+ try {
+ af_array out;
+ AF_CHECK(af_init());
+
+ dim4 d((size_t)dims[0]);
+ for(unsigned i = 1; i < ndims; i++) {
+ d[i] = dims[i];
+ }
+
+ switch(type) {
+ case f32: out = createHandle<float >(d); break;
+ case c32: out = createHandle<cfloat >(d); break;
+ case f64: out = createHandle<double >(d); break;
+ case c64: out = createHandle<cdouble>(d); break;
+ case b8: out = createHandle<char >(d); break;
+ case s32: out = createHandle<int >(d); break;
+ case u32: out = createHandle<uint >(d); break;
+ case u8: out = createHandle<uchar >(d); break;
+ case s64: out = createHandle<intl >(d); break;
+ case u64: out = createHandle<uintl >(d); break;
+ case s16: out = createHandle<short >(d); break;
+ case u16: out = createHandle<ushort >(d); break;
+ default: TYPE_ERROR(3, type);
+ }
+ std::swap(*result, out);
+ }
+ CATCHALL
+ return AF_SUCCESS;
+}
+
+//Strong Exception Guarantee
+af_err af_copy_array(af_array *out, const af_array in)
+{
+ try {
+ ArrayInfo info = getInfo(in);
+ const af_dtype type = info.getType();
+
+ af_array res;
+ switch(type) {
+ case f32: res = copyArray<float >(in); break;
+ case c32: res = copyArray<cfloat >(in); break;
+ case f64: res = copyArray<double >(in); break;
+ case c64: res = copyArray<cdouble >(in); break;
+ case b8: res = copyArray<char >(in); break;
+ case s32: res = copyArray<int >(in); break;
+ case u32: res = copyArray<uint >(in); break;
+ case u8: res = copyArray<uchar >(in); break;
+ case s64: res = copyArray<intl >(in); break;
+ case u64: res = copyArray<uintl >(in); break;
+ case s16: res = copyArray<short >(in); break;
+ case u16: res = copyArray<ushort >(in); break;
+ default: TYPE_ERROR(1, type);
+ }
+ std::swap(*out, res);
+ }
+ CATCHALL
+ return AF_SUCCESS;
+}
+
+//Strong Exception Guarantee
+af_err af_get_data_ref_count(int *use_count, const af_array in)
+{
+ try {
+ ArrayInfo info = getInfo(in);
+ const af_dtype type = info.getType();
+
+ int res;
+ switch(type) {
+ case f32: res = getArray<float >(in).useCount(); break;
+ case c32: res = getArray<cfloat >(in).useCount(); break;
+ case f64: res = getArray<double >(in).useCount(); break;
+ case c64: res = getArray<cdouble >(in).useCount(); break;
+ case b8: res = getArray<char >(in).useCount(); break;
+ case s32: res = getArray<int >(in).useCount(); break;
+ case u32: res = getArray<uint >(in).useCount(); break;
+ case u8: res = getArray<uchar >(in).useCount(); break;
+ case s64: res = getArray<intl >(in).useCount(); break;
+ case u64: res = getArray<uintl >(in).useCount(); break;
+ case s16: res = getArray<short >(in).useCount(); break;
+ case u16: res = getArray<ushort >(in).useCount(); break;
+ default: TYPE_ERROR(1, type);
+ }
+ std::swap(*use_count, res);
+ }
+ CATCHALL
+ return AF_SUCCESS;
+}
+
+af_err af_release_array(af_array arr)
+{
+ try {
+ int dev = getActiveDeviceId();
+
+ ArrayInfo info = getInfo(arr, false);
+
+ setDevice(info.getDevId());
+
+ af_dtype type = info.getType();
+
+ switch(type) {
+ case f32: releaseHandle<float >(arr); break;
+ case c32: releaseHandle<cfloat >(arr); break;
+ case f64: releaseHandle<double >(arr); break;
+ case c64: releaseHandle<cdouble >(arr); break;
+ case b8: releaseHandle<char >(arr); break;
+ case s32: releaseHandle<int >(arr); break;
+ case u32: releaseHandle<uint >(arr); break;
+ case u8: releaseHandle<uchar >(arr); break;
+ case s64: releaseHandle<intl >(arr); break;
+ case u64: releaseHandle<uintl >(arr); break;
+ case s16: releaseHandle<short >(arr); break;
+ case u16: releaseHandle<ushort >(arr); break;
+ default: TYPE_ERROR(0, type);
+ }
+
+ setDevice(dev);
+ }
+ CATCHALL
+
+ return AF_SUCCESS;
+}
+
+
+template<typename T>
+static af_array retainHandle(const af_array in)
+{
+ detail::Array<T> *A = reinterpret_cast<detail::Array<T> *>(in);
+ detail::Array<T> *out = detail::initArray<T>();
+ *out= *A;
+ return reinterpret_cast<af_array>(out);
+}
+
+af_array retain(const af_array in)
+{
+ af_dtype ty = getInfo(in).getType();
+ switch(ty) {
+ case f32: return retainHandle<float >(in);
+ case f64: return retainHandle<double >(in);
+ case s32: return retainHandle<int >(in);
+ case u32: return retainHandle<uint >(in);
+ case u8: return retainHandle<uchar >(in);
+ case c32: return retainHandle<detail::cfloat >(in);
+ case c64: return retainHandle<detail::cdouble >(in);
+ case b8: return retainHandle<char >(in);
+ case s64: return retainHandle<intl >(in);
+ case u64: return retainHandle<uintl >(in);
+ case s16: return retainHandle<short >(in);
+ case u16: return retainHandle<ushort >(in);
+ default:
+ TYPE_ERROR(1, ty);
+ }
+}
+
+af_err af_retain_array(af_array *out, const af_array in)
+{
+ try {
+ *out = retain(in);
+ }
+ CATCHALL;
+ return AF_SUCCESS;
+}
+
+template<typename T>
+void write_array(af_array arr, const T * const data, const size_t bytes, af_source src)
+{
+ if(src == afHost) {
+ writeHostDataArray(getWritableArray<T>(arr), data, bytes);
+ } else {
+ writeDeviceDataArray(getWritableArray<T>(arr), data, bytes);
+ }
+ return;
+}
+
+af_err af_write_array(af_array arr, const void *data, const size_t bytes, af_source src)
+{
+ try {
+ af_dtype type = getInfo(arr).getType();
+ //DIM_ASSERT(2, bytes <= getInfo(arr).bytes());
+
+ switch(type) {
+ case f32: write_array(arr, static_cast<const float *>(data), bytes, src); break;
+ case c32: write_array(arr, static_cast<const cfloat *>(data), bytes, src); break;
+ case f64: write_array(arr, static_cast<const double *>(data), bytes, src); break;
+ case c64: write_array(arr, static_cast<const cdouble *>(data), bytes, src); break;
+ case b8: write_array(arr, static_cast<const char *>(data), bytes, src); break;
+ case s32: write_array(arr, static_cast<const int *>(data), bytes, src); break;
+ case u32: write_array(arr, static_cast<const uint *>(data), bytes, src); break;
+ case u8: write_array(arr, static_cast<const uchar *>(data), bytes, src); break;
+ case s64: write_array(arr, static_cast<const intl *>(data), bytes, src); break;
+ case u64: write_array(arr, static_cast<const uintl *>(data), bytes, src); break;
+ case s16: write_array(arr, static_cast<const short *>(data), bytes, src); break;
+ case u16: write_array(arr, static_cast<const ushort *>(data), bytes, src); break;
+ default: TYPE_ERROR(4, type);
+ }
+ }
+ CATCHALL
+ return AF_SUCCESS;
+}
+
af_err af_get_elements(dim_t *elems, const af_array arr)
{
try {
diff --git a/src/api/c/data.cpp b/src/api/c/data.cpp
index 4a88899..295fa83 100644
--- a/src/api/c/data.cpp
+++ b/src/api/c/data.cpp
@@ -30,7 +30,7 @@ using af::dim4;
using namespace detail;
using namespace std;
-static inline dim4 verifyDims(const unsigned ndims, const dim_t * const dims)
+dim4 verifyDims(const unsigned ndims, const dim_t * const dims)
{
DIM_ASSERT(1, ndims >= 1);
@@ -45,62 +45,6 @@ static inline dim4 verifyDims(const unsigned ndims, const dim_t * const dims)
return d;
}
-af_err af_get_data_ptr(void *data, const af_array arr)
-{
- try {
- af_dtype type = getInfo(arr).getType();
- switch(type) {
- case f32: copyData(static_cast<float *>(data), arr); break;
- case c32: copyData(static_cast<cfloat *>(data), arr); break;
- case f64: copyData(static_cast<double *>(data), arr); break;
- case c64: copyData(static_cast<cdouble *>(data), arr); break;
- case b8: copyData(static_cast<char *>(data), arr); break;
- case s32: copyData(static_cast<int *>(data), arr); break;
- case u32: copyData(static_cast<unsigned *>(data), arr); break;
- case u8: copyData(static_cast<uchar *>(data), arr); break;
- case s64: copyData(static_cast<intl *>(data), arr); break;
- case u64: copyData(static_cast<uintl *>(data), arr); break;
- case s16: copyData(static_cast<short *>(data), arr); break;
- case u16: copyData(static_cast<ushort *>(data), arr); break;
- default: TYPE_ERROR(1, type);
- }
- }
- CATCHALL
- return AF_SUCCESS;
-}
-
-//Strong Exception Guarantee
-af_err af_create_array(af_array *result, const void * const data,
- const unsigned ndims, const dim_t * const dims,
- const af_dtype type)
-{
- try {
- af_array out;
- AF_CHECK(af_init());
-
- dim4 d = verifyDims(ndims, dims);
-
- switch(type) {
- case f32: out = createHandleFromData(d, static_cast<const float *>(data)); break;
- case c32: out = createHandleFromData(d, static_cast<const cfloat *>(data)); break;
- case f64: out = createHandleFromData(d, static_cast<const double *>(data)); break;
- case c64: out = createHandleFromData(d, static_cast<const cdouble *>(data)); break;
- case b8: out = createHandleFromData(d, static_cast<const char *>(data)); break;
- case s32: out = createHandleFromData(d, static_cast<const int *>(data)); break;
- case u32: out = createHandleFromData(d, static_cast<const uint *>(data)); break;
- case u8: out = createHandleFromData(d, static_cast<const uchar *>(data)); break;
- case s64: out = createHandleFromData(d, static_cast<const intl *>(data)); break;
- case u64: out = createHandleFromData(d, static_cast<const uintl *>(data)); break;
- case s16: out = createHandleFromData(d, static_cast<const short *>(data)); break;
- case u16: out = createHandleFromData(d, static_cast<const ushort *>(data)); break;
- default: TYPE_ERROR(4, type);
- }
- std::swap(*result, out);
- }
- CATCHALL
- return AF_SUCCESS;
-}
-
//Strong Exception Guarantee
af_err af_constant(af_array *result, const double value,
const unsigned ndims, const dim_t * const dims,
@@ -195,99 +139,6 @@ af_err af_constant_ulong(af_array *result, const uintl val,
return AF_SUCCESS;
}
-//Strong Exception Guarantee
-af_err af_create_handle(af_array *result, const unsigned ndims, const dim_t * const dims,
- const af_dtype type)
-{
- try {
- af_array out;
- AF_CHECK(af_init());
-
- dim4 d((size_t)dims[0]);
- for(unsigned i = 1; i < ndims; i++) {
- d[i] = dims[i];
- }
-
- switch(type) {
- case f32: out = createHandle<float >(d); break;
- case c32: out = createHandle<cfloat >(d); break;
- case f64: out = createHandle<double >(d); break;
- case c64: out = createHandle<cdouble>(d); break;
- case b8: out = createHandle<char >(d); break;
- case s32: out = createHandle<int >(d); break;
- case u32: out = createHandle<uint >(d); break;
- case u8: out = createHandle<uchar >(d); break;
- case s64: out = createHandle<intl >(d); break;
- case u64: out = createHandle<uintl >(d); break;
- case s16: out = createHandle<short >(d); break;
- case u16: out = createHandle<ushort >(d); break;
- default: TYPE_ERROR(3, type);
- }
- std::swap(*result, out);
- }
- CATCHALL
- return AF_SUCCESS;
-}
-
-//Strong Exception Guarantee
-af_err af_copy_array(af_array *out, const af_array in)
-{
- try {
- ArrayInfo info = getInfo(in);
- const af_dtype type = info.getType();
-
- af_array res;
- switch(type) {
- case f32: res = copyArray<float >(in); break;
- case c32: res = copyArray<cfloat >(in); break;
- case f64: res = copyArray<double >(in); break;
- case c64: res = copyArray<cdouble >(in); break;
- case b8: res = copyArray<char >(in); break;
- case s32: res = copyArray<int >(in); break;
- case u32: res = copyArray<uint >(in); break;
- case u8: res = copyArray<uchar >(in); break;
- case s64: res = copyArray<intl >(in); break;
- case u64: res = copyArray<uintl >(in); break;
- case s16: res = copyArray<short >(in); break;
- case u16: res = copyArray<ushort >(in); break;
- default: TYPE_ERROR(1, type);
- }
- std::swap(*out, res);
- }
- CATCHALL
- return AF_SUCCESS;
-}
-
-//Strong Exception Guarantee
-af_err af_get_data_ref_count(int *use_count, const af_array in)
-{
- try {
- ArrayInfo info = getInfo(in);
- const af_dtype type = info.getType();
-
- int res;
- switch(type) {
- case f32: res = getArray<float >(in).useCount(); break;
- case c32: res = getArray<cfloat >(in).useCount(); break;
- case f64: res = getArray<double >(in).useCount(); break;
- case c64: res = getArray<cdouble >(in).useCount(); break;
- case b8: res = getArray<char >(in).useCount(); break;
- case s32: res = getArray<int >(in).useCount(); break;
- case u32: res = getArray<uint >(in).useCount(); break;
- case u8: res = getArray<uchar >(in).useCount(); break;
- case s64: res = getArray<intl >(in).useCount(); break;
- case u64: res = getArray<uintl >(in).useCount(); break;
- case s16: res = getArray<short >(in).useCount(); break;
- case u16: res = getArray<ushort >(in).useCount(); break;
- default: TYPE_ERROR(1, type);
- }
- std::swap(*use_count, res);
- }
- CATCHALL
- return AF_SUCCESS;
-}
-
-
template<typename T>
static inline af_array randn_(const af::dim4 &dims)
{
@@ -402,80 +253,6 @@ af_err af_identity(af_array *out, const unsigned ndims, const dim_t * const dims
return AF_SUCCESS;
}
-af_err af_release_array(af_array arr)
-{
- try {
- int dev = getActiveDeviceId();
-
- ArrayInfo info = getInfo(arr, false);
-
- setDevice(info.getDevId());
-
- af_dtype type = info.getType();
-
- switch(type) {
- case f32: releaseHandle<float >(arr); break;
- case c32: releaseHandle<cfloat >(arr); break;
- case f64: releaseHandle<double >(arr); break;
- case c64: releaseHandle<cdouble >(arr); break;
- case b8: releaseHandle<char >(arr); break;
- case s32: releaseHandle<int >(arr); break;
- case u32: releaseHandle<uint >(arr); break;
- case u8: releaseHandle<uchar >(arr); break;
- case s64: releaseHandle<intl >(arr); break;
- case u64: releaseHandle<uintl >(arr); break;
- case s16: releaseHandle<short >(arr); break;
- case u16: releaseHandle<ushort >(arr); break;
- default: TYPE_ERROR(0, type);
- }
-
- setDevice(dev);
- }
- CATCHALL
-
- return AF_SUCCESS;
-}
-
-
-template<typename T>
-static af_array retainHandle(const af_array in)
-{
- detail::Array<T> *A = reinterpret_cast<detail::Array<T> *>(in);
- detail::Array<T> *out = detail::initArray<T>();
- *out= *A;
- return reinterpret_cast<af_array>(out);
-}
-
-af_array retain(const af_array in)
-{
- af_dtype ty = getInfo(in).getType();
- switch(ty) {
- case f32: return retainHandle<float >(in);
- case f64: return retainHandle<double >(in);
- case s32: return retainHandle<int >(in);
- case u32: return retainHandle<uint >(in);
- case u8: return retainHandle<uchar >(in);
- case c32: return retainHandle<detail::cfloat >(in);
- case c64: return retainHandle<detail::cdouble >(in);
- case b8: return retainHandle<char >(in);
- case s64: return retainHandle<intl >(in);
- case u64: return retainHandle<uintl >(in);
- case s16: return retainHandle<short >(in);
- case u16: return retainHandle<ushort >(in);
- default:
- TYPE_ERROR(1, ty);
- }
-}
-
-af_err af_retain_array(af_array *out, const af_array in)
-{
- try {
- *out = retain(in);
- }
- CATCHALL;
- return AF_SUCCESS;
-}
-
template<typename T>
static inline af_array range_(const dim4& d, const int seq_dim)
{
@@ -549,38 +326,6 @@ af_err af_iota(af_array *result, const unsigned ndims, const dim_t * const dims,
}
template<typename T>
-static inline void eval(af_array arr)
-{
- getArray<T>(arr).eval();
- return;
-}
-
-af_err af_eval(af_array arr)
-{
- try {
- af_dtype type = getInfo(arr).getType();
- switch (type) {
- case f32: eval<float >(arr); break;
- case f64: eval<double >(arr); break;
- case c32: eval<cfloat >(arr); break;
- case c64: eval<cdouble>(arr); break;
- case s32: eval<int >(arr); break;
- case u32: eval<uint >(arr); break;
- case u8 : eval<uchar >(arr); break;
- case b8 : eval<char >(arr); break;
- case s64: eval<intl >(arr); break;
- case u64: eval<uintl >(arr); break;
- case s16: eval<short >(arr); break;
- case u16: eval<ushort >(arr); break;
- default:
- TYPE_ERROR(0, type);
- }
- } CATCHALL;
-
- return AF_SUCCESS;
-}
-
-template<typename T>
static inline af_array diagCreate(const af_array in, const int num)
{
return getHandle(diagCreate<T>(getArray<T>(in), num));
@@ -654,43 +399,6 @@ af_err af_diag_extract(af_array *out, const af_array in, const int num)
return AF_SUCCESS;
}
-template<typename T>
-void write_array(af_array arr, const T * const data, const size_t bytes, af_source src)
-{
- if(src == afHost) {
- writeHostDataArray(getWritableArray<T>(arr), data, bytes);
- } else {
- writeDeviceDataArray(getWritableArray<T>(arr), data, bytes);
- }
- return;
-}
-
-af_err af_write_array(af_array arr, const void *data, const size_t bytes, af_source src)
-{
- try {
- af_dtype type = getInfo(arr).getType();
- //DIM_ASSERT(2, bytes <= getInfo(arr).bytes());
-
- switch(type) {
- case f32: write_array(arr, static_cast<const float *>(data), bytes, src); break;
- case c32: write_array(arr, static_cast<const cfloat *>(data), bytes, src); break;
- case f64: write_array(arr, static_cast<const double *>(data), bytes, src); break;
- case c64: write_array(arr, static_cast<const cdouble *>(data), bytes, src); break;
- case b8: write_array(arr, static_cast<const char *>(data), bytes, src); break;
- case s32: write_array(arr, static_cast<const int *>(data), bytes, src); break;
- case u32: write_array(arr, static_cast<const uint *>(data), bytes, src); break;
- case u8: write_array(arr, static_cast<const uchar *>(data), bytes, src); break;
- case s64: write_array(arr, static_cast<const intl *>(data), bytes, src); break;
- case u64: write_array(arr, static_cast<const uintl *>(data), bytes, src); break;
- case s16: write_array(arr, static_cast<const short *>(data), bytes, src); break;
- case u16: write_array(arr, static_cast<const ushort *>(data), bytes, src); break;
- default: TYPE_ERROR(4, type);
- }
- }
- CATCHALL
- return AF_SUCCESS;
-}
-
template<typename T, bool is_upper>
af_array triangle(const af_array in, bool is_unit_diag)
{
diff --git a/src/api/c/device.cpp b/src/api/c/device.cpp
index abe0b01..b93907d 100644
--- a/src/api/c/device.cpp
+++ b/src/api/c/device.cpp
@@ -156,3 +156,36 @@ af_err af_sync(const int device)
} CATCHALL;
return AF_SUCCESS;
}
+
+
+template<typename T>
+static inline void eval(af_array arr)
+{
+ getArray<T>(arr).eval();
+ return;
+}
+
+af_err af_eval(af_array arr)
+{
+ try {
+ af_dtype type = getInfo(arr).getType();
+ switch (type) {
+ case f32: eval<float >(arr); break;
+ case f64: eval<double >(arr); break;
+ case c32: eval<cfloat >(arr); break;
+ case c64: eval<cdouble>(arr); break;
+ case s32: eval<int >(arr); break;
+ case u32: eval<uint >(arr); break;
+ case u8 : eval<uchar >(arr); break;
+ case b8 : eval<char >(arr); break;
+ case s64: eval<intl >(arr); break;
+ case u64: eval<uintl >(arr); break;
+ case s16: eval<short >(arr); break;
+ case u16: eval<ushort >(arr); break;
+ default:
+ TYPE_ERROR(0, type);
+ }
+ } CATCHALL;
+
+ return AF_SUCCESS;
+}
diff --git a/src/api/c/handle.hpp b/src/api/c/handle.hpp
index ac7b74a..e5dc3f4 100644
--- a/src/api/c/handle.hpp
+++ b/src/api/c/handle.hpp
@@ -15,6 +15,7 @@
#include <math.hpp>
#include <copy.hpp>
#include <cast.hpp>
+#include <af/dim4.hpp>
const ArrayInfo& getInfo(const af_array arr, bool check = true);
@@ -109,3 +110,5 @@ static void releaseHandle(const af_array arr)
}
af_array retain(const af_array in);
+
+af::dim4 verifyDims(const unsigned ndims, const dim_t * const dims);
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/debian-science/packages/arrayfire.git
More information about the debian-science-commits
mailing list