STYLE: Changing array class to Array to comply with python style guide

- Also helps in avoiding path conflicts and

Author: pavanky

arrayfire/__init__.py

@@ -32,7 +32,7 @@
 del os
 
 #do not export internal classes
-del base_array
+del BaseArray
 del uidx
 del seq
 del index

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()
+    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()
+    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 = number_dtype(rhs)
-        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 = number_dtype(lhs)
-        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

@@ -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 = number_dtype(rhs)
-        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 = number_dtype(lhs)
-        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
 
@@ -424,7 +424,7 @@ def __nonzero__(self):
 
     def __getitem__(self, key):
         try:
-            out = array()
+            out = Array()
             n_dims = self.numdims()
             inds = get_indices(key, n_dims)
 

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_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()
+    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()
+    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()
+    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()
+    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()
+    out = Array()
     safe_call(clib.af_dot(ct.pointer(out.arr), lhs.arr, rhs.arr,\
                           lhs_opts, rhs_opts))
     return out

arrayfire/data.py

@@ -13,7 +13,7 @@
 from .util import *
 
 def constant(val, d0, d1=None, d2=None, d3=None, dtype=f32):
-    out = array()
+    out = Array()
     out.arr = constant_array(val, d0, d1, d2, d3, dtype)
     return out
 
@@ -28,7 +28,7 @@ def range(d0, d1=None, d2=None, d3=None, dim=-1, dtype=f32):
         else:
             raise TypeError("Invalid dtype")
 
-    out = array()
+    out = Array()
     dims = dim4(d0, d1, d2, d3)
 
     safe_call(clib.af_range(ct.pointer(out.arr), 4, ct.pointer(dims), dim, dtype))
@@ -42,7 +42,7 @@ def iota(d0, d1=None, d2=None, d3=None, dim=-1, tile_dims=None, dtype=f32):
         else:
             raise TypeError("Invalid dtype")
 
-    out = array()
+    out = Array()
     dims = dim4(d0, d1, d2, d3)
     td=[1]*4
 
@@ -63,7 +63,7 @@ def randu(d0, d1=None, d2=None, d3=None, dtype=f32):
         else:
             raise TypeError("Invalid dtype")
 
-    out = array()
+    out = Array()
     dims = dim4(d0, d1, d2, d3)
 
     safe_call(clib.af_randu(ct.pointer(out.arr), 4, ct.pointer(dims), dtype))
@@ -77,7 +77,7 @@ def randn(d0, d1=None, d2=None, d3=None, dtype=f32):
         else:
             raise TypeError("Invalid dtype")
 
-    out = array()
+    out = Array()
     dims = dim4(d0, d1, d2, d3)
 
     safe_call(clib.af_randn(ct.pointer(out.arr), 4, ct.pointer(dims), dtype))
@@ -99,22 +99,22 @@ def identity(d0, d1=None, d2=None, d3=None, dtype=f32):
         else:
             raise TypeError("Invalid dtype")
 
-    out = array()
+    out = Array()
     dims = dim4(d0, d1, d2, d3)
 
     safe_call(clib.af_identity(ct.pointer(out.arr), 4, ct.pointer(dims), dtype))
     return out
 
 def diag(a, num=0, extract=True):
-    out = array()
+    out = Array()
     if extract:
         safe_call(clib.af_diag_extract(ct.pointer(out.arr), a.arr, ct.c_int(num)))
     else:
         safe_call(clib.af_diag_create(ct.pointer(out.arr), a.arr, ct.c_int(num)))
     return out
 
 def join(dim, first, second, third=None, fourth=None):
-    out = array()
+    out = Array()
     if (third is None and fourth is None):
         safe_call(clib.af_join(ct.pointer(out.arr), dim, first.arr, second.arr))
     else:
@@ -131,43 +131,43 @@ def join(dim, first, second, third=None, fourth=None):
 
 
 def tile(a, d0, d1=1, d2=1, d3=1):
-    out = array()
+    out = Array()
     safe_call(clib.af_tile(ct.pointer(out.arr), a.arr, d0, d1, d2, d3))
     return out
 
 
 def reorder(a, d0=1, d1=0, d2=2, d3=3):
-    out = array()
+    out = Array()
     safe_call(clib.af_reorder(ct.pointer(out.arr), a.arr, d0, d1, d2, d3))
     return out
 
 def shift(a, d0, d1=0, d2=0, d3=0):
-    out = array()
+    out = Array()
     safe_call(clib.af_shift(ct.pointer(out.arr), a.arr, d0, d1, d2, d3))
     return out
 
 def moddims(a, d0, d1=1, d2=1, d3=1):
-    out = array()
+    out = Array()
     dims = dim4(d0, d1, d2, d3)
     safe_call(clib.af_moddims(ct.pointer(out.arr), a.arr, 4, ct.pointer(dims)))
     return out
 
 def flat(a):
-    out = array()
+    out = Array()
     safe_call(clib.af_flat(ct.pointer(out.arr), a.arr))
     return out
 
 def flip(a, dim=0):
-    out = array()
+    out = Array()
     safe_call(clib.af_flip(ct.pointer(out.arr), a.arr, ct.c_int(dim)))
     return out
 
 def lower(a, is_unit_diag=False):
-    out = array()
+    out = Array()
     safe_call(clib.af_lower(ct.pointer(out.arr), a.arr, is_unit_diag))
     return out
 
 def upper(a, is_unit_diag=False):
-    out = array()
+    out = Array()
     safe_call(clib.af_upper(ct.pointer(out.arr), a.arr, is_unit_diag))
     return out