BUGFIX: Fixing bug for 32 bit architectures

Author: pavanky

arrayfire/array.py

@@ -36,7 +36,7 @@ def _create_strided_array(buf, numdims, idims, dtype, is_device, offset, strides
     c_dims = dim4(idims[0], idims[1], idims[2], idims[3])
     if offset is None:
         offset = 0
-    offset = ct.c_ulonglong(offset)
+    offset = c_dim_t(offset)
     if strides is None:
         strides = (1, idims[0], idims[0]*idims[1], idims[0]*idims[1]*idims[2])
     while len(strides) < 4:
@@ -85,10 +85,10 @@ def constant_array(val, d0, d1=None, d2=None, d3=None, dtype=Dtype.f32):
         safe_call(backend.get().af_constant_complex(ct.pointer(out), c_real, c_imag,
                                                     4, ct.pointer(dims), dtype))
     elif dtype.value == Dtype.s64.value:
-        c_val = ct.c_longlong(val.real)
+        c_val = c_dim_t(val.real)
         safe_call(backend.get().af_constant_long(ct.pointer(out), c_val, 4, ct.pointer(dims)))
     elif dtype.value == Dtype.u64.value:
-        c_val = ct.c_ulonglong(val.real)
+        c_val = c_dim_t(val.real)
         safe_call(backend.get().af_constant_ulong(ct.pointer(out), c_val, 4, ct.pointer(dims)))
     else:
         c_val = ct.c_double(val)
@@ -526,7 +526,7 @@ def offset(self):
         offset : int
                  The offset in number of elements
         """
-        offset = ct.c_longlong(0)
+        offset = c_dim_t(0)
         safe_call(backend.get().af_get_offset(ct.pointer(offset), self.arr))
         return offset.value
 
@@ -539,10 +539,10 @@ def strides(self):
         strides : tuple
                   The strides for each dimension
         """
-        s0 = ct.c_longlong(0)
-        s1 = ct.c_longlong(0)
-        s2 = ct.c_longlong(0)
-        s3 = ct.c_longlong(0)
+        s0 = c_dim_t(0)
+        s1 = c_dim_t(0)
+        s2 = c_dim_t(0)
+        s3 = c_dim_t(0)
         safe_call(backend.get().af_get_strides(ct.pointer(s0), ct.pointer(s1),
                                    ct.pointer(s2), ct.pointer(s3), self.arr))
         strides = (s0.value,s1.value,s2.value,s3.value)
@@ -552,7 +552,7 @@ def elements(self):
         """
         Return the number of elements in the array.
         """
-        num = ct.c_ulonglong(0)
+        num = c_dim_t(0)
         safe_call(backend.get().af_get_elements(ct.pointer(num), self.arr))
         return num.value
 
@@ -574,10 +574,10 @@ def dims(self):
         """
         Return the shape of the array as a tuple.
         """
-        d0 = ct.c_longlong(0)
-        d1 = ct.c_longlong(0)
-        d2 = ct.c_longlong(0)
-        d3 = ct.c_longlong(0)
+        d0 = c_dim_t(0)
+        d1 = c_dim_t(0)
+        d2 = c_dim_t(0)
+        d3 = c_dim_t(0)
         safe_call(backend.get().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)
@@ -994,7 +994,7 @@ def __getitem__(self, key):
             inds = _get_indices(key)
 
             safe_call(backend.get().af_index_gen(ct.pointer(out.arr),
-                                    self.arr, ct.c_longlong(n_dims), inds.pointer))
+                                    self.arr, c_dim_t(n_dims), inds.pointer))
             return out
         except RuntimeError as e:
             raise IndexError(str(e))
@@ -1035,7 +1035,7 @@ def __setitem__(self, key, val):
             inds  = _get_indices(key)
 
             safe_call(backend.get().af_assign_gen(ct.pointer(out_arr),
-                                                  self.arr, ct.c_longlong(n_dims), inds.pointer,
+                                                  self.arr, c_dim_t(n_dims), inds.pointer,
                                                   other_arr))
             safe_call(backend.get().af_release_array(self.arr))
             if del_other:

arrayfire/device.py

@@ -287,7 +287,7 @@ def alloc_device(num_bytes):
     Allocate a buffer on the device with specified number of bytes.
     """
     ptr = ct.c_void_p(0)
-    c_num_bytes = ct.c_longlong(num_bytes)
+    c_num_bytes = c_dim_t(num_bytes)
     safe_call(backend.get().af_alloc_device(ct.pointer(ptr), c_num_bytes))
     return ptr.value
 
@@ -296,7 +296,7 @@ def alloc_host(num_bytes):
     Allocate a buffer on the host with specified number of bytes.
     """
     ptr = ct.c_void_p(0)
-    c_num_bytes = ct.c_longlong(num_bytes)
+    c_num_bytes = c_dim_t(num_bytes)
     safe_call(backend.get().af_alloc_host(ct.pointer(ptr), c_num_bytes))
     return ptr.value
 
@@ -305,7 +305,7 @@ def alloc_pinned(num_bytes):
     Allocate a buffer on the host using pinned memory with specified number of bytes.
     """
     ptr = ct.c_void_p(0)
-    c_num_bytes = ct.c_longlong(num_bytes)
+    c_num_bytes = c_dim_t(num_bytes)
     safe_call(backend.get().af_alloc_pinned(ct.pointer(ptr), c_num_bytes))
     return ptr.value
 

arrayfire/features.py

@@ -28,13 +28,13 @@ def __init__(self, num=0):
         self.feat = ct.c_void_p(0)
         if num is not None:
             assert(isinstance(num, numbers.Number))
-            safe_call(backend.get().af_create_features(ct.pointer(self.feat), ct.c_longlong(num)))
+            safe_call(backend.get().af_create_features(ct.pointer(self.feat), c_dim_t(num)))
 
     def num_features():
         """
         Returns the number of features detected.
         """
-        num = ct.c_longlong(0)
+        num = c_dim_t(0)
         safe_call(backend.get().af_get_features_num(ct.pointer(num), self.feat))
         return num
 

arrayfire/graphics.py

@@ -48,7 +48,7 @@ class Window(object):
     def __init__(self, width=1280, height=720, title="ArrayFire"):
         self._r = -1
         self._c = -1
-        self._wnd = ct.c_longlong(0)
+        self._wnd = ct.c_void_p(0)
         self._cmap = COLORMAP.DEFAULT
 
         _width  = 1280 if  width is None else  width

arrayfire/image.py

@@ -160,8 +160,8 @@ def resize(image, scale=None, odim0=None, odim1=None, method=INTERP.NEAREST):
 
     output = Array()
     safe_call(backend.get().af_resize(ct.pointer(output.arr),
-                                      image.arr, ct.c_longlong(odim0),
-                                      ct.c_longlong(odim1), method.value))
+                                      image.arr, c_dim_t(odim0),
+                                      c_dim_t(odim1), method.value))
 
     return output
 
@@ -204,7 +204,7 @@ def transform(image, trans_mat, odim0 = 0, odim1 = 0, method=INTERP.NEAREST, is_
     output = Array()
     safe_call(backend.get().af_transform(ct.pointer(output.arr),
                                          image.arr, trans_mat.arr,
-                                         ct.c_longlong(odim0), ct.c_longlong(odim1),
+                                         c_dim_t(odim0), c_dim_t(odim1),
                                          method.value, is_inverse))
     return output
 
@@ -277,7 +277,7 @@ def translate(image, trans0, trans1, odim0 = 0, odim1 = 0, method = INTERP.NEARE
     output = Array()
     safe_call(backend.get().af_translate(ct.pointer(output.arr),
                                          image.arr, trans0, trans1,
-                                         ct.c_longlong(odim0), ct.c_longlong(odim1), method.value))
+                                         c_dim_t(odim0), c_dim_t(odim1), method.value))
     return output
 
 def scale(image, scale0, scale1, odim0 = 0, odim1 = 0, method = INTERP.NEAREST):
@@ -319,7 +319,7 @@ def scale(image, scale0, scale1, odim0 = 0, odim1 = 0, method = INTERP.NEAREST):
     output = Array()
     safe_call(backend.get().af_scale(ct.pointer(output.arr),
                                      image.arr, ct.c_float(scale0), ct.c_float(scale1),
-                                     ct.c_longlong(odim0), ct.c_longlong(odim1), method.value))
+                                     c_dim_t(odim0), c_dim_t(odim1), method.value))
     return output
 
 def skew(image, skew0, skew1, odim0 = 0, odim1 = 0, method = INTERP.NEAREST, is_inverse=True):
@@ -364,7 +364,7 @@ def skew(image, skew0, skew1, odim0 = 0, odim1 = 0, method = INTERP.NEAREST, is_
     output = Array()
     safe_call(backend.get().af_skew(ct.pointer(output.arr),
                                     image.arr, ct.c_float(skew0), ct.c_float(skew1),
-                                    ct.c_longlong(odim0), ct.c_longlong(odim1),
+                                    c_dim_t(odim0), c_dim_t(odim1),
                                     method.value, is_inverse))
 
     return output
@@ -647,8 +647,8 @@ def medfilt(image, w0 = 3, w1 = 3, edge_pad = PAD.ZERO):
     """
     output = Array()
     safe_call(backend.get().af_medfilt(ct.pointer(output.arr),
-                                       image.arr, ct.c_longlong(w0),
-                                       ct.c_longlong(w1), edge_pad.value))
+                                       image.arr, c_dim_t(w0),
+                                       c_dim_t(w1), edge_pad.value))
     return output
 
 def minfilt(image, w_len = 3, w_wid = 3, edge_pad = PAD.ZERO):
@@ -679,8 +679,8 @@ def minfilt(image, w_len = 3, w_wid = 3, edge_pad = PAD.ZERO):
     """
     output = Array()
     safe_call(backend.get().af_minfilt(ct.pointer(output.arr),
-                                       image.arr, ct.c_longlong(w_len),
-                                       ct.c_longlong(w_wid), edge_pad.value))
+                                       image.arr, c_dim_t(w_len),
+                                       c_dim_t(w_wid), edge_pad.value))
     return output
 
 def maxfilt(image, w_len = 3, w_wid = 3, edge_pad = PAD.ZERO):
@@ -711,8 +711,8 @@ def maxfilt(image, w_len = 3, w_wid = 3, edge_pad = PAD.ZERO):
     """
     output = Array()
     safe_call(backend.get().af_maxfilt(ct.pointer(output.arr),
-                                       image.arr, ct.c_longlong(w_len),
-                                       ct.c_longlong(w_wid), edge_pad.value))
+                                       image.arr, c_dim_t(w_len),
+                                       c_dim_t(w_wid), edge_pad.value))
     return output
 
 def regions(image, conn = CONNECTIVITY.FOUR, out_type = Dtype.f32):
@@ -996,9 +996,9 @@ def unwrap(image, wx, wy, sx, sy, px=0, py=0, is_column=True):
 
     out = Array()
     safe_call(backend.get().af_unwrap(ct.pointer(out.arr), image.arr,
-                                      ct.c_longlong(wx), ct.c_longlong(wy),
-                                      ct.c_longlong(sx), ct.c_longlong(sy),
-                                      ct.c_longlong(px), ct.c_longlong(py),
+                                      c_dim_t(wx), c_dim_t(wy),
+                                      c_dim_t(sx), c_dim_t(sy),
+                                      c_dim_t(px), c_dim_t(py),
                                       is_column))
     return out
 
@@ -1078,10 +1078,10 @@ def wrap(a, ox, oy, wx, wy, sx, sy, px=0, py=0, is_column=True):
 
     out = Array()
     safe_call(backend.get().af_wrap(ct.pointer(out.arr), a.arr,
-                                    ct.c_longlong(ox), ct.c_longlong(oy),
-                                    ct.c_longlong(wx), ct.c_longlong(wy),
-                                    ct.c_longlong(sx), ct.c_longlong(sy),
-                                    ct.c_longlong(px), ct.c_longlong(py),
+                                    c_dim_t(ox), c_dim_t(oy),
+                                    c_dim_t(wx), c_dim_t(wy),
+                                    c_dim_t(sx), c_dim_t(sy),
+                                    c_dim_t(px), c_dim_t(py),
                                     is_column))
     return out
 

arrayfire/library.py

@@ -14,6 +14,19 @@
 import platform
 import ctypes as ct
 
+# Work around for unexpected architectures
+if 'c_dim_t_forced' in globals():
+    global c_dim_t_forced
+    c_dim_t = c_dim_t_forced
+else:
+    # dim_t is long long by default
+    c_dim_t = ct.c_longlong
+    # Change to int for 32 bit x86 and amr architectures
+    if (platform.architecture()[0][0:2] == '32' and
+        (platform.machine()[-2:] == '86' or
+         platform.machine()[0:3] == 'arm')):
+        c_dim_t = ct.c_int
+
 try:
     from enum import Enum as _Enum
     def _Enum_Type(v):

arrayfire/signal.py

@@ -127,7 +127,7 @@ def fft(signal, dim0 = None , scale = None):
         scale = 1.0
 
     output = Array()
-    safe_call(backend.get().af_fft(ct.pointer(output.arr), signal.arr, ct.c_double(scale), ct.c_longlong(dim0)))
+    safe_call(backend.get().af_fft(ct.pointer(output.arr), signal.arr, ct.c_double(scale), c_dim_t(dim0)))
     return output
 
 def fft2(signal, dim0 = None, dim1 = None , scale = None):
@@ -170,7 +170,7 @@ def fft2(signal, dim0 = None, dim1 = None , scale = None):
 
     output = Array()
     safe_call(backend.get().af_fft2(ct.pointer(output.arr), signal.arr, ct.c_double(scale),
-                                    ct.c_longlong(dim0), ct.c_longlong(dim1)))
+                                    c_dim_t(dim0), c_dim_t(dim1)))
     return output
 
 def fft3(signal, dim0 = None, dim1 = None , dim2 = None, scale = None):
@@ -220,7 +220,7 @@ def fft3(signal, dim0 = None, dim1 = None , dim2 = None, scale = None):
 
     output = Array()
     safe_call(backend.get().af_fft3(ct.pointer(output.arr), signal.arr, ct.c_double(scale),
-                                    ct.c_longlong(dim0), ct.c_longlong(dim1), ct.c_longlong(dim2)))
+                                    c_dim_t(dim0), c_dim_t(dim1), c_dim_t(dim2)))
     return output
 
 def ifft(signal, dim0 = None , scale = None):
@@ -261,7 +261,7 @@ def ifft(signal, dim0 = None , scale = None):
         scale = 1.0/float(dim0)
 
     output = Array()
-    safe_call(backend.get().af_ifft(ct.pointer(output.arr), signal.arr, ct.c_double(scale), ct.c_longlong(dim0)))
+    safe_call(backend.get().af_ifft(ct.pointer(output.arr), signal.arr, ct.c_double(scale), c_dim_t(dim0)))
     return output
 
 def ifft2(signal, dim0 = None, dim1 = None , scale = None):
@@ -312,7 +312,7 @@ def ifft2(signal, dim0 = None, dim1 = None , scale = None):
 
     output = Array()
     safe_call(backend.get().af_ifft2(ct.pointer(output.arr), signal.arr, ct.c_double(scale),
-                                     ct.c_longlong(dim0), ct.c_longlong(dim1)))
+                                     c_dim_t(dim0), c_dim_t(dim1)))
     return output
 
 def ifft3(signal, dim0 = None, dim1 = None , dim2 = None, scale = None):
@@ -370,7 +370,7 @@ def ifft3(signal, dim0 = None, dim1 = None , dim2 = None, scale = None):
 
     output = Array()
     safe_call(backend.get().af_ifft3(ct.pointer(output.arr), signal.arr, ct.c_double(scale),
-                                     ct.c_longlong(dim0), ct.c_longlong(dim1), ct.c_longlong(dim2)))
+                                     c_dim_t(dim0), c_dim_t(dim1), c_dim_t(dim2)))
     return output
 
 def fft_inplace(signal, scale = None):
@@ -539,7 +539,7 @@ def fft_r2c(signal, dim0 = None , scale = None):
         scale = 1.0
 
     output = Array()
-    safe_call(backend.get().af_fft_r2c(ct.pointer(output.arr), signal.arr, ct.c_double(scale), ct.c_longlong(dim0)))
+    safe_call(backend.get().af_fft_r2c(ct.pointer(output.arr), signal.arr, ct.c_double(scale), c_dim_t(dim0)))
     return output
 
 def fft2_r2c(signal, dim0 = None, dim1 = None , scale = None):
@@ -582,7 +582,7 @@ def fft2_r2c(signal, dim0 = None, dim1 = None , scale = None):
 
     output = Array()
     safe_call(backend.get().af_fft2_r2c(ct.pointer(output.arr), signal.arr, ct.c_double(scale),
-                                        ct.c_longlong(dim0), ct.c_longlong(dim1)))
+                                        c_dim_t(dim0), c_dim_t(dim1)))
     return output
 
 def fft3_r2c(signal, dim0 = None, dim1 = None , dim2 = None, scale = None):
@@ -632,7 +632,7 @@ def fft3_r2c(signal, dim0 = None, dim1 = None , dim2 = None, scale = None):
 
     output = Array()
     safe_call(backend.get().af_fft3_r2c(ct.pointer(output.arr), signal.arr, ct.c_double(scale),
-                                        ct.c_longlong(dim0), ct.c_longlong(dim1), ct.c_longlong(dim2)))
+                                        c_dim_t(dim0), c_dim_t(dim1), c_dim_t(dim2)))
     return output
 
 def _get_c2r_dim(dim, is_odd):

arrayfire/util.py

@@ -11,7 +11,7 @@
 import numbers
 
 def dim4(d0=1, d1=1, d2=1, d3=1):
-    c_dim4 = ct.c_longlong * 4
+    c_dim4 = c_dim_t * 4
     out = c_dim4(1, 1, 1, 1)
 
     for i, dim in enumerate((d0, d1, d2, d3)):
@@ -70,7 +70,7 @@ def to_str(c_str):
 def safe_call(af_error):
     if (af_error != ERR.NONE.value):
         err_str = ct.c_char_p(0)
-        err_len = ct.c_longlong(0)
+        err_len = c_dim_t(0)
         backend.get().af_get_last_error(ct.pointer(err_str), ct.pointer(err_len))
         raise RuntimeError(to_str(err_str))
 

arrayfire/vision.py

@@ -166,7 +166,7 @@ def hamming_matcher(query, database, dim = 0, num_nearest = 1):
     dist = Array()
     safe_call(backend.get().af_hamming_matcher(ct.pointer(idx.arr), ct.pointer(dist.arr),
                                                query.arr, database.arr,
-                                               ct.c_longlong(dim), ct.c_longlong(num_nearest)))
+                                               c_dim_t(dim), c_dim_t(num_nearest)))
     return index, dist
 
 def nearest_neighbour(query, database, dim = 0, num_nearest = 1, match_type=MATCH.SSD):
@@ -202,7 +202,7 @@ def nearest_neighbour(query, database, dim = 0, num_nearest = 1, match_type=MATC
     dist = Array()
     safe_call(backend.get().af_nearest_neighbour(ct.pointer(idx.arr), ct.pointer(dist.arr),
                                                  query.arr, database.arr,
-                                                 ct.c_longlong(dim), ct.c_longlong(num_nearest),
+                                                 c_dim_t(dim), c_dim_t(num_nearest),
                                                  match_type.value))
     return index, dist