FEAT/TEST: Adding support for getting data back to the host

Author: pavanky

arrayfire/__init__.py

@@ -53,3 +53,6 @@
 del get_indices
 del get_assign_dims
 del slice_to_length
+del ctype_to_lists
+del to_dtype
+del to_c_type

arrayfire/array.py

@@ -83,6 +83,14 @@ def binary_funcr(lhs, rhs, c_func):
 
     return out
 
+def transpose(a, conj=False):
+    out = array()
+    safe_call(clib.af_transpose(ct.pointer(out.arr), a.arr, conj))
+    return out
+
+def transpose_inplace(a, conj=False):
+    safe_call(clib.af_transpose_inplace(a.arr, conj))
+
 class seq(ct.Structure):
     _fields_ = [("begin", ct.c_double),
                 ("end"  , ct.c_double),
@@ -163,6 +171,17 @@ def slice_to_length(key, dim):
 
     return int(((tkey[1] - tkey[0] - 1) / tkey[2]) + 1)
 
+def ctype_to_lists(ctype_arr, dim, shape, offset=0):
+    if (dim == 0):
+        return list(ctype_arr[offset : offset + shape[0]])
+    else:
+        dim_len = shape[dim]
+        res = [[]] * dim_len
+        for n in range(dim_len):
+            res[n] = ctype_to_lists(ctype_arr, dim - 1, shape, offset)
+            offset += shape[0]
+        return res
+
 def get_assign_dims(key, idims):
     dims = [1]*4
 
@@ -518,6 +537,31 @@ def __setitem__(self, key, val):
         except RuntimeError as e:
             raise IndexError(str(e))
 
+    def to_ctype(self, row_major=False, return_shape=False):
+        tmp = transpose(self) if row_major else self
+        ctype_type = to_c_type[self.type()] * self.elements()
+        res = ctype_type()
+        safe_call(clib.af_get_data_ptr(ct.pointer(res), self.arr))
+        if (return_shape):
+            return res, self.dims()
+        else:
+            return res
+
+    def to_array(self, row_major=False, return_shape=False):
+        res = self.to_ctype(row_major, return_shape)
+
+        host = __import__("array")
+        h_type = to_typecode[self.type()]
+
+        if (return_shape):
+            return host.array(h_type, res[0]), res[1]
+        else:
+            return host.array(h_type, res)
+
+    def to_list(self, row_major=False):
+        ct_array, shape = self.to_ctype(row_major, True)
+        return ctype_to_lists(ct_array, len(shape) - 1, shape)
+
 def display(a):
     expr = inspect.stack()[1][-2]
     if (expr is not None):

arrayfire/blas.py

@@ -39,11 +39,3 @@ def dot(lhs, rhs, lhs_opts=AF_MAT_NONE, rhs_opts=AF_MAT_NONE):
     safe_call(clib.af_dot(ct.pointer(out.arr), lhs.arr, rhs.arr,\
                           lhs_opts, rhs_opts))
     return out
-
-def transpose(a, conj=False):
-    out = array()
-    safe_call(clib.af_transpose(ct.pointer(out.arr), a.arr, conj))
-    return out
-
-def transpose_inplace(a, conj=False):
-    safe_call(clib.af_transpose_inplace(a.arr, conj))

arrayfire/util.py

@@ -60,3 +60,21 @@ def get_version():
             'I' : u32,
             'l' : s64,
             'L' : u64}
+
+to_typecode = {f32.value : 'f',
+               f64.value : 'd',
+               b8.value : 'b',
+               u8.value : 'B',
+               s32.value : 'i',
+               u32.value : 'I',
+               s64.value : 'l',
+               u64.value : 'L'}
+
+to_c_type = {f32.value : ct.c_float,
+             f64.value : ct.c_double,
+             b8.value : ct.c_char,
+             u8.value : ct.c_ubyte,
+             s32.value : ct.c_int,
+             u32.value : ct.c_uint,
+             s64.value : ct.c_longlong,
+             u64.value : ct.c_ulonglong}

tests/simple_array.py

@@ -66,3 +66,23 @@
 af.display(a)
 a[idx, idx] = af.randu(3,3)
 af.display(a)
+
+af.display(af.transpose(a))
+
+af.transpose_inplace(a)
+af.display(a)
+
+c = a.to_ctype()
+for n in range(a.elements()):
+    print(c[n])
+
+c,s = a.to_ctype(True, True)
+for n in range(a.elements()):
+    print(c[n])
+print(s)
+
+arr = a.to_array()
+lst = a.to_list(True)
+
+print(arr)
+print(lst)

tests/simple_blas.py

@@ -19,8 +19,3 @@
 
 b = af.randu(5,1)
 af.display(af.dot(b,b))
-
-af.display(af.transpose(a))
-
-af.transpose_inplace(a)
-af.display(a)