Skip to content

Commit 1f75d5f

Browse files
pavankypavanky
committed
BUGFIX: Fixing import mess in arrayfire
- Also deleting modules imported for helping out arrayfire
1 parent 5740264 commit 1f75d5f

File tree

15 files changed

+385
-377
lines changed

15 files changed

+385
-377
lines changed

‎arrayfire/__init__.py‎

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -8,6 +8,7 @@
88
########################################################
99

1010
from .library import *
11+
from .array import *
1112
from .data import *
1213
from .util import *
1314
from .algorithm import *
@@ -20,3 +21,9 @@
2021
from .image import *
2122
from .features import *
2223
from .vision import *
24+
25+
# do not export default modules as part of arrayfire
26+
del ct
27+
del inspect
28+
del numbers
29+
del os

‎arrayfire/algorithm.py‎

Lines changed: 23 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -12,13 +12,13 @@
1212

1313
def parallel_dim(a, dim, c_func):
1414
out = array()
15-
safe_call(c_func(pointer(out.arr), a.arr, c_int(dim)))
15+
safe_call(c_func(ct.pointer(out.arr), a.arr, ct.c_int(dim)))
1616
return out
1717

1818
def reduce_all(a, c_func):
19-
real = c_double(0)
20-
imag = c_double(0)
21-
safe_call(c_func(pointer(real), pointer(imag), a.arr))
19+
real = ct.c_double(0)
20+
imag = ct.c_double(0)
21+
safe_call(c_func(ct.pointer(real), ct.pointer(imag), a.arr))
2222
real = real.value
2323
imag = imag.value
2424
return real if imag == 0 else real + imag * 1j
@@ -69,13 +69,13 @@ def imin(a, dim=None):
6969
if dim is not None:
7070
out = array()
7171
idx = array()
72-
safe_call(clib.af_imin(pointer(out.arr), pointer(idx.arr), a.arr, c_int(dim)))
72+
safe_call(clib.af_imin(ct.pointer(out.arr), ct.pointer(idx.arr), a.arr, ct.c_int(dim)))
7373
return out,idx
7474
else:
75-
real = c_double(0)
76-
imag = c_double(0)
77-
idx = c_uint(0)
78-
safe_call(clib.af_imin_all(pointer(real), pointer(imag), pointer(idx), a.arr))
75+
real = ct.c_double(0)
76+
imag = ct.c_double(0)
77+
idx = ct.c_uint(0)
78+
safe_call(clib.af_imin_all(ct.pointer(real), ct.pointer(imag), ct.pointer(idx), a.arr))
7979
real = real.value
8080
imag = imag.value
8181
val = real if imag == 0 else real + imag * 1j
@@ -85,13 +85,13 @@ def imax(a, dim=None):
8585
if dim is not None:
8686
out = array()
8787
idx = array()
88-
safe_call(clib.af_imax(pointer(out.arr), pointer(idx.arr), a.arr, c_int(dim)))
88+
safe_call(clib.af_imax(ct.pointer(out.arr), ct.pointer(idx.arr), a.arr, ct.c_int(dim)))
8989
return out,idx
9090
else:
91-
real = c_double(0)
92-
imag = c_double(0)
93-
idx = c_uint(0)
94-
safe_call(clib.af_imax_all(pointer(real), pointer(imag), pointer(idx), a.arr))
91+
real = ct.c_double(0)
92+
imag = ct.c_double(0)
93+
idx = ct.c_uint(0)
94+
safe_call(clib.af_imax_all(ct.pointer(real), ct.pointer(imag), ct.pointer(idx), a.arr))
9595
real = real.value
9696
imag = imag.value
9797
val = real if imag == 0 else real + imag * 1j
@@ -103,7 +103,7 @@ def accum(a, dim=0):
103103

104104
def where(a):
105105
out = array()
106-
safe_call(clib.af_where(pointer(out.arr), a.arr))
106+
safe_call(clib.af_where(ct.pointer(out.arr), a.arr))
107107
return out
108108

109109
def diff1(a, dim=0):
@@ -114,34 +114,34 @@ def diff2(a, dim=0):
114114

115115
def sort(a, dim=0, is_ascending=True):
116116
out = array()
117-
safe_call(clib.af_sort(pointer(out.arr), a.arr, c_uint(dim), c_bool(is_ascending)))
117+
safe_call(clib.af_sort(ct.pointer(out.arr), a.arr, ct.c_uint(dim), ct.c_bool(is_ascending)))
118118
return out
119119

120120
def sort_index(a, dim=0, is_ascending=True):
121121
out = array()
122122
idx = array()
123-
safe_call(clib.af_sort_index(pointer(out.arr), pointer(idx.arr), a.arr, \
124-
c_uint(dim), c_bool(is_ascending)))
123+
safe_call(clib.af_sort_index(ct.pointer(out.arr), ct.pointer(idx.arr), a.arr, \
124+
ct.c_uint(dim), ct.c_bool(is_ascending)))
125125
return out,idx
126126

127127
def sort_by_key(iv, ik, dim=0, is_ascending=True):
128128
ov = array()
129129
ok = array()
130-
safe_call(clib.af_sort_by_key(pointer(ov.arr), pointer(ok.arr), \
131-
iv.arr, ik.arr, c_uint(dim), c_bool(is_ascending)))
130+
safe_call(clib.af_sort_by_key(ct.pointer(ov.arr), ct.pointer(ok.arr), \
131+
iv.arr, ik.arr, ct.c_uint(dim), ct.c_bool(is_ascending)))
132132
return ov,ok
133133

134134
def set_unique(a, is_sorted=False):
135135
out = array()
136-
safe_call(clib.af_set_unique(pointer(out.arr), a.arr, c_bool(is_sorted)))
136+
safe_call(clib.af_set_unique(ct.pointer(out.arr), a.arr, ct.c_bool(is_sorted)))
137137
return out
138138

139139
def set_union(a, b, is_unique=False):
140140
out = array()
141-
safe_call(clib.af_set_union(pointer(out.arr), a.arr, b.arr, c_bool(is_unique)))
141+
safe_call(clib.af_set_union(ct.pointer(out.arr), a.arr, b.arr, ct.c_bool(is_unique)))
142142
return out
143143

144144
def set_intersect(a, b, is_unique=False):
145145
out = array()
146-
safe_call(clib.af_set_intersect(pointer(out.arr), a.arr, b.arr, c_bool(is_unique)))
146+
safe_call(clib.af_set_intersect(ct.pointer(out.arr), a.arr, b.arr, ct.c_bool(is_unique)))
147147
return out

‎arrayfire/arith.py‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -20,32 +20,32 @@ def arith_binary_func(lhs, rhs, c_func):
2020
TypeError("Atleast one input needs to be of type arrayfire.array")
2121

2222
elif (is_left_array and is_right_array):
23-
safe_call(c_func(pointer(out.arr), lhs.arr, rhs.arr, False))
23+
safe_call(c_func(ct.pointer(out.arr), lhs.arr, rhs.arr, False))
2424

2525
elif (is_valid_scalar(rhs)):
2626
ldims = dim4_tuple(lhs.dims())
2727
lty = lhs.type()
2828
other = array()
2929
other.arr = constant_array(rhs, ldims[0], ldims[1], ldims[2], ldims[3], lty)
30-
safe_call(c_func(pointer(out.arr), lhs.arr, other.arr, False))
30+
safe_call(c_func(ct.pointer(out.arr), lhs.arr, other.arr, False))
3131

3232
else:
3333
rdims = dim4_tuple(rhs.dims())
3434
rty = rhs.type()
3535
other = array()
3636
other.arr = constant_array(lhs, rdims[0], rdims[1], rdims[2], rdims[3], rty)
37-
safe_call(c_func(pointer(out.arr), lhs.arr, other.arr, False))
37+
safe_call(c_func(ct.pointer(out.arr), lhs.arr, other.arr, False))
3838

3939
return out
4040

4141
def arith_unary_func(a, c_func):
4242
out = array()
43-
safe_call(c_func(pointer(out.arr), a.arr))
43+
safe_call(c_func(ct.pointer(out.arr), a.arr))
4444
return out
4545

4646
def cast(a, dtype=f32):
4747
out=array()
48-
safe_call(clib.af_cast(pointer(out.arr), a.arr, dtype))
48+
safe_call(clib.af_cast(ct.pointer(out.arr), a.arr, dtype))
4949
return out
5050

5151
def minof(lhs, rhs):

‎arrayfire/array.py‎

Lines changed: 59 additions & 57 deletions
Original file line numberDiff line numberDiff line change
@@ -7,46 +7,46 @@
77
# http://arrayfire.com/licenses/BSD-3-Clause
88
########################################################
99

10-
import array as host
1110
import inspect
1211
from .library import *
1312
from .util import *
14-
from .data import *
1513

1614
def create_array(buf, numdims, idims, dtype):
17-
out_arr = c_longlong(0)
18-
c_dims = dim4(idims[0], idims[1], idims[2], idims[3])
19-
safe_call(clib.af_create_array(pointer(out_arr), c_longlong(buf), numdims, pointer(c_dims), dtype))
15+
out_arr = ct.c_longlong(0)
16+
ct.c_dims = dim4(idims[0], idims[1], idims[2], idims[3])
17+
safe_call(clib.af_create_array(ct.pointer(out_arr), ct.c_longlong(buf),\
18+
numdims, ct.pointer(ct.c_dims), dtype))
2019
return out_arr
2120

2221
def constant_array(val, d0, d1=None, d2=None, d3=None, dtype=f32):
2322

24-
if not isinstance(dtype, c_int):
23+
if not isinstance(dtype, ct.c_int):
2524
if isinstance(dtype, int):
26-
dtype = c_int(dtype)
25+
dtype = ct.c_int(dtype)
2726
else:
2827
raise TypeError("Invalid dtype")
2928

30-
out = c_longlong(0)
29+
out = ct.c_longlong(0)
3130
dims = dim4(d0, d1, d2, d3)
3231

3332
if isinstance(val, complex):
34-
c_real = c_double(val.real)
35-
c_imag = c_double(val.imag)
33+
c_real = ct.c_double(val.real)
34+
c_imag = ct.c_double(val.imag)
3635

3736
if (dtype != c32 and dtype != c64):
3837
dtype = c32
3938

40-
safe_call(clib.af_constant_complex(pointer(out), c_real, c_imag, 4, pointer(dims), dtype))
39+
safe_call(clib.af_constant_complex(ct.pointer(out), c_real, c_imag,\
40+
4, ct.pointer(dims), dtype))
4141
elif dtype == s64:
42-
c_val = c_longlong(val.real)
43-
safe_call(clib.af_constant_long(pointer(out), c_val, 4, pointer(dims)))
42+
c_val = ct.c_longlong(val.real)
43+
safe_call(clib.af_constant_long(ct.pointer(out), c_val, 4, ct.pointer(dims)))
4444
elif dtype == u64:
45-
c_val = c_ulonglong(val.real)
46-
safe_call(clib.af_constant_ulong(pointer(out), c_val, 4, pointer(dims)))
45+
c_val = ct.c_ulonglong(val.real)
46+
safe_call(clib.af_constant_ulong(ct.pointer(out), c_val, 4, ct.pointer(dims)))
4747
else:
48-
c_val = c_double(val)
49-
safe_call(clib.af_constant(pointer(out), c_val, 4, pointer(dims), dtype))
48+
c_val = ct.c_double(val)
49+
safe_call(clib.af_constant(ct.pointer(out), c_val, 4, ct.pointer(dims), dtype))
5050

5151
return out
5252

@@ -63,7 +63,7 @@ def binary_func(lhs, rhs, c_func):
6363
elif not isinstance(rhs, array):
6464
TypeError("Invalid parameter to binary function")
6565

66-
safe_call(c_func(pointer(out.arr), lhs.arr, other.arr, False))
66+
safe_call(c_func(ct.pointer(out.arr), lhs.arr, other.arr, False))
6767

6868
return out
6969

@@ -79,15 +79,15 @@ def binary_funcr(lhs, rhs, c_func):
7979
elif not isinstance(lhs, array):
8080
TypeError("Invalid parameter to binary function")
8181

82-
c_func(pointer(out.arr), other.arr, rhs.arr, False)
82+
c_func(ct.pointer(out.arr), other.arr, rhs.arr, False)
8383

8484
return out
8585

8686
class array(object):
8787

8888
def __init__(self, src=None, dims=(0,)):
8989

90-
self.arr = c_longlong(0)
90+
self.arr = ct.c_longlong(0)
9191

9292
buf=None
9393
buf_len=0
@@ -96,6 +96,8 @@ def __init__(self, src=None, dims=(0,)):
9696

9797
if src is not None:
9898

99+
host = __import__("array")
100+
99101
if isinstance(src, host.array):
100102
buf,buf_len = src.buffer_info()
101103
type_char = src.typecode
@@ -127,92 +129,92 @@ def __del__(self):
127129
clib.af_release_array(self.arr)
128130

129131
def elements(self):
130-
num = c_ulonglong(0)
131-
safe_call(clib.af_get_elements(pointer(num), self.arr))
132+
num = ct.c_ulonglong(0)
133+
safe_call(clib.af_get_elements(ct.pointer(num), self.arr))
132134
return num.value
133135

134136
def type(self):
135-
dty = c_int(f32.value)
136-
safe_call(clib.af_get_type(pointer(dty), self.arr))
137+
dty = ct.c_int(f32.value)
138+
safe_call(clib.af_get_type(ct.pointer(dty), self.arr))
137139
return dty.value
138140

139141
def dims(self):
140-
d0 = c_longlong(0)
141-
d1 = c_longlong(0)
142-
d2 = c_longlong(0)
143-
d3 = c_longlong(0)
144-
safe_call(clib.af_get_dims(pointer(d0), pointer(d1), pointer(d2), pointer(d3), self.arr))
142+
d0 = ct.c_longlong(0)
143+
d1 = ct.c_longlong(0)
144+
d2 = ct.c_longlong(0)
145+
d3 = ct.c_longlong(0)
146+
safe_call(clib.af_get_dims(ct.pointer(d0), ct.pointer(d1), ct.pointer(d2), ct.pointer(d3), self.arr))
145147
dims = (d0.value,d1.value,d2.value,d3.value)
146148
return dims[:self.numdims()]
147149

148150
def numdims(self):
149-
nd = c_uint(0)
150-
safe_call(clib.af_get_numdims(pointer(nd), self.arr))
151+
nd = ct.c_uint(0)
152+
safe_call(clib.af_get_numdims(ct.pointer(nd), self.arr))
151153
return nd.value
152154

153155
def is_empty(self):
154-
res = c_bool(False)
155-
safe_call(clib.af_is_empty(pointer(res), self.arr))
156+
res = ct.c_bool(False)
157+
safe_call(clib.af_is_empty(ct.pointer(res), self.arr))
156158
return res.value
157159

158160
def is_scalar(self):
159-
res = c_bool(False)
160-
safe_call(clib.af_is_scalar(pointer(res), self.arr))
161+
res = ct.c_bool(False)
162+
safe_call(clib.af_is_scalar(ct.pointer(res), self.arr))
161163
return res.value
162164

163165
def is_row(self):
164-
res = c_bool(False)
165-
safe_call(clib.af_is_row(pointer(res), self.arr))
166+
res = ct.c_bool(False)
167+
safe_call(clib.af_is_row(ct.pointer(res), self.arr))
166168
return res.value
167169

168170
def is_column(self):
169-
res = c_bool(False)
170-
safe_call(clib.af_is_column(pointer(res), self.arr))
171+
res = ct.c_bool(False)
172+
safe_call(clib.af_is_column(ct.pointer(res), self.arr))
171173
return res.value
172174

173175
def is_vector(self):
174-
res = c_bool(False)
175-
safe_call(clib.af_is_vector(pointer(res), self.arr))
176+
res = ct.c_bool(False)
177+
safe_call(clib.af_is_vector(ct.pointer(res), self.arr))
176178
return res.value
177179

178180
def is_complex(self):
179-
res = c_bool(False)
180-
safe_call(clib.af_is_complex(pointer(res), self.arr))
181+
res = ct.c_bool(False)
182+
safe_call(clib.af_is_complex(ct.pointer(res), self.arr))
181183
return res.value
182184

183185
def is_real(self):
184-
res = c_bool(False)
185-
safe_call(clib.af_is_real(pointer(res), self.arr))
186+
res = ct.c_bool(False)
187+
safe_call(clib.af_is_real(ct.pointer(res), self.arr))
186188
return res.value
187189

188190
def is_double(self):
189-
res = c_bool(False)
190-
safe_call(clib.af_is_double(pointer(res), self.arr))
191+
res = ct.c_bool(False)
192+
safe_call(clib.af_is_double(ct.pointer(res), self.arr))
191193
return res.value
192194

193195
def is_single(self):
194-
res = c_bool(False)
195-
safe_call(clib.af_is_single(pointer(res), self.arr))
196+
res = ct.c_bool(False)
197+
safe_call(clib.af_is_single(ct.pointer(res), self.arr))
196198
return res.value
197199

198200
def is_real_floating(self):
199-
res = c_bool(False)
200-
safe_call(clib.af_is_realfloating(pointer(res), self.arr))
201+
res = ct.c_bool(False)
202+
safe_call(clib.af_is_realfloating(ct.pointer(res), self.arr))
201203
return res.value
202204

203205
def is_floating(self):
204-
res = c_bool(False)
205-
safe_call(clib.af_is_floating(pointer(res), self.arr))
206+
res = ct.c_bool(False)
207+
safe_call(clib.af_is_floating(ct.pointer(res), self.arr))
206208
return res.value
207209

208210
def is_integer(self):
209-
res = c_bool(False)
210-
safe_call(clib.af_is_integer(pointer(res), self.arr))
211+
res = ct.c_bool(False)
212+
safe_call(clib.af_is_integer(ct.pointer(res), self.arr))
211213
return res.value
212214

213215
def is_bool(self):
214-
res = c_bool(False)
215-
safe_call(clib.af_is_bool(pointer(res), self.arr))
216+
res = ct.c_bool(False)
217+
safe_call(clib.af_is_bool(ct.pointer(res), self.arr))
216218
return res.value
217219

218220
def __add__(self, other):

0 commit comments

Comments
 (0)