[python-arrayfire] 50/58: Alias ctypes data types to custom data types
Ghislain Vaillant
ghisvail-guest at moszumanska.debian.org
Wed Sep 28 13:57:08 UTC 2016
This is an automated email from the git hooks/post-receive script.
ghisvail-guest pushed a commit to branch master
in repository python-arrayfire.
commit 5f8dce089579ce05a112b43cfef70696a1d286f6
Author: Pavan Yalamanchili <contact at pavanky.com>
Date: Sat Sep 24 14:38:19 2016 -0700
Alias ctypes data types to custom data types
---
arrayfire/algorithm.py | 58 +++++++--------
arrayfire/arith.py | 12 ++--
arrayfire/array.py | 182 ++++++++++++++++++++++++------------------------
arrayfire/base.py | 2 +-
arrayfire/blas.py | 10 +--
arrayfire/cuda.py | 8 +--
arrayfire/data.py | 42 +++++------
arrayfire/device.py | 64 ++++++++---------
arrayfire/features.py | 16 ++---
arrayfire/graphics.py | 74 ++++++++++----------
arrayfire/image.py | 106 ++++++++++++++--------------
arrayfire/index.py | 38 +++++-----
arrayfire/interop.py | 2 +-
arrayfire/lapack.py | 46 ++++++------
arrayfire/library.py | 48 ++++++++-----
arrayfire/opencl.py | 20 +++---
arrayfire/random.py | 40 +++++------
arrayfire/signal.py | 70 +++++++++----------
arrayfire/sparse.py | 26 +++----
arrayfire/statistics.py | 54 +++++++-------
arrayfire/util.py | 36 +++++-----
arrayfire/vision.py | 42 +++++------
22 files changed, 506 insertions(+), 490 deletions(-)
diff --git a/arrayfire/algorithm.py b/arrayfire/algorithm.py
index a219ea6..d57e0ce 100644
--- a/arrayfire/algorithm.py
+++ b/arrayfire/algorithm.py
@@ -16,14 +16,14 @@ from .array import *
def _parallel_dim(a, dim, c_func):
out = Array()
- safe_call(c_func(ct.pointer(out.arr), a.arr, ct.c_int(dim)))
+ safe_call(c_func(c_pointer(out.arr), a.arr, c_int_t(dim)))
return out
def _reduce_all(a, c_func):
- real = ct.c_double(0)
- imag = ct.c_double(0)
+ real = c_double_t(0)
+ imag = c_double_t(0)
- safe_call(c_func(ct.pointer(real), ct.pointer(imag), a.arr))
+ safe_call(c_func(c_pointer(real), c_pointer(imag), a.arr))
real = real.value
imag = imag.value
@@ -31,14 +31,14 @@ def _reduce_all(a, c_func):
def _nan_parallel_dim(a, dim, c_func, nan_val):
out = Array()
- safe_call(c_func(ct.pointer(out.arr), a.arr, ct.c_int(dim), ct.c_double(nan_val)))
+ safe_call(c_func(c_pointer(out.arr), a.arr, c_int_t(dim), c_double_t(nan_val)))
return out
def _nan_reduce_all(a, c_func, nan_val):
- real = ct.c_double(0)
- imag = ct.c_double(0)
+ real = c_double_t(0)
+ imag = c_double_t(0)
- safe_call(c_func(ct.pointer(real), ct.pointer(imag), a.arr, ct.c_double(nan_val)))
+ safe_call(c_func(c_pointer(real), c_pointer(imag), a.arr, c_double_t(nan_val)))
real = real.value
imag = imag.value
@@ -235,13 +235,13 @@ def imin(a, dim=None):
if dim is not None:
out = Array()
idx = Array()
- safe_call(backend.get().af_imin(ct.pointer(out.arr), ct.pointer(idx.arr), a.arr, ct.c_int(dim)))
+ safe_call(backend.get().af_imin(c_pointer(out.arr), c_pointer(idx.arr), a.arr, c_int_t(dim)))
return out,idx
else:
- real = ct.c_double(0)
- imag = ct.c_double(0)
- idx = ct.c_uint(0)
- safe_call(backend.get().af_imin_all(ct.pointer(real), ct.pointer(imag), ct.pointer(idx), a.arr))
+ real = c_double_t(0)
+ imag = c_double_t(0)
+ idx = c_uint_t(0)
+ safe_call(backend.get().af_imin_all(c_pointer(real), c_pointer(imag), c_pointer(idx), a.arr))
real = real.value
imag = imag.value
val = real if imag == 0 else real + imag * 1j
@@ -268,13 +268,13 @@ def imax(a, dim=None):
if dim is not None:
out = Array()
idx = Array()
- safe_call(backend.get().af_imax(ct.pointer(out.arr), ct.pointer(idx.arr), a.arr, ct.c_int(dim)))
+ safe_call(backend.get().af_imax(c_pointer(out.arr), c_pointer(idx.arr), a.arr, c_int_t(dim)))
return out,idx
else:
- real = ct.c_double(0)
- imag = ct.c_double(0)
- idx = ct.c_uint(0)
- safe_call(backend.get().af_imax_all(ct.pointer(real), ct.pointer(imag), ct.pointer(idx), a.arr))
+ real = c_double_t(0)
+ imag = c_double_t(0)
+ idx = c_uint_t(0)
+ safe_call(backend.get().af_imax_all(c_pointer(real), c_pointer(imag), c_pointer(idx), a.arr))
real = real.value
imag = imag.value
val = real if imag == 0 else real + imag * 1j
@@ -327,7 +327,7 @@ def scan(a, dim=0, op=BINARYOP.ADD, inclusive_scan=True):
- will contain scan of input.
"""
out = Array()
- safe_call(backend.get().af_scan(ct.pointer(out.arr), a.arr, dim, op.value, inclusive_scan))
+ safe_call(backend.get().af_scan(c_pointer(out.arr), a.arr, dim, op.value, inclusive_scan))
return out
def scan_by_key(key, a, dim=0, op=BINARYOP.ADD, inclusive_scan=True):
@@ -361,7 +361,7 @@ def scan_by_key(key, a, dim=0, op=BINARYOP.ADD, inclusive_scan=True):
- will contain scan of input.
"""
out = Array()
- safe_call(backend.get().af_scan_by_key(ct.pointer(out.arr), key.arr, a.arr, dim, op.value, inclusive_scan))
+ safe_call(backend.get().af_scan_by_key(c_pointer(out.arr), key.arr, a.arr, dim, op.value, inclusive_scan))
return out
def where(a):
@@ -379,7 +379,7 @@ def where(a):
Linear indices for non zero elements.
"""
out = Array()
- safe_call(backend.get().af_where(ct.pointer(out.arr), a.arr))
+ safe_call(backend.get().af_where(c_pointer(out.arr), a.arr))
return out
def diff1(a, dim=0):
@@ -441,7 +441,7 @@ def sort(a, dim=0, is_ascending=True):
Currently `dim` is only supported for 0.
"""
out = Array()
- safe_call(backend.get().af_sort(ct.pointer(out.arr), a.arr, ct.c_uint(dim), ct.c_bool(is_ascending)))
+ safe_call(backend.get().af_sort(c_pointer(out.arr), a.arr, c_uint_t(dim), c_bool_t(is_ascending)))
return out
def sort_index(a, dim=0, is_ascending=True):
@@ -469,8 +469,8 @@ 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)))
+ safe_call(backend.get().af_sort_index(c_pointer(out.arr), c_pointer(idx.arr), a.arr,
+ c_uint_t(dim), c_bool_t(is_ascending)))
return out,idx
def sort_by_key(iv, ik, dim=0, is_ascending=True):
@@ -500,8 +500,8 @@ 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)))
+ safe_call(backend.get().af_sort_by_key(c_pointer(ov.arr), c_pointer(ok.arr),
+ iv.arr, ik.arr, c_uint_t(dim), c_bool_t(is_ascending)))
return ov,ok
def set_unique(a, is_sorted=False):
@@ -521,7 +521,7 @@ def set_unique(a, is_sorted=False):
an array containing the unique values from `a`
"""
out = Array()
- safe_call(backend.get().af_set_unique(ct.pointer(out.arr), a.arr, ct.c_bool(is_sorted)))
+ safe_call(backend.get().af_set_unique(c_pointer(out.arr), a.arr, c_bool_t(is_sorted)))
return out
def set_union(a, b, is_unique=False):
@@ -543,7 +543,7 @@ def set_union(a, b, is_unique=False):
an array values after performing the union of `a` and `b`.
"""
out = Array()
- safe_call(backend.get().af_set_union(ct.pointer(out.arr), a.arr, b.arr, ct.c_bool(is_unique)))
+ safe_call(backend.get().af_set_union(c_pointer(out.arr), a.arr, b.arr, c_bool_t(is_unique)))
return out
def set_intersect(a, b, is_unique=False):
@@ -565,5 +565,5 @@ def set_intersect(a, b, is_unique=False):
an array values after performing the intersect of `a` and `b`.
"""
out = Array()
- safe_call(backend.get().af_set_intersect(ct.pointer(out.arr), a.arr, b.arr, ct.c_bool(is_unique)))
+ safe_call(backend.get().af_set_intersect(c_pointer(out.arr), a.arr, b.arr, c_bool_t(is_unique)))
return out
diff --git a/arrayfire/arith.py b/arrayfire/arith.py
index 3b397c4..70c2e54 100644
--- a/arrayfire/arith.py
+++ b/arrayfire/arith.py
@@ -26,27 +26,27 @@ def _arith_binary_func(lhs, rhs, c_func):
raise TypeError("Atleast one input needs to be of type arrayfire.array")
elif (is_left_array and is_right_array):
- safe_call(c_func(ct.pointer(out.arr), lhs.arr, rhs.arr, _bcast_var.get()))
+ safe_call(c_func(c_pointer(out.arr), lhs.arr, rhs.arr, _bcast_var.get()))
elif (_is_number(rhs)):
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_var.get()))
+ safe_call(c_func(c_pointer(out.arr), lhs.arr, other.arr, _bcast_var.get()))
else:
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_var.get()))
+ safe_call(c_func(c_pointer(out.arr), other.arr, rhs.arr, _bcast_var.get()))
return out
def _arith_unary_func(a, c_func):
out = Array()
- safe_call(c_func(ct.pointer(out.arr), a.arr))
+ safe_call(c_func(c_pointer(out.arr), a.arr))
return out
def cast(a, dtype):
@@ -75,7 +75,7 @@ def cast(a, dtype):
array containing the values from `a` after converting to `dtype`.
"""
out=Array()
- safe_call(backend.get().af_cast(ct.pointer(out.arr), a.arr, dtype.value))
+ safe_call(backend.get().af_cast(c_pointer(out.arr), a.arr, dtype.value))
return out
def minof(lhs, rhs):
@@ -160,7 +160,7 @@ def clamp(val, low, high):
else:
high_arr = high.arr
- safe_call(backend.get().af_clamp(ct.pointer(out.arr), val.arr, low_arr, high_arr, _bcast_var.get()))
+ safe_call(backend.get().af_clamp(c_pointer(out.arr), val.arr, low_arr, high_arr, _bcast_var.get()))
return out
diff --git a/arrayfire/array.py b/arrayfire/array.py
index 4e27af6..d9f78bf 100644
--- a/arrayfire/array.py
+++ b/arrayfire/array.py
@@ -21,18 +21,18 @@ from .index import *
from .index import _Index4
def _create_array(buf, numdims, idims, dtype, is_device):
- out_arr = ct.c_void_p(0)
+ out_arr = c_void_ptr_t(0)
c_dims = dim4(idims[0], idims[1], idims[2], idims[3])
if (not is_device):
- safe_call(backend.get().af_create_array(ct.pointer(out_arr), ct.c_void_p(buf),
- numdims, ct.pointer(c_dims), dtype.value))
+ safe_call(backend.get().af_create_array(c_pointer(out_arr), c_void_ptr_t(buf),
+ numdims, c_pointer(c_dims), dtype.value))
else:
- safe_call(backend.get().af_device_array(ct.pointer(out_arr), ct.c_void_p(buf),
- numdims, ct.pointer(c_dims), dtype.value))
+ safe_call(backend.get().af_device_array(c_pointer(out_arr), c_void_ptr_t(buf),
+ numdims, c_pointer(c_dims), dtype.value))
return out_arr
def _create_strided_array(buf, numdims, idims, dtype, is_device, offset, strides):
- out_arr = ct.c_void_p(0)
+ out_arr = c_void_ptr_t(0)
c_dims = dim4(idims[0], idims[1], idims[2], idims[3])
if offset is None:
offset = 0
@@ -46,17 +46,17 @@ def _create_strided_array(buf, numdims, idims, dtype, is_device, offset, strides
location = Source.device
else:
location = Source.host
- safe_call(backend.get().af_create_strided_array(ct.pointer(out_arr), ct.c_void_p(buf),
- offset, numdims, ct.pointer(c_dims),
- ct.pointer(strides), dtype.value,
+ safe_call(backend.get().af_create_strided_array(c_pointer(out_arr), c_void_ptr_t(buf),
+ offset, numdims, c_pointer(c_dims),
+ c_pointer(strides), dtype.value,
location.value))
return out_arr
def _create_empty_array(numdims, idims, dtype):
- out_arr = ct.c_void_p(0)
+ out_arr = c_void_ptr_t(0)
c_dims = dim4(idims[0], idims[1], idims[2], idims[3])
- safe_call(backend.get().af_create_handle(ct.pointer(out_arr),
- numdims, ct.pointer(c_dims), dtype.value))
+ safe_call(backend.get().af_create_handle(c_pointer(out_arr),
+ numdims, c_pointer(c_dims), dtype.value))
return out_arr
def constant_array(val, d0, d1=None, d2=None, d3=None, dtype=Dtype.f32):
@@ -64,35 +64,35 @@ def constant_array(val, d0, d1=None, d2=None, d3=None, dtype=Dtype.f32):
Internal function to create a C array. Should not be used externall.
"""
- if not isinstance(dtype, ct.c_int):
+ if not isinstance(dtype, c_int_t):
if isinstance(dtype, int):
- dtype = ct.c_int(dtype)
+ dtype = c_int_t(dtype)
elif isinstance(dtype, Dtype):
- dtype = ct.c_int(dtype.value)
+ dtype = c_int_t(dtype.value)
else:
raise TypeError("Invalid dtype")
- out = ct.c_void_p(0)
+ out = c_void_ptr_t(0)
dims = dim4(d0, d1, d2, d3)
if isinstance(val, complex):
- c_real = ct.c_double(val.real)
- c_imag = ct.c_double(val.imag)
+ c_real = c_double_t(val.real)
+ c_imag = c_double_t(val.imag)
if (dtype.value != Dtype.c32.value and dtype.value != Dtype.c64.value):
dtype = Dtype.c32.value
- safe_call(backend.get().af_constant_complex(ct.pointer(out), c_real, c_imag,
- 4, ct.pointer(dims), dtype))
+ safe_call(backend.get().af_constant_complex(c_pointer(out), c_real, c_imag,
+ 4, c_pointer(dims), dtype))
elif dtype.value == Dtype.s64.value:
- c_val = ct.c_longlong(val.real)
- safe_call(backend.get().af_constant_long(ct.pointer(out), c_val, 4, ct.pointer(dims)))
+ c_val = c_longlong_t(val.real)
+ safe_call(backend.get().af_constant_long(c_pointer(out), c_val, 4, c_pointer(dims)))
elif dtype.value == Dtype.u64.value:
- c_val = ct.c_ulonglong(val.real)
- safe_call(backend.get().af_constant_ulong(ct.pointer(out), c_val, 4, ct.pointer(dims)))
+ c_val = c_ulonglong_t(val.real)
+ safe_call(backend.get().af_constant_ulong(c_pointer(out), c_val, 4, c_pointer(dims)))
else:
- c_val = ct.c_double(val)
- safe_call(backend.get().af_constant(ct.pointer(out), c_val, 4, ct.pointer(dims), dtype))
+ c_val = c_double_t(val)
+ safe_call(backend.get().af_constant(c_pointer(out), c_val, 4, c_pointer(dims), dtype))
return out
@@ -109,7 +109,7 @@ def _binary_func(lhs, rhs, c_func):
elif not isinstance(rhs, Array):
raise TypeError("Invalid parameter to binary function")
- safe_call(c_func(ct.pointer(out.arr), lhs.arr, other.arr, _bcast_var.get()))
+ safe_call(c_func(c_pointer(out.arr), lhs.arr, other.arr, _bcast_var.get()))
return out
@@ -125,7 +125,7 @@ def _binary_funcr(lhs, rhs, c_func):
elif not isinstance(lhs, Array):
raise TypeError("Invalid parameter to binary function")
- c_func(ct.pointer(out.arr), other.arr, rhs.arr, _bcast_var.get())
+ c_func(c_pointer(out.arr), other.arr, rhs.arr, _bcast_var.get())
return out
@@ -257,7 +257,7 @@ def transpose(a, conj=False):
"""
out = Array()
- safe_call(backend.get().af_transpose(ct.pointer(out.arr), a.arr, conj))
+ safe_call(backend.get().af_transpose(c_pointer(out.arr), a.arr, conj))
return out
def transpose_inplace(a, conj=False):
@@ -403,7 +403,7 @@ class Array(BaseArray):
if src is not None:
if (isinstance(src, Array)):
- safe_call(backend.get().af_retain_array(ct.pointer(self.arr), src.arr))
+ safe_call(backend.get().af_retain_array(c_pointer(self.arr), src.arr))
return
host = __import__("array")
@@ -417,8 +417,8 @@ class Array(BaseArray):
buf,buf_len = tmp.buffer_info()
_type_char = tmp.typecode
numdims, idims = _get_info(dims, buf_len)
- elif isinstance(src, int) or isinstance(src, ct.c_void_p):
- buf = src if not isinstance(src, ct.c_void_p) else src.value
+ elif isinstance(src, int) or isinstance(src, c_void_ptr_t):
+ buf = src if not isinstance(src, c_void_ptr_t) else src.value
numdims, idims = _get_info(dims, buf_len)
@@ -476,7 +476,7 @@ class Array(BaseArray):
An identical copy of self.
"""
out = Array()
- safe_call(backend.get().af_copy_array(ct.pointer(out.arr), self.arr))
+ safe_call(backend.get().af_copy_array(c_pointer(out.arr), self.arr))
return out
def __del__(self):
@@ -503,8 +503,8 @@ class Array(BaseArray):
- A copy of the memory is done if multiple arrays share the same memory or the array is not the owner of the memory.
- In case of a copy the return value points to the newly allocated memory which is now exclusively owned by the array.
"""
- ptr = ct.c_void_p(0)
- backend.get().af_get_device_ptr(ct.pointer(ptr), self.arr)
+ ptr = c_void_ptr_t(0)
+ backend.get().af_get_device_ptr(c_pointer(ptr), self.arr)
return ptr.value
def raw_ptr(self):
@@ -524,8 +524,8 @@ class Array(BaseArray):
- In particular the JIT compiler will not be aware of the shared arrays.
- This results in JITed operations not being immediately visible through the other array.
"""
- ptr = ct.c_void_p(0)
- backend.get().af_get_raw_ptr(ct.pointer(ptr), self.arr)
+ ptr = c_void_ptr_t(0)
+ backend.get().af_get_raw_ptr(c_pointer(ptr), self.arr)
return ptr.value
def offset(self):
@@ -538,7 +538,7 @@ class Array(BaseArray):
The offset in number of elements
"""
offset = c_dim_t(0)
- safe_call(backend.get().af_get_offset(ct.pointer(offset), self.arr))
+ safe_call(backend.get().af_get_offset(c_pointer(offset), self.arr))
return offset.value
def strides(self):
@@ -554,8 +554,8 @@ class Array(BaseArray):
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))
+ safe_call(backend.get().af_get_strides(c_pointer(s0), c_pointer(s1),
+ c_pointer(s2), c_pointer(s3), self.arr))
strides = (s0.value,s1.value,s2.value,s3.value)
return strides[:self.numdims()]
@@ -564,15 +564,15 @@ class Array(BaseArray):
Return the number of elements in the array.
"""
num = c_dim_t(0)
- safe_call(backend.get().af_get_elements(ct.pointer(num), self.arr))
+ safe_call(backend.get().af_get_elements(c_pointer(num), self.arr))
return num.value
def dtype(self):
"""
Return the data type as a arrayfire.Dtype enum value.
"""
- dty = ct.c_int(Dtype.f32.value)
- safe_call(backend.get().af_get_type(ct.pointer(dty), self.arr))
+ dty = c_int_t(Dtype.f32.value)
+ safe_call(backend.get().af_get_type(c_pointer(dty), self.arr))
return to_dtype[to_typecode[dty.value]]
def type(self):
@@ -603,8 +603,8 @@ class Array(BaseArray):
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))
+ safe_call(backend.get().af_get_dims(c_pointer(d0), c_pointer(d1),
+ c_pointer(d2), c_pointer(d3), self.arr))
dims = (d0.value,d1.value,d2.value,d3.value)
return dims[:self.numdims()]
@@ -619,40 +619,40 @@ class Array(BaseArray):
"""
Return the number of dimensions of the array.
"""
- nd = ct.c_uint(0)
- safe_call(backend.get().af_get_numdims(ct.pointer(nd), self.arr))
+ nd = c_uint_t(0)
+ safe_call(backend.get().af_get_numdims(c_pointer(nd), self.arr))
return nd.value
def is_empty(self):
"""
Check if the array is empty i.e. it has no elements.
"""
- res = ct.c_bool(False)
- safe_call(backend.get().af_is_empty(ct.pointer(res), self.arr))
+ res = c_bool_t(False)
+ safe_call(backend.get().af_is_empty(c_pointer(res), self.arr))
return res.value
def is_scalar(self):
"""
Check if the array is scalar i.e. it has only one element.
"""
- res = ct.c_bool(False)
- safe_call(backend.get().af_is_scalar(ct.pointer(res), self.arr))
+ res = c_bool_t(False)
+ safe_call(backend.get().af_is_scalar(c_pointer(res), self.arr))
return res.value
def is_row(self):
"""
Check if the array is a row i.e. it has a shape of (1, cols).
"""
- res = ct.c_bool(False)
- safe_call(backend.get().af_is_row(ct.pointer(res), self.arr))
+ res = c_bool_t(False)
+ safe_call(backend.get().af_is_row(c_pointer(res), self.arr))
return res.value
def is_column(self):
"""
Check if the array is a column i.e. it has a shape of (rows, 1).
"""
- res = ct.c_bool(False)
- safe_call(backend.get().af_is_column(ct.pointer(res), self.arr))
+ res = c_bool_t(False)
+ safe_call(backend.get().af_is_column(c_pointer(res), self.arr))
return res.value
def is_vector(self):
@@ -663,96 +663,96 @@ class Array(BaseArray):
- (1, 1, vols)
- (1, 1, 1, batch)
"""
- res = ct.c_bool(False)
- safe_call(backend.get().af_is_vector(ct.pointer(res), self.arr))
+ res = c_bool_t(False)
+ safe_call(backend.get().af_is_vector(c_pointer(res), self.arr))
return res.value
def is_sparse(self):
"""
Check if the array is a sparse matrix.
"""
- res = ct.c_bool(False)
- safe_call(backend.get().af_is_sparse(ct.pointer(res), self.arr))
+ res = c_bool_t(False)
+ safe_call(backend.get().af_is_sparse(c_pointer(res), self.arr))
return res.value
def is_complex(self):
"""
Check if the array is of complex type.
"""
- res = ct.c_bool(False)
- safe_call(backend.get().af_is_complex(ct.pointer(res), self.arr))
+ res = c_bool_t(False)
+ safe_call(backend.get().af_is_complex(c_pointer(res), self.arr))
return res.value
def is_real(self):
"""
Check if the array is not of complex type.
"""
- res = ct.c_bool(False)
- safe_call(backend.get().af_is_real(ct.pointer(res), self.arr))
+ res = c_bool_t(False)
+ safe_call(backend.get().af_is_real(c_pointer(res), self.arr))
return res.value
def is_double(self):
"""
Check if the array is of double precision floating point type.
"""
- res = ct.c_bool(False)
- safe_call(backend.get().af_is_double(ct.pointer(res), self.arr))
+ res = c_bool_t(False)
+ safe_call(backend.get().af_is_double(c_pointer(res), self.arr))
return res.value
def is_single(self):
"""
Check if the array is of single precision floating point type.
"""
- res = ct.c_bool(False)
- safe_call(backend.get().af_is_single(ct.pointer(res), self.arr))
+ res = c_bool_t(False)
+ safe_call(backend.get().af_is_single(c_pointer(res), self.arr))
return res.value
def is_real_floating(self):
"""
Check if the array is real and of floating point type.
"""
- res = ct.c_bool(False)
- safe_call(backend.get().af_is_realfloating(ct.pointer(res), self.arr))
+ res = c_bool_t(False)
+ safe_call(backend.get().af_is_realfloating(c_pointer(res), self.arr))
return res.value
def is_floating(self):
"""
Check if the array is of floating point type.
"""
- res = ct.c_bool(False)
- safe_call(backend.get().af_is_floating(ct.pointer(res), self.arr))
+ res = c_bool_t(False)
+ safe_call(backend.get().af_is_floating(c_pointer(res), self.arr))
return res.value
def is_integer(self):
"""
Check if the array is of integer type.
"""
- res = ct.c_bool(False)
- safe_call(backend.get().af_is_integer(ct.pointer(res), self.arr))
+ res = c_bool_t(False)
+ safe_call(backend.get().af_is_integer(c_pointer(res), self.arr))
return res.value
def is_bool(self):
"""
Check if the array is of type b8.
"""
- res = ct.c_bool(False)
- safe_call(backend.get().af_is_bool(ct.pointer(res), self.arr))
+ res = c_bool_t(False)
+ safe_call(backend.get().af_is_bool(c_pointer(res), self.arr))
return res.value
def is_linear(self):
"""
Check if all elements of the array are contiguous.
"""
- res = ct.c_bool(False)
- safe_call(backend.get().af_is_linear(ct.pointer(res), self.arr))
+ res = c_bool_t(False)
+ safe_call(backend.get().af_is_linear(c_pointer(res), self.arr))
return res.value
def is_owner(self):
"""
Check if the array owns the raw pointer or is a derived array.
"""
- res = ct.c_bool(False)
- safe_call(backend.get().af_is_owner(ct.pointer(res), self.arr))
+ res = c_bool_t(False)
+ safe_call(backend.get().af_is_owner(c_pointer(res), self.arr))
return res.value
def __add__(self, other):
@@ -1033,7 +1033,7 @@ class Array(BaseArray):
inds = _get_indices(key)
- safe_call(backend.get().af_index_gen(ct.pointer(out.arr),
+ safe_call(backend.get().af_index_gen(c_pointer(out.arr),
self.arr, c_dim_t(n_dims), inds.pointer))
return out
except RuntimeError as e:
@@ -1071,10 +1071,10 @@ class Array(BaseArray):
other_arr = val.arr
del_other = False
- out_arr = ct.c_void_p(0)
+ out_arr = c_void_ptr_t(0)
inds = _get_indices(key)
- safe_call(backend.get().af_assign_gen(ct.pointer(out_arr),
+ safe_call(backend.get().af_assign_gen(c_pointer(out_arr),
self.arr, c_dim_t(n_dims), inds.pointer,
other_arr))
safe_call(backend.get().af_release_array(self.arr))
@@ -1113,7 +1113,7 @@ class Array(BaseArray):
tmp = transpose(self) if row_major else self
ctype_type = to_c_type[self.type()] * self.elements()
res = ctype_type()
- safe_call(backend.get().af_get_data_ptr(ct.pointer(res), self.arr))
+ safe_call(backend.get().af_get_data_ptr(c_pointer(res), self.arr))
if (return_shape):
return res, self.dims()
else:
@@ -1188,8 +1188,8 @@ class Array(BaseArray):
You can also use af.display(a, pres) to display the contents of the array with better precision.
"""
- arr_str = ct.c_char_p(0)
- safe_call(backend.get().af_array_to_string(ct.pointer(arr_str), "", self.arr, 4, True))
+ arr_str = c_char_ptr_t(0)
+ safe_call(backend.get().af_array_to_string(c_pointer(arr_str), "", self.arr, 4, True))
return 'arrayfire.Array()\nType: %s' % \
(to_typename[self.type()]) + to_str(arr_str)
@@ -1200,7 +1200,7 @@ class Array(BaseArray):
"""
import numpy as np
res = np.empty(self.dims(), dtype=np.dtype(to_typecode[self.type()]), order='F')
- safe_call(backend.get().af_get_data_ptr(ct.c_void_p(res.ctypes.data), self.arr))
+ safe_call(backend.get().af_get_data_ptr(c_void_ptr_t(res.ctypes.data), self.arr))
return res
def display(a, precision=4):
@@ -1226,7 +1226,7 @@ def display(a, precision=4):
pass
safe_call(backend.get().af_print_array_gen(name.encode('utf-8'),
- a.arr, ct.c_int(precision)))
+ a.arr, c_int_t(precision)))
def save_array(key, a, filename, append=False):
"""
@@ -1251,8 +1251,8 @@ def save_array(key, a, filename, append=False):
index : int
The index of the array stored in the file.
"""
- index = ct.c_int(-1)
- safe_call(backend.get().af_save_array(ct.pointer(index),
+ index = c_int_t(-1)
+ safe_call(backend.get().af_save_array(c_pointer(index),
key.encode('utf-8'),
a.arr,
filename.encode('utf-8'),
@@ -1283,11 +1283,11 @@ def read_array(filename, index=None, key=None):
assert((index is not None) or (key is not None))
out = Array()
if (index is not None):
- safe_call(backend.get().af_read_array_index(ct.pointer(out.arr),
+ safe_call(backend.get().af_read_array_index(c_pointer(out.arr),
filename.encode('utf-8'),
index))
elif (key is not None):
- safe_call(backend.get().af_read_array_key(ct.pointer(out.arr),
+ safe_call(backend.get().af_read_array_key(c_pointer(out.arr),
filename.encode('utf-8'),
key.encode('utf-8')))
diff --git a/arrayfire/base.py b/arrayfire/base.py
index 90b2205..ca072fa 100644
--- a/arrayfire/base.py
+++ b/arrayfire/base.py
@@ -19,4 +19,4 @@ class BaseArray(object):
Base array class for arrayfire. For internal use only.
"""
def __init__(self):
- self.arr = ct.c_void_p(0)
+ self.arr = c_void_ptr_t(0)
diff --git a/arrayfire/blas.py b/arrayfire/blas.py
index a3774f1..4fa7ffa 100644
--- a/arrayfire/blas.py
+++ b/arrayfire/blas.py
@@ -53,7 +53,7 @@ def matmul(lhs, rhs, lhs_opts=MATPROP.NONE, rhs_opts=MATPROP.NONE):
"""
out = Array()
- safe_call(backend.get().af_matmul(ct.pointer(out.arr), lhs.arr, rhs.arr,
+ safe_call(backend.get().af_matmul(c_pointer(out.arr), lhs.arr, rhs.arr,
lhs_opts.value, rhs_opts.value))
return out
@@ -84,7 +84,7 @@ def matmulTN(lhs, rhs):
"""
out = Array()
- safe_call(backend.get().af_matmul(ct.pointer(out.arr), lhs.arr, rhs.arr,
+ safe_call(backend.get().af_matmul(c_pointer(out.arr), lhs.arr, rhs.arr,
MATPROP.TRANS.value, MATPROP.NONE.value))
return out
@@ -115,7 +115,7 @@ def matmulNT(lhs, rhs):
"""
out = Array()
- safe_call(backend.get().af_matmul(ct.pointer(out.arr), lhs.arr, rhs.arr,
+ safe_call(backend.get().af_matmul(c_pointer(out.arr), lhs.arr, rhs.arr,
MATPROP.NONE.value, MATPROP.TRANS.value))
return out
@@ -146,7 +146,7 @@ def matmulTT(lhs, rhs):
"""
out = Array()
- safe_call(backend.get().af_matmul(ct.pointer(out.arr), lhs.arr, rhs.arr,
+ safe_call(backend.get().af_matmul(c_pointer(out.arr), lhs.arr, rhs.arr,
MATPROP.TRANS.value, MATPROP.TRANS.value))
return out
@@ -187,6 +187,6 @@ def dot(lhs, rhs, lhs_opts=MATPROP.NONE, rhs_opts=MATPROP.NONE):
"""
out = Array()
- safe_call(backend.get().af_dot(ct.pointer(out.arr), lhs.arr, rhs.arr,
+ safe_call(backend.get().af_dot(c_pointer(out.arr), lhs.arr, rhs.arr,
lhs_opts.value, rhs_opts.value))
return out
diff --git a/arrayfire/cuda.py b/arrayfire/cuda.py
index 4ca7810..ea24c0e 100644
--- a/arrayfire/cuda.py
+++ b/arrayfire/cuda.py
@@ -35,8 +35,8 @@ def get_stream(idx):
if (backend.name() != "cuda"):
raise RuntimeError("Invalid backend loaded")
- stream = ct.c_void_p(0)
- safe_call(backend.get().afcu_get_stream(ct.pointer(stream), idx))
+ stream = c_void_ptr_t(0)
+ safe_call(backend.get().afcu_get_stream(c_pointer(stream), idx))
return stream.value
def get_native_id(idx):
@@ -61,8 +61,8 @@ def get_native_id(idx):
if (backend.name() != "cuda"):
raise RuntimeError("Invalid backend loaded")
- native = ct.c_int(0)
- safe_call(backend.get().afcu_get_native_id(ct.pointer(native), idx))
+ native = c_int_t(0)
+ safe_call(backend.get().afcu_get_native_id(c_pointer(native), idx))
return native.value
def set_native_id(idx):
diff --git a/arrayfire/data.py b/arrayfire/data.py
index 786d649..0e953f7 100644
--- a/arrayfire/data.py
+++ b/arrayfire/data.py
@@ -118,7 +118,7 @@ def range(d0, d1=None, d2=None, d3=None, dim=0, dtype=Dtype.f32):
out = Array()
dims = dim4(d0, d1, d2, d3)
- safe_call(backend.get().af_range(ct.pointer(out.arr), 4, ct.pointer(dims), dim, dtype.value))
+ safe_call(backend.get().af_range(c_pointer(out.arr), 4, c_pointer(dims), dim, dtype.value))
return out
@@ -183,8 +183,8 @@ def iota(d0, d1=None, d2=None, d3=None, dim=-1, tile_dims=None, dtype=Dtype.f32)
tdims = dim4(td[0], td[1], td[2], td[3])
- safe_call(backend.get().af_iota(ct.pointer(out.arr), 4, ct.pointer(dims),
- 4, ct.pointer(tdims), dtype.value))
+ safe_call(backend.get().af_iota(c_pointer(out.arr), 4, c_pointer(dims),
+ 4, c_pointer(tdims), dtype.value))
return out
def identity(d0, d1, d2=None, d3=None, dtype=Dtype.f32):
@@ -221,7 +221,7 @@ def identity(d0, d1, d2=None, d3=None, dtype=Dtype.f32):
out = Array()
dims = dim4(d0, d1, d2, d3)
- safe_call(backend.get().af_identity(ct.pointer(out.arr), 4, ct.pointer(dims), dtype.value))
+ safe_call(backend.get().af_identity(c_pointer(out.arr), 4, c_pointer(dims), dtype.value))
return out
def diag(a, num=0, extract=True):
@@ -252,9 +252,9 @@ def diag(a, num=0, extract=True):
"""
out = Array()
if extract:
- safe_call(backend.get().af_diag_extract(ct.pointer(out.arr), a.arr, ct.c_int(num)))
+ safe_call(backend.get().af_diag_extract(c_pointer(out.arr), a.arr, c_int_t(num)))
else:
- safe_call(backend.get().af_diag_create(ct.pointer(out.arr), a.arr, ct.c_int(num)))
+ safe_call(backend.get().af_diag_create(c_pointer(out.arr), a.arr, c_int_t(num)))
return out
def join(dim, first, second, third=None, fourth=None):
@@ -317,9 +317,9 @@ def join(dim, first, second, third=None, fourth=None):
"""
out = Array()
if (third is None and fourth is None):
- safe_call(backend.get().af_join(ct.pointer(out.arr), dim, first.arr, second.arr))
+ safe_call(backend.get().af_join(c_pointer(out.arr), dim, first.arr, second.arr))
else:
- c_void_p_4 = ct.c_void_p * 4
+ c_void_p_4 = c_void_ptr_t * 4
c_array_vec = c_void_p_4(first.arr, second.arr, 0, 0)
num = 2
if third is not None:
@@ -329,7 +329,7 @@ def join(dim, first, second, third=None, fourth=None):
c_array_vec[num] = fourth.arr
num+=1
- safe_call(backend.get().af_join_many(ct.pointer(out.arr), dim, num, ct.pointer(c_array_vec)))
+ safe_call(backend.get().af_join_many(c_pointer(out.arr), dim, num, c_pointer(c_array_vec)))
return out
@@ -394,7 +394,7 @@ def tile(a, d0, d1=1, d2=1, d3=1):
0.8224 0.1794 0.0081 0.8224 0.1794 0.0081
"""
out = Array()
- safe_call(backend.get().af_tile(ct.pointer(out.arr), a.arr, d0, d1, d2, d3))
+ safe_call(backend.get().af_tile(c_pointer(out.arr), a.arr, d0, d1, d2, d3))
return out
@@ -479,7 +479,7 @@ def reorder(a, d0=1, d1=0, d2=2, d3=3):
0.9276 0.8662 0.3578 0.6263 0.9747
"""
out = Array()
- safe_call(backend.get().af_reorder(ct.pointer(out.arr), a.arr, d0, d1, d2, d3))
+ safe_call(backend.get().af_reorder(c_pointer(out.arr), a.arr, d0, d1, d2, d3))
return out
def shift(a, d0, d1=0, d2=0, d3=0):
@@ -535,7 +535,7 @@ def shift(a, d0, d1=0, d2=0, d3=0):
0.1437 0.0899 0.7104
"""
out = Array()
- safe_call(backend.get().af_shift(ct.pointer(out.arr), a.arr, d0, d1, d2, d3))
+ safe_call(backend.get().af_shift(c_pointer(out.arr), a.arr, d0, d1, d2, d3))
return out
def moddims(a, d0, d1=1, d2=1, d3=1):
@@ -569,7 +569,7 @@ def moddims(a, d0, d1=1, d2=1, d3=1):
"""
out = Array()
dims = dim4(d0, d1, d2, d3)
- safe_call(backend.get().af_moddims(ct.pointer(out.arr), a.arr, 4, ct.pointer(dims)))
+ safe_call(backend.get().af_moddims(c_pointer(out.arr), a.arr, 4, c_pointer(dims)))
return out
def flat(a):
@@ -589,7 +589,7 @@ def flat(a):
- 1 dimensional array containing all the elements from `a`.
"""
out = Array()
- safe_call(backend.get().af_flat(ct.pointer(out.arr), a.arr))
+ safe_call(backend.get().af_flat(c_pointer(out.arr), a.arr))
return out
def flip(a, dim=0):
@@ -636,7 +636,7 @@ def flip(a, dim=0):
"""
out = Array()
- safe_call(backend.get().af_flip(ct.pointer(out.arr), a.arr, ct.c_int(dim)))
+ safe_call(backend.get().af_flip(c_pointer(out.arr), a.arr, c_int_t(dim)))
return out
def lower(a, is_unit_diag=False):
@@ -659,7 +659,7 @@ def lower(a, is_unit_diag=False):
An array containing the lower triangular elements from `a`.
"""
out = Array()
- safe_call(backend.get().af_lower(ct.pointer(out.arr), a.arr, is_unit_diag))
+ safe_call(backend.get().af_lower(c_pointer(out.arr), a.arr, is_unit_diag))
return out
def upper(a, is_unit_diag=False):
@@ -682,7 +682,7 @@ def upper(a, is_unit_diag=False):
An array containing the upper triangular elements from `a`.
"""
out = Array()
- safe_call(backend.get().af_upper(ct.pointer(out.arr), a.arr, is_unit_diag))
+ safe_call(backend.get().af_upper(c_pointer(out.arr), a.arr, is_unit_diag))
return out
def select(cond, lhs, rhs):
@@ -743,12 +743,12 @@ def select(cond, lhs, rhs):
raise TypeError("Atleast one input needs to be of type arrayfire.array")
elif (is_left_array and is_right_array):
- safe_call(backend.get().af_select(ct.pointer(out.arr), cond.arr, lhs.arr, rhs.arr))
+ safe_call(backend.get().af_select(c_pointer(out.arr), cond.arr, lhs.arr, rhs.arr))
elif (_is_number(rhs)):
- safe_call(backend.get().af_select_scalar_r(ct.pointer(out.arr), cond.arr, lhs.arr, ct.c_double(rhs)))
+ safe_call(backend.get().af_select_scalar_r(c_pointer(out.arr), cond.arr, lhs.arr, c_double_t(rhs)))
else:
- safe_call(backend.get().af_select_scalar_l(ct.pointer(out.arr), cond.arr, ct.c_double(lhs), rhs.arr))
+ safe_call(backend.get().af_select_scalar_l(c_pointer(out.arr), cond.arr, c_double_t(lhs), rhs.arr))
return out
@@ -798,4 +798,4 @@ def replace(lhs, cond, rhs):
if (is_right_array):
safe_call(backend.get().af_replace(lhs.arr, cond.arr, rhs.arr))
else:
- safe_call(backend.get().af_replace_scalar(lhs.arr, cond.arr, ct.c_double(rhs)))
+ safe_call(backend.get().af_replace_scalar(lhs.arr, cond.arr, c_double_t(rhs)))
diff --git a/arrayfire/device.py b/arrayfire/device.py
index b13989b..ad8abd5 100644
--- a/arrayfire/device.py
+++ b/arrayfire/device.py
@@ -39,14 +39,14 @@ def device_info():
- 'toolkit': The toolkit version for the backend.
- 'compute': The compute version of the device.
"""
- c_char_256 = ct.c_char * 256
+ c_char_256 = c_char_t * 256
device_name = c_char_256()
backend_name = c_char_256()
toolkit = c_char_256()
compute = c_char_256()
- safe_call(backend.get().af_device_info(ct.pointer(device_name), ct.pointer(backend_name),
- ct.pointer(toolkit), ct.pointer(compute)))
+ safe_call(backend.get().af_device_info(c_pointer(device_name), c_pointer(backend_name),
+ c_pointer(toolkit), c_pointer(compute)))
dev_info = {}
dev_info['device'] = to_str(device_name)
dev_info['backend'] = to_str(backend_name)
@@ -59,16 +59,16 @@ def get_device_count():
"""
Returns the number of devices available.
"""
- c_num = ct.c_int(0)
- safe_call(backend.get().af_get_device_count(ct.pointer(c_num)))
+ c_num = c_int_t(0)
+ safe_call(backend.get().af_get_device_count(c_pointer(c_num)))
return c_num.value
def get_device():
"""
Returns the id of the current device.
"""
- c_dev = ct.c_int(0)
- safe_call(backend.get().af_get_device(ct.pointer(c_dev)))
+ c_dev = c_int_t(0)
+ safe_call(backend.get().af_get_device(c_pointer(c_dev)))
return c_dev.value
def set_device(num):
@@ -146,8 +146,8 @@ def is_dbl_supported(device=None):
- False if double precision not supported.
"""
dev = device if device is not None else get_device()
- res = ct.c_bool(False)
- safe_call(backend.get().af_get_dbl_support(ct.pointer(res), dev))
+ res = c_bool_t(False)
+ safe_call(backend.get().af_get_dbl_support(c_pointer(res), dev))
return res.value
def sync(device=None):
@@ -167,11 +167,11 @@ def __eval(*args):
if (nargs == 1):
safe_call(backend.get().af_eval(args[0].arr))
else:
- c_void_p_n = ct.c_void_p * nargs
+ c_void_p_n = c_void_ptr_t * nargs
arrs = c_void_p_n()
for n in range(nargs):
arrs[n] = args[n].arr
- safe_call(backend.get().af_eval_multiple(ct.c_int(nargs), ct.pointer(arrs)))
+ safe_call(backend.get().af_eval_multiple(c_int_t(nargs), c_pointer(arrs)))
return
def eval(*args):
@@ -241,8 +241,8 @@ def get_manual_eval_flag():
----
This does not affect the evaluation that occurs when a non JIT function forces the evaluation.
"""
- res = ct.c_bool(False)
- safe_call(backend.get().af_get_manual_eval_flag(ct.pointer(res)))
+ res = c_bool_t(False)
+ safe_call(backend.get().af_get_manual_eval_flag(c_pointer(res)))
return res.value
def device_mem_info():
@@ -262,12 +262,12 @@ def device_mem_info():
- The difference between alloc bytes and lock bytes equals the number of free bytes.
"""
- alloc_bytes = ct.c_size_t(0)
- alloc_buffers = ct.c_size_t(0)
- lock_bytes = ct.c_size_t(0)
- lock_buffers = ct.c_size_t(0)
- safe_call(backend.get().af_device_mem_info(ct.pointer(alloc_bytes), ct.pointer(alloc_buffers),
- ct.pointer(lock_bytes), ct.pointer(lock_buffers)))
+ alloc_bytes = c_size_t(0)
+ alloc_buffers = c_size_t(0)
+ lock_bytes = c_size_t(0)
+ lock_buffers = c_size_t(0)
+ safe_call(backend.get().af_device_mem_info(c_pointer(alloc_bytes), c_pointer(alloc_buffers),
+ c_pointer(lock_bytes), c_pointer(lock_buffers)))
mem_info = {}
mem_info['alloc'] = {'buffers' : alloc_buffers.value, 'bytes' : alloc_bytes.value}
mem_info['lock'] = {'buffers' : lock_buffers.value, 'bytes' : lock_bytes.value}
@@ -298,8 +298,8 @@ def get_device_ptr(a):
- This function enables the user to interoperate arrayfire with other CUDA/OpenCL/C libraries.
"""
- ptr = ct.c_void_p(0)
- safe_call(backend.get().af_get_device_ptr(ct.pointer(ptr), a.arr))
+ ptr = c_void_ptr_t(0)
+ safe_call(backend.get().af_get_device_ptr(c_pointer(ptr), a.arr))
return ptr
def lock_device_ptr(a):
@@ -338,8 +338,8 @@ def is_locked_array(a):
-----------
A bool specifying if the input array is locked.
"""
- res = ct.c_bool(False)
- safe_call(backend.get().af_is_locked_array(ct.pointer(res), a.arr))
+ res = c_bool_t(False)
+ safe_call(backend.get().af_is_locked_array(c_pointer(res), a.arr))
return res.value
def unlock_device_ptr(a):
@@ -366,48 +366,48 @@ def alloc_device(num_bytes):
"""
Allocate a buffer on the device with specified number of bytes.
"""
- ptr = ct.c_void_p(0)
+ ptr = c_void_ptr_t(0)
c_num_bytes = c_dim_t(num_bytes)
- safe_call(backend.get().af_alloc_device(ct.pointer(ptr), c_num_bytes))
+ safe_call(backend.get().af_alloc_device(c_pointer(ptr), c_num_bytes))
return ptr.value
def alloc_host(num_bytes):
"""
Allocate a buffer on the host with specified number of bytes.
"""
- ptr = ct.c_void_p(0)
+ ptr = c_void_ptr_t(0)
c_num_bytes = c_dim_t(num_bytes)
- safe_call(backend.get().af_alloc_host(ct.pointer(ptr), c_num_bytes))
+ safe_call(backend.get().af_alloc_host(c_pointer(ptr), c_num_bytes))
return ptr.value
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)
+ ptr = c_void_ptr_t(0)
c_num_bytes = c_dim_t(num_bytes)
- safe_call(backend.get().af_alloc_pinned(ct.pointer(ptr), c_num_bytes))
+ safe_call(backend.get().af_alloc_pinned(c_pointer(ptr), c_num_bytes))
return ptr.value
def free_device(ptr):
"""
Free the device memory allocated by alloc_device
"""
- cptr = ct.c_void_p(ptr)
+ cptr = c_void_ptr_t(ptr)
safe_call(backend.get().af_free_device(cptr))
def free_host(ptr):
"""
Free the host memory allocated by alloc_host
"""
- cptr = ct.c_void_p(ptr)
+ cptr = c_void_ptr_t(ptr)
safe_call(backend.get().af_free_host(cptr))
def free_pinned(ptr):
"""
Free the pinned memory allocated by alloc_pinned
"""
- cptr = ct.c_void_p(ptr)
+ cptr = c_void_ptr_t(ptr)
safe_call(backend.get().af_free_pinned(cptr))
from .array import Array
diff --git a/arrayfire/features.py b/arrayfire/features.py
index 6e006af..efb2489 100644
--- a/arrayfire/features.py
+++ b/arrayfire/features.py
@@ -27,17 +27,17 @@ class Features(object):
"""
def __init__(self, num=0):
- self.feat = ct.c_void_p(0)
+ self.feat = c_void_ptr_t(0)
if num is not None:
assert(isinstance(num, numbers.Number))
- safe_call(backend.get().af_create_features(ct.pointer(self.feat), c_dim_t(num)))
+ safe_call(backend.get().af_create_features(c_pointer(self.feat), c_dim_t(num)))
def num_features(self):
"""
Returns the number of features detected.
"""
num = c_dim_t(0)
- safe_call(backend.get().af_get_features_num(ct.pointer(num), self.feat))
+ safe_call(backend.get().af_get_features_num(c_pointer(num), self.feat))
return num
def get_xpos(self):
@@ -45,7 +45,7 @@ class Features(object):
Returns the x-positions of the features detected.
"""
out = Array()
- safe_call(backend.get().af_get_features_xpos(ct.pointer(out.arr), self.feat))
+ safe_call(backend.get().af_get_features_xpos(c_pointer(out.arr), self.feat))
return out
def get_ypos(self):
@@ -53,7 +53,7 @@ class Features(object):
Returns the y-positions of the features detected.
"""
out = Array()
- safe_call(backend.get().af_get_features_ypos(ct.pointer(out.arr), self.feat))
+ safe_call(backend.get().af_get_features_ypos(c_pointer(out.arr), self.feat))
return out
def get_score(self):
@@ -61,7 +61,7 @@ class Features(object):
Returns the scores of the features detected.
"""
out = Array()
- safe_call(backend.get().af_get_features_score(ct.pointer(out.arr), self.feat))
+ safe_call(backend.get().af_get_features_score(c_pointer(out.arr), self.feat))
return out
def get_orientation(self):
@@ -69,7 +69,7 @@ class Features(object):
Returns the orientations of the features detected.
"""
out = Array()
- safe_call(backend.get().af_get_features_orientation(ct.pointer(out.arr), self.feat))
+ safe_call(backend.get().af_get_features_orientation(c_pointer(out.arr), self.feat))
return out
def get_size(self):
@@ -77,5 +77,5 @@ class Features(object):
Returns the sizes of the features detected.
"""
out = Array()
- safe_call(backend.get().af_get_features_size(ct.pointer(out.arr), self.feat))
+ safe_call(backend.get().af_get_features_size(c_pointer(out.arr), self.feat))
return out
diff --git a/arrayfire/graphics.py b/arrayfire/graphics.py
index 59da8db..3ada187 100644
--- a/arrayfire/graphics.py
+++ b/arrayfire/graphics.py
@@ -16,15 +16,15 @@ from .array import *
from .util import _is_number
class _Cell(ct.Structure):
- _fields_ = [("row", ct.c_int),
- ("col", ct.c_int),
- ("title", ct.c_char_p),
- ("cmap", ct.c_int)]
+ _fields_ = [("row", c_int_t),
+ ("col", c_int_t),
+ ("title", c_char_ptr_t),
+ ("cmap", c_int_t)]
def __init__(self, r, c, title, cmap):
self.row = r
self.col = c
- self.title = title if title is not None else ct.c_char_p()
+ self.title = title if title is not None else c_char_ptr_t()
self.cmap = cmap.value
class Window(object):
@@ -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_void_p(0)
+ self._wnd = c_void_ptr_t(0)
self._cmap = COLORMAP.DEFAULT
_width = 1280 if width is None else width
@@ -57,9 +57,9 @@ class Window(object):
_title = _title.encode("ascii")
- safe_call(backend.get().af_create_window(ct.pointer(self._wnd),
- ct.c_int(_width), ct.c_int(_height),
- ct.c_char_p(_title)))
+ safe_call(backend.get().af_create_window(c_pointer(self._wnd),
+ c_int_t(_width), c_int_t(_height),
+ c_char_ptr_t(_title)))
def __del__(self):
"""
@@ -81,7 +81,7 @@ class Window(object):
Pixel offset from top
"""
- safe_call(backend.get().af_set_position(self._wnd, ct.c_int(x), ct.c_int(y)))
+ safe_call(backend.get().af_set_position(self._wnd, c_int_t(x), c_int_t(y)))
def set_title(self, title):
"""
@@ -138,7 +138,7 @@ class Window(object):
Title used for the image.
"""
_cell = _Cell(self._r, self._c, title, self._cmap)
- safe_call(backend.get().af_draw_image(self._wnd, img.arr, ct.pointer(_cell)))
+ safe_call(backend.get().af_draw_image(self._wnd, img.arr, c_pointer(_cell)))
def scatter(self, X, Y, Z=None, points=None, marker=MARKER.POINT, title=None):
"""
@@ -172,12 +172,12 @@ class Window(object):
if points is None:
if Z is None:
safe_call(backend.get().af_draw_scatter_2d(self._wnd, X.arr, Y.arr,
- marker.value, ct.pointer(_cell)))
+ marker.value, c_pointer(_cell)))
else:
safe_call(backend.get().af_draw_scatter_3d(self._wnd, X.arr, Y.arr, Z.arr,
- marker.value, ct.pointer(_cell)))
+ marker.value, c_pointer(_cell)))
else:
- safe_call(backend.get().af_draw_scatter_nd(self._wnd, points.arr, marker.value, ct.pointer(_cell)))
+ safe_call(backend.get().af_draw_scatter_nd(self._wnd, points.arr, marker.value, c_pointer(_cell)))
def scatter2(self, points, marker=MARKER.POINT, title=None):
"""
@@ -198,7 +198,7 @@ class Window(object):
assert(points.numdims() == 2)
_cell = _Cell(self._r, self._c, title, self._cmap)
safe_call(backend.get().af_draw_scatter2(self._wnd, points.arr,
- marker.value, ct.pointer(_cell)))
+ marker.value, c_pointer(_cell)))
def scatter3(self, points, marker=MARKER.POINT, title=None):
"""
@@ -219,7 +219,7 @@ class Window(object):
assert(points.numdims() == 3)
_cell = _Cell(self._r, self._c, title, self._cmap)
safe_call(backend.get().af_draw_scatter3(self._wnd, points.arr,
- marker.value, ct.pointer(_cell)))
+ marker.value, c_pointer(_cell)))
def plot(self, X, Y, Z=None, line = None, title=None):
"""
Display a 2D or 3D Plot.
@@ -254,11 +254,11 @@ class Window(object):
_cell = _Cell(self._r, self._c, title, self._cmap)
if line is None:
if Z is None:
- safe_call(backend.get().af_draw_plot_2d(self._wnd, X.arr, Y.arr, ct.pointer(_cell)))
+ safe_call(backend.get().af_draw_plot_2d(self._wnd, X.arr, Y.arr, c_pointer(_cell)))
else:
- safe_call(backend.get().af_draw_plot_3d(self._wnd, X.arr, Y.arr, Z.arr, ct.pointer(_cell)))
+ safe_call(backend.get().af_draw_plot_3d(self._wnd, X.arr, Y.arr, Z.arr, c_pointer(_cell)))
else:
- safe_call(backend.get().af_draw_plot_nd(self._wnd, line.arr, ct.pointer(_cell)))
+ safe_call(backend.get().af_draw_plot_nd(self._wnd, line.arr, c_pointer(_cell)))
def plot2(self, line, title=None):
"""
@@ -277,7 +277,7 @@ class Window(object):
assert(line.numdims() == 2)
_cell = _Cell(self._r, self._c, title, self._cmap)
- safe_call(backend.get().af_draw_plot_nd(self._wnd, line.arr, ct.pointer(_cell)))
+ safe_call(backend.get().af_draw_plot_nd(self._wnd, line.arr, c_pointer(_cell)))
def plot3(self, X=None, Y=None, Z=None, line=None, title=None):
"""
@@ -295,7 +295,7 @@ class Window(object):
assert(line.numdims() == 3)
_cell = _Cell(self._r, self._c, title, self._cmap)
- safe_call(backend.get().af_draw_plot_nd(self._wnd, line.arr, ct.pointer(_cell)))
+ safe_call(backend.get().af_draw_plot_nd(self._wnd, line.arr, c_pointer(_cell)))
def vector_field(self, xpoints, xdirs, ypoints, ydirs, zpoints=None, zdirs=None,
points = None, dirs = None, title=None):
@@ -351,14 +351,14 @@ class Window(object):
safe_call(backend.get().af_draw_vector_field_2d(self._wnd,
xpoints.arr, ypoints.arr,
xdirs.arr, ydirs.arr,
- ct.pointer(_cell)))
+ c_pointer(_cell)))
else:
safe_call(backend.get().af_draw_vector_field_2d(self._wnd,
xpoints.arr, ypoints.arr, zpoints.arr,
xdirs.arr, ydirs.arr, zdirs.arr,
- ct.pointer(_cell)))
+ c_pointer(_cell)))
else:
- safe_call(backend.get().af_draw_plot_nd(self._wnd, points.arr, dirs.arr, ct.pointer(_cell)))
+ safe_call(backend.get().af_draw_plot_nd(self._wnd, points.arr, dirs.arr, c_pointer(_cell)))
def surface(self, x_vals, y_vals, z_vals, title=None):
"""
@@ -382,7 +382,7 @@ class Window(object):
_cell = _Cell(self._r, self._c, title, self._cmap)
safe_call(backend.get().af_draw_surface(self._wnd,
x_vals.arr, y_vals.arr, z_vals.arr,
- ct.pointer(_cell)))
+ c_pointer(_cell)))
def hist(self, X, min_val, max_val, title=None):
"""
@@ -405,8 +405,8 @@ class Window(object):
"""
_cell = _Cell(self._r, self._c, title, self._cmap)
safe_call(backend.get().af_draw_hist(self._wnd, X.arr,
- ct.c_double(max_val), ct.c_double(min_val),
- ct.pointer(_cell)))
+ c_double_t(max_val), c_double_t(min_val),
+ c_pointer(_cell)))
def grid(self, rows, cols):
"""
@@ -422,7 +422,7 @@ class Window(object):
Number of columns in the grid.
"""
- safe_call(backend.get().af_grid(self._wnd, ct.c_int(rows), ct.c_int(cols)))
+ safe_call(backend.get().af_grid(self._wnd, c_int_t(rows), c_int_t(cols)))
def show(self):
"""
@@ -436,8 +436,8 @@ class Window(object):
"""
Close the window.
"""
- tmp = ct.c_bool(True)
- safe_call(backend.get().af_is_window_closed(ct.pointer(tmp), self._wnd))
+ tmp = c_bool_t(True)
+ safe_call(backend.get().af_is_window_closed(c_pointer(tmp), self._wnd))
return tmp
def set_visibility(is_visible):
@@ -486,15 +486,15 @@ class Window(object):
_cell = _Cell(self._r, self._c, "", self._cmap)
if (zmin is None or zmax is None):
safe_call(backend.get().af_set_axes_limits_2d(self._wnd,
- ct.c_float(xmin), ct.c_float(xmax),
- ct.c_float(ymin), ct.c_float(ymax),
- exact, ct.pointer(_cell)))
+ c_float_t(xmin), c_float_t(xmax),
+ c_float_t(ymin), c_float_t(ymax),
+ exact, c_pointer(_cell)))
else:
safe_call(backend.get().af_set_axes_limits_2d(self._wnd,
- ct.c_float(xmin), ct.c_float(xmax),
- ct.c_float(ymin), ct.c_float(ymax),
- ct.c_float(zmin), ct.c_float(zmax),
- exact, ct.pointer(_cell)))
+ c_float_t(xmin), c_float_t(xmax),
+ c_float_t(ymin), c_float_t(ymax),
+ c_float_t(zmin), c_float_t(zmax),
+ exact, c_pointer(_cell)))
def __getitem__(self, keys):
"""
diff --git a/arrayfire/image.py b/arrayfire/image.py
index 7ddb6de..5fadd99 100644
--- a/arrayfire/image.py
+++ b/arrayfire/image.py
@@ -36,7 +36,7 @@ def gradient(image):
"""
dx = Array()
dy = Array()
- safe_call(backend.get().af_gradient(ct.pointer(dx.arr), ct.pointer(dy.arr), image.arr))
+ safe_call(backend.get().af_gradient(c_pointer(dx.arr), c_pointer(dy.arr), image.arr))
return dx, dy
def load_image(file_name, is_color=False):
@@ -59,8 +59,8 @@ def load_image(file_name, is_color=False):
"""
assert(os.path.isfile(file_name))
image = Array()
- safe_call(backend.get().af_load_image(ct.pointer(image.arr),
- ct.c_char_p(file_name.encode('ascii')), is_color))
+ safe_call(backend.get().af_load_image(c_pointer(image.arr),
+ c_char_ptr_t(file_name.encode('ascii')), is_color))
return image
def save_image(image, file_name):
@@ -76,7 +76,7 @@ def save_image(image, file_name):
- Full path of the file name on the disk.
"""
assert(isinstance(file_name, str))
- safe_call(backend.get().af_save_image(ct.c_char_p(file_name.encode('ascii')), image.arr))
+ safe_call(backend.get().af_save_image(c_char_ptr_t(file_name.encode('ascii')), image.arr))
return image
@@ -97,8 +97,8 @@ def load_image_native(file_name):
"""
assert(os.path.isfile(file_name))
image = Array()
- safe_call(backend.get().af_load_image_native(ct.pointer(image.arr),
- ct.c_char_p(file_name.encode('ascii'))))
+ safe_call(backend.get().af_load_image_native(c_pointer(image.arr),
+ c_char_ptr_t(file_name.encode('ascii'))))
return image
def save_image_native(image, file_name):
@@ -114,7 +114,7 @@ def save_image_native(image, file_name):
- Full path of the file name on the disk.
"""
assert(isinstance(file_name, str))
- safe_call(backend.get().af_save_image_native(ct.c_char_p(file_name.encode('ascii')), image.arr))
+ safe_call(backend.get().af_save_image_native(c_char_ptr_t(file_name.encode('ascii')), image.arr))
return image
def resize(image, scale=None, odim0=None, odim1=None, method=INTERP.NEAREST):
@@ -160,7 +160,7 @@ def resize(image, scale=None, odim0=None, odim1=None, method=INTERP.NEAREST):
odim1 = int(scale * idims[1])
output = Array()
- safe_call(backend.get().af_resize(ct.pointer(output.arr),
+ safe_call(backend.get().af_resize(c_pointer(output.arr),
image.arr, c_dim_t(odim0),
c_dim_t(odim1), method.value))
@@ -203,7 +203,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),
+ safe_call(backend.get().af_transform(c_pointer(output.arr),
image.arr, trans_mat.arr,
c_dim_t(odim0), c_dim_t(odim1),
method.value, is_inverse))
@@ -235,8 +235,8 @@ def rotate(image, theta, is_crop = True, method = INTERP.NEAREST):
- Output image after rotating.
"""
output = Array()
- safe_call(backend.get().af_rotate(ct.pointer(output.arr), image.arr,
- ct.c_float(theta), is_crop, method.value))
+ safe_call(backend.get().af_rotate(c_pointer(output.arr), image.arr,
+ c_float_t(theta), is_crop, method.value))
return output
def translate(image, trans0, trans1, odim0 = 0, odim1 = 0, method = INTERP.NEAREST):
@@ -276,7 +276,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),
+ safe_call(backend.get().af_translate(c_pointer(output.arr),
image.arr, trans0, trans1,
c_dim_t(odim0), c_dim_t(odim1), method.value))
return output
@@ -318,8 +318,8 @@ 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),
+ safe_call(backend.get().af_scale(c_pointer(output.arr),
+ image.arr, c_float_t(scale0), c_float_t(scale1),
c_dim_t(odim0), c_dim_t(odim1), method.value))
return output
@@ -363,8 +363,8 @@ 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),
+ safe_call(backend.get().af_skew(c_pointer(output.arr),
+ image.arr, c_float_t(skew0), c_float_t(skew1),
c_dim_t(odim0), c_dim_t(odim1),
method.value, is_inverse))
@@ -407,9 +407,9 @@ def histogram(image, nbins, min_val = None, max_val = None):
max_val = af_max(image)
output = Array()
- safe_call(backend.get().af_histogram(ct.pointer(output.arr),
- image.arr, ct.c_uint(nbins),
- ct.c_double(min_val), ct.c_double(max_val)))
+ safe_call(backend.get().af_histogram(c_pointer(output.arr),
+ image.arr, c_uint_t(nbins),
+ c_double_t(min_val), c_double_t(max_val)))
return output
def hist_equal(image, hist):
@@ -433,7 +433,7 @@ def hist_equal(image, hist):
"""
output = Array()
- safe_call(backend.get().af_hist_equal(ct.pointer(output.arr), image.arr, hist.arr))
+ safe_call(backend.get().af_hist_equal(c_pointer(output.arr), image.arr, hist.arr))
return output
def dilate(image, mask = None):
@@ -461,7 +461,7 @@ def dilate(image, mask = None):
mask = constant(1, 3, 3, dtype=Dtype.f32)
output = Array()
- safe_call(backend.get().af_dilate(ct.pointer(output.arr), image.arr, mask.arr))
+ safe_call(backend.get().af_dilate(c_pointer(output.arr), image.arr, mask.arr))
return output
@@ -490,7 +490,7 @@ def dilate3(volume, mask = None):
mask = constant(1, 3, 3, 3, dtype=Dtype.f32)
output = Array()
- safe_call(backend.get().af_dilate3(ct.pointer(output.arr), volume.arr, mask.arr))
+ safe_call(backend.get().af_dilate3(c_pointer(output.arr), volume.arr, mask.arr))
return output
@@ -519,7 +519,7 @@ def erode(image, mask = None):
mask = constant(1, 3, 3, dtype=Dtype.f32)
output = Array()
- safe_call(backend.get().af_erode(ct.pointer(output.arr), image.arr, mask.arr))
+ safe_call(backend.get().af_erode(c_pointer(output.arr), image.arr, mask.arr))
return output
@@ -549,7 +549,7 @@ def erode3(volume, mask = None):
mask = constant(1, 3, 3, 3, dtype=Dtype.f32)
output = Array()
- safe_call(backend.get().af_erode3(ct.pointer(output.arr), volume.arr, mask.arr))
+ safe_call(backend.get().af_erode3(c_pointer(output.arr), volume.arr, mask.arr))
return output
@@ -580,9 +580,9 @@ def bilateral(image, s_sigma, c_sigma, is_color = False):
"""
output = Array()
- safe_call(backend.get().af_bilateral(ct.pointer(output.arr),
- image.arr, ct.c_float(s_sigma),
- ct.c_float(c_sigma), is_color))
+ safe_call(backend.get().af_bilateral(c_pointer(output.arr),
+ image.arr, c_float_t(s_sigma),
+ c_float_t(c_sigma), is_color))
return output
def mean_shift(image, s_sigma, c_sigma, n_iter, is_color = False):
@@ -615,9 +615,9 @@ def mean_shift(image, s_sigma, c_sigma, n_iter, is_color = False):
"""
output = Array()
- safe_call(backend.get().af_mean_shift(ct.pointer(output.arr),
- image.arr, ct.c_float(s_sigma), ct.c_float(c_sigma),
- ct.c_uint(n_iter), is_color))
+ safe_call(backend.get().af_mean_shift(c_pointer(output.arr),
+ image.arr, c_float_t(s_sigma), c_float_t(c_sigma),
+ c_uint_t(n_iter), is_color))
return output
def minfilt(image, w_len = 3, w_wid = 3, edge_pad = PAD.ZERO):
@@ -647,7 +647,7 @@ 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),
+ safe_call(backend.get().af_minfilt(c_pointer(output.arr),
image.arr, c_dim_t(w_len),
c_dim_t(w_wid), edge_pad.value))
return output
@@ -679,7 +679,7 @@ 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),
+ safe_call(backend.get().af_maxfilt(c_pointer(output.arr),
image.arr, c_dim_t(w_len),
c_dim_t(w_wid), edge_pad.value))
return output
@@ -707,7 +707,7 @@ def regions(image, conn = CONNECTIVITY.FOUR, out_type = Dtype.f32):
"""
output = Array()
- safe_call(backend.get().af_regions(ct.pointer(output.arr), image.arr,
+ safe_call(backend.get().af_regions(c_pointer(output.arr), image.arr,
conn.value, out_type.value))
return output
@@ -734,8 +734,8 @@ def sobel_derivatives(image, w_len=3):
"""
dx = Array()
dy = Array()
- safe_call(backend.get().af_sobel_operator(ct.pointer(dx.arr), ct.pointer(dy.arr),
- image.arr, ct.c_uint(w_len)))
+ safe_call(backend.get().af_sobel_operator(c_pointer(dx.arr), c_pointer(dy.arr),
+ image.arr, c_uint_t(w_len)))
return dx,dy
def gaussian_kernel(rows, cols, sigma_r = None, sigma_c = None):
@@ -775,9 +775,9 @@ def gaussian_kernel(rows, cols, sigma_r = None, sigma_c = None):
if (sigma_c is None):
sigma_c = 0.25 * cols + 0.75
- safe_call(backend.get().af_gaussian_kernel(ct.pointer(out.arr),
- ct.c_int(rows), ct.c_int(cols),
- ct.c_double(sigma_r), ct.c_double(sigma_c)))
+ safe_call(backend.get().af_gaussian_kernel(c_pointer(out.arr),
+ c_int_t(rows), c_int_t(cols),
+ c_double_t(sigma_r), c_double_t(sigma_c)))
return out
def sobel_filter(image, w_len = 3, is_fast = False):
@@ -839,8 +839,8 @@ def rgb2gray(image, r_factor = 0.2126, g_factor = 0.7152, b_factor = 0.0722):
"""
output=Array()
- safe_call(backend.get().af_rgb2gray(ct.pointer(output.arr),
- image.arr, ct.c_float(r_factor), ct.c_float(g_factor), ct.c_float(b_factor)))
+ safe_call(backend.get().af_rgb2gray(c_pointer(output.arr),
+ image.arr, c_float_t(r_factor), c_float_t(g_factor), c_float_t(b_factor)))
return output
def gray2rgb(image, r_factor = 1.0, g_factor = 1.0, b_factor = 1.0):
@@ -871,8 +871,8 @@ def gray2rgb(image, r_factor = 1.0, g_factor = 1.0, b_factor = 1.0):
"""
output=Array()
- safe_call(backend.get().af_gray2rgb(ct.pointer(output.arr),
- image.arr, ct.c_float(r_factor), ct.c_float(g_factor), ct.c_float(b_factor)))
+ safe_call(backend.get().af_gray2rgb(c_pointer(output.arr),
+ image.arr, c_float_t(r_factor), c_float_t(g_factor), c_float_t(b_factor)))
return output
def hsv2rgb(image):
@@ -893,7 +893,7 @@ def hsv2rgb(image):
"""
output = Array()
- safe_call(backend.get().af_hsv2rgb(ct.pointer(output.arr), image.arr))
+ safe_call(backend.get().af_hsv2rgb(c_pointer(output.arr), image.arr))
return output
def rgb2hsv(image):
@@ -914,7 +914,7 @@ def rgb2hsv(image):
"""
output = Array()
- safe_call(backend.get().af_rgb2hsv(ct.pointer(output.arr), image.arr))
+ safe_call(backend.get().af_rgb2hsv(c_pointer(output.arr), image.arr))
return output
def color_space(image, to_type, from_type):
@@ -940,7 +940,7 @@ def color_space(image, to_type, from_type):
"""
output = Array()
- safe_call(backend.get().af_color_space(ct.pointer(output.arr), image.arr,
+ safe_call(backend.get().af_color_space(c_pointer(output.arr), image.arr,
to_type.value, from_type.value))
return output
@@ -1006,7 +1006,7 @@ 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,
+ safe_call(backend.get().af_unwrap(c_pointer(out.arr), image.arr,
c_dim_t(wx), c_dim_t(wy),
c_dim_t(sx), c_dim_t(sy),
c_dim_t(px), c_dim_t(py),
@@ -1088,7 +1088,7 @@ 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,
+ safe_call(backend.get().af_wrap(c_pointer(out.arr), a.arr,
c_dim_t(ox), c_dim_t(oy),
c_dim_t(wx), c_dim_t(wy),
c_dim_t(sx), c_dim_t(sy),
@@ -1112,7 +1112,7 @@ def sat(image):
"""
out = Array()
- safe_call(backend.get().af_sat(ct.pointer(out.arr), image.arr))
+ safe_call(backend.get().af_sat(c_pointer(out.arr), image.arr))
return out
def ycbcr2rgb(image, standard=YCC_STD.BT_601):
@@ -1138,7 +1138,7 @@ def ycbcr2rgb(image, standard=YCC_STD.BT_601):
"""
out = Array()
- safe_call(backend.get().af_ycbcr2rgb(ct.pointer(out.arr), image.arr, standard.value))
+ safe_call(backend.get().af_ycbcr2rgb(c_pointer(out.arr), image.arr, standard.value))
return out
def rgb2ycbcr(image, standard=YCC_STD.BT_601):
@@ -1164,7 +1164,7 @@ def rgb2ycbcr(image, standard=YCC_STD.BT_601):
"""
out = Array()
- safe_call(backend.get().af_rgb2ycbcr(ct.pointer(out.arr), image.arr, standard.value))
+ safe_call(backend.get().af_rgb2ycbcr(c_pointer(out.arr), image.arr, standard.value))
return out
def moments(image, moment = MOMENT.FIRST_ORDER):
@@ -1191,13 +1191,13 @@ def moments(image, moment = MOMENT.FIRST_ORDER):
- array containing requested moment(s) of each image
"""
output = Array()
- safe_call(backend.get().af_moments(ct.pointer(output.arr), image.arr, moment.value))
+ safe_call(backend.get().af_moments(c_pointer(output.arr), image.arr, moment.value))
return output
def is_image_io_available():
"""
Function to check if the arrayfire library was built with Image IO support.
"""
- res = ct.c_bool(False)
- safe_call(backend.get().af_is_image_io_available(ct.pointer(res)))
+ res = c_bool_t(False)
+ safe_call(backend.get().af_is_image_io_available(c_pointer(res)))
return res.value
diff --git a/arrayfire/index.py b/arrayfire/index.py
index a23e2e2..18c68dc 100644
--- a/arrayfire/index.py
+++ b/arrayfire/index.py
@@ -39,27 +39,27 @@ class Seq(ct.Structure):
S: slice or number.
"""
- _fields_ = [("begin", ct.c_double),
- ("end" , ct.c_double),
- ("step" , ct.c_double)]
+ _fields_ = [("begin", c_double_t),
+ ("end" , c_double_t),
+ ("step" , c_double_t)]
def __init__ (self, S):
- self.begin = ct.c_double( 0)
- self.end = ct.c_double(-1)
- self.step = ct.c_double( 1)
+ self.begin = c_double_t( 0)
+ self.end = c_double_t(-1)
+ self.step = c_double_t( 1)
if _is_number(S):
- self.begin = ct.c_double(S)
- self.end = ct.c_double(S)
+ self.begin = c_double_t(S)
+ self.end = c_double_t(S)
elif isinstance(S, slice):
if (S.step is not None):
- self.step = ct.c_double(S.step)
+ self.step = c_double_t(S.step)
if(S.step < 0):
self.begin, self.end = self.end, self.begin
if (S.start is not None):
- self.begin = ct.c_double(S.start)
+ self.begin = c_double_t(S.start)
if (S.stop is not None):
- self.end = ct.c_double(S.stop - math.copysign(1, self.step))
+ self.end = c_double_t(S.stop - math.copysign(1, self.step))
else:
raise IndexError("Invalid type while indexing arrayfire.array")
@@ -146,13 +146,13 @@ class ParallelRange(Seq):
return self.next()
class _uidx(ct.Union):
- _fields_ = [("arr", ct.c_void_p),
+ _fields_ = [("arr", c_void_ptr_t),
("seq", Seq)]
class Index(ct.Structure):
_fields_ = [("idx", _uidx),
- ("isSeq", ct.c_bool),
- ("isBatch", ct.c_bool)]
+ ("isSeq", c_bool_t),
+ ("isBatch", c_bool_t)]
"""
Container for the index class in arrayfire C library
@@ -194,12 +194,12 @@ class Index(ct.Structure):
if isinstance(idx, BaseArray):
- arr = ct.c_void_p(0)
+ arr = c_void_ptr_t(0)
if (idx.type() == Dtype.b8.value):
- safe_call(backend.get().af_where(ct.pointer(arr), idx.arr))
+ safe_call(backend.get().af_where(c_pointer(arr), idx.arr))
else:
- safe_call(backend.get().af_retain_array(ct.pointer(arr), idx.arr))
+ safe_call(backend.get().af_retain_array(c_pointer(arr), idx.arr))
self.idx.arr = arr
self.isSeq = False
@@ -214,7 +214,7 @@ class Index(ct.Structure):
# ctypes field variables are automatically
# converted to basic C types so we have to
# build the void_p from the value again.
- arr = ct.c_void_p(self.idx.arr)
+ arr = c_void_ptr_t(self.idx.arr)
backend.get().af_release_array(arr)
class _Index4(object):
@@ -227,7 +227,7 @@ class _Index4(object):
self.idxs = [idx0,idx1,idx2,idx3]
@property
def pointer(self):
- return ct.pointer(self.array)
+ return c_pointer(self.array)
def __getitem__(self, idx):
return self.array[idx]
diff --git a/arrayfire/interop.py b/arrayfire/interop.py
index 4de6d1e..e1a5d3b 100644
--- a/arrayfire/interop.py
+++ b/arrayfire/interop.py
@@ -53,7 +53,7 @@ try:
"""
in_shape = np_arr.shape
- in_ptr = np_arr.ctypes.data_as(ct.c_void_p)
+ in_ptr = np_arr.ctypes.data_as(c_void_ptr_t)
in_dtype = _nptype_to_aftype[np_arr.dtype.str[1:]]
if (np_arr.flags['F_CONTIGUOUS']):
diff --git a/arrayfire/lapack.py b/arrayfire/lapack.py
index ba2a521..05c1873 100644
--- a/arrayfire/lapack.py
+++ b/arrayfire/lapack.py
@@ -41,7 +41,7 @@ def lu(A):
L = Array()
U = Array()
P = Array()
- safe_call(backend.get().af_lu(ct.pointer(L.arr), ct.pointer(U.arr), ct.pointer(P.arr), A.arr))
+ safe_call(backend.get().af_lu(c_pointer(L.arr), c_pointer(U.arr), c_pointer(P.arr), A.arr))
return L,U,P
def lu_inplace(A, pivot="lapack"):
@@ -68,7 +68,7 @@ def lu_inplace(A, pivot="lapack"):
"""
P = Array()
is_pivot_lapack = False if (pivot == "full") else True
- safe_call(backend.get().af_lu_inplace(ct.pointer(P.arr), A.arr, is_pivot_lapack))
+ safe_call(backend.get().af_lu_inplace(c_pointer(P.arr), A.arr, is_pivot_lapack))
return P
def qr(A):
@@ -98,7 +98,7 @@ def qr(A):
Q = Array()
R = Array()
T = Array()
- safe_call(backend.get().af_qr(ct.pointer(Q.arr), ct.pointer(R.arr), ct.pointer(T.arr), A.arr))
+ safe_call(backend.get().af_qr(c_pointer(Q.arr), c_pointer(R.arr), c_pointer(T.arr), A.arr))
return Q,R,T
def qr_inplace(A):
@@ -122,7 +122,7 @@ def qr_inplace(A):
This function is used to save space only when `R` is required.
"""
T = Array()
- safe_call(backend.get().af_qr_inplace(ct.pointer(T.arr), A.arr))
+ safe_call(backend.get().af_qr_inplace(c_pointer(T.arr), A.arr))
return T
def cholesky(A, is_upper=True):
@@ -151,8 +151,8 @@ def cholesky(A, is_upper=True):
"""
R = Array()
- info = ct.c_int(0)
- safe_call(backend.get().af_cholesky(ct.pointer(R.arr), ct.pointer(info), A.arr, is_upper))
+ info = c_int_t(0)
+ safe_call(backend.get().af_cholesky(c_pointer(R.arr), c_pointer(info), A.arr, is_upper))
return R, info.value
def cholesky_inplace(A, is_upper=True):
@@ -174,8 +174,8 @@ def cholesky_inplace(A, is_upper=True):
0 if decomposition sucessful.
"""
- info = ct.c_int(0)
- safe_call(backend.get().af_cholesky_inplace(ct.pointer(info), A.arr, is_upper))
+ info = c_int_t(0)
+ safe_call(backend.get().af_cholesky_inplace(c_pointer(info), A.arr, is_upper))
return info.value
def solve(A, B, options=MATPROP.NONE):
@@ -202,7 +202,7 @@ def solve(A, B, options=MATPROP.NONE):
"""
X = Array()
- safe_call(backend.get().af_solve(ct.pointer(X.arr), A.arr, B.arr, options.value))
+ safe_call(backend.get().af_solve(c_pointer(X.arr), A.arr, B.arr, options.value))
return X
def solve_lu(A, P, B, options=MATPROP.NONE):
@@ -230,7 +230,7 @@ def solve_lu(A, P, B, options=MATPROP.NONE):
"""
X = Array()
- safe_call(backend.get().af_solve_lu(ct.pointer(X.arr), A.arr, P.arr, B.arr, options.value))
+ safe_call(backend.get().af_solve_lu(c_pointer(X.arr), A.arr, P.arr, B.arr, options.value))
return X
def inverse(A, options=MATPROP.NONE):
@@ -260,7 +260,7 @@ def inverse(A, options=MATPROP.NONE):
"""
AI = Array()
- safe_call(backend.get().af_inverse(ct.pointer(AI.arr), A.arr, options.value))
+ safe_call(backend.get().af_inverse(c_pointer(AI.arr), A.arr, options.value))
return AI
def rank(A, tol=1E-5):
@@ -282,8 +282,8 @@ def rank(A, tol=1E-5):
r: int
- Rank of `A` within the given tolerance
"""
- r = ct.c_uint(0)
- safe_call(backend.get().af_rank(ct.pointer(r), A.arr, ct.c_double(tol)))
+ r = c_uint_t(0)
+ safe_call(backend.get().af_rank(c_pointer(r), A.arr, c_double_t(tol)))
return r.value
def det(A):
@@ -302,9 +302,9 @@ def det(A):
res: scalar
- Determinant of the matrix.
"""
- re = ct.c_double(0)
- im = ct.c_double(0)
- safe_call(backend.get().af_det(ct.pointer(re), ct.pointer(im), A.arr))
+ re = c_double_t(0)
+ im = c_double_t(0)
+ safe_call(backend.get().af_det(c_pointer(re), c_pointer(im), A.arr))
re = re.value
im = im.value
return re if (im == 0) else re + im * 1j
@@ -335,9 +335,9 @@ def norm(A, norm_type=NORM.EUCLID, p=1.0, q=1.0):
- norm of the input
"""
- res = ct.c_double(0)
- safe_call(backend.get().af_norm(ct.pointer(res), A.arr, norm_type.value,
- ct.c_double(p), ct.c_double(q)))
+ res = c_double_t(0)
+ safe_call(backend.get().af_norm(c_pointer(res), A.arr, norm_type.value,
+ c_double_t(p), c_double_t(q)))
return res.value
def svd(A):
@@ -371,7 +371,7 @@ def svd(A):
U = Array()
S = Array()
Vt = Array()
- safe_call(backend.get().af_svd(ct.pointer(U.arr), ct.pointer(S.arr), ct.pointer(Vt.arr), A.arr))
+ safe_call(backend.get().af_svd(c_pointer(U.arr), c_pointer(S.arr), c_pointer(Vt.arr), A.arr))
return U, S, Vt
def svd_inplace(A):
@@ -405,7 +405,7 @@ def svd_inplace(A):
U = Array()
S = Array()
Vt = Array()
- safe_call(backend.get().af_svd_inplace(ct.pointer(U.arr), ct.pointer(S.arr), ct.pointer(Vt.arr),
+ safe_call(backend.get().af_svd_inplace(c_pointer(U.arr), c_pointer(S.arr), c_pointer(Vt.arr),
A.arr))
return U, S, Vt
@@ -413,6 +413,6 @@ def is_lapack_available():
"""
Function to check if the arrayfire library was built with lapack support.
"""
- res = ct.c_bool(False)
- safe_call(backend.get().af_is_lapack_available(ct.pointer(res)))
+ res = c_bool_t(False)
+ safe_call(backend.get().af_is_lapack_available(c_pointer(res)))
return res.value
diff --git a/arrayfire/library.py b/arrayfire/library.py
index c054162..edaa626 100644
--- a/arrayfire/library.py
+++ b/arrayfire/library.py
@@ -14,18 +14,34 @@ Module containing enums and other constants.
import platform
import ctypes as ct
+c_float_t = ct.c_float
+c_double_t = ct.c_double
+c_int_t = ct.c_int
+c_uint_t = ct.c_uint
+c_longlong_t = ct.c_longlong
+c_ulonglong_t = ct.c_ulonglong
+c_char_t = ct.c_char
+c_bool_t = ct.c_bool
+c_uchar_t = ct.c_ubyte
+c_short_t = ct.c_short
+c_ushort_t = ct.c_ushort
+c_pointer = ct.pointer
+c_void_ptr_t = ct.c_void_p
+c_char_ptr_t = ct.c_char_p
+c_size_t = ct.c_size_t
+
# 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
+ c_dim_t = c_longlong_t
# 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
+ c_dim_t = c_int_t
try:
from enum import Enum as _Enum
@@ -522,7 +538,7 @@ class _clibrary(object):
pass
c_dim4 = c_dim_t*4
- out = ct.c_void_p(0)
+ out = c_void_ptr_t(0)
dims = c_dim4(10, 10, 1, 1)
# Iterate in reverse order of preference
@@ -534,7 +550,7 @@ class _clibrary(object):
__name = 'unified' if name == '' else name
clib = ct.CDLL(libname)
self.__clibs[__name] = clib
- err = clib.af_randu(ct.pointer(out), 4, ct.pointer(dims), Dtype.f32.value)
+ err = clib.af_randu(c_pointer(out), 4, c_pointer(dims), Dtype.f32.value)
if (err == ERR.NONE.value):
self.__name = __name
clib.af_release_array(out)
@@ -610,8 +626,8 @@ def get_backend_id(A):
name : str.
Backend name
"""
- backend_id = ct.c_int(BACKEND.CPU.value)
- safe_call(backend.get().af_get_backend_id(ct.pointer(backend_id), A.arr))
+ backend_id = c_int_t(BACKEND.CPU.value)
+ safe_call(backend.get().af_get_backend_id(c_pointer(backend_id), A.arr))
return backend.get_name(backend_id.value)
def get_backend_count():
@@ -624,8 +640,8 @@ def get_backend_count():
count : int
Number of available backends
"""
- count = ct.c_int(0)
- safe_call(backend.get().af_get_backend_count(ct.pointer(count)))
+ count = c_int_t(0)
+ safe_call(backend.get().af_get_backend_count(c_pointer(count)))
return count.value
def get_available_backends():
@@ -638,8 +654,8 @@ def get_available_backends():
names : tuple of strings
Names of available backends
"""
- available = ct.c_int(0)
- safe_call(backend.get().af_get_available_backends(ct.pointer(available)))
+ available = c_int_t(0)
+ safe_call(backend.get().af_get_available_backends(c_pointer(available)))
return backend.parse(int(available.value))
def get_active_backend():
@@ -649,8 +665,8 @@ def get_active_backend():
name : str.
Backend name
"""
- backend_id = ct.c_int(BACKEND.CPU.value)
- safe_call(backend.get().af_get_active_backend(ct.pointer(backend_id)))
+ backend_id = c_int_t(BACKEND.CPU.value)
+ safe_call(backend.get().af_get_active_backend(c_pointer(backend_id)))
return backend.get_name(backend_id.value)
def get_device_id(A):
@@ -667,16 +683,16 @@ def get_device_id(A):
dev : Integer
id of the device array was created on
"""
- device_id = ct.c_int(0)
- safe_call(backend.get().af_get_device_id(ct.pointer(device_id), A.arr))
+ device_id = c_int_t(0)
+ safe_call(backend.get().af_get_device_id(c_pointer(device_id), A.arr))
return device_id
def get_size_of(dtype):
"""
Get the size of the type represented by arrayfire.Dtype
"""
- size = ct.c_size_t(0)
- safe_call(backend.get().af_get_size_of(ct.pointer(size), dtype.value))
+ size = c_size_t(0)
+ safe_call(backend.get().af_get_size_of(c_pointer(size), dtype.value))
return size.value
from .util import safe_call
diff --git a/arrayfire/opencl.py b/arrayfire/opencl.py
index d41be1d..a4a09c9 100644
--- a/arrayfire/opencl.py
+++ b/arrayfire/opencl.py
@@ -59,8 +59,8 @@ def get_context(retain=False):
if (backend.name() != "opencl"):
raise RuntimeError("Invalid backend loaded")
- context = ct.c_void_p(0)
- safe_call(backend.get().afcl_get_context(ct.pointer(context), retain))
+ context = c_void_ptr_t(0)
+ safe_call(backend.get().afcl_get_context(c_pointer(context), retain))
return context.value
def get_queue(retain):
@@ -85,8 +85,8 @@ def get_queue(retain):
if (backend.name() != "opencl"):
raise RuntimeError("Invalid backend loaded")
- queue = ct.c_int(0)
- safe_call(backend.get().afcl_get_queue(ct.pointer(queue), retain))
+ queue = c_int_t(0)
+ safe_call(backend.get().afcl_get_queue(c_pointer(queue), retain))
return queue.value
def get_device_id():
@@ -107,8 +107,8 @@ def get_device_id():
if (backend.name() != "opencl"):
raise RuntimeError("Invalid backend loaded")
- idx = ct.c_int(0)
- safe_call(backend.get().afcl_get_device_id(ct.pointer(idx)))
+ idx = c_int_t(0)
+ safe_call(backend.get().afcl_get_device_id(c_pointer(idx)))
return idx.value
def set_device_id(idx):
@@ -204,14 +204,14 @@ def get_device_type():
"""
Get opencl device type
"""
- res = ct.c_int(DEVICE_TYPE.UNKNOWN.value)
- safe_call(backend.get().afcl_get_device_type(ct.pointer(res)))
+ res = c_int_t(DEVICE_TYPE.UNKNOWN.value)
+ safe_call(backend.get().afcl_get_device_type(c_pointer(res)))
return _to_device_type[res.value]
def get_platform():
"""
Get opencl platform
"""
- res = ct.c_int(PLATFORM.UNKNOWN.value)
- safe_call(backend.get().afcl_get_platform(ct.pointer(res)))
+ res = c_int_t(PLATFORM.UNKNOWN.value)
+ safe_call(backend.get().afcl_get_platform(c_pointer(res)))
return _to_platform[res.value]
diff --git a/arrayfire/random.py b/arrayfire/random.py
index d95fa90..c535792 100644
--- a/arrayfire/random.py
+++ b/arrayfire/random.py
@@ -42,8 +42,8 @@ class Random_Engine(object):
def __init__(self, engine_type = RANDOM_ENGINE.PHILOX, seed = 0, engine = None):
if (engine is None):
- self.engine = ct.c_void_p(0)
- safe_call(backend.get().af_create_random_engine(ct.pointer(self.engine), engine_type.value, ct.c_longlong(seed)))
+ self.engine = c_void_ptr_t(0)
+ safe_call(backend.get().af_create_random_engine(c_pointer(self.engine), engine_type.value, c_longlong_t(seed)))
else:
self.engine = engine
@@ -54,7 +54,7 @@ class Random_Engine(object):
"""
Set the type of the random engine.
"""
- safe_call(backend.get().af_random_engine_set_type(ct.pointer(self.engine), engine_type.value))
+ safe_call(backend.get().af_random_engine_set_type(c_pointer(self.engine), engine_type.value))
def get_type(self):
"""
@@ -63,22 +63,22 @@ class Random_Engine(object):
__to_random_engine_type = [RANDOM_ENGINE.PHILOX_4X32_10,
RANDOM_ENGINE.THREEFRY_2X32_16,
RANDOM_ENGINE.MERSENNE_GP11213]
- rty = ct.c_int(RANDOM_ENGINE.PHILOX.value)
- safe_call(backend.get().af_random_engine_get_type(ct.pointer(rty), self.engine))
+ rty = c_int_t(RANDOM_ENGINE.PHILOX.value)
+ safe_call(backend.get().af_random_engine_get_type(c_pointer(rty), self.engine))
return __to_random_engine_type[rty]
def set_seed(self, seed):
"""
Set the seed for the random engine.
"""
- safe_call(backend.get().af_random_engine_set_seed(ct.pointer(self.engine), ct.c_longlong(seed)))
+ safe_call(backend.get().af_random_engine_set_seed(c_pointer(self.engine), c_longlong_t(seed)))
def get_seed(self):
"""
Get the seed for the random engine.
"""
- seed = ct.c_longlong(0)
- safe_call(backend.get().af_random_engine_get_seed(ct.pointer(seed), self.engine))
+ seed = c_longlong_t(0)
+ safe_call(backend.get().af_random_engine_get_seed(c_pointer(seed), self.engine))
return seed.value
def randu(d0, d1=None, d2=None, d3=None, dtype=Dtype.f32, engine=None):
@@ -119,9 +119,9 @@ def randu(d0, d1=None, d2=None, d3=None, dtype=Dtype.f32, engine=None):
dims = dim4(d0, d1, d2, d3)
if engine is None:
- safe_call(backend.get().af_randu(ct.pointer(out.arr), 4, ct.pointer(dims), dtype.value))
+ safe_call(backend.get().af_randu(c_pointer(out.arr), 4, c_pointer(dims), dtype.value))
else:
- safe_call(backend.get().af_random_uniform(ct.pointer(out.arr), 4, ct.pointer(dims), dtype.value, engine.engine))
+ safe_call(backend.get().af_random_uniform(c_pointer(out.arr), 4, c_pointer(dims), dtype.value, engine.engine))
return out
@@ -164,9 +164,9 @@ def randn(d0, d1=None, d2=None, d3=None, dtype=Dtype.f32, engine=None):
dims = dim4(d0, d1, d2, d3)
if engine is None:
- safe_call(backend.get().af_randn(ct.pointer(out.arr), 4, ct.pointer(dims), dtype.value))
+ safe_call(backend.get().af_randn(c_pointer(out.arr), 4, c_pointer(dims), dtype.value))
else:
- safe_call(backend.get().af_random_normal(ct.pointer(out.arr), 4, ct.pointer(dims), dtype.value, engine.engine))
+ safe_call(backend.get().af_random_normal(c_pointer(out.arr), 4, c_pointer(dims), dtype.value, engine.engine))
return out
@@ -179,7 +179,7 @@ def set_seed(seed=0):
seed: int.
Seed for the random number generator
"""
- safe_call(backend.get().af_set_seed(ct.c_ulonglong(seed)))
+ safe_call(backend.get().af_set_seed(c_ulonglong_t(seed)))
def get_seed():
"""
@@ -190,8 +190,8 @@ def get_seed():
seed: int.
Seed for the random number generator
"""
- seed = ct.c_ulonglong(0)
- safe_call(backend.get().af_get_seed(ct.pointer(seed)))
+ seed = c_ulonglong_t(0)
+ safe_call(backend.get().af_get_seed(c_pointer(seed)))
return seed.value
def set_default_random_engine_type(engine_type):
@@ -214,7 +214,7 @@ def set_default_random_engine_type(engine_type):
This only affects randu and randn when a random engine is not specified.
"""
- safe_call(backend.get().af_set_default_random_engine_type(ct.pointer(self.engine), engine_type.value))
+ safe_call(backend.get().af_set_default_random_engine_type(c_pointer(self.engine), engine_type.value))
def get_default_random_engine():
"""
@@ -225,8 +225,8 @@ def get_default_random_engine():
The default random engine used by randu and randn
"""
- engine = ct.c_void_p(0)
- default_engine = ct.c_void_p(0)
- safe_call(backend.get().af_get_default_random_engine(ct.pointer(default_engine)))
- safe_call(backend.get().af_retain_random_engine(ct.pointer(engine), default_engine))
+ engine = c_void_ptr_t(0)
+ default_engine = c_void_ptr_t(0)
+ safe_call(backend.get().af_get_default_random_engine(c_pointer(default_engine)))
+ safe_call(backend.get().af_retain_random_engine(c_pointer(engine), default_engine))
return Random_Engine(engine=engine)
diff --git a/arrayfire/signal.py b/arrayfire/signal.py
index 363ed24..4ddea26 100644
--- a/arrayfire/signal.py
+++ b/arrayfire/signal.py
@@ -48,8 +48,8 @@ def approx1(signal, pos0, method=INTERP.LINEAR, off_grid=0.0):
"""
output = Array()
- safe_call(backend.get().af_approx1(ct.pointer(output.arr), signal.arr, pos0.arr,
- method.value, ct.c_double(off_grid)))
+ safe_call(backend.get().af_approx1(c_pointer(output.arr), signal.arr, pos0.arr,
+ method.value, c_double_t(off_grid)))
return output
def approx2(signal, pos0, pos1, method=INTERP.LINEAR, off_grid=0.0):
@@ -90,8 +90,8 @@ def approx2(signal, pos0, pos1, method=INTERP.LINEAR, off_grid=0.0):
"""
output = Array()
- safe_call(backend.get().af_approx2(ct.pointer(output.arr), signal.arr,
- pos0.arr, pos1.arr, method.value, ct.c_double(off_grid)))
+ safe_call(backend.get().af_approx2(c_pointer(output.arr), signal.arr,
+ pos0.arr, pos1.arr, method.value, c_double_t(off_grid)))
return output
def fft(signal, dim0 = None , scale = None):
@@ -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), c_dim_t(dim0)))
+ safe_call(backend.get().af_fft(c_pointer(output.arr), signal.arr, c_double_t(scale), c_dim_t(dim0)))
return output
def fft2(signal, dim0 = None, dim1 = None , scale = None):
@@ -169,7 +169,7 @@ def fft2(signal, dim0 = None, dim1 = None , scale = None):
scale = 1.0
output = Array()
- safe_call(backend.get().af_fft2(ct.pointer(output.arr), signal.arr, ct.c_double(scale),
+ safe_call(backend.get().af_fft2(c_pointer(output.arr), signal.arr, c_double_t(scale),
c_dim_t(dim0), c_dim_t(dim1)))
return output
@@ -219,7 +219,7 @@ def fft3(signal, dim0 = None, dim1 = None , dim2 = None, scale = None):
scale = 1.0
output = Array()
- safe_call(backend.get().af_fft3(ct.pointer(output.arr), signal.arr, ct.c_double(scale),
+ safe_call(backend.get().af_fft3(c_pointer(output.arr), signal.arr, c_double_t(scale),
c_dim_t(dim0), c_dim_t(dim1), c_dim_t(dim2)))
return output
@@ -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), c_dim_t(dim0)))
+ safe_call(backend.get().af_ifft(c_pointer(output.arr), signal.arr, c_double_t(scale), c_dim_t(dim0)))
return output
def ifft2(signal, dim0 = None, dim1 = None , scale = None):
@@ -311,7 +311,7 @@ def ifft2(signal, dim0 = None, dim1 = None , scale = None):
scale = 1.0/float(dim0 * dim1)
output = Array()
- safe_call(backend.get().af_ifft2(ct.pointer(output.arr), signal.arr, ct.c_double(scale),
+ safe_call(backend.get().af_ifft2(c_pointer(output.arr), signal.arr, c_double_t(scale),
c_dim_t(dim0), c_dim_t(dim1)))
return output
@@ -369,7 +369,7 @@ def ifft3(signal, dim0 = None, dim1 = None , dim2 = None, scale = None):
scale = 1.0 / float(dim0 * dim1 * dim2)
output = Array()
- safe_call(backend.get().af_ifft3(ct.pointer(output.arr), signal.arr, ct.c_double(scale),
+ safe_call(backend.get().af_ifft3(c_pointer(output.arr), signal.arr, c_double_t(scale),
c_dim_t(dim0), c_dim_t(dim1), c_dim_t(dim2)))
return output
@@ -392,7 +392,7 @@ def fft_inplace(signal, scale = None):
if scale is None:
scale = 1.0
- safe_call(backend.get().af_fft_inplace(signal.arr, ct.c_double(scale)))
+ safe_call(backend.get().af_fft_inplace(signal.arr, c_double_t(scale)))
def fft2_inplace(signal, scale = None):
"""
@@ -413,7 +413,7 @@ def fft2_inplace(signal, scale = None):
if scale is None:
scale = 1.0
- safe_call(backend.get().af_fft2_inplace(signal.arr, ct.c_double(scale)))
+ safe_call(backend.get().af_fft2_inplace(signal.arr, c_double_t(scale)))
def fft3_inplace(signal, scale = None):
"""
@@ -434,7 +434,7 @@ def fft3_inplace(signal, scale = None):
scale = 1.0
output = Array()
- safe_call(backend.get().af_fft3_inplace(signal.arr, ct.c_double(scale)))
+ safe_call(backend.get().af_fft3_inplace(signal.arr, c_double_t(scale)))
def ifft_inplace(signal, scale = None):
"""
@@ -455,7 +455,7 @@ def ifft_inplace(signal, scale = None):
dim0 = signal.dims()[0]
scale = 1.0/float(dim0)
- safe_call(backend.get().af_ifft_inplace(signal.arr, ct.c_double(scale)))
+ safe_call(backend.get().af_ifft_inplace(signal.arr, c_double_t(scale)))
def ifft2_inplace(signal, scale = None):
"""
@@ -479,7 +479,7 @@ def ifft2_inplace(signal, scale = None):
dim1 = dims[1]
scale = 1.0/float(dim0 * dim1)
- safe_call(backend.get().af_ifft2_inplace(signal.arr, ct.c_double(scale)))
+ safe_call(backend.get().af_ifft2_inplace(signal.arr, c_double_t(scale)))
def ifft3_inplace(signal, scale = None):
"""
@@ -504,7 +504,7 @@ def ifft3_inplace(signal, scale = None):
dim2 = dims[2]
scale = 1.0 / float(dim0 * dim1 * dim2)
- safe_call(backend.get().af_ifft3_inplace(signal.arr, ct.c_double(scale)))
+ safe_call(backend.get().af_ifft3_inplace(signal.arr, c_double_t(scale)))
def fft_r2c(signal, dim0 = None , 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), c_dim_t(dim0)))
+ safe_call(backend.get().af_fft_r2c(c_pointer(output.arr), signal.arr, c_double_t(scale), c_dim_t(dim0)))
return output
def fft2_r2c(signal, dim0 = None, dim1 = None , scale = None):
@@ -581,7 +581,7 @@ def fft2_r2c(signal, dim0 = None, dim1 = None , scale = None):
scale = 1.0
output = Array()
- safe_call(backend.get().af_fft2_r2c(ct.pointer(output.arr), signal.arr, ct.c_double(scale),
+ safe_call(backend.get().af_fft2_r2c(c_pointer(output.arr), signal.arr, c_double_t(scale),
c_dim_t(dim0), c_dim_t(dim1)))
return output
@@ -631,7 +631,7 @@ def fft3_r2c(signal, dim0 = None, dim1 = None , dim2 = None, scale = None):
scale = 1.0
output = Array()
- safe_call(backend.get().af_fft3_r2c(ct.pointer(output.arr), signal.arr, ct.c_double(scale),
+ safe_call(backend.get().af_fft3_r2c(c_pointer(output.arr), signal.arr, c_double_t(scale),
c_dim_t(dim0), c_dim_t(dim1), c_dim_t(dim2)))
return output
@@ -669,7 +669,7 @@ def fft_c2r(signal, is_odd = False, scale = None):
scale = 1.0/float(dim0)
output = Array()
- safe_call(backend.get().af_fft_c2r(ct.pointer(output.arr), signal.arr, ct.c_double(scale), is_odd))
+ safe_call(backend.get().af_fft_c2r(c_pointer(output.arr), signal.arr, c_double_t(scale), is_odd))
return output
def fft2_c2r(signal, is_odd = False, scale = None):
@@ -704,7 +704,7 @@ def fft2_c2r(signal, is_odd = False, scale = None):
scale = 1.0/float(dim0 * dim1)
output = Array()
- safe_call(backend.get().af_fft2_c2r(ct.pointer(output.arr), signal.arr, ct.c_double(scale), is_odd))
+ safe_call(backend.get().af_fft2_c2r(c_pointer(output.arr), signal.arr, c_double_t(scale), is_odd))
return output
def fft3_c2r(signal, is_odd = False, scale = None):
@@ -740,7 +740,7 @@ def fft3_c2r(signal, is_odd = False, scale = None):
scale = 1.0/float(dim0 * dim1 * dim2)
output = Array()
- safe_call(backend.get().af_fft3_c2r(ct.pointer(output.arr), signal.arr, ct.c_double(scale), is_odd))
+ safe_call(backend.get().af_fft3_c2r(c_pointer(output.arr), signal.arr, c_double_t(scale), is_odd))
return output
@@ -871,7 +871,7 @@ def convolve1(signal, kernel, conv_mode = CONV_MODE.DEFAULT, conv_domain = CONV_
"""
output = Array()
- safe_call(backend.get().af_convolve1(ct.pointer(output.arr), signal.arr, kernel.arr,
+ safe_call(backend.get().af_convolve1(c_pointer(output.arr), signal.arr, kernel.arr,
conv_mode.value, conv_domain.value))
return output
@@ -919,7 +919,7 @@ def convolve2(signal, kernel, conv_mode = CONV_MODE.DEFAULT, conv_domain = CONV_
"""
output = Array()
- safe_call(backend.get().af_convolve2(ct.pointer(output.arr), signal.arr, kernel.arr,
+ safe_call(backend.get().af_convolve2(c_pointer(output.arr), signal.arr, kernel.arr,
conv_mode.value, conv_domain.value))
return output
@@ -949,7 +949,7 @@ def convolve2_separable(col_kernel, row_kernel, signal, conv_mode = CONV_MODE.DE
- Output of 2D sepearable convolution.
"""
output = Array()
- safe_call(backend.get().af_convolve2_sep(ct.pointer(output.arr),
+ safe_call(backend.get().af_convolve2_sep(c_pointer(output.arr),
col_kernel.arr, row_kernel.arr,signal.arr,
conv_mode.value))
return output
@@ -996,7 +996,7 @@ def convolve3(signal, kernel, conv_mode = CONV_MODE.DEFAULT, conv_domain = CONV_
"""
output = Array()
- safe_call(backend.get().af_convolve3(ct.pointer(output.arr), signal.arr, kernel.arr,
+ safe_call(backend.get().af_convolve3(c_pointer(output.arr), signal.arr, kernel.arr,
conv_mode.value, conv_domain.value))
return output
@@ -1083,7 +1083,7 @@ def fft_convolve1(signal, kernel, conv_mode = CONV_MODE.DEFAULT):
"""
output = Array()
- safe_call(backend.get().af_fft_convolve1(ct.pointer(output.arr), signal.arr, kernel.arr,
+ safe_call(backend.get().af_fft_convolve1(c_pointer(output.arr), signal.arr, kernel.arr,
conv_mode.value))
return output
@@ -1127,7 +1127,7 @@ def fft_convolve2(signal, kernel, conv_mode = CONV_MODE.DEFAULT):
"""
output = Array()
- safe_call(backend.get().af_fft_convolve2(ct.pointer(output.arr), signal.arr, kernel.arr,
+ safe_call(backend.get().af_fft_convolve2(c_pointer(output.arr), signal.arr, kernel.arr,
conv_mode.value))
return output
@@ -1169,7 +1169,7 @@ def fft_convolve3(signal, kernel, conv_mode = CONV_MODE.DEFAULT):
"""
output = Array()
- safe_call(backend.get().af_fft_convolve3(ct.pointer(output.arr), signal.arr, kernel.arr,
+ safe_call(backend.get().af_fft_convolve3(c_pointer(output.arr), signal.arr, kernel.arr,
conv_mode.value))
return output
@@ -1235,7 +1235,7 @@ def fir(B, X):
"""
Y = Array()
- safe_call(backend.get().af_fir(ct.pointer(Y.arr), B.arr, X.arr))
+ safe_call(backend.get().af_fir(c_pointer(Y.arr), B.arr, X.arr))
return Y
def iir(B, A, X):
@@ -1262,7 +1262,7 @@ def iir(B, A, X):
"""
Y = Array()
- safe_call(backend.get().af_iir(ct.pointer(Y.arr), B.arr, A.arr, X.arr))
+ safe_call(backend.get().af_iir(c_pointer(Y.arr), B.arr, A.arr, X.arr))
return Y
def medfilt(signal, w0 = 3, w1 = 3, edge_pad = PAD.ZERO):
@@ -1292,7 +1292,7 @@ def medfilt(signal, w0 = 3, w1 = 3, edge_pad = PAD.ZERO):
"""
output = Array()
- safe_call(backend.get().af_medfilt(ct.pointer(output.arr),
+ safe_call(backend.get().af_medfilt(c_pointer(output.arr),
signal.arr, c_dim_t(w0),
c_dim_t(w1), edge_pad.value))
return output
@@ -1321,7 +1321,7 @@ def medfilt1(signal, length = 3, edge_pad = PAD.ZERO):
"""
output = Array()
- safe_call(backend.get().af_medfilt1(ct.pointer(output.arr), signal.arr, c_dim_t(length), edge_pad.value))
+ safe_call(backend.get().af_medfilt1(c_pointer(output.arr), signal.arr, c_dim_t(length), edge_pad.value))
return output
def medfilt2(signal, w0 = 3, w1 = 3, edge_pad = PAD.ZERO):
@@ -1351,7 +1351,7 @@ def medfilt2(signal, w0 = 3, w1 = 3, edge_pad = PAD.ZERO):
"""
output = Array()
- safe_call(backend.get().af_medfilt2(ct.pointer(output.arr),
+ safe_call(backend.get().af_medfilt2(c_pointer(output.arr),
signal.arr, c_dim_t(w0),
c_dim_t(w1), edge_pad.value))
return output
@@ -1366,4 +1366,4 @@ def set_fft_plan_cache_size(cache_size):
cache_size : scalar
the number of plans that shall be cached
"""
- safe_call(backend.get().af_set_fft_plan_cache_size(ct.c_size_t(cache_size)))
+ safe_call(backend.get().af_set_fft_plan_cache_size(c_size_t(cache_size)))
diff --git a/arrayfire/sparse.py b/arrayfire/sparse.py
index 9a4c304..82eed17 100644
--- a/arrayfire/sparse.py
+++ b/arrayfire/sparse.py
@@ -56,7 +56,7 @@ def sparse(values, row_idx, col_idx, nrows, ncols, storage = STORAGE.CSR):
assert(isinstance(row_idx, Array))
assert(isinstance(col_idx, Array))
out = Array()
- safe_call(backend.get().af_create_sparse_array(ct.pointer(out.arr), c_dim_t(nrows), c_dim_t(ncols),
+ safe_call(backend.get().af_create_sparse_array(c_pointer(out.arr), c_dim_t(nrows), c_dim_t(ncols),
values.arr, row_idx.arr, col_idx.arr, storage.value))
return out
@@ -112,7 +112,7 @@ def sparse_from_dense(dense, storage = STORAGE.CSR):
"""
assert(isinstance(dense, Array))
out = Array()
- safe_call(backend.get().af_create_sparse_array_from_dense(ct.pointer(out.arr), dense.arr, storage.value))
+ safe_call(backend.get().af_create_sparse_array_from_dense(c_pointer(out.arr), dense.arr, storage.value))
return out
def sparse_to_dense(sparse):
@@ -131,7 +131,7 @@ def sparse_to_dense(sparse):
A dense matrix.
"""
out = Array()
- safe_call(backend.get().af_sparse_to_dense(ct.pointer(out.arr), sparse.arr))
+ safe_call(backend.get().af_sparse_to_dense(c_pointer(out.arr), sparse.arr))
return out
def sparse_get_info(sparse):
@@ -155,9 +155,9 @@ def sparse_get_info(sparse):
values = Array()
row_idx = Array()
col_idx = Array()
- stype = ct.c_int(0)
- safe_call(backend.get().af_sparse_get_info(ct.pointer(values.arr), ct.pointer(row_idx.arr),
- ct.pointer(col_idx.arr), ct.pointer(stype),
+ stype = c_int_t(0)
+ safe_call(backend.get().af_sparse_get_info(c_pointer(values.arr), c_pointer(row_idx.arr),
+ c_pointer(col_idx.arr), c_pointer(stype),
sparse.arr))
return (values, row_idx, col_idx, __to_sparse_enum[stype.value])
@@ -177,7 +177,7 @@ def sparse_get_values(sparse):
"""
values = Array()
- safe_call(backend.get().af_sparse_get_values(ct.pointer(values.arr), sparse.arr))
+ safe_call(backend.get().af_sparse_get_values(c_pointer(values.arr), sparse.arr))
return values
def sparse_get_row_idx(sparse):
@@ -196,7 +196,7 @@ def sparse_get_row_idx(sparse):
"""
row_idx = Array()
- safe_call(backend.get().af_sparse_get_row_idx(ct.pointer(row_idx.arr), sparse.arr))
+ safe_call(backend.get().af_sparse_get_row_idx(c_pointer(row_idx.arr), sparse.arr))
return row_idx
def sparse_get_col_idx(sparse):
@@ -215,7 +215,7 @@ def sparse_get_col_idx(sparse):
"""
col_idx = Array()
- safe_call(backend.get().af_sparse_get_col_idx(ct.pointer(col_idx.arr), sparse.arr))
+ safe_call(backend.get().af_sparse_get_col_idx(c_pointer(col_idx.arr), sparse.arr))
return col_idx
def sparse_get_nnz(sparse):
@@ -234,7 +234,7 @@ def sparse_get_nnz(sparse):
"""
nnz = c_dim_t(0)
- safe_call(backend.get().af_sparse_get_nnz(ct.pointer(nnz), sparse.arr))
+ safe_call(backend.get().af_sparse_get_nnz(c_pointer(nnz), sparse.arr))
return nnz.value
def sparse_get_storage(sparse):
@@ -252,8 +252,8 @@ def sparse_get_storage(sparse):
Number of non zero elements in the sparse matrix.
"""
- storage = ct.c_int(0)
- safe_call(backend.get().af_sparse_get_storage(ct.pointer(storage), sparse.arr))
+ storage = c_int_t(0)
+ safe_call(backend.get().af_sparse_get_storage(c_pointer(storage), sparse.arr))
return __to_sparse_enum[storage.value]
def sparse_convert_to(sparse, storage):
@@ -271,5 +271,5 @@ def sparse_convert_to(sparse, storage):
Sparse matrix converted to the appropriate type.
"""
out = Array()
- safe_call(backend.get().af_sparse_convert_to(ct.pointer(out.arr), sparse.arr, storage.value))
+ safe_call(backend.get().af_sparse_convert_to(c_pointer(out.arr), sparse.arr, storage.value))
return out
diff --git a/arrayfire/statistics.py b/arrayfire/statistics.py
index d953369..e8abaea 100644
--- a/arrayfire/statistics.py
+++ b/arrayfire/statistics.py
@@ -19,19 +19,19 @@ def mean(a, weights=None, dim=None):
out = Array()
if weights is None:
- safe_call(backend.get().af_mean(ct.pointer(out.arr), a.arr, ct.c_int(dim)))
+ safe_call(backend.get().af_mean(c_pointer(out.arr), a.arr, c_int_t(dim)))
else:
- safe_call(backend.get().af_mean_weighted(ct.pointer(out.arr), a.arr, weights.arr, ct.c_int(dim)))
+ safe_call(backend.get().af_mean_weighted(c_pointer(out.arr), a.arr, weights.arr, c_int_t(dim)))
return out
else:
- real = ct.c_double(0)
- imag = ct.c_double(0)
+ real = c_double_t(0)
+ imag = c_double_t(0)
if weights is None:
- safe_call(backend.get().af_mean_all(ct.pointer(real), ct.pointer(imag), a.arr))
+ safe_call(backend.get().af_mean_all(c_pointer(real), c_pointer(imag), a.arr))
else:
- safe_call(backend.get().af_mean_all_weighted(ct.pointer(real), ct.pointer(imag), a.arr, weights.arr))
+ safe_call(backend.get().af_mean_all_weighted(c_pointer(real), c_pointer(imag), a.arr, weights.arr))
real = real.value
imag = imag.value
@@ -43,19 +43,19 @@ def var(a, isbiased=False, weights=None, dim=None):
out = Array()
if weights is None:
- safe_call(backend.get().af_var(ct.pointer(out.arr), a.arr, isbiased, ct.c_int(dim)))
+ safe_call(backend.get().af_var(c_pointer(out.arr), a.arr, isbiased, c_int_t(dim)))
else:
- safe_call(backend.get().af_var_weighted(ct.pointer(out.arr), a.arr, weights.arr, ct.c_int(dim)))
+ safe_call(backend.get().af_var_weighted(c_pointer(out.arr), a.arr, weights.arr, c_int_t(dim)))
return out
else:
- real = ct.c_double(0)
- imag = ct.c_double(0)
+ real = c_double_t(0)
+ imag = c_double_t(0)
if weights is None:
- safe_call(backend.get().af_var_all(ct.pointer(real), ct.pointer(imag), a.arr, isbiased))
+ safe_call(backend.get().af_var_all(c_pointer(real), c_pointer(imag), a.arr, isbiased))
else:
- safe_call(backend.get().af_var_all_weighted(ct.pointer(real), ct.pointer(imag), a.arr, weights.arr))
+ safe_call(backend.get().af_var_all_weighted(c_pointer(real), c_pointer(imag), a.arr, weights.arr))
real = real.value
imag = imag.value
@@ -65,12 +65,12 @@ def var(a, isbiased=False, weights=None, dim=None):
def stdev(a, dim=None):
if dim is not None:
out = Array()
- safe_call(backend.get().af_stdev(ct.pointer(out.arr), a.arr, ct.c_int(dim)))
+ safe_call(backend.get().af_stdev(c_pointer(out.arr), a.arr, c_int_t(dim)))
return out
else:
- real = ct.c_double(0)
- imag = ct.c_double(0)
- safe_call(backend.get().af_stdev_all(ct.pointer(real), ct.pointer(imag), a.arr))
+ real = c_double_t(0)
+ imag = c_double_t(0)
+ safe_call(backend.get().af_stdev_all(c_pointer(real), c_pointer(imag), a.arr))
real = real.value
imag = imag.value
return real if imag == 0 else real + imag * 1j
@@ -78,12 +78,12 @@ def stdev(a, dim=None):
def cov(a, isbiased=False, dim=None):
if dim is not None:
out = Array()
- safe_call(backend.get().af_cov(ct.pointer(out.arr), a.arr, isbiased, ct.c_int(dim)))
+ safe_call(backend.get().af_cov(c_pointer(out.arr), a.arr, isbiased, c_int_t(dim)))
return out
else:
- real = ct.c_double(0)
- imag = ct.c_double(0)
- safe_call(backend.get().af_cov_all(ct.pointer(real), ct.pointer(imag), a.arr, isbiased))
+ real = c_double_t(0)
+ imag = c_double_t(0)
+ safe_call(backend.get().af_cov_all(c_pointer(real), c_pointer(imag), a.arr, isbiased))
real = real.value
imag = imag.value
return real if imag == 0 else real + imag * 1j
@@ -91,20 +91,20 @@ def cov(a, isbiased=False, dim=None):
def median(a, dim=None):
if dim is not None:
out = Array()
- safe_call(backend.get().af_median(ct.pointer(out.arr), a.arr, ct.c_int(dim)))
+ safe_call(backend.get().af_median(c_pointer(out.arr), a.arr, c_int_t(dim)))
return out
else:
- real = ct.c_double(0)
- imag = ct.c_double(0)
- safe_call(backend.get().af_median_all(ct.pointer(real), ct.pointer(imag), a.arr))
+ real = c_double_t(0)
+ imag = c_double_t(0)
+ safe_call(backend.get().af_median_all(c_pointer(real), c_pointer(imag), a.arr))
real = real.value
imag = imag.value
return real if imag == 0 else real + imag * 1j
def corrcoef(x, y):
- real = ct.c_double(0)
- imag = ct.c_double(0)
- safe_call(backend.get().af_corrcoef(ct.pointer(real), ct.pointer(imag), x.arr, y.arr))
+ real = c_double_t(0)
+ imag = c_double_t(0)
+ safe_call(backend.get().af_corrcoef(c_pointer(real), c_pointer(imag), x.arr, y.arr))
real = real.value
imag = imag.value
return real if imag == 0 else real + imag * 1j
diff --git a/arrayfire/util.py b/arrayfire/util.py
index 35cc5a8..709bd78 100644
--- a/arrayfire/util.py
+++ b/arrayfire/util.py
@@ -73,19 +73,19 @@ def to_str(c_str):
def safe_call(af_error):
if (af_error != ERR.NONE.value):
- err_str = ct.c_char_p(0)
+ err_str = c_char_ptr_t(0)
err_len = c_dim_t(0)
- backend.get().af_get_last_error(ct.pointer(err_str), ct.pointer(err_len))
+ backend.get().af_get_last_error(c_pointer(err_str), c_pointer(err_len))
raise RuntimeError(to_str(err_str))
def get_version():
"""
Function to get the version of arrayfire.
"""
- major=ct.c_int(0)
- minor=ct.c_int(0)
- patch=ct.c_int(0)
- safe_call(backend.get().af_get_version(ct.pointer(major), ct.pointer(minor), ct.pointer(patch)))
+ major=c_int_t(0)
+ minor=c_int_t(0)
+ patch=c_int_t(0)
+ safe_call(backend.get().af_get_version(c_pointer(major), c_pointer(minor), c_pointer(patch)))
return major.value,minor.value,patch.value
def get_reversion():
@@ -120,18 +120,18 @@ to_typecode = {Dtype.f32.value : 'f',
Dtype.c32.value : 'F',
Dtype.c64.value : 'D'}
-to_c_type = {Dtype.f32.value : ct.c_float,
- Dtype.f64.value : ct.c_double,
- Dtype.b8.value : ct.c_char,
- Dtype.u8.value : ct.c_ubyte,
- Dtype.s16.value : ct.c_short,
- Dtype.u16.value : ct.c_ushort,
- Dtype.s32.value : ct.c_int,
- Dtype.u32.value : ct.c_uint,
- Dtype.s64.value : ct.c_longlong,
- Dtype.u64.value : ct.c_ulonglong,
- Dtype.c32.value : ct.c_float * 2,
- Dtype.c64.value : ct.c_double * 2}
+to_c_type = {Dtype.f32.value : c_float_t,
+ Dtype.f64.value : c_double_t,
+ Dtype.b8.value : c_char_t,
+ Dtype.u8.value : c_uchar_t,
+ Dtype.s16.value : c_short_t,
+ Dtype.u16.value : c_ushort_t,
+ Dtype.s32.value : c_int_t,
+ Dtype.u32.value : c_uint_t,
+ Dtype.s64.value : c_longlong_t,
+ Dtype.u64.value : c_ulonglong_t,
+ Dtype.c32.value : c_float_t * 2,
+ Dtype.c64.value : c_double_t * 2}
to_typename = {Dtype.f32.value : 'float',
Dtype.f64.value : 'double',
diff --git a/arrayfire/vision.py b/arrayfire/vision.py
index 9598a6b..2e5edac 100644
--- a/arrayfire/vision.py
+++ b/arrayfire/vision.py
@@ -47,9 +47,9 @@ def fast(image, threshold=20.0, arc_length=9, non_max=True, feature_ratio=0.05,
"""
out = Features()
- safe_call(backend.get().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)))
+ safe_call(backend.get().af_fast(c_pointer(out.feat),
+ image.arr, c_float_t(threshold), c_uint_t(arc_length), non_max,
+ c_float_t(feature_ratio), c_uint_t(edge)))
return out
def harris(image, max_corners=500, min_response=1E5, sigma=1.0, block_size=0, k_thr=0.04):
@@ -91,9 +91,9 @@ def harris(image, max_corners=500, min_response=1E5, sigma=1.0, block_size=0, k_
"""
out = Features()
- safe_call(backend.get().af_harris(ct.pointer(out.feat),
- image.arr, ct.c_uint(max_corners), ct.c_float(min_response),
- ct.c_float(sigma), ct.c_uint(block_size), ct.c_float(k_thr)))
+ safe_call(backend.get().af_harris(c_pointer(out.feat),
+ image.arr, c_uint_t(max_corners), c_float_t(min_response),
+ c_float_t(sigma), c_uint_t(block_size), c_float_t(k_thr)))
return out
def orb(image, threshold=20.0, max_features=400, scale = 1.5, num_levels = 4, blur_image = False):
@@ -131,9 +131,9 @@ def orb(image, threshold=20.0, max_features=400, scale = 1.5, num_levels = 4, bl
"""
feat = Features()
desc = Array()
- safe_call(backend.get().af_orb(ct.pointer(feat.feat), ct.pointer(desc.arr),
- ct.c_float(threshold), ct.c_uint(max_features),
- ct.c_float(scale), ct.c_uint(num_levels), blur_image))
+ safe_call(backend.get().af_orb(c_pointer(feat.feat), c_pointer(desc.arr),
+ c_float_t(threshold), c_uint_t(max_features),
+ c_float_t(scale), c_uint_t(num_levels), blur_image))
return feat, desc
def hamming_matcher(query, database, dim = 0, num_nearest = 1):
@@ -164,7 +164,7 @@ def hamming_matcher(query, database, dim = 0, num_nearest = 1):
"""
index = Array()
dist = Array()
- safe_call(backend.get().af_hamming_matcher(ct.pointer(idx.arr), ct.pointer(dist.arr),
+ safe_call(backend.get().af_hamming_matcher(c_pointer(idx.arr), c_pointer(dist.arr),
query.arr, database.arr,
c_dim_t(dim), c_dim_t(num_nearest)))
return index, dist
@@ -200,7 +200,7 @@ def nearest_neighbour(query, database, dim = 0, num_nearest = 1, match_type=MATC
"""
index = Array()
dist = Array()
- safe_call(backend.get().af_nearest_neighbour(ct.pointer(idx.arr), ct.pointer(dist.arr),
+ safe_call(backend.get().af_nearest_neighbour(c_pointer(idx.arr), c_pointer(dist.arr),
query.arr, database.arr,
c_dim_t(dim), c_dim_t(num_nearest),
match_type.value))
@@ -229,7 +229,7 @@ def match_template(image, template, match_type = MATCH.SAD):
"""
out = Array()
- safe_call(backend.get().af_match_template(ct.pointer(out.arr),
+ safe_call(backend.get().af_match_template(c_pointer(out.arr),
image.arr, template.arr,
match_type.value))
return out
@@ -266,10 +266,10 @@ def susan(image, radius=3, diff_thr=32, geom_thr=10, feature_ratio=0.05, edge=3)
"""
out = Features()
- safe_call(backend.get().af_susan(ct.pointer(out.feat),
- image.arr, ct.c_uint(radius), ct.c_float(diff_thr),
- ct.c_float(geom_thr), ct.c_float(feature_ratio),
- ct.c_uint(edge)))
+ safe_call(backend.get().af_susan(c_pointer(out.feat),
+ image.arr, c_uint_t(radius), c_float_t(diff_thr),
+ c_float_t(geom_thr), c_float_t(feature_ratio),
+ c_uint_t(edge)))
return out
def dog(image, radius1, radius2):
@@ -301,7 +301,7 @@ def dog(image, radius1, radius2):
"""
out = Array()
- safe_call(backend.get().af_dog(ct.pointer(out.arr),
+ safe_call(backend.get().af_dog(c_pointer(out.arr),
image.arr, radius1, radius2))
return out
@@ -345,7 +345,7 @@ def sift(image, num_layers=3, contrast_threshold=0.04, edge_threshold=10.0, init
feat = Features()
desc = Array()
- safe_call(af_sift(ct.pointer(feat), ct.pointer(desc),
+ safe_call(af_sift(c_pointer(feat), c_pointer(desc),
image.arr, num_layers, contrast_threshold, edge_threshold,
initial_sigma, double_input, intensity_scale, feature_ratio))
@@ -391,7 +391,7 @@ def gloh(image, num_layers=3, contrast_threshold=0.04, edge_threshold=10.0, init
feat = Features()
desc = Array()
- safe_call(af_gloh(ct.pointer(feat), ct.pointer(desc),
+ safe_call(af_gloh(c_pointer(feat), c_pointer(desc),
image.arr, num_layers, contrast_threshold, edge_threshold,
initial_sigma, double_input, intensity_scale, feature_ratio))
@@ -433,8 +433,8 @@ def homography(x_src, y_src, x_dst, y_dst, htype = HOMOGRAPHY.RANSAC,
"""
H = Array()
- inliers = ct.c_int(0)
- safe_call(backend.get().af_homography(ct.pointer(H), ct.pointer(inliers),
+ inliers = c_int_t(0)
+ safe_call(backend.get().af_homography(c_pointer(H), c_pointer(inliers),
x_src.arr, y_src.arr, x_dst.arr, y_dst.arr,
htype.value, ransac_threshold, iters, out_type.value))
return (H, inliers)
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/debian-science/packages/python-arrayfire.git
More information about the debian-science-commits
mailing list