Replace dim4 with CShape

Author: roaffix

arrayfire/array_api/__init__.py

@@ -6,5 +6,4 @@
     "complex64", "complex128", "bool"]
 
 from ._array_object import Array
-from ._dtypes import (
-    bool, complex64, complex128, float32, float64, int16, int32, int64, uint8, uint16, uint32, uint64)
+from ._dtypes import bool, complex64, complex128, float32, float64, int16, int32, int64, uint8, uint16, uint32, uint64

arrayfire/array_api/_array_object.py

@@ -2,13 +2,12 @@
 
 import array as py_array
 import ctypes
-import math
 from dataclasses import dataclass
 
 from arrayfire import backend, safe_call  # TODO refactoring
 from arrayfire.array import _in_display_dims_limit  # TODO refactoring
 
-from ._dtypes import Dtype, c_dim_t, float32, supported_dtypes
+from ._dtypes import CShape, Dtype, c_dim_t, float32, supported_dtypes
 from ._utils import Device, PointerSource, to_str
 
 ShapeType = tuple[None | int, ...]
@@ -28,7 +27,6 @@ class Array:
     __array_priority__ = 30
 
     # Initialisation
-    _array_buffer = _ArrayBuffer()
     arr = ctypes.c_void_p(0)
 
     def __init__(
@@ -46,12 +44,12 @@ def __init__(
         if x is None:
             if not shape:  # shape is None or empty tuple
                 safe_call(backend.get().af_create_handle(
-                    ctypes.pointer(self.arr), 0, ctypes.pointer(dim4()), dtype.c_api_value))
+                    ctypes.pointer(self.arr), 0, ctypes.pointer(CShape().c_array), dtype.c_api_value))
                 return
 
             # NOTE: applies inplace changes for self.arr
             safe_call(backend.get().af_create_handle(
-                ctypes.pointer(self.arr), len(shape), ctypes.pointer(dim4(*shape)), dtype.c_api_value))
+                ctypes.pointer(self.arr), len(shape), ctypes.pointer(CShape(*shape).c_array), dtype.c_api_value))
             return
 
         if isinstance(x, Array):
@@ -61,19 +59,16 @@ def __init__(
         if isinstance(x, py_array.array):
             _type_char = x.typecode
             _array_buffer = _ArrayBuffer(*x.buffer_info())
-            numdims, idims = _get_info(shape, _array_buffer.length)
 
         elif isinstance(x, list):
             _array = py_array.array("f", x)  # BUG [True, False] -> dtype: f32   # TODO add int and float
             _type_char = _array.typecode
             _array_buffer = _ArrayBuffer(*_array.buffer_info())
-            numdims, idims = _get_info(shape, _array_buffer.length)
 
         elif isinstance(x, int) or isinstance(x, ctypes.c_void_p):  # TODO
             _array_buffer = _ArrayBuffer(x if not isinstance(x, ctypes.c_void_p) else x.value)
-            numdims, idims = _get_info(shape, _array_buffer.length)
 
-            if not math.prod(idims):
+            if not shape:
                 raise RuntimeError("Expected to receive the initial shape due to the x being a data pointer.")
 
             if _no_initial_dtype:
@@ -84,34 +79,37 @@ def __init__(
         else:
             raise TypeError("Passed object x is an object of unsupported class.")
 
+        _cshape = _get_cshape(shape, _array_buffer.length)
+
         if not _no_initial_dtype and dtype.typecode != _type_char:
             raise TypeError("Can not create array of requested type from input data type")
 
         if not (offset or strides):
             if pointer_source == PointerSource.host:
                 safe_call(backend.get().af_create_array(
-                    ctypes.pointer(self.arr), ctypes.c_void_p(_array_buffer.address), numdims,
-                    ctypes.pointer(dim4(*idims)), dtype.c_api_value))
+                    ctypes.pointer(self.arr), ctypes.c_void_p(_array_buffer.address), _cshape.original_shape,
+                    ctypes.pointer(_cshape.c_array), dtype.c_api_value))
                 return
 
             safe_call(backend.get().af_device_array(
-                ctypes.pointer(self.arr), ctypes.c_void_p(_array_buffer.address), numdims,
-                ctypes.pointer(dim4(*idims)), dtype.c_api_value))
+                ctypes.pointer(self.arr), ctypes.c_void_p(_array_buffer.address), _cshape.original_shape,
+                ctypes.pointer(_cshape.c_array), dtype.c_api_value))
             return
 
-        if offset is None:  # TODO
+        if offset is None:
             offset = c_dim_t(0)
 
-        if strides is None:  # TODO
-            strides = (1, idims[0], idims[0]*idims[1], idims[0]*idims[1]*idims[2])
+        if strides is None:
+            strides = (1, _cshape[0], _cshape[0]*_cshape[1], _cshape[0]*_cshape[1]*_cshape[2])
 
         if len(strides) < 4:
             strides += (strides[-1], ) * (4 - len(strides))
-        strides_dim4 = dim4(*strides)
+        strides_cshape = CShape(*strides).c_array
 
         safe_call(backend.get().af_create_strided_array(
-            ctypes.pointer(self.arr), ctypes.c_void_p(_array_buffer.address), offset, numdims,
-            ctypes.pointer(dim4(*idims)), ctypes.pointer(strides_dim4), dtype.c_api_value, pointer_source.value))
+            ctypes.pointer(self.arr), ctypes.c_void_p(_array_buffer.address), offset, _cshape.original_shape,
+            ctypes.pointer(_cshape.c_array), ctypes.pointer(strides_cshape), dtype.c_api_value,
+            pointer_source.value))
 
     def __str__(self) -> str:  # FIXME
         if not _in_display_dims_limit(self.shape):
@@ -126,7 +124,7 @@ def __len__(self) -> int:
         return self.shape[0] if self.shape else 0  # type: ignore[return-value]
 
     def __pos__(self) -> Array:
-        """y
+        """
         Return +self
         """
         return self
@@ -190,8 +188,7 @@ def shape(self) -> ShapeType:
         d3 = c_dim_t(0)
         safe_call(backend.get().af_get_dims(
             ctypes.pointer(d0), ctypes.pointer(d1), ctypes.pointer(d2), ctypes.pointer(d3), self.arr))
-        dims = (d0.value, d1.value, d2.value, d3.value)
-        return dims[:self.ndim]  # FIXME An array dimension must be None if and only if a dimension is unknown
+        return (d0.value, d1.value, d2.value, d3.value)[:self.ndim]  # Skip passing None values
 
     def _as_str(self) -> str:
         arr_str = ctypes.c_char_p(0)
@@ -201,30 +198,6 @@ def _as_str(self) -> str:
         safe_call(backend.get().af_free_host(arr_str))
         return py_str
 
-    # def _get_metadata_str(self, show_dims: bool = True) -> str:
-    #     return (
-    #         "arrayfire.Array()\n"
-    #         f"Type: {self.dtype.typename}\n"
-    #         f"Dims: {str(self._dims) if show_dims else ''}")
-
-    # @property
-    # def dtype(self) -> ...:
-    #     dty = ctypes.c_int()
-    #     safe_call(backend.get().af_get_type(ctypes.pointer(dty), self.arr))  # -> new dty
-
-# @safe_call
-# def backend()
-#     ...
-
-# @backend(safe=True)
-# def af_get_type(arr) -> ...:
-#     dty = ctypes.c_int()
-#     safe_call(backend.get().af_get_type(ctypes.pointer(dty), self.arr)) # -> new dty
-#     return dty
-
-# def new_dtype():
-#     return af_get_type(self.arr)
-
 
 def _metadata_string(dtype: Dtype, dims: None | ShapeType = None) -> str:
     return (
@@ -233,20 +206,14 @@ def _metadata_string(dtype: Dtype, dims: None | ShapeType = None) -> str:
         f"Dims: {str(dims) if dims else ''}")
 
 
-def _get_info(shape: None | tuple[int], buffer_length: int) -> tuple[int, list[int]]:
-    # TODO refactor
+def _get_cshape(shape: None | tuple[int], buffer_length: int) -> CShape:
     if shape:
-        numdims = len(shape)
-        idims = [1]*4
-        for i in range(numdims):
-            idims[i] = shape[i]
-    elif (buffer_length != 0):
-        idims = [buffer_length, 1, 1, 1]
-        numdims = 1
-    else:
-        raise RuntimeError("Invalid size")
+        return CShape(*shape)
+
+    if buffer_length != 0:
+        return CShape(buffer_length)
 
-    return numdims, idims
+    raise RuntimeError("Shape and buffer length are size invalid.")
 
 
 def _c_api_value_to_dtype(value: int) -> Dtype:
@@ -282,16 +249,6 @@ def _str_to_dtype(value: int) -> Dtype:
 #     return out
 
 
-def dim4(d0: int = 1, d1: int = 1, d2: int = 1, d3: int = 1):  # type: ignore # FIXME
-    c_dim4 = c_dim_t * 4  # ctypes.c_int | ctypes.c_longlong * 4
-    out = c_dim4(1, 1, 1, 1)
-
-    for i, dim in enumerate((d0, d1, d2, d3)):
-        if dim is not None:
-            out[i] = c_dim_t(dim)
-
-    return out
-
 # TODO replace candidate below
 # def dim4_to_tuple(shape: ShapeType, default: int=1) -> ShapeType:
 #     assert(isinstance(dims, tuple))

arrayfire/array_api/_dtypes.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import ctypes
 from dataclasses import dataclass
 from typing import Type
@@ -31,6 +33,39 @@ class Dtype:
 bool = Dtype("b", ctypes.c_bool, "bool", 4)
 
 supported_dtypes = [
-    # int8,
     int16, int32, int64, uint8, uint16, uint32, uint64, float32, float64, complex64, complex128, bool
 ]
+
+
+class CShape(tuple):
+    def __new__(cls, *args: int) -> CShape:
+        cls.original_shape = len(args)
+        return tuple.__new__(cls, args)
+
+    def __init__(self, x1: int = 1, x2: int = 1, x3: int = 1, x4: int = 1) -> None:
+        self.x1 = x1
+        self.x2 = x2
+        self.x3 = x3
+        self.x4 = x4
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}{self.x1, self.x2, self.x3, self.x4}"
+
+    @property
+    def c_array(self):  # type: ignore[no-untyped-def]
+        c_shape = c_dim_t * 4  # ctypes.c_int | ctypes.c_longlong * 4
+        return c_shape(c_dim_t(self.x1), c_dim_t(self.x2), c_dim_t(self.x3), c_dim_t(self.x4))
+
+
+# @safe_call
+# def backend()
+#     ...
+
+# @backend(safe=True)
+# def af_get_type(arr) -> ...:
+#     dty = ctypes.c_int()
+#     safe_call(backend.get().af_get_type(ctypes.pointer(dty), self.arr)) # -> new dty
+#     return dty
+
+# def new_dtype():
+#     return af_get_type(self.arr)

arrayfire/array_api/pytest.ini

@@ -0,0 +1,4 @@
+[pytest]
+addopts = --cache-clear --cov=./arrayfire/array_api --flake8 --mypy --isort ./arrayfire/array_api
+console_output_style = classic
+markers = mypy

arrayfire/array_api/tests/test_array.py

@@ -1,3 +1,5 @@
+import pytest
+
 from arrayfire.array_api import Array, float32
 
 
@@ -9,3 +11,18 @@ def test_empty_array() -> None:
     assert array.size == 0
     assert array.shape == ()
     assert len(array) == 0
+
+
+def test_array_from_1d_list() -> None:
+    array = Array([1, 2, 3])
+
+    assert array.dtype == float32
+    assert array.ndim == 1
+    assert array.size == 3
+    assert array.shape == (3,)
+    assert len(array) == 3
+
+
+def test_array_from_2d_list() -> None:
+    with pytest.raises(TypeError):
+        Array([[1, 2, 3], [1, 2, 3]])