Merge pull request #23 from pavanky/cleanup

Style clean up

Author: pavanky

arrayfire/__init__.py

@@ -32,11 +32,11 @@
 del os
 
 #do not export internal classes
-del base_array
+del BaseArray
 del uidx
-del seq
-del index
-del cell
+del Seq
+del Index
+del Cell
 del bcast
 
 #do not export internal functions

arrayfire/algorithm.py

@@ -11,7 +11,7 @@
 from .array import *
 
 def parallel_dim(a, dim, c_func):
-    out = array()
+    out = Array()
     safe_call(c_func(ct.pointer(out.arr), a.arr, ct.c_int(dim)))
     return out
 
@@ -67,8 +67,8 @@ def count(a, dim=None):
 
 def imin(a, dim=None):
     if dim is not None:
-        out = array()
-        idx = array()
+        out = Array()
+        idx = Array()
         safe_call(clib.af_imin(ct.pointer(out.arr), ct.pointer(idx.arr), a.arr, ct.c_int(dim)))
         return out,idx
     else:
@@ -83,8 +83,8 @@ def imin(a, dim=None):
 
 def imax(a, dim=None):
     if dim is not None:
-        out = array()
-        idx = array()
+        out = Array()
+        idx = Array()
         safe_call(clib.af_imax(ct.pointer(out.arr), ct.pointer(idx.arr), a.arr, ct.c_int(dim)))
         return out,idx
     else:
@@ -102,7 +102,7 @@ def accum(a, dim=0):
     return parallel_dim(a, dim, clib.af_accum)
 
 def where(a):
-    out = array()
+    out = Array()
     safe_call(clib.af_where(ct.pointer(out.arr), a.arr))
     return out
 
@@ -113,35 +113,35 @@ def diff2(a, dim=0):
     return parallel_dim(a, dim, clib.af_diff2)
 
 def sort(a, dim=0, is_ascending=True):
-    out = array()
+    out = Array()
     safe_call(clib.af_sort(ct.pointer(out.arr), a.arr, ct.c_uint(dim), ct.c_bool(is_ascending)))
     return out
 
 def sort_index(a, dim=0, is_ascending=True):
-    out = array()
-    idx = array()
-    safe_call(clib.af_sort_index(ct.pointer(out.arr), ct.pointer(idx.arr), a.arr, \
+    out = Array()
+    idx = Array()
+    safe_call(clib.af_sort_index(ct.pointer(out.arr), ct.pointer(idx.arr), a.arr,
                                  ct.c_uint(dim), ct.c_bool(is_ascending)))
     return out,idx
 
 def sort_by_key(iv, ik, dim=0, is_ascending=True):
-    ov = array()
-    ok = array()
-    safe_call(clib.af_sort_by_key(ct.pointer(ov.arr), ct.pointer(ok.arr), \
+    ov = Array()
+    ok = Array()
+    safe_call(clib.af_sort_by_key(ct.pointer(ov.arr), ct.pointer(ok.arr),
                                   iv.arr, ik.arr, ct.c_uint(dim), ct.c_bool(is_ascending)))
     return ov,ok
 
 def set_unique(a, is_sorted=False):
-    out = array()
+    out = Array()
     safe_call(clib.af_set_unique(ct.pointer(out.arr), a.arr, ct.c_bool(is_sorted)))
     return out
 
 def set_union(a, b, is_unique=False):
-    out = array()
+    out = Array()
     safe_call(clib.af_set_union(ct.pointer(out.arr), a.arr, b.arr, ct.c_bool(is_unique)))
     return out
 
 def set_intersect(a, b, is_unique=False):
-    out = array()
+    out = Array()
     safe_call(clib.af_set_intersect(ct.pointer(out.arr), a.arr, b.arr, ct.c_bool(is_unique)))
     return out

arrayfire/arith.py

@@ -12,10 +12,10 @@
 from .broadcast import *
 
 def arith_binary_func(lhs, rhs, c_func):
-    out = array()
+    out = Array()
 
-    is_left_array = isinstance(lhs, array)
-    is_right_array = isinstance(rhs, array)
+    is_left_array = isinstance(lhs, Array)
+    is_right_array = isinstance(rhs, Array)
 
     if not (is_left_array or is_right_array):
         raise TypeError("Atleast one input needs to be of type arrayfire.array")
@@ -26,26 +26,26 @@ def arith_binary_func(lhs, rhs, c_func):
     elif (is_number(rhs)):
         ldims = dim4_tuple(lhs.dims())
         rty = implicit_dtype(rhs, lhs.type())
-        other = array()
+        other = Array()
         other.arr = constant_array(rhs, ldims[0], ldims[1], ldims[2], ldims[3], rty)
         safe_call(c_func(ct.pointer(out.arr), lhs.arr, other.arr, bcast.get()))
 
     else:
         rdims = dim4_tuple(rhs.dims())
         lty = implicit_dtype(lhs, rhs.type())
-        other = array()
+        other = Array()
         other.arr = constant_array(lhs, rdims[0], rdims[1], rdims[2], rdims[3], lty)
         safe_call(c_func(ct.pointer(out.arr), other.arr, rhs.arr, bcast.get()))
 
     return out
 
 def arith_unary_func(a, c_func):
-    out = array()
+    out = Array()
     safe_call(c_func(ct.pointer(out.arr), a.arr))
     return out
 
 def cast(a, dtype=f32):
-    out=array()
+    out=Array()
     safe_call(clib.af_cast(ct.pointer(out.arr), a.arr, dtype))
     return out
 

arrayfire/array.py

@@ -15,10 +15,10 @@
 from .index import *
 
 def create_array(buf, numdims, idims, dtype):
-    out_arr = ct.c_longlong(0)
-    ct.c_dims = dim4(idims[0], idims[1], idims[2], idims[3])
-    safe_call(clib.af_create_array(ct.pointer(out_arr), ct.c_longlong(buf),\
-                                   numdims, ct.pointer(ct.c_dims), dtype))
+    out_arr = ct.c_void_p(0)
+    c_dims = dim4(idims[0], idims[1], idims[2], idims[3])
+    safe_call(clib.af_create_array(ct.pointer(out_arr), ct.c_void_p(buf),
+                                   numdims, ct.pointer(c_dims), dtype))
     return out_arr
 
 def constant_array(val, d0, d1=None, d2=None, d3=None, dtype=f32):
@@ -29,7 +29,7 @@ def constant_array(val, d0, d1=None, d2=None, d3=None, dtype=f32):
         else:
             raise TypeError("Invalid dtype")
 
-    out = ct.c_longlong(0)
+    out = ct.c_void_p(0)
     dims = dim4(d0, d1, d2, d3)
 
     if isinstance(val, complex):
@@ -39,7 +39,7 @@ def constant_array(val, d0, d1=None, d2=None, d3=None, dtype=f32):
         if (dtype != c32 and dtype != c64):
             dtype = c32
 
-        safe_call(clib.af_constant_complex(ct.pointer(out), c_real, c_imag,\
+        safe_call(clib.af_constant_complex(ct.pointer(out), c_real, c_imag,
                                            4, ct.pointer(dims), dtype))
     elif dtype == s64:
         c_val = ct.c_longlong(val.real)
@@ -55,39 +55,39 @@ def constant_array(val, d0, d1=None, d2=None, d3=None, dtype=f32):
 
 
 def binary_func(lhs, rhs, c_func):
-    out = array()
+    out = Array()
     other = rhs
 
     if (is_number(rhs)):
         ldims = dim4_tuple(lhs.dims())
         rty = implicit_dtype(rhs, lhs.type())
-        other = array()
+        other = Array()
         other.arr = constant_array(rhs, ldims[0], ldims[1], ldims[2], ldims[3], rty)
-    elif not isinstance(rhs, array):
+    elif not isinstance(rhs, Array):
         raise TypeError("Invalid parameter to binary function")
 
     safe_call(c_func(ct.pointer(out.arr), lhs.arr, other.arr, bcast.get()))
 
     return out
 
 def binary_funcr(lhs, rhs, c_func):
-    out = array()
+    out = Array()
     other = lhs
 
     if (is_number(lhs)):
         rdims = dim4_tuple(rhs.dims())
         lty = implicit_dtype(lhs, rhs.type())
-        other = array()
+        other = Array()
         other.arr = constant_array(lhs, rdims[0], rdims[1], rdims[2], rdims[3], lty)
-    elif not isinstance(lhs, array):
+    elif not isinstance(lhs, Array):
         raise TypeError("Invalid parameter to binary function")
 
     c_func(ct.pointer(out.arr), other.arr, rhs.arr, bcast.get())
 
     return out
 
 def transpose(a, conj=False):
-    out = array()
+    out = Array()
     safe_call(clib.af_transpose(ct.pointer(out.arr), a.arr, conj))
     return out
 
@@ -124,11 +124,11 @@ def get_info(dims, buf_len):
     return numdims, idims
 
 
-class array(base_array):
+class Array(BaseArray):
 
     def __init__(self, src=None, dims=(0,), type_char=None):
 
-        super(array, self).__init__()
+        super(Array, self).__init__()
 
         buf=None
         buf_len=0
@@ -137,7 +137,7 @@ def __init__(self, src=None, dims=(0,), type_char=None):
 
         if src is not None:
 
-            if (isinstance(src, array)):
+            if (isinstance(src, Array)):
                 safe_call(clib.af_retain_array(ct.pointer(self.arr), src.arr))
                 return
 
@@ -178,7 +178,7 @@ def __init__(self, src=None, dims=(0,), type_char=None):
             self.arr = create_array(buf, numdims, idims, to_dtype[_type_char])
 
     def copy(self):
-        out = array()
+        out = Array()
         safe_call(clib.af_copy_array(ct.pointer(out.arr), self.arr))
         return out
 
@@ -187,7 +187,7 @@ def __del__(self):
             clib.af_release_array(self.arr)
 
     def device_ptr(self):
-        ptr = ctypes.c_void_p(0)
+        ptr = ct.c_void_p(0)
         clib.af_get_device_ptr(ct.pointer(ptr), self.arr)
         return ptr.value
 
@@ -206,7 +206,7 @@ def dims(self):
         d1 = ct.c_longlong(0)
         d2 = ct.c_longlong(0)
         d3 = ct.c_longlong(0)
-        safe_call(clib.af_get_dims(ct.pointer(d0), ct.pointer(d1),\
+        safe_call(clib.af_get_dims(ct.pointer(d0), ct.pointer(d1),
                                    ct.pointer(d2), ct.pointer(d3), self.arr))
         dims = (d0.value,d1.value,d2.value,d3.value)
         return dims[:self.numdims()]
@@ -424,11 +424,11 @@ def __nonzero__(self):
 
     def __getitem__(self, key):
         try:
-            out = array()
+            out = Array()
             n_dims = self.numdims()
             inds = get_indices(key, n_dims)
 
-            safe_call(clib.af_index_gen(ct.pointer(out.arr),\
+            safe_call(clib.af_index_gen(ct.pointer(out.arr),
                                         self.arr, ct.c_longlong(n_dims), ct.pointer(inds)))
             return out
         except RuntimeError as e:
@@ -445,11 +445,11 @@ def __setitem__(self, key, val):
             else:
                 other_arr = val.arr
 
-            out_arr = ct.c_longlong(0)
+            out_arr = ct.c_void_p(0)
             inds  = get_indices(key, n_dims)
 
-            safe_call(clib.af_assign_gen(ct.pointer(out_arr),\
-                                         self.arr, ct.c_longlong(n_dims), ct.pointer(inds),\
+            safe_call(clib.af_assign_gen(ct.pointer(out_arr),
+                                         self.arr, ct.c_longlong(n_dims), ct.pointer(inds),
                                          other_arr))
             safe_call(clib.af_release_array(self.arr))
             self.arr = out_arr

arrayfire/base.py

@@ -9,6 +9,6 @@
 from .library import *
 from .util import *
 
-class base_array(object):
+class BaseArray(object):
     def __init__(self):
-        self.arr = ct.c_longlong(0)
+        self.arr = ct.c_void_p(0)

arrayfire/blas.py

@@ -11,31 +11,31 @@
 from .array import *
 
 def matmul(lhs, rhs, lhs_opts=AF_MAT_NONE, rhs_opts=AF_MAT_NONE):
-    out = array()
-    safe_call(clib.af_matmul(ct.pointer(out.arr), lhs.arr, rhs.arr,\
+    out = Array()
+    safe_call(clib.af_matmul(ct.pointer(out.arr), lhs.arr, rhs.arr,
                              lhs_opts, rhs_opts))
     return out
 
 def matmulTN(lhs, rhs):
-    out = array()
-    safe_call(clib.af_matmul(ct.pointer(out.arr), lhs.arr, rhs.arr,\
+    out = Array()
+    safe_call(clib.af_matmul(ct.pointer(out.arr), lhs.arr, rhs.arr,
                              AF_MAT_TRANS, AF_MAT_NONE))
     return out
 
 def matmulNT(lhs, rhs):
-    out = array()
-    safe_call(clib.af_matmul(ct.pointer(out.arr), lhs.arr, rhs.arr,\
+    out = Array()
+    safe_call(clib.af_matmul(ct.pointer(out.arr), lhs.arr, rhs.arr,
                              AF_MAT_NONE, AF_MAT_TRANS))
     return out
 
 def matmulTT(lhs, rhs):
-    out = array()
-    safe_call(clib.af_matmul(ct.pointer(out.arr), lhs.arr, rhs.arr,\
+    out = Array()
+    safe_call(clib.af_matmul(ct.pointer(out.arr), lhs.arr, rhs.arr,
                              AF_MAT_TRANS, AF_MAT_TRANS))
     return out
 
 def dot(lhs, rhs, lhs_opts=AF_MAT_NONE, rhs_opts=AF_MAT_NONE):
-    out = array()
-    safe_call(clib.af_dot(ct.pointer(out.arr), lhs.arr, rhs.arr,\
+    out = Array()
+    safe_call(clib.af_dot(ct.pointer(out.arr), lhs.arr, rhs.arr,
                           lhs_opts, rhs_opts))
     return out