Merge branch 'master' into update-dpnp-fix

Author: Vahid Tavanashad

.github/workflows/check-mkl-interfaces.yaml

@@ -48,7 +48,7 @@ jobs:
 
       - name: Merge conda env files
         run: |
-          conda-merge ${{ env.build-with-oneapi-env }} ${{ env.dpctl-pkg-env }} ${{ env.oneapi-pkgs-env }} > ${{ env.environment-file }}
+          conda-merge ${{ env.dpctl-pkg-env }} ${{ env.oneapi-pkgs-env }} ${{ env.build-with-oneapi-env }} > ${{ env.environment-file }}
           cat ${{ env.environment-file }}
 
       - name: Upload artifact

.github/workflows/conda-package.yml

@@ -93,13 +93,13 @@ jobs:
         continue-on-error: true
         run: conda build --no-test --python ${{ matrix.python }} --numpy 2.0 ${{ env.channels-list }} conda-recipe
         env:
-          MAX_BUILD_CMPL_MKL_VERSION: '2025.1a0'
+          MAX_BUILD_CMPL_MKL_VERSION: '2025.2a0'
 
       - name: ReBuild conda package
         if: steps.build_conda_pkg.outcome == 'failure'
         run: conda build --no-test --python ${{ matrix.python }} --numpy 2.0 ${{ env.channels-list }} conda-recipe
         env:
-          MAX_BUILD_CMPL_MKL_VERSION: '2025.1a0'
+          MAX_BUILD_CMPL_MKL_VERSION: '2025.2a0'
 
       - name: Upload artifact
         uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2

CHANGELOG.md

@@ -15,15 +15,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
-* Extended `dpnp.fft.fftfreq` and `dpnp.fft.rfftfreq` functions to support `dtype` keyword per Python Array API spec 2024.12 [#2384](https://github.com/IntelPython/dpnp/pull/2384)
+* Improved performance of `dpnp.nansum`, `dpnp.nanprod`, `dpnp.nancumsum`, and `dpnp.nancumprod` by reusing `dpnp.nan_to_num` function in implementation of the functions [#2339](https://github.com/IntelPython/dpnp/pull/2339)
 * Allowed input array of `uint64` dtype in `dpnp.bincount` [#2361](https://github.com/IntelPython/dpnp/pull/2361)
 * The vector norms `ord={None, 1, 2, inf}` and the matrix norms `ord={None, 1, 2, inf, "fro", "nuc"}` now consistently return zero for empty arrays, which are arrays with at least one axis of size zero. This change affects `dpnp.linalg.norm`, `dpnp.linalg.vector_norm`, and `dpnp.linalg.matrix_norm`. Previously, dpnp would either raise errors or return zero depending on the parameters provided [#2371](https://github.com/IntelPython/dpnp/pull/2371)
-* Improved performance of `dpnp.nansum`, `dpnp.nanprod`, `dpnp.nancumsum`, and `dpnp.nancumprod` by reusing `dpnp.nan_to_num` function in implementation of the functions [#2339](https://github.com/IntelPython/dpnp/pull/2339)
+* Extended `dpnp.fft.fftfreq` and `dpnp.fft.rfftfreq` functions to support `dtype` keyword per Python Array API spec 2024.12 [#2384](https://github.com/IntelPython/dpnp/pull/2384)
 * Updated `dpnp.fix` to return output with the same data-type of input [#2392](https://github.com/IntelPython/dpnp/pull/2392)
 
 ### Fixed
 
 * Resolved an issue with an incorrect result returned due to missing dependency from the strided kernel on a copy event in `dpnp.erf` [#2378](https://github.com/IntelPython/dpnp/pull/2378)
+* Updated `conda create` commands build and install instructions of `Quick start guide` to avoid a compilation error [#2395](https://github.com/IntelPython/dpnp/pull/2395)
 
 
 ## [0.17.0] - 02/26/2025

doc/quick_start_guide.rst

@@ -88,14 +88,18 @@ On Linux:
 
 .. code-block:: bash
 
-    conda create -n build-env dpctl cython dpcpp_linux-64 mkl-devel-dpcpp tbb-devel onedpl-devel cmake scikit-build ninja pytest -c https://software.repos.intel.com/python/conda/ -c conda-forge
+    conda create -n build-env dpctl cython dpcpp_linux-64 mkl-devel-dpcpp tbb-devel \
+          onedpl-devel cmake scikit-build ninja pytest intel-gpu-ocl-icd-system     \
+          -c dppy/label/dev -c https://software.repos.intel.com/python/conda/ -c conda-forge
     conda activate build-env
 
 On Windows:
 
 .. code-block:: bash
 
-    conda create -n build-env dpctl cython dpcpp_win-64 mkl-devel-dpcpp tbb-devel onedpl-devel cmake scikit-build ninja pytest -c https://software.repos.intel.com/python/conda/ -c conda-forge
+    conda create -n build-env dpctl cython dpcpp_win-64 mkl-devel-dpcpp tbb-devel \
+          onedpl-devel cmake scikit-build ninja pytest intel-gpu-ocl-icd-system   \
+          -c dppy/label/dev -c https://software.repos.intel.com/python/conda/ -c conda-forge
     conda activate build-env
 
 To build and install the package on Linux OS, run:

dpnp/dpnp_iface_types.py

@@ -32,16 +32,25 @@
 This module provides public type interface file for the library
 """
 
+import functools
+
+import dpctl
 import dpctl.tensor as dpt
 import numpy
 
+import dpnp
+
 from .dpnp_array import dpnp_array
 
+# pylint: disable=no-name-in-module
+from .dpnp_utils import get_usm_allocations
+
 __all__ = [
     "bool",
     "bool_",
     "byte",
     "cdouble",
+    "common_type",
     "complex128",
     "complex64",
     "complexfloating",
@@ -145,6 +154,67 @@
 pi = numpy.pi
 
 
+def common_type(*arrays):
+    """
+    Return a scalar type which is common to the input arrays.
+
+    The return type will always be an inexact (i.e. floating point or complex)
+    scalar type, even if all the arrays are integer arrays.
+    If one of the inputs is an integer array, the minimum precision type
+    that is returned is the default floating point data type for the device
+    where the input arrays are allocated.
+
+    For full documentation refer to :obj:`numpy.common_type`.
+
+    Parameters
+    ----------
+    arrays: {dpnp.ndarray, usm_ndarray}
+        Input arrays.
+
+    Returns
+    -------
+    out: data type
+        Data type object.
+
+    See Also
+    --------
+    :obj:`dpnp.dtype` : Create a data type object.
+
+    Examples
+    --------
+    >>> import dpnp as np
+    >>> np.common_type(np.arange(2, dtype=np.float32))
+    numpy.float32
+    >>> np.common_type(np.arange(2, dtype=np.float32), np.arange(2))
+    numpy.float64 # may vary
+    >>> np.common_type(np.arange(4), np.array([45, 6.j]), np.array([45.0]))
+    numpy.complex128 # may vary
+
+    """
+
+    if len(arrays) == 0:
+        return (
+            dpnp.float16
+            if dpctl.select_default_device().has_aspect_fp16
+            else dpnp.float32
+        )
+
+    dpnp.check_supported_arrays_type(*arrays)
+
+    _, exec_q = get_usm_allocations(arrays)
+    default_float_dtype = dpnp.default_float_type(sycl_queue=exec_q)
+    dtypes = []
+    for a in arrays:
+        if not dpnp.issubdtype(a.dtype, dpnp.number):
+            raise TypeError("can't get common type for non-numeric array")
+        if dpnp.issubdtype(a.dtype, dpnp.integer):
+            dtypes.append(default_float_dtype)
+        else:
+            dtypes.append(a.dtype)
+
+    return functools.reduce(numpy.promote_types, dtypes).type
+
+
 # pylint: disable=redefined-outer-name
 def finfo(dtype):
     """

dpnp/fft/dpnp_iface_fft.py

@@ -38,11 +38,7 @@
 
 import dpnp
 
-from .dpnp_utils_fft import (
-    dpnp_fft,
-    dpnp_fftn,
-    dpnp_fillfreq,
-)
+from .dpnp_utils_fft import dpnp_fft, dpnp_fftn, dpnp_fillfreq, swap_direction
 
 __all__ = [
     "fft",
@@ -66,24 +62,6 @@
 ]
 
 
-_SWAP_DIRECTION_MAP = {
-    "backward": "forward",
-    None: "forward",
-    "ortho": "ortho",
-    "forward": "backward",
-}
-
-
-def _swap_direction(norm):
-    try:
-        return _SWAP_DIRECTION_MAP[norm]
-    except KeyError:
-        raise ValueError(
-            f'Invalid norm value {norm}; should be None, "backward", '
-            '"ortho" or "forward".'
-        ) from None
-
-
 def fft(a, n=None, axis=-1, norm=None, out=None):
     """
     Compute the one-dimensional discrete Fourier Transform.
@@ -644,7 +622,7 @@ def hfft(a, n=None, axis=-1, norm=None, out=None):
 
     """
 
-    new_norm = _swap_direction(norm)
+    new_norm = swap_direction(norm)
     return irfft(dpnp.conjugate(a), n=n, axis=axis, norm=new_norm, out=out)
 
 
@@ -1073,7 +1051,7 @@ def ihfft(a, n=None, axis=-1, norm=None, out=None):
 
     """
 
-    new_norm = _swap_direction(norm)
+    new_norm = swap_direction(norm)
     res = rfft(a, n=n, axis=axis, norm=new_norm, out=out)
     return dpnp.conjugate(res, out=out)
 

dpnp/fft/dpnp_utils_fft.py

@@ -57,11 +57,7 @@
     _standardize_strides_to_nonzero,
 )
 
-__all__ = [
-    "dpnp_fft",
-    "dpnp_fftn",
-    "dpnp_fillfreq",
-]
+__all__ = ["dpnp_fft", "dpnp_fftn", "dpnp_fillfreq", "swap_direction"]
 
 
 def _check_norm(norm):
@@ -584,7 +580,6 @@ def dpnp_fft(a, forward, real, n=None, axis=-1, norm=None, out=None):
     if n < 1:
         raise ValueError(f"Invalid number of FFT data points ({n}) specified")
 
-    _check_norm(norm)
     a = _truncate_or_pad(a, (n,), (axis,))
     _validate_out_keyword(a, out, (n,), (axis,), c2c, c2r, r2c)
     # if input array is copied, in-place FFT can be used
@@ -714,3 +709,17 @@ def dpnp_fillfreq(a, m, n, val):
     ht_lin_ev, lin_ev = ti._linspace_step(m - n, 1, a[m:].get_array(), exec_q)
     _manager.add_event_pair(ht_lin_ev, lin_ev)
     return a * val
+
+
+def swap_direction(norm):
+    """Swap the direction of the FFT."""
+
+    _check_norm(norm)
+    _swap_direction_map = {
+        "backward": "forward",
+        None: "forward",
+        "ortho": "ortho",
+        "forward": "backward",
+    }
+
+    return _swap_direction_map[norm]

dpnp/tests/test_fft.py

@@ -14,6 +14,7 @@
     get_all_dtypes,
     get_complex_dtypes,
     get_float_dtypes,
+    has_support_aspect16,
 )
 
 
@@ -926,6 +927,16 @@ def test_rfft_1D_on_2D_array_out(self, dtype, n, axis, norm, order):
         expected = numpy.fft.rfft(a_np, n=n, axis=axis, norm=norm)
         assert_dtype_allclose(result, expected, check_only_type_kind=True)
 
+    @pytest.mark.skipif(not has_support_aspect16(), reason="no fp16 support")
+    def test_float16(self):
+        a = numpy.arange(10, dtype=numpy.float16)
+        ia = dpnp.array(a)
+
+        expected = numpy.fft.rfft(a)
+        result = dpnp.fft.rfft(ia)
+        # check_only_type_kind=True since Intel NumPy returns complex128
+        assert_dtype_allclose(result, expected, check_only_type_kind=True)
+
     @pytest.mark.parametrize("xp", [numpy, dpnp])
     def test_rfft_error(self, xp):
         a = xp.ones((4, 3), dtype=xp.complex64)

dpnp/tests/third_party/cupy/test_type_routines.py

@@ -4,7 +4,7 @@
 import pytest
 
 import dpnp as cupy
-from dpnp.tests.helper import has_support_aspect64
+from dpnp.tests.helper import has_support_aspect16, has_support_aspect64
 from dpnp.tests.third_party.cupy import testing
 
 
@@ -47,13 +47,17 @@ def test_can_cast(self, xp, from_dtype, to_dtype):
         return ret
 
 
-@pytest.mark.skip("dpnp.common_type() is not implemented yet")
 class TestCommonType(unittest.TestCase):
 
     @testing.numpy_cupy_equal()
     def test_common_type_empty(self, xp):
         ret = xp.common_type()
         assert type(ret) is type
+        # NumPy always returns float16 for empty input,
+        # but dpnp returns float32 if the device does not support
+        # 16-bit precision floating point operations
+        if xp is numpy and not has_support_aspect16():
+            return xp.float32
         return ret
 
     @testing.for_all_dtypes(no_bool=True)
@@ -62,6 +66,11 @@ def test_common_type_single_argument(self, xp, dtype):
         array = _generate_type_routines_input(xp, dtype, "array")
         ret = xp.common_type(array)
         assert type(ret) is type
+        # NumPy promotes integer types to float64,
+        # but dpnp may return float32 if the device does not support
+        # 64-bit precision floating point operations.
+        if xp is numpy and not has_support_aspect64():
+            return xp.float32
         return ret
 
     @testing.for_all_dtypes_combination(
@@ -73,6 +82,8 @@ def test_common_type_two_arguments(self, xp, dtype1, dtype2):
         array2 = _generate_type_routines_input(xp, dtype2, "array")
         ret = xp.common_type(array1, array2)
         assert type(ret) is type
+        if xp is numpy and not has_support_aspect64():
+            return xp.float32
         return ret
 
     @testing.for_all_dtypes()