[python-arrayfire] 35/250: BUGFIX: Fixing import mess in arrayfire
Ghislain Vaillant
ghisvail-guest at moszumanska.debian.org
Mon Mar 28 22:59:28 UTC 2016
This is an automated email from the git hooks/post-receive script.
ghisvail-guest pushed a commit to branch debian/master
in repository python-arrayfire.
commit 1f75d5f08ea1978cfe67496a53c8e72ff56eadbb
Author: Pavan Yalamanchili <pavan at arrayfire.com>
Date: Thu Jul 16 11:17:51 2015 -0400
BUGFIX: Fixing import mess in arrayfire
- Also deleting modules imported for helping out arrayfire
---
arrayfire/__init__.py | 7 ++
arrayfire/algorithm.py | 46 ++++++------
arrayfire/arith.py | 10 +--
arrayfire/array.py | 116 +++++++++++++++---------------
arrayfire/blas.py | 12 ++--
arrayfire/data.py | 66 ++++++++---------
arrayfire/device.py | 43 ++++++-----
arrayfire/features.py | 18 ++---
arrayfire/image.py | 88 +++++++++++------------
arrayfire/lapack.py | 36 +++++-----
arrayfire/library.py | 186 ++++++++++++++++++++++++------------------------
arrayfire/signal.py | 42 +++++------
arrayfire/statistics.py | 54 +++++++-------
arrayfire/util.py | 20 +++---
arrayfire/vision.py | 18 ++---
15 files changed, 385 insertions(+), 377 deletions(-)
diff --git a/arrayfire/__init__.py b/arrayfire/__init__.py
index 39d38ec..14376d3 100644
--- a/arrayfire/__init__.py
+++ b/arrayfire/__init__.py
@@ -8,6 +8,7 @@
########################################################
from .library import *
+from .array import *
from .data import *
from .util import *
from .algorithm import *
@@ -20,3 +21,9 @@ from .signal import *
from .image import *
from .features import *
from .vision import *
+
+# do not export default modules as part of arrayfire
+del ct
+del inspect
+del numbers
+del os
diff --git a/arrayfire/algorithm.py b/arrayfire/algorithm.py
index d9d538d..7607dd8 100644
--- a/arrayfire/algorithm.py
+++ b/arrayfire/algorithm.py
@@ -12,13 +12,13 @@ from .array import *
def parallel_dim(a, dim, c_func):
out = array()
- safe_call(c_func(pointer(out.arr), a.arr, c_int(dim)))
+ safe_call(c_func(ct.pointer(out.arr), a.arr, ct.c_int(dim)))
return out
def reduce_all(a, c_func):
- real = c_double(0)
- imag = c_double(0)
- safe_call(c_func(pointer(real), pointer(imag), a.arr))
+ real = ct.c_double(0)
+ imag = ct.c_double(0)
+ safe_call(c_func(ct.pointer(real), ct.pointer(imag), a.arr))
real = real.value
imag = imag.value
return real if imag == 0 else real + imag * 1j
@@ -69,13 +69,13 @@ def imin(a, dim=None):
if dim is not None:
out = array()
idx = array()
- safe_call(clib.af_imin(pointer(out.arr), pointer(idx.arr), a.arr, c_int(dim)))
+ safe_call(clib.af_imin(ct.pointer(out.arr), ct.pointer(idx.arr), a.arr, ct.c_int(dim)))
return out,idx
else:
- real = c_double(0)
- imag = c_double(0)
- idx = c_uint(0)
- safe_call(clib.af_imin_all(pointer(real), pointer(imag), pointer(idx), a.arr))
+ real = ct.c_double(0)
+ imag = ct.c_double(0)
+ idx = ct.c_uint(0)
+ safe_call(clib.af_imin_all(ct.pointer(real), ct.pointer(imag), ct.pointer(idx), a.arr))
real = real.value
imag = imag.value
val = real if imag == 0 else real + imag * 1j
@@ -85,13 +85,13 @@ def imax(a, dim=None):
if dim is not None:
out = array()
idx = array()
- safe_call(clib.af_imax(pointer(out.arr), pointer(idx.arr), a.arr, c_int(dim)))
+ safe_call(clib.af_imax(ct.pointer(out.arr), ct.pointer(idx.arr), a.arr, ct.c_int(dim)))
return out,idx
else:
- real = c_double(0)
- imag = c_double(0)
- idx = c_uint(0)
- safe_call(clib.af_imax_all(pointer(real), pointer(imag), pointer(idx), a.arr))
+ real = ct.c_double(0)
+ imag = ct.c_double(0)
+ idx = ct.c_uint(0)
+ safe_call(clib.af_imax_all(ct.pointer(real), ct.pointer(imag), ct.pointer(idx), a.arr))
real = real.value
imag = imag.value
val = real if imag == 0 else real + imag * 1j
@@ -103,7 +103,7 @@ def accum(a, dim=0):
def where(a):
out = array()
- safe_call(clib.af_where(pointer(out.arr), a.arr))
+ safe_call(clib.af_where(ct.pointer(out.arr), a.arr))
return out
def diff1(a, dim=0):
@@ -114,34 +114,34 @@ def diff2(a, dim=0):
def sort(a, dim=0, is_ascending=True):
out = array()
- safe_call(clib.af_sort(pointer(out.arr), a.arr, c_uint(dim), c_bool(is_ascending)))
+ safe_call(clib.af_sort(ct.pointer(out.arr), a.arr, ct.c_uint(dim), ct.c_bool(is_ascending)))
return out
def sort_index(a, dim=0, is_ascending=True):
out = array()
idx = array()
- safe_call(clib.af_sort_index(pointer(out.arr), pointer(idx.arr), a.arr, \
- c_uint(dim), c_bool(is_ascending)))
+ safe_call(clib.af_sort_index(ct.pointer(out.arr), ct.pointer(idx.arr), a.arr, \
+ ct.c_uint(dim), ct.c_bool(is_ascending)))
return out,idx
def sort_by_key(iv, ik, dim=0, is_ascending=True):
ov = array()
ok = array()
- safe_call(clib.af_sort_by_key(pointer(ov.arr), pointer(ok.arr), \
- iv.arr, ik.arr, c_uint(dim), c_bool(is_ascending)))
+ safe_call(clib.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)))
return ov,ok
def set_unique(a, is_sorted=False):
out = array()
- safe_call(clib.af_set_unique(pointer(out.arr), a.arr, c_bool(is_sorted)))
+ safe_call(clib.af_set_unique(ct.pointer(out.arr), a.arr, ct.c_bool(is_sorted)))
return out
def set_union(a, b, is_unique=False):
out = array()
- safe_call(clib.af_set_union(pointer(out.arr), a.arr, b.arr, c_bool(is_unique)))
+ safe_call(clib.af_set_union(ct.pointer(out.arr), a.arr, b.arr, ct.c_bool(is_unique)))
return out
def set_intersect(a, b, is_unique=False):
out = array()
- safe_call(clib.af_set_intersect(pointer(out.arr), a.arr, b.arr, c_bool(is_unique)))
+ safe_call(clib.af_set_intersect(ct.pointer(out.arr), a.arr, b.arr, ct.c_bool(is_unique)))
return out
diff --git a/arrayfire/arith.py b/arrayfire/arith.py
index 1688bcd..a57234f 100644
--- a/arrayfire/arith.py
+++ b/arrayfire/arith.py
@@ -20,32 +20,32 @@ def arith_binary_func(lhs, rhs, c_func):
TypeError("Atleast one input needs to be of type arrayfire.array")
elif (is_left_array and is_right_array):
- safe_call(c_func(pointer(out.arr), lhs.arr, rhs.arr, False))
+ safe_call(c_func(ct.pointer(out.arr), lhs.arr, rhs.arr, False))
elif (is_valid_scalar(rhs)):
ldims = dim4_tuple(lhs.dims())
lty = lhs.type()
other = array()
other.arr = constant_array(rhs, ldims[0], ldims[1], ldims[2], ldims[3], lty)
- safe_call(c_func(pointer(out.arr), lhs.arr, other.arr, False))
+ safe_call(c_func(ct.pointer(out.arr), lhs.arr, other.arr, False))
else:
rdims = dim4_tuple(rhs.dims())
rty = rhs.type()
other = array()
other.arr = constant_array(lhs, rdims[0], rdims[1], rdims[2], rdims[3], rty)
- safe_call(c_func(pointer(out.arr), lhs.arr, other.arr, False))
+ safe_call(c_func(ct.pointer(out.arr), lhs.arr, other.arr, False))
return out
def arith_unary_func(a, c_func):
out = array()
- safe_call(c_func(pointer(out.arr), a.arr))
+ safe_call(c_func(ct.pointer(out.arr), a.arr))
return out
def cast(a, dtype=f32):
out=array()
- safe_call(clib.af_cast(pointer(out.arr), a.arr, dtype))
+ safe_call(clib.af_cast(ct.pointer(out.arr), a.arr, dtype))
return out
def minof(lhs, rhs):
diff --git a/arrayfire/array.py b/arrayfire/array.py
index e4fa163..4dfce65 100644
--- a/arrayfire/array.py
+++ b/arrayfire/array.py
@@ -7,46 +7,46 @@
# http://arrayfire.com/licenses/BSD-3-Clause
########################################################
-import array as host
import inspect
from .library import *
from .util import *
-from .data import *
def create_array(buf, numdims, idims, dtype):
- out_arr = c_longlong(0)
- c_dims = dim4(idims[0], idims[1], idims[2], idims[3])
- safe_call(clib.af_create_array(pointer(out_arr), c_longlong(buf), numdims, pointer(c_dims), dtype))
+ out_arr = ct.c_longlong(0)
+ ct.c_dims = dim4(idims[0], idims[1], idims[2], idims[3])
+ safe_call(clib.af_create_array(ct.pointer(out_arr), ct.c_longlong(buf),\
+ numdims, ct.pointer(ct.c_dims), dtype))
return out_arr
def constant_array(val, d0, d1=None, d2=None, d3=None, dtype=f32):
- if not isinstance(dtype, c_int):
+ if not isinstance(dtype, ct.c_int):
if isinstance(dtype, int):
- dtype = c_int(dtype)
+ dtype = ct.c_int(dtype)
else:
raise TypeError("Invalid dtype")
- out = c_longlong(0)
+ out = ct.c_longlong(0)
dims = dim4(d0, d1, d2, d3)
if isinstance(val, complex):
- c_real = c_double(val.real)
- c_imag = c_double(val.imag)
+ c_real = ct.c_double(val.real)
+ c_imag = ct.c_double(val.imag)
if (dtype != c32 and dtype != c64):
dtype = c32
- safe_call(clib.af_constant_complex(pointer(out), c_real, c_imag, 4, pointer(dims), dtype))
+ safe_call(clib.af_constant_complex(ct.pointer(out), c_real, c_imag,\
+ 4, ct.pointer(dims), dtype))
elif dtype == s64:
- c_val = c_longlong(val.real)
- safe_call(clib.af_constant_long(pointer(out), c_val, 4, pointer(dims)))
+ c_val = ct.c_longlong(val.real)
+ safe_call(clib.af_constant_long(ct.pointer(out), c_val, 4, ct.pointer(dims)))
elif dtype == u64:
- c_val = c_ulonglong(val.real)
- safe_call(clib.af_constant_ulong(pointer(out), c_val, 4, pointer(dims)))
+ c_val = ct.c_ulonglong(val.real)
+ safe_call(clib.af_constant_ulong(ct.pointer(out), c_val, 4, ct.pointer(dims)))
else:
- c_val = c_double(val)
- safe_call(clib.af_constant(pointer(out), c_val, 4, pointer(dims), dtype))
+ c_val = ct.c_double(val)
+ safe_call(clib.af_constant(ct.pointer(out), c_val, 4, ct.pointer(dims), dtype))
return out
@@ -63,7 +63,7 @@ def binary_func(lhs, rhs, c_func):
elif not isinstance(rhs, array):
TypeError("Invalid parameter to binary function")
- safe_call(c_func(pointer(out.arr), lhs.arr, other.arr, False))
+ safe_call(c_func(ct.pointer(out.arr), lhs.arr, other.arr, False))
return out
@@ -79,7 +79,7 @@ def binary_funcr(lhs, rhs, c_func):
elif not isinstance(lhs, array):
TypeError("Invalid parameter to binary function")
- c_func(pointer(out.arr), other.arr, rhs.arr, False)
+ c_func(ct.pointer(out.arr), other.arr, rhs.arr, False)
return out
@@ -87,7 +87,7 @@ class array(object):
def __init__(self, src=None, dims=(0,)):
- self.arr = c_longlong(0)
+ self.arr = ct.c_longlong(0)
buf=None
buf_len=0
@@ -96,6 +96,8 @@ class array(object):
if src is not None:
+ host = __import__("array")
+
if isinstance(src, host.array):
buf,buf_len = src.buffer_info()
type_char = src.typecode
@@ -127,92 +129,92 @@ class array(object):
clib.af_release_array(self.arr)
def elements(self):
- num = c_ulonglong(0)
- safe_call(clib.af_get_elements(pointer(num), self.arr))
+ num = ct.c_ulonglong(0)
+ safe_call(clib.af_get_elements(ct.pointer(num), self.arr))
return num.value
def type(self):
- dty = c_int(f32.value)
- safe_call(clib.af_get_type(pointer(dty), self.arr))
+ dty = ct.c_int(f32.value)
+ safe_call(clib.af_get_type(ct.pointer(dty), self.arr))
return dty.value
def dims(self):
- d0 = c_longlong(0)
- d1 = c_longlong(0)
- d2 = c_longlong(0)
- d3 = c_longlong(0)
- safe_call(clib.af_get_dims(pointer(d0), pointer(d1), pointer(d2), pointer(d3), self.arr))
+ d0 = ct.c_longlong(0)
+ d1 = ct.c_longlong(0)
+ d2 = ct.c_longlong(0)
+ d3 = ct.c_longlong(0)
+ safe_call(clib.af_get_dims(ct.pointer(d0), ct.pointer(d1), ct.pointer(d2), ct.pointer(d3), self.arr))
dims = (d0.value,d1.value,d2.value,d3.value)
return dims[:self.numdims()]
def numdims(self):
- nd = c_uint(0)
- safe_call(clib.af_get_numdims(pointer(nd), self.arr))
+ nd = ct.c_uint(0)
+ safe_call(clib.af_get_numdims(ct.pointer(nd), self.arr))
return nd.value
def is_empty(self):
- res = c_bool(False)
- safe_call(clib.af_is_empty(pointer(res), self.arr))
+ res = ct.c_bool(False)
+ safe_call(clib.af_is_empty(ct.pointer(res), self.arr))
return res.value
def is_scalar(self):
- res = c_bool(False)
- safe_call(clib.af_is_scalar(pointer(res), self.arr))
+ res = ct.c_bool(False)
+ safe_call(clib.af_is_scalar(ct.pointer(res), self.arr))
return res.value
def is_row(self):
- res = c_bool(False)
- safe_call(clib.af_is_row(pointer(res), self.arr))
+ res = ct.c_bool(False)
+ safe_call(clib.af_is_row(ct.pointer(res), self.arr))
return res.value
def is_column(self):
- res = c_bool(False)
- safe_call(clib.af_is_column(pointer(res), self.arr))
+ res = ct.c_bool(False)
+ safe_call(clib.af_is_column(ct.pointer(res), self.arr))
return res.value
def is_vector(self):
- res = c_bool(False)
- safe_call(clib.af_is_vector(pointer(res), self.arr))
+ res = ct.c_bool(False)
+ safe_call(clib.af_is_vector(ct.pointer(res), self.arr))
return res.value
def is_complex(self):
- res = c_bool(False)
- safe_call(clib.af_is_complex(pointer(res), self.arr))
+ res = ct.c_bool(False)
+ safe_call(clib.af_is_complex(ct.pointer(res), self.arr))
return res.value
def is_real(self):
- res = c_bool(False)
- safe_call(clib.af_is_real(pointer(res), self.arr))
+ res = ct.c_bool(False)
+ safe_call(clib.af_is_real(ct.pointer(res), self.arr))
return res.value
def is_double(self):
- res = c_bool(False)
- safe_call(clib.af_is_double(pointer(res), self.arr))
+ res = ct.c_bool(False)
+ safe_call(clib.af_is_double(ct.pointer(res), self.arr))
return res.value
def is_single(self):
- res = c_bool(False)
- safe_call(clib.af_is_single(pointer(res), self.arr))
+ res = ct.c_bool(False)
+ safe_call(clib.af_is_single(ct.pointer(res), self.arr))
return res.value
def is_real_floating(self):
- res = c_bool(False)
- safe_call(clib.af_is_realfloating(pointer(res), self.arr))
+ res = ct.c_bool(False)
+ safe_call(clib.af_is_realfloating(ct.pointer(res), self.arr))
return res.value
def is_floating(self):
- res = c_bool(False)
- safe_call(clib.af_is_floating(pointer(res), self.arr))
+ res = ct.c_bool(False)
+ safe_call(clib.af_is_floating(ct.pointer(res), self.arr))
return res.value
def is_integer(self):
- res = c_bool(False)
- safe_call(clib.af_is_integer(pointer(res), self.arr))
+ res = ct.c_bool(False)
+ safe_call(clib.af_is_integer(ct.pointer(res), self.arr))
return res.value
def is_bool(self):
- res = c_bool(False)
- safe_call(clib.af_is_bool(pointer(res), self.arr))
+ res = ct.c_bool(False)
+ safe_call(clib.af_is_bool(ct.pointer(res), self.arr))
return res.value
def __add__(self, other):
diff --git a/arrayfire/blas.py b/arrayfire/blas.py
index a548978..312a6d0 100644
--- a/arrayfire/blas.py
+++ b/arrayfire/blas.py
@@ -12,37 +12,37 @@ from .array import *
def matmul(lhs, rhs, lhs_opts=AF_MAT_NONE, rhs_opts=AF_MAT_NONE):
out = array()
- safe_call(clib.af_matmul(pointer(out.arr), lhs.arr, rhs.arr,\
+ safe_call(clib.af_matmul(ct.pointer(out.arr), lhs.arr, rhs.arr,\
lhs_opts, rhs_opts))
return out
def matmulTN(lhs, rhs):
out = array()
- safe_call(clib.af_matmul(pointer(out.arr), lhs.arr, rhs.arr,\
+ safe_call(clib.af_matmul(ct.pointer(out.arr), lhs.arr, rhs.arr,\
AF_MAT_TRANS, AF_MAT_NONE))
return out
def matmulNT(lhs, rhs):
out = array()
- safe_call(clib.af_matmul(pointer(out.arr), lhs.arr, rhs.arr,\
+ safe_call(clib.af_matmul(ct.pointer(out.arr), lhs.arr, rhs.arr,\
AF_MAT_NONE, AF_MAT_TRANS))
return out
def matmulTT(lhs, rhs):
out = array()
- safe_call(clib.af_matmul(pointer(out.arr), lhs.arr, rhs.arr,\
+ safe_call(clib.af_matmul(ct.pointer(out.arr), lhs.arr, rhs.arr,\
AF_MAT_TRANS, AF_MAT_TRANS))
return out
def dot(lhs, rhs, lhs_opts=AF_MAT_NONE, rhs_opts=AF_MAT_NONE):
out = array()
- safe_call(clib.af_dot(pointer(out.arr), lhs.arr, rhs.arr,\
+ safe_call(clib.af_dot(ct.pointer(out.arr), lhs.arr, rhs.arr,\
lhs_opts, rhs_opts))
return out
def transpose(a, conj=False):
out = array()
- safe_call(clib.af_transpose(pointer(out.arr), a.arr, conj))
+ safe_call(clib.af_transpose(ct.pointer(out.arr), a.arr, conj))
return out
def transpose_inplace(a, conj=False):
diff --git a/arrayfire/data.py b/arrayfire/data.py
index 0e89a9a..d3edb2c 100644
--- a/arrayfire/data.py
+++ b/arrayfire/data.py
@@ -22,23 +22,23 @@ brange = range
def range(d0, d1=None, d2=None, d3=None, dim=-1, dtype=f32):
- if not isinstance(dtype, c_int):
+ if not isinstance(dtype, ct.c_int):
if isinstance(dtype, int):
- dtype = c_int(dtype)
+ dtype = ct.c_int(dtype)
else:
raise TypeError("Invalid dtype")
out = array()
dims = dim4(d0, d1, d2, d3)
- safe_call(clib.af_range(pointer(out.arr), 4, pointer(dims), dim, dtype))
+ safe_call(clib.af_range(ct.pointer(out.arr), 4, ct.pointer(dims), dim, dtype))
return out
def iota(d0, d1=None, d2=None, d3=None, dim=-1, tile_dims=None, dtype=f32):
- if not isinstance(dtype, c_int):
+ if not isinstance(dtype, ct.c_int):
if isinstance(dtype, int):
- dtype = c_int(dtype)
+ dtype = ct.c_int(dtype)
else:
raise TypeError("Invalid dtype")
@@ -52,122 +52,122 @@ def iota(d0, d1=None, d2=None, d3=None, dim=-1, tile_dims=None, dtype=f32):
tdims = dim4(td[0], td[1], td[2], td[3])
- safe_call(clib.af_iota(pointer(out.arr), 4, pointer(dims), 4, pointer(tdims), dtype))
+ safe_call(clib.af_iota(ct.pointer(out.arr), 4, ct.pointer(dims), 4, ct.pointer(tdims), dtype))
return out
def randu(d0, d1=None, d2=None, d3=None, dtype=f32):
- if not isinstance(dtype, c_int):
+ if not isinstance(dtype, ct.c_int):
if isinstance(dtype, int):
- dtype = c_int(dtype)
+ dtype = ct.c_int(dtype)
else:
raise TypeError("Invalid dtype")
out = array()
dims = dim4(d0, d1, d2, d3)
- safe_call(clib.af_randu(pointer(out.arr), 4, pointer(dims), dtype))
+ safe_call(clib.af_randu(ct.pointer(out.arr), 4, ct.pointer(dims), dtype))
return out
def randn(d0, d1=None, d2=None, d3=None, dtype=f32):
- if not isinstance(dtype, c_int):
+ if not isinstance(dtype, ct.c_int):
if isinstance(dtype, int):
- dtype = c_int(dtype)
+ dtype = ct.c_int(dtype)
else:
raise TypeError("Invalid dtype")
out = array()
dims = dim4(d0, d1, d2, d3)
- safe_call(clib.af_randn(pointer(out.arr), 4, pointer(dims), dtype))
+ safe_call(clib.af_randn(ct.pointer(out.arr), 4, ct.pointer(dims), dtype))
return out
def set_seed(seed=0):
- safe_call(clib.af_set_seed(c_ulonglong(seed)))
+ safe_call(clib.af_set_seed(ct.c_ulonglong(seed)))
def get_seed():
- seed = c_ulonglong(0)
- safe_call(clib.af_get_seed(pointer(seed)))
+ seed = ct.c_ulonglong(0)
+ safe_call(clib.af_get_seed(ct.pointer(seed)))
return seed.value
def identity(d0, d1=None, d2=None, d3=None, dtype=f32):
- if not isinstance(dtype, c_int):
+ if not isinstance(dtype, ct.c_int):
if isinstance(dtype, int):
- dtype = c_int(dtype)
+ dtype = ct.c_int(dtype)
else:
raise TypeError("Invalid dtype")
out = array()
dims = dim4(d0, d1, d2, d3)
- safe_call(clib.af_identity(pointer(out.arr), 4, pointer(dims), dtype))
+ safe_call(clib.af_identity(ct.pointer(out.arr), 4, ct.pointer(dims), dtype))
return out
def diag(a, num=0, extract=True):
out = array()
if extract:
- safe_call(clib.af_diag_extract(pointer(out.arr), a.arr, c_int(num)))
+ safe_call(clib.af_diag_extract(ct.pointer(out.arr), a.arr, ct.c_int(num)))
else:
- safe_call(clib.af_diag_create(pointer(out.arr), a.arr, c_int(num)))
+ safe_call(clib.af_diag_create(ct.pointer(out.arr), a.arr, ct.c_int(num)))
return out
def join(dim, first, second, third=None, fourth=None):
out = array()
if (third is None and fourth is None):
- safe_call(clib.af_join(pointer(out.arr), dim, first.arr, second.arr))
+ safe_call(clib.af_join(ct.pointer(out.arr), dim, first.arr, second.arr))
else:
- c_array_vec = dim4(first, second, 0, 0)
+ ct.c_array_vec = dim4(first, second, 0, 0)
num = 2
if third is not None:
- c_array_vec[num] = third.arr
+ ct.c_array_vec[num] = third.arr
num+=1
if fourth is not None:
- c_array_vec[num] = fourth.arr
+ ct.c_array_vec[num] = fourth.arr
num+=1
- safe_call(clib.af_join_many(pointer(out.arr), dim, num, pointer(c_array_vec)))
+ safe_call(clib.af_join_many(ct.pointer(out.arr), dim, num, ct.pointer(ct.c_array_vec)))
def tile(a, d0, d1=1, d2=1, d3=1):
out = array()
- safe_call(clib.af_tile(pointer(out.arr), a.arr, d0, d1, d2, d3))
+ safe_call(clib.af_tile(ct.pointer(out.arr), a.arr, d0, d1, d2, d3))
return out
def reorder(a, d0=1, d1=0, d2=2, d3=3):
out = array()
- safe_call(clib.af_reorder(pointer(out.arr), a.arr, d0, d1, d2, d3))
+ safe_call(clib.af_reorder(ct.pointer(out.arr), a.arr, d0, d1, d2, d3))
return out
def shift(a, d0, d1=0, d2=0, d3=0):
out = array()
- safe_call(clib.af_shift(pointer(out.arr), a.arr, d0, d1, d2, d3))
+ safe_call(clib.af_shift(ct.pointer(out.arr), a.arr, d0, d1, d2, d3))
return out
def moddims(a, d0, d1=1, d2=1, d3=1):
out = array()
dims = dim4(d0, d1, d2, d3)
- safe_call(clib.af_moddims(pointer(out.arr), a.arr, 4, pointer(dims)))
+ safe_call(clib.af_moddims(ct.pointer(out.arr), a.arr, 4, ct.pointer(dims)))
return out
def flat(a):
out = array()
- safe_call(clib.af_flat(pointer(out.arr), a.arr))
+ safe_call(clib.af_flat(ct.pointer(out.arr), a.arr))
return out
def flip(a, dim=0):
out = array()
- safe_call(clib.af_flip(pointer(out.arr), a.arr, c_int(dim)))
+ safe_call(clib.af_flip(ct.pointer(out.arr), a.arr, ct.c_int(dim)))
return out
def lower(a, is_unit_diag=False):
out = array()
- safe_call(clib.af_lower(pointer(out.arr), a.arr, is_unit_diag))
+ safe_call(clib.af_lower(ct.pointer(out.arr), a.arr, is_unit_diag))
return out
def upper(a, is_unit_diag=False):
out = array()
- safe_call(clib.af_upper(pointer(out.arr), a.arr, is_unit_diag))
+ safe_call(clib.af_upper(ct.pointer(out.arr), a.arr, is_unit_diag))
return out
diff --git a/arrayfire/device.py b/arrayfire/device.py
index b661e3e..3a0462b 100644
--- a/arrayfire/device.py
+++ b/arrayfire/device.py
@@ -8,21 +8,20 @@
########################################################
from .library import *
-from ctypes import *
from .util import (safe_call, to_str)
def info():
safe_call(clib.af_info())
def device_info():
- c_char_256 = c_char * 256
- device_name = c_char_256()
- backend_name = c_char_256()
- toolkit = c_char_256()
- compute = c_char_256()
+ ct.c_char_256 = ct.c_char * 256
+ device_name = ct.c_char_256()
+ backend_name = ct.c_char_256()
+ toolkit = ct.c_char_256()
+ compute = ct.c_char_256()
- safe_call(clib.af_device_info(pointer(device_name), pointer(backend_name), \
- pointer(toolkit), pointer(compute)))
+ safe_call(clib.af_device_info(ct.pointer(device_name), ct.pointer(backend_name), \
+ ct.pointer(toolkit), ct.pointer(compute)))
dev_info = {}
dev_info['device'] = to_str(device_name)
dev_info['backend'] = to_str(backend_name)
@@ -32,22 +31,22 @@ def device_info():
return dev_info
def get_device_count():
- c_num = c_int(0)
- safe_call(clib.af_get_device_count(pointer(c_num)))
- return c_num.value
+ ct.c_num = ct.c_int(0)
+ safe_call(clib.af_get_device_count(ct.pointer(ct.c_num)))
+ return ct.c_num.value
def get_device():
- c_dev = c_int(0)
- safe_call(clib.af_get_device(pointer(c_dev)))
- return c_dev.value
+ ct.c_dev = ct.c_int(0)
+ safe_call(clib.af_get_device(ct.pointer(ct.c_dev)))
+ return ct.c_dev.value
def set_device(num):
safe_call(clib.af_set_device(num))
def is_dbl_supported(device=None):
dev = device if device is not None else get_device()
- res = c_bool(False)
- safe_call(clib.af_get_dbl_support(pointer(res), dev))
+ res = ct.c_bool(False)
+ safe_call(clib.af_get_dbl_support(ct.pointer(res), dev))
return res.value
def sync(device=None):
@@ -55,12 +54,12 @@ def sync(device=None):
safe_call(clib.af_sync(dev))
def device_mem_info():
- 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(clib.af_device_mem_info(pointer(alloc_bytes), pointer(alloc_buffers),\
- pointer(lock_bytes), pointer(lock_buffers)))
+ 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(clib.af_device_mem_info(ct.pointer(alloc_bytes), ct.pointer(alloc_buffers),\
+ ct.pointer(lock_bytes), ct.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}
diff --git a/arrayfire/features.py b/arrayfire/features.py
index c020aae..8c8c694 100644
--- a/arrayfire/features.py
+++ b/arrayfire/features.py
@@ -13,37 +13,37 @@ import numbers
class features(object):
def __init__(self, num=None):
- self.feat = c_longlong(0)
+ self.feat = ct.c_longlong(0)
if num is not None:
assert(isinstance(num, numbers.Number))
- safe_call(clib.af_create_features(pointer(self.feat), c_longlong(num)))
+ safe_call(clib.af_create_features(ct.pointer(self.feat), ct.c_longlong(num)))
def num_features():
- num = c_longlong(0)
- safe_call(clib.af_get_features_num(pointer(num), self.feat))
+ num = ct.c_longlong(0)
+ safe_call(clib.af_get_features_num(ct.pointer(num), self.feat))
return num
def get_xpos():
out = array()
- safe_call(clib.af_get_features_xpos(pointer(out.arr), self.feat))
+ safe_call(clib.af_get_features_xpos(ct.pointer(out.arr), self.feat))
return out
def get_ypos():
out = array()
- safe_call(clib.af_get_features_ypos(pointer(out.arr), self.feat))
+ safe_call(clib.af_get_features_ypos(ct.pointer(out.arr), self.feat))
return out
def get_score():
out = array()
- safe_call(clib.af_get_features_score(pointer(out.arr), self.feat))
+ safe_call(clib.af_get_features_score(ct.pointer(out.arr), self.feat))
return out
def get_orientation():
out = array()
- safe_call(clib.af_get_features_orientation(pointer(out.arr), self.feat))
+ safe_call(clib.af_get_features_orientation(ct.pointer(out.arr), self.feat))
return out
def get_size():
out = array()
- safe_call(clib.af_get_features_size(pointer(out.arr), self.feat))
+ safe_call(clib.af_get_features_size(ct.pointer(out.arr), self.feat))
return out
diff --git a/arrayfire/image.py b/arrayfire/image.py
index 636731b..3fc7622 100644
--- a/arrayfire/image.py
+++ b/arrayfire/image.py
@@ -15,18 +15,18 @@ import os
def gradient(image):
dx = array()
dy = array()
- safe_call(clib.af_gradient(pointer(dx.arr), pointer(dy.arr), image.arr))
+ safe_call(clib.af_gradient(ct.pointer(dx.arr), ct.pointer(dy.arr), image.arr))
return dx, dy
def load_image(file_name, is_color=False):
assert(os.path.isfile(file_name))
image = array()
- safe_call(clib.af_load_image(pointer(image.arr), c_char_p(file_name.encode('ascii')), is_color))
+ safe_call(clib.af_load_image(ct.pointer(image.arr), ct.c_char_p(file_name.encode('ascii')), is_color))
return image
def save_image(image, file_name):
assert(isinstance(file_name, str))
- safe_call(clib.af_save_image(c_char_p(file_name.encode('ascii')), image.arr))
+ safe_call(clib.af_save_image(ct.c_char_p(file_name.encode('ascii')), image.arr))
return image
def resize(image, scale=None, odim0=None, odim1=None, method=AF_INTERP_NEAREST):
@@ -40,41 +40,41 @@ def resize(image, scale=None, odim0=None, odim1=None, method=AF_INTERP_NEAREST):
odim1 = int(scale * idims[1])
output = array()
- safe_call(clib.af_resize(pointer(output.arr),\
- image.arr, c_longlong(odim0), c_longlong(odim1), method))
+ safe_call(clib.af_resize(ct.pointer(output.arr),\
+ image.arr, ct.c_longlong(odim0), ct.c_longlong(odim1), method))
return output
def transform(image, transform, odim0 = 0, odim1 = 0, method=AF_INTERP_NEAREST, is_inverse=True):
output = array()
- safe_call(clib.af_transform(pointer(output.arr),\
+ safe_call(clib.af_transform(ct.pointer(output.arr),\
image.arr, transform.arr,\
- c_longlong(odim0), c_longlong(odim1), method, is_inverse))
+ ct.c_longlong(odim0), ct.c_longlong(odim1), method, is_inverse))
return output
def rotate(image, theta, is_crop = True, method = AF_INTERP_NEAREST):
output = array()
- safe_call(clib.af_rotate(pointer(output.arr), image.arr, c_double(theta), is_crop, method))
+ safe_call(clib.af_rotate(ct.pointer(output.arr), image.arr, ct.c_double(theta), is_crop, method))
return output
def translate(image, trans0, trans1, odim0 = 0, odim1 = 0, method = AF_INTERP_NEAREST):
output = array()
- safe_call(clib.af_translate(pointer(output.arr), \
- image.arr, trans0, trans1, c_longlong(odim0), c_longlong(odim1), method))
+ safe_call(clib.af_translate(ct.pointer(output.arr), \
+ image.arr, trans0, trans1, ct.c_longlong(odim0), ct.c_longlong(odim1), method))
return output
def scale(image, scale0, scale1, odim0 = 0, odim1 = 0, method = AF_INTERP_NEAREST):
output = array()
- safe_call(clib.af_scale(pointer(output.arr),\
- image.arr, c_double(scale0), c_double(scale1),\
- c_longlong(odim0), c_longlong(odim1), method))
+ safe_call(clib.af_scale(ct.pointer(output.arr),\
+ image.arr, ct.c_double(scale0), ct.c_double(scale1),\
+ ct.c_longlong(odim0), ct.c_longlong(odim1), method))
return output
def skew(image, skew0, skew1, odim0 = 0, odim1 = 0, method = AF_INTERP_NEAREST, is_inverse=True):
output = array()
- safe_call(clib.af_skew(pointer(output.arr),\
- image.arr, c_double(skew0), c_double(skew1), \
- c_longlong(odim0), c_longlong(odim1), method, is_inverse))
+ safe_call(clib.af_skew(ct.pointer(output.arr),\
+ image.arr, ct.c_double(skew0), ct.c_double(skew1), \
+ ct.c_longlong(odim0), ct.c_longlong(odim1), method, is_inverse))
return output
@@ -89,13 +89,13 @@ def histogram(image, nbins, min_val = None, max_val = None):
max_val = af_max(image)
output = array()
- safe_call(clib.af_histogram(pointer(output.arr),\
- image.arr, c_uint(nbins), c_double(min_val), c_double(max_val)))
+ safe_call(clib.af_histogram(ct.pointer(output.arr),\
+ image.arr, ct.c_uint(nbins), ct.c_double(min_val), ct.c_double(max_val)))
return output
def hist_equal(image, hist):
output = array()
- safe_call(clib.af_hist_equal(pointer(output.arr), image.arr, hist.arr))
+ safe_call(clib.af_hist_equal(ct.pointer(output.arr), image.arr, hist.arr))
return output
def dilate(image, mask = None):
@@ -104,7 +104,7 @@ def dilate(image, mask = None):
mask = constant(1, 3, 3, dtype=f32)
output = array()
- safe_call(clib.af_dilate(pointer(output.arr), image.arr, mask.arr))
+ safe_call(clib.af_dilate(ct.pointer(output.arr), image.arr, mask.arr))
return output
@@ -114,7 +114,7 @@ def dilate3(image, mask = None):
mask = constant(1, 3, 3, 3, dtype=f32)
output = array()
- safe_call(clib.af_dilate3(pointer(output.arr), image.arr, mask.arr))
+ safe_call(clib.af_dilate3(ct.pointer(output.arr), image.arr, mask.arr))
return output
@@ -124,7 +124,7 @@ def erode(image, mask = None):
mask = constant(1, 3, 3, dtype=f32)
output = array()
- safe_call(clib.af_erode(pointer(output.arr), image.arr, mask.arr))
+ safe_call(clib.af_erode(ct.pointer(output.arr), image.arr, mask.arr))
return output
@@ -134,51 +134,51 @@ def erode3(image, mask = None):
mask = constant(1, 3, 3, 3, dtype=f32)
output = array()
- safe_call(clib.af_erode3(pointer(output.arr), image.arr, mask.arr))
+ safe_call(clib.af_erode3(ct.pointer(output.arr), image.arr, mask.arr))
return output
def bilateral(image, s_sigma, c_sigma, is_color = False):
output = array()
- safe_call(clib.af_bilateral(pointer(output.arr),\
- image.arr, c_double(s_sigma), c_double(c_sigma), is_color))
+ safe_call(clib.af_bilateral(ct.pointer(output.arr),\
+ image.arr, ct.c_double(s_sigma), ct.c_double(c_sigma), is_color))
return output
def mean_shift(image, s_sigma, c_sigma, n_iter, is_color = False):
output = array()
- safe_call(clib.af_mean_shift(pointer(output.arr),\
- image.arr, c_double(s_sigma), c_double(c_sigma),\
- c_uint(n_iter), is_color))
+ safe_call(clib.af_mean_shift(ct.pointer(output.arr),\
+ image.arr, ct.c_double(s_sigma), ct.c_double(c_sigma),\
+ ct.c_uint(n_iter), is_color))
return output
def medfilt(image, w_len = 3, w_wid = 3, edge_pad = AF_PAD_ZERO):
output = array()
- safe_call(clib.af_medfilt(pointer(output.arr), \
- image.arr, c_longlong(w_len), c_longlong(w_wid), edge_pad))
+ safe_call(clib.af_medfilt(ct.pointer(output.arr), \
+ image.arr, ct.c_longlong(w_len), ct.c_longlong(w_wid), edge_pad))
return output
def minfilt(image, w_len = 3, w_wid = 3, edge_pad = AF_PAD_ZERO):
output = array()
- safe_call(clib.af_minfilt(pointer(output.arr), \
- image.arr, c_longlong(w_len), c_longlong(w_wid), edge_pad))
+ safe_call(clib.af_minfilt(ct.pointer(output.arr), \
+ image.arr, ct.c_longlong(w_len), ct.c_longlong(w_wid), edge_pad))
return output
def maxfilt(image, w_len = 3, w_wid = 3, edge_pad = AF_PAD_ZERO):
output = array()
- safe_call(clib.af_maxfilt(pointer(output.arr), \
- image.arr, c_longlong(w_len), c_longlong(w_wid), edge_pad))
+ safe_call(clib.af_maxfilt(ct.pointer(output.arr), \
+ image.arr, ct.c_longlong(w_len), ct.c_longlong(w_wid), edge_pad))
return output
def regions(image, connectivity = AF_CONNECTIVITY_4, out_type = f32):
output = array()
- safe_call(clib.af_regions(pointer(output.arr), image.arr, connectivity, out_type))
+ safe_call(clib.af_regions(ct.pointer(output.arr), image.arr, connectivity, out_type))
return output
def sobel_derivatives(image, w_len=3):
dx = array()
dy = array()
- safe_call(clib.af_sobel_operator(pointer(dx.arr), pointer(dy.arr),\
- image.arr, c_uint(w_len)))
+ safe_call(clib.af_sobel_operator(ct.pointer(dx.arr), ct.pointer(dy.arr),\
+ image.arr, ct.c_uint(w_len)))
return dx,dy
def sobel_filter(image, w_len = 3, is_fast = False):
@@ -193,27 +193,27 @@ def sobel_filter(image, w_len = 3, is_fast = False):
def rgb2gray(image, r_factor = 0.2126, g_factor = 0.7152, b_factor = 0.0722):
output=array()
- safe_call(clib.af_rgb2gray(pointer(output.arr), \
- image.arr, c_float(r_factor), c_float(g_factor), c_float(b_factor)))
+ safe_call(clib.af_rgb2gray(ct.pointer(output.arr), \
+ image.arr, ct.c_float(r_factor), ct.c_float(g_factor), ct.c_float(b_factor)))
return output
def gray2rgb(image, r_factor = 1.0, g_factor = 1.0, b_factor = 1.0):
output=array()
- safe_call(clib.af_gray2rgb(pointer(output.arr), \
- image.arr, c_float(r_factor), c_float(g_factor), c_float(b_factor)))
+ safe_call(clib.af_gray2rgb(ct.pointer(output.arr), \
+ image.arr, ct.c_float(r_factor), ct.c_float(g_factor), ct.c_float(b_factor)))
return output
def hsv2rgb(image):
output = array()
- safe_call(clib.af_hsv2rgb(pointer(output.arr), image.arr))
+ safe_call(clib.af_hsv2rgb(ct.pointer(output.arr), image.arr))
return output
def rgb2hsv(image):
output = array()
- safe_call(clib.af_rgb2hsv(pointer(output.arr), image.arr))
+ safe_call(clib.af_rgb2hsv(ct.pointer(output.arr), image.arr))
return output
def color_space(image, to_type, from_type):
output = array()
- safe_call(clib.af_color_space(pointer(output.arr), image.arr, to_type, from_type))
+ safe_call(clib.af_color_space(ct.pointer(output.arr), image.arr, to_type, from_type))
return output
diff --git a/arrayfire/lapack.py b/arrayfire/lapack.py
index febc6d1..7300edb 100644
--- a/arrayfire/lapack.py
+++ b/arrayfire/lapack.py
@@ -14,67 +14,67 @@ def lu(A):
L = array()
U = array()
P = array()
- safe_call(clib.af_lu(pointer(L.arr), pointer(U.arr), pointer(P.arr), A.arr))
+ safe_call(clib.af_lu(ct.pointer(L.arr), ct.pointer(U.arr), ct.pointer(P.arr), A.arr))
return L,U,P
def lu_inplace(A, pivot="lapack"):
P = array()
is_pivot_lapack = False if (pivot == "full") else True
- safe_call(clib.af_lu_inplace(pointer(P.arr), A.arr, is_pivot_lapack))
+ safe_call(clib.af_lu_inplace(ct.pointer(P.arr), A.arr, is_pivot_lapack))
return P
def qr(A):
Q = array()
R = array()
T = array()
- safe_call(clib.af_lu(pointer(Q.arr), pointer(R.arr), pointer(T.arr), A.arr))
+ safe_call(clib.af_lu(ct.pointer(Q.arr), ct.pointer(R.arr), ct.pointer(T.arr), A.arr))
return Q,R,T
def qr_inplace(A):
T = array()
- safe_call(clib.af_qr_inplace(pointer(T.arr), A.arr))
+ safe_call(clib.af_qr_inplace(ct.pointer(T.arr), A.arr))
return T
def cholesky(A, is_upper=True):
R = array()
- info = c_int(0)
- safe_call(clib.af_cholesky(pointer(R.arr), pointer(info), A.arr, is_upper))
+ info = ct.c_int(0)
+ safe_call(clib.af_cholesky(ct.pointer(R.arr), ct.pointer(info), A.arr, is_upper))
return R, info.value
def cholesky_inplace(A, is_upper=True):
- info = c_int(0)
- safe_call(clib.af_cholesky_inplace(pointer(info), A.arr, is_upper))
+ info = ct.c_int(0)
+ safe_call(clib.af_cholesky_inplace(ct.pointer(info), A.arr, is_upper))
return info.value
def solve(A, B, options=AF_MAT_NONE):
X = array()
- safe_call(clib.af_solve(pointer(X.arr), A.arr, B.arr, options))
+ safe_call(clib.af_solve(ct.pointer(X.arr), A.arr, B.arr, options))
return X
def solve_lu(A, P, B, options=AF_MAT_NONE):
X = array()
- safe_call(clib.af_solve_lu(pointer(X.arr), A.arr, P.arr, B.arr, options))
+ safe_call(clib.af_solve_lu(ct.pointer(X.arr), A.arr, P.arr, B.arr, options))
return X
def inverse(A, options=AF_MAT_NONE):
I = array()
- safe_call(clib.af_inverse(pointer(I.arr), A.arr, options))
+ safe_call(clib.af_inverse(ct.pointer(I.arr), A.arr, options))
return I
def rank(A, tol=1E-5):
- r = c_uint(0)
- safe_call(clib.af_rank(pointer(r), A.arr, c_double(tol)))
+ r = ct.c_uint(0)
+ safe_call(clib.af_rank(ct.pointer(r), A.arr, ct.c_double(tol)))
return r.value
def det(A):
- re = c_double(0)
- im = c_double(0)
- safe_call(clib.af_det(pointer(re), pointer(im), A.arr))
+ re = ct.c_double(0)
+ im = ct.c_double(0)
+ safe_call(clib.af_det(ct.pointer(re), ct.pointer(im), A.arr))
re = re.value
im = im.value
return re if (im == 0) else re + im * 1j
def norm(A, norm_type=AF_NORM_EUCLID, p=1.0, q=1.0):
- res = c_double(0)
- safe_call(clib.af_norm(pointer(res), A.arr, norm_type, c_double(p), c_double(q)))
+ res = ct.c_double(0)
+ safe_call(clib.af_norm(ct.pointer(res), A.arr, norm_type, ct.c_double(p), ct.c_double(q)))
return res.value
diff --git a/arrayfire/library.py b/arrayfire/library.py
index ca40bf6..058997a 100644
--- a/arrayfire/library.py
+++ b/arrayfire/library.py
@@ -8,7 +8,7 @@
########################################################
import platform
-from ctypes import *
+import ctypes as ct
def load_backend(name):
platform_name = platform.system()
@@ -21,8 +21,8 @@ def load_backend(name):
else:
raise OSError(platform_name + ' not supported')
- cdll.LoadLibrary(libname)
- clib = CDLL(libname)
+ ct.cdll.LoadLibrary(libname)
+ clib = ct.CDLL(libname)
print("Using %s backend" % name)
return clib
@@ -35,105 +35,105 @@ except:
clib = load_backend('cpu')
-AF_SUCCESS = c_int(0)
+AF_SUCCESS = ct.c_int(0)
#100-199 Errors in environment
-AF_ERR_NO_MEM = c_int(101)
-AF_ERR_DRIVER = c_int(102)
-AF_ERR_RUNTIME = c_int(103)
+AF_ERR_NO_MEM = ct.c_int(101)
+AF_ERR_DRIVER = ct.c_int(102)
+AF_ERR_RUNTIME = ct.c_int(103)
# 200-299 Errors in input parameters
-AF_ERR_INVALID_ARRAY = c_int(201)
-AF_ERR_ARG = c_int(202)
-AF_ERR_SIZE = c_int(203)
-AF_ERR_TYPE = c_int(204)
-AF_ERR_DIFF_TYPE = c_int(205)
-AF_ERR_BATCH = c_int(207)
+AF_ERR_INVALID_ARRAY = ct.c_int(201)
+AF_ERR_ARG = ct.c_int(202)
+AF_ERR_SIZE = ct.c_int(203)
+AF_ERR_TYPE = ct.c_int(204)
+AF_ERR_DIFF_TYPE = ct.c_int(205)
+AF_ERR_BATCH = ct.c_int(207)
# 300-399 Errors for missing software features
-AF_ERR_NOT_SUPPORTED = c_int(301)
-AF_ERR_NOT_CONFIGURED = c_int(302)
+AF_ERR_NOT_SUPPORTED = ct.c_int(301)
+AF_ERR_NOT_CONFIGURED = ct.c_int(302)
# 400-499 Errors for missing hardware features
-AF_ERR_NO_DBL = c_int(401)
-AF_ERR_NO_GFX = c_int(402)
+AF_ERR_NO_DBL = ct.c_int(401)
+AF_ERR_NO_GFX = ct.c_int(402)
# 900-999 Errors from upstream libraries and runtimes
-AF_ERR_INTERNAL = c_int(998)
-AF_ERR_UNKNOWN = c_int(999)
-
-f32 = c_int(0)
-c32 = c_int(1)
-f64 = c_int(2)
-c64 = c_int(3)
-b8 = c_int(4)
-s32 = c_int(5)
-u32 = c_int(6)
-u8 = c_int(7)
-s64 = c_int(8)
-u64 = c_int(9)
-
-afDevice = c_int(0)
-afHost = c_int(1)
-
-AF_INTERP_NEAREST = c_int(0)
-AF_INTERP_LINEAR = c_int(1)
-AF_INTERP_BILINEAR = c_int(2)
-AF_INTERP_CUBIC = c_int(3)
-
-AF_PAD_ZERO = c_int(0)
-AF_PAD_SYM = c_int(1)
-
-AF_CONNECTIVITY_4 = c_int(4)
-AF_CONNECTIVITY_8 = c_int(8)
-
-AF_CONV_DEFAULT = c_int(0)
-AF_CONV_EXPAND = c_int(1)
-
-AF_CONV_AUTO = c_int(0)
-AF_CONV_SPATIAL = c_int(1)
-AF_CONV_FREQ = c_int(2)
-
-AF_SAD = c_int(0)
-AF_ZSAD = c_int(1)
-AF_LSAD = c_int(2)
-AF_SSD = c_int(3)
-AF_ZSSD = c_int(4)
-AF_LSSD = c_int(5)
-AF_NCC = c_int(6)
-AF_ZNCC = c_int(7)
-AF_SHD = c_int(8)
-
-AF_GRAY = c_int(0)
-AF_RGB = c_int(1)
-AF_HSV = c_int(2)
-
-AF_MAT_NONE = c_int(0)
-AF_MAT_TRANS = c_int(1)
-AF_MAT_CTRANS = c_int(2)
-AF_MAT_UPPER = c_int(32)
-AF_MAT_LOWER = c_int(64)
-AF_MAT_DIAG_UNIT = c_int(128)
-AF_MAT_SYM = c_int(512)
-AF_MAT_POSDEF = c_int(1024)
-AF_MAT_ORTHOG = c_int(2048)
-AF_MAT_TRI_DIAG = c_int(4096)
-AF_MAT_BLOCK_DIAG = c_int(8192)
-
-AF_NORM_VECTOR_1 = c_int(0)
-AF_NORM_VECTOR_INF = c_int(1)
-AF_NORM_VECTOR_2 = c_int(2)
-AF_NORM_VECTOR_P = c_int(3)
-AF_NORM_MATRIX_1 = c_int(4)
-AF_NORM_MATRIX_INF = c_int(5)
-AF_NORM_MATRIX_2 = c_int(6)
-AF_NORM_MATRIX_L_PQ = c_int(7)
+AF_ERR_INTERNAL = ct.c_int(998)
+AF_ERR_UNKNOWN = ct.c_int(999)
+
+f32 = ct.c_int(0)
+c32 = ct.c_int(1)
+f64 = ct.c_int(2)
+c64 = ct.c_int(3)
+b8 = ct.c_int(4)
+s32 = ct.c_int(5)
+u32 = ct.c_int(6)
+u8 = ct.c_int(7)
+s64 = ct.c_int(8)
+u64 = ct.c_int(9)
+
+afDevice = ct.c_int(0)
+afHost = ct.c_int(1)
+
+AF_INTERP_NEAREST = ct.c_int(0)
+AF_INTERP_LINEAR = ct.c_int(1)
+AF_INTERP_BILINEAR = ct.c_int(2)
+AF_INTERP_CUBIC = ct.c_int(3)
+
+AF_PAD_ZERO = ct.c_int(0)
+AF_PAD_SYM = ct.c_int(1)
+
+AF_CONNECTIVITY_4 = ct.c_int(4)
+AF_CONNECTIVITY_8 = ct.c_int(8)
+
+AF_CONV_DEFAULT = ct.c_int(0)
+AF_CONV_EXPAND = ct.c_int(1)
+
+AF_CONV_AUTO = ct.c_int(0)
+AF_CONV_SPATIAL = ct.c_int(1)
+AF_CONV_FREQ = ct.c_int(2)
+
+AF_SAD = ct.c_int(0)
+AF_ZSAD = ct.c_int(1)
+AF_LSAD = ct.c_int(2)
+AF_SSD = ct.c_int(3)
+AF_ZSSD = ct.c_int(4)
+AF_LSSD = ct.c_int(5)
+AF_NCC = ct.c_int(6)
+AF_ZNCC = ct.c_int(7)
+AF_SHD = ct.c_int(8)
+
+AF_GRAY = ct.c_int(0)
+AF_RGB = ct.c_int(1)
+AF_HSV = ct.c_int(2)
+
+AF_MAT_NONE = ct.c_int(0)
+AF_MAT_TRANS = ct.c_int(1)
+AF_MAT_CTRANS = ct.c_int(2)
+AF_MAT_UPPER = ct.c_int(32)
+AF_MAT_LOWER = ct.c_int(64)
+AF_MAT_DIAG_UNIT = ct.c_int(128)
+AF_MAT_SYM = ct.c_int(512)
+AF_MAT_POSDEF = ct.c_int(1024)
+AF_MAT_ORTHOG = ct.c_int(2048)
+AF_MAT_TRI_DIAG = ct.c_int(4096)
+AF_MAT_BLOCK_DIAG = ct.c_int(8192)
+
+AF_NORM_VECTOR_1 = ct.c_int(0)
+AF_NORM_VECTOR_INF = ct.c_int(1)
+AF_NORM_VECTOR_2 = ct.c_int(2)
+AF_NORM_VECTOR_P = ct.c_int(3)
+AF_NORM_MATRIX_1 = ct.c_int(4)
+AF_NORM_MATRIX_INF = ct.c_int(5)
+AF_NORM_MATRIX_2 = ct.c_int(6)
+AF_NORM_MATRIX_L_PQ = ct.c_int(7)
AF_NORM_EUCLID = AF_NORM_VECTOR_2
-AF_COLORMAP_DEFAULT = c_int(0)
-AF_COLORMAP_SPECTRUM = c_int(1)
-AF_COLORMAP_COLORS = c_int(2)
-AF_COLORMAP_RED = c_int(3)
-AF_COLORMAP_MOOD = c_int(4)
-AF_COLORMAP_HEAT = c_int(5)
-AF_COLORMAP_BLUE = c_int(6)
+AF_COLORMAP_DEFAULT = ct.c_int(0)
+AF_COLORMAP_SPECTRUM = ct.c_int(1)
+AF_COLORMAP_COLORS = ct.c_int(2)
+AF_COLORMAP_RED = ct.c_int(3)
+AF_COLORMAP_MOOD = ct.c_int(4)
+AF_COLORMAP_HEAT = ct.c_int(5)
+AF_COLORMAP_BLUE = ct.c_int(6)
diff --git a/arrayfire/signal.py b/arrayfire/signal.py
index 983a732..aea2275 100644
--- a/arrayfire/signal.py
+++ b/arrayfire/signal.py
@@ -12,13 +12,13 @@ from .array import *
def approx1(signal, pos0, method=AF_INTERP_LINEAR, off_grid=0.0):
output = array()
- safe_call(clib.af_approx1(pointer(output.arr), signal.arr, pos0.arr, method, c_double(off_grid)))
+ safe_call(clib.af_approx1(ct.pointer(output.arr), signal.arr, pos0.arr, method, ct.c_double(off_grid)))
return output
def approx2(signal, pos0, pos1, method=AF_INTERP_LINEAR, off_grid=0.0):
output = array()
- safe_call(clib.af_approx2(pointer(output.arr), signal.arr, \
- pos0.arr, pos1.arr, method, c_double(off_grid)))
+ safe_call(clib.af_approx2(ct.pointer(output.arr), signal.arr, \
+ pos0.arr, pos1.arr, method, ct.c_double(off_grid)))
return output
def fft(signal, dim0 = None , scale = None):
@@ -30,7 +30,7 @@ def fft(signal, dim0 = None , scale = None):
scale = 1.0
output = array()
- safe_call(clib.af_fft(pointer(output.arr), signal.arr, c_double(scale), c_longlong(dim0)))
+ safe_call(clib.af_fft(ct.pointer(output.arr), signal.arr, ct.c_double(scale), ct.c_longlong(dim0)))
return output
def fft2(signal, dim0 = None, dim1 = None , scale = None):
@@ -45,8 +45,8 @@ def fft2(signal, dim0 = None, dim1 = None , scale = None):
scale = 1.0
output = array()
- safe_call(clib.af_fft2(pointer(output.arr), signal.arr, c_double(scale),\
- c_longlong(dim0), c_longlong(dim1)))
+ safe_call(clib.af_fft2(ct.pointer(output.arr), signal.arr, ct.c_double(scale),\
+ ct.c_longlong(dim0), ct.c_longlong(dim1)))
return output
def fft3(signal, dim0 = None, dim1 = None , dim2 = None, scale = None):
@@ -64,8 +64,8 @@ def fft3(signal, dim0 = None, dim1 = None , dim2 = None, scale = None):
scale = 1.0
output = array()
- safe_call(clib.af_fft3(pointer(output.arr), signal.arr, c_double(scale),\
- c_longlong(dim0), c_longlong(dim1), c_longlong(dim2)))
+ safe_call(clib.af_fft3(ct.pointer(output.arr), signal.arr, ct.c_double(scale),\
+ ct.c_longlong(dim0), ct.c_longlong(dim1), ct.c_longlong(dim2)))
return output
def ifft(signal, dim0 = None , scale = None):
@@ -77,7 +77,7 @@ def ifft(signal, dim0 = None , scale = None):
scale = 1.0/float(dim0)
output = array()
- safe_call(clib.af_ifft(pointer(output.arr), signal.arr, c_double(scale), c_longlong(dim0)))
+ safe_call(clib.af_ifft(ct.pointer(output.arr), signal.arr, ct.c_double(scale), ct.c_longlong(dim0)))
return output
def ifft2(signal, dim0 = None, dim1 = None , scale = None):
@@ -97,8 +97,8 @@ def ifft2(signal, dim0 = None, dim1 = None , scale = None):
scale = 1.0/float(dim0 * dim1)
output = array()
- safe_call(clib.af_ifft2(pointer(output.arr), signal.arr, c_double(scale),\
- c_longlong(dim0), c_longlong(dim1)))
+ safe_call(clib.af_ifft2(ct.pointer(output.arr), signal.arr, ct.c_double(scale),\
+ ct.c_longlong(dim0), ct.c_longlong(dim1)))
return output
def ifft3(signal, dim0 = None, dim1 = None , dim2 = None, scale = None):
@@ -121,8 +121,8 @@ def ifft3(signal, dim0 = None, dim1 = None , dim2 = None, scale = None):
scale = 1.0 / float(dim0 * dim1 * dim2)
output = array()
- safe_call(clib.af_ifft3(pointer(output.arr), signal.arr, c_double(scale),\
- c_longlong(dim0), c_longlong(dim1), c_longlong(dim2)))
+ safe_call(clib.af_ifft3(ct.pointer(output.arr), signal.arr, ct.c_double(scale),\
+ ct.c_longlong(dim0), ct.c_longlong(dim1), ct.c_longlong(dim2)))
return output
def dft(signal, scale = None, odims=(None, None, None, None)):
@@ -155,17 +155,17 @@ def idft(signal, scale = None, odims=(None, None, None, None)):
def convolve1(signal, kernel, conv_mode = AF_CONV_DEFAULT, conv_domain = AF_CONV_AUTO):
output = array()
- safe_call(clib.af_convolve1(pointer(output.arr), signal.arr, kernel.arr, conv_mode, conv_domain))
+ safe_call(clib.af_convolve1(ct.pointer(output.arr), signal.arr, kernel.arr, conv_mode, conv_domain))
return output
def convolve2(signal, kernel, conv_mode = AF_CONV_DEFAULT, conv_domain = AF_CONV_AUTO):
output = array()
- safe_call(clib.af_convolve2(pointer(output.arr), signal.arr, kernel.arr, conv_mode, conv_domain))
+ safe_call(clib.af_convolve2(ct.pointer(output.arr), signal.arr, kernel.arr, conv_mode, conv_domain))
return output
def convolve3(signal, kernel, conv_mode = AF_CONV_DEFAULT, conv_domain = AF_CONV_AUTO):
output = array()
- safe_call(clib.af_convolve3(pointer(output.arr), signal.arr, kernel.arr, conv_mode, conv_domain))
+ safe_call(clib.af_convolve3(ct.pointer(output.arr), signal.arr, kernel.arr, conv_mode, conv_domain))
return output
def convolve(signal, kernel, conv_mode = AF_CONV_DEFAULT, conv_domain = AF_CONV_AUTO):
@@ -181,17 +181,17 @@ def convolve(signal, kernel, conv_mode = AF_CONV_DEFAULT, conv_domain = AF_CONV_
def fft_convolve1(signal, kernel, conv_mode = AF_CONV_DEFAULT):
output = array()
- safe_call(clib.af_fft_convolve1(pointer(output.arr), signal.arr, kernel.arr, conv_mode))
+ safe_call(clib.af_fft_convolve1(ct.pointer(output.arr), signal.arr, kernel.arr, conv_mode))
return output
def fft_convolve2(signal, kernel, conv_mode = AF_CONV_DEFAULT):
output = array()
- safe_call(clib.af_fft_convolve2(pointer(output.arr), signal.arr, kernel.arr, conv_mode))
+ safe_call(clib.af_fft_convolve2(ct.pointer(output.arr), signal.arr, kernel.arr, conv_mode))
return output
def fft_convolve3(signal, kernel, conv_mode = AF_CONV_DEFAULT):
output = array()
- safe_call(clib.af_fft_convolve3(pointer(output.arr), signal.arr, kernel.arr, conv_mode))
+ safe_call(clib.af_fft_convolve3(ct.pointer(output.arr), signal.arr, kernel.arr, conv_mode))
return output
def fft_convolve(signal, kernel, conv_mode = AF_CONV_DEFAULT):
@@ -207,10 +207,10 @@ def fft_convolve(signal, kernel, conv_mode = AF_CONV_DEFAULT):
def fir(B, X):
Y = array()
- safe_call(clib.af_fir(pointer(Y.arr), B.arr, X.arr))
+ safe_call(clib.af_fir(ct.pointer(Y.arr), B.arr, X.arr))
return Y
def iir(B, A, X):
Y = array()
- safe_call(clib.af_iir(pointer(Y.arr), B.arr, A.arr, X.arr))
+ safe_call(clib.af_iir(ct.pointer(Y.arr), B.arr, A.arr, X.arr))
return Y
diff --git a/arrayfire/statistics.py b/arrayfire/statistics.py
index 337df56..e3dd0f7 100644
--- a/arrayfire/statistics.py
+++ b/arrayfire/statistics.py
@@ -15,19 +15,19 @@ def mean(a, weights=None, dim=None):
out = array()
if weights is None:
- safe_call(clib.af_mean(pointer(out.arr), a.arr, c_int(dim)))
+ safe_call(clib.af_mean(ct.pointer(out.arr), a.arr, ct.c_int(dim)))
else:
- safe_call(clib.af_mean_weighted(pointer(out.arr), a.arr, weights.arr, c_int(dim)))
+ safe_call(clib.af_mean_weighted(ct.pointer(out.arr), a.arr, weights.arr, ct.c_int(dim)))
return out
else:
- real = c_double(0)
- imag = c_double(0)
+ real = ct.c_double(0)
+ imag = ct.c_double(0)
if weights is None:
- safe_call(clib.af_mean_all(pointer(real), pointer(imag), a.arr))
+ safe_call(clib.af_mean_all(ct.pointer(real), ct.pointer(imag), a.arr))
else:
- safe_call(clib.af_mean_all_weighted(pointer(real), pointer(imag), a.arr, weights.arr))
+ safe_call(clib.af_mean_all_weighted(ct.pointer(real), ct.pointer(imag), a.arr, weights.arr))
real = real.value
imag = imag.value
@@ -39,19 +39,19 @@ def var(a, isbiased=False, weights=None, dim=None):
out = array()
if weights is None:
- safe_call(clib.af_var(pointer(out.arr), a.arr, isbiased, c_int(dim)))
+ safe_call(clib.af_var(ct.pointer(out.arr), a.arr, isbiased, ct.c_int(dim)))
else:
- safe_call(clib.af_var_weighted(pointer(out.arr), a.arr, weights.arr, c_int(dim)))
+ safe_call(clib.af_var_weighted(ct.pointer(out.arr), a.arr, weights.arr, ct.c_int(dim)))
return out
else:
- real = c_double(0)
- imag = c_double(0)
+ real = ct.c_double(0)
+ imag = ct.c_double(0)
if weights is None:
- safe_call(clib.af_var_all(pointer(real), pointer(imag), a.arr, isbiased))
+ safe_call(clib.af_var_all(ct.pointer(real), ct.pointer(imag), a.arr, isbiased))
else:
- safe_call(clib.af_var_all_weighted(pointer(real), pointer(imag), a.arr, weights.arr))
+ safe_call(clib.af_var_all_weighted(ct.pointer(real), ct.pointer(imag), a.arr, weights.arr))
real = real.value
imag = imag.value
@@ -61,12 +61,12 @@ def var(a, isbiased=False, weights=None, dim=None):
def stdev(a, dim=None):
if dim is not None:
out = array()
- safe_call(clib.af_stdev(pointer(out.arr), a.arr, c_int(dim)))
+ safe_call(clib.af_stdev(ct.pointer(out.arr), a.arr, ct.c_int(dim)))
return out
else:
- real = c_double(0)
- imag = c_double(0)
- safe_call(clib.af_stdev_all(pointer(real), pointer(imag), a.arr))
+ real = ct.c_double(0)
+ imag = ct.c_double(0)
+ safe_call(clib.af_stdev_all(ct.pointer(real), ct.pointer(imag), a.arr))
real = real.value
imag = imag.value
return real if imag == 0 else real + imag * 1j
@@ -74,12 +74,12 @@ def stdev(a, dim=None):
def cov(a, isbiased=False, dim=None):
if dim is not None:
out = array()
- safe_call(clib.af_cov(pointer(out.arr), a.arr, isbiased, c_int(dim)))
+ safe_call(clib.af_cov(ct.pointer(out.arr), a.arr, isbiased, ct.c_int(dim)))
return out
else:
- real = c_double(0)
- imag = c_double(0)
- safe_call(clib.af_cov_all(pointer(real), pointer(imag), a.arr, isbiased))
+ real = ct.c_double(0)
+ imag = ct.c_double(0)
+ safe_call(clib.af_cov_all(ct.pointer(real), ct.pointer(imag), a.arr, isbiased))
real = real.value
imag = imag.value
return real if imag == 0 else real + imag * 1j
@@ -87,20 +87,20 @@ def cov(a, isbiased=False, dim=None):
def median(a, dim=None):
if dim is not None:
out = array()
- safe_call(clib.af_median(pointer(out.arr), a.arr, c_int(dim)))
+ safe_call(clib.af_median(ct.pointer(out.arr), a.arr, ct.c_int(dim)))
return out
else:
- real = c_double(0)
- imag = c_double(0)
- safe_call(clib.af_median_all(pointer(real), pointer(imag), a.arr))
+ real = ct.c_double(0)
+ imag = ct.c_double(0)
+ safe_call(clib.af_median_all(ct.pointer(real), ct.pointer(imag), a.arr))
real = real.value
imag = imag.value
return real if imag == 0 else real + imag * 1j
def corrcoef(x, y):
- real = c_double(0)
- imag = c_double(0)
- safe_call(clib.af_corrcoef(pointer(real), pointer(imag), x.arr, y.arr))
+ real = ct.c_double(0)
+ imag = ct.c_double(0)
+ safe_call(clib.af_corrcoef(ct.pointer(real), ct.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 bd4879c..f4b3ab1 100644
--- a/arrayfire/util.py
+++ b/arrayfire/util.py
@@ -11,8 +11,8 @@ from .library import *
import numbers
def dim4(d0=1, d1=1, d2=1, d3=1):
- c_dim4 = c_longlong * 4
- out = c_dim4(1, 1, 1, 1)
+ ct.c_dim4 = ct.c_longlong * 4
+ out = ct.c_dim4(1, 1, 1, 1)
for i, dim in enumerate((d0, d1, d2, d3)):
if (dim is not None): out[i] = dim
@@ -40,16 +40,16 @@ def to_str(c_str):
def safe_call(af_error):
if (af_error != AF_SUCCESS.value):
- c_err_str = c_char_p(0)
- c_err_len = c_longlong(0)
- clib.af_get_last_error(pointer(c_err_str), pointer(c_err_len))
- raise RuntimeError(to_str(c_err_str), af_error)
+ err_str = ct.c_char_p(0)
+ err_len = ct.c_longlong(0)
+ clib.af_get_last_error(ct.pointer(err_str), ct.pointer(err_len))
+ raise RuntimeError(to_str(err_str), af_error)
def get_version():
- major=c_int(0)
- minor=c_int(0)
- patch=c_int(0)
- safe_call(clib.af_get_version(pointer(major), pointer(minor), pointer(patch)))
+ major=ct.c_int(0)
+ minor=ct.c_int(0)
+ patch=ct.c_int(0)
+ safe_call(clib.af_get_version(ct.pointer(major), ct.pointer(minor), ct.pointer(patch)))
return major,minor,patch
to_dtype = {'f' : f32,
diff --git a/arrayfire/vision.py b/arrayfire/vision.py
index 3f340e1..80bc4bc 100644
--- a/arrayfire/vision.py
+++ b/arrayfire/vision.py
@@ -12,28 +12,28 @@ from .features import *
def fast(image, threshold=20.0, arc_length=9, non_max=True, feature_ratio=0.05, edge=3):
out = features()
- safe_call(clib.af_fast(pointer(out.feat),\
- image.arr, c_float(threshold), c_uint(arc_length), non_max, \
- c_float(feature_ratio), c_uint(edge)))
+ safe_call(clib.af_fast(ct.pointer(out.feat),\
+ image.arr, ct.c_float(threshold), ct.c_uint(arc_length), non_max, \
+ ct.c_float(feature_ratio), ct.c_uint(edge)))
return out
def orb(image, threshold=20.0, max_features=400, scale = 1.5, num_levels = 4, blur_image = False):
feat = features()
desc = array()
- safe_call(clib.af_orb(pointer(feat.feat), pointer(desc.arr),\
- c_float(threshold), c_uint(max_features),\
- c_float(scale), c_uint(num_levels), blur_image))
+ safe_call(clib.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))
return feat, desc
def hamming_matcher(query, database, dim = 0, num_nearest = 1):
index = array()
dist = array()
- safe_call(clib.af_hamming_matcher(pointer(idx.arr), pointer(dist.arr),\
+ safe_call(clib.af_hamming_matcher(ct.pointer(idx.arr), ct.pointer(dist.arr),\
query.arr, database.arr, \
- c_longlong(dim), c_longlong(num_nearest)))
+ ct.c_longlong(dim), ct.c_longlong(num_nearest)))
return index, dist
def match_template(image, template, match_type = AF_SAD):
out = array()
- safe_call(clib.af_match_template(pointer(out.arr), image.arr, template.arr, match_type))
+ safe_call(clib.af_match_template(ct.pointer(out.arr), image.arr, template.arr, match_type))
return out
--
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