Fix/missing functions (#11)

* Fix and update tags

* Add signals

* Fix minor bugs

Author: roaffix

README.md

@@ -15,7 +15,7 @@ Arrayfire python C library wrapper
 - [x] Linear Algebra
 - [x] Machine Learning
 - [x] Mathematical Functions
-- [ ] Signal Processing
+- [x] Signal Processing
 - [x] Statistics
 - [x] Unified API Functions
 - [x] Vector Algorithms

arrayfire_wrapper/_backend.py

@@ -10,10 +10,11 @@
 from pathlib import Path
 from typing import Iterator
 
-from ._logger import logger
 from .defines import is_arch_x86
 from .version import ARRAYFIRE_VER_MAJOR
 
+VERBOSE_LOADS = os.environ.get("AF_VERBOSE_LOADS", "") == "1"
+
 
 class _LibPrefixes(Enum):
     forge = ""
@@ -120,10 +121,6 @@ def __iter__(self) -> Iterator:
 
 class Backend:
     _backend_type: BackendType
-    # HACK for osx
-    # _backend.clib = ctypes.CDLL("/opt/arrayfire//lib/libafcpu.3.dylib")
-    # HACK for windows
-    # _backend.clib = ctypes.CDLL("C:/Program Files/ArrayFire/v3/lib/afcpu.dll")
     _clib: ctypes.CDLL
 
     def __init__(self) -> None:
@@ -136,18 +133,21 @@ def _load_forge_lib(self) -> None:
         for lib_name in self._lib_names("forge", _LibPrefixes.forge):
             try:
                 ctypes.cdll.LoadLibrary(str(lib_name))
-                logger.info(f"Loaded {lib_name}")
+                if VERBOSE_LOADS:
+                    print(f"Loaded {lib_name}")
                 break
             except OSError:
-                logger.warning(f"Unable to load {lib_name}")
+                if VERBOSE_LOADS:
+                    print(f"Unable to load {lib_name}")
                 pass
 
     def _load_backend_libs(self) -> None:
         for backend_type in BackendType:
             self._load_backend_lib(backend_type)
 
             if self._backend_type:
-                logger.info(f"Setting {backend_type.name} as backend.")
+                if VERBOSE_LOADS:
+                    print(f"Setting {backend_type.name} as backend.")
                 break
 
         if not self._backend_type and not self._clib:
@@ -169,19 +169,23 @@ def _load_backend_lib(self, _backend_type: BackendType) -> None:
                 if _backend_type == BackendType.cuda:
                     self._load_nvrtc_builtins_lib(lib_name.parent)
 
-                logger.info(f"Loaded {lib_name}")
+                if VERBOSE_LOADS:
+                    print(f"Loaded {lib_name}")
                 break
             except OSError:
-                logger.warning(f"Unable to load {lib_name}")
+                if VERBOSE_LOADS:
+                    print(f"Unable to load {lib_name}")
                 pass
 
     def _load_nvrtc_builtins_lib(self, lib_path: Path) -> None:
         nvrtc_name = self._find_nvrtc_builtins_lib_name(lib_path)
         if nvrtc_name:
             ctypes.cdll.LoadLibrary(str(lib_path / nvrtc_name))
-            logger.info(f"Loaded {lib_path / nvrtc_name}")
+            if VERBOSE_LOADS:
+                print(f"Loaded {lib_path / nvrtc_name}")
         else:
-            logger.warning("Could not find local nvrtc-builtins library")
+            if VERBOSE_LOADS:
+                print("Could not find local nvrtc-builtins library")
 
     def _lib_names(self, name: str, lib: _LibPrefixes, ver_major: str | None = None) -> list[Path]:
         post = self._backend_path_config.lib_postfix if ver_major is None else ver_major

arrayfire_wrapper/_logger.py

@@ -87,14 +87,12 @@ def implicit_dtype(number: int | float | _python_bool | complex, array_dtype: Dt
     if array_dtype not in supported_dtypes:
         raise ValueError(f"{array_dtype} is not in supported dtypes.")
 
-    if not (array_dtype == float32 or array_dtype == complex32):
-        return number_dtype
+    _a32 = array_dtype == float32 or array_dtype == complex32
 
-    # FIXME
-    # if number_dtype == float64:
-    #     return float32
+    if number_dtype == float64 and _a32:
+        return float32
 
-    if number_dtype == complex64:
+    if number_dtype == complex64 and _a32:
         return complex64
 
     return number_dtype

arrayfire_wrapper/dtypes.py

@@ -803,6 +803,98 @@
     var_weighted,
 )
 
+# Signal Processing
+
+__all__ += [
+    "convolve1",
+    "convolve2",
+    "convolve2_nn",
+    "convolve2_sep",
+    "convolve3",
+    "fft_convolve1",
+    "fft_convolve2",
+    "fft_convolve3",
+]
+
+from .signal_processing.convolutions import (
+    convolve1,
+    convolve2,
+    convolve2_nn,
+    convolve2_sep,
+    convolve3,
+    fft_convolve1,
+    fft_convolve2,
+    fft_convolve3,
+)
+
+__all__ += [
+    "fft",
+    "fft2",
+    "fft2_c2r",
+    "fft2_inplace",
+    "fft2_r2c",
+    "fft3",
+    "fft3_c2r",
+    "fft3_inplace",
+    "fft3_r2c",
+    "fft_c2r",
+    "fft_inplace",
+    "fft_r2c",
+    "ifft",
+    "ifft2",
+    "ifft2_inplace",
+    "ifft3",
+    "ifft3_inplace",
+    "ifft_inplace",
+]
+
+from .signal_processing.fast_fourier_transforms import (
+    fft,
+    fft2,
+    fft2_c2r,
+    fft2_inplace,
+    fft2_r2c,
+    fft3,
+    fft3_c2r,
+    fft3_inplace,
+    fft3_r2c,
+    fft_c2r,
+    fft_inplace,
+    fft_r2c,
+    ifft,
+    ifft2,
+    ifft2_inplace,
+    ifft3,
+    ifft3_inplace,
+    ifft_inplace,
+)
+
+__all__ += ["fir", "iir"]
+
+from .signal_processing.filter import fir, iir
+
+__all__ += [
+    "approx1",
+    "approx1_uniform",
+    "approx1_uniform_v2",
+    "approx1_v2",
+    "approx2",
+    "approx2_uniform",
+    "approx2_uniform_v2",
+    "approx2_v2",
+]
+
+from .signal_processing.interpolation_and_approximation import (
+    approx1,
+    approx1_uniform,
+    approx1_uniform_v2,
+    approx1_v2,
+    approx2,
+    approx2_uniform,
+    approx2_uniform_v2,
+    approx2_v2,
+)
+
 # Unified API functions
 
 __all__ += [
@@ -831,8 +923,6 @@
 
 # Constants
 
-# TODO change and use as reimport from file where it is used
-
 __all__ += ["Match", "Moment", "Pad", "PointerSource", "TopK", "VarianceBias"]
 
 from ._constants import Match, Moment, Pad, PointerSource, TopK, VarianceBias

arrayfire_wrapper/lib/__init__.py

@@ -18,13 +18,24 @@ class Connectivity(Enum):  # Neighbourhood connectivity
     EIGHT = 8
 
 
+class ConvDomain(Enum):  # Convolution domain
+    AUTO = 0
+    SPATIAL = 1
+    FREQ = 2
+
+
 class ConvGradient(Enum):  # Convolution Gradient Types
     DEFAULT = 0
     FILTER = 1
     DATA = 2
     BIAS = 3
 
 
+class ConvMode(Enum):  # Convolution output formats
+    DEFAULT = 0
+    EXPAND = 1
+
+
 class CSpace(Enum):  # Colorspace formats
     GRAY = 0
     RGB = 1

arrayfire_wrapper/lib/_constants.py

@@ -203,7 +203,7 @@ def __init__(self, idx: Any) -> None:
         self.isBatch = False
         self.isSeq = True
 
-        # FIXME cyclic reimport
+        # BUG cyclic reimport
         # if isinstance(idx, Array):
         #     if idx.dtype == af_bool:
         #         self.idx.arr = everything.where(idx.arr)

arrayfire_wrapper/lib/create_and_modify_array/assignment_and_indexing/_indexing.py

@@ -4,8 +4,6 @@
 from arrayfire_wrapper.defines import AFArray, CDimT
 from arrayfire_wrapper.lib._utility import call_from_clib
 
-# TODO unfinished module
-
 
 def index_gen(arr: AFArray, ndims: int, indices: Any, /) -> AFArray:
     """

arrayfire_wrapper/lib/create_and_modify_array/assignment_and_indexing/index.py

@@ -1,6 +1,16 @@
-from arrayfire_wrapper.defines import AFArray
+import ctypes
 
+from arrayfire_wrapper.defines import AFArray, CShape
+from arrayfire_wrapper.dtypes import Dtype
+from arrayfire_wrapper.lib._utility import call_from_clib
 
-def iota() -> AFArray:
-    # TODO
-    return NotImplemented
+
+def iota(shape: tuple[int, ...], t_shape: tuple[int, ...], dtype: Dtype, /) -> AFArray:
+    """
+    source: https://arrayfire.org/docs/group__data__func__iota.htm#ga032c10a9bbd3cf051f711bfea1dea65c
+    """
+    out = AFArray.create_null_pointer()
+    c_shape = CShape(*shape)
+    t_c_shape = CShape(*t_shape)
+    call_from_clib(iota.__name__, ctypes.pointer(out), 4, c_shape.c_array, 4, t_c_shape.c_array, dtype.c_api_value)
+    return out

arrayfire_wrapper/lib/create_and_modify_array/create_array/iota.py

@@ -1,9 +1,25 @@
-from arrayfire_wrapper.defines import AFArray
+import ctypes
 
+from arrayfire_wrapper.defines import AFArray, CShape
+from arrayfire_wrapper.lib._constants import Pad
+from arrayfire_wrapper.lib._utility import call_from_clib
 
-def pad() -> AFArray:
+
+def pad(arr: AFArray, begin_shape: tuple[int, ...], end_shape: tuple[int, ...], border_type: Pad) -> AFArray:
     """
     source: https://arrayfire.org/docs/group__data__func__pad.htm#gabe75c767e4e89f82a4e5864bf6e1ef15
     """
-    # TODO
+    out = AFArray.create_null_pointer()
+    begin_c_shape = CShape(*begin_shape)
+    end_c_shape = CShape(*end_shape)
+    call_from_clib(
+        pad.__name__,
+        ctypes.pointer(out),
+        arr,
+        4,
+        begin_c_shape.c_array,
+        4,
+        end_c_shape.c_array,
+        border_type.value,
+    )
     return NotImplemented