Extend and fix api (arrayfire#3)

* Add layout, interface and statistics

* Fix imports

* Add dtype aliases

* Make backend private

Author: roaffix

README.md

@@ -1,3 +1,21 @@
 # arrayfire-python-wrapper
 
 Arrayfire python C library wrapper
+
+## Completionist
+
+- [ ] Computer Vision
+- [ ] Events
+- [x] Functions to Create and Modify Arrays
+- [x] Functions to Work with Internal Array Layout
+- [ ] Image Processing
+- [ ] Input and Output Functions
+- [x] Interface Functions
+- [ ] Linear Algebra
+- [ ] Machine Learning
+- [x] Mathematical Functions
+- [ ] Memory Management
+- [ ] Signal Processing
+- [x] Statistics
+- [ ] Unified API Functions
+- [ ] Vector Algorithms

arrayfire_wrapper/__init__.py

@@ -7,8 +7,65 @@
 __all__ += ["__arrayfire_version__"]
 __arrayfire_version__ = ARRAYFIRE_VERSION
 
-__all__ += ["add"]
-from arrayfire_wrapper.lib.mathematical_functions import add
+__all__ += ["AFArray"]
+from .defines import AFArray
 
-__all__ += ["randu"]
-from arrayfire_wrapper.lib.create_and_modify_array import randu
+__all__ = [
+    "Dtype",
+    "b8",
+    "bool",
+    "c32",
+    "c64",
+    "complex32",
+    "complex64",
+    "f16",
+    "f32",
+    "f64",
+    "float16",
+    "float32",
+    "float64",
+    "int16",
+    "int32",
+    "int64",
+    "s16",
+    "s32",
+    "s64",
+    "u8",
+    "u16",
+    "u32",
+    "u64",
+    "uint8",
+    "uint16",
+    "uint32",
+    "uint64",
+]
+
+from .dtypes import (
+    Dtype,
+    b8,
+    bool,
+    c32,
+    c64,
+    complex32,
+    complex64,
+    f16,
+    f32,
+    f64,
+    float16,
+    float32,
+    float64,
+    int16,
+    int32,
+    int64,
+    s16,
+    s32,
+    s64,
+    u8,
+    u16,
+    u32,
+    u64,
+    uint8,
+    uint16,
+    uint32,
+    uint64,
+)

arrayfire_wrapper/backend.py arrayfire_wrapper/_backend.pyarrayfire_wrapper/backend.py renamed to arrayfire_wrapper/_backend.py

@@ -56,3 +56,11 @@ class Moment(Enum):
     M10 = 4
     M11 = 8
     FIRST_ORDER = M00 | M01 | M10 | M11
+
+
+class PointerSource(Enum):
+    """
+    Source of the pointer.
+    """
+    device = 0  # gpu
+    host = 1  # cpu

arrayfire_wrapper/defines.py

@@ -24,20 +24,19 @@ def __repr__(self) -> str:
 
 
 # Specification required
-int8 = Dtype("int8", "i8", ctypes.c_char, "int8", 4)  # HACK int8 - Not Supported, b8?
-int16 = Dtype("int16", "h", ctypes.c_short, "short int", 10)
-int32 = Dtype("int32", "i", ctypes.c_int, "int", 5)
-int64 = Dtype("int64", "l", ctypes.c_longlong, "long int", 8)
-uint8 = Dtype("uint8", "B", ctypes.c_ubyte, "unsigned_char", 7)
-uint16 = Dtype("uint16", "H", ctypes.c_ushort, "unsigned short int", 11)
-uint32 = Dtype("uint32", "I", ctypes.c_uint, "unsigned int", 6)
-uint64 = Dtype("uint64", "L", ctypes.c_ulonglong, "unsigned long int", 9)
-float16 = Dtype("float16", "e", ctypes.c_uint16, "half", 12)
-float32 = Dtype("float32", "f", ctypes.c_float, "float", 0)
-float64 = Dtype("float64", "d", ctypes.c_double, "double", 2)
-complex64 = Dtype("complex64", "F", ctypes.c_float * 2, "float complex", 1)  # type: ignore[arg-type]
-complex128 = Dtype("complex128", "D", ctypes.c_double * 2, "double complex", 3)  # type: ignore[arg-type]
-bool = Dtype("bool", "b", ctypes.c_bool, "bool", 4)
+int16 = s16 = Dtype("int16", "h", ctypes.c_short, "short int", 10)
+int32 = s32 = Dtype("int32", "i", ctypes.c_int, "int", 5)
+int64 = s64 = Dtype("int64", "l", ctypes.c_longlong, "long int", 8)
+uint8 = u8 = Dtype("uint8", "B", ctypes.c_ubyte, "unsigned_char", 7)
+uint16 = u16 = Dtype("uint16", "H", ctypes.c_ushort, "unsigned short int", 11)
+uint32 = u32 = Dtype("uint32", "I", ctypes.c_uint, "unsigned int", 6)
+uint64 = u64 = Dtype("uint64", "L", ctypes.c_ulonglong, "unsigned long int", 9)
+float16 = f16 = Dtype("float16", "e", ctypes.c_uint16, "half", 12)
+float32 = f32 = Dtype("float32", "f", ctypes.c_float, "float", 0)
+float64 = f64 = Dtype("float64", "d", ctypes.c_double, "double", 2)
+complex32 = c32 = Dtype("complex64", "F", ctypes.c_float * 2, "float complex", 1)  # type: ignore[arg-type]
+complex64 = c64 = Dtype("complex128", "D", ctypes.c_double * 2, "double complex", 3)  # type: ignore[arg-type]
+bool = b8 = Dtype("bool", "b", ctypes.c_bool, "bool", 4)
 
 supported_dtypes = (
     int16,
@@ -51,14 +50,26 @@ def __repr__(self) -> str:
     float32,
     float64,
     complex64,
-    complex128,
+    complex32,
     bool,
-    int8,  # BUG if place on top of the list
+    s16,
+    s32,
+    s64,
+    u8,
+    u16,
+    u32,
+    u64,
+    f16,
+    f32,
+    f64,
+    c32,
+    c64,
+    b8,
 )
 
 
 def is_complex_dtype(dtype: Dtype) -> _python_bool:
-    return dtype in {complex64, complex128}
+    return dtype in {complex32, complex64}
 
 
 def to_str(c_str: ctypes.c_char_p | ctypes.Array[ctypes.c_char]) -> str:
@@ -71,19 +82,19 @@ def implicit_dtype(number: int | float | _python_bool | complex, array_dtype: Dt
     elif isinstance(number, int):
         number_dtype = int64
     elif isinstance(number, float):
-        number_dtype = float64
+        number_dtype = float32
     elif isinstance(number, complex):
-        number_dtype = complex128
+        number_dtype = complex64
     else:
         raise TypeError(f"{type(number)} is not supported and can not be converted to af.Dtype.")
 
-    if not (array_dtype == float32 or array_dtype == complex64):
+    if not (array_dtype == float32 or array_dtype == complex32):
         return number_dtype
 
     if number_dtype == float64:
         return float32
 
-    if number_dtype == complex128:
+    if number_dtype == complex64:
         return complex64
 
     return number_dtype