"update local master branch"

Merge branch 'master' of https://github.com/arrayfire/arrayfire-binary-python-wrapper

Author: sakchal

arrayfire_wrapper/_backend.py

@@ -11,8 +11,6 @@
 from pathlib import Path
 from typing import Iterator
 
-from arrayfire_wrapper.defines import AFArray
-
 from .version import ARRAYFIRE_VER_MAJOR
 
 VERBOSE_LOADS = os.environ.get("AF_VERBOSE_LOADS", "") == "1"
@@ -37,7 +35,7 @@ def is_cygwin(cls, name: str) -> bool:
 class _BackendPathConfig:
     lib_prefix: str
     lib_postfix: str
-    af_path: Path
+    af_path: Path | None
     af_is_user_path: bool
     cuda_found: bool
 
@@ -175,7 +173,7 @@ def __iter__(self) -> Iterator:
 
 
 class Backend:
-    _backend_type: BackendType
+    _backend_type: BackendType | None
     _clibs: dict[BackendType, ctypes.CDLL]
 
     def __init__(self) -> None:
@@ -297,51 +295,17 @@ def _find_nvrtc_builtins_lib_name(self, search_path: Path) -> str | None:
                 return f.name
         return None
 
-    # unified backend functions
-    def get_active_backend(self) -> str:
-        if self._backend_type == BackendType.unified:
-            from arrayfire_wrapper.lib.unified_api_functions import get_active_backend as unified_get_active_backend
-
-            return unified_get_active_backend()
-        raise RuntimeError("Using unified function on non-unified backend")
-
-    def get_available_backends(self) -> list[int]:
-        if self._backend_type == BackendType.unified:
-            from arrayfire_wrapper.lib.unified_api_functions import (
-                get_available_backends as unified_get_available_backends,
-            )
-
-            return unified_get_available_backends()
-        raise RuntimeError("Using unified function on non-unified backend")
-
-    def get_backend_count(self) -> int:
-        if self._backend_type == BackendType.unified:
-            from arrayfire_wrapper.lib.unified_api_functions import get_backend_count as unified_get_backend_count
-
-            return unified_get_backend_count()
-        raise RuntimeError("Using unified function on non-unified backend")
-
-    def get_backend_id(self, arr: AFArray, /) -> int:
-        if self._backend_type == BackendType.unified:
-            from arrayfire_wrapper.lib.unified_api_functions import get_backend_id as unified_get_backend_id
-
-            return unified_get_backend_id(arr)
-        raise RuntimeError("Using unified function on non-unified backend")
-
-    def get_device_id(self, arr: AFArray, /) -> int:
-        if self._backend_type == BackendType.unified:
-            from arrayfire_wrapper.lib.unified_api_functions import get_device_id as unified_get_device_id
-
-            return unified_get_device_id(arr)
-        raise RuntimeError("Using unified function on non-unified backend")
-
     @property
     def backend_type(self) -> BackendType:
-        return self._backend_type
+        if self._backend_type:
+            return self._backend_type
+        raise RuntimeError("No valid _backend_type")
 
     @property
     def clib(self) -> ctypes.CDLL:
-        return self._clibs[self._backend_type]
+        if self._backend_type:
+            return self._clibs[self._backend_type]
+        raise RuntimeError("No valid _backend_type")
 
 
 # Initialize the backend

arrayfire_wrapper/lib/mathematical_functions/numeric_functions.py

@@ -1,16 +1,13 @@
 import ctypes
 
+import arrayfire_wrapper.dtypes as dtype
+import arrayfire_wrapper.lib as wrapper
 from arrayfire_wrapper.defines import AFArray
-from arrayfire_wrapper.dtypes import float32
 from arrayfire_wrapper.lib._utility import binary_op, call_from_clib, unary_op
 from arrayfire_wrapper.lib.create_and_modify_array.create_array import create_constant_array
 from arrayfire_wrapper.lib.mathematical_functions.arithmetic_operations import sub
 
 
-import arrayfire_wrapper.dtypes as dtype
-import arrayfire_wrapper.lib as wrapper
-
-
 def abs_(arr: AFArray, /) -> AFArray:
     """
     source: https://arrayfire.org/docs/group__arith__func__abs.htm#ga7e8b3c848e6cda3d1f3b0c8b2b4c3f8f

scripts/build_package_without_binaries.sh

@@ -1,15 +1,15 @@
 #!/bin/bash
 
-# Run the Python script and capture the output and error
+# Run the Python script and capture the output or error
 output=$(python -m build 2>&1)
 
-# Define the expected error message
-expected_error="Could not load any ArrayFire libraries."
+# Define the expected output message
+expected_output="Successfully built"
 
-# Check if the output contains the expected error message
-if echo "$output" | grep -q "$expected_error"; then
-  echo "Expected error received."
-  exit 0  # Exit with success as the error is expected
+# Check if the output contains the expected output message
+if echo "$output" | grep -q "$expected_output"; then
+  echo "Expected output received."
+  exit 0  # Exit with success as the output is expected
 else
   echo "Unexpected output: $output"
   exit 1  # Exit with failure as the output was not expected

tests/test_bitshift.py

@@ -0,0 +1,198 @@
+import pytest
+
+import arrayfire_wrapper.dtypes as dtype
+import arrayfire_wrapper.lib as wrapper
+from arrayfire_wrapper.lib.create_and_modify_array.helper_functions import array_to_string
+from tests.utility_functions import check_type_supported, get_real_types
+
+
+@pytest.mark.parametrize("dtype_name", get_real_types())
+def test_bitshiftl_dtypes(dtype_name: dtype.Dtype) -> None:
+    """Test bit shift operation across all supported data types."""
+    check_type_supported(dtype_name)
+    if dtype_name == dtype.f16 or dtype_name == dtype.f32:
+        pytest.skip()
+    shape = (5, 5)
+    values = wrapper.randu(shape, dtype_name)
+    bits_to_shift = wrapper.constant(1, shape, dtype_name)
+
+    result = wrapper.bitshiftl(values, bits_to_shift)
+
+    assert dtype.c_api_value_to_dtype(wrapper.get_type(result)) == dtype_name, f"Failed for dtype: {dtype_name}"
+
+
+@pytest.mark.parametrize(
+    "invdtypes",
+    [
+        dtype.c32,
+        dtype.f64,
+    ],
+)
+def test_bitshiftl_supported_dtypes(invdtypes: dtype.Dtype) -> None:
+    """Test bitshift operations for unsupported integer data types."""
+    shape = (5, 5)
+    with pytest.raises(RuntimeError):
+        value = wrapper.randu(shape, invdtypes)
+        bits_to_shift = wrapper.constant(1, shape, invdtypes)
+
+        result = wrapper.bitshiftl(value, bits_to_shift)
+        assert dtype.c_api_value_to_dtype(wrapper.get_type(result)) == invdtypes, f"Failed for dtype: {invdtypes}"
+
+
+@pytest.mark.parametrize("input_size", [8, 10, 12])
+def test_bitshiftl_varying_input_size(input_size: int) -> None:
+    """Test bitshift left operation with varying input sizes"""
+    shape = (input_size, input_size)
+    value = wrapper.randu(shape, dtype.int16)
+    shift_amount = wrapper.constant(1, shape, dtype.int16)  # Fixed shift amount for simplicity
+
+    result = wrapper.bitshiftl(value, shift_amount)
+
+    assert (wrapper.get_dims(result)[0], wrapper.get_dims(result)[1]) == shape
+
+
+@pytest.mark.parametrize(
+    "shape",
+    [
+        (10,),
+        (5, 5),
+        (2, 3, 4),
+    ],
+)
+def test_bitshiftl_varying_shapes(shape: tuple) -> None:
+    """Test left bit shifting with arrays of varying shapes."""
+    values = wrapper.randu(shape, dtype.int16)
+    bits_to_shift = wrapper.constant(1, shape, dtype.int16)
+
+    result = wrapper.bitshiftl(values, bits_to_shift)
+
+    assert wrapper.get_dims(result)[0 : len(shape)] == shape  # noqa
+
+
+@pytest.mark.parametrize("shift_amount", [-1, 0, 2, 30])
+def test_bitshift_left_varying_shift_amount(shift_amount: int) -> None:
+    """Test bitshift left operation with varying shift amounts."""
+    shape = (5, 5)
+    value = wrapper.randu(shape, dtype.int16)
+    shift_amount_arr = wrapper.constant(shift_amount, shape, dtype.int16)
+
+    result = wrapper.bitshiftl(value, shift_amount_arr)
+
+    assert (wrapper.get_dims(result)[0], wrapper.get_dims(result)[1]) == shape
+
+
+@pytest.mark.parametrize(
+    "shape_a, shape_b",
+    [
+        ((1, 5), (5, 1)),  # 2D with 2D inverse
+        ((5, 5), (5, 1)),  # 2D with 2D
+        ((5, 5), (1, 1)),  # 2D with 2D
+        ((1, 1, 1), (5, 5, 5)),  # 3D with 3D
+    ],
+)
+def test_bitshiftl_different_shapes(shape_a: tuple, shape_b: tuple) -> None:
+    """Test if left bit shifting handles arrays of different shapes"""
+    with pytest.raises(RuntimeError):
+        values = wrapper.randu(shape_a, dtype.int16)
+        bits_to_shift = wrapper.constant(1, shape_b, dtype.int16)
+        result = wrapper.bitshiftl(values, bits_to_shift)
+        print(array_to_string("", result, 3, False))
+        assert (
+            wrapper.get_dims(result)[0 : len(shape_a)] == shape_a  # noqa
+        ), f"Failed for shapes {shape_a} and {shape_b}"
+
+
+@pytest.mark.parametrize("shift_amount", [-1, 0, 2, 30])
+def test_bitshift_right_varying_shift_amount(shift_amount: int) -> None:
+    """Test bitshift right operation with varying shift amounts."""
+    shape = (5, 5)
+    value = wrapper.randu(shape, dtype.int16)
+    shift_amount_arr = wrapper.constant(shift_amount, shape, dtype.int16)
+
+    result = wrapper.bitshiftr(value, shift_amount_arr)
+
+    assert (wrapper.get_dims(result)[0], wrapper.get_dims(result)[1]) == shape
+
+
+@pytest.mark.parametrize("dtype_name", get_real_types())
+def test_bitshiftr_dtypes(dtype_name: dtype.Dtype) -> None:
+    """Test bit shift operation across all supported data types."""
+    check_type_supported(dtype_name)
+    if dtype_name == dtype.f16 or dtype_name == dtype.f32:
+        pytest.skip()
+    shape = (5, 5)
+    values = wrapper.randu(shape, dtype_name)
+    bits_to_shift = wrapper.constant(1, shape, dtype_name)
+
+    result = wrapper.bitshiftr(values, bits_to_shift)
+
+    assert dtype.c_api_value_to_dtype(wrapper.get_type(result)) == dtype_name, f"Failed for dtype: {dtype_name}"
+
+
+@pytest.mark.parametrize(
+    "invdtypes",
+    [
+        dtype.c32,
+        dtype.f64,
+    ],
+)
+def test_bitshiftr_supported_dtypes(invdtypes: dtype.Dtype) -> None:
+    """Test bitshift operations for unsupported integer data types."""
+    shape = (5, 5)
+    with pytest.raises(RuntimeError):
+        value = wrapper.randu(shape, invdtypes)
+        shift_amount = wrapper.constant(1, shape, invdtypes)
+
+        result = wrapper.bitshiftr(value, shift_amount)
+        assert dtype.c_api_value_to_dtype(wrapper.get_type(result)) == invdtypes, f"Failed for dtype: {invdtypes}"
+
+
+@pytest.mark.parametrize("input_size", [8, 10, 12])
+def test_bitshift_right_varying_input_size(input_size: int) -> None:
+    """Test bitshift right operation with varying input sizes"""
+    shape = (input_size, input_size)
+    value = wrapper.randu(shape, dtype.int16)
+    shift_amount = wrapper.constant(1, shape, dtype.int16)  # Fixed shift amount for simplicity
+
+    result = wrapper.bitshiftr(value, shift_amount)
+
+    assert (wrapper.get_dims(result)[0], wrapper.get_dims(result)[1]) == shape
+
+
+@pytest.mark.parametrize(
+    "shape",
+    [
+        (10,),
+        (5, 5),
+        (2, 3, 4),
+    ],
+)
+def test_bitshiftr_varying_shapes(shape: tuple) -> None:
+    """Test right bit shifting with arrays of varying shapes."""
+    values = wrapper.randu(shape, dtype.int16)
+    bits_to_shift = wrapper.constant(1, shape, dtype.int16)
+
+    result = wrapper.bitshiftr(values, bits_to_shift)
+
+    assert wrapper.get_dims(result)[0 : len(shape)] == shape  # noqa
+
+
+@pytest.mark.parametrize(
+    "shape_a, shape_b",
+    [
+        ((1, 5), (5, 1)),  # 2D with 2D inverse
+        ((5, 5), (5, 1)),  # 2D with 2D
+        ((5, 5), (1, 1)),  # 2D with 2D
+        ((1, 1, 1), (5, 5, 5)),  # 3D with 3D
+    ],
+)
+def test_bitshiftr_different_shapes(shape_a: tuple, shape_b: tuple) -> None:
+    """Test if right bit shifting handles arrays of different shapes"""
+    with pytest.raises(RuntimeError):
+        values = wrapper.randu(shape_a, dtype.int16)
+        bits_to_shift = wrapper.constant(1, shape_b, dtype.int16)
+        result = wrapper.bitshiftr(values, bits_to_shift)
+        print(array_to_string("", result, 3, False))
+        assert (
+            wrapper.get_dims(result)[0 : len(shape_a)] == shape_a  # noqa
+        ), f"Failed for shapes {shape_a} and {shape_b}"