Syle changes and converting util functions to be private

Author: pavanky

arrayfire/__init__.py

@@ -31,31 +31,7 @@
 del numbers
 del os
 
-#do not export internal classes
-del BaseArray
-del uidx
-del Seq
-del Index
-del Cell
-del bcast
-
 #do not export internal functions
-del binary_func
-del binary_funcr
-del create_array
-del constant_array
-del parallel_dim
-del reduce_all
-del arith_unary_func
-del arith_binary_func
-del brange
-del dim4_tuple
+del bcast
 del is_number
-del to_str
 del safe_call
-del get_indices
-del get_assign_dims
-del slice_to_length
-del ctype_to_lists
-del to_dtype
-del to_c_type

arrayfire/algorithm.py

@@ -10,12 +10,12 @@
 from .library import *
 from .array import *
 
-def parallel_dim(a, dim, c_func):
+def _parallel_dim(a, dim, c_func):
     out = Array()
     safe_call(c_func(ct.pointer(out.arr), a.arr, ct.c_int(dim)))
     return out
 
-def reduce_all(a, c_func):
+def _reduce_all(a, c_func):
     real = ct.c_double(0)
     imag = ct.c_double(0)
     safe_call(c_func(ct.pointer(real), ct.pointer(imag), a.arr))
@@ -25,45 +25,45 @@ def reduce_all(a, c_func):
 
 def sum(a, dim=None):
     if dim is not None:
-        return parallel_dim(a, dim, backend.get().af_sum)
+        return _parallel_dim(a, dim, backend.get().af_sum)
     else:
-        return reduce_all(a, backend.get().af_sum_all)
+        return _reduce_all(a, backend.get().af_sum_all)
 
 def product(a, dim=None):
     if dim is not None:
-        return parallel_dim(a, dim, backend.get().af_product)
+        return _parallel_dim(a, dim, backend.get().af_product)
     else:
-        return reduce_all(a, backend.get().af_product_all)
+        return _reduce_all(a, backend.get().af_product_all)
 
 def min(a, dim=None):
     if dim is not None:
-        return parallel_dim(a, dim, backend.get().af_min)
+        return _parallel_dim(a, dim, backend.get().af_min)
     else:
-        return reduce_all(a, backend.get().af_min_all)
+        return _reduce_all(a, backend.get().af_min_all)
 
 def max(a, dim=None):
     if dim is not None:
-        return parallel_dim(a, dim, backend.get().af_max)
+        return _parallel_dim(a, dim, backend.get().af_max)
     else:
-        return reduce_all(a, backend.get().af_max_all)
+        return _reduce_all(a, backend.get().af_max_all)
 
 def all_true(a, dim=None):
     if dim is not None:
-        return parallel_dim(a, dim, backend.get().af_all_true)
+        return _parallel_dim(a, dim, backend.get().af_all_true)
     else:
-        return reduce_all(a, backend.get().af_all_true_all)
+        return _reduce_all(a, backend.get().af_all_true_all)
 
 def any_true(a, dim=None):
     if dim is not None:
-        return parallel_dim(a, dim, backend.get().af_any_true)
+        return _parallel_dim(a, dim, backend.get().af_any_true)
     else:
-        return reduce_all(a, backend.get().af_any_true_all)
+        return _reduce_all(a, backend.get().af_any_true_all)
 
 def count(a, dim=None):
     if dim is not None:
-        return parallel_dim(a, dim, backend.get().af_count)
+        return _parallel_dim(a, dim, backend.get().af_count)
     else:
-        return reduce_all(a, backend.get().af_count_all)
+        return _reduce_all(a, backend.get().af_count_all)
 
 def imin(a, dim=None):
     if dim is not None:
@@ -99,18 +99,18 @@ def imax(a, dim=None):
 
 
 def accum(a, dim=0):
-    return parallel_dim(a, dim, backend.get().af_accum)
+    return _parallel_dim(a, dim, backend.get().af_accum)
 
 def where(a):
     out = Array()
     safe_call(backend.get().af_where(ct.pointer(out.arr), a.arr))
     return out
 
 def diff1(a, dim=0):
-    return parallel_dim(a, dim, backend.get().af_diff1)
+    return _parallel_dim(a, dim, backend.get().af_diff1)
 
 def diff2(a, dim=0):
-    return parallel_dim(a, dim, backend.get().af_diff2)
+    return _parallel_dim(a, dim, backend.get().af_diff2)
 
 def sort(a, dim=0, is_ascending=True):
     out = Array()
@@ -121,14 +121,14 @@ def sort_index(a, dim=0, is_ascending=True):
     out = Array()
     idx = Array()
     safe_call(backend.get().af_sort_index(ct.pointer(out.arr), ct.pointer(idx.arr), a.arr,
-                                 ct.c_uint(dim), ct.c_bool(is_ascending)))
+                                          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(backend.get().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)))
+                                           iv.arr, ik.arr, ct.c_uint(dim), ct.c_bool(is_ascending)))
     return ov,ok
 
 def set_unique(a, is_sorted=False):

arrayfire/arith.py

@@ -11,7 +11,7 @@
 from .array import *
 from .broadcast import *
 
-def arith_binary_func(lhs, rhs, c_func):
+def _arith_binary_func(lhs, rhs, c_func):
     out = Array()
 
     is_left_array = isinstance(lhs, Array)
@@ -24,22 +24,22 @@ def arith_binary_func(lhs, rhs, c_func):
         safe_call(c_func(ct.pointer(out.arr), lhs.arr, rhs.arr, bcast.get()))
 
     elif (is_number(rhs)):
-        ldims = dim4_tuple(lhs.dims())
+        ldims = dim4_to_tuple(lhs.dims())
         rty = implicit_dtype(rhs, lhs.type())
         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())
+        rdims = dim4_to_tuple(rhs.dims())
         lty = implicit_dtype(lhs, rhs.type())
         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):
+def _arith_unary_func(a, c_func):
     out = Array()
     safe_call(c_func(ct.pointer(out.arr), a.arr))
     return out
@@ -50,145 +50,145 @@ def cast(a, dtype=f32):
     return out
 
 def minof(lhs, rhs):
-    return arith_binary_func(lhs, rhs, backend.get().af_minof)
+    return _arith_binary_func(lhs, rhs, backend.get().af_minof)
 
 def maxof(lhs, rhs):
-    return arith_binary_func(lhs, rhs, backend.get().af_maxof)
+    return _arith_binary_func(lhs, rhs, backend.get().af_maxof)
 
 def rem(lhs, rhs):
-    return arith_binary_func(lhs, rhs, backend.get().af_rem)
+    return _arith_binary_func(lhs, rhs, backend.get().af_rem)
 
 def abs(a):
-    return arith_unary_func(a, backend.get().af_abs)
+    return _arith_unary_func(a, backend.get().af_abs)
 
 def arg(a):
-    return arith_unary_func(a, backend.get().af_arg)
+    return _arith_unary_func(a, backend.get().af_arg)
 
 def sign(a):
-    return arith_unary_func(a, backend.get().af_sign)
+    return _arith_unary_func(a, backend.get().af_sign)
 
 def round(a):
-    return arith_unary_func(a, backend.get().af_round)
+    return _arith_unary_func(a, backend.get().af_round)
 
 def trunc(a):
-    return arith_unary_func(a, backend.get().af_trunc)
+    return _arith_unary_func(a, backend.get().af_trunc)
 
 def floor(a):
-    return arith_unary_func(a, backend.get().af_floor)
+    return _arith_unary_func(a, backend.get().af_floor)
 
 def ceil(a):
-    return arith_unary_func(a, backend.get().af_ceil)
+    return _arith_unary_func(a, backend.get().af_ceil)
 
 def hypot(lhs, rhs):
-    return arith_binary_func(lhs, rhs, backend.get().af_hypot)
+    return _arith_binary_func(lhs, rhs, backend.get().af_hypot)
 
 def sin(a):
-    return arith_unary_func(a, backend.get().af_sin)
+    return _arith_unary_func(a, backend.get().af_sin)
 
 def cos(a):
-    return arith_unary_func(a, backend.get().af_cos)
+    return _arith_unary_func(a, backend.get().af_cos)
 
 def tan(a):
-    return arith_unary_func(a, backend.get().af_tan)
+    return _arith_unary_func(a, backend.get().af_tan)
 
 def asin(a):
-    return arith_unary_func(a, backend.get().af_asin)
+    return _arith_unary_func(a, backend.get().af_asin)
 
 def acos(a):
-    return arith_unary_func(a, backend.get().af_acos)
+    return _arith_unary_func(a, backend.get().af_acos)
 
 def atan(a):
-    return arith_unary_func(a, backend.get().af_atan)
+    return _arith_unary_func(a, backend.get().af_atan)
 
 def atan2(lhs, rhs):
-    return arith_binary_func(lhs, rhs, backend.get().af_atan2)
+    return _arith_binary_func(lhs, rhs, backend.get().af_atan2)
 
 def cplx(lhs, rhs=None):
     if rhs is None:
-        return arith_unary_func(lhs, backend.get().af_cplx)
+        return _arith_unary_func(lhs, backend.get().af_cplx)
     else:
-        return arith_binary_func(lhs, rhs, backend.get().af_cplx2)
+        return _arith_binary_func(lhs, rhs, backend.get().af_cplx2)
 
 def real(lhs):
-    return arith_unary_func(lhs, backend.get().af_real)
+    return _arith_unary_func(lhs, backend.get().af_real)
 
 def imag(lhs):
-    return arith_unary_func(lhs, backend.get().af_imag)
+    return _arith_unary_func(lhs, backend.get().af_imag)
 
 def conjg(lhs):
-    return arith_unary_func(lhs, backend.get().af_conjg)
+    return _arith_unary_func(lhs, backend.get().af_conjg)
 
 def sinh(a):
-    return arith_unary_func(a, backend.get().af_sinh)
+    return _arith_unary_func(a, backend.get().af_sinh)
 
 def cosh(a):
-    return arith_unary_func(a, backend.get().af_cosh)
+    return _arith_unary_func(a, backend.get().af_cosh)
 
 def tanh(a):
-    return arith_unary_func(a, backend.get().af_tanh)
+    return _arith_unary_func(a, backend.get().af_tanh)
 
 def asinh(a):
-    return arith_unary_func(a, backend.get().af_asinh)
+    return _arith_unary_func(a, backend.get().af_asinh)
 
 def acosh(a):
-    return arith_unary_func(a, backend.get().af_acosh)
+    return _arith_unary_func(a, backend.get().af_acosh)
 
 def atanh(a):
-    return arith_unary_func(a, backend.get().af_atanh)
+    return _arith_unary_func(a, backend.get().af_atanh)
 
 def root(lhs, rhs):
-    return arith_binary_func(lhs, rhs, backend.get().af_root)
+    return _arith_binary_func(lhs, rhs, backend.get().af_root)
 
 def pow(lhs, rhs):
-    return arith_binary_func(lhs, rhs, backend.get().af_pow)
+    return _arith_binary_func(lhs, rhs, backend.get().af_pow)
 
 def pow2(a):
-    return arith_unary_func(a, backend.get().af_pow2)
+    return _arith_unary_func(a, backend.get().af_pow2)
 
 def exp(a):
-    return arith_unary_func(a, backend.get().af_exp)
+    return _arith_unary_func(a, backend.get().af_exp)
 
 def expm1(a):
-    return arith_unary_func(a, backend.get().af_expm1)
+    return _arith_unary_func(a, backend.get().af_expm1)
 
 def erf(a):
-    return arith_unary_func(a, backend.get().af_erf)
+    return _arith_unary_func(a, backend.get().af_erf)
 
 def erfc(a):
-    return arith_unary_func(a, backend.get().af_erfc)
+    return _arith_unary_func(a, backend.get().af_erfc)
 
 def log(a):
-    return arith_unary_func(a, backend.get().af_log)
+    return _arith_unary_func(a, backend.get().af_log)
 
 def log1p(a):
-    return arith_unary_func(a, backend.get().af_log1p)
+    return _arith_unary_func(a, backend.get().af_log1p)
 
 def log10(a):
-    return arith_unary_func(a, backend.get().af_log10)
+    return _arith_unary_func(a, backend.get().af_log10)
 
 def log2(a):
-    return arith_unary_func(a, backend.get().af_log2)
+    return _arith_unary_func(a, backend.get().af_log2)
 
 def sqrt(a):
-    return arith_unary_func(a, backend.get().af_sqrt)
+    return _arith_unary_func(a, backend.get().af_sqrt)
 
 def cbrt(a):
-    return arith_unary_func(a, backend.get().af_cbrt)
+    return _arith_unary_func(a, backend.get().af_cbrt)
 
 def factorial(a):
-    return arith_unary_func(a, backend.get().af_factorial)
+    return _arith_unary_func(a, backend.get().af_factorial)
 
 def tgamma(a):
-    return arith_unary_func(a, backend.get().af_tgamma)
+    return _arith_unary_func(a, backend.get().af_tgamma)
 
 def lgamma(a):
-    return arith_unary_func(a, backend.get().af_lgamma)
+    return _arith_unary_func(a, backend.get().af_lgamma)
 
 def iszero(a):
-    return arith_unary_func(a, backend.get().af_iszero)
+    return _arith_unary_func(a, backend.get().af_iszero)
 
 def isinf(a):
-    return arith_unary_func(a, backend.get().af_isinf)
+    return _arith_unary_func(a, backend.get().af_isinf)
 
 def isnan(a):
-    return arith_unary_func(a, backend.get().af_isnan)
+    return _arith_unary_func(a, backend.get().af_isnan)