Capitalizing the class names for Seq, Index, ParallelRange and Cell

Author: pavanky

arrayfire/__init__.py

@@ -34,9 +34,9 @@
 #do not export internal classes
 del BaseArray
 del uidx
-del seq
-del index
-del cell
+del Seq
+del Index
+del Cell
 del bcast
 
 #do not export internal functions

arrayfire/features.py

@@ -10,7 +10,7 @@
 from .array import *
 import numbers
 
-class features(object):
+class Features(object):
 
     def __init__(self, num=None):
         self.feat = ct.c_void_p(0)

arrayfire/graphics.py

@@ -10,7 +10,7 @@
 from .library import *
 from .array import *
 
-class cell(ct.Structure):
+class Cell(ct.Structure):
     _fields_ = [("row", ct.c_int),
                 ("col", ct.c_int),
                 ("title", ct.c_char_p),
@@ -52,15 +52,15 @@ def set_colormap(self, cmap):
         self._cmap = cmap
 
     def image(self, img, title=None):
-        _cell = cell(self._r, self._c, title, self._cmap)
+        _cell = Cell(self._r, self._c, title, self._cmap)
         safe_call(clib.af_draw_image(self._wnd, img.arr, ct.pointer(_cell)))
 
     def plot(self, X, Y, title=None):
-        _cell = cell(self._r, self._c, title, self._cmap)
+        _cell = Cell(self._r, self._c, title, self._cmap)
         safe_call(clib.af_draw_plot(self._wnd, X.arr, Y.arr, ct.pointer(_cell)))
 
     def hist(self, X, min_val, max_val, title=None):
-        _cell = cell(self._r, self._c, title, self._cmap)
+        _cell = Cell(self._r, self._c, title, self._cmap)
         safe_call(clib.af_draw_hist(self._wnd, X.arr, \
                                     ct.c_double(max_val), ct.c_double(min_val),\
                                     ct.pointer(_cell)))

arrayfire/index.py

@@ -11,7 +11,7 @@
 from .base import *
 from .broadcast import *
 
-class seq(ct.Structure):
+class Seq(ct.Structure):
     _fields_ = [("begin", ct.c_double),
                 ("end"  , ct.c_double),
                 ("step" , ct.c_double)]
@@ -36,7 +36,7 @@ def __init__ (self, S):
         else:
             raise IndexError("Invalid type while indexing arrayfire.array")
 
-class parallel_range(seq):
+class ParallelRange(Seq):
 
     def __init__(self, start, stop=None, step=None):
 
@@ -45,7 +45,7 @@ def __init__(self, start, stop=None, step=None):
             start = 0
 
         self.S = slice(start, stop, step)
-        super(parallel_range, self).__init__(self.S)
+        super(ParallelRange, self).__init__(self.S)
 
     def __iter__(self):
         return self
@@ -81,9 +81,9 @@ def slice_to_length(key, dim):
 
 class uidx(ct.Union):
     _fields_ = [("arr", ct.c_void_p),
-                ("seq", seq)]
+                ("seq", Seq)]
 
-class index(ct.Structure):
+class Index(ct.Structure):
     _fields_ = [("idx", uidx),
                 ("isSeq", ct.c_bool),
                 ("isBatch", ct.c_bool)]
@@ -97,26 +97,26 @@ def __init__ (self, idx):
         if isinstance(idx, BaseArray):
             self.idx.arr = idx.arr
             self.isSeq   = False
-        elif isinstance(idx, parallel_range):
+        elif isinstance(idx, ParallelRange):
             self.idx.seq = idx
             self.isBatch = True
         else:
-            self.idx.seq = seq(idx)
+            self.idx.seq = Seq(idx)
 
 def get_indices(key, n_dims):
 
-    index_vec = index * n_dims
+    index_vec = Index * n_dims
     inds = index_vec()
 
     for n in range(n_dims):
-        inds[n] = index(slice(None))
+        inds[n] = Index(slice(None))
 
     if isinstance(key, tuple):
         n_idx = len(key)
         for n in range(n_idx):
-            inds[n] = index(key[n])
+            inds[n] = Index(key[n])
     else:
-        inds[0] = index(key)
+        inds[0] = Index(key)
 
     return inds
 
@@ -133,7 +133,7 @@ def get_assign_dims(key, idims):
     elif isinstance(key, slice):
         dims[0] = slice_to_length(key, idims[0])
         return dims
-    elif isinstance(key, parallel_range):
+    elif isinstance(key, ParallelRange):
         dims[0] = slice_to_length(key.S, idims[0])
         return dims
     elif isinstance(key, BaseArray):
@@ -152,7 +152,7 @@ def get_assign_dims(key, idims):
                 dims[n] = key[n].elements()
             elif (isinstance(key[n], slice)):
                 dims[n] = slice_to_length(key[n], idims[n])
-            elif (isinstance(key[n], parallel_range)):
+            elif (isinstance(key[n], ParallelRange)):
                 dims[n] = slice_to_length(key[n].S, idims[n])
             else:
                 raise IndexError("Invalid type while assigning to arrayfire.array")

arrayfire/vision.py

@@ -11,14 +11,14 @@
 from .features import *
 
 def fast(image, threshold=20.0, arc_length=9, non_max=True, feature_ratio=0.05, edge=3):
-    out = features()
+    out = Features()
     safe_call(clib.af_fast(ct.pointer(out.feat),\
                            image.arr, ct.c_float(threshold), ct.c_uint(arc_length), non_max, \
                            ct.c_float(feature_ratio), ct.c_uint(edge)))
     return out
 
 def orb(image, threshold=20.0, max_features=400, scale = 1.5, num_levels = 4, blur_image = False):
-    feat = features()
+    feat = Features()
     desc = Array()
     safe_call(clib.af_orb(ct.pointer(feat.feat), ct.pointer(desc.arr),\
                           ct.c_float(threshold), ct.c_uint(max_features),\

tests/simple_index.py

@@ -8,7 +8,7 @@
 # http://arrayfire.com/licenses/BSD-3-Clause
 ########################################################
 import arrayfire as af
-from arrayfire import parallel_range
+from arrayfire import ParallelRange
 import array as host
 
 a = af.randu(5, 5)
@@ -50,11 +50,11 @@
 b = af.randu(5,1)
 af.display(a)
 af.display(b)
-for ii in parallel_range(1,3):
+for ii in ParallelRange(1,3):
     a[ii] = b[ii]
 
 af.display(a)
 
-for ii in parallel_range(2,5):
+for ii in ParallelRange(2,5):
     b[ii] = 2
 af.display(b)