BUGFIX: Fixing import mess in arrayfire · arrayfire/arrayfire-python@1f75d5f · GitHub

arrayfire / arrayfire-python Public

• Notifications You must be signed in to change notification settings
• Fork 64
• Star 422

• Code
• Issues 57
• Pull requests 3
• Actions
• Projects
• Wiki
• Security and quality
• Insights

Additional navigation options

Commit 1f75d5f

Browse filesBrowse the repository at this point in the historyBrowse files

pavanky

committed

BUGFIX: Fixing import mess in arrayfire

- Also deleting modules imported for helping out arrayfire

1 parent 5740264 commit 1f75d5f
Copy full SHA for 1f75d5f

15 files changed

+385-377Lines changed: 385 additions & 377 deletions

File tree

Expand file treeCollapse file tree

Open diff view settings

Filter options

• arrayfire
  • __init__.py
  • algorithm.py
  • arith.py
  • array.py
  • blas.py
  • data.py
  • device.py
  • features.py
  • image.py
  • lapack.py
  • library.py
  • signal.py
  • statistics.py
  • util.py
  • vision.py

Expand file treeCollapse file tree

Open diff view settings

Collapse file

‎arrayfire/__init__.py‎

Copy file name to clipboardExpand all lines: arrayfire/__init__.py

+7Lines changed: 7 additions & 0 deletions

Original file line number	Diff line number	Diff line change
@@ -8,6 +8,7 @@
8	8	########################################################
9	9
10	10	from .library import *
	11	+ from .array import *
11	12	from .data import *
12	13	from .util import *
13	14	from .algorithm import *
@@ -20,3 +21,9 @@
20	21	from .image import *
21	22	from .features import *
22	23	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

Collapse file

‎arrayfire/algorithm.py‎

Copy file name to clipboardExpand all lines: arrayfire/algorithm.py

+23-23Lines changed: 23 additions & 23 deletions

Original file line number	Diff line number	Diff line change
@@ -12,13 +12,13 @@
12	12
13	13	def parallel_dim(a, dim, c_func):
14	14	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)))
16	16	return out
17	17
18	18	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))
22	22	real = real.value
23	23	imag = imag.value
24	24	return real if imag == 0 else real + imag * 1j
@@ -69,13 +69,13 @@ def imin(a, dim=None):
69	69	if dim is not None:
70	70	out = array()
71	71	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)))
73	73	return out,idx
74	74	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))
79	79	real = real.value
80	80	imag = imag.value
81	81	val = real if imag == 0 else real + imag * 1j
@@ -85,13 +85,13 @@ def imax(a, dim=None):
85	85	if dim is not None:
86	86	out = array()
87	87	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)))
89	89	return out,idx
90	90	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))
95	95	real = real.value
96	96	imag = imag.value
97	97	val = real if imag == 0 else real + imag * 1j
@@ -103,7 +103,7 @@ def accum(a, dim=0):
103	103
104	104	def where(a):
105	105	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))
107	107	return out
108	108
109	109	def diff1(a, dim=0):
@@ -114,34 +114,34 @@ def diff2(a, dim=0):
114	114
115	115	def sort(a, dim=0, is_ascending=True):
116	116	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)))
118	118	return out
119	119
120	120	def sort_index(a, dim=0, is_ascending=True):
121	121	out = array()
122	122	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)))
125	125	return out,idx
126	126
127	127	def sort_by_key(iv, ik, dim=0, is_ascending=True):
128	128	ov = array()
129	129	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)))
132	132	return ov,ok
133	133
134	134	def set_unique(a, is_sorted=False):
135	135	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)))
137	137	return out
138	138
139	139	def set_union(a, b, is_unique=False):
140	140	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)))
142	142	return out
143	143
144	144	def set_intersect(a, b, is_unique=False):
145	145	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)))
147	147	return out

Collapse file

‎arrayfire/arith.py‎

Copy file name to clipboardExpand all lines: arrayfire/arith.py

+5-5Lines changed: 5 additions & 5 deletions

Original file line number	Diff line number	Diff line change
@@ -20,32 +20,32 @@ def arith_binary_func(lhs, rhs, c_func):
20	20	TypeError("Atleast one input needs to be of type arrayfire.array")
21	21
22	22	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))
24	24
25	25	elif (is_valid_scalar(rhs)):
26	26	ldims = dim4_tuple(lhs.dims())
27	27	lty = lhs.type()
28	28	other = array()
29	29	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))
31	31
32	32	else:
33	33	rdims = dim4_tuple(rhs.dims())
34	34	rty = rhs.type()
35	35	other = array()
36	36	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))
38	38
39	39	return out
40	40
41	41	def arith_unary_func(a, c_func):
42	42	out = array()
43		- safe_call(c_func(pointer(out.arr), a.arr))
	43	+ safe_call(c_func(ct.pointer(out.arr), a.arr))
44	44	return out
45	45
46	46	def cast(a, dtype=f32):
47	47	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))
49	49	return out
50	50
51	51	def minof(lhs, rhs):

Collapse file

‎arrayfire/array.py‎

Copy file name to clipboardExpand all lines: arrayfire/array.py

+59-57Lines changed: 59 additions & 57 deletions

Original file line number	Diff line number	Diff line change
@@ -7,46 +7,46 @@
7	7	# http://arrayfire.com/licenses/BSD-3-Clause
8	8	########################################################
9	9
10		- import array as host
11	10	import inspect
12	11	from .library import *
13	12	from .util import *
14		- from .data import *
15	13
16	14	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))
20	19	return out_arr
21	20
22	21	def constant_array(val, d0, d1=None, d2=None, d3=None, dtype=f32):
23	22
24		- if not isinstance(dtype, c_int):
	23	+ if not isinstance(dtype, ct.c_int):
25	24	if isinstance(dtype, int):
26		- dtype = c_int(dtype)
	25	+ dtype = ct.c_int(dtype)
27	26	else:
28	27	raise TypeError("Invalid dtype")
29	28
30		- out = c_longlong(0)
	29	+ out = ct.c_longlong(0)
31	30	dims = dim4(d0, d1, d2, d3)
32	31
33	32	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)
36	35
37	36	if (dtype != c32 and dtype != c64):
38	37	dtype = c32
39	38
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))
41	41	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)))
44	44	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)))
47	47	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))
50	50
51	51	return out
52	52
@@ -63,7 +63,7 @@ def binary_func(lhs, rhs, c_func):
63	63	elif not isinstance(rhs, array):
64	64	TypeError("Invalid parameter to binary function")
65	65
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))
67	67
68	68	return out
69	69
@@ -79,15 +79,15 @@ def binary_funcr(lhs, rhs, c_func):
79	79	elif not isinstance(lhs, array):
80	80	TypeError("Invalid parameter to binary function")
81	81
82		- c_func(pointer(out.arr), other.arr, rhs.arr, False)
	82	+ c_func(ct.pointer(out.arr), other.arr, rhs.arr, False)
83	83
84	84	return out
85	85
86	86	class array(object):
87	87
88	88	def __init__(self, src=None, dims=(0,)):
89	89
90		- self.arr = c_longlong(0)
	90	+ self.arr = ct.c_longlong(0)
91	91
92	92	buf=None
93	93	buf_len=0
@@ -96,6 +96,8 @@ def __init__(self, src=None, dims=(0,)):
96	96
97	97	if src is not None:
98	98
	99	+ host = __import__("array")
	100	+
99	101	if isinstance(src, host.array):
100	102	buf,buf_len = src.buffer_info()
101	103	type_char = src.typecode
@@ -127,92 +129,92 @@ def __del__(self):
127	129	clib.af_release_array(self.arr)
128	130
129	131	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))
132	134	return num.value
133	135
134	136	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))
137	139	return dty.value
138	140
139	141	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))
145	147	dims = (d0.value,d1.value,d2.value,d3.value)
146	148	return dims[:self.numdims()]
147	149
148	150	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))
151	153	return nd.value
152	154
153	155	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))
156	158	return res.value
157	159
158	160	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))
161	163	return res.value
162	164
163	165	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))
166	168	return res.value
167	169
168	170	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))
171	173	return res.value
172	174
173	175	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))
176	178	return res.value
177	179
178	180	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))
181	183	return res.value
182	184
183	185	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))
186	188	return res.value
187	189
188	190	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))
191	193	return res.value
192	194
193	195	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))
196	198	return res.value
197	199
198	200	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))
201	203	return res.value
202	204
203	205	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))
206	208	return res.value
207	209
208	210	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))
211	213	return res.value
212	214
213	215	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))
216	218	return res.value
217	219
218	220	def __add__(self, other):

0 commit comments

Comments

0 (0)