Repository: IntelPython/dpnp (language: python)

Issue:
Update dpnp.astype function
Leverage dpctl.tensor.astype() implementation.
Clean up old implementation.
Refresh test_ndarray_copy_and_view.py test file.

- [x] Have you provided a meaningful PR description?
- [x] Have you added a test, reproducer or referred to issue with a reproducer?
- [x] Have you tested your changes locally for CPU and GPU devices?
- [x] Have you made sure that new changes do not introduce compiler warnings?
- [ ] Have you checked performance impact of proposed changes?
- [ ] If this PR is a work in progress, are you filing the PR as a draft?



Discussion / hints:

Fix patch:
diff --git a/.github/workflows/build-sphinx.yml b/.github/workflows/build-sphinx.yml
index 62b4eb00fd3..a35480e25ee 100644
--- a/.github/workflows/build-sphinx.yml
+++ b/.github/workflows/build-sphinx.yml
@@ -91,7 +91,7 @@ jobs:
 
       - name: Install dpnp dependencies
         run: |
-          conda install numpy"<1.24" dpctl mkl-devel-dpcpp onedpl-devel tbb-devel dpcpp_linux-64 \
+          conda install numpy"<1.24" dpctl">=0.15.1dev1" mkl-devel-dpcpp onedpl-devel tbb-devel dpcpp_linux-64 \
               cmake cython pytest ninja scikit-build sysroot_linux-64">=2.28" ${{ env.CHANNELS }}
 
       - name: Install cuPy dependencies
diff --git a/.github/workflows/conda-package.yml b/.github/workflows/conda-package.yml
index 365d8490ec6..76b24b44287 100644
--- a/.github/workflows/conda-package.yml
+++ b/.github/workflows/conda-package.yml
@@ -27,18 +27,25 @@ env:
       test_sycl_queue.py
       test_umath.py
       test_usm_type.py
-      third_party/cupy/core_tests/test_ndarray_complex_ops.py
+      third_party/cupy/core_tests
       third_party/cupy/linalg_tests/test_product.py
       third_party/cupy/logic_tests/test_comparison.py
       third_party/cupy/logic_tests/test_truth.py
       third_party/cupy/manipulation_tests/test_basic.py
+      third_party/cupy/manipulation_tests/test_dims.py
       third_party/cupy/manipulation_tests/test_join.py
       third_party/cupy/manipulation_tests/test_rearrange.py
       third_party/cupy/manipulation_tests/test_transpose.py
+      third_party/cupy/math_tests/test_arithmetic.py
       third_party/cupy/math_tests/test_explog.py
+      third_party/cupy/math_tests/test_floating.py
+      third_party/cupy/math_tests/test_hyperbolic.py
+      third_party/cupy/math_tests/test_matmul.py
       third_party/cupy/math_tests/test_misc.py
+      third_party/cupy/math_tests/test_rounding.py
       third_party/cupy/math_tests/test_trigonometric.py
       third_party/cupy/sorting_tests/test_sort.py
+      third_party/cupy/sorting_tests/test_count.py
   VER_JSON_NAME: 'version.json'
   VER_SCRIPT1: "import json; f = open('version.json', 'r'); j = json.load(f); f.close(); "
   VER_SCRIPT2: "d = j['dpnp'][0]; print('='.join((d[s] for s in ('version', 'build'))))"
@@ -395,3 +402,33 @@ jobs:
         run: anaconda --token ${{ env.ANACONDA_TOKEN }} upload --user dppy --label dev ${{ env.PACKAGE_NAME }}-*.tar.bz2
         env:
           ANACONDA_TOKEN: ${{ secrets.ANACONDA_TOKEN }}
+
+  cleanup_packages:
+    name: Clean up anaconda packages
+    needs: [upload]
+    runs-on: 'ubuntu-latest'
+    defaults:
+      run:
+        shell: bash -el {0}
+    steps:
+      - uses: conda-incubator/setup-miniconda@v2
+        with:
+          run-post: false
+          channel-priority: "disabled"
+          channels: conda-forge
+          python-version: '3.11'
+
+      - name: Install anaconda-client
+        run: conda install anaconda-client
+
+      - name: Checkout repo
+        uses: actions/checkout@v2
+        with:
+          repository: IntelPython/devops-tools
+          fetch-depth: 0
+
+      - name: Cleanup old packages
+        run: |
+          python scripts/cleanup-old-packages.py \
+          --verbose --force --token ${{ secrets.ANACONDA_TOKEN }} \
+          --package dppy/${{ env.PACKAGE_NAME }} --label dev
diff --git a/.github/workflows/generate_coverage.yaml b/.github/workflows/generate_coverage.yaml
index 776e521f66e..668b69e1fb5 100644
--- a/.github/workflows/generate_coverage.yaml
+++ b/.github/workflows/generate_coverage.yaml
@@ -39,26 +39,32 @@ jobs:
       - name: Install Lcov
         run: |
           sudo apt-get install lcov
+
       - name: Install dpnp dependencies
         run: |
           conda install cython llvm cmake">=3.21" scikit-build ninja pytest pytest-cov coverage[toml] \
               dpctl dpcpp_linux-64 sysroot_linux-64">=2.28" mkl-devel-dpcpp tbb-devel onedpl-devel ${{ env.CHANNELS }}
+
       - name: Conda info
         run: |
           conda info
           conda list
+
       - name: Build dpnp with coverage
         run: |
           python scripts/gen_coverage.py --pytest-opts="--ignore tests/test_random.py"
+
       - name: Install coverall dependencies
         run: |
           sudo gem install coveralls-lcov
           pip install coveralls==3.2.0
+
       - name: Upload coverage data to coveralls.io
         run: |
           echo "Processing pytest-coverage"
           export DPNP_PYTEST_LCOV=$(find . -name dpnp_pytest.lcov)
           coveralls-lcov -v -n $DPNP_PYTEST_LCOV > pytest-dpnp-c-api-coverage.json
+
           # merge file with coverage data and upload
           echo "Merging files with coverage data"
           coveralls --service=github --merge=pytest-dpnp-c-api-coverage.json
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 02b15ba98c3..46e988bdcbe 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,8 +1,4 @@
-cmake_minimum_required(VERSION 3.21...3.26 FATAL_ERROR)
-
-if (${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.24")
-  cmake_policy(SET CMP0135 NEW)
-endif()
+cmake_minimum_required(VERSION 3.21...3.27 FATAL_ERROR)
 
 project(dpnp
   DESCRIPTION "NumPy-like API accelerated by SYCL."
@@ -27,7 +23,7 @@ endif()
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${DPCTL_MODULE_PATH})
 
 
-find_package(IntelDPCPP REQUIRED)
+find_package(IntelSYCL REQUIRED PATHS ${CMAKE_SOURCE_DIR}/dpnp/backend/cmake/Modules NO_DEFAULT_PATH)
 find_package(TBB QUIET)
 if(TBB_FOUND)
     find_package(TBB REQUIRED)
@@ -77,7 +73,7 @@ FetchContent_Declare(
 )
 FetchContent_MakeAvailable(pybind11)
 
-find_package(PythonExtensions REQUIRED)
+find_package(Python REQUIRED COMPONENTS Development.Module)
 find_package(NumPy REQUIRED)
 
 set(CYTHON_FLAGS "-t -w \"${CMAKE_SOURCE_DIR}\"")
diff --git a/conda-recipe/meta.yaml b/conda-recipe/meta.yaml
index 9e7b9774218..3f701fc4b4e 100644
--- a/conda-recipe/meta.yaml
+++ b/conda-recipe/meta.yaml
@@ -8,12 +8,12 @@ requirements:
     host:
       - python
       - setuptools
-      - numpy 1.21
+      - numpy
       - cython
       - cmake >=3.21
       - ninja
       - git
-      - dpctl >=0.15.0
+      - dpctl >=0.15.1dev1
       - mkl-devel-dpcpp {{ environ.get('MKL_VER', '>=2024.0.0') }}
       - onedpl-devel
       - tbb-devel
@@ -25,7 +25,7 @@ requirements:
       - sysroot_linux-64 >=2.28 # [linux]
     run:
       - python
-      - dpctl >=0.15.0
+      - dpctl >=0.15.1dev1
       - {{ pin_compatible('dpcpp-cpp-rt', min_pin='x.x', max_pin='x') }}
       - {{ pin_compatible('mkl-dpcpp', min_pin='x.x', max_pin='x') }}
       - {{ pin_compatible('numpy', min_pin='x.x', max_pin='x') }}
diff --git a/doc/docstring_template.py b/doc/docstring_template.py
index a31bb250576..60a83c181a6 100644
--- a/doc/docstring_template.py
+++ b/doc/docstring_template.py
@@ -78,7 +78,7 @@ def func(a, b=None, c=True):
     -----------
     Some limitations in comparison to baseline, ex:
     Input array data types are limited by supported DPNP :ref:`Data types`.
-    Parameter ``c`` is supported only with default value ``True``.
+    Parameter `c` is supported only with default value ``True``.
     Otherwise the function will be executed sequentially on CPU.
 
     See Also
diff --git a/dpnp/CMakeLists.txt b/dpnp/CMakeLists.txt
index df4971cfa38..ebaf1d7b0ef 100644
--- a/dpnp/CMakeLists.txt
+++ b/dpnp/CMakeLists.txt
@@ -1,37 +1,45 @@
 
 function(build_dpnp_cython_ext _trgt _src _dest)
+  set(options SYCL)
+  cmake_parse_arguments(BUILD_DPNP_EXT "${options}" "" "" ${ARGN})
   add_cython_target(${_trgt} ${_src} CXX OUTPUT_VAR _generated_src)
   message(STATUS "Using ${_trgt}")
-  add_library(${_trgt} MODULE ${_generated_src})
+
+  Python_add_library(${_trgt} MODULE WITH_SOABI ${_generated_src})
   set(_trgt_deps "${_trgt}_deps")
   add_custom_target(${_trgt_deps} DEPENDS ${_src})
   add_dependencies(${_trgt} ${_trgt_deps})
+
+  if (BUILD_DPNP_EXT_SYCL)
+    add_sycl_to_target(TARGET ${_trgt} SOURCES ${_generated_src})
+  endif()
+
   if (DPNP_GENERATE_COVERAGE)
     target_compile_definitions(${_trgt} PRIVATE CYTHON_TRACE=1 CYTHON_TRACE_NOGIL=1)
+    target_compile_options(${_trgt} PRIVATE "-fno-sycl-use-footer")
   endif()
-  target_compile_definitions(${_trgt} PRIVATE NPY_NO_DEPRECATED_API=NPY_1_7_API_VERSION)
+
   # NumPy
+  target_compile_definitions(${_trgt} PRIVATE NPY_NO_DEPRECATED_API=NPY_1_7_API_VERSION)
   target_include_directories(${_trgt} PRIVATE ${NumPy_INCLUDE_DIR})
+
   # Dpctl
   target_include_directories(${_trgt} PRIVATE ${Dpctl_INCLUDE_DIR})
   target_link_directories(${_trgt} PRIVATE ${Dpctl_INCLUDE_DIR}/..)
-  target_link_libraries(${_trgt} DPCTLSyclInterface)
+  target_link_libraries(${_trgt} PRIVATE DPCTLSyclInterface)
 
   set(_linker_options "LINKER:${DPNP_LDFLAGS}")
   target_link_options(${_trgt} PRIVATE ${_linker_options})
-  python_extension_module(${_trgt})
 
   if (DPNP_GENERATE_COVERAGE)
        set(_copy_cxx_trgt "${_trgt}_copy_cxx")
        add_custom_target(
-           ${_copy_cxx_trgt} ALL
-           COMMAND ${CMAKE_COMMAND}
-         -DSOURCE_FILE=${_generated_src}
-         -DDEST=${CMAKE_CURRENT_SOURCE_DIR}
-         -P ${CMAKE_SOURCE_DIR}/dpnp/cmake/copy_existing.cmake
-     DEPENDS ${_trgt}
-     VERBATIM
-           COMMENT "Copying Cython-generated source for target ${_trgt} to dpnp source layout"
+           ${_copy_cxx_trgt} ALL COMMAND ${CMAKE_COMMAND}
+           -DSOURCE_FILE=${_generated_src}
+           -DDEST=${CMAKE_CURRENT_SOURCE_DIR}
+           -P ${CMAKE_SOURCE_DIR}/dpnp/cmake/copy_existing.cmake
+           DEPENDS ${_trgt}
+           VERBATIM COMMENT "Copying Cython-generated source for target ${_trgt} to dpnp source layout"
        )
   endif()
   install(TARGETS ${_trgt} LIBRARY DESTINATION ${_dest})
@@ -39,7 +47,7 @@ endfunction()
 
 function(build_dpnp_cython_ext_with_backend _trgt _src _dest)
   build_dpnp_cython_ext(${_trgt} ${_src} ${_dest})
-  target_link_libraries(${_trgt} dpnp_backend_library)
+  target_link_libraries(${_trgt} PRIVATE dpnp_backend_library)
   if (UNIX)
     set_target_properties(${_trgt} PROPERTIES INSTALL_RPATH "$ORIGIN/..")
   endif()
diff --git a/dpnp/backend/cmake/Modules/IntelSYCLConfig.cmake b/dpnp/backend/cmake/Modules/IntelSYCLConfig.cmake
new file mode 100644
index 00000000000..052aaa965dc
--- /dev/null
+++ b/dpnp/backend/cmake/Modules/IntelSYCLConfig.cmake
@@ -0,0 +1,360 @@
+#
+# Modifications, Copyright (C) 2023 Intel Corporation
+#
+# This software and the related documents are Intel copyrighted materials, and
+# your use of them is governed by the express license under which they were
+# provided to you ("License"). Unless the License provides otherwise, you may not
+# use, modify, copy, publish, distribute, disclose or transmit this software or
+# the related documents without Intel's prior written permission.
+#
+# This software and the related documents are provided as is, with no express
+# or implied warranties, other than those that are expressly stated in the
+# License.
+#
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+#[=======================================================================[.rst:
+IntelSYCLConfig
+-------
+
+Library to verify SYCL compatibility of CMAKE_CXX_COMPILER
+and passes relevant compiler flags.
+
+Result Variables
+^^^^^^^^^^^^^^^^
+
+This will define the following variables:
+
+``IntelSYCL_FOUND``
+  True if the system has the SYCL library.
+``SYCL_LANGUAGE_VERSION``
+  The SYCL language spec version by Compiler.
+``SYCL_INCLUDE_DIR``
+  Include directories needed to use SYCL.
+``SYCL_IMPLEMENTATION_ID``
+  The SYCL compiler variant.
+``SYCL_FLAGS``
+  SYCL specific flags for the compiler.
+
+``IntelSYCL::SYCL_CXX``
+  Target for using Intel SYCL (DPC++).  The following properties are defined
+  for the target: ``INTERFACE_COMPILE_OPTIONS``, ``INTERFACE_LINK_OPTIONS``,
+  ``INTERFACE_INCLUDE_DIRECTORIES``, and ``INTERFACE_LINK_DIRECTORIES``
+
+Cache Variables
+^^^^^^^^^^^^^^^
+
+The following cache variable may also be set:
+
+``SYCL_LANGUAGE_VERSION``
+  The SYCL language spec version by Compiler.
+
+
+.. Note::
+
+  1. User needs to set -DCMAKE_CXX_COMPILER or environment of
+  CXX pointing to SYCL compatible compiler  ( eg: icx, clang++, icpx)
+
+
+  2. Add this package to user's Cmake config file.
+
+  .. code-block:: cmake
+
+    find_package(IntelSYCL REQUIRED)
+
+  3. Add sources to target through add_sycl_to_target()
+
+  .. code-block:: cmake
+
+     # Compile specific sources for SYCL and build target for SYCL
+     add_executable(target_proj A.cpp B.cpp offload1.cpp offload2.cpp)
+     add_sycl_to_target(TARGET target_proj SOURCES offload1.cpp offload2.cpp)
+
+#]=======================================================================]
+
+include(${CMAKE_ROOT}/Modules/FindPackageHandleStandardArgs.cmake)
+
+find_package(PkgConfig QUIET)
+if(PKG_CONFIG_FOUND)
+  # TODO add dependency package module checks, if any
+endif()
+
+
+# TODO: can't use find_program to override the CMAKE_CXX_COMPILER as
+# Platform/ files are executed, potentially for a different compiler.
+# Safer approach is to make user to define CMAKE_CXX_COMPILER.
+
+string(COMPARE EQUAL "${CMAKE_CXX_COMPILER}" "" nocmplr)
+if(nocmplr)
+  set(IntelSYCL_FOUND False)
+  set(SYCL_REASON_FAILURE "SYCL: CMAKE_CXX_COMPILER not set!!")
+  set(IntelSYCL_NOT_FOUND_MESSAGE "${SYCL_REASON_FAILURE}")
+endif()
+
+# Check if a Compiler ID is being set. project() should be set prior to find_package()
+
+if("x${CMAKE_CXX_COMPILER_ID}" STREQUAL "x")
+   set(IntelSYCL_FOUND False)
+   set(SYCL_REASON_FAILURE "CMake CXX Compiler family is not set. Please make sure find_package(IntelSYCL) is called after project()!!")
+   set(IntelSYCL_NOT_FOUND_MESSAGE "${SYCL_REASON_FAILURE}")
+   return()
+endif()
+
+# Check for known compiler family that supports SYCL
+
+if( NOT "x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xClang" AND
+    NOT "x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xIntelLLVM")
+   set(IntelSYCL_FOUND False)
+   set(SYCL_REASON_FAILURE "Unsupported compiler family ${CMAKE_CXX_COMPILER_ID} and compiler ${CMAKE_CXX_COMPILER}!!")
+   set(IntelSYCL_NOT_FOUND_MESSAGE "${SYCL_REASON_FAILURE}")
+   return()
+endif()
+
+# Assume that CXX Compiler supports SYCL and then test to verify.
+set(SYCL_COMPILER ${CMAKE_CXX_COMPILER})
+
+# Function to write a test case to verify SYCL features.
+
+function(SYCL_FEATURE_TEST_WRITE src)
+
+  set(pp_if "#if")
+  set(pp_endif "#endif")
+
+  set(SYCL_TEST_CONTENT "")
+  string(APPEND SYCL_TEST_CONTENT "#include <iostream>\nusing namespace std;\n")
+  string(APPEND SYCL_TEST_CONTENT "int main(){\n")
+
+  # Feature tests goes here
+
+  string(APPEND SYCL_TEST_CONTENT "${pp_if} defined(SYCL_LANGUAGE_VERSION)\n")
+  string(APPEND SYCL_TEST_CONTENT "cout << \"SYCL_LANGUAGE_VERSION=\"<<SYCL_LANGUAGE_VERSION<<endl;\n")
+  string(APPEND SYCL_TEST_CONTENT "${pp_endif}\n")
+
+  string(APPEND SYCL_TEST_CONTENT "return 0;}\n")
+
+  file(WRITE ${src} "${SYCL_TEST_CONTENT}")
+
+endfunction()
+
+# Function to Build the feature check test case.
+
+function(SYCL_FEATURE_TEST_BUILD TEST_SRC_FILE TEST_EXE)
+
+  # Convert CXX Flag string to list
+  set(SYCL_CXX_FLAGS_LIST "${SYCL_CXX_FLAGS}")
+  separate_arguments(SYCL_CXX_FLAGS_LIST)
+
+  # Spawn a process to build the test case.
+  execute_process(
+    COMMAND "${SYCL_COMPILER}"
+    ${SYCL_CXX_FLAGS_LIST}
+    ${TEST_SRC_FILE}
+    "-o"
+    ${TEST_EXE}
+    WORKING_DIRECTORY ${SYCL_TEST_DIR}
+    OUTPUT_VARIABLE output ERROR_VARIABLE output
+    OUTPUT_FILE ${SYCL_TEST_DIR}/Compile.log
+    RESULT_VARIABLE result
+    TIMEOUT 60
+    )
+
+  # Verify if test case build properly.
+  if(result)
+    message("SYCL feature test compile failed!")
+    message("compile output is: ${output}")
+  endif()
+
+  # TODO: what to do if it doesn't build
+
+endfunction()
+
+# Function to run the test case to generate feature info.
+
+function(SYCL_FEATURE_TEST_RUN TEST_EXE)
+
+  # Spawn a process to run the test case.
+
+  execute_process(
+    COMMAND ${TEST_EXE}
+    WORKING_DIRECTORY ${SYCL_TEST_DIR}
+    OUTPUT_VARIABLE output ERROR_VARIABLE output
+    RESULT_VARIABLE result
+    TIMEOUT 60
+    )
+
+  # Verify the test execution output.
+  if(test_result)
+    set(IntelSYCL_FOUND False)
+    set(SYCL_REASON_FAILURE "SYCL: feature test execution failed!!")
+  endif()
+  # TODO: what iff the result is false.. error or ignore?
+
+  set( test_result "${result}" PARENT_SCOPE)
+  set( test_output "${output}" PARENT_SCOPE)
+
+endfunction()
+
+
+# Function to extract the information from test execution.
+function(SYCL_FEATURE_TEST_EXTRACT test_output)
+
+  string(REGEX REPLACE "\n" ";" test_output_list "${test_output}")
+
+  set(SYCL_LANGUAGE_VERSION "")
+  foreach(strl ${test_output_list})
+     if(${strl} MATCHES "^SYCL_LANGUAGE_VERSION=([A-Za-z0-9_]+)$")
+       string(REGEX REPLACE "^SYCL_LANGUAGE_VERSION=" "" extracted_sycl_lang "${strl}")
+       set(SYCL_LANGUAGE_VERSION ${extracted_sycl_lang})
+     endif()
+  endforeach()
+
+  set(SYCL_LANGUAGE_VERSION "${SYCL_LANGUAGE_VERSION}" PARENT_SCOPE)
+endfunction()
+
+if(SYCL_COMPILER)
+  # TODO ensure CMAKE_LINKER and CMAKE_CXX_COMPILER are same/supports SYCL.
+  # set(CMAKE_LINKER ${SYCL_COMPILER})
+
+  # use REALPATH to resolve symlinks
+  get_filename_component(_REALPATH_SYCL_COMPILER "${SYCL_COMPILER}" REALPATH)
+  get_filename_component(SYCL_BIN_DIR "${_REALPATH_SYCL_COMPILER}" DIRECTORY)
+  get_filename_component(SYCL_PACKAGE_DIR "${SYCL_BIN_DIR}" DIRECTORY CACHE)
+
+  # Find Include path from binary
+  find_file(SYCL_INCLUDE_DIR
+    NAMES
+      include
+    HINTS
+      ${SYCL_PACKAGE_DIR} $ENV{SYCL_INCLUDE_DIR_HINT}
+    NO_DEFAULT_PATH
+      )
+
+  # Find Library directory
+  find_file(SYCL_LIBRARY_DIR
+    NAMES
+      lib lib64
+    HINTS
+      ${SYCL_PACKAGE_DIR} $ENV{SYCL_LIBRARY_DIR_HINT}
+    NO_DEFAULT_PATH
+      )
+
+endif()
+
+
+set(SYCL_FLAGS "")
+set(SYCL_LINK_FLAGS "")
+
+# Based on Compiler ID, add support for SYCL
+if( "x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xClang" OR
+    "x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xIntelLLVM")
+  list(APPEND SYCL_FLAGS "-fsycl")
+  list(APPEND SYCL_LINK_FLAGS "-fsycl")
+endif()
+
+# TODO verify if this is needed
+# Windows: Add Exception handling
+if(WIN32)
+  list(APPEND SYCL_FLAGS "/EHsc")
+endif()
+
+set(SYCL_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${SYCL_FLAGS}")
+
+# And now test the assumptions.
+
+# Create a clean working directory.
+set(SYCL_TEST_DIR "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/TESTSYCL")
+file(REMOVE_RECURSE ${SYCL_TEST_DIR})
+file(MAKE_DIRECTORY ${SYCL_TEST_DIR})
+
+# Create the test source file
+set(TEST_SRC_FILE "${SYCL_TEST_DIR}/sycl_features.cpp")
+set(TEST_EXE "${TEST_SRC_FILE}.exe")
+SYCL_FEATURE_TEST_WRITE(${TEST_SRC_FILE})
+
+# Build the test and create test executable
+SYCL_FEATURE_TEST_BUILD(${TEST_SRC_FILE} ${TEST_EXE})
+
+# Execute the test to extract information
+SYCL_FEATURE_TEST_RUN(${TEST_EXE})
+
+# Extract test output for information
+SYCL_FEATURE_TEST_EXTRACT(${test_output})
+
+# As per specification, all the SYCL compatible compilers should
+# define macro  SYCL_LANGUAGE_VERSION
+string(COMPARE EQUAL "${SYCL_LANGUAGE_VERSION}" "" nosycllang)
+if(nosycllang)
+  set(IntelSYCL_FOUND False)
+  set(SYCL_REASON_FAILURE "SYCL: It appears that the ${CMAKE_CXX_COMPILER} does not support SYCL")
+  set(IntelSYCL_NOT_FOUND_MESSAGE "${SYCL_REASON_FAILURE}")
+endif()
+
+# Placeholder for identifying various implementations of SYCL compilers.
+# for now, set to the CMAKE_CXX_COMPILER_ID
+set(SYCL_IMPLEMENTATION_ID "${CMAKE_CXX_COMPILER_ID}")
+
+message(DEBUG "The SYCL compiler is ${SYCL_COMPILER}")
+message(DEBUG "The SYCL Flags are ${SYCL_FLAGS}")
+message(DEBUG "The SYCL Language Version is ${SYCL_LANGUAGE_VERSION}")
+
+add_library(IntelSYCL::SYCL_CXX INTERFACE IMPORTED)
+set_property(TARGET IntelSYCL::SYCL_CXX PROPERTY
+  INTERFACE_COMPILE_OPTIONS ${SYCL_FLAGS})
+set_property(TARGET IntelSYCL::SYCL_CXX PROPERTY
+  INTERFACE_LINK_OPTIONS ${SYCL_LINK_FLAGS})
+set_property(TARGET IntelSYCL::SYCL_CXX PROPERTY
+  INTERFACE_INCLUDE_DIRECTORIES ${SYCL_INCLUDE_DIR})
+set_property(TARGET IntelSYCL::SYCL_CXX PROPERTY
+  INTERFACE_LINK_DIRECTORIES ${SYCL_LIBRARY_DIR})
+
+find_package_handle_standard_args(
+  IntelSYCL
+  FOUND_VAR IntelSYCL_FOUND
+  REQUIRED_VARS SYCL_INCLUDE_DIR SYCL_LIBRARY_DIR SYCL_FLAGS
+  VERSION_VAR SYCL_LANGUAGE_VERSION
+  REASON_FAILURE_MESSAGE "${SYCL_REASON_FAILURE}")
+
+# Include in Cache
+set(SYCL_LANGUAGE_VERSION "${SYCL_LANGUAGE_VERSION}" CACHE STRING "SYCL Language version")
+
+function(add_sycl_to_target)
+
+  set(one_value_args TARGET)
+  set(multi_value_args SOURCES)
+  cmake_parse_arguments(SYCL
+    ""
+    "${one_value_args}"
+    "${multi_value_args}"
+    ${ARGN})
+
+
+    get_target_property(__sycl_cxx_options IntelSYCL::SYCL_CXX INTERFACE_COMPILE_OPTIONS)
+    get_target_property(__sycl_cxx_include_directories IntelSYCL::SYCL_CXX INTERFACE_INCLUDE_DIRECTORIES)
+
+    if(NOT ${ARGC})
+      message(FATAL_ERROR " add_sycl_to_target() does not have any arguments")
+    elseif(${ARGC} EQUAL 1)
+      message(WARNING "add_sycl_to_target() have only one argument specified.. assuming the target to be ${ARGV}.
+Adding sycl to all sources but that may effect compilation times")
+      set(SYCL_TARGET ${ARGV})
+    endif()
+
+    if(NOT SYCL_SOURCES)
+      message(WARNING "add_sycl_to_target() does not have sources specified.. Adding sycl to all sources but that may effect compilation times")
+      target_compile_options(${SYCL_TARGET} PUBLIC ${__sycl_cxx_options})
+      target_include_directories(${SYCL_TARGET} PUBLIC ${__sycl_cxx_include_directories})
+    endif()
+
+    foreach(source ${SYCL_SOURCES})
+      set_source_files_properties(${source} PROPERTIES COMPILE_OPTIONS "${__sycl_cxx_options}")
+      set_source_files_properties(${source} PROPERTIES INCLUDE_DIRECTORIES "${__sycl_cxx_include_directories}")
+    endforeach()
+
+    get_target_property(__sycl_link_options
+        IntelSYCL::SYCL_CXX INTERFACE_LINK_OPTIONS)
+    target_link_options(${SYCL_TARGET} PRIVATE "${__sycl_link_options}")
+    get_target_property(__sycl_link_directories
+        IntelSYCL::SYCL_CXX INTERFACE_LINK_DIRECTORIES)
+    target_link_directories(${SYCL_TARGET} PUBLIC "${__sycl_link_directories}")
+endfunction(add_sycl_to_target)
diff --git a/dpnp/backend/cmake/Modules/MKLConfig.cmake b/dpnp/backend/cmake/Modules/MKLConfig.cmake
index 07290e8ea33..fa6f80a19b6 100644
--- a/dpnp/backend/cmake/Modules/MKLConfig.cmake
+++ b/dpnp/backend/cmake/Modules/MKLConfig.cmake
@@ -414,7 +414,7 @@ if(GNU_C_COMPILER OR GNU_Fortran_COMPILER)
   endif()
 endif()
 
-# Additonal compiler & linker options
+# Additional compiler & linker options
 if(CXX_COMPILER_NAME STREQUAL "icpx" OR CXX_COMPILER_NAME STREQUAL "icx.exe")
   list(APPEND MKL_DPCPP_COPT "-fsycl")
   list(APPEND MKL_DPCPP_LOPT "-fsycl")
diff --git a/dpnp/backend/examples/example8.cpp b/dpnp/backend/examples/example8.cpp
index af342614c30..ffc18a99f42 100644
--- a/dpnp/backend/examples/example8.cpp
+++ b/dpnp/backend/examples/example8.cpp
@@ -56,7 +56,7 @@ int main(int, char **)
 
     dpnp_argsort_c<double, long>(array, result, size);
 
-    std::cout << "array with 'sorted' indeces" << std::endl;
+    std::cout << "array with 'sorted' indices" << std::endl;
     for (size_t i = 0; i < size; ++i) {
         std::cout << result[i] << ", ";
     }
diff --git a/dpnp/backend/extensions/lapack/CMakeLists.txt b/dpnp/backend/extensions/lapack/CMakeLists.txt
index 0c90b4f0ca5..7679db38d6a 100644
--- a/dpnp/backend/extensions/lapack/CMakeLists.txt
+++ b/dpnp/backend/extensions/lapack/CMakeLists.txt
@@ -25,12 +25,15 @@
 
 
 set(python_module_name _lapack_impl)
-pybind11_add_module(${python_module_name} MODULE
-    lapack_py.cpp
-    heevd.cpp
-    syevd.cpp
+set(_module_src
+    ${CMAKE_CURRENT_SOURCE_DIR}/lapack_py.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/heevd.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/syevd.cpp
 )
 
+pybind11_add_module(${python_module_name} MODULE ${_module_src})
+add_sycl_to_target(TARGET ${python_module_name} SOURCES ${_module_src})
+
 if (WIN32)
     if (${CMAKE_VERSION} VERSION_LESS "3.27")
         # this is a work-around for target_link_options inserting option after -link option, cause
diff --git a/dpnp/backend/extensions/lapack/heevd.cpp b/dpnp/backend/extensions/lapack/heevd.cpp
index d8ca71f7aae..e57d34f10c0 100644
--- a/dpnp/backend/extensions/lapack/heevd.cpp
+++ b/dpnp/backend/extensions/lapack/heevd.cpp
@@ -114,7 +114,7 @@ static sycl::event heevd_impl(sycl::queue exec_q,
         info = -1;
     }
 
-    if (info != 0) // an unexected error occurs
+    if (info != 0) // an unexpected error occurs
     {
         if (scratchpad != nullptr) {
             sycl::free(scratchpad, exec_q);
@@ -188,8 +188,9 @@ std::pair<sycl::event, sycl::event>
     bool is_eig_vecs_f_contig = eig_vecs.is_f_contiguous();
     bool is_eig_vals_c_contig = eig_vals.is_c_contiguous();
     if (!is_eig_vecs_f_contig) {
-        throw py::value_error("An array with input matrix / ouput eigenvectors "
-                              "must be F-contiguous");
+        throw py::value_error(
+            "An array with input matrix / output eigenvectors "
+            "must be F-contiguous");
     }
     else if (!is_eig_vals_c_contig) {
         throw py::value_error(
diff --git a/dpnp/backend/extensions/lapack/syevd.cpp b/dpnp/backend/extensions/lapack/syevd.cpp
index b9b700184f8..11c13569bf6 100644
--- a/dpnp/backend/extensions/lapack/syevd.cpp
+++ b/dpnp/backend/extensions/lapack/syevd.cpp
@@ -112,7 +112,7 @@ static sycl::event syevd_impl(sycl::queue exec_q,
         info = -1;
     }
 
-    if (info != 0) // an unexected error occurs
+    if (info != 0) // an unexpected error occurs
     {
         if (scratchpad != nullptr) {
             sycl::free(scratchpad, exec_q);
@@ -186,8 +186,9 @@ std::pair<sycl::event, sycl::event>
     bool is_eig_vecs_f_contig = eig_vecs.is_f_contiguous();
     bool is_eig_vals_c_contig = eig_vals.is_c_contiguous();
     if (!is_eig_vecs_f_contig) {
-        throw py::value_error("An array with input matrix / ouput eigenvectors "
-                              "must be F-contiguous");
+        throw py::value_error(
+            "An array with input matrix / output eigenvectors "
+            "must be F-contiguous");
     }
     else if (!is_eig_vals_c_contig) {
         throw py::value_error(
@@ -202,7 +203,7 @@ std::pair<sycl::event, sycl::event>
 
     if (eig_vecs_type_id != eig_vals_type_id) {
         throw py::value_error(
-            "Types of eigenvectors and eigenvalues are missmatched");
+            "Types of eigenvectors and eigenvalues are mismatched");
     }
 
     syevd_impl_fn_ptr_t syevd_fn = syevd_dispatch_vector[eig_vecs_type_id];
diff --git a/dpnp/backend/extensions/sycl_ext/CMakeLists.txt b/dpnp/backend/extensions/sycl_ext/CMakeLists.txt
index 9a18630eb3b..4aff4d2e766 100644
--- a/dpnp/backend/extensions/sycl_ext/CMakeLists.txt
+++ b/dpnp/backend/extensions/sycl_ext/CMakeLists.txt
@@ -25,10 +25,13 @@
 
 
 set(python_module_name _sycl_ext_impl)
-pybind11_add_module(${python_module_name} MODULE
-    sum_mean.cpp
+set(_module_src
+    ${CMAKE_CURRENT_SOURCE_DIR}/sum_mean.cpp
 )
 
+pybind11_add_module(${python_module_name} MODULE ${_module_src})
+add_sycl_to_target(TARGET ${python_module_name} SOURCES ${_module_src})
+
 if (WIN32)
     if (${CMAKE_VERSION} VERSION_LESS "3.27")
         # this is a work-around for target_link_options inserting option after -link option, cause
diff --git a/dpnp/backend/extensions/sycl_ext/dispatcher_utils.hpp b/dpnp/backend/extensions/sycl_ext/dispatcher_utils.hpp
index 57f1a4e43a0..f04472e9c18 100644
--- a/dpnp/backend/extensions/sycl_ext/dispatcher_utils.hpp
+++ b/dpnp/backend/extensions/sycl_ext/dispatcher_utils.hpp
@@ -388,8 +388,8 @@ struct CartesianDispatcher
 
     FnT operator()(std::initializer_list<DispatchT> values)
     {
-        // though std::initializer_list::size is constexpr it doesnt work for
-        // some reson constexpr auto const list_size = values.size();
+        // though std::initializer_list::size is constexpr it doesn't work for
+        // some reason constexpr auto const list_size = values.size();
         std::array<int, sizeof...(Axis)> idx;
         bool found =
             coord_in_space<DispatchT, Matcher, std::tuple<Axis...>>::get(
diff --git a/dpnp/backend/extensions/sycl_ext/sum_mean.hpp b/dpnp/backend/extensions/sycl_ext/sum_mean.hpp
index a3779901501..69e85eed884 100644
--- a/dpnp/backend/extensions/sycl_ext/sum_mean.hpp
+++ b/dpnp/backend/extensions/sycl_ext/sum_mean.hpp
@@ -61,7 +61,7 @@ bool check_limitations(const dpctl::tensor::usm_ndarray &in,
     size_t out_full_size = out.get_size() * out.get_elemsize();
     if (out_full_size > local_mem_size) {
         if (throw_on_fail)
-            throw py::value_error("Resulting array exceeds local memroy size" +
+            throw py::value_error("Resulting array exceeds local memory size" +
                                   std::to_string(local_mem_size));
 
         return false;
diff --git a/dpnp/backend/extensions/vm/CMakeLists.txt b/dpnp/backend/extensions/vm/CMakeLists.txt
index 6c8e21fa535..3f13fb571a6 100644
--- a/dpnp/backend/extensions/vm/CMakeLists.txt
+++ b/dpnp/backend/extensions/vm/CMakeLists.txt
@@ -25,10 +25,13 @@
 
 
 set(python_module_name _vm_impl)
-pybind11_add_module(${python_module_name} MODULE
-    vm_py.cpp
+set(_module_src
+    ${CMAKE_CURRENT_SOURCE_DIR}/vm_py.cpp
 )
 
+pybind11_add_module(${python_module_name} MODULE ${_module_src})
+add_sycl_to_target(TARGET ${python_module_name} SOURCES ${_module_src})
+
 if (WIN32)
     if (${CMAKE_VERSION} VERSION_LESS "3.27")
         # this is a work-around for target_link_options inserting option after -link option, cause
diff --git a/dpnp/backend/extensions/vm/abs.hpp b/dpnp/backend/extensions/vm/abs.hpp
new file mode 100644
index 00000000000..4a2894e7c46
--- /dev/null
+++ b/dpnp/backend/extensions/vm/abs.hpp
@@ -0,0 +1,79 @@
+//*****************************************************************************
+// Copyright (c) 2023, Intel Corporation
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// - Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+// - Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+// THE POSSIBILITY OF SUCH DAMAGE.
+//*****************************************************************************
+
+#pragma once
+
+#include <CL/sycl.hpp>
+
+#include "common.hpp"
+#include "types_matrix.hpp"
+
+namespace dpnp
+{
+namespace backend
+{
+namespace ext
+{
+namespace vm
+{
+template <typename T>
+sycl::event abs_contig_impl(sycl::queue exec_q,
+                            const std::int64_t n,
+                            const char *in_a,
+                            char *out_y,
+                            const std::vector<sycl::event> &depends)
+{
+    type_utils::validate_type_for_device<T>(exec_q);
+
+    const T *a = reinterpret_cast<const T *>(in_a);
+    using resTy = typename types::AbsOutputType<T>::value_type;
+    resTy *y = reinterpret_cast<resTy *>(out_y);
+
+    return mkl_vm::abs(exec_q,
+                       n, // number of elements to be calculated
+                       a, // pointer `a` containing input vector of size n
+                       y, // pointer `y` to the output vector of size n
+                       depends);
+}
+
+template <typename fnT, typename T>
+struct AbsContigFactory
+{
+    fnT get()
+    {
+        if constexpr (std::is_same_v<
+                          typename types::AbsOutputType<T>::value_type, void>)
+        {
+            return nullptr;
+        }
+        else {
+            return abs_contig_impl<T>;
+        }
+    }
+};
+} // namespace vm
+} // namespace ext
+} // namespace backend
+} // namespace dpnp
diff --git a/dpnp/backend/extensions/vm/acos.hpp b/dpnp/backend/extensions/vm/acos.hpp
index 10bd68bf66e..392ee56e172 100644
--- a/dpnp/backend/extensions/vm/acos.hpp
+++ b/dpnp/backend/extensions/vm/acos.hpp
@@ -48,7 +48,8 @@ sycl::event acos_contig_impl(sycl::queue exec_q,
     type_utils::validate_type_for_device<T>(exec_q);
 
     const T *a = reinterpret_cast<const T *>(in_a);
-    T *y = reinterpret_cast<T *>(out_y);
+    using resTy = typename types::AcosOutputType<T>::value_type;
+    resTy *y = reinterpret_cast<resTy *>(out_y);
 
     return mkl_vm::acos(exec_q,
                         n, // number of elements to be calculated
diff --git a/dpnp/backend/extensions/vm/acosh.hpp b/dpnp/backend/extensions/vm/acosh.hpp
index 63d17cbd464..9e3d2491382 100644
--- a/dpnp/backend/extensions/vm/acosh.hpp
+++ b/dpnp/backend/extensions/vm/acosh.hpp
@@ -48,7 +48,8 @@ sycl::event acosh_contig_impl(sycl::queue exec_q,
     type_utils::validate_type_for_device<T>(exec_q);
 
     const T *a = reinterpret_cast<const T *>(in_a);
-    T *y = reinterpret_cast<T *>(out_y);
+    using resTy = typename types::AcoshOutputType<T>::value_type;
+    resTy *y = reinterpret_cast<resTy *>(out_y);
 
     return mkl_vm::acosh(exec_q,
                          n, // number of elements to be calculated
diff --git a/dpnp/backend/extensions/vm/add.hpp b/dpnp/backend/extensions/vm/add.hpp
index d80755f0ec0..85cbda9e668 100644
--- a/dpnp/backend/extensions/vm/add.hpp
+++ b/dpnp/backend/extensions/vm/add.hpp
@@ -50,7 +50,8 @@ sycl::event add_contig_impl(sycl::queue exec_q,
 
     const T *a = reinterpret_cast<const T *>(in_a);
     const T *b = reinterpret_cast<const T *>(in_b);
-    T *y = reinterpret_cast<T *>(out_y);
+    using resTy = typename types::AddOutputType<T>::value_type;
+    resTy *y = reinterpret_cast<resTy *>(out_y);
 
     return mkl_vm::add(exec_q,
                        n, // number of elements to be calculated
diff --git a/dpnp/backend/extensions/vm/asin.hpp b/dpnp/backend/extensions/vm/asin.hpp
index 8df471f79c1..4ff131c352f 100644
--- a/dpnp/backend/extensions/vm/asin.hpp
+++ b/dpnp/backend/extensions/vm/asin.hpp
@@ -48,7 +48,8 @@ sycl::event asin_contig_impl(sycl::queue exec_q,
     type_utils::validate_type_for_device<T>(exec_q);
 
     const T *a = reinterpret_cast<const T *>(in_a);
-    T *y = reinterpret_cast<T *>(out_y);
+    using resTy = typename types::AsinOutputType<T>::value_type;
+    resTy *y = reinterpret_cast<resTy *>(out_y);
 
     return mkl_vm::asin(exec_q,
                         n, // number of elements to be calculated
diff --git a/dpnp/backend/extensions/vm/asinh.hpp b/dpnp/backend/extensions/vm/asinh.hpp
index 4e8e242257a..3bc61dc813d 100644
--- a/dpnp/backend/extensions/vm/asinh.hpp
+++ b/dpnp/backend/extensions/vm/asinh.hpp
@@ -48,7 +48,8 @@ sycl::event asinh_contig_impl(sycl::queue exec_q,
     type_utils::validate_type_for_device<T>(exec_q);
 
     const T *a = reinterpret_cast<const T *>(in_a);
-    T *y = reinterpret_cast<T *>(out_y);
+    using resTy = typename types::AsinhOutputType<T>::value_type;
+    resTy *y = reinterpret_cast<resTy *>(out_y);
 
     return mkl_vm::asinh(exec_q,
                          n, // number of elements to be calculated
diff --git a/dpnp/backend/extensions/vm/atan.hpp b/dpnp/backend/extensions/vm/atan.hpp
index 35967bb720a..ed38bdc2e71 100644
--- a/dpnp/backend/extensions/vm/atan.hpp
+++ b/dpnp/backend/extensions/vm/atan.hpp
@@ -48,7 +48,8 @@ sycl::event atan_contig_impl(sycl::queue exec_q,
     type_utils::validate_type_for_device<T>(exec_q);
 
     const T *a = reinterpret_cast<const T *>(in_a);
-    T *y = reinterpret_cast<T *>(out_y);
+    using resTy = typename types::AtanOutputType<T>::value_type;
+    resTy *y = reinterpret_cast<resTy *>(out_y);
 
     return mkl_vm::atan(exec_q,
                         n, // number of elements to be calculated
diff --git a/dpnp/backend/extensions/vm/atan2.hpp b/dpnp/backend/extensions/vm/atan2.hpp
index bf3d95a9c7d..09788cd8a41 100644
--- a/dpnp/backend/extensions/vm/atan2.hpp
+++ b/dpnp/backend/extensions/vm/atan2.hpp
@@ -50,7 +50,8 @@ sycl::event atan2_contig_impl(sycl::queue exec_q,
 
     const T *a = reinterpret_cast<const T *>(in_a);
     const T *b = reinterpret_cast<const T *>(in_b);
-    T *y = reinterpret_cast<T *>(out_y);
+    using resTy = typename types::Atan2OutputType<T>::value_type;
+    resTy *y = reinterpret_cast<resTy *>(out_y);
 
     return mkl_vm::atan2(exec_q,
                          n, // number of elements to be calculated
diff --git a/dpnp/backend/extensions/vm/atanh.hpp b/dpnp/backend/extensions/vm/atanh.hpp
index 6f7ee1064e8..3f22f7c4283 100644
--- a/dpnp/backend/extensions/vm/atanh.hpp
+++ b/dpnp/backend/extensions/vm/atanh.hpp
@@ -48,7 +48,8 @@ sycl::event atanh_contig_impl(sycl::queue exec_q,
     type_utils::validate_type_for_device<T>(exec_q);
 
     const T *a = reinterpret_cast<const T *>(in_a);
-    T *y = reinterpret_cast<T *>(out_y);
+    using resTy = typename types::AtanhOutputType<T>::value_type;
+    resTy *y = reinterpret_cast<resTy *>(out_y);
 
     return mkl_vm::atanh(exec_q,
                          n, // number of elements to be calculated
diff --git a/dpnp/backend/extensions/vm/ceil.hpp b/dpnp/backend/extensions/vm/ceil.hpp
index b1354b884c3..04265342168 100644
--- a/dpnp/backend/extensions/vm/ceil.hpp
+++ b/dpnp/backend/extensions/vm/ceil.hpp
@@ -48,7 +48,8 @@ sycl::event ceil_contig_impl(sycl::queue exec_q,
     type_utils::validate_type_for_device<T>(exec_q);
 
     const T *a = reinterpret_cast<const T *>(in_a);
-    T *y = reinterpret_cast<T *>(out_y);
+    using resTy = typename types::CeilOutputType<T>::value_type;
+    resTy *y = reinterpret_cast<resTy *>(out_y);
 
     return mkl_vm::ceil(exec_q,
                         n, // number of elements to be calculated
diff --git a/dpnp/backend/extensions/vm/common.hpp b/dpnp/backend/extensions/vm/common.hpp
index db68df60967..60bfb4e0881 100644
--- a/dpnp/backend/extensions/vm/common.hpp
+++ b/dpnp/backend/extensions/vm/common.hpp
@@ -82,15 +82,8 @@ std::pair<sycl::event, sycl::event>
 {
     // check type_nums
     int src_typenum = src.get_typenum();
-    int dst_typenum = dst.get_typenum();
-
     auto array_types = dpctl_td_ns::usm_ndarray_types();
     int src_typeid = array_types.typenum_to_lookup_id(src_typenum);
-    int dst_typeid = array_types.typenum_to_lookup_id(dst_typenum);
-
-    if (src_typeid != dst_typeid) {
-        throw py::value_error("Input and output arrays have different types.");
-    }
 
     // check that queues are compatible
     if (!dpctl::utils::queues_are_compatible(exec_q, {src, dst})) {
@@ -124,15 +117,15 @@ std::pair<sycl::event, sycl::event>
         return std::make_pair(sycl::event(), sycl::event());
     }
 
-    // ensure that output is ample enough to accomodate all elements
+    // ensure that output is ample enough to accommodate all elements
     auto dst_offsets = dst.get_minmax_offsets();
-    // destination must be ample enough to accomodate all elements
+    // destination must be ample enough to accommodate all elements
     {
         size_t range =
             static_cast<size_t>(dst_offsets.second - dst_offsets.first);
         if (range + 1 < src_nelems) {
             throw py::value_error(
-                "Destination array can not accomodate all the elements "
+                "Destination array can not accommodate all the elements "
                 "of source array.");
         }
     }
@@ -155,7 +148,7 @@ std::pair<sycl::event, sycl::event>
         throw py::value_error("Input and outpur arrays must be C-contiguous.");
     }
 
-    auto dispatch_fn = dispatch_vector[dst_typeid];
+    auto dispatch_fn = dispatch_vector[src_typeid];
     if (dispatch_fn == nullptr) {
         throw py::value_error("No implementation is defined for ufunc.");
     }
@@ -179,16 +172,13 @@ std::pair<sycl::event, sycl::event> binary_ufunc(
     // check type_nums
     int src1_typenum = src1.get_typenum();
     int src2_typenum = src2.get_typenum();
-    int dst_typenum = dst.get_typenum();
 
     auto array_types = dpctl_td_ns::usm_ndarray_types();
     int src1_typeid = array_types.typenum_to_lookup_id(src1_typenum);
     int src2_typeid = array_types.typenum_to_lookup_id(src2_typenum);
-    int dst_typeid = array_types.typenum_to_lookup_id(dst_typenum);
 
-    if (src1_typeid != src2_typeid || src2_typeid != dst_typeid) {
-        throw py::value_error(
-            "Either any of input arrays or output array have different types.");
+    if (src1_typeid != src2_typeid) {
+        throw py::value_error("Input arrays have different types.");
     }
 
     // check that queues are compatible
@@ -225,15 +215,15 @@ std::pair<sycl::event, sycl::event> binary_ufunc(
         return std::make_pair(sycl::event(), sycl::event());
     }
 
-    // ensure that output is ample enough to accomodate all elements
+    // ensure that output is ample enough to accommodate all elements
     auto dst_offsets = dst.get_minmax_offsets();
-    // destination must be ample enough to accomodate all elements
+    // destination must be ample enough to accommodate all elements
     {
         size_t range =
             static_cast<size_t>(dst_offsets.second - dst_offsets.first);
         if (range + 1 < src_nelems) {
             throw py::value_error(
-                "Destination array can not accomodate all the "
+                "Destination array can not accommodate all the "
                 "elements of source array.");
         }
     }
@@ -259,7 +249,7 @@ std::pair<sycl::event, sycl::event> binary_ufunc(
         throw py::value_error("Input and outpur arrays must be C-contiguous.");
     }
 
-    auto dispatch_fn = dispatch_vector[dst_typeid];
+    auto dispatch_fn = dispatch_vector[src1_typeid];
     if (dispatch_fn == nullptr) {
         throw py::value_error("No implementation is defined for ufunc.");
     }
@@ -279,16 +269,8 @@ bool need_to_call_unary_ufunc(sycl::queue exec_q,
 {
     // check type_nums
     int src_typenum = src.get_typenum();
-    int dst_typenum = dst.get_typenum();
-
     auto array_types = dpctl_td_ns::usm_ndarray_types();
     int src_typeid = array_types.typenum_to_lookup_id(src_typenum);
-    int dst_typeid = array_types.typenum_to_lookup_id(dst_typenum);
-
-    // types must be the same
-    if (src_typeid != dst_typeid) {
-        return false;
-    }
 
     // OneMKL VM functions perform a copy on host if no double type support
     if (!exec_q.get_device().has(sycl::aspect::fp64)) {
@@ -329,9 +311,9 @@ bool need_to_call_unary_ufunc(sycl::queue exec_q,
         return false;
     }
 
-    // ensure that output is ample enough to accomodate all elements
+    // ensure that output is ample enough to accommodate all elements
     auto dst_offsets = dst.get_minmax_offsets();
-    // destination must be ample enough to accomodate all elements
+    // destination must be ample enough to accommodate all elements
     {
         size_t range =
             static_cast<size_t>(dst_offsets.second - dst_offsets.first);
@@ -346,7 +328,7 @@ bool need_to_call_unary_ufunc(sycl::queue exec_q,
         return false;
     }
 
-    // suppport only contiguous inputs
+    // support only contiguous inputs
     bool is_src_c_contig = src.is_c_contiguous();
     bool is_dst_c_contig = dst.is_c_contiguous();
 
@@ -356,7 +338,7 @@ bool need_to_call_unary_ufunc(sycl::queue exec_q,
     }
 
     // MKL function is not defined for the type
-    if (dispatch_vector[dst_typeid] == nullptr) {
+    if (dispatch_vector[src_typeid] == nullptr) {
         return false;
     }
     return true;
@@ -372,15 +354,13 @@ bool need_to_call_binary_ufunc(sycl::queue exec_q,
     // check type_nums
     int src1_typenum = src1.get_typenum();
     int src2_typenum = src2.get_typenum();
-    int dst_typenum = dst.get_typenum();
 
     auto array_types = dpctl_td_ns::usm_ndarray_types();
     int src1_typeid = array_types.typenum_to_lookup_id(src1_typenum);
     int src2_typeid = array_types.typenum_to_lookup_id(src2_typenum);
-    int dst_typeid = array_types.typenum_to_lookup_id(dst_typenum);
 
     // types must be the same
-    if (src1_typeid != src2_typeid || src2_typeid != dst_typeid) {
+    if (src1_typeid != src2_typeid) {
         return false;
     }
 
@@ -425,9 +405,9 @@ bool need_to_call_binary_ufunc(sycl::queue exec_q,
         return false;
     }
 
-    // ensure that output is ample enough to accomodate all elements
+    // ensure that output is ample enough to accommodate all elements
     auto dst_offsets = dst.get_minmax_offsets();
-    // destination must be ample enough to accomodate all elements
+    // destination must be ample enough to accommodate all elements
     {
         size_t range =
             static_cast<size_t>(dst_offsets.second - dst_offsets.first);
@@ -442,7 +422,7 @@ bool need_to_call_binary_ufunc(sycl::queue exec_q,
         return false;
     }
 
-    // suppport only contiguous inputs
+    // support only contiguous inputs
     bool is_src1_c_contig = src1.is_c_contiguous();
     bool is_src2_c_contig = src2.is_c_contiguous();
     bool is_dst_c_contig = dst.is_c_contiguous();
@@ -454,7 +434,7 @@ bool need_to_call_binary_ufunc(sycl::queue exec_q,
     }
 
     // MKL function is not defined for the type
-    if (dispatch_vector[dst_typeid] == nullptr) {
+    if (dispatch_vector[src1_typeid] == nullptr) {
         return false;
     }
     return true;
diff --git a/dpnp/backend/extensions/vm/conj.hpp b/dpnp/backend/extensions/vm/conj.hpp
index a18226509b4..106c20eb95f 100644
--- a/dpnp/backend/extensions/vm/conj.hpp
+++ b/dpnp/backend/extensions/vm/conj.hpp
@@ -48,7 +48,8 @@ sycl::event conj_contig_impl(sycl::queue exec_q,
     type_utils::validate_type_for_device<T>(exec_q);
 
     const T *a = reinterpret_cast<const T *>(in_a);
-    T *y = reinterpret_cast<T *>(out_y);
+    using resTy = typename types::ConjOutputType<T>::value_type;
+    resTy *y = reinterpret_cast<resTy *>(out_y);
 
     return mkl_vm::conj(exec_q,
                         n, // number of elements to be calculated
diff --git a/dpnp/backend/extensions/vm/cos.hpp b/dpnp/backend/extensions/vm/cos.hpp
index d7212b67e1c..58cea706a0b 100644
--- a/dpnp/backend/extensions/vm/cos.hpp
+++ b/dpnp/backend/extensions/vm/cos.hpp
@@ -48,7 +48,8 @@ sycl::event cos_contig_impl(sycl::queue exec_q,
     type_utils::validate_type_for_device<T>(exec_q);
 
     const T *a = reinterpret_cast<const T *>(in_a);
-    T *y = reinterpret_cast<T *>(out_y);
+    using resTy = typename types::CosOutputType<T>::value_type;
+    resTy *y = reinterpret_cast<resTy *>(out_y);
 
     return mkl_vm::cos(exec_q,
                        n, // number of elements to be calculated
diff --git a/dpnp/backend/extensions/vm/cosh.hpp b/dpnp/backend/extensions/vm/cosh.hpp
index 4a02bf361a5..ec1a160c03e 100644
--- a/dpnp/backend/extensions/vm/cosh.hpp
+++ b/dpnp/backend/extensions/vm/cosh.hpp
@@ -48,7 +48,8 @@ sycl::event cosh_contig_impl(sycl::queue exec_q,
     type_utils::validate_type_for_device<T>(exec_q);
 
     const T *a = reinterpret_cast<const T *>(in_a);
-    T *y = reinterpret_cast<T *>(out_y);
+    using resTy = typename types::CoshOutputType<T>::value_type;
+    resTy *y = reinterpret_cast<resTy *>(out_y);
 
     return mkl_vm::cosh(exec_q,
                         n, // number of elements to be calculated
diff --git a/dpnp/backend/extensions/vm/div.hpp b/dpnp/backend/extensions/vm/div.hpp
index e309daa988d..48cbe7f000c 100644
--- a/dpnp/backend/extensions/vm/div.hpp
+++ b/dpnp/backend/extensions/vm/div.hpp
@@ -50,7 +50,8 @@ sycl::event div_contig_impl(sycl::queue exec_q,
 
     const T *a = reinterpret_cast<const T *>(in_a);
     const T *b = reinterpret_cast<const T *>(in_b);
-    T *y = reinterpret_cast<T *>(out_y);
+    using resTy = typename types::DivOutputType<T>::value_type;
+    resTy *y = reinterpret_cast<resTy *>(out_y);
 
     return mkl_vm::div(exec_q,
                        n, // number of elements to be calculated
diff --git a/dpnp/backend/extensions/vm/exp.hpp b/dpnp/backend/extensions/vm/exp.hpp
new file mode 100644
index 00000000000..e5de0e1f371
--- /dev/null
+++ b/dpnp/backend/extensions/vm/exp.hpp
@@ -0,0 +1,79 @@
+//*****************************************************************************
+// Copyright (c) 2023, Intel Corporation
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// - Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+// - Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+// THE POSSIBILITY OF SUCH DAMAGE.
+//*****************************************************************************
+
+#pragma once
+
+#include <CL/sycl.hpp>
+
+#include "common.hpp"
+#include "types_matrix.hpp"
+
+namespace dpnp
+{
+namespace backend
+{
+namespace ext
+{
+namespace vm
+{
+template <typename T>
+sycl::event exp_contig_impl(sycl::queue exec_q,
+                            const std::int64_t n,
+                            const char *in_a,
+                            char *out_y,
+                            const std::vector<sycl::event> &depends)
+{
+    type_utils::validate_type_for_device<T>(exec_q);
+
+    const T *a = reinterpret_cast<const T *>(in_a);
+    using resTy = typename types::ExpOutputType<T>::value_type;
+    resTy *y = reinterpret_cast<resTy *>(out_y);
+
+    return mkl_vm::exp(exec_q,
+                       n, // number of elements to be calculated
+                       a, // pointer `a` containing input vector of size n
+                       y, // pointer `y` to the output vector of size n
+                       depends);
+}
+
+template <typename fnT, typename T>
+struct ExpContigFactory
+{
+    fnT get()
+    {
+        if constexpr (std::is_same_v<
+                          typename types::ExpOutputType<T>::value_type, void>)
+        {
+            return nullptr;
+        }
+        else {
+            return exp_contig_impl<T>;
+        }
+    }
+};
+} // namespace vm
+} // namespace ext
+} // namespace backend
+} // namespace dpnp
diff --git a/dpnp/backend/extensions/vm/expm1.hpp b/dpnp/backend/extensions/vm/expm1.hpp
new file mode 100644
index 00000000000..6f443a99a6b
--- /dev/null
+++ b/dpnp/backend/extensions/vm/expm1.hpp
@@ -0,0 +1,79 @@
+//*****************************************************************************
+// Copyright (c) 2023, Intel Corporation
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// - Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+// - Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+// THE POSSIBILITY OF SUCH DAMAGE.
+//*****************************************************************************
+
+#pragma once
+
+#include <CL/sycl.hpp>
+
+#include "common.hpp"
+#include "types_matrix.hpp"
+
+namespace dpnp
+{
+namespace backend
+{
+namespace ext
+{
+namespace vm
+{
+template <typename T>
+sycl::event expm1_contig_impl(sycl::queue exec_q,
+                              const std::int64_t n,
+                              const char *in_a,
+                              char *out_y,
+                              const std::vector<sycl::event> &depends)
+{
+    type_utils::validate_type_for_device<T>(exec_q);
+
+    const T *a = reinterpret_cast<const T *>(in_a);
+    using resTy = typename types::Expm1OutputType<T>::value_type;
+    resTy *y = reinterpret_cast<resTy *>(out_y);
+
+    return mkl_vm::expm1(exec_q,
+                         n, // number of elements to be calculated
+                         a, // pointer `a` containing input vector of size n
+                         y, // pointer `y` to the output vector of size n
+                         depends);
+}
+
+template <typename fnT, typename T>
+struct Expm1ContigFactory
+{
+    fnT get()
+    {
+        if constexpr (std::is_same_v<
+                          typename types::Expm1OutputType<T>::value_type, void>)
+        {
+            return nullptr;
+        }
+        else {
+            return expm1_contig_impl<T>;
+        }
+    }
+};
+} // namespace vm
+} // namespace ext
+} // namespace backend
+} // namespace dpnp
diff --git a/dpnp/backend/extensions/vm/floor.hpp b/dpnp/backend/extensions/vm/floor.hpp
index 66707ba2979..ec4413909ac 100644
--- a/dpnp/backend/extensions/vm/floor.hpp
+++ b/dpnp/backend/extensions/vm/floor.hpp
@@ -48,7 +48,8 @@ sycl::event floor_contig_impl(sycl::queue exec_q,
     type_utils::validate_type_for_device<T>(exec_q);
 
     const T *a = reinterpret_cast<const T *>(in_a);
-    T *y = reinterpret_cast<T *>(out_y);
+    using resTy = typename types::FloorOutputType<T>::value_type;
+    resTy *y = reinterpret_cast<resTy *>(out_y);
 
     return mkl_vm::floor(exec_q,
                          n, // number of elements to be calculated
diff --git a/dpnp/backend/extensions/vm/hypot.hpp b/dpnp/backend/extensions/vm/hypot.hpp
new file mode 100644
index 00000000000..5e729aa7477
--- /dev/null
+++ b/dpnp/backend/extensions/vm/hypot.hpp
@@ -0,0 +1,82 @@
+//*****************************************************************************
+// Copyright (c) 2023, Intel Corporation
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// - Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+// - Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+// THE POSSIBILITY OF SUCH DAMAGE.
+//*****************************************************************************
+
+#pragma once
+
+#include <CL/sycl.hpp>
+
+#include "common.hpp"
+#include "types_matrix.hpp"
+
+namespace dpnp
+{
+namespace backend
+{
+namespace ext
+{
+namespace vm
+{
+template <typename T>
+sycl::event hypot_contig_impl(sycl::queue exec_q,
+                              const std::int64_t n,
+                              const char *in_a,
+                              const char *in_b,
+                              char *out_y,
+                              const std::vector<sycl::event> &depends)
+{
+    type_utils::validate_type_for_device<T>(exec_q);
+
+    const T *a = reinterpret_cast<const T *>(in_a);
+    const T *b = reinterpret_cast<const T *>(in_b);
+    using resTy = typename types::HypotOutputType<T>::value_type;
+    resTy *y = reinterpret_cast<resTy *>(out_y);
+
+    return mkl_vm::hypot(exec_q,
+                         n, // number of elements to be calculated
+                         a, // pointer `a` containing 1st input vector of size n
+                         b, // pointer `b` containing 2nd input vector of size n
+                         y, // pointer `y` to the output vector of size n
+                         depends);
+}
+
+template <typename fnT, typename T>
+struct HypotContigFactory
+{
+    fnT get()
+    {
+        if constexpr (std::is_same_v<
+                          typename types::HypotOutputType<T>::value_type, void>)
+        {
+            return nullptr;
+        }
+        else {
+            return hypot_contig_impl<T>;
+        }
+    }
+};
+} // namespace vm
+} // namespace ext
+} // namespace backend
+} // namespace dpnp
diff --git a/dpnp/backend/extensions/vm/ln.hpp b/dpnp/backend/extensions/vm/ln.hpp
index edf58d98724..c08440c728e 100644
--- a/dpnp/backend/extensions/vm/ln.hpp
+++ b/dpnp/backend/extensions/vm/ln.hpp
@@ -48,7 +48,8 @@ sycl::event ln_contig_impl(sycl::queue exec_q,
     type_utils::validate_type_for_device<T>(exec_q);
 
     const T *a = reinterpret_cast<const T *>(in_a);
-    T *y = reinterpret_cast<T *>(out_y);
+    using resTy = typename types::LnOutputType<T>::value_type;
+    resTy *y = reinterpret_cast<resTy *>(out_y);
 
     return mkl_vm::ln(exec_q,
                       n, // number of elements to be calculated
diff --git a/dpnp/backend/extensions/vm/log10.hpp b/dpnp/backend/extensions/vm/log10.hpp
new file mode 100644
index 00000000000..1d2556a1ffc
--- /dev/null
+++ b/dpnp/backend/extensions/vm/log10.hpp
@@ -0,0 +1,79 @@
+//*****************************************************************************
+// Copyright (c) 2023, Intel Corporation
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// - Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+// - Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+// THE POSSIBILITY OF SUCH DAMAGE.
+//*****************************************************************************
+
+#pragma once
+
+#include <CL/sycl.hpp>
+
+#include "common.hpp"
+#include "types_matrix.hpp"
+
+namespace dpnp
+{
+namespace backend
+{
+namespace ext
+{
+namespace vm
+{
+template <typename T>
+sycl::event log10_contig_impl(sycl::queue exec_q,
+                              const std::int64_t n,
+                              const char *in_a,
+                              char *out_y,
+                              const std::vector<sycl::event> &depends)
+{
+    type_utils::validate_type_for_device<T>(exec_q);
+
+    const T *a = reinterpret_cast<const T *>(in_a);
+    using resTy = typename types::Log10OutputType<T>::value_type;
+    resTy *y = reinterpret_cast<resTy *>(out_y);
+
+    return mkl_vm::log10(exec_q,
+                         n, // number of elements to be calculated
+                         a, // pointer `a` containing input vector of size n
+                         y, // pointer `y` to the output vector of size n
+                         depends);
+}
+
+template <typename fnT, typename T>
+struct Log10ContigFactory
+{
+    fnT get()
+    {
+        if constexpr (std::is_same_v<
+                          typename types::Log10OutputType<T>::value_type, void>)
+        {
+            return nullptr;
+        }
+        else {
+            return log10_contig_impl<T>;
+        }
+    }
+};
+} // namespace vm
+} // namespace ext
+} // namespace backend
+} // namespace dpnp
diff --git a/dpnp/backend/extensions/vm/log1p.hpp b/dpnp/backend/extensions/vm/log1p.hpp
new file mode 100644
index 00000000000..7b5e46752f1
--- /dev/null
+++ b/dpnp/backend/extensions/vm/log1p.hpp
@@ -0,0 +1,79 @@
+//*****************************************************************************
+// Copyright (c) 2023, Intel Corporation
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// - Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+// - Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+// THE POSSIBILITY OF SUCH DAMAGE.
+//*****************************************************************************
+
+#pragma once
+
+#include <CL/sycl.hpp>
+
+#include "common.hpp"
+#include "types_matrix.hpp"
+
+namespace dpnp
+{
+namespace backend
+{
+namespace ext
+{
+namespace vm
+{
+template <typename T>
+sycl::event log1p_contig_impl(sycl::queue exec_q,
+                              const std::int64_t n,
+                              const char *in_a,
+                              char *out_y,
+                              const std::vector<sycl::event> &depends)
+{
+    type_utils::validate_type_for_device<T>(exec_q);
+
+    const T *a = reinterpret_cast<const T *>(in_a);
+    using resTy = typename types::Log1pOutputType<T>::value_type;
+    resTy *y = reinterpret_cast<resTy *>(out_y);
+
+    return mkl_vm::log1p(exec_q,
+                         n, // number of elements to be calculated
+                         a, // pointer `a` containing input vector of size n
+                         y, // pointer `y` to the output vector of size n
+                         depends);
+}
+
+template <typename fnT, typename T>
+struct Log1pContigFactory
+{
+    fnT get()
+    {
+        if constexpr (std::is_same_v<
+                          typename types::Log1pOutputType<T>::value_type, void>)
+        {
+            return nullptr;
+        }
+        else {
+            return log1p_contig_impl<T>;
+        }
+    }
+};
+} // namespace vm
+} // namespace ext
+} // namespace backend
+} // namespace dpnp
diff --git a/dpnp/backend/extensions/vm/log2.hpp b/dpnp/backend/extensions/vm/log2.hpp
new file mode 100644
index 00000000000..2d7d359e234
--- /dev/null
+++ b/dpnp/backend/extensions/vm/log2.hpp
@@ -0,0 +1,79 @@
+//*****************************************************************************
+// Copyright (c) 2023, Intel Corporation
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// - Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+// - Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+// THE POSSIBILITY OF SUCH DAMAGE.
+//*****************************************************************************
+
+#pragma once
+
+#include <CL/sycl.hpp>
+
+#include "common.hpp"
+#include "types_matrix.hpp"
+
+namespace dpnp
+{
+namespace backend
+{
+namespace ext
+{
+namespace vm
+{
+template <typename T>
+sycl::event log2_contig_impl(sycl::queue exec_q,
+                             const std::int64_t n,
+                             const char *in_a,
+                             char *out_y,
+                             const std::vector<sycl::event> &depends)
+{
+    type_utils::validate_type_for_device<T>(exec_q);
+
+    const T *a = reinterpret_cast<const T *>(in_a);
+    using resTy = typename types::Log2OutputType<T>::value_type;
+    resTy *y = reinterpret_cast<resTy *>(out_y);
+
+    return mkl_vm::log2(exec_q,
+                        n, // number of elements to be calculated
+                        a, // pointer `a` containing input vector of size n
+                        y, // pointer `y` to the output vector of size n
+                        depends);
+}
+
+template <typename fnT, typename T>
+struct Log2ContigFactory
+{
+    fnT get()
+    {
+        if constexpr (std::is_same_v<
+                          typename types::Log2OutputType<T>::value_type, void>)
+        {
+            return nullptr;
+        }
+        else {
+            return log2_contig_impl<T>;
+        }
+    }
+};
+} // namespace vm
+} // namespace ext
+} // namespace backend
+} // namespace dpnp
diff --git a/dpnp/backend/extensions/vm/mul.hpp b/dpnp/backend/extensions/vm/mul.hpp
index 4f827a05619..52ddaae377a 100644
--- a/dpnp/backend/extensions/vm/mul.hpp
+++ b/dpnp/backend/extensions/vm/mul.hpp
@@ -50,7 +50,8 @@ sycl::event mul_contig_impl(sycl::queue exec_q,
 
     const T *a = reinterpret_cast<const T *>(in_a);
     const T *b = reinterpret_cast<const T *>(in_b);
-    T *y = reinterpret_cast<T *>(out_y);
+    using resTy = typename types::MulOutputType<T>::value_type;
+    resTy *y = reinterpret_cast<resTy *>(out_y);
 
     return mkl_vm::mul(exec_q,
                        n, // number of elements to be calculated
diff --git a/dpnp/backend/extensions/vm/pow.hpp b/dpnp/backend/extensions/vm/pow.hpp
index 5b7d13ca94f..744cbb073a6 100644
--- a/dpnp/backend/extensions/vm/pow.hpp
+++ b/dpnp/backend/extensions/vm/pow.hpp
@@ -50,7 +50,8 @@ sycl::event pow_contig_impl(sycl::queue exec_q,
 
     const T *a = reinterpret_cast<const T *>(in_a);
     const T *b = reinterpret_cast<const T *>(in_b);
-    T *y = reinterpret_cast<T *>(out_y);
+    using resTy = typename types::PowOutputType<T>::value_type;
+    resTy *y = reinterpret_cast<resTy *>(out_y);
 
     return mkl_vm::pow(exec_q,
                        n, // number of elements to be calculated
diff --git a/dpnp/backend/extensions/vm/round.hpp b/dpnp/backend/extensions/vm/round.hpp
index 0760db4d3fc..8c7ae033f49 100644
--- a/dpnp/backend/extensions/vm/round.hpp
+++ b/dpnp/backend/extensions/vm/round.hpp
@@ -48,7 +48,8 @@ sycl::event round_contig_impl(sycl::queue exec_q,
     type_utils::validate_type_for_device<T>(exec_q);
 
     const T *a = reinterpret_cast<const T *>(in_a);
-    T *y = reinterpret_cast<T *>(out_y);
+    using resTy = typename types::RoundOutputType<T>::value_type;
+    resTy *y = reinterpret_cast<resTy *>(out_y);
 
     return mkl_vm::rint(exec_q,
                         n, // number of elements to be calculated
diff --git a/dpnp/backend/extensions/vm/sin.hpp b/dpnp/backend/extensions/vm/sin.hpp
index 90fa3ad114e..adfec626885 100644
--- a/dpnp/backend/extensions/vm/sin.hpp
+++ b/dpnp/backend/extensions/vm/sin.hpp
@@ -48,7 +48,8 @@ sycl::event sin_contig_impl(sycl::queue exec_q,
     type_utils::validate_type_for_device<T>(exec_q);
 
     const T *a = reinterpret_cast<const T *>(in_a);
-    T *y = reinterpret_cast<T *>(out_y);
+    using resTy = typename types::SinOutputType<T>::value_type;
+    resTy *y = reinterpret_cast<resTy *>(out_y);
 
     return mkl_vm::sin(exec_q,
                        n, // number of elements to be calculated
diff --git a/dpnp/backend/extensions/vm/sinh.hpp b/dpnp/backend/extensions/vm/sinh.hpp
index 8b8114ad54e..b48ca06c79f 100644
--- a/dpnp/backend/extensions/vm/sinh.hpp
+++ b/dpnp/backend/extensions/vm/sinh.hpp
@@ -48,7 +48,8 @@ sycl::event sinh_contig_impl(sycl::queue exec_q,
     type_utils::validate_type_for_device<T>(exec_q);
 
     const T *a = reinterpret_cast<const T *>(in_a);
-    T *y = reinterpret_cast<T *>(out_y);
+    using resTy = typename types::SinhOutputType<T>::value_type;
+    resTy *y = reinterpret_cast<resTy *>(out_y);
 
     return mkl_vm::sinh(exec_q,
                         n, // number of elements to be calculated
diff --git a/dpnp/backend/extensions/vm/sqr.hpp b/dpnp/backend/extensions/vm/sqr.hpp
index ceb9a3896f1..7dbd96eea42 100644
--- a/dpnp/backend/extensions/vm/sqr.hpp
+++ b/dpnp/backend/extensions/vm/sqr.hpp
@@ -48,7 +48,8 @@ sycl::event sqr_contig_impl(sycl::queue exec_q,
     type_utils::validate_type_for_device<T>(exec_q);
 
     const T *a = reinterpret_cast<const T *>(in_a);
-    T *y = reinterpret_cast<T *>(out_y);
+    using resTy = typename types::SqrOutputType<T>::value_type;
+    resTy *y = reinterpret_cast<resTy *>(out_y);
 
     return mkl_vm::sqr(exec_q,
                        n, // number of elements to be calculated
diff --git a/dpnp/backend/extensions/vm/sqrt.hpp b/dpnp/backend/extensions/vm/sqrt.hpp
index df20ee4b050..f819c49723e 100644
--- a/dpnp/backend/extensions/vm/sqrt.hpp
+++ b/dpnp/backend/extensions/vm/sqrt.hpp
@@ -48,7 +48,8 @@ sycl::event sqrt_contig_impl(sycl::queue exec_q,
     type_utils::validate_type_for_device<T>(exec_q);
 
     const T *a = reinterpret_cast<const T *>(in_a);
-    T *y = reinterpret_cast<T *>(out_y);
+    using resTy = typename types::SqrtOutputType<T>::value_type;
+    resTy *y = reinterpret_cast<resTy *>(out_y);
 
     return mkl_vm::sqrt(exec_q,
                         n, // number of elements to be calculated
diff --git a/dpnp/backend/extensions/vm/sub.hpp b/dpnp/backend/extensions/vm/sub.hpp
index f7bec14d48b..e2b25b4b798 100644
--- a/dpnp/backend/extensions/vm/sub.hpp
+++ b/dpnp/backend/extensions/vm/sub.hpp
@@ -50,7 +50,8 @@ sycl::event sub_contig_impl(sycl::queue exec_q,
 
     const T *a = reinterpret_cast<const T *>(in_a);
     const T *b = reinterpret_cast<const T *>(in_b);
-    T *y = reinterpret_cast<T *>(out_y);
+    using resTy = typename types::SubOutputType<T>::value_type;
+    resTy *y = reinterpret_cast<resTy *>(out_y);
 
     return mkl_vm::sub(exec_q,
                        n, // number of elements to be calculated
diff --git a/dpnp/backend/extensions/vm/tan.hpp b/dpnp/backend/extensions/vm/tan.hpp
index 4a9d0cc5e2e..d9d7a025fd6 100644
--- a/dpnp/backend/extensions/vm/tan.hpp
+++ b/dpnp/backend/extensions/vm/tan.hpp
@@ -48,7 +48,8 @@ sycl::event tan_contig_impl(sycl::queue exec_q,
     type_utils::validate_type_for_device<T>(exec_q);
 
     const T *a = reinterpret_cast<const T *>(in_a);
-    T *y = reinterpret_cast<T *>(out_y);
+    using resTy = typename types::TanOutputType<T>::value_type;
+    resTy *y = reinterpret_cast<resTy *>(out_y);
 
     return mkl_vm::tan(exec_q,
                        n, // number of elements to be calculated
diff --git a/dpnp/backend/extensions/vm/tanh.hpp b/dpnp/backend/extensions/vm/tanh.hpp
index ed1be8f8d52..068f93185d4 100644
--- a/dpnp/backend/extensions/vm/tanh.hpp
+++ b/dpnp/backend/extensions/vm/tanh.hpp
@@ -48,7 +48,8 @@ sycl::event tanh_contig_impl(sycl::queue exec_q,
     type_utils::validate_type_for_device<T>(exec_q);
 
     const T *a = reinterpret_cast<const T *>(in_a);
-    T *y = reinterpret_cast<T *>(out_y);
+    using resTy = typename types::TanhOutputType<T>::value_type;
+    resTy *y = reinterpret_cast<resTy *>(out_y);
 
     return mkl_vm::tanh(exec_q,
                         n, // number of elements to be calculated
diff --git a/dpnp/backend/extensions/vm/trunc.hpp b/dpnp/backend/extensions/vm/trunc.hpp
index d8ecadff363..1950bbdcc57 100644
--- a/dpnp/backend/extensions/vm/trunc.hpp
+++ b/dpnp/backend/extensions/vm/trunc.hpp
@@ -48,7 +48,8 @@ sycl::event trunc_contig_impl(sycl::queue exec_q,
     type_utils::validate_type_for_device<T>(exec_q);
 
     const T *a = reinterpret_cast<const T *>(in_a);
-    T *y = reinterpret_cast<T *>(out_y);
+    using resTy = typename types::TruncOutputType<T>::value_type;
+    resTy *y = reinterpret_cast<resTy *>(out_y);
 
     return mkl_vm::trunc(exec_q,
                          n, // number of elements to be calculated
diff --git a/dpnp/backend/extensions/vm/types_matrix.hpp b/dpnp/backend/extensions/vm/types_matrix.hpp
index bbf74ed8c86..03328f92fb3 100644
--- a/dpnp/backend/extensions/vm/types_matrix.hpp
+++ b/dpnp/backend/extensions/vm/types_matrix.hpp
@@ -43,6 +43,23 @@ namespace vm
 {
 namespace types
 {
+/**
+ * @brief A factory to define pairs of supported types for which
+ * MKL VM library provides support in oneapi::mkl::vm::abs<T> function.
+ *
+ * @tparam T Type of input vector `a` and of result vector `y`.
+ */
+template <typename T>
+struct AbsOutputType
+{
+    using value_type = typename std::disjunction<
+        dpctl_td_ns::TypeMapResultEntry<T, std::complex<double>, double>,
+        dpctl_td_ns::TypeMapResultEntry<T, std::complex<float>, float>,
+        dpctl_td_ns::TypeMapResultEntry<T, double>,
+        dpctl_td_ns::TypeMapResultEntry<T, float>,
+        dpctl_td_ns::DefaultResultEntry<void>>::result_type;
+};
+
 /**
  * @brief A factory to define pairs of supported types for which
  * MKL VM library provides support in oneapi::mkl::vm::acos<T> function.
@@ -195,8 +212,8 @@ template <typename T>
 struct CeilOutputType
 {
     using value_type = typename std::disjunction<
-        dpctl_td_ns::TypeMapResultEntry<T, double, double>,
-        dpctl_td_ns::TypeMapResultEntry<T, float, float>,
+        dpctl_td_ns::TypeMapResultEntry<T, double>,
+        dpctl_td_ns::TypeMapResultEntry<T, float>,
         dpctl_td_ns::DefaultResultEntry<void>>::result_type;
 };
 
@@ -210,10 +227,8 @@ template <typename T>
 struct ConjOutputType
 {
     using value_type = typename std::disjunction<
-        dpctl_td_ns::
-            TypeMapResultEntry<T, std::complex<double>, std::complex<double>>,
-        dpctl_td_ns::
-            TypeMapResultEntry<T, std::complex<float>, std::complex<float>>,
+        dpctl_td_ns::TypeMapResultEntry<T, std::complex<double>>,
+        dpctl_td_ns::TypeMapResultEntry<T, std::complex<float>>,
         dpctl_td_ns::DefaultResultEntry<void>>::result_type;
 };
 
@@ -229,8 +244,8 @@ struct CosOutputType
     using value_type = typename std::disjunction<
         dpctl_td_ns::TypeMapResultEntry<T, std::complex<double>>,
         dpctl_td_ns::TypeMapResultEntry<T, std::complex<float>>,
-        dpctl_td_ns::TypeMapResultEntry<T, double, double>,
-        dpctl_td_ns::TypeMapResultEntry<T, float, float>,
+        dpctl_td_ns::TypeMapResultEntry<T, double>,
+        dpctl_td_ns::TypeMapResultEntry<T, float>,
         dpctl_td_ns::DefaultResultEntry<void>>::result_type;
 };
 
@@ -246,8 +261,8 @@ struct CoshOutputType
     using value_type = typename std::disjunction<
         dpctl_td_ns::TypeMapResultEntry<T, std::complex<double>>,
         dpctl_td_ns::TypeMapResultEntry<T, std::complex<float>>,
-        dpctl_td_ns::TypeMapResultEntry<T, double, double>,
-        dpctl_td_ns::TypeMapResultEntry<T, float, float>,
+        dpctl_td_ns::TypeMapResultEntry<T, double>,
+        dpctl_td_ns::TypeMapResultEntry<T, float>,
         dpctl_td_ns::DefaultResultEntry<void>>::result_type;
 };
 
@@ -276,6 +291,38 @@ struct DivOutputType
         dpctl_td_ns::DefaultResultEntry<void>>::result_type;
 };
 
+/**
+ * @brief A factory to define pairs of supported types for which
+ * MKL VM library provides support in oneapi::mkl::vm::exp<T> function.
+ *
+ * @tparam T Type of input vector `a` and of result vector `y`.
+ */
+template <typename T>
+struct ExpOutputType
+{
+    using value_type = typename std::disjunction<
+        dpctl_td_ns::TypeMapResultEntry<T, std::complex<double>>,
+        dpctl_td_ns::TypeMapResultEntry<T, std::complex<float>>,
+        dpctl_td_ns::TypeMapResultEntry<T, double>,
+        dpctl_td_ns::TypeMapResultEntry<T, float>,
+        dpctl_td_ns::DefaultResultEntry<void>>::result_type;
+};
+
+/**
+ * @brief A factory to define pairs of supported types for which
+ * MKL VM library provides support in oneapi::mkl::vm::expm1<T> function.
+ *
+ * @tparam T Type of input vector `a` and of result vector `y`.
+ */
+template <typename T>
+struct Expm1OutputType
+{
+    using value_type = typename std::disjunction<
+        dpctl_td_ns::TypeMapResultEntry<T, double>,
+        dpctl_td_ns::TypeMapResultEntry<T, float>,
+        dpctl_td_ns::DefaultResultEntry<void>>::result_type;
+};
+
 /**
  * @brief A factory to define pairs of supported types for which
  * MKL VM library provides support in oneapi::mkl::vm::floor<T> function.
@@ -286,8 +333,23 @@ template <typename T>
 struct FloorOutputType
 {
     using value_type = typename std::disjunction<
-        dpctl_td_ns::TypeMapResultEntry<T, double, double>,
-        dpctl_td_ns::TypeMapResultEntry<T, float, float>,
+        dpctl_td_ns::TypeMapResultEntry<T, double>,
+        dpctl_td_ns::TypeMapResultEntry<T, float>,
+        dpctl_td_ns::DefaultResultEntry<void>>::result_type;
+};
+
+/**
+ * @brief A factory to define pairs of supported types for which
+ * MKL VM library provides support in oneapi::mkl::vm::hypot<T> function.
+ *
+ * @tparam T Type of input vectors `a` and `b` and of result vector `y`.
+ */
+template <typename T>
+struct HypotOutputType
+{
+    using value_type = typename std::disjunction<
+        dpctl_td_ns::BinaryTypeMapResultEntry<T, double, T, double, double>,
+        dpctl_td_ns::BinaryTypeMapResultEntry<T, float, T, float, float>,
         dpctl_td_ns::DefaultResultEntry<void>>::result_type;
 };
 
@@ -301,12 +363,57 @@ template <typename T>
 struct LnOutputType
 {
     using value_type = typename std::disjunction<
-        dpctl_td_ns::
-            TypeMapResultEntry<T, std::complex<double>, std::complex<double>>,
-        dpctl_td_ns::
-            TypeMapResultEntry<T, std::complex<float>, std::complex<float>>,
-        dpctl_td_ns::TypeMapResultEntry<T, double, double>,
-        dpctl_td_ns::TypeMapResultEntry<T, float, float>,
+        dpctl_td_ns::TypeMapResultEntry<T, std::complex<double>>,
+        dpctl_td_ns::TypeMapResultEntry<T, std::complex<float>>,
+        dpctl_td_ns::TypeMapResultEntry<T, double>,
+        dpctl_td_ns::TypeMapResultEntry<T, float>,
+        dpctl_td_ns::DefaultResultEntry<void>>::result_type;
+};
+
+/**
+ * @brief A factory to define pairs of supported types for which
+ * MKL VM library provides support in oneapi::mkl::vm::log10<T> function.
+ *
+ * @tparam T Type of input vector `a` and of result vector `y`.
+ */
+template <typename T>
+struct Log10OutputType
+{
+    using value_type = typename std::disjunction<
+        dpctl_td_ns::TypeMapResultEntry<T, std::complex<double>>,
+        dpctl_td_ns::TypeMapResultEntry<T, std::complex<float>>,
+        dpctl_td_ns::TypeMapResultEntry<T, double>,
+        dpctl_td_ns::TypeMapResultEntry<T, float>,
+        dpctl_td_ns::DefaultResultEntry<void>>::result_type;
+};
+
+/**
+ * @brief A factory to define pairs of supported types for which
+ * MKL VM library provides support in oneapi::mkl::vm::log1p<T> function.
+ *
+ * @tparam T Type of input vector `a` and of result vector `y`.
+ */
+template <typename T>
+struct Log1pOutputType
+{
+    using value_type = typename std::disjunction<
+        dpctl_td_ns::TypeMapResultEntry<T, double>,
+        dpctl_td_ns::TypeMapResultEntry<T, float>,
+        dpctl_td_ns::DefaultResultEntry<void>>::result_type;
+};
+
+/**
+ * @brief A factory to define pairs of supported types for which
+ * MKL VM library provides support in oneapi::mkl::vm::log2<T> function.
+ *
+ * @tparam T Type of input vector `a` and of result vector `y`.
+ */
+template <typename T>
+struct Log2OutputType
+{
+    using value_type = typename std::disjunction<
+        dpctl_td_ns::TypeMapResultEntry<T, double>,
+        dpctl_td_ns::TypeMapResultEntry<T, float>,
         dpctl_td_ns::DefaultResultEntry<void>>::result_type;
 };
 
@@ -370,8 +477,8 @@ template <typename T>
 struct RoundOutputType
 {
     using value_type = typename std::disjunction<
-        dpctl_td_ns::TypeMapResultEntry<T, double, double>,
-        dpctl_td_ns::TypeMapResultEntry<T, float, float>,
+        dpctl_td_ns::TypeMapResultEntry<T, double>,
+        dpctl_td_ns::TypeMapResultEntry<T, float>,
         dpctl_td_ns::DefaultResultEntry<void>>::result_type;
 };
 
@@ -387,8 +494,8 @@ struct SinOutputType
     using value_type = typename std::disjunction<
         dpctl_td_ns::TypeMapResultEntry<T, std::complex<double>>,
         dpctl_td_ns::TypeMapResultEntry<T, std::complex<float>>,
-        dpctl_td_ns::TypeMapResultEntry<T, double, double>,
-        dpctl_td_ns::TypeMapResultEntry<T, float, float>,
+        dpctl_td_ns::TypeMapResultEntry<T, double>,
+        dpctl_td_ns::TypeMapResultEntry<T, float>,
         dpctl_td_ns::DefaultResultEntry<void>>::result_type;
 };
 
@@ -404,8 +511,8 @@ struct SinhOutputType
     using value_type = typename std::disjunction<
         dpctl_td_ns::TypeMapResultEntry<T, std::complex<double>>,
         dpctl_td_ns::TypeMapResultEntry<T, std::complex<float>>,
-        dpctl_td_ns::TypeMapResultEntry<T, double, double>,
-        dpctl_td_ns::TypeMapResultEntry<T, float, float>,
+        dpctl_td_ns::TypeMapResultEntry<T, double>,
+        dpctl_td_ns::TypeMapResultEntry<T, float>,
         dpctl_td_ns::DefaultResultEntry<void>>::result_type;
 };
 
@@ -419,8 +526,8 @@ template <typename T>
 struct SqrOutputType
 {
     using value_type = typename std::disjunction<
-        dpctl_td_ns::TypeMapResultEntry<T, double, double>,
-        dpctl_td_ns::TypeMapResultEntry<T, float, float>,
+        dpctl_td_ns::TypeMapResultEntry<T, double>,
+        dpctl_td_ns::TypeMapResultEntry<T, float>,
         dpctl_td_ns::DefaultResultEntry<void>>::result_type;
 };
 
@@ -434,12 +541,10 @@ template <typename T>
 struct SqrtOutputType
 {
     using value_type = typename std::disjunction<
-        dpctl_td_ns::
-            TypeMapResultEntry<T, std::complex<double>, std::complex<double>>,
-        dpctl_td_ns::
-            TypeMapResultEntry<T, std::complex<float>, std::complex<float>>,
-        dpctl_td_ns::TypeMapResultEntry<T, double, double>,
-        dpctl_td_ns::TypeMapResultEntry<T, float, float>,
+        dpctl_td_ns::TypeMapResultEntry<T, std::complex<double>>,
+        dpctl_td_ns::TypeMapResultEntry<T, std::complex<float>>,
+        dpctl_td_ns::TypeMapResultEntry<T, double>,
+        dpctl_td_ns::TypeMapResultEntry<T, float>,
         dpctl_td_ns::DefaultResultEntry<void>>::result_type;
 };
 
@@ -512,8 +617,8 @@ template <typename T>
 struct TruncOutputType
 {
     using value_type = typename std::disjunction<
-        dpctl_td_ns::TypeMapResultEntry<T, double, double>,
-        dpctl_td_ns::TypeMapResultEntry<T, float, float>,
+        dpctl_td_ns::TypeMapResultEntry<T, double>,
+        dpctl_td_ns::TypeMapResultEntry<T, float>,
         dpctl_td_ns::DefaultResultEntry<void>>::result_type;
 };
 
diff --git a/dpnp/backend/extensions/vm/vm_py.cpp b/dpnp/backend/extensions/vm/vm_py.cpp
index e4d89ff6e84..a7dfce88a7a 100644
--- a/dpnp/backend/extensions/vm/vm_py.cpp
+++ b/dpnp/backend/extensions/vm/vm_py.cpp
@@ -30,6 +30,7 @@
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 
+#include "abs.hpp"
 #include "acos.hpp"
 #include "acosh.hpp"
 #include "add.hpp"
@@ -44,8 +45,14 @@
 #include "cos.hpp"
 #include "cosh.hpp"
 #include "div.hpp"
+#include "exp.hpp"
+#include "expm1.hpp"
 #include "floor.hpp"
+#include "hypot.hpp"
 #include "ln.hpp"
+#include "log10.hpp"
+#include "log1p.hpp"
+#include "log2.hpp"
 #include "mul.hpp"
 #include "pow.hpp"
 #include "round.hpp"
@@ -65,6 +72,7 @@ namespace vm_ext = dpnp::backend::ext::vm;
 using vm_ext::binary_impl_fn_ptr_t;
 using vm_ext::unary_impl_fn_ptr_t;
 
+static unary_impl_fn_ptr_t abs_dispatch_vector[dpctl_td_ns::num_types];
 static unary_impl_fn_ptr_t acos_dispatch_vector[dpctl_td_ns::num_types];
 static unary_impl_fn_ptr_t acosh_dispatch_vector[dpctl_td_ns::num_types];
 static binary_impl_fn_ptr_t add_dispatch_vector[dpctl_td_ns::num_types];
@@ -74,12 +82,18 @@ static unary_impl_fn_ptr_t atan_dispatch_vector[dpctl_td_ns::num_types];
 static binary_impl_fn_ptr_t atan2_dispatch_vector[dpctl_td_ns::num_types];
 static unary_impl_fn_ptr_t atanh_dispatch_vector[dpctl_td_ns::num_types];
 static unary_impl_fn_ptr_t ceil_dispatch_vector[dpctl_td_ns::num_types];
+static unary_impl_fn_ptr_t conj_dispatch_vector[dpctl_td_ns::num_types];
 static unary_impl_fn_ptr_t cos_dispatch_vector[dpctl_td_ns::num_types];
 static unary_impl_fn_ptr_t cosh_dispatch_vector[dpctl_td_ns::num_types];
 static binary_impl_fn_ptr_t div_dispatch_vector[dpctl_td_ns::num_types];
+static unary_impl_fn_ptr_t exp_dispatch_vector[dpctl_td_ns::num_types];
+static unary_impl_fn_ptr_t expm1_dispatch_vector[dpctl_td_ns::num_types];
 static unary_impl_fn_ptr_t floor_dispatch_vector[dpctl_td_ns::num_types];
-static unary_impl_fn_ptr_t conj_dispatch_vector[dpctl_td_ns::num_types];
+static binary_impl_fn_ptr_t hypot_dispatch_vector[dpctl_td_ns::num_types];
 static unary_impl_fn_ptr_t ln_dispatch_vector[dpctl_td_ns::num_types];
+static unary_impl_fn_ptr_t log10_dispatch_vector[dpctl_td_ns::num_types];
+static unary_impl_fn_ptr_t log1p_dispatch_vector[dpctl_td_ns::num_types];
+static unary_impl_fn_ptr_t log2_dispatch_vector[dpctl_td_ns::num_types];
 static binary_impl_fn_ptr_t mul_dispatch_vector[dpctl_td_ns::num_types];
 static binary_impl_fn_ptr_t pow_dispatch_vector[dpctl_td_ns::num_types];
 static unary_impl_fn_ptr_t round_dispatch_vector[dpctl_td_ns::num_types];
@@ -97,6 +111,34 @@ PYBIND11_MODULE(_vm_impl, m)
     using arrayT = dpctl::tensor::usm_ndarray;
     using event_vecT = std::vector<sycl::event>;
 
+    // UnaryUfunc: ==== Abs(x) ====
+    {
+        vm_ext::init_ufunc_dispatch_vector<unary_impl_fn_ptr_t,
+                                           vm_ext::AbsContigFactory>(
+            abs_dispatch_vector);
+
+        auto abs_pyapi = [&](sycl::queue exec_q, arrayT src, arrayT dst,
+                             const event_vecT &depends = {}) {
+            return vm_ext::unary_ufunc(exec_q, src, dst, depends,
+                                       abs_dispatch_vector);
+        };
+        m.def("_abs", abs_pyapi,
+              "Call `abs` function from OneMKL VM library to compute "
+              "the absolute value of vector elements",
+              py::arg("sycl_queue"), py::arg("src"), py::arg("dst"),
+              py::arg("depends") = py::list());
+
+        auto abs_need_to_call_pyapi = [&](sycl::queue exec_q, arrayT src,
+                                          arrayT dst) {
+            return vm_ext::need_to_call_unary_ufunc(exec_q, src, dst,
+                                                    abs_dispatch_vector);
+        };
+        m.def("_mkl_abs_to_call", abs_need_to_call_pyapi,
+              "Check input arguments to answer if `abs` function from "
+              "OneMKL VM library can be used",
+              py::arg("sycl_queue"), py::arg("src"), py::arg("dst"));
+    }
+
     // UnaryUfunc: ==== Acos(x) ====
     {
         vm_ext::init_ufunc_dispatch_vector<unary_impl_fn_ptr_t,
@@ -466,6 +508,62 @@ PYBIND11_MODULE(_vm_impl, m)
               py::arg("dst"));
     }
 
+    // UnaryUfunc: ==== Exp(x) ====
+    {
+        vm_ext::init_ufunc_dispatch_vector<unary_impl_fn_ptr_t,
+                                           vm_ext::ExpContigFactory>(
+            exp_dispatch_vector);
+
+        auto exp_pyapi = [&](sycl::queue exec_q, arrayT src, arrayT dst,
+                             const event_vecT &depends = {}) {
+            return vm_ext::unary_ufunc(exec_q, src, dst, depends,
+                                       exp_dispatch_vector);
+        };
+        m.def("_exp", exp_pyapi,
+              "Call `exp` function from OneMKL VM library to compute "
+              "natural (base-e) exponential of vector elements",
+              py::arg("sycl_queue"), py::arg("src"), py::arg("dst"),
+              py::arg("depends") = py::list());
+
+        auto exp_need_to_call_pyapi = [&](sycl::queue exec_q, arrayT src,
+                                          arrayT dst) {
+            return vm_ext::need_to_call_unary_ufunc(exec_q, src, dst,
+                                                    exp_dispatch_vector);
+        };
+        m.def("_mkl_exp_to_call", exp_need_to_call_pyapi,
+              "Check input arguments to answer if `exp` function from "
+              "OneMKL VM library can be used",
+              py::arg("sycl_queue"), py::arg("src"), py::arg("dst"));
+    }
+
+    // UnaryUfunc: ==== expm1(x) ====
+    {
+        vm_ext::init_ufunc_dispatch_vector<unary_impl_fn_ptr_t,
+                                           vm_ext::Expm1ContigFactory>(
+            expm1_dispatch_vector);
+
+        auto expm1_pyapi = [&](sycl::queue exec_q, arrayT src, arrayT dst,
+                               const event_vecT &depends = {}) {
+            return vm_ext::unary_ufunc(exec_q, src, dst, depends,
+                                       expm1_dispatch_vector);
+        };
+        m.def("_expm1", expm1_pyapi,
+              "Call `expm1` function from OneMKL VM library to compute "
+              "subtraction of 1 from the exponential of vector elements",
+              py::arg("sycl_queue"), py::arg("src"), py::arg("dst"),
+              py::arg("depends") = py::list());
+
+        auto expm1_need_to_call_pyapi = [&](sycl::queue exec_q, arrayT src,
+                                            arrayT dst) {
+            return vm_ext::need_to_call_unary_ufunc(exec_q, src, dst,
+                                                    expm1_dispatch_vector);
+        };
+        m.def("_mkl_expm1_to_call", expm1_need_to_call_pyapi,
+              "Check input arguments to answer if `expm1` function from "
+              "OneMKL VM library can be used",
+              py::arg("sycl_queue"), py::arg("src"), py::arg("dst"));
+    }
+
     // UnaryUfunc: ==== Floor(x) ====
     {
         vm_ext::init_ufunc_dispatch_vector<unary_impl_fn_ptr_t,
@@ -494,6 +592,35 @@ PYBIND11_MODULE(_vm_impl, m)
               py::arg("sycl_queue"), py::arg("src"), py::arg("dst"));
     }
 
+    // BinaryUfunc: ==== Hypot(x1, x2) ====
+    {
+        vm_ext::init_ufunc_dispatch_vector<binary_impl_fn_ptr_t,
+                                           vm_ext::HypotContigFactory>(
+            hypot_dispatch_vector);
+
+        auto hypot_pyapi = [&](sycl::queue exec_q, arrayT src1, arrayT src2,
+                               arrayT dst, const event_vecT &depends = {}) {
+            return vm_ext::binary_ufunc(exec_q, src1, src2, dst, depends,
+                                        hypot_dispatch_vector);
+        };
+        m.def("_hypot", hypot_pyapi,
+              "Call `hypot` function from OneMKL VM library to compute element "
+              "by element hypotenuse of `x`",
+              py::arg("sycl_queue"), py::arg("src1"), py::arg("src2"),
+              py::arg("dst"), py::arg("depends") = py::list());
+
+        auto hypot_need_to_call_pyapi = [&](sycl::queue exec_q, arrayT src1,
+                                            arrayT src2, arrayT dst) {
+            return vm_ext::need_to_call_binary_ufunc(exec_q, src1, src2, dst,
+                                                     hypot_dispatch_vector);
+        };
+        m.def("_mkl_hypot_to_call", hypot_need_to_call_pyapi,
+              "Check input arguments to answer if `hypot` function from "
+              "OneMKL VM library can be used",
+              py::arg("sycl_queue"), py::arg("src1"), py::arg("src2"),
+              py::arg("dst"));
+    }
+
     // UnaryUfunc: ==== Ln(x) ====
     {
         vm_ext::init_ufunc_dispatch_vector<unary_impl_fn_ptr_t,
@@ -522,6 +649,90 @@ PYBIND11_MODULE(_vm_impl, m)
               py::arg("sycl_queue"), py::arg("src"), py::arg("dst"));
     }
 
+    // UnaryUfunc: ==== Log10(x) ====
+    {
+        vm_ext::init_ufunc_dispatch_vector<unary_impl_fn_ptr_t,
+                                           vm_ext::Log10ContigFactory>(
+            log10_dispatch_vector);
+
+        auto log10_pyapi = [&](sycl::queue exec_q, arrayT src, arrayT dst,
+                               const event_vecT &depends = {}) {
+            return vm_ext::unary_ufunc(exec_q, src, dst, depends,
+                                       log10_dispatch_vector);
+        };
+        m.def("_log10", log10_pyapi,
+              "Call `log10` function from OneMKL VM library to compute "
+              "base-10 logarithm of vector elements",
+              py::arg("sycl_queue"), py::arg("src"), py::arg("dst"),
+              py::arg("depends") = py::list());
+
+        auto log10_need_to_call_pyapi = [&](sycl::queue exec_q, arrayT src,
+                                            arrayT dst) {
+            return vm_ext::need_to_call_unary_ufunc(exec_q, src, dst,
+                                                    log10_dispatch_vector);
+        };
+        m.def("_mkl_log10_to_call", log10_need_to_call_pyapi,
+              "Check input arguments to answer if `log10` function from "
+              "OneMKL VM library can be used",
+              py::arg("sycl_queue"), py::arg("src"), py::arg("dst"));
+    }
+
+    // UnaryUfunc: ==== Log1p(x) ====
+    {
+        vm_ext::init_ufunc_dispatch_vector<unary_impl_fn_ptr_t,
+                                           vm_ext::Log1pContigFactory>(
+            log1p_dispatch_vector);
+
+        auto log1p_pyapi = [&](sycl::queue exec_q, arrayT src, arrayT dst,
+                               const event_vecT &depends = {}) {
+            return vm_ext::unary_ufunc(exec_q, src, dst, depends,
+                                       log1p_dispatch_vector);
+        };
+        m.def("_log1p", log1p_pyapi,
+              "Call `log1p` function from OneMKL VM library to compute "
+              "natural logarithm of 1 plus vector elements",
+              py::arg("sycl_queue"), py::arg("src"), py::arg("dst"),
+              py::arg("depends") = py::list());
+
+        auto log1p_need_to_call_pyapi = [&](sycl::queue exec_q, arrayT src,
+                                            arrayT dst) {
+            return vm_ext::need_to_call_unary_ufunc(exec_q, src, dst,
+                                                    log1p_dispatch_vector);
+        };
+        m.def("_mkl_log1p_to_call", log1p_need_to_call_pyapi,
+              "Check input arguments to answer if `log1p` function from "
+              "OneMKL VM library can be used",
+              py::arg("sycl_queue"), py::arg("src"), py::arg("dst"));
+    }
+
+    // UnaryUfunc: ==== Log2(x) ====
+    {
+        vm_ext::init_ufunc_dispatch_vector<unary_impl_fn_ptr_t,
+                                           vm_ext::Log2ContigFactory>(
+            log2_dispatch_vector);
+
+        auto log2_pyapi = [&](sycl::queue exec_q, arrayT src, arrayT dst,
+                              const event_vecT &depends = {}) {
+            return vm_ext::unary_ufunc(exec_q, src, dst, depends,
+                                       log2_dispatch_vector);
+        };
+        m.def("_log2", log2_pyapi,
+              "Call `log2` function from OneMKL VM library to compute "
+              "base-2 logarithm of vector elements",
+              py::arg("sycl_queue"), py::arg("src"), py::arg("dst"),
+              py::arg("depends") = py::list());
+
+        auto log2_need_to_call_pyapi = [&](sycl::queue exec_q, arrayT src,
+                                           arrayT dst) {
+            return vm_ext::need_to_call_unary_ufunc(exec_q, src, dst,
+                                                    log2_dispatch_vector);
+        };
+        m.def("_mkl_log2_to_call", log2_need_to_call_pyapi,
+              "Check input arguments to answer if `log2` function from "
+              "OneMKL VM library can be used",
+              py::arg("sycl_queue"), py::arg("src"), py::arg("dst"));
+    }
+
     // BinaryUfunc: ==== Mul(x1, x2) ====
     {
         vm_ext::init_ufunc_dispatch_vector<binary_impl_fn_ptr_t,
diff --git a/dpnp/backend/include/dpnp_iface.hpp b/dpnp/backend/include/dpnp_iface.hpp
index 994fa05a012..0cbcfab9f96 100644
--- a/dpnp/backend/include/dpnp_iface.hpp
+++ b/dpnp/backend/include/dpnp_iface.hpp
@@ -1015,7 +1015,7 @@ INP_DLLEXPORT void
  *
  * @param [in]  q_ref               Reference to SYCL queue.
  * @param [in]  array               Input array with data.
- * @param [out] result              Output array with indeces.
+ * @param [out] result              Output array with indices.
  * @param [in]  size                Number of elements in input arrays.
  * @param [in]  dep_event_vec_ref   Reference to vector of SYCL events.
  */
@@ -1069,7 +1069,7 @@ INP_DLLEXPORT void dpnp_searchsorted_c(void *result,
  *
  * @param [in]  q_ref               Reference to SYCL queue.
  * @param [in]  array               Input array with data.
- * @param [out] result              Output array with indeces.
+ * @param [out] result              Output array with indices.
  * @param [in]  size                Number of elements in input arrays.
  * @param [in]  dep_event_vec_ref   Reference to vector of SYCL events.
  */
@@ -1564,7 +1564,7 @@ INP_DLLEXPORT void dpnp_min_c(void *array,
  *
  * @param [in]  q_ref               Reference to SYCL queue.
  * @param [in]  array               Input array with data.
- * @param [out] result              Output array with indeces.
+ * @param [out] result              Output array with indices.
  * @param [in]  size                Number of elements in input array.
  * @param [in]  dep_event_vec_ref   Reference to vector of SYCL events.
  */
@@ -1585,7 +1585,7 @@ INP_DLLEXPORT void dpnp_argmax_c(void *array, void *result, size_t size);
  *
  * @param [in]  q_ref               Reference to SYCL queue.
  * @param [in]  array               Input array with data.
- * @param [out] result              Output array with indeces.
+ * @param [out] result              Output array with indices.
  * @param [in]  size                Number of elements in input array.
  * @param [in]  dep_event_vec_ref   Reference to vector of SYCL events.
  */
@@ -1606,7 +1606,7 @@ INP_DLLEXPORT void dpnp_argmin_c(void *array, void *result, size_t size);
  *
  * @param [in]  q_ref               Reference to SYCL queue.
  * @param [in]  input_in            Input array with data.
- * @param [out] result_out          Output array with indeces.
+ * @param [out] result_out          Output array with indices.
  * @param [in]  input_size          Number of elements in input arrays.
  * @param [in]  decimals            Number of decimal places to round. Support
  * only with default value 0.
@@ -1633,7 +1633,7 @@ INP_DLLEXPORT void dpnp_around_c(const void *input_in,
  *
  * @param [in]  q_ref               Reference to SYCL queue.
  * @param [in]  array               Input array with data.
- * @param [out] result              Output array with indeces.
+ * @param [out] result              Output array with indices.
  * @param [in]  shape               Shape of input array.
  * @param [in]  ndim                Number of elements in shape.
  * @param [in]  axis                Axis.
@@ -1819,7 +1819,7 @@ INP_DLLEXPORT void dpnp_triu_c(void *array,
  *
  * @param [in]  q_ref               Reference to SYCL queue.
  * @param [in]  array               Input array with data.
- * @param [out] result              Output array with indeces.
+ * @param [out] result              Output array with indices.
  * @param [in]  shape               Shape of input array.
  * @param [in]  ndim                Number of elements in shape.
  * @param [in]  axis                Axis.
diff --git a/dpnp/backend/include/dpnp_iface_fptr.hpp b/dpnp/backend/include/dpnp_iface_fptr.hpp
index dd9a9a97df3..6f282e1e1f6 100644
--- a/dpnp/backend/include/dpnp_iface_fptr.hpp
+++ b/dpnp/backend/include/dpnp_iface_fptr.hpp
@@ -58,11 +58,9 @@
  */
 enum class DPNPFuncName : size_t
 {
-    DPNP_FN_NONE,         /**< Very first element of the enumeration */
-    DPNP_FN_ABSOLUTE,     /**< Used in numpy.absolute() impl  */
-    DPNP_FN_ABSOLUTE_EXT, /**< Used in numpy.absolute() impl, requires extra
-                             parameters */
-    DPNP_FN_ADD,          /**< Used in numpy.add() impl  */
+    DPNP_FN_NONE,     /**< Very first element of the enumeration */
+    DPNP_FN_ABSOLUTE, /**< Used in numpy.absolute() impl  */
+    DPNP_FN_ADD,      /**< Used in numpy.add() impl  */
     DPNP_FN_ADD_EXT, /**< Used in numpy.add() impl, requires extra parameters */
     DPNP_FN_ALL,     /**< Used in numpy.all() impl  */
     DPNP_FN_ALLCLOSE,     /**< Used in numpy.allclose() impl  */
@@ -88,8 +86,6 @@ enum class DPNPFuncName : size_t
                              parameters */
     DPNP_FN_AROUND,       /**< Used in numpy.around() impl  */
     DPNP_FN_ASTYPE,       /**< Used in numpy.astype() impl  */
-    DPNP_FN_ASTYPE_EXT,   /**< Used in numpy.astype() impl, requires extra
-                             parameters */
     DPNP_FN_BITWISE_AND,  /**< Used in numpy.bitwise_and() impl  */
     DPNP_FN_BITWISE_OR,   /**< Used in numpy.bitwise_or() impl  */
     DPNP_FN_BITWISE_XOR,  /**< Used in numpy.bitwise_xor() impl  */
@@ -119,25 +115,23 @@ enum class DPNPFuncName : size_t
     DPNP_FN_COS,           /**< Used in numpy.cos() impl  */
     DPNP_FN_COSH,          /**< Used in numpy.cosh() impl  */
     DPNP_FN_COUNT_NONZERO, /**< Used in numpy.count_nonzero() impl  */
-    DPNP_FN_COUNT_NONZERO_EXT, /**< Used in numpy.count_nonzero() impl, requires
-                                  extra parameters */
-    DPNP_FN_COV,               /**< Used in numpy.cov() impl  */
-    DPNP_FN_CROSS,             /**< Used in numpy.cross() impl  */
-    DPNP_FN_CROSS_EXT,         /**< Used in numpy.cross() impl, requires extra
-                                  parameters */
-    DPNP_FN_CUMPROD,           /**< Used in numpy.cumprod() impl  */
-    DPNP_FN_CUMPROD_EXT,       /**< Used in numpy.cumprod() impl, requires extra
-                                  parameters */
-    DPNP_FN_CUMSUM,            /**< Used in numpy.cumsum() impl  */
-    DPNP_FN_CUMSUM_EXT,        /**< Used in numpy.cumsum() impl, requires extra
-                                  parameters */
-    DPNP_FN_DEGREES,           /**< Used in numpy.degrees() impl  */
-    DPNP_FN_DEGREES_EXT,       /**< Used in numpy.degrees() impl, requires extra
-                                  parameters */
-    DPNP_FN_DET,               /**< Used in numpy.linalg.det() impl  */
-    DPNP_FN_DET_EXT,  /**< Used in numpy.linalg.det() impl, requires extra
-                         parameters */
-    DPNP_FN_DIAG,     /**< Used in numpy.diag() impl  */
+    DPNP_FN_COV,           /**< Used in numpy.cov() impl  */
+    DPNP_FN_CROSS,         /**< Used in numpy.cross() impl  */
+    DPNP_FN_CROSS_EXT,     /**< Used in numpy.cross() impl, requires extra
+                              parameters */
+    DPNP_FN_CUMPROD,       /**< Used in numpy.cumprod() impl  */
+    DPNP_FN_CUMPROD_EXT,   /**< Used in numpy.cumprod() impl, requires extra
+                              parameters */
+    DPNP_FN_CUMSUM,        /**< Used in numpy.cumsum() impl  */
+    DPNP_FN_CUMSUM_EXT,    /**< Used in numpy.cumsum() impl, requires extra
+                              parameters */
+    DPNP_FN_DEGREES,       /**< Used in numpy.degrees() impl  */
+    DPNP_FN_DEGREES_EXT,   /**< Used in numpy.degrees() impl, requires extra
+                              parameters */
+    DPNP_FN_DET,           /**< Used in numpy.linalg.det() impl  */
+    DPNP_FN_DET_EXT,       /**< Used in numpy.linalg.det() impl, requires extra
+                              parameters */
+    DPNP_FN_DIAG,          /**< Used in numpy.diag() impl  */
     DPNP_FN_DIAG_EXT, /**< Used in numpy.diag() impl, requires extra parameters
                        */
     DPNP_FN_DIAG_INDICES,     /**< Used in numpy.diag_indices() impl  */
@@ -160,24 +154,19 @@ enum class DPNPFuncName : size_t
     DPNP_FN_EIGVALS,     /**< Used in numpy.linalg.eigvals() impl  */
     DPNP_FN_EIGVALS_EXT, /**< Used in numpy.linalg.eigvals() impl, requires
                             extra parameters */
-    DPNP_FN_EQUAL_EXT,   /**< Used in numpy.equal() impl, requires extra
-                            parameters */
     DPNP_FN_ERF,         /**< Used in scipy.special.erf impl  */
     DPNP_FN_ERF_EXT,     /**< Used in scipy.special.erf impl, requires extra
                             parameters */
     DPNP_FN_EYE,         /**< Used in numpy.eye() impl  */
     DPNP_FN_EXP,         /**< Used in numpy.exp() impl  */
-    DPNP_FN_EXP_EXT, /**< Used in numpy.exp() impl, requires extra parameters */
-    DPNP_FN_EXP2,    /**< Used in numpy.exp2() impl  */
-    DPNP_FN_EXP2_EXT,  /**< Used in numpy.exp2() impl, requires extra parameters
-                        */
-    DPNP_FN_EXPM1,     /**< Used in numpy.expm1() impl  */
-    DPNP_FN_EXPM1_EXT, /**< Used in numpy.expm1() impl, requires extra
-                          parameters */
-    DPNP_FN_FABS,      /**< Used in numpy.fabs() impl  */
-    DPNP_FN_FABS_EXT,  /**< Used in numpy.fabs() impl, requires extra parameters
-                        */
-    DPNP_FN_FFT_FFT,   /**< Used in numpy.fft.fft() impl  */
+    DPNP_FN_EXP2,        /**< Used in numpy.exp2() impl  */
+    DPNP_FN_EXP2_EXT, /**< Used in numpy.exp2() impl, requires extra parameters
+                       */
+    DPNP_FN_EXPM1,    /**< Used in numpy.expm1() impl  */
+    DPNP_FN_FABS,     /**< Used in numpy.fabs() impl  */
+    DPNP_FN_FABS_EXT, /**< Used in numpy.fabs() impl, requires extra parameters
+                       */
+    DPNP_FN_FFT_FFT,  /**< Used in numpy.fft.fft() impl  */
     DPNP_FN_FFT_FFT_EXT,   /**< Used in numpy.fft.fft() impl, requires extra
                               parameters */
     DPNP_FN_FFT_RFFT,      /**< Used in numpy.fft.rfft() impl  */
@@ -198,16 +187,8 @@ enum class DPNPFuncName : size_t
                         */
     DPNP_FN_FULL,      /**< Used in numpy.full() impl  */
     DPNP_FN_FULL_LIKE, /**< Used in numpy.full_like() impl  */
-    DPNP_FN_GREATER_EXT,       /**< Used in numpy.greater() impl, requires extra
-                                  parameters */
-    DPNP_FN_GREATER_EQUAL_EXT, /**< Used in numpy.greater_equal() impl, requires
-                                  extra parameters */
-    DPNP_FN_HYPOT,             /**< Used in numpy.hypot() impl  */
-    DPNP_FN_HYPOT_EXT,         /**< Used in numpy.hypot() impl, requires extra
-                                  parameters  */
-    DPNP_FN_IDENTITY,          /**< Used in numpy.identity() impl  */
-    DPNP_FN_IDENTITY_EXT, /**< Used in numpy.identity() impl, requires extra
-                             parameters  */
+    DPNP_FN_HYPOT,     /**< Used in numpy.hypot() impl  */
+    DPNP_FN_IDENTITY,  /**< Used in numpy.identity() impl  */
     DPNP_FN_INITVAL, /**< Used in numpy ones, ones_like, zeros, zeros_like impls
                       */
     DPNP_FN_INITVAL_EXT, /**< Used in numpy ones, ones_like, zeros, zeros_like
@@ -219,22 +200,12 @@ enum class DPNPFuncName : size_t
     DPNP_FN_KRON,        /**< Used in numpy.kron() impl  */
     DPNP_FN_KRON_EXT, /**< Used in numpy.kron() impl, requires extra parameters
                        */
-    DPNP_FN_LEFT_SHIFT, /**< Used in numpy.left_shift() impl  */
-    DPNP_FN_LESS_EXT, /**< Used in numpy.less() impl, requires extra parameters
-                       */
-    DPNP_FN_LESS_EQUAL_EXT, /**< Used in numpy.less_equal() impl, requires extra
-                               parameters */
-    DPNP_FN_LOG,            /**< Used in numpy.log() impl  */
-    DPNP_FN_LOG10,          /**< Used in numpy.log10() impl  */
-    DPNP_FN_LOG10_EXT,      /**< Used in numpy.log10() impl, requires extra
-                               parameters  */
-    DPNP_FN_LOG2,           /**< Used in numpy.log2() impl  */
-    DPNP_FN_LOG2_EXT,  /**< Used in numpy.log2() impl, requires extra parameters
-                        */
-    DPNP_FN_LOG1P,     /**< Used in numpy.log1p() impl  */
-    DPNP_FN_LOG1P_EXT, /**< Used in numpy.log1p() impl, requires extra
-                          parameters  */
-    DPNP_FN_MATMUL,    /**< Used in numpy.matmul() impl  */
+    DPNP_FN_LEFT_SHIFT,      /**< Used in numpy.left_shift() impl  */
+    DPNP_FN_LOG,             /**< Used in numpy.log() impl  */
+    DPNP_FN_LOG10,           /**< Used in numpy.log10() impl  */
+    DPNP_FN_LOG2,            /**< Used in numpy.log2() impl  */
+    DPNP_FN_LOG1P,           /**< Used in numpy.log1p() impl  */
+    DPNP_FN_MATMUL,          /**< Used in numpy.matmul() impl  */
     DPNP_FN_MATMUL_EXT,      /**< Used in numpy.matmul() impl, requires extra
                                 parameters */
     DPNP_FN_MATRIX_RANK,     /**< Used in numpy.linalg.matrix_rank() impl  */
@@ -242,8 +213,8 @@ enum class DPNPFuncName : size_t
                                 requires extra parameters */
     DPNP_FN_MAX,             /**< Used in numpy.max() impl  */
     DPNP_FN_MAX_EXT, /**< Used in numpy.max() impl, requires extra parameters */
-    DPNP_FN_MAXIMUM, /**< Used in numpy.maximum() impl  */
-    DPNP_FN_MAXIMUM_EXT, /**< Used in numpy.maximum() impl , requires extra
+    DPNP_FN_MAXIMUM, /**< Used in numpy.fmax() impl  */
+    DPNP_FN_MAXIMUM_EXT, /**< Used in numpy.fmax() impl , requires extra
                             parameters */
     DPNP_FN_MEAN,        /**< Used in numpy.mean() impl  */
     DPNP_FN_MEDIAN,      /**< Used in numpy.median() impl  */
@@ -251,8 +222,8 @@ enum class DPNPFuncName : size_t
                             parameters */
     DPNP_FN_MIN,         /**< Used in numpy.min() impl  */
     DPNP_FN_MIN_EXT, /**< Used in numpy.min() impl, requires extra parameters */
-    DPNP_FN_MINIMUM, /**< Used in numpy.minimum() impl  */
-    DPNP_FN_MINIMUM_EXT, /**< Used in numpy.minimum() impl, requires extra
+    DPNP_FN_MINIMUM, /**< Used in numpy.fmin() impl  */
+    DPNP_FN_MINIMUM_EXT, /**< Used in numpy.fmax() impl, requires extra
                             parameters */
     DPNP_FN_MODF,        /**< Used in numpy.modf() impl  */
     DPNP_FN_MODF_EXT, /**< Used in numpy.modf() impl, requires extra parameters
@@ -265,8 +236,6 @@ enum class DPNPFuncName : size_t
                               parameters */
     DPNP_FN_NEGATIVE,      /**< Used in numpy.negative() impl  */
     DPNP_FN_NONZERO,       /**< Used in numpy.nonzero() impl  */
-    DPNP_FN_NOT_EQUAL_EXT, /**< Used in numpy.not_equal() impl, requires extra
-                              parameters */
     DPNP_FN_ONES,          /**< Used in numpy.ones() impl */
     DPNP_FN_ONES_LIKE,     /**< Used in numpy.ones_like() impl */
     DPNP_FN_PARTITION,     /**< Used in numpy.partition() impl */
@@ -440,19 +409,18 @@ enum class DPNPFuncName : size_t
     DPNP_FN_TAKE,    /**< Used in numpy.take() impl  */
     DPNP_FN_TAN,     /**< Used in numpy.tan() impl  */
     DPNP_FN_TANH,    /**< Used in numpy.tanh() impl  */
-    DPNP_FN_TRANSPOSE, /**< Used in numpy.transpose() impl  */
-    DPNP_FN_TRACE,     /**< Used in numpy.trace() impl  */
-    DPNP_FN_TRACE_EXT, /**< Used in numpy.trace() impl, requires extra
-                          parameters */
-    DPNP_FN_TRAPZ,     /**< Used in numpy.trapz() impl  */
-    DPNP_FN_TRAPZ_EXT, /**< Used in numpy.trapz() impl, requires extra
-                          parameters */
-    DPNP_FN_TRI,       /**< Used in numpy.tri() impl  */
-    DPNP_FN_TRI_EXT, /**< Used in numpy.tri() impl, requires extra parameters */
-    DPNP_FN_TRIL,    /**< Used in numpy.tril() impl  */
-    DPNP_FN_TRIU,    /**< Used in numpy.triu() impl  */
-    DPNP_FN_TRUNC,   /**< Used in numpy.trunc() impl  */
-    DPNP_FN_VANDER,  /**< Used in numpy.vander() impl  */
+    DPNP_FN_TRANSPOSE,  /**< Used in numpy.transpose() impl  */
+    DPNP_FN_TRACE,      /**< Used in numpy.trace() impl  */
+    DPNP_FN_TRACE_EXT,  /**< Used in numpy.trace() impl, requires extra
+                           parameters */
+    DPNP_FN_TRAPZ,      /**< Used in numpy.trapz() impl  */
+    DPNP_FN_TRAPZ_EXT,  /**< Used in numpy.trapz() impl, requires extra
+                           parameters */
+    DPNP_FN_TRI,        /**< Used in numpy.tri() impl  */
+    DPNP_FN_TRIL,       /**< Used in numpy.tril() impl  */
+    DPNP_FN_TRIU,       /**< Used in numpy.triu() impl  */
+    DPNP_FN_TRUNC,      /**< Used in numpy.trunc() impl  */
+    DPNP_FN_VANDER,     /**< Used in numpy.vander() impl  */
     DPNP_FN_VANDER_EXT, /**< Used in numpy.vander() impl, requires extra
                            parameters */
     DPNP_FN_VAR,        /**< Used in numpy.var() impl  */
@@ -545,7 +513,7 @@ DPNPFuncData_t get_dpnp_function_ptr(
  * @ingroup BACKEND_API
  * @brief get runtime pointer to selected function
  *
- * Same interface function as @ref get_dpnp_function_ptr with a bit diffrent
+ * Same interface function as @ref get_dpnp_function_ptr with a bit different
  * interface
  *
  * @param [out] result_type  Type of the result provided by the backend API
diff --git a/dpnp/backend/include/dpnp_iface_random.hpp b/dpnp/backend/include/dpnp_iface_random.hpp
index 562e5ae34a2..10ba3a2e282 100644
--- a/dpnp/backend/include/dpnp_iface_random.hpp
+++ b/dpnp/backend/include/dpnp_iface_random.hpp
@@ -205,7 +205,7 @@ INP_DLLEXPORT void dpnp_rng_gamma_c(void *result,
 /**
  * @ingroup BACKEND_RANDOM_API
  * @brief math library implementation of random number generator (gaussian
- * continious distribution)
+ * continuous distribution)
  *
  * @param [in]  q_ref               Reference to SYCL queue.
  * @param [out] result              Output array.
@@ -431,7 +431,7 @@ INP_DLLEXPORT void dpnp_rng_multinomial_c(void *result,
  * @param [in]  q_ref               Reference to SYCL queue.
  * @param [out] result              Output array.
  * @param [in]  dimen               Dimension of output random vectors.
- * @param [in]  mean_in             Mean arry of dimension.
+ * @param [in]  mean_in             Mean array of dimension.
  * @param [in]  mean_size           Length of `mean_in`.
  * @param [in]  cov                 Variance-covariance matrix.
  * @param [in]  cov_size            Length of `cov_in`.
@@ -518,7 +518,7 @@ INP_DLLEXPORT void dpnp_rng_noncentral_chisquare_c(void *result,
 /**
  * @ingroup BACKEND_RANDOM_API
  * @brief math library implementation of random number generator (normal
- * continious distribution)
+ * continuous distribution)
  *
  * @param [in]  q_ref               Reference to SYCL queue.
  * @param [out] result_out          Output array.
@@ -645,7 +645,7 @@ INP_DLLEXPORT void
  * @param [in]  itemsize            Length of `result` array element in bytes.
  * @param [in]  ndim                Number of array dimensions in `result`
  * arrays.
- * @param [in]  high_dim_size       Number of elements in `result` arrays higer
+ * @param [in]  high_dim_size       Number of elements in `result` arrays higher
  * dimension, or len(result).
  * @param [in]  size                Number of elements in `result` arrays.
  * @param [in]  dep_event_vec_ref   Reference to vector of SYCL events.
diff --git a/dpnp/backend/kernels/dpnp_krnl_arraycreation.cpp b/dpnp/backend/kernels/dpnp_krnl_arraycreation.cpp
index 3ea782a6064..a655c03100f 100644
--- a/dpnp/backend/kernels/dpnp_krnl_arraycreation.cpp
+++ b/dpnp/backend/kernels/dpnp_krnl_arraycreation.cpp
@@ -392,13 +392,6 @@ template <typename _DataType>
 void (*dpnp_identity_default_c)(void *,
                                 const size_t) = dpnp_identity_c<_DataType>;
 
-template <typename _DataType>
-DPCTLSyclEventRef (*dpnp_identity_ext_c)(DPCTLSyclQueueRef,
-                                         void *,
-                                         const size_t,
-                                         const DPCTLEventVectorRef) =
-    dpnp_identity_c<_DataType>;
-
 template <typename _DataType>
 class dpnp_ones_c_kernel;
 
@@ -851,15 +844,6 @@ template <typename _DataType>
 void (*dpnp_tri_default_c)(void *, const size_t, const size_t, const int) =
     dpnp_tri_c<_DataType>;
 
-template <typename _DataType>
-DPCTLSyclEventRef (*dpnp_tri_ext_c)(DPCTLSyclQueueRef,
-                                    void *,
-                                    const size_t,
-                                    const size_t,
-                                    const int,
-                                    const DPCTLEventVectorRef) =
-    dpnp_tri_c<_DataType>;
-
 template <typename _DataType>
 DPCTLSyclEventRef dpnp_tril_c(DPCTLSyclQueueRef q_ref,
                               void *array_in,
@@ -1265,21 +1249,6 @@ void func_map_init_arraycreation(func_map_t &fmap)
     fmap[DPNPFuncName::DPNP_FN_IDENTITY][eft_C128][eft_C128] = {
         eft_C128, (void *)dpnp_identity_default_c<std::complex<double>>};
 
-    fmap[DPNPFuncName::DPNP_FN_IDENTITY_EXT][eft_INT][eft_INT] = {
-        eft_INT, (void *)dpnp_identity_ext_c<int32_t>};
-    fmap[DPNPFuncName::DPNP_FN_IDENTITY_EXT][eft_LNG][eft_LNG] = {
-        eft_LNG, (void *)dpnp_identity_ext_c<int64_t>};
-    fmap[DPNPFuncName::DPNP_FN_IDENTITY_EXT][eft_FLT][eft_FLT] = {
-        eft_FLT, (void *)dpnp_identity_ext_c<float>};
-    fmap[DPNPFuncName::DPNP_FN_IDENTITY_EXT][eft_DBL][eft_DBL] = {
-        eft_DBL, (void *)dpnp_identity_ext_c<double>};
-    fmap[DPNPFuncName::DPNP_FN_IDENTITY_EXT][eft_BLN][eft_BLN] = {
-        eft_BLN, (void *)dpnp_identity_ext_c<bool>};
-    fmap[DPNPFuncName::DPNP_FN_IDENTITY_EXT][eft_C64][eft_C64] = {
-        eft_C64, (void *)dpnp_identity_ext_c<std::complex<float>>};
-    fmap[DPNPFuncName::DPNP_FN_IDENTITY_EXT][eft_C128][eft_C128] = {
-        eft_C128, (void *)dpnp_identity_ext_c<std::complex<double>>};
-
     fmap[DPNPFuncName::DPNP_FN_ONES][eft_INT][eft_INT] = {
         eft_INT, (void *)dpnp_ones_default_c<int32_t>};
     fmap[DPNPFuncName::DPNP_FN_ONES][eft_LNG][eft_LNG] = {
@@ -1431,15 +1400,6 @@ void func_map_init_arraycreation(func_map_t &fmap)
     fmap[DPNPFuncName::DPNP_FN_TRI][eft_DBL][eft_DBL] = {
         eft_DBL, (void *)dpnp_tri_default_c<double>};
 
-    fmap[DPNPFuncName::DPNP_FN_TRI_EXT][eft_INT][eft_INT] = {
-        eft_INT, (void *)dpnp_tri_ext_c<int32_t>};
-    fmap[DPNPFuncName::DPNP_FN_TRI_EXT][eft_LNG][eft_LNG] = {
-        eft_LNG, (void *)dpnp_tri_ext_c<int64_t>};
-    fmap[DPNPFuncName::DPNP_FN_TRI_EXT][eft_FLT][eft_FLT] = {
-        eft_FLT, (void *)dpnp_tri_ext_c<float>};
-    fmap[DPNPFuncName::DPNP_FN_TRI_EXT][eft_DBL][eft_DBL] = {
-        eft_DBL, (void *)dpnp_tri_ext_c<double>};
-
     fmap[DPNPFuncName::DPNP_FN_TRIL][eft_INT][eft_INT] = {
         eft_INT, (void *)dpnp_tril_default_c<int32_t>};
     fmap[DPNPFuncName::DPNP_FN_TRIL][eft_LNG][eft_LNG] = {
diff --git a/dpnp/backend/kernels/dpnp_krnl_bitwise.cpp b/dpnp/backend/kernels/dpnp_krnl_bitwise.cpp
index 0134e94ef39..4fdd1a394ed 100644
--- a/dpnp/backend/kernels/dpnp_krnl_bitwise.cpp
+++ b/dpnp/backend/kernels/dpnp_krnl_bitwise.cpp
@@ -264,7 +264,7 @@ static void func_map_init_bitwise_1arg_1type(func_map_t &fmap)
             }                                                                  \
                                                                                \
             /* memory transfer optimization, use USM-host for temporary speeds \
-             * up tranfer to device */                                         \
+             * up transfer to device */                                        \
             using usm_host_allocatorT =                                        \
                 sycl::usm_allocator<shape_elem_type, sycl::usm::alloc::host>;  \
                                                                                \
diff --git a/dpnp/backend/kernels/dpnp_krnl_common.cpp b/dpnp/backend/kernels/dpnp_krnl_common.cpp
index dd6c8119c1b..d575f8bdb96 100644
--- a/dpnp/backend/kernels/dpnp_krnl_common.cpp
+++ b/dpnp/backend/kernels/dpnp_krnl_common.cpp
@@ -101,14 +101,6 @@ template <typename _DataType, typename _ResultType>
 void (*dpnp_astype_default_c)(const void *, void *, const size_t) =
     dpnp_astype_c<_DataType, _ResultType>;
 
-template <typename _DataType, typename _ResultType>
-DPCTLSyclEventRef (*dpnp_astype_ext_c)(DPCTLSyclQueueRef,
-                                       const void *,
-                                       void *,
-                                       const size_t,
-                                       const DPCTLEventVectorRef) =
-    dpnp_astype_c<_DataType, _ResultType>;
-
 template <typename _KernelNameSpecialization1,
           typename _KernelNameSpecialization2,
           typename _KernelNameSpecialization3>
@@ -322,7 +314,7 @@ DPCTLSyclEventRef dpnp_dot_c(DPCTLSyclQueueRef q_ref,
         // TODO: rewrite the condition in general case for ndims > 2
         // (looks like there are such another cases)
         if (ext_input1_ndim == 2 && ext_input2_ndim == 2) {
-            // OneMKL gemm suports only arrays contiguous on inner dimension,
+            // OneMKL gemm supports only arrays contiguous on inner dimension,
             // so stride for at least one dimension should be equal to 1
             if ((ext_input1_strides[0] == 1 || ext_input1_strides[1] == 1) &&
                 (ext_input2_strides[0] == 1 || ext_input2_strides[1] == 1) &&
@@ -392,7 +384,7 @@ DPCTLSyclEventRef dpnp_dot_c(DPCTLSyclQueueRef q_ref,
                     info = -1;
                 }
 
-                if (info != 0) // an unexected error occurs
+                if (info != 0) // an unexpected error occurs
                 {
                     throw std::runtime_error(error_msg.str());
                 }
@@ -1035,63 +1027,6 @@ void func_map_init_linalg(func_map_t &fmap)
         (void *)
             dpnp_astype_default_c<std::complex<double>, std::complex<double>>};
 
-    fmap[DPNPFuncName::DPNP_FN_ASTYPE_EXT][eft_BLN][eft_BLN] = {
-        eft_BLN, (void *)dpnp_astype_ext_c<bool, bool>};
-    fmap[DPNPFuncName::DPNP_FN_ASTYPE_EXT][eft_BLN][eft_INT] = {
-        eft_INT, (void *)dpnp_astype_ext_c<bool, int32_t>};
-    fmap[DPNPFuncName::DPNP_FN_ASTYPE_EXT][eft_BLN][eft_LNG] = {
-        eft_LNG, (void *)dpnp_astype_ext_c<bool, int64_t>};
-    fmap[DPNPFuncName::DPNP_FN_ASTYPE_EXT][eft_BLN][eft_FLT] = {
-        eft_FLT, (void *)dpnp_astype_ext_c<bool, float>};
-    fmap[DPNPFuncName::DPNP_FN_ASTYPE_EXT][eft_BLN][eft_DBL] = {
-        eft_DBL, (void *)dpnp_astype_ext_c<bool, double>};
-    fmap[DPNPFuncName::DPNP_FN_ASTYPE_EXT][eft_INT][eft_BLN] = {
-        eft_BLN, (void *)dpnp_astype_ext_c<int32_t, bool>};
-    fmap[DPNPFuncName::DPNP_FN_ASTYPE_EXT][eft_INT][eft_INT] = {
-        eft_INT, (void *)dpnp_astype_ext_c<int32_t, int32_t>};
-    fmap[DPNPFuncName::DPNP_FN_ASTYPE_EXT][eft_INT][eft_LNG] = {
-        eft_LNG, (void *)dpnp_astype_ext_c<int32_t, int64_t>};
-    fmap[DPNPFuncName::DPNP_FN_ASTYPE_EXT][eft_INT][eft_FLT] = {
-        eft_FLT, (void *)dpnp_astype_ext_c<int32_t, float>};
-    fmap[DPNPFuncName::DPNP_FN_ASTYPE_EXT][eft_INT][eft_DBL] = {
-        eft_DBL, (void *)dpnp_astype_ext_c<int32_t, double>};
-    fmap[DPNPFuncName::DPNP_FN_ASTYPE_EXT][eft_LNG][eft_BLN] = {
-        eft_BLN, (void *)dpnp_astype_ext_c<int64_t, bool>};
-    fmap[DPNPFuncName::DPNP_FN_ASTYPE_EXT][eft_LNG][eft_INT] = {
-        eft_INT, (void *)dpnp_astype_ext_c<int64_t, int32_t>};
-    fmap[DPNPFuncName::DPNP_FN_ASTYPE_EXT][eft_LNG][eft_LNG] = {
-        eft_LNG, (void *)dpnp_astype_ext_c<int64_t, int64_t>};
-    fmap[DPNPFuncName::DPNP_FN_ASTYPE_EXT][eft_LNG][eft_FLT] = {
-        eft_FLT, (void *)dpnp_astype_ext_c<int64_t, float>};
-    fmap[DPNPFuncName::DPNP_FN_ASTYPE_EXT][eft_LNG][eft_DBL] = {
-        eft_DBL, (void *)dpnp_astype_ext_c<int64_t, double>};
-    fmap[DPNPFuncName::DPNP_FN_ASTYPE_EXT][eft_FLT][eft_BLN] = {
-        eft_BLN, (void *)dpnp_astype_ext_c<float, bool>};
-    fmap[DPNPFuncName::DPNP_FN_ASTYPE_EXT][eft_FLT][eft_INT] = {
-        eft_INT, (void *)dpnp_astype_ext_c<float, int32_t>};
-    fmap[DPNPFuncName::DPNP_FN_ASTYPE_EXT][eft_FLT][eft_LNG] = {
-        eft_LNG, (void *)dpnp_astype_ext_c<float, int64_t>};
-    fmap[DPNPFuncName::DPNP_FN_ASTYPE_EXT][eft_FLT][eft_FLT] = {
-        eft_FLT, (void *)dpnp_astype_ext_c<float, float>};
-    fmap[DPNPFuncName::DPNP_FN_ASTYPE_EXT][eft_FLT][eft_DBL] = {
-        eft_DBL, (void *)dpnp_astype_ext_c<float, double>};
-    fmap[DPNPFuncName::DPNP_FN_ASTYPE_EXT][eft_DBL][eft_BLN] = {
-        eft_BLN, (void *)dpnp_astype_ext_c<double, bool>};
-    fmap[DPNPFuncName::DPNP_FN_ASTYPE_EXT][eft_DBL][eft_INT] = {
-        eft_INT, (void *)dpnp_astype_ext_c<double, int32_t>};
-    fmap[DPNPFuncName::DPNP_FN_ASTYPE_EXT][eft_DBL][eft_LNG] = {
-        eft_LNG, (void *)dpnp_astype_ext_c<double, int64_t>};
-    fmap[DPNPFuncName::DPNP_FN_ASTYPE_EXT][eft_DBL][eft_FLT] = {
-        eft_FLT, (void *)dpnp_astype_ext_c<double, float>};
-    fmap[DPNPFuncName::DPNP_FN_ASTYPE_EXT][eft_DBL][eft_DBL] = {
-        eft_DBL, (void *)dpnp_astype_ext_c<double, double>};
-    fmap[DPNPFuncName::DPNP_FN_ASTYPE_EXT][eft_C64][eft_C64] = {
-        eft_C64,
-        (void *)dpnp_astype_ext_c<std::complex<float>, std::complex<float>>};
-    fmap[DPNPFuncName::DPNP_FN_ASTYPE_EXT][eft_C128][eft_C128] = {
-        eft_C128,
-        (void *)dpnp_astype_ext_c<std::complex<double>, std::complex<double>>};
-
     fmap[DPNPFuncName::DPNP_FN_DOT][eft_INT][eft_INT] = {
         eft_INT, (void *)dpnp_dot_default_c<int32_t, int32_t, int32_t>};
     fmap[DPNPFuncName::DPNP_FN_DOT][eft_INT][eft_LNG] = {
diff --git a/dpnp/backend/kernels/dpnp_krnl_elemwise.cpp b/dpnp/backend/kernels/dpnp_krnl_elemwise.cpp
index 4b26da44853..5b0b9b04753 100644
--- a/dpnp/backend/kernels/dpnp_krnl_elemwise.cpp
+++ b/dpnp/backend/kernels/dpnp_krnl_elemwise.cpp
@@ -92,7 +92,7 @@
             }                                                                  \
                                                                                \
             /* memory transfer optimization, use USM-host for temporary speeds \
-             * up tranfer to device */                                         \
+             * up transfer to device */                                        \
             using usm_host_allocatorT =                                        \
                 sycl::usm_allocator<shape_elem_type, sycl::usm::alloc::host>;  \
                                                                                \
@@ -409,9 +409,21 @@ static void func_map_init_elemwise_1arg_2type(func_map_t &fmap)
         eft_DBL, (void *)dpnp_degrees_c_default<double, double>};
 
     fmap[DPNPFuncName::DPNP_FN_DEGREES_EXT][eft_INT][eft_INT] = {
-        eft_DBL, (void *)dpnp_degrees_c_ext<int32_t, double>};
+        get_default_floating_type(),
+        (void *)dpnp_degrees_c_ext<
+            int32_t, func_type_map_t::find_type<get_default_floating_type()>>,
+        get_default_floating_type<std::false_type>(),
+        (void *)dpnp_degrees_c_ext<
+            int32_t, func_type_map_t::find_type<
+                         get_default_floating_type<std::false_type>()>>};
     fmap[DPNPFuncName::DPNP_FN_DEGREES_EXT][eft_LNG][eft_LNG] = {
-        eft_DBL, (void *)dpnp_degrees_c_ext<int64_t, double>};
+        get_default_floating_type(),
+        (void *)dpnp_degrees_c_ext<
+            int64_t, func_type_map_t::find_type<get_default_floating_type()>>,
+        get_default_floating_type<std::false_type>(),
+        (void *)dpnp_degrees_c_ext<
+            int64_t, func_type_map_t::find_type<
+                         get_default_floating_type<std::false_type>()>>};
     fmap[DPNPFuncName::DPNP_FN_DEGREES_EXT][eft_FLT][eft_FLT] = {
         eft_FLT, (void *)dpnp_degrees_c_ext<float, float>};
     fmap[DPNPFuncName::DPNP_FN_DEGREES_EXT][eft_DBL][eft_DBL] = {
@@ -427,9 +439,21 @@ static void func_map_init_elemwise_1arg_2type(func_map_t &fmap)
         eft_DBL, (void *)dpnp_exp2_c_default<double, double>};
 
     fmap[DPNPFuncName::DPNP_FN_EXP2_EXT][eft_INT][eft_INT] = {
-        eft_DBL, (void *)dpnp_exp2_c_ext<int32_t, double>};
+        get_default_floating_type(),
+        (void *)dpnp_exp2_c_ext<
+            int32_t, func_type_map_t::find_type<get_default_floating_type()>>,
+        get_default_floating_type<std::false_type>(),
+        (void *)dpnp_exp2_c_ext<
+            int32_t, func_type_map_t::find_type<
+                         get_default_floating_type<std::false_type>()>>};
     fmap[DPNPFuncName::DPNP_FN_EXP2_EXT][eft_LNG][eft_LNG] = {
-        eft_DBL, (void *)dpnp_exp2_c_ext<int64_t, double>};
+        get_default_floating_type(),
+        (void *)dpnp_exp2_c_ext<
+            int64_t, func_type_map_t::find_type<get_default_floating_type()>>,
+        get_default_floating_type<std::false_type>(),
+        (void *)dpnp_exp2_c_ext<
+            int64_t, func_type_map_t::find_type<
+                         get_default_floating_type<std::false_type>()>>};
     fmap[DPNPFuncName::DPNP_FN_EXP2_EXT][eft_FLT][eft_FLT] = {
         eft_FLT, (void *)dpnp_exp2_c_ext<float, float>};
     fmap[DPNPFuncName::DPNP_FN_EXP2_EXT][eft_DBL][eft_DBL] = {
@@ -444,15 +468,6 @@ static void func_map_init_elemwise_1arg_2type(func_map_t &fmap)
     fmap[DPNPFuncName::DPNP_FN_EXP][eft_DBL][eft_DBL] = {
         eft_DBL, (void *)dpnp_exp_c_default<double, double>};
 
-    fmap[DPNPFuncName::DPNP_FN_EXP_EXT][eft_INT][eft_INT] = {
-        eft_DBL, (void *)dpnp_exp_c_ext<int32_t, double>};
-    fmap[DPNPFuncName::DPNP_FN_EXP_EXT][eft_LNG][eft_LNG] = {
-        eft_DBL, (void *)dpnp_exp_c_ext<int64_t, double>};
-    fmap[DPNPFuncName::DPNP_FN_EXP_EXT][eft_FLT][eft_FLT] = {
-        eft_FLT, (void *)dpnp_exp_c_ext<float, float>};
-    fmap[DPNPFuncName::DPNP_FN_EXP_EXT][eft_DBL][eft_DBL] = {
-        eft_DBL, (void *)dpnp_exp_c_ext<double, double>};
-
     fmap[DPNPFuncName::DPNP_FN_EXPM1][eft_INT][eft_INT] = {
         eft_DBL, (void *)dpnp_expm1_c_default<int32_t, double>};
     fmap[DPNPFuncName::DPNP_FN_EXPM1][eft_LNG][eft_LNG] = {
@@ -462,15 +477,6 @@ static void func_map_init_elemwise_1arg_2type(func_map_t &fmap)
     fmap[DPNPFuncName::DPNP_FN_EXPM1][eft_DBL][eft_DBL] = {
         eft_DBL, (void *)dpnp_expm1_c_default<double, double>};
 
-    fmap[DPNPFuncName::DPNP_FN_EXPM1_EXT][eft_INT][eft_INT] = {
-        eft_DBL, (void *)dpnp_expm1_c_ext<int32_t, double>};
-    fmap[DPNPFuncName::DPNP_FN_EXPM1_EXT][eft_LNG][eft_LNG] = {
-        eft_DBL, (void *)dpnp_expm1_c_ext<int64_t, double>};
-    fmap[DPNPFuncName::DPNP_FN_EXPM1_EXT][eft_FLT][eft_FLT] = {
-        eft_FLT, (void *)dpnp_expm1_c_ext<float, float>};
-    fmap[DPNPFuncName::DPNP_FN_EXPM1_EXT][eft_DBL][eft_DBL] = {
-        eft_DBL, (void *)dpnp_expm1_c_ext<double, double>};
-
     fmap[DPNPFuncName::DPNP_FN_FABS][eft_INT][eft_INT] = {
         eft_DBL, (void *)dpnp_fabs_c_default<int32_t, double>};
     fmap[DPNPFuncName::DPNP_FN_FABS][eft_LNG][eft_LNG] = {
@@ -507,15 +513,6 @@ static void func_map_init_elemwise_1arg_2type(func_map_t &fmap)
     fmap[DPNPFuncName::DPNP_FN_LOG10][eft_DBL][eft_DBL] = {
         eft_DBL, (void *)dpnp_log10_c_default<double, double>};
 
-    fmap[DPNPFuncName::DPNP_FN_LOG10_EXT][eft_INT][eft_INT] = {
-        eft_DBL, (void *)dpnp_log10_c_ext<int32_t, double>};
-    fmap[DPNPFuncName::DPNP_FN_LOG10_EXT][eft_LNG][eft_LNG] = {
-        eft_DBL, (void *)dpnp_log10_c_ext<int64_t, double>};
-    fmap[DPNPFuncName::DPNP_FN_LOG10_EXT][eft_FLT][eft_FLT] = {
-        eft_FLT, (void *)dpnp_log10_c_ext<float, float>};
-    fmap[DPNPFuncName::DPNP_FN_LOG10_EXT][eft_DBL][eft_DBL] = {
-        eft_DBL, (void *)dpnp_log10_c_ext<double, double>};
-
     fmap[DPNPFuncName::DPNP_FN_LOG1P][eft_INT][eft_INT] = {
         eft_DBL, (void *)dpnp_log1p_c_default<int32_t, double>};
     fmap[DPNPFuncName::DPNP_FN_LOG1P][eft_LNG][eft_LNG] = {
@@ -525,15 +522,6 @@ static void func_map_init_elemwise_1arg_2type(func_map_t &fmap)
     fmap[DPNPFuncName::DPNP_FN_LOG1P][eft_DBL][eft_DBL] = {
         eft_DBL, (void *)dpnp_log1p_c_default<double, double>};
 
-    fmap[DPNPFuncName::DPNP_FN_LOG1P_EXT][eft_INT][eft_INT] = {
-        eft_DBL, (void *)dpnp_log1p_c_ext<int32_t, double>};
-    fmap[DPNPFuncName::DPNP_FN_LOG1P_EXT][eft_LNG][eft_LNG] = {
-        eft_DBL, (void *)dpnp_log1p_c_ext<int64_t, double>};
-    fmap[DPNPFuncName::DPNP_FN_LOG1P_EXT][eft_FLT][eft_FLT] = {
-        eft_FLT, (void *)dpnp_log1p_c_ext<float, float>};
-    fmap[DPNPFuncName::DPNP_FN_LOG1P_EXT][eft_DBL][eft_DBL] = {
-        eft_DBL, (void *)dpnp_log1p_c_ext<double, double>};
-
     fmap[DPNPFuncName::DPNP_FN_LOG2][eft_INT][eft_INT] = {
         eft_DBL, (void *)dpnp_log2_c_default<int32_t, double>};
     fmap[DPNPFuncName::DPNP_FN_LOG2][eft_LNG][eft_LNG] = {
@@ -543,15 +531,6 @@ static void func_map_init_elemwise_1arg_2type(func_map_t &fmap)
     fmap[DPNPFuncName::DPNP_FN_LOG2][eft_DBL][eft_DBL] = {
         eft_DBL, (void *)dpnp_log2_c_default<double, double>};
 
-    fmap[DPNPFuncName::DPNP_FN_LOG2_EXT][eft_INT][eft_INT] = {
-        eft_DBL, (void *)dpnp_log2_c_ext<int32_t, double>};
-    fmap[DPNPFuncName::DPNP_FN_LOG2_EXT][eft_LNG][eft_LNG] = {
-        eft_DBL, (void *)dpnp_log2_c_ext<int64_t, double>};
-    fmap[DPNPFuncName::DPNP_FN_LOG2_EXT][eft_FLT][eft_FLT] = {
-        eft_FLT, (void *)dpnp_log2_c_ext<float, float>};
-    fmap[DPNPFuncName::DPNP_FN_LOG2_EXT][eft_DBL][eft_DBL] = {
-        eft_DBL, (void *)dpnp_log2_c_ext<double, double>};
-
     fmap[DPNPFuncName::DPNP_FN_LOG][eft_INT][eft_INT] = {
         eft_DBL, (void *)dpnp_log_c_default<int32_t, double>};
     fmap[DPNPFuncName::DPNP_FN_LOG][eft_LNG][eft_LNG] = {
@@ -571,9 +550,21 @@ static void func_map_init_elemwise_1arg_2type(func_map_t &fmap)
         eft_DBL, (void *)dpnp_radians_c_default<double, double>};
 
     fmap[DPNPFuncName::DPNP_FN_RADIANS_EXT][eft_INT][eft_INT] = {
-        eft_DBL, (void *)dpnp_radians_c_ext<int32_t, double>};
+        get_default_floating_type(),
+        (void *)dpnp_radians_c_ext<
+            int32_t, func_type_map_t::find_type<get_default_floating_type()>>,
+        get_default_floating_type<std::false_type>(),
+        (void *)dpnp_radians_c_ext<
+            int32_t, func_type_map_t::find_type<
+                         get_default_floating_type<std::false_type>()>>};
     fmap[DPNPFuncName::DPNP_FN_RADIANS_EXT][eft_LNG][eft_LNG] = {
-        eft_DBL, (void *)dpnp_radians_c_ext<int64_t, double>};
+        get_default_floating_type(),
+        (void *)dpnp_radians_c_ext<
+            int64_t, func_type_map_t::find_type<get_default_floating_type()>>,
+        get_default_floating_type<std::false_type>(),
+        (void *)dpnp_radians_c_ext<
+            int64_t, func_type_map_t::find_type<
+                         get_default_floating_type<std::false_type>()>>};
     fmap[DPNPFuncName::DPNP_FN_RADIANS_EXT][eft_FLT][eft_FLT] = {
         eft_FLT, (void *)dpnp_radians_c_ext<float, float>};
     fmap[DPNPFuncName::DPNP_FN_RADIANS_EXT][eft_DBL][eft_DBL] = {
@@ -754,7 +745,7 @@ constexpr auto dispatch_fmod_op(T elem1, T elem2)
             }                                                                  \
                                                                                \
             /* memory transfer optimization, use USM-host for temporary speeds \
-             * up tranfer to device */                                         \
+             * up transfer to device */                                        \
             using usm_host_allocatorT =                                        \
                 sycl::usm_allocator<shape_elem_type, sycl::usm::alloc::host>;  \
                                                                                \
@@ -1146,7 +1137,7 @@ static void func_map_init_elemwise_1arg_1type(func_map_t &fmap)
             }                                                                  \
                                                                                \
             /* memory transfer optimization, use USM-host for temporary speeds \
-             * up tranfer to device */                                         \
+             * up transfer to device */                                        \
             using usm_host_allocatorT =                                        \
                 sycl::usm_allocator<shape_elem_type, sycl::usm::alloc::host>;  \
                                                                                \
@@ -1514,19 +1505,6 @@ static void func_map_elemwise_2arg_3type_short_core(func_map_t &fmap)
                func_type_map_t::find_type<FT1>,
                func_type_map_t::find_type<FTs>>}),
      ...);
-    ((fmap[DPNPFuncName::DPNP_FN_HYPOT_EXT][FT1][FTs] =
-          {get_floating_res_type<FT1, FTs>(),
-           (void *)dpnp_hypot_c_ext<
-               func_type_map_t::find_type<get_floating_res_type<FT1, FTs>()>,
-               func_type_map_t::find_type<FT1>,
-               func_type_map_t::find_type<FTs>>,
-           get_floating_res_type<FT1, FTs, std::false_type>(),
-           (void *)dpnp_hypot_c_ext<
-               func_type_map_t::find_type<
-                   get_floating_res_type<FT1, FTs, std::false_type>()>,
-               func_type_map_t::find_type<FT1>,
-               func_type_map_t::find_type<FTs>>}),
-     ...);
     ((fmap[DPNPFuncName::DPNP_FN_MAXIMUM_EXT][FT1][FTs] =
           {get_floating_res_type<FT1, FTs, std::true_type, std::true_type>(),
            (void *)dpnp_maximum_c_ext<
diff --git a/dpnp/backend/kernels/dpnp_krnl_logic.cpp b/dpnp/backend/kernels/dpnp_krnl_logic.cpp
index 429f9d96f1e..0674f1387b7 100644
--- a/dpnp/backend/kernels/dpnp_krnl_logic.cpp
+++ b/dpnp/backend/kernels/dpnp_krnl_logic.cpp
@@ -197,7 +197,7 @@ static sycl::event dpnp_allclose(sycl::queue &q,
                 }
             }
 
-            // casting integeral to floating type to avoid bad behavior
+            // casting integral to floating type to avoid bad behavior
             // on abs(MIN_INT), which leads to undefined result
             using _Arr2Type = std::conditional_t<std::is_integral_v<_DataType2>,
                                                  _TolType, _DataType2>;
@@ -525,7 +525,7 @@ DPCTLSyclEventRef (*dpnp_any_ext_c)(DPCTLSyclQueueRef,
             }                                                                  \
                                                                                \
             /* memory transfer optimization, use USM-host for temporary speeds \
-             * up tranfer to device */                                         \
+             * up transfer to device */                                        \
             using usm_host_allocatorT =                                        \
                 sycl::usm_allocator<shape_elem_type, sycl::usm::alloc::host>;  \
                                                                                \
@@ -667,47 +667,6 @@ DPCTLSyclEventRef (*dpnp_any_ext_c)(DPCTLSyclQueueRef,
         const DPCTLEventVectorRef) =                                           \
         __name__<_DataType_input1, _DataType_input2>;
 
-#include <dpnp_gen_2arg_2type_tbl.hpp>
-
-template <DPNPFuncType FT1, DPNPFuncType... FTs>
-static void func_map_logic_2arg_2type_core(func_map_t &fmap)
-{
-    ((fmap[DPNPFuncName::DPNP_FN_EQUAL_EXT][FT1][FTs] =
-          {eft_BLN, (void *)dpnp_equal_c_ext<func_type_map_t::find_type<FT1>,
-                                             func_type_map_t::find_type<FTs>>}),
-     ...);
-    ((fmap[DPNPFuncName::DPNP_FN_GREATER_EXT][FT1][FTs] =
-          {eft_BLN,
-           (void *)dpnp_greater_c_ext<func_type_map_t::find_type<FT1>,
-                                      func_type_map_t::find_type<FTs>>}),
-     ...);
-    ((fmap[DPNPFuncName::DPNP_FN_GREATER_EQUAL_EXT][FT1][FTs] =
-          {eft_BLN,
-           (void *)dpnp_greater_equal_c_ext<func_type_map_t::find_type<FT1>,
-                                            func_type_map_t::find_type<FTs>>}),
-     ...);
-    ((fmap[DPNPFuncName::DPNP_FN_LESS_EXT][FT1][FTs] =
-          {eft_BLN, (void *)dpnp_less_c_ext<func_type_map_t::find_type<FT1>,
-                                            func_type_map_t::find_type<FTs>>}),
-     ...);
-    ((fmap[DPNPFuncName::DPNP_FN_LESS_EQUAL_EXT][FT1][FTs] =
-          {eft_BLN,
-           (void *)dpnp_less_equal_c_ext<func_type_map_t::find_type<FT1>,
-                                         func_type_map_t::find_type<FTs>>}),
-     ...);
-    ((fmap[DPNPFuncName::DPNP_FN_NOT_EQUAL_EXT][FT1][FTs] =
-          {eft_BLN,
-           (void *)dpnp_not_equal_c_ext<func_type_map_t::find_type<FT1>,
-                                        func_type_map_t::find_type<FTs>>}),
-     ...);
-}
-
-template <DPNPFuncType... FTs>
-static void func_map_logic_2arg_2type_helper(func_map_t &fmap)
-{
-    ((func_map_logic_2arg_2type_core<FTs, FTs...>(fmap)), ...);
-}
-
 void func_map_init_logic(func_map_t &fmap)
 {
     fmap[DPNPFuncName::DPNP_FN_ALL][eft_BLN][eft_BLN] = {
@@ -798,8 +757,5 @@ void func_map_init_logic(func_map_t &fmap)
     fmap[DPNPFuncName::DPNP_FN_ANY][eft_DBL][eft_DBL] = {
         eft_DBL, (void *)dpnp_any_default_c<double, bool>};
 
-    func_map_logic_2arg_2type_helper<eft_BLN, eft_INT, eft_LNG, eft_FLT,
-                                     eft_DBL>(fmap);
-
     return;
 }
diff --git a/dpnp/backend/kernels/dpnp_krnl_mathematical.cpp b/dpnp/backend/kernels/dpnp_krnl_mathematical.cpp
index b4f5cd96b4d..975f4b67ca8 100644
--- a/dpnp/backend/kernels/dpnp_krnl_mathematical.cpp
+++ b/dpnp/backend/kernels/dpnp_krnl_mathematical.cpp
@@ -216,14 +216,6 @@ template <typename _DataType>
 void (*dpnp_elemwise_absolute_default_c)(const void *, void *, size_t) =
     dpnp_elemwise_absolute_c<_DataType>;
 
-template <typename _DataType_input, typename _DataType_output = _DataType_input>
-DPCTLSyclEventRef (*dpnp_elemwise_absolute_ext_c)(DPCTLSyclQueueRef,
-                                                  const void *,
-                                                  void *,
-                                                  size_t,
-                                                  const DPCTLEventVectorRef) =
-    dpnp_elemwise_absolute_c<_DataType_input, _DataType_output>;
-
 template <typename _DataType_output,
           typename _DataType_input1,
           typename _DataType_input2>
@@ -1151,21 +1143,6 @@ void func_map_init_mathematical(func_map_t &fmap)
     fmap[DPNPFuncName::DPNP_FN_ABSOLUTE][eft_DBL][eft_DBL] = {
         eft_DBL, (void *)dpnp_elemwise_absolute_default_c<double>};
 
-    fmap[DPNPFuncName::DPNP_FN_ABSOLUTE_EXT][eft_INT][eft_INT] = {
-        eft_INT, (void *)dpnp_elemwise_absolute_ext_c<int32_t>};
-    fmap[DPNPFuncName::DPNP_FN_ABSOLUTE_EXT][eft_LNG][eft_LNG] = {
-        eft_LNG, (void *)dpnp_elemwise_absolute_ext_c<int64_t>};
-    fmap[DPNPFuncName::DPNP_FN_ABSOLUTE_EXT][eft_FLT][eft_FLT] = {
-        eft_FLT, (void *)dpnp_elemwise_absolute_ext_c<float>};
-    fmap[DPNPFuncName::DPNP_FN_ABSOLUTE_EXT][eft_DBL][eft_DBL] = {
-        eft_DBL, (void *)dpnp_elemwise_absolute_ext_c<double>};
-    fmap[DPNPFuncName::DPNP_FN_ABSOLUTE_EXT][eft_C64][eft_C64] = {
-        eft_FLT,
-        (void *)dpnp_elemwise_absolute_ext_c<std::complex<float>, float>};
-    fmap[DPNPFuncName::DPNP_FN_ABSOLUTE_EXT][eft_C128][eft_C128] = {
-        eft_DBL,
-        (void *)dpnp_elemwise_absolute_ext_c<std::complex<double>, double>};
-
     fmap[DPNPFuncName::DPNP_FN_AROUND][eft_INT][eft_INT] = {
         eft_INT, (void *)dpnp_around_default_c<int32_t>};
     fmap[DPNPFuncName::DPNP_FN_AROUND][eft_LNG][eft_LNG] = {
diff --git a/dpnp/backend/kernels/dpnp_krnl_statistics.cpp b/dpnp/backend/kernels/dpnp_krnl_statistics.cpp
index b0c1016b803..3acf53f0de4 100644
--- a/dpnp/backend/kernels/dpnp_krnl_statistics.cpp
+++ b/dpnp/backend/kernels/dpnp_krnl_statistics.cpp
@@ -292,14 +292,6 @@ template <typename _DataType_input, typename _DataType_output>
 void (*dpnp_count_nonzero_default_c)(void *, void *, size_t) =
     dpnp_count_nonzero_c<_DataType_input, _DataType_output>;
 
-template <typename _DataType_input, typename _DataType_output>
-DPCTLSyclEventRef (*dpnp_count_nonzero_ext_c)(DPCTLSyclQueueRef,
-                                              void *,
-                                              void *,
-                                              size_t,
-                                              const DPCTLEventVectorRef) =
-    dpnp_count_nonzero_c<_DataType_input, _DataType_output>;
-
 template <typename _DataType>
 class dpnp_max_c_kernel;
 
@@ -1273,17 +1265,6 @@ void func_map_init_statistics(func_map_t &fmap)
     fmap[DPNPFuncName::DPNP_FN_COUNT_NONZERO][eft_DBL][eft_DBL] = {
         eft_LNG, (void *)dpnp_count_nonzero_default_c<double, int64_t>};
 
-    fmap[DPNPFuncName::DPNP_FN_COUNT_NONZERO_EXT][eft_BLN][eft_BLN] = {
-        eft_LNG, (void *)dpnp_count_nonzero_ext_c<bool, int64_t>};
-    fmap[DPNPFuncName::DPNP_FN_COUNT_NONZERO_EXT][eft_INT][eft_INT] = {
-        eft_LNG, (void *)dpnp_count_nonzero_ext_c<int32_t, int64_t>};
-    fmap[DPNPFuncName::DPNP_FN_COUNT_NONZERO_EXT][eft_LNG][eft_LNG] = {
-        eft_LNG, (void *)dpnp_count_nonzero_ext_c<int64_t, int64_t>};
-    fmap[DPNPFuncName::DPNP_FN_COUNT_NONZERO_EXT][eft_FLT][eft_FLT] = {
-        eft_LNG, (void *)dpnp_count_nonzero_ext_c<float, int64_t>};
-    fmap[DPNPFuncName::DPNP_FN_COUNT_NONZERO_EXT][eft_DBL][eft_DBL] = {
-        eft_LNG, (void *)dpnp_count_nonzero_ext_c<double, int64_t>};
-
     fmap[DPNPFuncName::DPNP_FN_COV][eft_INT][eft_INT] = {
         eft_DBL, (void *)dpnp_cov_default_c<double>};
     fmap[DPNPFuncName::DPNP_FN_COV][eft_LNG][eft_LNG] = {
diff --git a/dpnp/backend/src/dpnp_fptr.hpp b/dpnp/backend/src/dpnp_fptr.hpp
index d485711f8f5..459398f7611 100644
--- a/dpnp/backend/src/dpnp_fptr.hpp
+++ b/dpnp/backend/src/dpnp_fptr.hpp
@@ -98,7 +98,7 @@ struct func_type_map_factory_t : public Ps...
 };
 
 /**
- * A map of the FPTR interface to link Data type enum value with accociated C++
+ * A map of the FPTR interface to link Data type enum value with associated C++
  * type
  */
 typedef func_type_map_factory_t<
diff --git a/dpnp/backend/src/dpnp_iterator.hpp b/dpnp/backend/src/dpnp_iterator.hpp
index e4bc041bdcd..399f2706383 100644
--- a/dpnp/backend/src/dpnp_iterator.hpp
+++ b/dpnp/backend/src/dpnp_iterator.hpp
@@ -40,7 +40,8 @@
  * @ingroup BACKEND_UTILS
  * @brief Iterator for @ref DPNPC_id type
  *
- * This type should be used to simplify data iteraton over input with parameters
+ * This type should be used to simplify data iteration over input with
+ * parameters
  * "[axis|axes]" It is designed to be used in SYCL environment
  *
  */
diff --git a/dpnp/backend/src/dpnp_random_state.hpp b/dpnp/backend/src/dpnp_random_state.hpp
index 4f00dc074c9..862a2cb765c 100644
--- a/dpnp/backend/src/dpnp_random_state.hpp
+++ b/dpnp/backend/src/dpnp_random_state.hpp
@@ -73,7 +73,7 @@ struct mcg59_struct : engine_struct
  *
  * @param [in]  mt19937       A structure with MKL engine which will be filled
  *                            with generated value by MKL.
- * @param [in]  q_ref         A refference on SYCL queue which will be used to
+ * @param [in]  q_ref         A reference on SYCL queue which will be used to
  *                            obtain random numbers.
  * @param [in]  seed          An initial condition of the generator state.
  */
@@ -90,7 +90,7 @@ INP_DLLEXPORT void MT19937_InitScalarSeed(mt19937_struct *mt19937,
  *
  * @param [in]  mt19937       A structure with MKL engine which will be filled
  *                            with generated value by MKL.
- * @param [in]  q_ref         A refference on SYCL queue which will be used to
+ * @param [in]  q_ref         A reference on SYCL queue which will be used to
  *                            obtain random numbers.
  * @param [in]  seed          A vector with the initial conditions of the
  *                            generator state.
@@ -119,7 +119,7 @@ INP_DLLEXPORT void MT19937_Delete(mt19937_struct *mt19937);
  *
  * @param [in]  mcg59         A structure with MKL engine which will be filled
  *                            with generated value by MKL.
- * @param [in]  q_ref         A refference on SYCL queue which will be used to
+ * @param [in]  q_ref         A reference on SYCL queue which will be used to
  *                            obtain random numbers.
  * @param [in]  seed          An initial condition of the generator state.
  */
diff --git a/dpnp/backend/src/dpnp_utils.hpp b/dpnp/backend/src/dpnp_utils.hpp
index 34547f76f76..bb939004ee0 100644
--- a/dpnp/backend/src/dpnp_utils.hpp
+++ b/dpnp/backend/src/dpnp_utils.hpp
@@ -46,7 +46,7 @@
 
 /**
  * Version of SYCL DPC++ 2023 compiler where a return type of sycl::abs() is
- * changed from unsinged integer to signed one of input vector.
+ * changed from unsigned integer to signed one of input vector.
  */
 #ifndef __SYCL_COMPILER_VECTOR_ABS_CHANGED
 #define __SYCL_COMPILER_VECTOR_ABS_CHANGED 20230503L
@@ -115,17 +115,17 @@ void get_shape_offsets_inkernel(const _DataType *shape,
 
 /**
  * @ingroup BACKEND_UTILS
- * @brief Calculation of indeces in array
+ * @brief Calculation of indices in array
  *
- * Calculates indeces of element in array with given linear position
+ * Calculates indices of element in array with given linear position
  * for example:
  *   idx = 5, shape = (2, 3), ndim = 2,
- *   indeces xyz should be [1, 1]
+ *   indices xyz should be [1, 1]
  *
  * @param [in]  idx     linear index of the element in multy-D array.
  * @param [in]  ndim    number of dimensions.
  * @param [in]  shape   offsets of array.
- * @param [out] xyz     indeces.
+ * @param [out] xyz     indices.
  */
 template <typename _DataType>
 void get_xyz_by_id(size_t idx,
@@ -435,7 +435,7 @@ static inline std::vector<shape_elem_type>
  *
  * @param [in]  q  sycl::device which is examined for type support.
  *
- * @exception std::runtime_error    type T is out of suppport by the queue.
+ * @exception std::runtime_error    type T is out of support by the queue.
  */
 template <typename T>
 static inline void validate_type_for_device(const sycl::device &d)
@@ -471,7 +471,7 @@ static inline void validate_type_for_device(const sycl::device &d)
  *
  * @param [in]  q  sycl::queue which is examined for type support.
  *
- * @exception std::runtime_error    type T is out of suppport by the queue.
+ * @exception std::runtime_error    type T is out of support by the queue.
  */
 template <typename T>
 static inline void validate_type_for_device(const sycl::queue &q)
@@ -490,15 +490,15 @@ static inline void validate_type_for_device(const sycl::queue &q)
 template <typename T>
 std::ostream &operator<<(std::ostream &out, const std::vector<T> &vec)
 {
-    std::string delimeter;
+    std::string delimiter;
     out << "{";
     // std::copy(vec.begin(), vec.end(), std::ostream_iterator<T>(out, ", "));
     // out << "\b\b}"; // last two 'backspaces' needs to eliminate last
     // delimiter. ex: {2, 3, 4, }
     for (auto &elem : vec) {
-        out << delimeter << elem;
-        if (delimeter.empty()) {
-            delimeter.assign(", ");
+        out << delimiter << elem;
+        if (delimiter.empty()) {
+            delimiter.assign(", ");
         }
     }
     out << "}";
diff --git a/dpnp/backend/src/memory_sycl.cpp b/dpnp/backend/src/memory_sycl.cpp
index 5a7cec6118c..e7922bf798f 100644
--- a/dpnp/backend/src/memory_sycl.cpp
+++ b/dpnp/backend/src/memory_sycl.cpp
@@ -81,7 +81,7 @@ char *dpnp_memory_alloc_c(DPCTLSyclQueueRef q_ref, size_t size_in_bytes)
 #if not defined(NDEBUG)
         if (memory_type != sycl::usm::alloc::device) {
             for (size_t i = 0; i < size_in_bytes / sizeof(char); ++i) {
-                array[i] = 0; // type dependant is better. set double(42.42)
+                array[i] = 0; // type dependent is better. set double(42.42)
                               // instead zero
             }
         }
diff --git a/dpnp/dparray.pxd b/dpnp/dparray.pxd
index 9f94db42f40..95a2963c7d0 100644
--- a/dpnp/dparray.pxd
+++ b/dpnp/dparray.pxd
@@ -50,4 +50,3 @@ cdef class dparray:
     cdef void * get_data(self)
 
     cpdef item(self, id=*)
-    cpdef dparray astype(self, dtype, order=*, casting=*, subok=*, copy=*)
diff --git a/dpnp/dparray.pyx b/dpnp/dparray.pyx
index e8d9dd2e345..947065b23ef 100644
--- a/dpnp/dparray.pyx
+++ b/dpnp/dparray.pyx
@@ -41,12 +41,11 @@ from libcpp cimport bool as cpp_bool
 import numpy
 
 from dpnp.dpnp_algo import (
-    dpnp_astype,
     dpnp_flatten,
 )
 
 # to avoid interference with Python internal functions
-from dpnp.dpnp_iface import asnumpy
+from dpnp.dpnp_iface import asnumpy, astype
 from dpnp.dpnp_iface import get_dpnp_descriptor as iface_get_dpnp_descriptor
 from dpnp.dpnp_iface import prod as iface_prod
 from dpnp.dpnp_iface import sum as iface_sum
@@ -323,7 +322,7 @@ cdef class dparray:
 
     @property
     def shape(self):
-        """Lengths of axes. A tuple of numbers represents size of each dimention.
+        """Lengths of axes. A tuple of numbers represents size of each dimension.
 
         Setter of this property involves reshaping without copy. If the array
         cannot be reshaped without copy, it raises an exception.
@@ -336,7 +335,7 @@ cdef class dparray:
 
     @shape.setter
     def shape(self, newshape):
-        """Set new lengths of axes. A tuple of numbers represents size of each dimention.
+        """Set new lengths of axes. A tuple of numbers represents size of each dimension.
         It involves reshaping without copy. If the array cannot be reshaped without copy,
         it raises an exception.
 
@@ -344,7 +343,7 @@ cdef class dparray:
 
         """
 
-        self._dparray_shape = newshape  # TODO strides, enpty dimentions and etc.
+        self._dparray_shape = newshape  # TODO strides, enpty dimensions and etc.
 
     @property
     def flags(self) -> _flagsobj:
@@ -870,47 +869,36 @@ cdef class dparray:
     def __truediv__(self, other):
         return divide(self, other)
 
-    cpdef dparray astype(self, dtype, order='K', casting='unsafe', subok=True, copy=True):
-        """Copy the array with data type casting.
+    def astype(self, dtype, order='K', casting='unsafe', subok=True, copy=True):
+        """
+        Copy the array with data type casting.
 
-        Args:
-            dtype: Target type.
-            order ({'C', 'F', 'A', 'K'}): Row-major (C-style) or column-major (Fortran-style) order.
-                When ``order`` is 'A', it uses 'F' if ``a`` is column-major and uses 'C' otherwise.
-                And when ``order`` is 'K', it keeps strides as closely as possible.
-            copy (bool): If it is False and no cast happens, then this method returns the array itself.
-                Otherwise, a copy is returned.
+        Parameters
+        ----------
+        dtype : dtype
+            Target data type.
+        order : {'C', 'F', 'A', 'K'}
+            Row-major (C-style) or column-major (Fortran-style) order.
+            When ``order`` is 'A', it uses 'F' if ``a`` is column-major and uses 'C' otherwise.
+            And when ``order`` is 'K', it keeps strides as closely as possible.
+        copy : bool
+            If it is False and no cast happens, then this method returns the array itself.
+            Otherwise, a copy is returned.
 
-        Returns:
+        Returns
+        -------
+        out : dpnp.ndarray
             If ``copy`` is False and no cast is required, then the array itself is returned.
             Otherwise, it returns a (possibly casted) copy of the array.
 
-        .. note::
-           This method currently does not support `order``, `casting``, ``copy``, and ``subok`` arguments.
-
-        .. seealso:: :meth:`numpy.ndarray.astype`
+        Limitations
+        -----------
+        Parameter `subok` is supported with default value.
+        Otherwise ``NotImplementedError`` exception will be raised.
 
         """
 
-        if casting is not 'unsafe':
-            pass
-        elif subok is not True:
-            pass
-        elif copy is not True:
-            pass
-        elif order is not 'K':
-            pass
-        elif self.dtype == numpy.complex128 or dtype == numpy.complex128:
-            pass
-        elif self.dtype == numpy.complex64 or dtype == numpy.complex64:
-            pass
-        else:
-            self_desc = iface_get_dpnp_descriptor(self)
-            return dpnp_astype(self_desc, dtype).get_pyobj()
-
-        result = dp2nd_array(self).astype(dtype=dtype, order=order, casting=casting, subok=subok, copy=copy)
-
-        return nd2dp_array(result)
+        return astype(self, dtype, order=order, casting=casting, subok=subok, copy=copy)
 
     def conj(self):
         """
@@ -1077,7 +1065,8 @@ cdef class dparray:
         -----------
         Input array is supported as :obj:`dpnp.ndarray`.
         Input kth is supported as :obj:`int`.
-        Parameters ``axis``, ``kind`` and ``order`` are supported only with default values.
+        Parameters `axis`, `kind` and `order` are supported only with default values.
+
         """
 
         return partition(self, kth, axis, kind, order)
diff --git a/dpnp/dpnp_algo/CMakeLists.txt b/dpnp/dpnp_algo/CMakeLists.txt
index 8aa419220de..f39615f145a 100644
--- a/dpnp/dpnp_algo/CMakeLists.txt
+++ b/dpnp/dpnp_algo/CMakeLists.txt
@@ -2,7 +2,6 @@
 set(dpnp_algo_pyx_deps
   ${CMAKE_CURRENT_SOURCE_DIR}/dpnp_algo_linearalgebra.pxi
   ${CMAKE_CURRENT_SOURCE_DIR}/dpnp_algo_manipulation.pxi
-  ${CMAKE_CURRENT_SOURCE_DIR}/dpnp_algo_counting.pxi
   ${CMAKE_CURRENT_SOURCE_DIR}/dpnp_algo_statistics.pxi
   ${CMAKE_CURRENT_SOURCE_DIR}/dpnp_algo_trigonometric.pxi
   ${CMAKE_CURRENT_SOURCE_DIR}/dpnp_algo_sorting.pxi
diff --git a/dpnp/dpnp_algo/dpnp_algo.pxd b/dpnp/dpnp_algo/dpnp_algo.pxd
index a512737ef31..7c0d00dd03d 100644
--- a/dpnp/dpnp_algo/dpnp_algo.pxd
+++ b/dpnp/dpnp_algo/dpnp_algo.pxd
@@ -33,8 +33,6 @@ from dpnp.dpnp_utils.dpnp_algo_utils cimport dpnp_descriptor
 
 cdef extern from "dpnp_iface_fptr.hpp" namespace "DPNPFuncName":  # need this namespace for Enum import
     cdef enum DPNPFuncName "DPNPFuncName":
-        DPNP_FN_ABSOLUTE
-        DPNP_FN_ABSOLUTE_EXT
         DPNP_FN_ALLCLOSE
         DPNP_FN_ALLCLOSE_EXT
         DPNP_FN_ARANGE
@@ -44,8 +42,6 @@ cdef extern from "dpnp_iface_fptr.hpp" namespace "DPNPFuncName":  # need this na
         DPNP_FN_ARGMIN_EXT
         DPNP_FN_ARGSORT
         DPNP_FN_ARGSORT_EXT
-        DPNP_FN_ASTYPE
-        DPNP_FN_ASTYPE_EXT
         DPNP_FN_CBRT
         DPNP_FN_CBRT_EXT
         DPNP_FN_CHOLESKY
@@ -58,8 +54,6 @@ cdef extern from "dpnp_iface_fptr.hpp" namespace "DPNPFuncName":  # need this na
         DPNP_FN_COPYSIGN_EXT
         DPNP_FN_CORRELATE
         DPNP_FN_CORRELATE_EXT
-        DPNP_FN_COUNT_NONZERO
-        DPNP_FN_COUNT_NONZERO_EXT
         DPNP_FN_CROSS
         DPNP_FN_CROSS_EXT
         DPNP_FN_CUMPROD
@@ -88,12 +82,8 @@ cdef extern from "dpnp_iface_fptr.hpp" namespace "DPNPFuncName":  # need this na
         DPNP_FN_ERF_EXT
         DPNP_FN_EYE
         DPNP_FN_EYE_EXT
-        DPNP_FN_EXP
-        DPNP_FN_EXP_EXT
         DPNP_FN_EXP2
         DPNP_FN_EXP2_EXT
-        DPNP_FN_EXPM1
-        DPNP_FN_EXPM1_EXT
         DPNP_FN_FABS
         DPNP_FN_FABS_EXT
         DPNP_FN_FFT_FFT
@@ -108,20 +98,10 @@ cdef extern from "dpnp_iface_fptr.hpp" namespace "DPNPFuncName":  # need this na
         DPNP_FN_FMOD_EXT
         DPNP_FN_FULL
         DPNP_FN_FULL_LIKE
-        DPNP_FN_HYPOT
-        DPNP_FN_HYPOT_EXT
-        DPNP_FN_IDENTITY
-        DPNP_FN_IDENTITY_EXT
         DPNP_FN_INV
         DPNP_FN_INV_EXT
         DPNP_FN_KRON
         DPNP_FN_KRON_EXT
-        DPNP_FN_LOG10
-        DPNP_FN_LOG10_EXT
-        DPNP_FN_LOG1P
-        DPNP_FN_LOG1P_EXT
-        DPNP_FN_LOG2
-        DPNP_FN_LOG2_EXT
         DPNP_FN_MATMUL
         DPNP_FN_MATMUL_EXT
         DPNP_FN_MATRIX_RANK
@@ -244,8 +224,6 @@ cdef extern from "dpnp_iface_fptr.hpp" namespace "DPNPFuncName":  # need this na
         DPNP_FN_TRANSPOSE
         DPNP_FN_TRAPZ
         DPNP_FN_TRAPZ_EXT
-        DPNP_FN_TRI
-        DPNP_FN_TRI_EXT
         DPNP_FN_TRIL
         DPNP_FN_TRIL_EXT
         DPNP_FN_TRIU
@@ -351,7 +329,6 @@ ctypedef c_dpctl.DPCTLSyclEventRef(*dpnp_reduction_c_t)(c_dpctl.DPCTLSyclQueueRe
                                                         const long*,
                                                         const c_dpctl.DPCTLEventVectorRef)
 
-cpdef dpnp_descriptor dpnp_astype(dpnp_descriptor x1, dtype)
 cpdef dpnp_descriptor dpnp_flatten(dpnp_descriptor x1)
 
 
@@ -384,13 +361,10 @@ cpdef dpnp_descriptor dpnp_copy(dpnp_descriptor x1)
 """
 Mathematical functions
 """
-cpdef dpnp_descriptor dpnp_hypot(dpnp_descriptor x1_obj, dpnp_descriptor x2_obj, object dtype=*,
-                                 dpnp_descriptor out=*, object where=*)
-cpdef dpnp_descriptor dpnp_maximum(dpnp_descriptor x1_obj, dpnp_descriptor x2_obj, object dtype=*,
+cpdef dpnp_descriptor dpnp_fmax(dpnp_descriptor x1_obj, dpnp_descriptor x2_obj, object dtype=*,
                                    dpnp_descriptor out=*, object where=*)
-cpdef dpnp_descriptor dpnp_minimum(dpnp_descriptor x1_obj, dpnp_descriptor x2_obj, object dtype=*,
+cpdef dpnp_descriptor dpnp_fmin(dpnp_descriptor x1_obj, dpnp_descriptor x2_obj, object dtype=*,
                                    dpnp_descriptor out=*, object where=*)
-
 """
 Array manipulation routines
 """
@@ -420,11 +394,6 @@ Trigonometric functions
 """
 cpdef dpnp_descriptor dpnp_cbrt(dpnp_descriptor array1)
 cpdef dpnp_descriptor dpnp_degrees(dpnp_descriptor array1)
-cpdef dpnp_descriptor dpnp_exp(dpnp_descriptor array1, dpnp_descriptor out)
 cpdef dpnp_descriptor dpnp_exp2(dpnp_descriptor array1)
-cpdef dpnp_descriptor dpnp_expm1(dpnp_descriptor array1)
-cpdef dpnp_descriptor dpnp_log10(dpnp_descriptor array1)
-cpdef dpnp_descriptor dpnp_log1p(dpnp_descriptor array1)
-cpdef dpnp_descriptor dpnp_log2(dpnp_descriptor array1)
 cpdef dpnp_descriptor dpnp_radians(dpnp_descriptor array1)
 cpdef dpnp_descriptor dpnp_recip(dpnp_descriptor array1)
diff --git a/dpnp/dpnp_algo/dpnp_algo.pyx b/dpnp/dpnp_algo/dpnp_algo.pyx
index 0bde1b25fb2..0892c9f05e4 100644
--- a/dpnp/dpnp_algo/dpnp_algo.pyx
+++ b/dpnp/dpnp_algo/dpnp_algo.pyx
@@ -54,14 +54,12 @@ import operator
 import numpy
 
 __all__ = [
-    "dpnp_astype",
     "dpnp_flatten",
     "dpnp_queue_initialize",
 ]
 
 
 include "dpnp_algo_arraycreation.pxi"
-include "dpnp_algo_counting.pxi"
 include "dpnp_algo_indexing.pxi"
 include "dpnp_algo_linearalgebra.pxi"
 include "dpnp_algo_logic.pxi"
@@ -74,9 +72,6 @@ include "dpnp_algo_statistics.pxi"
 include "dpnp_algo_trigonometric.pxi"
 
 
-ctypedef c_dpctl.DPCTLSyclEventRef(*fptr_dpnp_astype_t)(c_dpctl.DPCTLSyclQueueRef,
-                                                        const void *, void * , const size_t,
-                                                        const c_dpctl.DPCTLEventVectorRef)
 ctypedef c_dpctl.DPCTLSyclEventRef(*fptr_dpnp_flatten_t)(c_dpctl.DPCTLSyclQueueRef,
                                                          void *, const size_t, const size_t,
                                                          const shape_elem_type * , const shape_elem_type * ,
@@ -86,37 +81,6 @@ ctypedef c_dpctl.DPCTLSyclEventRef(*fptr_dpnp_flatten_t)(c_dpctl.DPCTLSyclQueueR
                                                          const c_dpctl.DPCTLEventVectorRef)
 
 
-cpdef utils.dpnp_descriptor dpnp_astype(utils.dpnp_descriptor x1, dtype):
-    cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(x1.dtype)
-    cdef DPNPFuncType param2_type = dpnp_dtype_to_DPNPFuncType(dtype)
-
-    cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_ASTYPE_EXT, param1_type, param2_type)
-
-    x1_obj = x1.get_array()
-
-    # ceate result array with type given by FPTR data
-    cdef shape_type_c result_shape = x1.shape
-    cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape,
-                                                                       kernel_data.return_type,
-                                                                       None,
-                                                                       device=x1_obj.sycl_device,
-                                                                       usm_type=x1_obj.usm_type,
-                                                                       sycl_queue=x1_obj.sycl_queue)
-
-    result_sycl_queue = result.get_array().sycl_queue
-
-    cdef c_dpctl.SyclQueue q = <c_dpctl.SyclQueue> result_sycl_queue
-    cdef c_dpctl.DPCTLSyclQueueRef q_ref = q.get_queue_ref()
-
-    cdef fptr_dpnp_astype_t func = <fptr_dpnp_astype_t > kernel_data.ptr
-    cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref, x1.get_data(), result.get_data(), x1.size, NULL)
-
-    with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)
-    c_dpctl.DPCTLEvent_Delete(event_ref)
-
-    return result
-
-
 cpdef utils.dpnp_descriptor dpnp_flatten(utils.dpnp_descriptor x1):
     cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(x1.dtype)
 
@@ -127,7 +91,7 @@ cpdef utils.dpnp_descriptor dpnp_flatten(utils.dpnp_descriptor x1):
 
     x1_obj = x1.get_array()
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef shape_type_c result_shape = (x1.size,)
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape,
                                                                        kernel_data.return_type,
diff --git a/dpnp/dpnp_algo/dpnp_algo_arraycreation.pxi b/dpnp/dpnp_algo/dpnp_algo_arraycreation.pxi
index 3525a42ca0d..5ebb8d157a7 100644
--- a/dpnp/dpnp_algo/dpnp_algo_arraycreation.pxi
+++ b/dpnp/dpnp_algo/dpnp_algo_arraycreation.pxi
@@ -39,12 +39,10 @@ __all__ += [
     "dpnp_copy",
     "dpnp_diag",
     "dpnp_geomspace",
-    "dpnp_identity",
     "dpnp_linspace",
     "dpnp_logspace",
     "dpnp_ptp",
     "dpnp_trace",
-    "dpnp_tri",
     "dpnp_vander",
 ]
 
@@ -168,28 +166,6 @@ cpdef utils.dpnp_descriptor dpnp_geomspace(start, stop, num, endpoint, dtype, ax
     return result
 
 
-cpdef utils.dpnp_descriptor dpnp_identity(n, result_dtype):
-    cdef DPNPFuncType dtype_in = dpnp_dtype_to_DPNPFuncType(result_dtype)
-
-    cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_IDENTITY_EXT, dtype_in, DPNP_FT_NONE)
-
-    cdef shape_type_c shape_in = (n, n)
-    cdef utils.dpnp_descriptor result = utils.create_output_descriptor(shape_in, kernel_data.return_type, None)
-
-    result_sycl_queue = result.get_array().sycl_queue
-
-    cdef c_dpctl.SyclQueue q = <c_dpctl.SyclQueue> result_sycl_queue
-    cdef c_dpctl.DPCTLSyclQueueRef q_ref = q.get_queue_ref()
-
-    cdef fptr_1out_t func = <fptr_1out_t > kernel_data.ptr
-    cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref, result.get_data(), n, NULL)
-
-    with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)
-    c_dpctl.DPCTLEvent_Delete(event_ref)
-
-    return result
-
-
 def dpnp_linspace(start, stop, num, dtype=None, device=None, usm_type=None, sycl_queue=None, endpoint=True, retstep=False, axis=0):
     usm_type_alloc, sycl_queue_alloc = utils_py.get_usm_allocations([start, stop])
 
@@ -372,7 +348,7 @@ cpdef utils.dpnp_descriptor dpnp_trace(utils.dpnp_descriptor arr, offset=0, axis
 
     arr_obj = arr.get_array()
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef shape_type_c result_shape = diagonal_shape[:-1]
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape,
                                                                        kernel_data.return_type,
@@ -401,39 +377,13 @@ cpdef utils.dpnp_descriptor dpnp_trace(utils.dpnp_descriptor arr, offset=0, axis
     return result
 
 
-cpdef utils.dpnp_descriptor dpnp_tri(N, M=None, k=0, dtype=dpnp.float):
-    if M is None:
-        M = N
-
-    cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(dtype)
-
-    cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_TRI_EXT, param1_type, param1_type)
-
-    cdef shape_type_c shape_in = (N, M)
-    cdef utils.dpnp_descriptor result = utils.create_output_descriptor(shape_in, kernel_data.return_type, None)
-
-    result_sycl_queue = result.get_array().sycl_queue
-
-    cdef c_dpctl.SyclQueue q = <c_dpctl.SyclQueue> result_sycl_queue
-    cdef c_dpctl.DPCTLSyclQueueRef q_ref = q.get_queue_ref()
-
-    cdef custom_indexing_1out_func_ptr_t func = <custom_indexing_1out_func_ptr_t > kernel_data.ptr
-
-    cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref, result.get_data(), N, M, k, NULL)
-
-    with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)
-    c_dpctl.DPCTLEvent_Delete(event_ref)
-
-    return result
-
-
 cpdef utils.dpnp_descriptor dpnp_vander(utils.dpnp_descriptor x1, int N, int increasing):
     cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(x1.dtype)
     cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_VANDER_EXT, param1_type, DPNP_FT_NONE)
 
     x1_obj = x1.get_array()
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef shape_type_c result_shape = (x1.size, N)
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape,
                                                                        kernel_data.return_type,
diff --git a/dpnp/dpnp_algo/dpnp_algo_counting.pxi b/dpnp/dpnp_algo/dpnp_algo_counting.pxi
deleted file mode 100644
index ef32d3ed362..00000000000
--- a/dpnp/dpnp_algo/dpnp_algo_counting.pxi
+++ /dev/null
@@ -1,44 +0,0 @@
-# cython: language_level=3
-# cython: linetrace=True
-# -*- coding: utf-8 -*-
-# *****************************************************************************
-# Copyright (c) 2016-2023, Intel Corporation
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-# - Redistributions of source code must retain the above copyright notice,
-#   this list of conditions and the following disclaimer.
-# - Redistributions in binary form must reproduce the above copyright notice,
-#   this list of conditions and the following disclaimer in the documentation
-#   and/or other materials provided with the distribution.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
-# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
-# THE POSSIBILITY OF SUCH DAMAGE.
-# *****************************************************************************
-
-"""Module Backend (Counting part)
-
-This module contains interface functions between C backend layer
-and the rest of the library
-
-"""
-
-# NO IMPORTs here. All imports must be placed into main "dpnp_algo.pyx" file
-
-__all__ += [
-    "dpnp_count_nonzero"
-]
-
-
-cpdef utils.dpnp_descriptor dpnp_count_nonzero(utils.dpnp_descriptor x1):
-    return call_fptr_1in_1out(DPNP_FN_COUNT_NONZERO_EXT, x1, (1,))
diff --git a/dpnp/dpnp_algo/dpnp_algo_linearalgebra.pxi b/dpnp/dpnp_algo/dpnp_algo_linearalgebra.pxi
index ffa80c97be4..6614399f182 100644
--- a/dpnp/dpnp_algo/dpnp_algo_linearalgebra.pxi
+++ b/dpnp/dpnp_algo/dpnp_algo_linearalgebra.pxi
@@ -170,7 +170,7 @@ cpdef utils.dpnp_descriptor dpnp_inner(dpnp_descriptor array1, dpnp_descriptor a
 
     result_sycl_device, result_usm_type, result_sycl_queue = utils.get_common_usm_allocation(array1, array2)
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef utils.dpnp_descriptor result = utils_py.create_output_descriptor_py(result_shape,
                                                                              result_type,
                                                                              None,
@@ -261,7 +261,7 @@ cpdef utils.dpnp_descriptor dpnp_kron(dpnp_descriptor in_array1, dpnp_descriptor
 
     result_sycl_device, result_usm_type, result_sycl_queue = utils.get_common_usm_allocation(in_array1, in_array2)
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape,
                                                                        kernel_data.return_type,
                                                                        None,
@@ -340,7 +340,7 @@ cpdef utils.dpnp_descriptor dpnp_matmul(utils.dpnp_descriptor in_array1, utils.d
     # get the FPTR data structure
     cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_MATMUL_EXT, param1_type, param2_type)
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     result_sycl_device, result_usm_type, result_sycl_queue = utils.get_common_usm_allocation(in_array1, in_array2)
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(shape_result,
                                                                        kernel_data.return_type,
diff --git a/dpnp/dpnp_algo/dpnp_algo_manipulation.pxi b/dpnp/dpnp_algo/dpnp_algo_manipulation.pxi
index 4280bd621ce..7a517ac261f 100644
--- a/dpnp/dpnp_algo/dpnp_algo_manipulation.pxi
+++ b/dpnp/dpnp_algo/dpnp_algo_manipulation.pxi
@@ -36,8 +36,6 @@ and the rest of the library
 # NO IMPORTs here. All imports must be placed into main "dpnp_algo.pyx" file
 
 __all__ += [
-    "dpnp_atleast_2d",
-    "dpnp_atleast_3d",
     "dpnp_repeat",
 ]
 
@@ -48,60 +46,6 @@ ctypedef c_dpctl.DPCTLSyclEventRef(*fptr_dpnp_repeat_t)(c_dpctl.DPCTLSyclQueueRe
                                                         const c_dpctl.DPCTLEventVectorRef)
 
 
-cpdef utils.dpnp_descriptor dpnp_atleast_2d(utils.dpnp_descriptor arr):
-    # it looks like it should be dpnp.copy + dpnp.reshape
-    cdef utils.dpnp_descriptor result
-    cdef size_t arr_ndim = arr.ndim
-    cdef long arr_size = arr.size
-    if arr_ndim == 1:
-        arr_obj = arr.get_array()
-        result = utils_py.create_output_descriptor_py((1, arr_size),
-                                                      arr.dtype,
-                                                      None,
-                                                      device=arr_obj.sycl_device,
-                                                      usm_type=arr_obj.usm_type,
-                                                      sycl_queue=arr_obj.sycl_queue)
-        for i in range(arr_size):
-            result.get_pyobj()[0, i] = arr.get_pyobj()[i]
-        return result
-    else:
-        return arr
-
-
-cpdef utils.dpnp_descriptor dpnp_atleast_3d(utils.dpnp_descriptor arr):
-    # it looks like it should be dpnp.copy + dpnp.reshape
-    cdef utils.dpnp_descriptor result
-    cdef size_t arr_ndim = arr.ndim
-    cdef shape_type_c arr_shape = arr.shape
-    cdef long arr_size = arr.size
-
-    arr_obj = arr.get_array()
-
-    if arr_ndim == 1:
-        result = utils_py.create_output_descriptor_py((1, 1, arr_size),
-                                                      arr.dtype,
-                                                      None,
-                                                      device=arr_obj.sycl_device,
-                                                      usm_type=arr_obj.usm_type,
-                                                      sycl_queue=arr_obj.sycl_queue)
-        for i in range(arr_size):
-            result.get_pyobj()[0, 0, i] = arr.get_pyobj()[i]
-        return result
-    elif arr_ndim == 2:
-        result = utils_py.create_output_descriptor_py((1, arr_shape[0], arr_shape[1]),
-                                                      arr.dtype,
-                                                      None,
-                                                      device=arr_obj.sycl_device,
-                                                      usm_type=arr_obj.usm_type,
-                                                      sycl_queue=arr_obj.sycl_queue)
-        for i in range(arr_shape[0]):
-            for j in range(arr_shape[1]):
-                result.get_pyobj()[0, i, j] = arr.get_pyobj()[i, j]
-        return result
-    else:
-        return arr
-
-
 cpdef utils.dpnp_descriptor dpnp_repeat(utils.dpnp_descriptor array1, repeats, axes=None):
     cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(array1.dtype)
 
@@ -109,7 +53,7 @@ cpdef utils.dpnp_descriptor dpnp_repeat(utils.dpnp_descriptor array1, repeats, a
 
     array1_obj = array1.get_array()
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef shape_type_c result_shape = (array1.size * repeats, )
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape,
                                                                        kernel_data.return_type,
diff --git a/dpnp/dpnp_algo/dpnp_algo_mathematical.pxi b/dpnp/dpnp_algo/dpnp_algo_mathematical.pxi
index 401232ca8f2..21f7768cf2b 100644
--- a/dpnp/dpnp_algo/dpnp_algo_mathematical.pxi
+++ b/dpnp/dpnp_algo/dpnp_algo_mathematical.pxi
@@ -36,7 +36,6 @@ and the rest of the library
 # NO IMPORTs here. All imports must be placed into main "dpnp_algo.pyx" file
 
 __all__ += [
-    "dpnp_absolute",
     "dpnp_copysign",
     "dpnp_cross",
     "dpnp_cumprod",
@@ -46,9 +45,8 @@ __all__ += [
     "dpnp_fabs",
     "dpnp_fmod",
     "dpnp_gradient",
-    'dpnp_hypot',
-    "dpnp_maximum",
-    "dpnp_minimum",
+    "dpnp_fmax",
+    "dpnp_fmin",
     "dpnp_modf",
     "dpnp_nancumprod",
     "dpnp_nancumsum",
@@ -60,9 +58,6 @@ __all__ += [
 ]
 
 
-ctypedef c_dpctl.DPCTLSyclEventRef(*fptr_custom_elemwise_absolute_1in_1out_t)(c_dpctl.DPCTLSyclQueueRef,
-                                                                              void * , void * , size_t,
-                                                                              const c_dpctl.DPCTLEventVectorRef)
 ctypedef c_dpctl.DPCTLSyclEventRef(*fptr_1in_2out_t)(c_dpctl.DPCTLSyclQueueRef,
                                                      void * , void * , void * , size_t,
                                                      const c_dpctl.DPCTLEventVectorRef)
@@ -71,41 +66,6 @@ ctypedef c_dpctl.DPCTLSyclEventRef(*ftpr_custom_trapz_2in_1out_with_2size_t)(c_d
                                                                              const c_dpctl.DPCTLEventVectorRef)
 
 
-cpdef utils.dpnp_descriptor dpnp_absolute(utils.dpnp_descriptor x1):
-    cdef shape_type_c x1_shape = x1.shape
-    cdef size_t x1_shape_size = x1.ndim
-
-    # convert string type names (array.dtype) to C enum DPNPFuncType
-    cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(x1.dtype)
-
-    # get the FPTR data structure
-    cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_ABSOLUTE_EXT, param1_type, param1_type)
-
-    x1_obj = x1.get_array()
-
-    # ceate result array with type given by FPTR data
-    cdef utils.dpnp_descriptor result = utils.create_output_descriptor(x1_shape,
-                                                                       kernel_data.return_type,
-                                                                       None,
-                                                                       device=x1_obj.sycl_device,
-                                                                       usm_type=x1_obj.usm_type,
-                                                                       sycl_queue=x1_obj.sycl_queue)
-
-    result_sycl_queue = result.get_array().sycl_queue
-
-    cdef c_dpctl.SyclQueue q = <c_dpctl.SyclQueue> result_sycl_queue
-    cdef c_dpctl.DPCTLSyclQueueRef q_ref = q.get_queue_ref()
-
-    cdef fptr_custom_elemwise_absolute_1in_1out_t func = <fptr_custom_elemwise_absolute_1in_1out_t > kernel_data.ptr
-    # call FPTR function
-    cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref, x1.get_data(), result.get_data(), x1.size, NULL)
-
-    with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)
-    c_dpctl.DPCTLEvent_Delete(event_ref)
-
-    return result
-
-
 cpdef utils.dpnp_descriptor dpnp_copysign(utils.dpnp_descriptor x1_obj,
                                           utils.dpnp_descriptor x2_obj,
                                           object dtype=None,
@@ -249,7 +209,7 @@ cpdef utils.dpnp_descriptor dpnp_gradient(utils.dpnp_descriptor y1, int dx=1):
 
     y1_obj = y1.get_array()
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef shape_type_c result_shape = utils._object_to_tuple(size)
     cdef utils.dpnp_descriptor result = utils_py.create_output_descriptor_py(result_shape,
                                                                              dpnp.default_float_type(y1_obj.sycl_queue),
@@ -273,15 +233,7 @@ cpdef utils.dpnp_descriptor dpnp_gradient(utils.dpnp_descriptor y1, int dx=1):
     return result
 
 
-cpdef utils.dpnp_descriptor dpnp_hypot(utils.dpnp_descriptor x1_obj,
-                                       utils.dpnp_descriptor x2_obj,
-                                       object dtype=None,
-                                       utils.dpnp_descriptor out=None,
-                                       object where=True):
-    return call_fptr_2in_1out_strides(DPNP_FN_HYPOT_EXT, x1_obj, x2_obj, dtype, out, where)
-
-
-cpdef utils.dpnp_descriptor dpnp_maximum(utils.dpnp_descriptor x1_obj,
+cpdef utils.dpnp_descriptor dpnp_fmax(utils.dpnp_descriptor x1_obj,
                                          utils.dpnp_descriptor x2_obj,
                                          object dtype=None,
                                          utils.dpnp_descriptor out=None,
@@ -289,7 +241,7 @@ cpdef utils.dpnp_descriptor dpnp_maximum(utils.dpnp_descriptor x1_obj,
     return call_fptr_2in_1out_strides(DPNP_FN_MAXIMUM_EXT, x1_obj, x2_obj, dtype, out, where)
 
 
-cpdef utils.dpnp_descriptor dpnp_minimum(utils.dpnp_descriptor x1_obj,
+cpdef utils.dpnp_descriptor dpnp_fmin(utils.dpnp_descriptor x1_obj,
                                          utils.dpnp_descriptor x2_obj,
                                          object dtype=None,
                                          utils.dpnp_descriptor out=None,
@@ -306,7 +258,7 @@ cpdef tuple dpnp_modf(utils.dpnp_descriptor x1):
 
     x1_obj = x1.get_array()
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef shape_type_c result_shape = x1.shape
     cdef utils.dpnp_descriptor result1 = utils.create_output_descriptor(result_shape,
                                                                         kernel_data.return_type,
@@ -415,13 +367,13 @@ cpdef utils.dpnp_descriptor dpnp_prod(utils.dpnp_descriptor x1,
                                       object initial=None,
                                       object where=True):
     """
-    input:float64   : outout:float64   : name:prod
-    input:float32   : outout:float32   : name:prod
-    input:int64     : outout:int64     : name:prod
-    input:int32     : outout:int64     : name:prod
-    input:bool      : outout:int64     : name:prod
-    input:complex64 : outout:complex64 : name:prod
-    input:complex128: outout:complex128: name:prod
+    input:float64   : output:float64   : name:prod
+    input:float32   : output:float32   : name:prod
+    input:int64     : output:int64     : name:prod
+    input:int32     : output:int64     : name:prod
+    input:bool      : output:int64     : name:prod
+    input:complex64 : output:complex64 : name:prod
+    input:complex128: output:complex128: name:prod
     """
 
     cdef shape_type_c x1_shape = x1.shape
@@ -533,7 +485,7 @@ cpdef utils.dpnp_descriptor dpnp_trapz(utils.dpnp_descriptor y1, utils.dpnp_desc
 
     result_sycl_device, result_usm_type, result_sycl_queue = utils.get_common_usm_allocation(y1, x1)
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef shape_type_c result_shape = (1,)
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape,
                                                                        kernel_data.return_type,
diff --git a/dpnp/dpnp_algo/dpnp_algo_searching.pxi b/dpnp/dpnp_algo/dpnp_algo_searching.pxi
index 46f1c83f42b..a84c918f3c2 100644
--- a/dpnp/dpnp_algo/dpnp_algo_searching.pxi
+++ b/dpnp/dpnp_algo/dpnp_algo_searching.pxi
@@ -55,7 +55,7 @@ cpdef utils.dpnp_descriptor dpnp_argmax(utils.dpnp_descriptor in_array1):
 
     in_array1_obj = in_array1.get_array()
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef shape_type_c result_shape = (1,)
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape,
                                                                        kernel_data.return_type,
@@ -91,7 +91,7 @@ cpdef utils.dpnp_descriptor dpnp_argmin(utils.dpnp_descriptor in_array1):
 
     in_array1_obj = in_array1.get_array()
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef shape_type_c result_shape = (1,)
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape,
                                                                        kernel_data.return_type,
diff --git a/dpnp/dpnp_algo/dpnp_algo_statistics.pxi b/dpnp/dpnp_algo/dpnp_algo_statistics.pxi
index 1c35cb4ac33..43463c7791d 100644
--- a/dpnp/dpnp_algo/dpnp_algo_statistics.pxi
+++ b/dpnp/dpnp_algo/dpnp_algo_statistics.pxi
@@ -86,7 +86,7 @@ cdef utils.dpnp_descriptor call_fptr_custom_std_var_1in_1out(DPNPFuncName fptr_n
 
     x1_obj = x1.get_array()
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef shape_type_c result_shape = (1,)
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape,
                                                                        kernel_data.return_type,
@@ -144,7 +144,7 @@ cpdef utils.dpnp_descriptor dpnp_correlate(utils.dpnp_descriptor x1, utils.dpnp_
 
     result_sycl_device, result_usm_type, result_sycl_queue = utils.get_common_usm_allocation(x1, x2)
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef shape_type_c result_shape = (1,)
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape,
                                                                        kernel_data.return_type,
@@ -185,7 +185,7 @@ cdef utils.dpnp_descriptor _dpnp_max(utils.dpnp_descriptor x1, _axis_, shape_typ
 
     x1_obj = x1.get_array()
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape,
                                                                        kernel_data.return_type,
                                                                        None,
@@ -392,7 +392,7 @@ cpdef utils.dpnp_descriptor dpnp_nanvar(utils.dpnp_descriptor arr, ddof):
 
     arr_obj = arr.get_array()
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef shape_type_c result_shape = utils._object_to_tuple(res_size)
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape,
                                                                        kernel_data.return_type,
diff --git a/dpnp/dpnp_algo/dpnp_algo_trigonometric.pxi b/dpnp/dpnp_algo/dpnp_algo_trigonometric.pxi
index 55e7e9c8dc5..099aa9ba7ab 100644
--- a/dpnp/dpnp_algo/dpnp_algo_trigonometric.pxi
+++ b/dpnp/dpnp_algo/dpnp_algo_trigonometric.pxi
@@ -38,12 +38,7 @@ and the rest of the library
 __all__ += [
     'dpnp_cbrt',
     'dpnp_degrees',
-    'dpnp_exp',
     'dpnp_exp2',
-    'dpnp_expm1',
-    'dpnp_log10',
-    'dpnp_log1p',
-    'dpnp_log2',
     'dpnp_radians',
     'dpnp_recip',
     'dpnp_unwrap'
@@ -58,30 +53,10 @@ cpdef utils.dpnp_descriptor dpnp_degrees(utils.dpnp_descriptor x1):
     return call_fptr_1in_1out_strides(DPNP_FN_DEGREES_EXT, x1)
 
 
-cpdef utils.dpnp_descriptor dpnp_exp(utils.dpnp_descriptor x1, utils.dpnp_descriptor out):
-    return call_fptr_1in_1out_strides(DPNP_FN_EXP_EXT, x1, dtype=None, out=out, where=True, func_name='exp')
-
-
 cpdef utils.dpnp_descriptor dpnp_exp2(utils.dpnp_descriptor x1):
     return call_fptr_1in_1out_strides(DPNP_FN_EXP2_EXT, x1)
 
 
-cpdef utils.dpnp_descriptor dpnp_expm1(utils.dpnp_descriptor x1):
-    return call_fptr_1in_1out_strides(DPNP_FN_EXPM1_EXT, x1)
-
-
-cpdef utils.dpnp_descriptor dpnp_log10(utils.dpnp_descriptor x1):
-    return call_fptr_1in_1out_strides(DPNP_FN_LOG10_EXT, x1)
-
-
-cpdef utils.dpnp_descriptor dpnp_log1p(utils.dpnp_descriptor x1):
-    return call_fptr_1in_1out_strides(DPNP_FN_LOG1P_EXT, x1)
-
-
-cpdef utils.dpnp_descriptor dpnp_log2(utils.dpnp_descriptor x1):
-    return call_fptr_1in_1out_strides(DPNP_FN_LOG2_EXT, x1)
-
-
 cpdef utils.dpnp_descriptor dpnp_recip(utils.dpnp_descriptor x1):
     return call_fptr_1in_1out_strides(DPNP_FN_RECIP_EXT, x1)
 
diff --git a/dpnp/dpnp_algo/dpnp_elementwise_common.py b/dpnp/dpnp_algo/dpnp_elementwise_common.py
index 9c9276d3376..39b2199e914 100644
--- a/dpnp/dpnp_algo/dpnp_elementwise_common.py
+++ b/dpnp/dpnp_algo/dpnp_elementwise_common.py
@@ -27,13 +27,7 @@
 # *****************************************************************************
 
 
-from sys import platform
-
-import dpctl.tensor._tensor_impl as ti
-from dpctl.tensor._elementwise_common import (
-    BinaryElementwiseFunc,
-    UnaryElementwiseFunc,
-)
+import dpctl.tensor as dpt
 
 import dpnp
 import dpnp.backend.extensions.vm._vm_impl as vmi
@@ -42,6 +36,7 @@
 
 __all__ = [
     "check_nd_call_func",
+    "dpnp_abs",
     "dpnp_acos",
     "dpnp_acosh",
     "dpnp_add",
@@ -59,10 +54,13 @@
     "dpnp_cosh",
     "dpnp_divide",
     "dpnp_equal",
+    "dpnp_exp",
+    "dpnp_expm1",
     "dpnp_floor",
     "dpnp_floor_divide",
     "dpnp_greater",
     "dpnp_greater_equal",
+    "dpnp_hypot",
     "dpnp_imag",
     "dpnp_invert",
     "dpnp_isfinite",
@@ -72,12 +70,19 @@
     "dpnp_less",
     "dpnp_less_equal",
     "dpnp_log",
+    "dpnp_log10",
+    "dpnp_log1p",
+    "dpnp_log2",
+    "dpnp_logaddexp",
     "dpnp_logical_and",
     "dpnp_logical_not",
     "dpnp_logical_or",
     "dpnp_logical_xor",
+    "dpnp_maximum",
+    "dpnp_minimum",
     "dpnp_multiply",
     "dpnp_negative",
+    "dpnp_positive",
     "dpnp_not_equal",
     "dpnp_power",
     "dpnp_proj",
@@ -164,6 +169,105 @@ def check_nd_call_func(
     )
 
 
+def _make_unary_func(
+    name, dpt_unary_fn, fn_docstring, mkl_fn_to_call=None, mkl_impl_fn=None
+):
+    impl_fn = dpt_unary_fn.get_implementation_function()
+    type_resolver_fn = dpt_unary_fn.get_type_result_resolver_function()
+
+    def _call_func(src, dst, sycl_queue, depends=None):
+        """A callback to register in UnaryElementwiseFunc class of dpctl.tensor"""
+
+        if depends is None:
+            depends = []
+
+        if mkl_fn_to_call is not None and mkl_fn_to_call(sycl_queue, src, dst):
+            # call pybind11 extension for unary function from OneMKL VM
+            return mkl_impl_fn(sycl_queue, src, dst, depends)
+        return impl_fn(src, dst, sycl_queue, depends)
+
+    func = dpt_unary_fn.__class__(
+        name, type_resolver_fn, _call_func, fn_docstring
+    )
+    return func
+
+
+def _make_binary_func(
+    name, dpt_binary_fn, fn_docstring, mkl_fn_to_call=None, mkl_impl_fn=None
+):
+    impl_fn = dpt_binary_fn.get_implementation_function()
+    type_resolver_fn = dpt_binary_fn.get_type_result_resolver_function()
+    inplce_fn = dpt_binary_fn.get_implementation_inplace_function()
+    acceptance_fn = dpt_binary_fn.get_type_promotion_path_acceptance_function()
+
+    def _call_func(src1, src2, dst, sycl_queue, depends=None):
+        """A callback to register in UnaryElementwiseFunc class of dpctl.tensor"""
+
+        if depends is None:
+            depends = []
+
+        if mkl_fn_to_call is not None and mkl_fn_to_call(
+            sycl_queue, src1, src2, dst
+        ):
+            # call pybind11 extension for binary function from OneMKL VM
+            return mkl_impl_fn(sycl_queue, src1, src2, dst, depends)
+        return impl_fn(src1, src2, dst, sycl_queue, depends)
+
+    func = dpt_binary_fn.__class__(
+        name,
+        type_resolver_fn,
+        _call_func,
+        fn_docstring,
+        inplce_fn,
+        acceptance_fn,
+    )
+    return func
+
+
+_abs_docstring = """
+abs(x, out=None, order='K')
+
+Calculates the absolute value for each element `x_i` of input array `x`.
+
+Args:
+    x (dpnp.ndarray):
+        Input array, expected to have numeric data type.
+    out ({None, dpnp.ndarray}, optional):
+        Output array to populate. Array must have the correct
+        shape and the expected data type.
+    order ("C","F","A","K", optional): memory layout of the new
+        output array, if parameter `out` is `None`.
+        Default: "K".
+Return:
+    dpnp.ndarray:
+        An array containing the element-wise absolute values.
+        For complex input, the absolute value is its magnitude.
+        If `x` has a real-valued data type, the returned array has the
+        same data type as `x`. If `x` has a complex floating-point data type,
+        the returned array has a real-valued floating-point data type whose
+        precision matches the precision of `x`.
+"""
+
+abs_func = _make_unary_func(
+    "abs", dpt.abs, _abs_docstring, vmi._mkl_abs_to_call, vmi._abs
+)
+
+
+def dpnp_abs(x, out=None, order="K"):
+    """
+    Invokes abs() function from pybind11 extension of OneMKL VM if possible.
+
+    Otherwise fully relies on dpctl.tensor implementation for abs() function.
+
+    """
+    # dpctl.tensor only works with usm_ndarray
+    x1_usm = dpnp.get_usm_ndarray(x)
+    out_usm = None if out is None else dpnp.get_usm_ndarray(out)
+
+    res_usm = abs_func(x1_usm, out=out_usm, order=order)
+    return dpnp_array._create_from_usm_ndarray(res_usm)
+
+
 _acos_docstring = """
 acos(x, out=None, order='K')
 
@@ -185,21 +289,8 @@ def check_nd_call_func(
         of the returned array is determined by the Type Promotion Rules.
 """
 
-
-def _call_acos(src, dst, sycl_queue, depends=None):
-    """A callback to register in UnaryElementwiseFunc class of dpctl.tensor"""
-
-    if depends is None:
-        depends = []
-
-    if vmi._mkl_acos_to_call(sycl_queue, src, dst):
-        # call pybind11 extension for acos() function from OneMKL VM
-        return vmi._acos(sycl_queue, src, dst, depends)
-    return ti._acos(src, dst, sycl_queue, depends)
-
-
-acos_func = UnaryElementwiseFunc(
-    "acos", ti._acos_result_type, _call_acos, _acos_docstring
+acos_func = _make_unary_func(
+    "arccos", dpt.acos, _acos_docstring, vmi._mkl_acos_to_call, vmi._acos
 )
 
 
@@ -239,21 +330,8 @@ def dpnp_acos(x, out=None, order="K"):
         the Type Promotion Rules.
 """
 
-
-def _call_acosh(src, dst, sycl_queue, depends=None):
-    """A callback to register in UnaryElementwiseFunc class of dpctl.tensor"""
-
-    if depends is None:
-        depends = []
-
-    if vmi._mkl_acosh_to_call(sycl_queue, src, dst):
-        # call pybind11 extension for acosh() function from OneMKL VM
-        return vmi._acosh(sycl_queue, src, dst, depends)
-    return ti._acosh(src, dst, sycl_queue, depends)
-
-
-acosh_func = UnaryElementwiseFunc(
-    "acosh", ti._acosh_result_type, _call_acosh, _acosh_docstring
+acosh_func = _make_unary_func(
+    "arccosh", dpt.acosh, _acosh_docstring, vmi._mkl_acosh_to_call, vmi._acosh
 )
 
 
@@ -272,7 +350,7 @@ def dpnp_acosh(x, out=None, order="K"):
     return dpnp_array._create_from_usm_ndarray(res_usm)
 
 
-_add_docstring_ = """
+_add_docstring = """
 add(x1, x2, out=None, order="K")
 
 Calculates the sum for each element `x1_i` of the input array `x1` with
@@ -295,21 +373,8 @@ def dpnp_acosh(x, out=None, order="K"):
         of the returned array is determined by the Type Promotion Rules.
 """
 
-
-def _call_add(src1, src2, dst, sycl_queue, depends=None):
-    """A callback to register in BinaryElementwiseFunc class of dpctl.tensor"""
-
-    if depends is None:
-        depends = []
-
-    if vmi._mkl_add_to_call(sycl_queue, src1, src2, dst):
-        # call pybind11 extension for add() function from OneMKL VM
-        return vmi._add(sycl_queue, src1, src2, dst, depends)
-    return ti._add(src1, src2, dst, sycl_queue, depends)
-
-
-add_func = BinaryElementwiseFunc(
-    "add", ti._add_result_type, _call_add, _add_docstring_, ti._add_inplace
+add_func = _make_binary_func(
+    "add", dpt.add, _add_docstring, vmi._mkl_add_to_call, vmi._add
 )
 
 
@@ -352,21 +417,8 @@ def dpnp_add(x1, x2, out=None, order="K"):
         of the returned array is determined by the Type Promotion Rules.
 """
 
-
-def _call_asin(src, dst, sycl_queue, depends=None):
-    """A callback to register in UnaryElementwiseFunc class of dpctl.tensor"""
-
-    if depends is None:
-        depends = []
-
-    if vmi._mkl_asin_to_call(sycl_queue, src, dst):
-        # call pybind11 extension for asin() function from OneMKL VM
-        return vmi._asin(sycl_queue, src, dst, depends)
-    return ti._asin(src, dst, sycl_queue, depends)
-
-
-asin_func = UnaryElementwiseFunc(
-    "asin", ti._asin_result_type, _call_asin, _asin_docstring
+asin_func = _make_unary_func(
+    "arcsin", dpt.asin, _asin_docstring, vmi._mkl_asin_to_call, vmi._asin
 )
 
 
@@ -406,21 +458,8 @@ def dpnp_asin(x, out=None, order="K"):
         the Type Promotion Rules.
 """
 
-
-def _call_asinh(src, dst, sycl_queue, depends=None):
-    """A callback to register in UnaryElementwiseFunc class of dpctl.tensor"""
-
-    if depends is None:
-        depends = []
-
-    if vmi._mkl_asinh_to_call(sycl_queue, src, dst):
-        # call pybind11 extension for asinh() function from OneMKL VM
-        return vmi._asinh(sycl_queue, src, dst, depends)
-    return ti._asinh(src, dst, sycl_queue, depends)
-
-
-asinh_func = UnaryElementwiseFunc(
-    "asinh", ti._asinh_result_type, _call_asinh, _asinh_docstring
+asinh_func = _make_unary_func(
+    "arcsinh", dpt.asinh, _asinh_docstring, vmi._mkl_asinh_to_call, vmi._asinh
 )
 
 
@@ -460,21 +499,8 @@ def dpnp_asinh(x, out=None, order="K"):
         of the returned array is determined by the Type Promotion Rules.
 """
 
-
-def _call_atan(src, dst, sycl_queue, depends=None):
-    """A callback to register in UnaryElementwiseFunc class of dpctl.tensor"""
-
-    if depends is None:
-        depends = []
-
-    if vmi._mkl_atan_to_call(sycl_queue, src, dst):
-        # call pybind11 extension for atan() function from OneMKL VM
-        return vmi._atan(sycl_queue, src, dst, depends)
-    return ti._atan(src, dst, sycl_queue, depends)
-
-
-atan_func = UnaryElementwiseFunc(
-    "atan", ti._atan_result_type, _call_atan, _atan_docstring
+atan_func = _make_unary_func(
+    "arctan", dpt.atan, _atan_docstring, vmi._mkl_atan_to_call, vmi._atan
 )
 
 
@@ -493,7 +519,7 @@ def dpnp_atan(x, out=None, order="K"):
     return dpnp_array._create_from_usm_ndarray(res_usm)
 
 
-_atan2_docstring_ = """
+_atan2_docstring = """
 atan2(x1, x2, out=None, order="K")
 
 Calculates the inverse tangent of the quotient `x1_i/x2_i` for each element
@@ -520,24 +546,8 @@ def dpnp_atan(x, out=None, order="K"):
         determined by Type Promotion Rules.
 """
 
-
-def _call_atan2(src1, src2, dst, sycl_queue, depends=None):
-    """A callback to register in BinaryElementwiseFunc class of dpctl.tensor"""
-
-    if depends is None:
-        depends = []
-
-    if vmi._mkl_atan2_to_call(sycl_queue, src1, src2, dst):
-        # call pybind11 extension for atan2() function from OneMKL VM
-        return vmi._atan2(sycl_queue, src1, src2, dst, depends)
-    return ti._atan2(src1, src2, dst, sycl_queue, depends)
-
-
-atan2_func = BinaryElementwiseFunc(
-    "atan2",
-    ti._atan2_result_type,
-    _call_atan2,
-    _atan2_docstring_,
+atan2_func = _make_binary_func(
+    "arctan2", dpt.atan2, _atan2_docstring, vmi._mkl_atan2_to_call, vmi._atan2
 )
 
 
@@ -580,21 +590,8 @@ def dpnp_atan2(x1, x2, out=None, order="K"):
         the Type Promotion Rules.
 """
 
-
-def _call_atanh(src, dst, sycl_queue, depends=None):
-    """A callback to register in UnaryElementwiseFunc class of dpctl.tensor"""
-
-    if depends is None:
-        depends = []
-
-    if vmi._mkl_atanh_to_call(sycl_queue, src, dst):
-        # call pybind11 extension for atanh() function from OneMKL VM
-        return vmi._atanh(sycl_queue, src, dst, depends)
-    return ti._atanh(src, dst, sycl_queue, depends)
-
-
-atanh_func = UnaryElementwiseFunc(
-    "atanh", ti._atanh_result_type, _call_atanh, _atanh_docstring
+atanh_func = _make_unary_func(
+    "arctanh", dpt.atanh, _atanh_docstring, vmi._mkl_atanh_to_call, vmi._atanh
 )
 
 
@@ -613,7 +610,7 @@ def dpnp_atanh(x, out=None, order="K"):
     return dpnp_array._create_from_usm_ndarray(res_usm)
 
 
-_bitwise_and_docstring_ = """
+_bitwise_and_docstring = """
 bitwise_and(x1, x2, out=None, order='K')
 
 Computes the bitwise AND of the underlying binary representation of each
@@ -638,12 +635,8 @@ def dpnp_atanh(x, out=None, order="K"):
         of the returned array is determined by the Type Promotion Rules.
 """
 
-
-bitwise_and_func = BinaryElementwiseFunc(
-    "bitwise_and",
-    ti._bitwise_and_result_type,
-    ti._bitwise_and,
-    _bitwise_and_docstring_,
+bitwise_and_func = _make_binary_func(
+    "bitwise_and", dpt.bitwise_and, _bitwise_and_docstring
 )
 
 
@@ -661,7 +654,7 @@ def dpnp_bitwise_and(x1, x2, out=None, order="K"):
     return dpnp_array._create_from_usm_ndarray(res_usm)
 
 
-_bitwise_or_docstring_ = """
+_bitwise_or_docstring = """
 bitwise_or(x1, x2, out=None, order='K')
 
 Computes the bitwise OR of the underlying binary representation of each
@@ -686,12 +679,8 @@ def dpnp_bitwise_and(x1, x2, out=None, order="K"):
         of the returned array is determined by the Type Promotion Rules.
 """
 
-
-bitwise_or_func = BinaryElementwiseFunc(
-    "bitwise_or",
-    ti._bitwise_or_result_type,
-    ti._bitwise_or,
-    _bitwise_or_docstring_,
+bitwise_or_func = _make_binary_func(
+    "bitwise_or", dpt.bitwise_or, _bitwise_or_docstring
 )
 
 
@@ -709,7 +698,7 @@ def dpnp_bitwise_or(x1, x2, out=None, order="K"):
     return dpnp_array._create_from_usm_ndarray(res_usm)
 
 
-_bitwise_xor_docstring_ = """
+_bitwise_xor_docstring = """
 bitwise_xor(x1, x2, out=None, order='K')
 
 Computes the bitwise XOR of the underlying binary representation of each
@@ -734,12 +723,8 @@ def dpnp_bitwise_or(x1, x2, out=None, order="K"):
         of the returned array is determined by the Type Promotion Rules.
 """
 
-
-bitwise_xor_func = BinaryElementwiseFunc(
-    "bitwise_xor",
-    ti._bitwise_xor_result_type,
-    ti._bitwise_xor,
-    _bitwise_xor_docstring_,
+bitwise_xor_func = _make_binary_func(
+    "bitwise_xor", dpt.bitwise_xor, _bitwise_xor_docstring
 )
 
 
@@ -778,21 +763,8 @@ def dpnp_bitwise_xor(x1, x2, out=None, order="K"):
         The returned array has the same data type as `x`.
 """
 
-
-def _call_ceil(src, dst, sycl_queue, depends=None):
-    """A callback to register in UnaryElementwiseFunc class of dpctl.tensor"""
-
-    if depends is None:
-        depends = []
-
-    if vmi._mkl_ceil_to_call(sycl_queue, src, dst):
-        # call pybind11 extension for ceil() function from OneMKL VM
-        return vmi._ceil(sycl_queue, src, dst, depends)
-    return ti._ceil(src, dst, sycl_queue, depends)
-
-
-ceil_func = UnaryElementwiseFunc(
-    "ceil", ti._ceil_result_type, _call_ceil, _ceil_docstring
+ceil_func = _make_unary_func(
+    "ceil", dpt.ceil, _ceil_docstring, vmi._mkl_ceil_to_call, vmi._ceil
 )
 
 
@@ -830,21 +802,8 @@ def dpnp_ceil(x, out=None, order="K"):
         of the returned array is determined by the Type Promotion Rules.
 """
 
-
-def _call_cos(src, dst, sycl_queue, depends=None):
-    """A callback to register in UnaryElementwiseFunc class of dpctl.tensor"""
-
-    if depends is None:
-        depends = []
-
-    if vmi._mkl_cos_to_call(sycl_queue, src, dst):
-        # call pybind11 extension for cos() function from OneMKL VM
-        return vmi._cos(sycl_queue, src, dst, depends)
-    return ti._cos(src, dst, sycl_queue, depends)
-
-
-cos_func = UnaryElementwiseFunc(
-    "cos", ti._cos_result_type, _call_cos, _cos_docstring
+cos_func = _make_unary_func(
+    "cos", dpt.cos, _cos_docstring, vmi._mkl_cos_to_call, vmi._cos
 )
 
 
@@ -883,21 +842,8 @@ def dpnp_cos(x, out=None, order="K"):
         of the returned array is determined by the Type Promotion Rules.
 """
 
-
-def _call_cosh(src, dst, sycl_queue, depends=None):
-    """A callback to register in UnaryElementwiseFunc class of dpctl.tensor"""
-
-    if depends is None:
-        depends = []
-
-    if vmi._mkl_cosh_to_call(sycl_queue, src, dst):
-        # call pybind11 extension for cosh() function from OneMKL VM
-        return vmi._cosh(sycl_queue, src, dst, depends)
-    return ti._cosh(src, dst, sycl_queue, depends)
-
-
-cosh_func = UnaryElementwiseFunc(
-    "cosh", ti._cosh_result_type, _call_cosh, _cosh_docstring
+cosh_func = _make_unary_func(
+    "cosh", dpt.cosh, _cosh_docstring, vmi._mkl_cosh_to_call, vmi._cosh
 )
 
 
@@ -936,21 +882,8 @@ def dpnp_cosh(x, out=None, order="K"):
         The returned array has the same data type as `x`.
 """
 
-
-def _call_conj(src, dst, sycl_queue, depends=None):
-    """A callback to register in UnaryElementwiseFunc class of dpctl.tensor"""
-
-    if depends is None:
-        depends = []
-
-    if vmi._mkl_conj_to_call(sycl_queue, src, dst):
-        # call pybind11 extension for conj() function from OneMKL VM
-        return vmi._conj(sycl_queue, src, dst, depends)
-    return ti._conj(src, dst, sycl_queue, depends)
-
-
-conj_func = UnaryElementwiseFunc(
-    "conj", ti._conj_result_type, _call_conj, _conj_docstring
+conj_func = _make_unary_func(
+    "conj", dpt.conj, _conj_docstring, vmi._mkl_conj_to_call, vmi._conj
 )
 
 
@@ -968,7 +901,7 @@ def dpnp_conj(x, out=None, order="K"):
     return dpnp_array._create_from_usm_ndarray(res_usm)
 
 
-_divide_docstring_ = """
+_divide_docstring = """
 divide(x1, x2, out=None, order="K")
 
 Calculates the ratio for each element `x1_i` of the input array `x1` with
@@ -991,24 +924,8 @@ def dpnp_conj(x, out=None, order="K"):
         of the returned array is determined by the Type Promotion Rules.
 """
 
-
-def _call_divide(src1, src2, dst, sycl_queue, depends=None):
-    """A callback to register in BinaryElementwiseFunc class of dpctl.tensor"""
-
-    if depends is None:
-        depends = []
-
-    if vmi._mkl_div_to_call(sycl_queue, src1, src2, dst):
-        # call pybind11 extension for div() function from OneMKL VM
-        return vmi._div(sycl_queue, src1, src2, dst, depends)
-    return ti._divide(src1, src2, dst, sycl_queue, depends)
-
-
-divide_func = BinaryElementwiseFunc(
-    "divide",
-    ti._divide_result_type,
-    _call_divide,
-    _divide_docstring_,
+divide_func = _make_binary_func(
+    "divide", dpt.divide, _divide_docstring, vmi._mkl_div_to_call, vmi._div
 )
 
 
@@ -1030,9 +947,9 @@ def dpnp_divide(x1, x2, out=None, order="K"):
     return dpnp_array._create_from_usm_ndarray(res_usm)
 
 
-_equal_docstring_ = """
-
+_equal_docstring = """
 equal(x1, x2, out=None, order="K")
+
 Calculates equality results for each element `x1_i` of
 the input array `x1` the respective element `x2_i` of the input array `x2`.
 
@@ -1053,10 +970,7 @@ def dpnp_divide(x1, x2, out=None, order="K"):
         The data type of the returned array is determined by the Type Promotion Rules.
 """
 
-
-equal_func = BinaryElementwiseFunc(
-    "equal", ti._equal_result_type, ti._equal, _equal_docstring_
-)
+equal_func = _make_binary_func("equal", dpt.equal, _equal_docstring)
 
 
 def dpnp_equal(x1, x2, out=None, order="K"):
@@ -1073,6 +987,90 @@ def dpnp_equal(x1, x2, out=None, order="K"):
     return dpnp_array._create_from_usm_ndarray(res_usm)
 
 
+_exp_docstring = """
+exp(x, out=None, order='K')
+
+Computes the exponential for each element `x_i` of input array `x`.
+
+Args:
+    x (dpnp.ndarray):
+        Input array, expected to have numeric data type.
+    out ({None, dpnp.ndarray}, optional):
+        Output array to populate. Array must have the correct
+        shape and the expected data type.
+    order ("C","F","A","K", optional): memory layout of the new
+        output array, if parameter `out` is `None`.
+        Default: "K".
+Return:
+    dpnp.ndarray:
+        An array containing the element-wise exponential of `x`.
+        The data type of the returned array is determined by
+        the Type Promotion Rules.
+"""
+
+exp_func = _make_unary_func(
+    "exp", dpt.exp, _exp_docstring, vmi._mkl_exp_to_call, vmi._exp
+)
+
+
+def dpnp_exp(x, out=None, order="K"):
+    """
+    Invokes exp() function from pybind11 extension of OneMKL VM if possible.
+
+    Otherwise fully relies on dpctl.tensor implementation for exp() function.
+    """
+
+    # dpctl.tensor only works with usm_ndarray
+    x1_usm = dpnp.get_usm_ndarray(x)
+    out_usm = None if out is None else dpnp.get_usm_ndarray(out)
+
+    res_usm = exp_func(x1_usm, out=out_usm, order=order)
+    return dpnp_array._create_from_usm_ndarray(res_usm)
+
+
+_expm1_docstring = """
+expm1(x, out=None, order='K')
+
+Computes the exponential minus 1 for each element `x_i` of input array `x`.
+
+This function calculates `exp(x) - 1.0` more accurately for small values of `x`.
+
+Args:
+    x (dpnp.ndarray):
+        Input array, expected to have numeric data type.
+    out ({None, dpnp.ndarray}, optional):
+        Output array to populate. Array must have the correct
+        shape and the expected data type.
+    order ("C","F","A","K", optional): memory layout of the new
+        output array, if parameter `out` is `None`.
+        Default: "K".
+Return:
+    dpnp.ndarray:
+        An array containing the element-wise `exp(x) - 1` results.
+        The data type of the returned array is determined by the Type
+        Promotion Rules.
+"""
+
+expm1_func = _make_unary_func(
+    "expm1", dpt.expm1, _expm1_docstring, vmi._mkl_expm1_to_call, vmi._expm1
+)
+
+
+def dpnp_expm1(x, out=None, order="K"):
+    """
+    Invokes expm1() function from pybind11 extension of OneMKL VM if possible.
+
+    Otherwise fully relies on dpctl.tensor implementation for expm1() function.
+    """
+
+    # dpctl.tensor only works with usm_ndarray
+    x1_usm = dpnp.get_usm_ndarray(x)
+    out_usm = None if out is None else dpnp.get_usm_ndarray(out)
+
+    res_usm = expm1_func(x1_usm, out=out_usm, order=order)
+    return dpnp_array._create_from_usm_ndarray(res_usm)
+
+
 _floor_docstring = """
 floor(x, out=None, order='K')
 
@@ -1094,21 +1092,8 @@ def dpnp_equal(x1, x2, out=None, order="K"):
         The returned array has the same data type as `x`.
 """
 
-
-def _call_floor(src, dst, sycl_queue, depends=None):
-    """A callback to register in UnaryElementwiseFunc class of dpctl.tensor"""
-
-    if depends is None:
-        depends = []
-
-    if vmi._mkl_floor_to_call(sycl_queue, src, dst):
-        # call pybind11 extension for floor() function from OneMKL VM
-        return vmi._floor(sycl_queue, src, dst, depends)
-    return ti._floor(src, dst, sycl_queue, depends)
-
-
-floor_func = UnaryElementwiseFunc(
-    "floor", ti._floor_result_type, _call_floor, _floor_docstring
+floor_func = _make_unary_func(
+    "floor", dpt.floor, _floor_docstring, vmi._mkl_floor_to_call, vmi._floor
 )
 
 
@@ -1126,11 +1111,13 @@ def dpnp_floor(x, out=None, order="K"):
     return dpnp_array._create_from_usm_ndarray(res_usm)
 
 
-_floor_divide_docstring_ = """
+_floor_divide_docstring = """
 floor_divide(x1, x2, out=None, order="K")
+
 Calculates the ratio for each element `x1_i` of the input array `x1` with
 the respective element `x2_i` of the input array `x2` to the greatest
 integer-value number that is not greater than the division result.
+
 Args:
     x1 (dpnp.ndarray):
         First input array, expected to have numeric data type.
@@ -1149,12 +1136,8 @@ def dpnp_floor(x, out=None, order="K"):
         Promotion Rules
 """
 
-
-floor_divide_func = BinaryElementwiseFunc(
-    "floor_divide",
-    ti._floor_divide_result_type,
-    ti._floor_divide,
-    _floor_divide_docstring_,
+floor_divide_func = _make_binary_func(
+    "floor_divide", dpt.floor_divide, _floor_divide_docstring
 )
 
 
@@ -1172,7 +1155,7 @@ def dpnp_floor_divide(x1, x2, out=None, order="K"):
     return dpnp_array._create_from_usm_ndarray(res_usm)
 
 
-_greater_docstring_ = """
+_greater_docstring = """
 greater(x1, x2, out=None, order="K")
 
 Calculates the greater-than results for each element `x1_i` of
@@ -1195,10 +1178,7 @@ def dpnp_floor_divide(x1, x2, out=None, order="K"):
         The data type of the returned array is determined by the Type Promotion Rules.
 """
 
-
-greater_func = BinaryElementwiseFunc(
-    "greater", ti._greater_result_type, ti._greater, _greater_docstring_
-)
+greater_func = _make_binary_func("greater", dpt.greater, _greater_docstring)
 
 
 def dpnp_greater(x1, x2, out=None, order="K"):
@@ -1215,7 +1195,7 @@ def dpnp_greater(x1, x2, out=None, order="K"):
     return dpnp_array._create_from_usm_ndarray(res_usm)
 
 
-_greater_equal_docstring_ = """
+_greater_equal_docstring = """
 greater_equal(x1, x2, out=None, order="K")
 
 Calculates the greater-than or equal-to results for each element `x1_i` of
@@ -1238,12 +1218,8 @@ def dpnp_greater(x1, x2, out=None, order="K"):
         The data type of the returned array is determined by the Type Promotion Rules.
 """
 
-
-greater_equal_func = BinaryElementwiseFunc(
-    "greater_equal",
-    ti._greater_equal_result_type,
-    ti._greater_equal,
-    _greater_equal_docstring_,
+greater_equal_func = _make_binary_func(
+    "greater_equal", dpt.greater_equal, _greater_equal_docstring
 )
 
 
@@ -1261,6 +1237,52 @@ def dpnp_greater_equal(x1, x2, out=None, order="K"):
     return dpnp_array._create_from_usm_ndarray(res_usm)
 
 
+_hypot_docstring = """
+hypot(x1, x2, out=None, order="K")
+
+Calculates the hypotenuse for a right triangle with "legs" `x1_i` and `x2_i` of
+input arrays `x1` and `x2`.
+
+Args:
+    x1 (dpnp.ndarray):
+        First input array, expected to have a real-valued data type.
+    x2 (dpnp.ndarray):
+        Second input array, also expected to have a real-valued data type.
+    out ({None, dpnp.ndarray}, optional):
+        Output array to populate.
+        Array have the correct shape and the expected data type.
+    order ("C","F","A","K", None, optional):
+        Memory layout of the newly output array, if parameter `out` is `None`.
+        Default: "K".
+Returns:
+    dpnp.ndarray:
+        An array containing the element-wise hypotenuse. The data type
+        of the returned array is determined by the Type Promotion Rules.
+"""
+
+hypot_func = _make_binary_func(
+    "hypot", dpt.hypot, _hypot_docstring, vmi._mkl_hypot_to_call, vmi._hypot
+)
+
+
+def dpnp_hypot(x1, x2, out=None, order="K"):
+    """
+    Invokes hypot() function from pybind11 extension of OneMKL VM if possible.
+
+    Otherwise fully relies on dpctl.tensor implementation for hypot() function.
+    """
+
+    # dpctl.tensor only works with usm_ndarray or scalar
+    x1_usm_or_scalar = dpnp.get_usm_ndarray_or_scalar(x1)
+    x2_usm_or_scalar = dpnp.get_usm_ndarray_or_scalar(x2)
+    out_usm = None if out is None else dpnp.get_usm_ndarray(out)
+
+    res_usm = hypot_func(
+        x1_usm_or_scalar, x2_usm_or_scalar, out=out_usm, order=order
+    )
+    return dpnp_array._create_from_usm_ndarray(res_usm)
+
+
 _imag_docstring = """
 imag(x, out=None, order="K")
 
@@ -1284,10 +1306,7 @@ def dpnp_greater_equal(x1, x2, out=None, order="K"):
         with the same floating-point precision as complex input.
 """
 
-
-imag_func = UnaryElementwiseFunc(
-    "imag", ti._imag_result_type, ti._imag, _imag_docstring
-)
+imag_func = _make_unary_func("imag", dpt.imag, _imag_docstring)
 
 
 def dpnp_imag(x, out=None, order="K"):
@@ -1322,13 +1341,7 @@ def dpnp_imag(x, out=None, order="K"):
         input array.
 """
 
-
-invert_func = UnaryElementwiseFunc(
-    "invert",
-    ti._bitwise_invert_result_type,
-    ti._bitwise_invert,
-    _invert_docstring,
-)
+invert_func = _make_unary_func("invert", dpt.bitwise_invert, _invert_docstring)
 
 
 def dpnp_invert(x, out=None, order="K"):
@@ -1363,10 +1376,7 @@ def dpnp_invert(x, out=None, order="K"):
         The data type of the returned array is `bool`.
 """
 
-
-isfinite_func = UnaryElementwiseFunc(
-    "isfinite", ti._isfinite_result_type, ti._isfinite, _isfinite_docstring
-)
+isfinite_func = _make_unary_func("isfinite", dpt.isfinite, _isfinite_docstring)
 
 
 def dpnp_isfinite(x, out=None, order="K"):
@@ -1400,10 +1410,7 @@ def dpnp_isfinite(x, out=None, order="K"):
         False otherwise. The data type of the returned array is `bool`.
 """
 
-
-isinf_func = UnaryElementwiseFunc(
-    "isinf", ti._isinf_result_type, ti._isinf, _isinf_docstring
-)
+isinf_func = _make_unary_func("isinf", dpt.isinf, _isinf_docstring)
 
 
 def dpnp_isinf(x, out=None, order="K"):
@@ -1437,10 +1444,7 @@ def dpnp_isinf(x, out=None, order="K"):
         The data type of the returned array is `bool`.
 """
 
-
-isnan_func = UnaryElementwiseFunc(
-    "isnan", ti._isnan_result_type, ti._isnan, _isnan_docstring
-)
+isnan_func = _make_unary_func("isnan", dpt.isnan, _isnan_docstring)
 
 
 def dpnp_isnan(x, out=None, order="K"):
@@ -1454,7 +1458,7 @@ def dpnp_isnan(x, out=None, order="K"):
     return dpnp_array._create_from_usm_ndarray(res_usm)
 
 
-_left_shift_docstring_ = """
+_left_shift_docstring = """
 left_shift(x1, x2, out=None, order='K')
 
 Shifts the bits of each element `x1_i` of the input array x1 to the left by
@@ -1479,12 +1483,8 @@ def dpnp_isnan(x, out=None, order="K"):
         of the returned array is determined by the Type Promotion Rules.
 """
 
-
-left_shift_func = BinaryElementwiseFunc(
-    "bitwise_left_shift",
-    ti._bitwise_left_shift_result_type,
-    ti._bitwise_left_shift,
-    _left_shift_docstring_,
+left_shift_func = _make_binary_func(
+    "left_shift", dpt.bitwise_left_shift, _left_shift_docstring
 )
 
 
@@ -1502,7 +1502,7 @@ def dpnp_left_shift(x1, x2, out=None, order="K"):
     return dpnp_array._create_from_usm_ndarray(res_usm)
 
 
-_less_docstring_ = """
+_less_docstring = """
 less(x1, x2, out=None, order="K")
 
 Calculates the less-than results for each element `x1_i` of
@@ -1525,10 +1525,7 @@ def dpnp_left_shift(x1, x2, out=None, order="K"):
         The data type of the returned array is determined by the Type Promotion Rules.
 """
 
-
-less_func = BinaryElementwiseFunc(
-    "less", ti._less_result_type, ti._less, _less_docstring_
-)
+less_func = _make_binary_func("less", dpt.less, _less_docstring)
 
 
 def dpnp_less(x1, x2, out=None, order="K"):
@@ -1545,7 +1542,7 @@ def dpnp_less(x1, x2, out=None, order="K"):
     return dpnp_array._create_from_usm_ndarray(res_usm)
 
 
-_less_equal_docstring_ = """
+_less_equal_docstring = """
 less_equal(x1, x2, out=None, order="K")
 
 Calculates the less-than or equal-to results for each element `x1_i` of
@@ -1568,12 +1565,8 @@ def dpnp_less(x1, x2, out=None, order="K"):
         The data type of the returned array is determined by the Type Promotion Rules.
 """
 
-
-less_equal_func = BinaryElementwiseFunc(
-    "less_equal",
-    ti._less_equal_result_type,
-    ti._less_equal,
-    _less_equal_docstring_,
+less_equal_func = _make_binary_func(
+    "less_equal", dpt.less_equal, _less_equal_docstring
 )
 
 
@@ -1593,7 +1586,9 @@ def dpnp_less_equal(x1, x2, out=None, order="K"):
 
 _log_docstring = """
 log(x, out=None, order='K')
+
 Computes the natural logarithm element-wise.
+
 Args:
     x (dpnp.ndarray):
         Input array, expected to have numeric data type.
@@ -1606,23 +1601,12 @@ def dpnp_less_equal(x1, x2, out=None, order="K"):
 Return:
     dpnp.ndarray:
         An array containing the element-wise natural logarithm values.
+        The data type of the returned array is determined by the Type
+        Promotion Rules.
 """
 
-
-def _call_log(src, dst, sycl_queue, depends=None):
-    """A callback to register in UnaryElementwiseFunc class of dpctl.tensor"""
-
-    if depends is None:
-        depends = []
-
-    if vmi._mkl_ln_to_call(sycl_queue, src, dst):
-        # call pybind11 extension for ln() function from OneMKL VM
-        return vmi._ln(sycl_queue, src, dst, depends)
-    return ti._log(src, dst, sycl_queue, depends)
-
-
-log_func = UnaryElementwiseFunc(
-    "log", ti._log_result_type, _call_log, _log_docstring
+log_func = _make_unary_func(
+    "log", dpt.log, _log_docstring, vmi._mkl_ln_to_call, vmi._ln
 )
 
 
@@ -1641,20 +1625,190 @@ def dpnp_log(x, out=None, order="K"):
     return dpnp_array._create_from_usm_ndarray(res_usm)
 
 
-_logical_and_docstring_ = """
-logical_and(x1, x2, out=None, order='K')
+_log10_docstring = """
+log10(x, out=None, order='K')
 
-Computes the logical AND for each element `x1_i` of the input array `x1`
-with the respective element `x2_i` of the input array `x2`.
+Computes the base-10 logarithm for each element `x_i` of input array `x`.
 
 Args:
-    x1 (dpnp.ndarray):
-        First input array.
-    x2 (dpnp.ndarray):
-        Second input array.
+    x (dpnp.ndarray):
+        Input array, expected to have numeric data type.
     out ({None, dpnp.ndarray}, optional):
-        Output array to populate.
-        Array have the correct shape and the expected data type.
+        Output array to populate. Array must have the correct
+        shape and the expected data type.
+    order ("C","F","A","K", optional): memory layout of the new
+        output array, if parameter `out` is `None`.
+        Default: "K".
+Return:
+    dpnp.ndarray:
+        An array containing the base-10 logarithm of `x`.
+        The data type of the returned array is determined by the
+        Type Promotion Rules.
+"""
+
+log10_func = _make_unary_func(
+    "log10", dpt.log10, _log10_docstring, vmi._mkl_log10_to_call, vmi._log10
+)
+
+
+def dpnp_log10(x, out=None, order="K"):
+    """
+    Invokes log10() function from pybind11 extension of OneMKL VM if possible.
+
+    Otherwise fully relies on dpctl.tensor implementation for log10() function.
+    """
+
+    # dpctl.tensor only works with usm_ndarray
+    x1_usm = dpnp.get_usm_ndarray(x)
+    out_usm = None if out is None else dpnp.get_usm_ndarray(out)
+
+    res_usm = log10_func(x1_usm, out=out_usm, order=order)
+    return dpnp_array._create_from_usm_ndarray(res_usm)
+
+
+_log1p_docstring = """
+log1p(x, out=None, order='K')
+
+Computes an approximation of `log(1+x)` element-wise.
+
+Args:
+    x (dpnp.ndarray):
+        Input array, expected to have numeric data type.
+    out ({None, dpnp.ndarray}, optional):
+        Output array to populate. Array must have the correct
+        shape and the expected data type.
+    order ("C","F","A","K", optional): memory layout of the new
+        output array, if parameter `out` is `None`.
+        Default: "K".
+Return:
+    dpnp.ndarray:
+        An array containing the element-wise `log(1+x)` values. The data type
+        of the returned array is determined by the Type Promotion Rules.
+"""
+
+log1p_func = _make_unary_func(
+    "log1p", dpt.log1p, _log1p_docstring, vmi._mkl_log1p_to_call, vmi._log1p
+)
+
+
+def dpnp_log1p(x, out=None, order="K"):
+    """
+    Invokes log1p() function from pybind11 extension of OneMKL VM if possible.
+
+    Otherwise fully relies on dpctl.tensor implementation for log1p() function.
+    """
+
+    # dpctl.tensor only works with usm_ndarray
+    x1_usm = dpnp.get_usm_ndarray(x)
+    out_usm = None if out is None else dpnp.get_usm_ndarray(out)
+
+    res_usm = log1p_func(x1_usm, out=out_usm, order=order)
+    return dpnp_array._create_from_usm_ndarray(res_usm)
+
+
+_log2_docstring = """
+log2(x, out=None, order='K')
+
+Computes the base-2 logarithm for each element `x_i` of input array `x`.
+
+Args:
+    x (dpnp.ndarray):
+        Input array, expected to have numeric data type.
+    out ({None, dpnp.ndarray}, optional):
+        Output array to populate. Array must have the correct
+        shape and the expected data type.
+    order ("C","F","A","K", optional): memory layout of the new
+        output array, if parameter `out` is `None`.
+        Default: "K".
+Return:
+    dpnp.ndarray:
+        An array containing the base-2 logarithm of `x`.
+        The data type of the returned array is determined by the
+        Type Promotion Rules.
+"""
+
+log2_func = _make_unary_func(
+    "log2", dpt.log2, _log2_docstring, vmi._mkl_log2_to_call, vmi._log2
+)
+
+
+def dpnp_log2(x, out=None, order="K"):
+    """
+    Invokes log2() function from pybind11 extension of OneMKL VM if possible.
+
+    Otherwise fully relies on dpctl.tensor implementation for log2() function.
+    """
+
+    # dpctl.tensor only works with usm_ndarray
+    x1_usm = dpnp.get_usm_ndarray(x)
+    out_usm = None if out is None else dpnp.get_usm_ndarray(out)
+
+    res_usm = log2_func(x1_usm, out=out_usm, order=order)
+    return dpnp_array._create_from_usm_ndarray(res_usm)
+
+
+_logaddexp_docstring = """
+logaddexp(x1, x2, out=None, order="K")
+
+Calculates the natural logarithm of the sum of exponentiations for each element
+`x1_i` of the input array `x1` with the respective element `x2_i` of the input
+array `x2`.
+
+This function calculates `log(exp(x1) + exp(x2))` more accurately for small
+values of `x`.
+
+Args:
+    x1 (dpnp.ndarray):
+        First input array, expected to have a real-valued floating-point
+        data type.
+    x2 (dpnp.ndarray):
+        Second input array, also expected to have a real-valued
+        floating-point data type.
+    out ({None, dpnp.ndarray}, optional):
+        Output array to populate.
+        Array have the correct shape and the expected data type.
+    order ("C","F","A","K", None, optional):
+        Memory layout of the newly output array, if parameter `out` is `None`.
+        Default: "K".
+Returns:
+    dpnp.ndarray:
+        An array containing the result of element-wise result. The data type
+        of the returned array is determined by the Type Promotion Rules.
+"""
+
+logaddexp_func = _make_binary_func(
+    "logaddexp", dpt.logaddexp, _logaddexp_docstring
+)
+
+
+def dpnp_logaddexp(x1, x2, out=None, order="K"):
+    """Invokes logaddexp() from dpctl.tensor implementation for logaddexp() function."""
+
+    # dpctl.tensor only works with usm_ndarray or scalar
+    x1_usm_or_scalar = dpnp.get_usm_ndarray_or_scalar(x1)
+    x2_usm_or_scalar = dpnp.get_usm_ndarray_or_scalar(x2)
+    out_usm = None if out is None else dpnp.get_usm_ndarray(out)
+
+    res_usm = logaddexp_func(
+        x1_usm_or_scalar, x2_usm_or_scalar, out=out_usm, order=order
+    )
+    return dpnp_array._create_from_usm_ndarray(res_usm)
+
+
+_logical_and_docstring = """
+logical_and(x1, x2, out=None, order='K')
+
+Computes the logical AND for each element `x1_i` of the input array `x1`
+with the respective element `x2_i` of the input array `x2`.
+
+Args:
+    x1 (dpnp.ndarray):
+        First input array.
+    x2 (dpnp.ndarray):
+        Second input array.
+    out ({None, dpnp.ndarray}, optional):
+        Output array to populate.
+        Array have the correct shape and the expected data type.
     order ("C","F","A","K", optional):
         Memory layout of the newly output array, if parameter `out` is `None`.
         Default: "K".
@@ -1663,12 +1817,8 @@ def dpnp_log(x, out=None, order="K"):
         An array containing the element-wise logical AND results.
 """
 
-
-logical_and_func = BinaryElementwiseFunc(
-    "logical_and",
-    ti._logical_and_result_type,
-    ti._logical_and,
-    _logical_and_docstring_,
+logical_and_func = _make_binary_func(
+    "logical_and", dpt.logical_and, _logical_and_docstring
 )
 
 
@@ -1686,9 +1836,11 @@ def dpnp_logical_and(x1, x2, out=None, order="K"):
     return dpnp_array._create_from_usm_ndarray(res_usm)
 
 
-_logical_not_docstring_ = """
+_logical_not_docstring = """
 logical_not(x, out=None, order='K')
+
 Computes the logical NOT for each element `x_i` of input array `x`.
+
 Args:
     x (dpnp.ndarray):
         Input array.
@@ -1703,12 +1855,8 @@ def dpnp_logical_and(x1, x2, out=None, order="K"):
         An array containing the element-wise logical NOT results.
 """
 
-
-logical_not_func = UnaryElementwiseFunc(
-    "logical_not",
-    ti._logical_not_result_type,
-    ti._logical_not,
-    _logical_not_docstring_,
+logical_not_func = _make_unary_func(
+    "logical_not", dpt.logical_not, _logical_not_docstring
 )
 
 
@@ -1723,7 +1871,7 @@ def dpnp_logical_not(x, out=None, order="K"):
     return dpnp_array._create_from_usm_ndarray(res_usm)
 
 
-_logical_or_docstring_ = """
+_logical_or_docstring = """
 logical_or(x1, x2, out=None, order='K')
 
 Computes the logical OR for each element `x1_i` of the input array `x1`
@@ -1745,12 +1893,8 @@ def dpnp_logical_not(x, out=None, order="K"):
         An array containing the element-wise logical OR results.
 """
 
-
-logical_or_func = BinaryElementwiseFunc(
-    "logical_or",
-    ti._logical_or_result_type,
-    ti._logical_or,
-    _logical_or_docstring_,
+logical_or_func = _make_binary_func(
+    "logical_or", dpt.logical_or, _logical_or_docstring
 )
 
 
@@ -1768,7 +1912,7 @@ def dpnp_logical_or(x1, x2, out=None, order="K"):
     return dpnp_array._create_from_usm_ndarray(res_usm)
 
 
-_logical_xor_docstring_ = """
+_logical_xor_docstring = """
 logical_xor(x1, x2, out=None, order='K')
 
 Computes the logical XOR for each element `x1_i` of the input array `x1`
@@ -1790,11 +1934,8 @@ def dpnp_logical_or(x1, x2, out=None, order="K"):
         An array containing the element-wise logical XOR results.
 """
 
-logical_xor_func = BinaryElementwiseFunc(
-    "logical_xor",
-    ti._logical_xor_result_type,
-    ti._logical_xor,
-    _logical_xor_docstring_,
+logical_xor_func = _make_binary_func(
+    "logical_xor", dpt.logical_xor, _logical_xor_docstring
 )
 
 
@@ -1812,7 +1953,87 @@ def dpnp_logical_xor(x1, x2, out=None, order="K"):
     return dpnp_array._create_from_usm_ndarray(res_usm)
 
 
-_multiply_docstring_ = """
+_maximum_docstring = """
+maximum(x1, x2, out=None, order='K')
+
+Compares two input arrays `x1` and `x2` and returns
+a new array containing the element-wise maxima.
+
+Args:
+    x1 (dpnp.ndarray):
+        First input array, expected to have numeric data type.
+    x2 (dpnp.ndarray):
+        Second input array, also expected to have numeric data type.
+    out ({None, dpnp.ndarray}, optional):
+        Output array to populate.
+        Array have the correct shape and the expected data type.
+    order ("C","F","A","K", optional):
+        Memory layout of the newly output array, if parameter `out` is `None`.
+        Default: "K".
+Returns:
+    dpnp.ndarray:
+        An array containing the element-wise maxima. The data type of
+        the returned array is determined by the Type Promotion Rules.
+"""
+
+maximum_func = _make_binary_func("maximum", dpt.maximum, _maximum_docstring)
+
+
+def dpnp_maximum(x1, x2, out=None, order="K"):
+    """Invokes maximum() from dpctl.tensor implementation for maximum() function."""
+
+    # dpctl.tensor only works with usm_ndarray or scalar
+    x1_usm_or_scalar = dpnp.get_usm_ndarray_or_scalar(x1)
+    x2_usm_or_scalar = dpnp.get_usm_ndarray_or_scalar(x2)
+    out_usm = None if out is None else dpnp.get_usm_ndarray(out)
+
+    res_usm = maximum_func(
+        x1_usm_or_scalar, x2_usm_or_scalar, out=out_usm, order=order
+    )
+    return dpnp_array._create_from_usm_ndarray(res_usm)
+
+
+_minimum_docstring = """
+minimum(x1, x2, out=None, order='K')
+
+Compares two input arrays `x1` and `x2` and returns
+a new array containing the element-wise minima.
+
+Args:
+    x1 (dpnp.ndarray):
+        First input array, expected to have numeric data type.
+    x2 (dpnp.ndarray):
+        Second input array, also expected to have numeric data type.
+    out ({None, dpnp.ndarray}, optional):
+        Output array to populate.
+        Array have the correct shape and the expected data type.
+    order ("C","F","A","K", optional):
+        Memory layout of the newly output array, if parameter `out` is `None`.
+        Default: "K".
+Returns:
+    dpnp.ndarray:
+        An array containing the element-wise minima. The data type of
+        the returned array is determined by the Type Promotion Rules.
+"""
+
+minimum_func = _make_binary_func("minimum", dpt.minimum, _minimum_docstring)
+
+
+def dpnp_minimum(x1, x2, out=None, order="K"):
+    """Invokes minimum() from dpctl.tensor implementation for minimum() function."""
+
+    # dpctl.tensor only works with usm_ndarray or scalar
+    x1_usm_or_scalar = dpnp.get_usm_ndarray_or_scalar(x1)
+    x2_usm_or_scalar = dpnp.get_usm_ndarray_or_scalar(x2)
+    out_usm = None if out is None else dpnp.get_usm_ndarray(out)
+
+    res_usm = minimum_func(
+        x1_usm_or_scalar, x2_usm_or_scalar, out=out_usm, order=order
+    )
+    return dpnp_array._create_from_usm_ndarray(res_usm)
+
+
+_multiply_docstring = """
 multiply(x1, x2, out=None, order="K")
 
 Calculates the product for each element `x1_i` of the input array `x1`
@@ -1835,25 +2056,12 @@ def dpnp_logical_xor(x1, x2, out=None, order="K"):
         of the returned array is determined by the Type Promotion Rules.
 """
 
-
-def _call_multiply(src1, src2, dst, sycl_queue, depends=None):
-    """A callback to register in BinaryElementwiseFunc class of dpctl.tensor"""
-
-    if depends is None:
-        depends = []
-
-    if vmi._mkl_mul_to_call(sycl_queue, src1, src2, dst):
-        # call pybind11 extension for mul() function from OneMKL VM
-        return vmi._mul(sycl_queue, src1, src2, dst, depends)
-    return ti._multiply(src1, src2, dst, sycl_queue, depends)
-
-
-multiply_func = BinaryElementwiseFunc(
+multiply_func = _make_binary_func(
     "multiply",
-    ti._multiply_result_type,
-    _call_multiply,
-    _multiply_docstring_,
-    ti._multiply_inplace,
+    dpt.multiply,
+    _multiply_docstring,
+    vmi._mkl_mul_to_call,
+    vmi._mul,
 )
 
 
@@ -1894,10 +2102,7 @@ def dpnp_multiply(x1, x2, out=None, order="K"):
         An array containing the negative of `x`.
 """
 
-
-negative_func = UnaryElementwiseFunc(
-    "negative", ti._negative_result_type, ti._negative, _negative_docstring
-)
+negative_func = _make_unary_func("negative", dpt.negative, _negative_docstring)
 
 
 def dpnp_negative(x, out=None, order="K"):
@@ -1918,7 +2123,7 @@ def dpnp_negative(x, out=None, order="K"):
     return dpnp_array._create_from_usm_ndarray(res_usm)
 
 
-_not_equal_docstring_ = """
+_not_equal_docstring = """
 not_equal(x1, x2, out=None, order="K")
 
 Calculates inequality results for each element `x1_i` of
@@ -1941,11 +2146,8 @@ def dpnp_negative(x, out=None, order="K"):
         The data type of the returned array is determined by the Type Promotion Rules.
 """
 
-not_equal_func = BinaryElementwiseFunc(
-    "not_equal",
-    ti._not_equal_result_type,
-    ti._not_equal,
-    _not_equal_docstring_,
+not_equal_func = _make_binary_func(
+    "not_equal", dpt.not_equal, _not_equal_docstring
 )
 
 
@@ -1963,7 +2165,46 @@ def dpnp_not_equal(x1, x2, out=None, order="K"):
     return dpnp_array._create_from_usm_ndarray(res_usm)
 
 
-_power_docstring_ = """
+_positive_docstring = """
+positive(x, out=None, order="K")
+
+Computes the numerical positive for each element `x_i` of input array `x`.
+
+Args:
+    x (dpnp.ndarray):
+        Input array, expected to have numeric data type.
+    out ({None, dpnp.ndarray}, optional):
+        Output array to populate.
+        Array have the correct shape and the expected data type.
+    order ("C","F","A","K", optional):
+        Memory layout of the newly output array, if parameter `out` is `None`.
+        Default: "K".
+Returns:
+    dpnp.ndarray:
+        An array containing the positive of `x`.
+"""
+
+positive_func = _make_unary_func("positive", dpt.positive, _positive_docstring)
+
+
+def dpnp_positive(x, out=None, order="K"):
+    """Invokes positive() from dpctl.tensor implementation for positive() function."""
+
+    # TODO: discuss with dpctl if the check is needed to be moved there
+    if not dpnp.isscalar(x) and x.dtype == dpnp.bool:
+        raise TypeError(
+            "DPNP boolean positive, the `+` operator, is not supported."
+        )
+
+    # dpctl.tensor only works with usm_ndarray
+    x1_usm = dpnp.get_usm_ndarray(x)
+    out_usm = None if out is None else dpnp.get_usm_ndarray(out)
+
+    res_usm = positive_func(x1_usm, out=out_usm, order=order)
+    return dpnp_array._create_from_usm_ndarray(res_usm)
+
+
+_power_docstring = """
 power(x1, x2, out=None, order="K")
 
 Calculates `x1_i` raised to `x2_i` for each element `x1_i` of the input array
@@ -1987,24 +2228,8 @@ def dpnp_not_equal(x1, x2, out=None, order="K"):
         The data type of the returned array is determined by the Type Promotion Rules.
 """
 
-
-def _call_pow(src1, src2, dst, sycl_queue, depends=None):
-    """A callback to register in BinaryElementwiseFunc class of dpctl.tensor"""
-
-    if depends is None:
-        depends = []
-
-    # TODO: remove this check when OneMKL is fixed on Windows
-    is_win = platform.startswith("win")
-
-    if not is_win and vmi._mkl_pow_to_call(sycl_queue, src1, src2, dst):
-        # call pybind11 extension for pow() function from OneMKL VM
-        return vmi._pow(sycl_queue, src1, src2, dst, depends)
-    return ti._pow(src1, src2, dst, sycl_queue, depends)
-
-
-pow_func = BinaryElementwiseFunc(
-    "pow", ti._pow_result_type, _call_pow, _power_docstring_
+power_func = _make_binary_func(
+    "power", dpt.pow, _power_docstring, vmi._mkl_pow_to_call, vmi._pow
 )
 
 
@@ -2020,7 +2245,7 @@ def dpnp_power(x1, x2, out=None, order="K"):
     x2_usm_or_scalar = dpnp.get_usm_ndarray_or_scalar(x2)
     out_usm = None if out is None else dpnp.get_usm_ndarray(out)
 
-    res_usm = pow_func(
+    res_usm = power_func(
         x1_usm_or_scalar, x2_usm_or_scalar, out=out_usm, order=order
     )
     return dpnp_array._create_from_usm_ndarray(res_usm)
@@ -2046,10 +2271,7 @@ def dpnp_power(x1, x2, out=None, order="K"):
         The returned array has the same data type as `x`.
 """
 
-
-proj_func = UnaryElementwiseFunc(
-    "proj", ti._proj_result_type, ti._proj, _proj_docstring
-)
+proj_func = _make_unary_func("proj", dpt.proj, _proj_docstring)
 
 
 def dpnp_proj(x, out=None, order="K"):
@@ -2086,10 +2308,7 @@ def dpnp_proj(x, out=None, order="K"):
         with the same floating-point precision as complex input.
 """
 
-
-real_func = UnaryElementwiseFunc(
-    "real", ti._real_result_type, ti._real, _real_docstring
-)
+real_func = _make_unary_func("real", dpt.real, _real_docstring)
 
 
 def dpnp_real(x, out=None, order="K"):
@@ -2103,11 +2322,13 @@ def dpnp_real(x, out=None, order="K"):
     return dpnp_array._create_from_usm_ndarray(res_usm)
 
 
-_remainder_docstring_ = """
+_remainder_docstring = """
 remainder(x1, x2, out=None, order='K')
+
 Calculates the remainder of division for each element `x1_i` of the input array
 `x1` with the respective element `x2_i` of the input array `x2`.
 This function is equivalent to the Python modulus operator.
+
 Args:
     x1 (dpnp.ndarray):
         First input array, expected to have a real-valued data type.
@@ -2125,12 +2346,8 @@ def dpnp_real(x, out=None, order="K"):
         the returned array is determined by the Type Promotion Rules.
 """
 
-
-remainder_func = BinaryElementwiseFunc(
-    "remainder",
-    ti._remainder_result_type,
-    ti._remainder,
-    _remainder_docstring_,
+remainder_func = _make_binary_func(
+    "remainder", dpt.remainder, _remainder_docstring
 )
 
 
@@ -2146,7 +2363,7 @@ def dpnp_remainder(x1, x2, out=None, order="K"):
     return dpnp_array._create_from_usm_ndarray(res_usm)
 
 
-_right_shift_docstring_ = """
+_right_shift_docstring = """
 right_shift(x1, x2, out=None, order='K')
 
 Shifts the bits of each element `x1_i` of the input array `x1` to the right
@@ -2170,12 +2387,8 @@ def dpnp_remainder(x1, x2, out=None, order="K"):
         of the returned array is determined by the Type Promotion Rules.
 """
 
-
-right_shift_func = BinaryElementwiseFunc(
-    "bitwise_right_shift",
-    ti._bitwise_right_shift_result_type,
-    ti._bitwise_right_shift,
-    _right_shift_docstring_,
+right_shift_func = _make_binary_func(
+    "right_shift", dpt.bitwise_right_shift, _right_shift_docstring
 )
 
 
@@ -2195,8 +2408,10 @@ def dpnp_right_shift(x1, x2, out=None, order="K"):
 
 _round_docstring = """
 round(x, out=None, order='K')
+
 Rounds each element `x_i` of the input array `x` to
 the nearest integer-valued number.
+
 Args:
     x (dpnp.ndarray):
         Input array, expected to have numeric data type.
@@ -2212,21 +2427,8 @@ def dpnp_right_shift(x1, x2, out=None, order="K"):
         of the returned array is determined by the Type Promotion Rules.
 """
 
-
-def _call_round(src, dst, sycl_queue, depends=None):
-    """A callback to register in UnaryElementwiseFunc class of dpctl.tensor"""
-
-    if depends is None:
-        depends = []
-
-    if vmi._mkl_round_to_call(sycl_queue, src, dst):
-        # call pybind11 extension for round() function from OneMKL VM
-        return vmi._round(sycl_queue, src, dst, depends)
-    return ti._round(src, dst, sycl_queue, depends)
-
-
-round_func = UnaryElementwiseFunc(
-    "round", ti._round_result_type, _call_round, _round_docstring
+round_func = _make_unary_func(
+    "round", dpt.round, _round_docstring, vmi._mkl_round_to_call, vmi._round
 )
 
 
@@ -2268,10 +2470,7 @@ def dpnp_round(x, out=None, order="K"):
         returned array is determined by the Type Promotion Rules.
 """
 
-
-sign_func = UnaryElementwiseFunc(
-    "sign", ti._sign_result_type, ti._sign, _sign_docstring
-)
+sign_func = _make_unary_func("sign", dpt.sign, _sign_docstring)
 
 
 def dpnp_sign(x, out=None, order="K"):
@@ -2310,10 +2509,7 @@ def dpnp_sign(x, out=None, order="K"):
         must have a data type of `bool`.
 """
 
-
-signbit_func = UnaryElementwiseFunc(
-    "signbit", ti._signbit_result_type, ti._signbit, _signbit_docstring
-)
+signbit_func = _make_unary_func("signbit", dpt.signbit, _signbit_docstring)
 
 
 def dpnp_signbit(x, out=None, order="K"):
@@ -2347,21 +2543,8 @@ def dpnp_signbit(x, out=None, order="K"):
         returned array is determined by the Type Promotion Rules.
 """
 
-
-def _call_sin(src, dst, sycl_queue, depends=None):
-    """A callback to register in UnaryElementwiseFunc class of dpctl.tensor"""
-
-    if depends is None:
-        depends = []
-
-    if vmi._mkl_sin_to_call(sycl_queue, src, dst):
-        # call pybind11 extension for sin() function from OneMKL VM
-        return vmi._sin(sycl_queue, src, dst, depends)
-    return ti._sin(src, dst, sycl_queue, depends)
-
-
-sin_func = UnaryElementwiseFunc(
-    "sin", ti._sin_result_type, _call_sin, _sin_docstring
+sin_func = _make_unary_func(
+    "sin", dpt.sin, _sin_docstring, vmi._mkl_sin_to_call, vmi._sin
 )
 
 
@@ -2400,21 +2583,8 @@ def dpnp_sin(x, out=None, order="K"):
         of the returned array is determined by the Type Promotion Rules.
 """
 
-
-def _call_sinh(src, dst, sycl_queue, depends=None):
-    """A callback to register in UnaryElementwiseFunc class of dpctl.tensor"""
-
-    if depends is None:
-        depends = []
-
-    if vmi._mkl_sinh_to_call(sycl_queue, src, dst):
-        # call pybind11 extension for sinh() function from OneMKL VM
-        return vmi._sinh(sycl_queue, src, dst, depends)
-    return ti._sinh(src, dst, sycl_queue, depends)
-
-
-sinh_func = UnaryElementwiseFunc(
-    "sinh", ti._sinh_result_type, _call_sinh, _sinh_docstring
+sinh_func = _make_unary_func(
+    "sinh", dpt.sinh, _sinh_docstring, vmi._mkl_sinh_to_call, vmi._sinh
 )
 
 
@@ -2433,9 +2603,11 @@ def dpnp_sinh(x, out=None, order="K"):
     return dpnp_array._create_from_usm_ndarray(res_usm)
 
 
-_sqrt_docstring_ = """
+_sqrt_docstring = """
 sqrt(x, out=None, order='K')
+
 Computes the non-negative square-root for each element `x_i` for input array `x`.
+
 Args:
     x (dpnp.ndarray):
         Input array.
@@ -2450,24 +2622,8 @@ def dpnp_sinh(x, out=None, order="K"):
         An array containing the element-wise square-root results.
 """
 
-
-def _call_sqrt(src, dst, sycl_queue, depends=None):
-    """A callback to register in UnaryElementwiseFunc class of dpctl.tensor"""
-
-    if depends is None:
-        depends = []
-
-    if vmi._mkl_sqrt_to_call(sycl_queue, src, dst):
-        # call pybind11 extension for sqrt() function from OneMKL VM
-        return vmi._sqrt(sycl_queue, src, dst, depends)
-    return ti._sqrt(src, dst, sycl_queue, depends)
-
-
-sqrt_func = UnaryElementwiseFunc(
-    "sqrt",
-    ti._sqrt_result_type,
-    _call_sqrt,
-    _sqrt_docstring_,
+sqrt_func = _make_unary_func(
+    "sqrt", dpt.sqrt, _sqrt_docstring, vmi._mkl_sqrt_to_call, vmi._sqrt
 )
 
 
@@ -2486,9 +2642,11 @@ def dpnp_sqrt(x, out=None, order="K"):
     return dpnp_array._create_from_usm_ndarray(res_usm)
 
 
-_square_docstring_ = """
+_square_docstring = """
 square(x, out=None, order='K')
+
 Computes `x_i**2` (or `x_i*x_i`) for each element `x_i` of input array `x`.
+
 Args:
     x (dpnp.ndarray):
         Input array.
@@ -2503,24 +2661,8 @@ def dpnp_sqrt(x, out=None, order="K"):
         An array containing the element-wise square results.
 """
 
-
-def _call_square(src, dst, sycl_queue, depends=None):
-    """A callback to register in UnaryElementwiseFunc class of dpctl.tensor"""
-
-    if depends is None:
-        depends = []
-
-    if vmi._mkl_sqr_to_call(sycl_queue, src, dst):
-        # call pybind11 extension for sqr() function from OneMKL VM
-        return vmi._sqr(sycl_queue, src, dst, depends)
-    return ti._square(src, dst, sycl_queue, depends)
-
-
-square_func = UnaryElementwiseFunc(
-    "square",
-    ti._square_result_type,
-    _call_square,
-    _square_docstring_,
+square_func = _make_unary_func(
+    "square", dpt.square, _square_docstring, vmi._mkl_sqr_to_call, vmi._sqr
 )
 
 
@@ -2539,10 +2681,10 @@ def dpnp_square(x, out=None, order="K"):
     return dpnp_array._create_from_usm_ndarray(res_usm)
 
 
-_subtract_docstring_ = """
+_subtract_docstring = """
 subtract(x1, x2, out=None, order="K")
 
-Calculates the difference bewteen each element `x1_i` of the input
+Calculates the difference between each element `x1_i` of the input
 array `x1` and the respective element `x2_i` of the input array `x2`.
 
 Args:
@@ -2562,25 +2704,12 @@ def dpnp_square(x, out=None, order="K"):
         of the returned array is determined by the Type Promotion Rules.
 """
 
-
-def _call_subtract(src1, src2, dst, sycl_queue, depends=None):
-    """A callback to register in BinaryElementwiseFunc class of dpctl.tensor"""
-
-    if depends is None:
-        depends = []
-
-    if vmi._mkl_sub_to_call(sycl_queue, src1, src2, dst):
-        # call pybind11 extension for sub() function from OneMKL VM
-        return vmi._sub(sycl_queue, src1, src2, dst, depends)
-    return ti._subtract(src1, src2, dst, sycl_queue, depends)
-
-
-subtract_func = BinaryElementwiseFunc(
+subtract_func = _make_binary_func(
     "subtract",
-    ti._subtract_result_type,
-    _call_subtract,
-    _subtract_docstring_,
-    ti._subtract_inplace,
+    dpt.subtract,
+    _subtract_docstring,
+    vmi._mkl_sub_to_call,
+    vmi._sub,
 )
 
 
@@ -2633,21 +2762,8 @@ def dpnp_subtract(x1, x2, out=None, order="K"):
         of the returned array is determined by the Type Promotion Rules.
 """
 
-
-def _call_tan(src, dst, sycl_queue, depends=None):
-    """A callback to register in UnaryElementwiseFunc class of dpctl.tensor"""
-
-    if depends is None:
-        depends = []
-
-    if vmi._mkl_tan_to_call(sycl_queue, src, dst):
-        # call pybind11 extension for tan() function from OneMKL VM
-        return vmi._tan(sycl_queue, src, dst, depends)
-    return ti._tan(src, dst, sycl_queue, depends)
-
-
-tan_func = UnaryElementwiseFunc(
-    "tan", ti._tan_result_type, _call_tan, _tan_docstring
+tan_func = _make_unary_func(
+    "tan", dpt.tan, _tan_docstring, vmi._mkl_tan_to_call, vmi._tan
 )
 
 
@@ -2686,21 +2802,8 @@ def dpnp_tan(x, out=None, order="K"):
         of the returned array is determined by the Type Promotion Rules.
 """
 
-
-def _call_tanh(src, dst, sycl_queue, depends=None):
-    """A callback to register in UnaryElementwiseFunc class of dpctl.tensor"""
-
-    if depends is None:
-        depends = []
-
-    if vmi._mkl_tanh_to_call(sycl_queue, src, dst):
-        # call pybind11 extension for tanh() function from OneMKL VM
-        return vmi._tanh(sycl_queue, src, dst, depends)
-    return ti._tanh(src, dst, sycl_queue, depends)
-
-
-tanh_func = UnaryElementwiseFunc(
-    "tanh", ti._tanh_result_type, _call_tanh, _tanh_docstring
+tanh_func = _make_unary_func(
+    "tanh", dpt.tanh, _tanh_docstring, vmi._mkl_tanh_to_call, vmi._tanh
 )
 
 
@@ -2742,21 +2845,8 @@ def dpnp_tanh(x, out=None, order="K"):
         of the returned array is determined by the Type Promotion Rules.
 """
 
-
-def _call_trunc(src, dst, sycl_queue, depends=None):
-    """A callback to register in UnaryElementwiseFunc class of dpctl.tensor"""
-
-    if depends is None:
-        depends = []
-
-    if vmi._mkl_trunc_to_call(sycl_queue, src, dst):
-        # call pybind11 extension for trunc() function from OneMKL VM
-        return vmi._trunc(sycl_queue, src, dst, depends)
-    return ti._trunc(src, dst, sycl_queue, depends)
-
-
-trunc_func = UnaryElementwiseFunc(
-    "trunc", ti._trunc_result_type, _call_trunc, _trunc_docstring
+trunc_func = _make_unary_func(
+    "trunc", dpt.trunc, _trunc_docstring, vmi._mkl_trunc_to_call, vmi._trunc
 )
 
 
diff --git a/dpnp/dpnp_array.py b/dpnp/dpnp_array.py
index 252fa17c5b4..ce80de31be5 100644
--- a/dpnp/dpnp_array.py
+++ b/dpnp/dpnp_array.py
@@ -35,7 +35,7 @@ def _get_unwrapped_index_key(key):
     Get an unwrapped index key.
 
     Return a key where each nested instance of DPNP array is unwrapped into USM ndarray
-    for futher processing in DPCTL advanced indexing functions.
+    for further processing in DPCTL advanced indexing functions.
 
     """
 
@@ -344,7 +344,9 @@ def __or__(self, other):
         """Return self|value."""
         return dpnp.bitwise_or(self, other)
 
-    # '__pos__',
+    def __pos__(self):
+        """Return +self."""
+        return dpnp.positive(self)
 
     def __pow__(self, other):
         """Return self**value."""
@@ -595,32 +597,64 @@ def asnumpy(self):
         return dpt.asnumpy(self._array_obj)
 
     def astype(self, dtype, order="K", casting="unsafe", subok=True, copy=True):
-        """Copy the array with data type casting.
+        """
+        Copy the array with data type casting.
 
-        Args:
-            dtype: Target type.
-            order ({'C', 'F', 'A', 'K'}): Row-major (C-style) or column-major (Fortran-style) order.
-                When ``order`` is 'A', it uses 'F' if ``a`` is column-major and uses 'C' otherwise.
-                And when ``order`` is 'K', it keeps strides as closely as possible.
-            copy (bool): If it is False and no cast happens, then this method returns the array itself.
-                Otherwise, a copy is returned.
+        For full documentation refer to :obj:`numpy.ndarray.astype`.
 
-        Returns:
-            If ``copy`` is False and no cast is required, then the array itself is returned.
-            Otherwise, it returns a (possibly casted) copy of the array.
+        Parameters
+        ----------
+        x1 : {dpnp.ndarray, usm_ndarray}
+            Array data type casting.
+        dtype : dtype
+            Target data type.
+        order : {'C', 'F', 'A', 'K'}
+            Row-major (C-style) or column-major (Fortran-style) order.
+            When ``order`` is 'A', it uses 'F' if ``a`` is column-major and uses 'C' otherwise.
+            And when ``order`` is 'K', it keeps strides as closely as possible.
+        copy : bool
+            If it is False and no cast happens, then this method returns the array itself.
+            Otherwise, a copy is returned.
+        casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
+            Controls what kind of data casting may occur. Defaults to 'unsafe' for backwards compatibility.
+            'no' means the data types should not be cast at all.
+            'equiv' means only byte-order changes are allowed.
+            'safe' means only casts which can preserve values are allowed.
+            'same_kind' means only safe casts or casts within a kind, like float64 to float32, are allowed.
+            'unsafe' means any data conversions may be done.
+        copy : bool, optional
+            By default, astype always returns a newly allocated array. If this is set to false, and the dtype,
+            order, and subok requirements are satisfied, the input array is returned instead of a copy.
 
-        .. note::
-           This method currently does not support `order``, `casting``, ``copy``, and ``subok`` arguments.
+        Returns
+        -------
+        arr_t : dpnp.ndarray
+            Unless `copy` is ``False`` and the other conditions for returning the input array
+            are satisfied, `arr_t` is a new array of the same shape as the input array,
+            with dtype, order given by dtype, order.
 
-        .. seealso:: :meth:`numpy.ndarray.astype`
+        Limitations
+        -----------
+        Parameter `subok` is supported with default value.
+        Otherwise ``NotImplementedError`` exception will be raised.
+
+        Examples
+        --------
+        >>> import dpnp as np
+        >>> x = np.array([1, 2, 2.5])
+        >>> x
+        array([1. , 2. , 2.5])
+        >>> x.astype(int)
+        array([1, 2, 2])
 
         """
 
-        new_array = self.__new__(dpnp_array)
-        new_array._array_obj = dpt.astype(
-            self._array_obj, dtype, order=order, casting=casting, copy=copy
-        )
-        return new_array
+        if subok is not True:
+            raise NotImplementedError(
+                f"subok={subok} is currently not supported"
+            )
+
+        return dpnp.astype(self, dtype, order=order, casting=casting, copy=copy)
 
     # 'base',
     # 'byteswap',
@@ -1098,7 +1132,7 @@ def round(self, decimals=0, out=None):
 
     @property
     def shape(self):
-        """Lengths of axes. A tuple of numbers represents size of each dimention.
+        """Lengths of axes. A tuple of numbers represents size of each dimension.
 
         Setter of this property involves reshaping without copy. If the array
         cannot be reshaped without copy, it raises an exception.
@@ -1114,7 +1148,7 @@ def shape(self, newshape):
         """
         Set new lengths of axes.
 
-        A tuple of numbers represents size of each dimention.
+        A tuple of numbers represents size of each dimension.
         It involves reshaping without copy. If the array cannot be reshaped without copy,
         it raises an exception.
 
diff --git a/dpnp/dpnp_container.py b/dpnp/dpnp_container.py
index c8c0858df7e..b36b64a5113 100644
--- a/dpnp/dpnp_container.py
+++ b/dpnp/dpnp_container.py
@@ -29,7 +29,7 @@
 
 Notes
 -----
-This module contains code and dependency on diffrent containers used in DPNP
+This module contains code and dependency on different containers used in DPNP
 
 """
 
diff --git a/dpnp/dpnp_iface.py b/dpnp/dpnp_iface.py
index c131bf733ce..d6d5b3a4861 100644
--- a/dpnp/dpnp_iface.py
+++ b/dpnp/dpnp_iface.py
@@ -46,6 +46,7 @@
 import dpctl.tensor as dpt
 import numpy
 
+import dpnp
 from dpnp.dpnp_algo import *
 from dpnp.dpnp_array import dpnp_array
 from dpnp.dpnp_utils import *
@@ -149,42 +150,57 @@ def asnumpy(input, order="C"):
     return numpy.asarray(input, order=order)
 
 
-def astype(x1, dtype, order="K", casting="unsafe", subok=True, copy=True):
-    """Copy the array with data type casting."""
-    if isinstance(x1, dpnp_array):
-        return x1.astype(dtype, order=order, casting=casting, copy=copy)
-
-    if isinstance(x1, dpt.usm_ndarray):
-        return dpt.astype(x1, dtype, order=order, casting=casting, copy=copy)
-
-    x1_desc = get_dpnp_descriptor(x1, copy_when_nondefault_queue=False)
-    if not x1_desc:
-        pass
-    elif order != "K":
-        pass
-    elif casting != "unsafe":
-        pass
-    elif not subok:
-        pass
-    elif not copy:
-        pass
-    elif x1_desc.dtype == numpy.complex128 or dtype == numpy.complex128:
-        pass
-    elif x1_desc.dtype == numpy.complex64 or dtype == numpy.complex64:
-        pass
-    else:
-        return dpnp_astype(x1_desc, dtype).get_pyobj()
-
-    return call_origin(
-        numpy.ndarray.astype,
-        x1,
-        dtype,
-        order=order,
-        casting=casting,
-        subok=subok,
-        copy=copy,
+def astype(x1, dtype, order="K", casting="unsafe", copy=True):
+    """
+    Copy the array with data type casting.
+
+    Parameters
+    ----------
+    x1 : {dpnp.ndarray, usm_ndarray}
+        Array data type casting.
+    dtype : dtype
+        Target data type.
+    order : {'C', 'F', 'A', 'K'}
+        Row-major (C-style) or column-major (Fortran-style) order.
+        When ``order`` is 'A', it uses 'F' if ``a`` is column-major and uses 'C' otherwise.
+        And when ``order`` is 'K', it keeps strides as closely as possible.
+    copy : bool
+        If it is False and no cast happens, then this method returns the array itself.
+        Otherwise, a copy is returned.
+    casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
+        Controls what kind of data casting may occur. Defaults to 'unsafe' for backwards compatibility.
+        'no' means the data types should not be cast at all.
+        'equiv' means only byte-order changes are allowed.
+        'safe' means only casts which can preserve values are allowed.
+        'same_kind' means only safe casts or casts within a kind, like float64 to float32, are allowed.
+        'unsafe' means any data conversions may be done.
+    copy : bool, optional
+        By default, astype always returns a newly allocated array. If this is set to false, and the dtype,
+        order, and subok requirements are satisfied, the input array is returned instead of a copy.
+
+    Returns
+    -------
+    arr_t : dpnp.ndarray
+        Unless `copy` is ``False`` and the other conditions for returning the input array
+        are satisfied, `arr_t` is a new array of the same shape as the input array,
+        with dtype, order given by dtype, order.
+
+    """
+
+    if order is None:
+        order = "K"
+
+    x1_obj = dpnp.get_usm_ndarray(x1)
+    array_obj = dpt.astype(
+        x1_obj, dtype, order=order, casting=casting, copy=copy
     )
 
+    # return x1 if dpctl returns a zero copy of x1_obj
+    if array_obj is x1_obj and isinstance(x1, dpnp_array):
+        return x1
+
+    return dpnp_array._create_from_usm_ndarray(array_obj)
+
 
 def convert_single_elem_array_to_scalar(obj, keepdims=False):
     """Convert array with single element to scalar."""
@@ -262,7 +278,7 @@ def get_dpnp_descriptor(
     """
     Return True:
       never
-    Return DPNP internal data discriptor object if:
+    Return DPNP internal data descriptor object if:
       1. We can proceed with input data object with DPNP
       2. We want to handle input data object
     Return False if:
@@ -350,37 +366,45 @@ def get_normalized_queue_device(obj=None, device=None, sycl_queue=None):
     Utility to process complementary keyword arguments 'device' and 'sycl_queue'
     in subsequent calls of functions from `dpctl.tensor` module.
 
-    If both arguments 'device' and 'sycl_queue' have default value `None`
+    If both arguments 'device' and 'sycl_queue' have default value ``None``
     and 'obj' has `sycl_queue` attribute, it assumes that Compute Follows Data
     approach has to be applied and so the resulting SYCL queue will be normalized
     based on the queue value from 'obj'.
 
-    Args:
-        obj (optional): A python object. Can be an instance of `dpnp_array`,
-            `dpctl.tensor.usm_ndarray`, an object representing SYCL USM allocation
-            and implementing `__sycl_usm_array_interface__` protocol,
-            an instance of `numpy.ndarray`, an object supporting Python buffer protocol,
-            a Python scalar, or a (possibly nested) sequence of Python scalars.
-        sycl_queue (:class:`dpctl.SyclQueue`, optional):
-            explicitly indicates where USM allocation is done
-            and the population code (if any) is executed.
-            Value `None` is interpreted as get the SYCL queue
-            from `obj` parameter if not None, from `device` keyword,
-            or use default queue.
-            Default: None
-        device (string, :class:`dpctl.SyclDevice`, :class:`dpctl.SyclQueue,
-            :class:`dpctl.tensor.Device`, optional):
-            array-API keyword indicating non-partitioned SYCL device
-            where array is allocated.
+    Parameters
+    ----------
+    obj : object, optional
+        A python object. Can be an instance of `dpnp_array`,
+        `dpctl.tensor.usm_ndarray`, an object representing SYCL USM allocation
+        and implementing `__sycl_usm_array_interface__` protocol, an instance
+        of `numpy.ndarray`, an object supporting Python buffer protocol,
+        a Python scalar, or a (possibly nested) sequence of Python scalars.
+    sycl_queue : class:`dpctl.SyclQueue`, optional
+        A queue which explicitly indicates where USM allocation is done
+        and the population code (if any) is executed.
+        Value ``None`` is interpreted as to get the SYCL queue from either
+        `obj` parameter if not ``None`` or from `device` keyword,
+        or to use default queue.
+    device : {string, :class:`dpctl.SyclDevice`, :class:`dpctl.SyclQueue,
+              :class:`dpctl.tensor.Device`}, optional
+        An array-API keyword indicating non-partitioned SYCL device
+        where array is allocated.
+
     Returns
-        :class:`dpctl.SyclQueue` object normalized by `normalize_queue_device` call
+    -------
+    sycl_queue: dpctl.SyclQueue
+        A :class:`dpctl.SyclQueue` object normalized by `normalize_queue_device` call
         of `dpctl.tensor` module invoked with 'device' and 'sycl_queue' values.
         If both incoming 'device' and 'sycl_queue' are None and 'obj' has `sycl_queue` attribute,
         the normalization will be performed for 'obj.sycl_queue' value.
-    Raises:
-        TypeError: if argument is not of the expected type, or keywords
-            imply incompatible queues.
+
+    Raises
+    ------
+    TypeError
+        If argument is not of the expected type, or keywords imply incompatible queues.
+
     """
+
     if (
         device is None
         and sycl_queue is None
@@ -389,12 +413,9 @@ def get_normalized_queue_device(obj=None, device=None, sycl_queue=None):
     ):
         sycl_queue = obj.sycl_queue
 
-    # TODO: remove check dpt._device has attribute 'normalize_queue_device'
-    if hasattr(dpt._device, "normalize_queue_device"):
-        return dpt._device.normalize_queue_device(
-            sycl_queue=sycl_queue, device=device
-        )
-    return sycl_queue
+    return dpt._device.normalize_queue_device(
+        sycl_queue=sycl_queue, device=device
+    )
 
 
 def get_usm_ndarray(a):
diff --git a/dpnp/dpnp_iface_arraycreation.py b/dpnp/dpnp_iface_arraycreation.py
index 22e7c1e0d9d..2a8d80fc389 100644
--- a/dpnp/dpnp_iface_arraycreation.py
+++ b/dpnp/dpnp_iface_arraycreation.py
@@ -115,7 +115,7 @@ def arange(
 
     Limitations
     -----------
-    Parameter ``like`` is supported only with default value ``None``.
+    Parameter `like` is supported only with default value ``None``.
     Otherwise the function will be executed sequentially on CPU.
 
     See Also
@@ -668,8 +668,8 @@ def empty(
 
     Limitations
     -----------
-    Parameter ``order`` is supported only with values ``"C"`` and ``"F"``.
-    Parameter ``like`` is supported only with default value ``None``.
+    Parameter `order` is supported only with values ``"C"`` and ``"F"``.
+    Parameter `like` is supported only with default value ``None``.
     Otherwise the function will be executed sequentially on CPU.
 
     See Also
@@ -724,9 +724,9 @@ def empty_like(
 
     Limitations
     -----------
-    Parameter ``x1`` is supported as :class:`dpnp.dpnp_array` or :class:`dpctl.tensor.usm_ndarray`
-    Parameter ``order`` is supported with values ``"C"`` or ``"F"``.
-    Parameter ``subok`` is supported only with default value ``False``.
+    Parameter `x1` is supported as :class:`dpnp.dpnp_array` or :class:`dpctl.tensor.usm_ndarray`
+    Parameter `order` is supported with values ``"C"`` or ``"F"``.
+    Parameter `subok` is supported only with default value ``False``.
     Otherwise the function will be executed sequentially on CPU.
 
     See Also
@@ -790,8 +790,8 @@ def eye(
 
     Limitations
     -----------
-    Parameter ``order`` is supported only with values ``"C"`` and ``"F"``.
-    Parameter ``like`` is supported only with default value ``None``.
+    Parameter `order` is supported only with values ``"C"`` and ``"F"``.
+    Parameter `like` is supported only with default value ``None``.
     Otherwise the function will be executed sequentially on CPU.
 
     """
@@ -916,8 +916,8 @@ def full(
 
     Limitations
     -----------
-    Parameter ``order`` is supported only with values ``"C"`` and ``"F"``.
-    Parameter ``like`` is supported only with default value ``None``.
+    Parameter `order` is supported only with values ``"C"`` and ``"F"``.
+    Parameter `like` is supported only with default value ``None``.
     Otherwise the function will be executed sequentially on CPU.
 
     See Also
@@ -973,9 +973,9 @@ def full_like(
 
     Limitations
     -----------
-    Parameter ``x1`` is supported as :class:`dpnp.dpnp_array` or :class:`dpctl.tensor.usm_ndarray`
-    Parameter ``order`` is supported only with values ``"C"`` and ``"F"``.
-    Parameter ``subok`` is supported only with default value ``False``.
+    Parameter `x1` is supported as :class:`dpnp.dpnp_array` or :class:`dpctl.tensor.usm_ndarray`
+    Parameter `order` is supported only with values ``"C"`` and ``"F"``.
+    Parameter `subok` is supported only with default value ``False``.
     Otherwise the function will be executed sequentially on CPU.
 
     See Also
@@ -1027,7 +1027,7 @@ def geomspace(start, stop, num=50, endpoint=True, dtype=None, axis=0):
 
     Limitations
     -----------
-    Parameter ``axis`` is supported only with default value ``0``.
+    Parameter `axis` is supported only with default value ``0``.
 
     See Also
     --------
@@ -1061,7 +1061,9 @@ def geomspace(start, stop, num=50, endpoint=True, dtype=None, axis=0):
     return call_origin(numpy.geomspace, start, stop, num, endpoint, dtype, axis)
 
 
-def identity(n, dtype=None, *, like=None):
+def identity(
+    n, dtype=None, *, device=None, usm_type="device", sycl_queue=None, like=None
+):
     """
     Return the identity array.
 
@@ -1069,9 +1071,22 @@ def identity(n, dtype=None, *, like=None):
 
     For full documentation refer to :obj:`numpy.identity`.
 
+    Returns
+    -------
+    out : dpnp.ndarray
+        `n` x `n` array with its main diagonal set to one,
+        and all other elements 0.
+
     Limitations
     -----------
-    Parameter ``like`` is currently not supported .
+    Parameter `like` is currently not supported.
+    Otherwise the function will be executed sequentially on CPU.
+
+    See Also
+    --------
+    :obj:`dpnp.eye` : Return a 2-D array with ones on the diagonal and zeros elsewhere.
+    :obj:`dpnp.ones` : Return a new array setting values to one.
+    :obj:`dpnp.diag` : Return diagonal 2-D array from an input 1-D array.
 
     Examples
     --------
@@ -1086,11 +1101,16 @@ def identity(n, dtype=None, *, like=None):
         if like is not None:
             pass
         elif n < 0:
-            pass
+            raise ValueError("negative dimensions are not allowed")
         else:
             _dtype = dpnp.default_float_type() if dtype is None else dtype
-            return dpnp_identity(n, _dtype).get_pyobj()
-
+            return dpnp.eye(
+                n,
+                dtype=_dtype,
+                device=device,
+                usm_type=usm_type,
+                sycl_queue=sycl_queue,
+            )
     return call_origin(numpy.identity, n, dtype=dtype, like=like)
 
 
@@ -1115,8 +1135,8 @@ def linspace(
 
     Limitations
     -----------
-    Parameter ``axis`` is supported only with default value ``0``.
-    Parameter ``retstep`` is supported only with default value ``False``.
+    Parameter `axis` is supported only with default value ``0``.
+    Parameter `retstep` is supported only with default value ``False``.
     Otherwise the function will be executed sequentially on CPU.
 
     See Also
@@ -1198,7 +1218,7 @@ def logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None, axis=0):
 
     Limitations
     -----------
-    Parameter ``axis`` is supported only with default value ``0``.
+    Parameter `axis` is supported only with default value ``0``.
 
     See Also
     --------
@@ -1252,8 +1272,8 @@ def meshgrid(*xi, copy=True, sparse=False, indexing="xy"):
     Limitations
     -----------
     Each array instance from `xi` is supported as either :class:`dpnp.dpnp_array` or :class:`dpctl.tensor.usm_ndarray`.
-    Parameter ``copy`` is supported only with default value ``True``.
-    Parameter ``sparse`` is supported only with default value ``False``.
+    Parameter `copy` is supported only with default value ``True``.
+    Parameter `sparse` is supported only with default value ``False``.
     Otherwise the function will be executed sequentially on CPU.
 
     Examples
@@ -1379,8 +1399,8 @@ def ones(
 
     Limitations
     -----------
-    Parameter ``order`` is supported only with values ``"C"`` and ``"F"``.
-    Parameter ``like`` is supported only with default value ``None``.
+    Parameter `order` is supported only with values ``"C"`` and ``"F"``.
+    Parameter `like` is supported only with default value ``None``.
     Otherwise the function will be executed sequentially on CPU.
 
     See Also
@@ -1439,9 +1459,9 @@ def ones_like(
 
     Limitations
     -----------
-    Parameter ``x1`` is supported as :class:`dpnp.dpnp_array` or :class:`dpctl.tensor.usm_ndarray`
-    Parameter ``order`` is supported with values ``"C"`` or ``"F"``.
-    Parameter ``subok`` is supported only with default value ``False``.
+    Parameter `x1` is supported as :class:`dpnp.dpnp_array` or :class:`dpctl.tensor.usm_ndarray`
+    Parameter `order` is supported with values ``"C"`` or ``"F"``.
+    Parameter `subok` is supported only with default value ``False``.
     Otherwise the function will be executed sequentially on CPU.
 
     See Also
@@ -1494,7 +1514,8 @@ def ptp(arr, axis=None, out=None, keepdims=numpy._NoValue):
     Limitations
     -----------
     Input array is supported as :obj:`dpnp.ndarray`.
-    Parameters ``out`` and ``keepdims`` are supported only with default values.
+    Parameters `out` and `keepdims` are supported only with default values.
+
     """
     arr_desc = dpnp.get_dpnp_descriptor(arr, copy_when_nondefault_queue=False)
     if not arr_desc:
@@ -1523,7 +1544,7 @@ def trace(x1, offset=0, axis1=0, axis2=1, dtype=None, out=None):
     Limitations
     -----------
     Input array is supported as :obj:`dpnp.ndarray`.
-    Parameters ``axis1``, ``axis2``, ``out`` and ``dtype`` are supported only with default values.
+    Parameters `axis1`, `axis2`, `out` and `dtype` are supported only with default values.
     """
 
     x1_desc = dpnp.get_dpnp_descriptor(x1, copy_when_nondefault_queue=False)
@@ -1546,12 +1567,37 @@ def trace(x1, offset=0, axis1=0, axis2=1, dtype=None, out=None):
     return call_origin(numpy.trace, x1, offset, axis1, axis2, dtype, out)
 
 
-def tri(N, M=None, k=0, dtype=dpnp.float, **kwargs):
+def tri(
+    N,
+    M=None,
+    k=0,
+    dtype=dpnp.float,
+    device=None,
+    usm_type="device",
+    sycl_queue=None,
+    **kwargs,
+):
     """
     An array with ones at and below the given diagonal and zeros elsewhere.
 
     For full documentation refer to :obj:`numpy.tri`.
 
+    Returns
+    -------
+    out : ndarray of shape (N, M)
+        Array with its lower triangle filled with ones and zeros elsewhere.
+
+    Limitations
+    -----------
+    Parameter `M`, `N`, and `k` are only supported as integer data type.
+    Keyword argument `kwargs` is currently unsupported.
+    Otherwise the function will be executed sequentially on CPU.
+
+    See Also
+    --------
+    :obj:`dpnp.tril` : Return lower triangle of an array.
+    :obj:`dpnp.triu` : Return upper triangle of an array.
+
     Examples
     --------
     >>> import dpnp as np
@@ -1586,7 +1632,17 @@ def tri(N, M=None, k=0, dtype=dpnp.float, **kwargs):
                 if dtype in (dpnp.float, None)
                 else dtype
             )
-            return dpnp_tri(N, M, k, _dtype).get_pyobj()
+            if M is None:
+                M = N
+
+            m = dpnp.ones(
+                (N, M),
+                dtype=_dtype,
+                device=device,
+                usm_type=usm_type,
+                sycl_queue=sycl_queue,
+            )
+            return dpnp.tril(m, k=k)
 
     return call_origin(numpy.tri, N, M, k, dtype, **kwargs)
 
@@ -1737,8 +1793,8 @@ def zeros(
 
     Limitations
     -----------
-    Parameter ``order`` is supported only with values ``"C"`` and ``"F"``.
-    Parameter ``like`` is supported only with default value ``None``.
+    Parameter `order` is supported only with values ``"C"`` and ``"F"``.
+    Parameter `like` is supported only with default value ``None``.
     Otherwise the function will be executed sequentially on CPU.
 
     See Also
@@ -1796,9 +1852,9 @@ def zeros_like(
 
     Limitations
     -----------
-    Parameter ``x1`` is supported as :class:`dpnp.dpnp_array` or :class:`dpctl.tensor.usm_ndarray`
-    Parameter ``order`` is supported with values ``"C"`` or ``"F"``.
-    Parameter ``subok`` is supported only with default value ``False``.
+    Parameter `x1` is supported as :class:`dpnp.dpnp_array` or :class:`dpctl.tensor.usm_ndarray`
+    Parameter `order` is supported with values ``"C"`` or ``"F"``.
+    Parameter `subok` is supported only with default value ``False``.
     Otherwise the function will be executed sequentially on CPU.
 
     See Also
diff --git a/dpnp/dpnp_iface_counting.py b/dpnp/dpnp_iface_counting.py
index 1b5a6e6fe99..35301a6b9db 100644
--- a/dpnp/dpnp_iface_counting.py
+++ b/dpnp/dpnp_iface_counting.py
@@ -39,48 +39,54 @@
 
 """
 
-
-import numpy
-
 import dpnp
-from dpnp.dpnp_algo.dpnp_algo import *  # TODO need to investigate why dpnp.dpnp_algo can not be used
-from dpnp.dpnp_utils import *
 
 __all__ = ["count_nonzero"]
 
 
-def count_nonzero(x1, axis=None, *, keepdims=False):
+def count_nonzero(a, axis=None, *, keepdims=False):
     """
-    Counts the number of non-zero values in the array ``in_array1``.
+    Counts the number of non-zero values in the array `a`.
 
     For full documentation refer to :obj:`numpy.count_nonzero`.
 
+    Returns
+    -------
+    out : dpnp.ndarray
+        Number of non-zero values in the array along a given axis.
+        Otherwise, a zero-dimensional array with the total number of
+        non-zero values in the array is returned.
+
     Limitations
     -----------
-        Parameter ``x1`` is supported as :obj:`dpnp.ndarray`.
-        Otherwise the function will be executed sequentially on CPU.
-        Parameter ``axis`` is supported only with default value `None`.
-        Parameter ``keepdims`` is supported only with default value `False`.
+    Parameters `a` is supported as either :class:`dpnp.ndarray`
+    or :class:`dpctl.tensor.usm_ndarray`.
+    Otherwise ``TypeError`` exception will be raised.
+    Input array data types are limited by supported DPNP :ref:`Data types`.
+
+    See Also
+    --------
+    :obj:`dpnp.nonzero` : Return the coordinates of all the non-zero values.
 
     Examples
     --------
     >>> import dpnp as np
-    >>> np.count_nonzero(np.array([1, 0, 3, 0, 5])
-    3
-    >>> np.count_nonzero(np.array([[1, 0, 3, 0, 5],[0, 9, 0, 7, 0]]))
-    5
+    >>> np.count_nonzero(np.eye(4))
+    array(4)
+    >>> a = np.array([[0, 1, 7, 0],
+                      [3, 0, 2, 19]])
+    >>> np.count_nonzero(a)
+    array(5)
+    >>> np.count_nonzero(a, axis=0)
+    array([1, 1, 2, 1])
+    >>> np.count_nonzero(a, axis=1)
+    array([2, 3])
+    >>> np.count_nonzero(a, axis=1, keepdims=True)
+    array([[2],
+           [3]])
 
     """
-    x1_desc = dpnp.get_dpnp_descriptor(x1, copy_when_nondefault_queue=False)
-    if x1_desc:
-        if axis is not None:
-            pass
-        elif keepdims is not False:
-            pass
-        else:
-            result_obj = dpnp_count_nonzero(x1_desc).get_pyobj()
-            result = dpnp.convert_single_elem_array_to_scalar(result_obj)
-
-            return result
 
-    return call_origin(numpy.count_nonzero, x1, axis, keepdims=keepdims)
+    # TODO: might be improved by implementing an extension with `count_nonzero` kernel
+    a = dpnp.astype(a, dpnp.bool, copy=False)
+    return a.sum(axis=axis, dtype=dpnp.intp, keepdims=keepdims)
diff --git a/dpnp/dpnp_iface_indexing.py b/dpnp/dpnp_iface_indexing.py
index 0c19127831a..bc04a47efaf 100644
--- a/dpnp/dpnp_iface_indexing.py
+++ b/dpnp/dpnp_iface_indexing.py
@@ -218,8 +218,9 @@ def diagonal(x1, offset=0, axis1=0, axis2=1):
     Limitations
     -----------
     Input array is supported as :obj:`dpnp.ndarray`.
-    Parameters ``axis1`` and ``axis2`` are supported only with default values.
+    Parameters `axis1` and `axis2` are supported only with default values.
     Otherwise the function will be executed sequentially on CPU.
+
     """
 
     x1_desc = dpnp.get_dpnp_descriptor(x1, copy_when_nondefault_queue=False)
@@ -284,7 +285,7 @@ def fill_diagonal(x1, val, wrap=False):
 
     Limitations
     -----------
-    Parameter ``wrap`` is supported only with default values.
+    Parameter `wrap` is supported only with default values.
 
     See Also
     --------
@@ -314,8 +315,9 @@ def indices(dimensions, dtype=int, sparse=False):
 
     Limitations
     -----------
-    Parameters ``dtype`` and ``sparse`` are supported only with default values.
-    Parameter ``dimensions`` is supported with len <=2.
+    Parameters `dtype` and `sparse` are supported only with default values.
+    Parameter `dimensions` is supported with len <=2.
+
     """
 
     if not isinstance(dimensions, (tuple, list)):
@@ -562,7 +564,7 @@ def select(condlist, choicelist, default=0):
     Limitations
     -----------
     Arrays of input lists are supported as :obj:`dpnp.ndarray`.
-    Parameter ``default`` are supported only with default values.
+    Parameter `default` is supported only with default values.
     """
 
     if not use_origin_backend():
diff --git a/dpnp/dpnp_iface_libmath.py b/dpnp/dpnp_iface_libmath.py
index 046767f22e2..3d016e7d1d0 100644
--- a/dpnp/dpnp_iface_libmath.py
+++ b/dpnp/dpnp_iface_libmath.py
@@ -56,7 +56,7 @@ def erf(in_array1):
 
     Limitations
     -----------
-    Parameter ``in_array1`` is supported as :obj:`dpnp.ndarray`.
+    Parameter `in_array1` is supported as :obj:`dpnp.ndarray`.
     Otherwise the function will be executed sequentially on CPU.
     Input array data types are limited by supported DPNP :ref:`Data types`.
 
diff --git a/dpnp/dpnp_iface_linearalgebra.py b/dpnp/dpnp_iface_linearalgebra.py
index 3e3e92d8245..30b6134da17 100644
--- a/dpnp/dpnp_iface_linearalgebra.py
+++ b/dpnp/dpnp_iface_linearalgebra.py
@@ -198,9 +198,9 @@ def inner(x1, x2, **kwargs):
 
     Limitations
     -----------
-        Parameters ``x1`` and ``x2`` are supported as :obj:`dpnp.ndarray`.
-        Keyword arguments ``kwargs`` are currently unsupported.
-        Otherwise the functions will be executed sequentially on CPU.
+    Parameters `x1` and `x2` are supported as :obj:`dpnp.ndarray`.
+    Keyword argument `kwargs` is currently unsupported.
+    Otherwise the functions will be executed sequentially on CPU.
 
     See Also
     --------
@@ -256,7 +256,7 @@ def matmul(x1, x2, out=None, **kwargs):
     -----------
     Input arrays are supported as :obj:`dpnp.ndarray`.
     Otherwise the function will be executed sequentially on CPU.
-    Parameter ``out`` is supported as :obj:`dpnp.ndarray` and as default value ``None``.
+    Parameter `out` is supported as :obj:`dpnp.ndarray` and as default value ``None``.
     Input array data types are limited by supported DPNP :ref:`Data types`.
 
     See Also
@@ -392,11 +392,11 @@ def tensordot(x1, x2, axes=2):
 
     Limitations
     -----------
-        Parameters ``x1`` and ``x2`` are supported as :obj:`dpnp.ndarray`.
-        Keyword arguments ``kwargs`` are currently unsupported.
-        Parameter ``axes`` is supported only with value ``1``.
-        Otherwise the functions will be executed sequentially on CPU.
-        Input array data types are limited by supported DPNP :ref:`Data types`.
+    Parameters `x1` and `x2` are supported as :obj:`dpnp.ndarray`.
+    Keyword argument `kwargs` is currently unsupported.
+    Parameter `axes` is supported only with value ``1``.
+    Otherwise the functions will be executed sequentially on CPU.
+    Input array data types are limited by supported DPNP :ref:`Data types`.
 
     See Also
     --------
diff --git a/dpnp/dpnp_iface_logic.py b/dpnp/dpnp_iface_logic.py
index c4704d09f9a..169e0bc607a 100644
--- a/dpnp/dpnp_iface_logic.py
+++ b/dpnp/dpnp_iface_logic.py
@@ -172,7 +172,7 @@ def allclose(a, b, rtol=1.0e-5, atol=1.0e-8, **kwargs):
     Keyword argument `kwargs` is currently unsupported.
     Otherwise the functions will be executed sequentially on CPU.
     Parameters `rtol` and `atol` are supported as scalars. Otherwise
-    ``TypeError`` exeption will be raised.
+    ``TypeError`` exception will be raised.
     Input array data types are limited by supported integer and
     floating DPNP :ref:`Data types`.
 
diff --git a/dpnp/dpnp_iface_manipulation.py b/dpnp/dpnp_iface_manipulation.py
index f71aa751cb2..78614b952a7 100644
--- a/dpnp/dpnp_iface_manipulation.py
+++ b/dpnp/dpnp_iface_manipulation.py
@@ -54,7 +54,9 @@
     "atleast_1d",
     "atleast_2d",
     "atleast_3d",
+    "broadcast_arrays",
     "broadcast_to",
+    "can_cast",
     "concatenate",
     "copyto",
     "expand_dims",
@@ -73,6 +75,7 @@
     "squeeze",
     "stack",
     "swapaxes",
+    "tile",
     "transpose",
     "unique",
     "vstack",
@@ -124,15 +127,13 @@ def atleast_1d(*arys):
     """
     Convert inputs to arrays with at least one dimension.
 
-    Scalar inputs are converted to 1-dimensional arrays, whilst
-    higher-dimensional inputs are preserved.
-
     For full documentation refer to :obj:`numpy.atleast_1d`.
 
     Parameters
     ----------
-    arys : {dpnp_array, usm_ndarray}
-        One or more input arrays.
+    arys : {dpnp.ndarray, usm_ndarray}
+        One or more array-like sequences. Arrays that already have one or more
+        dimensions are preserved.
 
     Returns
     -------
@@ -142,14 +143,20 @@ def atleast_1d(*arys):
 
     See Also
     --------
-    atleast_2d, atleast_3d
+    :obj:`dpnp.atleast_2d` : View inputs as arrays with at least two dimensions.
+    :obj:`dpnp.atleast_3d` : View inputs as arrays with at least three dimensions.
 
     Examples
     --------
     >>> import dpnp as np
-    >>> np.atleast_1d(1.0)
+    >>> x = np.array(1.0)
+    >>> np.atleast_1d(x)
     array([1.])
 
+    >>> y = np.array([3, 4])
+    >>> np.atleast_1d(x, y)
+    [array([1.]), array([3, 4])]
+
     >>> x = np.arange(9.0).reshape(3,3)
     >>> np.atleast_1d(x)
     array([[0., 1., 2.],
@@ -158,18 +165,21 @@ def atleast_1d(*arys):
     >>> np.atleast_1d(x) is x
     True
 
-    >>> np.atleast_1d(1, [3, 4])
-    [array([1]), array([3, 4])]
-
     """
 
     res = []
     for ary in arys:
-        ary = dpnp.asanyarray(ary)
+        if not dpnp.is_supported_array_type(ary):
+            raise TypeError(
+                "Each input array must be any of supported type, "
+                f"but got {type(ary)}"
+            )
         if ary.ndim == 0:
             result = ary.reshape(1)
         else:
             result = ary
+        if isinstance(result, dpt.usm_ndarray):
+            result = dpnp_array._create_from_usm_ndarray(result)
         res.append(result)
     if len(res) == 1:
         return res[0]
@@ -183,36 +193,57 @@ def atleast_2d(*arys):
 
     For full documentation refer to :obj:`numpy.atleast_2d`.
 
-    Limitations
-    -----------
-    Input arrays is supported as :obj:`dpnp.ndarray`.
+    Parameters
+    ----------
+    arys : {dpnp.ndarray, usm_ndarray}
+        One or more array-like sequences. Arrays that already have two or more
+        dimensions are preserved.
+
+    Returns
+    -------
+    out : dpnp.ndarray
+        An array, or list of arrays, each with ``a.ndim >= 2``.
+        Copies are avoided where possible, and views with two or more
+        dimensions are returned.
+
+    See Also
+    --------
+    :obj:`dpnp.atleast_1d` : Convert inputs to arrays with at least one dimension.
+    :obj:`dpnp.atleast_3d` : View inputs as arrays with at least three dimensions.
+
+    Examples
+    --------
+    >>> import dpnp as np
+    >>> x = np.array(3.0)
+    >>> np.atleast_2d(x)
+    array([[3.]])
+
+    >>> x = np.arange(3.0)
+    >>> np.atleast_2d(x)
+    array([[0., 1., 2.]])
+
     """
 
-    all_is_array = True
-    arys_desc = []
+    res = []
     for ary in arys:
-        if not dpnp.isscalar(ary):
-            ary_desc = dpnp.get_dpnp_descriptor(
-                ary, copy_when_nondefault_queue=False
+        if not dpnp.is_supported_array_type(ary):
+            raise TypeError(
+                "Each input array must be any of supported type, "
+                f"but got {type(ary)}"
             )
-            if ary_desc:
-                arys_desc.append(ary_desc)
-                continue
-        all_is_array = False
-        break
-
-    if not use_origin_backend(arys[0]) and all_is_array:
-        result = []
-        for ary_desc in arys_desc:
-            res = dpnp_atleast_2d(ary_desc).get_pyobj()
-            result.append(res)
-
-        if len(result) == 1:
-            return result[0]
+        if ary.ndim == 0:
+            result = ary.reshape(1, 1)
+        elif ary.ndim == 1:
+            result = ary[dpnp.newaxis, :]
         else:
-            return result
-
-    return call_origin(numpy.atleast_2d, *arys)
+            result = ary
+        if isinstance(result, dpt.usm_ndarray):
+            result = dpnp_array._create_from_usm_ndarray(result)
+        res.append(result)
+    if len(res) == 1:
+        return res[0]
+    else:
+        return res
 
 
 def atleast_3d(*arys):
@@ -221,36 +252,112 @@ def atleast_3d(*arys):
 
     For full documentation refer to :obj:`numpy.atleast_3d`.
 
-    Limitations
-    -----------
-    Input arrays is supported as :obj:`dpnp.ndarray`.
+    Parameters
+    ----------
+    arys : {dpnp.ndarray, usm_ndarray}
+        One or more array-like sequences. Arrays that already have three or more
+        dimensions are preserved.
+
+    Returns
+    -------
+    out : dpnp.ndarray
+        An array, or list of arrays, each with ``a.ndim >= 3``. Copies are
+        avoided where possible, and views with three or more dimensions are
+        returned.
+
+    See Also
+    --------
+    :obj:`dpnp.atleast_1d` : Convert inputs to arrays with at least one dimension.
+    :obj:`dpnp.atleast_2d` : View inputs as arrays with at least three dimensions.
+
+    Examples
+    --------
+    >>> import dpnp as np
+    >>> x = np.array(3.0)
+    >>> np.atleast_3d(x)
+    array([[[3.]]])
+
+    >>> x = np.arange(3.0)
+    >>> np.atleast_3d(x).shape
+    (1, 3, 1)
+
+    >>> x = np.arange(12.0).reshape(4, 3)
+    >>> np.atleast_3d(x).shape
+    (4, 3, 1)
+
     """
 
-    all_is_array = True
-    arys_desc = []
+    res = []
     for ary in arys:
-        if not dpnp.isscalar(ary):
-            ary_desc = dpnp.get_dpnp_descriptor(
-                ary, copy_when_nondefault_queue=False
+        if not dpnp.is_supported_array_type(ary):
+            raise TypeError(
+                "Each input array must be any of supported type, "
+                f"but got {type(ary)}"
             )
-            if ary_desc:
-                arys_desc.append(ary_desc)
-                continue
-        all_is_array = False
-        break
-
-    if not use_origin_backend(arys[0]) and all_is_array:
-        result = []
-        for ary_desc in arys_desc:
-            res = dpnp_atleast_3d(ary_desc).get_pyobj()
-            result.append(res)
-
-        if len(result) == 1:
-            return result[0]
+        if ary.ndim == 0:
+            result = ary.reshape(1, 1, 1)
+        elif ary.ndim == 1:
+            result = ary[dpnp.newaxis, :, dpnp.newaxis]
+        elif ary.ndim == 2:
+            result = ary[:, :, dpnp.newaxis]
         else:
-            return result
+            result = ary
+        if isinstance(result, dpt.usm_ndarray):
+            result = dpnp_array._create_from_usm_ndarray(result)
+        res.append(result)
+    if len(res) == 1:
+        return res[0]
+    else:
+        return res
+
+
+def broadcast_arrays(*args, subok=False):
+    """
+    Broadcast any number of arrays against each other.
+
+    For full documentation refer to :obj:`numpy.broadcast_arrays`.
+
+    Returns
+    -------
+    broadcasted : list of dpnp.ndarray
+        These arrays are views on the original arrays.
+
+    Limitations
+    -----------
+    Parameter `args` is supported as either :class:`dpnp.ndarray`
+    or :class:`dpctl.tensor.usm_ndarray`.
+    Otherwise ``TypeError`` exception will be raised.
+    Parameter `subok` is supported with default value.
+    Otherwise ``NotImplementedError`` exception will be raised.
+
+    See Also
+    --------
+    :obj:`dpnp.broadcast_to` : Broadcast an array to a new shape.
+
+    Examples
+    --------
+    >>> import dpnp as np
+    >>> x = np.array([[1, 2, 3]])
+    >>> y = np.array([[4], [5]])
+    >>> np.broadcast_arrays(x, y)
+    [array([[1, 2, 3],
+            [1, 2, 3]]), array([[4, 4, 4],
+            [5, 5, 5]])]
+
+    """
 
-    return call_origin(numpy.atleast_3d, *arys)
+    if subok is not False:
+        raise NotImplementedError(f"subok={subok} is currently not supported")
+
+    if len(args) == 0:
+        return []
+
+    dpt_arrays = dpt.broadcast_arrays(
+        *[dpnp.get_usm_ndarray(array) for array in args]
+    )
+    return [
+        dpnp_array._create_from_usm_ndarray(usm_arr) for usm_arr in dpt_arrays
+    ]
 
 
 def broadcast_to(array, /, shape, subok=False):
@@ -268,10 +375,15 @@ def broadcast_to(array, /, shape, subok=False):
     -----------
     Parameter `array` is supported as either :class:`dpnp.ndarray`
     or :class:`dpctl.tensor.usm_ndarray`.
+    Otherwise ``TypeError`` exception will be raised.
     Parameter `subok` is supported with default value.
-    Otherwise the function will be executed sequentially on CPU.
+    Otherwise ``NotImplementedError`` exception will be raised.
     Input array data types of `array` is limited by supported DPNP :ref:`Data types`.
 
+    See Also
+    --------
+    :obj:`dpnp.broadcast_arrays` : Broadcast any number of arrays against each other.
+
     Examples
     --------
     >>> import dpnp as dp
@@ -284,13 +396,52 @@ def broadcast_to(array, /, shape, subok=False):
     """
 
     if subok is not False:
-        pass
-    elif dpnp.is_supported_array_type(array):
-        dpt_array = dpnp.get_usm_ndarray(array)
-        new_array = dpt.broadcast_to(dpt_array, shape)
-        return dpnp_array._create_from_usm_ndarray(new_array)
+        raise NotImplementedError(f"subok={subok} is currently not supported")
+
+    dpt_array = dpnp.get_usm_ndarray(array)
+    new_array = dpt.broadcast_to(dpt_array, shape)
+    return dpnp_array._create_from_usm_ndarray(new_array)
+
+
+def can_cast(from_, to, casting="safe"):
+    """
+    Returns ``True`` if cast between data types can occur according to the casting rule.
+
+    If `from` is a scalar or array scalar, also returns ``True`` if the scalar value can
+    be cast without overflow or truncation to an integer.
+
+    For full documentation refer to :obj:`numpy.can_cast`.
+
+    Parameters
+    ----------
+    from : dpnp.array, dtype
+        Source data type.
+    to : dtype
+        Target data type.
+    casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
+        Controls what kind of data casting may occur.
+
+    Returns
+    -------
+    out: bool
+        True if cast can occur according to the casting rule.
+
+    See Also
+    --------
+    :obj:`dpnp.result_type` : Returns the type that results from applying the NumPy
+        type promotion rules to the arguments.
+
+    """
 
-    return call_origin(numpy.broadcast_to, array, shape=shape, subok=subok)
+    if dpnp.is_supported_array_type(to):
+        raise TypeError("Cannot construct a dtype from an array")
+
+    dtype_from = (
+        from_.dtype
+        if dpnp.is_supported_array_type(from_)
+        else dpnp.dtype(from_)
+    )
+    return dpt.can_cast(dtype_from, to, casting)
 
 
 def concatenate(
@@ -301,19 +452,29 @@ def concatenate(
 
     For full documentation refer to :obj:`numpy.concatenate`.
 
+    Parameters
+    ----------
+    arrays : {dpnp.ndarray, usm_ndarray}
+        The arrays must have the same shape, except in the dimension corresponding
+        to axis (the first, by default).
+    axis : int, optional
+        The axis along which the arrays will be joined. If axis is None, arrays are
+        flattened before use. Default is 0.
+    out : dpnp.ndarray, optional
+        If provided, the destination to place the result. The shape must be correct,
+        matching that of what concatenate would have returned if no out argument were
+        specified.
+    dtype : str or dtype
+        If provided, the destination array will have this dtype. Cannot be provided
+        together with out.
+    casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
+        Controls what kind of data casting may occur. Defaults to 'same_kind'.
+
     Returns
     -------
     out : dpnp.ndarray
         The concatenated array.
 
-    Limitations
-    -----------
-    Each array in `arrays` is supported as either :class:`dpnp.ndarray`
-    or :class:`dpctl.tensor.usm_ndarray`. Otherwise ``TypeError`` exception
-    will be raised.
-    Parameters `out` and `dtype are supported with default value.
-    Otherwise the function will be executed sequentially on CPU.
-
     See Also
     --------
     :obj:`dpnp.array_split` : Split an array into multiple sub-arrays of equal or near-equal size.
@@ -345,25 +506,20 @@ def concatenate(
 
     """
 
-    if out is not None:
-        pass
-    elif dtype is not None:
-        pass
-    elif casting != "same_kind":
-        pass
-    else:
-        usm_arrays = [dpnp.get_usm_ndarray(x) for x in arrays]
-        usm_res = dpt.concat(usm_arrays, axis=axis)
-        return dpnp_array._create_from_usm_ndarray(usm_res)
-
-    return call_origin(
-        numpy.concatenate,
-        arrays,
-        axis=axis,
-        out=out,
-        dtype=dtype,
-        casting=casting,
-    )
+    if dtype is not None and out is not None:
+        raise TypeError(
+            "concatenate() only takes `out` or `dtype` as an argument, but both were provided."
+        )
+
+    usm_arrays = [dpnp.get_usm_ndarray(x) for x in arrays]
+    usm_res = dpt.concat(usm_arrays, axis=axis)
+    res = dpnp_array._create_from_usm_ndarray(usm_res)
+    if dtype is not None:
+        res = res.astype(dtype, casting=casting, copy=False)
+    elif out is not None:
+        dpnp.copyto(out, res, casting=casting)
+        return out
+    return res
 
 
 def copyto(dst, src, casting="same_kind", where=True):
@@ -410,7 +566,7 @@ def copyto(dst, src, casting="same_kind", where=True):
     elif not dpnp.is_supported_array_type(src):
         src = dpnp.array(src, sycl_queue=dst.sycl_queue)
 
-    if not dpt.can_cast(src.dtype, dst.dtype, casting=casting):
+    if not dpnp.can_cast(src.dtype, dst.dtype, casting=casting):
         raise TypeError(
             f"Cannot cast from {src.dtype} to {dst.dtype} "
             f"according to the rule {casting}."
@@ -717,19 +873,21 @@ def hstack(tup, *, dtype=None, casting="same_kind"):
 
     For full documentation refer to :obj:`numpy.hstack`.
 
+    Parameters
+    ----------
+    tup : {dpnp.ndarray, usm_ndarray}
+        The arrays must have the same shape along all but the second axis,
+        except 1-D arrays which can be any length.
+    dtype : str or dtype
+        If provided, the destination array will have this dtype.
+    casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
+        Controls what kind of data casting may occur. Defaults to 'same_kind'.
+
     Returns
     -------
     out : dpnp.ndarray
         The stacked array which has one more dimension than the input arrays.
 
-    Limitations
-    -----------
-    Each array in `tup` is supported as either :class:`dpnp.ndarray`
-    or :class:`dpctl.tensor.usm_ndarray`. Otherwise ``TypeError`` exception
-    will be raised.
-    Parameters `dtype` and `casting` are supported with default value.
-    Otherwise the function will be executed sequentially on CPU.
-
     See Also
     --------
     :obj:`dpnp.concatenate` : Join a sequence of arrays along an existing axis.
@@ -850,10 +1008,10 @@ def repeat(a, repeats, axis=None):
     Limitations
     -----------
     Input array is supported as :obj:`dpnp.ndarray`.
-    Parameter ``axis`` is supported with value either ``None`` or ``0``.
+    Parameter `axis` is supported with value either ``None`` or ``0``.
     Dimension of input array are supported to be less than ``2``.
     Otherwise the function will be executed sequentially on CPU.
-    If ``repeats`` is ``tuple`` or ``list``, should be ``len(repeats) > 1``.
+    If `repeats` is ``tuple`` or ``list``, should be ``len(repeats) > 1``.
     Input array data types are limited by supported DPNP :ref:`Data types`.
 
     .. seealso:: :obj:`numpy.tile` tile an array.
@@ -890,7 +1048,7 @@ def reshape(a, /, newshape, order="C", copy=None):
 
     Parameters
     ----------
-    a : {dpnp_array, usm_ndarray}
+    a : {dpnp.ndarray, usm_ndarray}
         Array to be reshaped.
     newshape : int or tuple of ints
         The new shape should be compatible with the original shape. If
@@ -1206,26 +1364,32 @@ def squeeze(a, /, axis=None):
     )
 
 
-def stack(arrays, /, *, axis=0, out=None, dtype=None, **kwargs):
+def stack(arrays, /, *, axis=0, out=None, dtype=None, casting="same_kind"):
     """
     Join a sequence of arrays along a new axis.
 
     For full documentation refer to :obj:`numpy.stack`.
 
+    Parameters
+    ----------
+    arrays : {dpnp.ndarray, usm_ndarray}
+        Each array must have the same shape.
+    axis : int, optional
+        The axis in the result array along which the input arrays are stacked.
+    out : dpnp.ndarray, optional
+        If provided, the destination to place the result. The shape must be correct,
+        matching that of what stack would have returned if no out argument were specified.
+    dtype : str or dtype
+        If provided, the destination array will have this dtype. Cannot be provided
+        together with out.
+    casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
+        Controls what kind of data casting may occur. Defaults to 'same_kind'.
+
     Returns
     -------
     out : dpnp.ndarray
         The stacked array which has one more dimension than the input arrays.
 
-    Limitations
-    -----------
-    Each array in `arrays` is supported as either :class:`dpnp.ndarray`
-    or :class:`dpctl.tensor.usm_ndarray`. Otherwise ``TypeError`` exception
-    will be raised.
-    Parameters `out` and `dtype` are supported with default value.
-    Keyword argument ``kwargs`` is currently unsupported.
-    Otherwise the function will be executed sequentially on CPU.
-
     See Also
     --------
     :obj:`dpnp.concatenate` : Join a sequence of arrays along an existing axis.
@@ -1258,25 +1422,20 @@ def stack(arrays, /, *, axis=0, out=None, dtype=None, **kwargs):
 
     """
 
-    if kwargs:
-        pass
+    if dtype is not None and out is not None:
+        raise TypeError(
+            "stack() only takes `out` or `dtype` as an argument, but both were provided."
+        )
+
+    usm_arrays = [dpnp.get_usm_ndarray(x) for x in arrays]
+    usm_res = dpt.stack(usm_arrays, axis=axis)
+    res = dpnp_array._create_from_usm_ndarray(usm_res)
+    if dtype is not None:
+        res = res.astype(dtype, casting=casting, copy=False)
     elif out is not None:
-        pass
-    elif dtype is not None:
-        pass
-    else:
-        usm_arrays = [dpnp.get_usm_ndarray(x) for x in arrays]
-        usm_res = dpt.stack(usm_arrays, axis=axis)
-        return dpnp_array._create_from_usm_ndarray(usm_res)
-
-    return call_origin(
-        numpy.stack,
-        arrays,
-        axis=axis,
-        out=out,
-        dtype=dtype,
-        **kwargs,
-    )
+        dpnp.copyto(out, res, casting=casting)
+        return out
+    return res
 
 
 def swapaxes(a, axis1, axis2):
@@ -1332,6 +1491,84 @@ def swapaxes(a, axis1, axis2):
     )
 
 
+def tile(A, reps):
+    """
+    Construct an array by repeating `A` the number of times given by reps.
+
+    If `reps` has length ``d``, the result will have dimension of
+    ``max(d, A.ndim)``.
+
+    If ``A.ndim < d``, `A` is promoted to be d-dimensional by prepending new
+    axes. So a shape (3,) array is promoted to (1, 3) for 2-D replication,
+    or shape (1, 1, 3) for 3-D replication. If this is not the desired
+    behavior, promote `A` to d-dimensions manually before calling this
+    function.
+
+    If ``A.ndim > d``, `reps` is promoted to `A`.ndim by prepending 1's to it.
+    Thus for an `A` of shape (2, 3, 4, 5), a `reps` of (2, 2) is treated as
+    (1, 1, 2, 2).
+
+    Note : Although tile may be used for broadcasting, it is strongly
+    recommended to use dpnp's broadcasting operations and functions.
+
+    For full documentation refer to :obj:`numpy.tile`.
+
+    Parameters
+    ----------
+    A : dpnp.ndarray
+        The input array.
+    reps : array_like
+        The number of repetitions of `A` along each axis.
+
+    Returns
+    -------
+    c : dpnp.ndarray
+        The tiled output array.
+
+    See Also
+    --------
+    :obj:`dpnp.repeat` : Repeat elements of an array.
+    :obj:`dpnp.broadcast_to` : Broadcast an array to a new shape
+
+    Examples
+    --------
+    >>> import dpnp as np
+    >>> a = np.array([0, 1, 2])
+    >>> np.tile(a, 2)
+    array([0, 1, 2, 0, 1, 2])
+
+    >>> np.tile(a, (2, 2))
+    array([[0, 1, 2, 0, 1, 2],
+           [0, 1, 2, 0, 1, 2]])
+
+    >>> np.tile(a, (2, 1, 2))
+    array([[[0, 1, 2, 0, 1, 2]],
+           [[0, 1, 2, 0, 1, 2]]])
+
+    >>> b = np.array([[1, 2], [3, 4]])
+    >>> np.tile(b, 2)
+    array([[1, 2, 1, 2],
+           [3, 4, 3, 4]])
+
+    >>> np.tile(b, (2, 1))
+    array([[1, 2],
+           [3, 4],
+           [1, 2],
+           [3, 4]])
+
+    >>> c = np.array([1, 2, 3, 4])
+    >>> np.tile(c, (4, 1))
+    array([[1, 2, 3, 4],
+           [1, 2, 3, 4],
+           [1, 2, 3, 4],
+           [1, 2, 3, 4]])
+
+    """
+
+    dpt_array = dpnp.get_usm_ndarray(A)
+    return dpnp_array._create_from_usm_ndarray(dpt.tile(dpt_array, reps))
+
+
 def transpose(a, axes=None):
     """
     Returns an array with axes transposed.
@@ -1414,20 +1651,63 @@ def unique(ar, **kwargs):
     return call_origin(numpy.unique, ar, **kwargs)
 
 
-def vstack(tup):
+def vstack(tup, *, dtype=None, casting="same_kind"):
     """
     Stack arrays in sequence vertically (row wise).
 
     For full documentation refer to :obj:`numpy.vstack`.
 
-    """
+    Parameters
+    ----------
+    tup : {dpnp.ndarray, usm_ndarray}
+        The arrays must have the same shape along all but the first axis.
+        1-D arrays must have the same length.
+    dtype : str or dtype
+        If provided, the destination array will have this dtype.
+    casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
+        Controls what kind of data casting may occur. Defaults to 'same_kind'.
+
+    Returns
+    -------
+    out : dpnp.ndarray
+        The array formed by stacking the given arrays, will be at least 2-D.
+
+    See Also
+    --------
+    :obj:`dpnp.concatenate` : Join a sequence of arrays along an existing axis.
+    :obj:`dpnp.stack` : Join a sequence of arrays along a new axis.
+    :obj:`dpnp.hstack` : Stack arrays in sequence horizontally (column wise).
+    :obj:`dpnp.dstack` : Stack arrays in sequence depth wise (along third axis).
+    :obj:`dpnp.column_stack` : Stack 1-D arrays as columns into a 2-D array.
+    :obj:`dpnp.block` : Assemble an nd-array from nested lists of blocks.
+    :obj:`dpnp.split` : Split array into a list of multiple sub-arrays of equal size.
+
+    Examples
+    --------
+    >>> import dpnp as np
+    >>> a = np.array([1, 2, 3])
+    >>> b = np.array([4, 5, 6])
+    >>> np.vstack((a, b))
+    array([[1, 2, 3],
+           [4, 5, 6]])
+
+    >>> a = np.array([[1], [2], [3]])
+    >>> b = np.array([[4], [5], [6]])
+    >>> np.vstack((a, b))
+    array([[1],
+           [2],
+           [3],
+           [4],
+           [5],
+           [6]])
 
-    # TODO:
-    # `call_origin` cannot convert sequence of array to sequence of
-    # nparray
-    tup_new = []
-    for tp in tup:
-        tpx = dpnp.asnumpy(tp) if not isinstance(tp, numpy.ndarray) else tp
-        tup_new.append(tpx)
+    """
 
-    return call_origin(numpy.vstack, tup_new)
+    if not hasattr(tup, "__getitem__"):
+        raise TypeError(
+            "Arrays to stack must be passed as a sequence type such as list or tuple."
+        )
+    arrs = dpnp.atleast_2d(*tup)
+    if not isinstance(arrs, list):
+        arrs = [arrs]
+    return dpnp.concatenate(arrs, axis=0, dtype=dtype, casting=casting)
diff --git a/dpnp/dpnp_iface_mathematical.py b/dpnp/dpnp_iface_mathematical.py
index 82277276824..650c0478e17 100644
--- a/dpnp/dpnp_iface_mathematical.py
+++ b/dpnp/dpnp_iface_mathematical.py
@@ -50,6 +50,7 @@
 from .dpnp_algo import *
 from .dpnp_algo.dpnp_elementwise_common import (
     check_nd_call_func,
+    dpnp_abs,
     dpnp_add,
     dpnp_ceil,
     dpnp_conj,
@@ -57,8 +58,11 @@
     dpnp_floor,
     dpnp_floor_divide,
     dpnp_imag,
+    dpnp_maximum,
+    dpnp_minimum,
     dpnp_multiply,
     dpnp_negative,
+    dpnp_positive,
     dpnp_power,
     dpnp_proj,
     dpnp_real,
@@ -105,6 +109,7 @@
     "nanprod",
     "nansum",
     "negative",
+    "positive",
     "power",
     "prod",
     "proj",
@@ -122,37 +127,22 @@
 ]
 
 
-def abs(*args, **kwargs):
-    """
-    Calculate the absolute value element-wise.
-
-    For full documentation refer to :obj:`numpy.absolute`.
-
-    Notes
-    -----
-    :obj:`dpnp.abs` is a shorthand for :obj:`dpnp.absolute`.
-
-    Examples
-    --------
-    >>> import dpnp as np
-    >>> a = np.array([-1.2, 1.2])
-    >>> result = np.abs(a)
-    >>> [x for x in result]
-    [1.2, 1.2]
-
-    """
-
-    return dpnp.absolute(*args, **kwargs)
-
-
-def absolute(x, /, out=None, *, where=True, dtype=None, subok=True, **kwargs):
+def absolute(
+    x,
+    /,
+    out=None,
+    *,
+    order="K",
+    where=True,
+    dtype=None,
+    subok=True,
+    **kwargs,
+):
     """
     Calculate the absolute value element-wise.
 
     For full documentation refer to :obj:`numpy.absolute`.
 
-    .. seealso:: :obj:`dpnp.abs` : Calculate the absolute value element-wise.
-
     Returns
     -------
     out : dpnp.ndarray
@@ -166,50 +156,43 @@ def absolute(x, /, out=None, *, where=True, dtype=None, subok=True, **kwargs):
     Otherwise the function will be executed sequentially on CPU.
     Input array data types are limited by supported DPNP :ref:`Data types`.
 
+    See Also
+    --------
+    :obj:`dpnp.fabs` : Calculate the absolute value element-wise excluding complex types.
+
+    Notes
+    -----
+    ``dpnp.abs`` is a shorthand for this function.
+
     Examples
     --------
-    >>> import dpnp as dp
-    >>> a = dp.array([-1.2, 1.2])
-    >>> result = dp.absolute(a)
-    >>> [x for x in result]
-    [1.2, 1.2]
+    >>> import dpnp as np
+    >>> a = np.array([-1.2, 1.2])
+    >>> np.absolute(a)
+    array([1.2, 1.2])
 
-    """
+    >>> a = np.array(1.2 + 1j)
+    >>> np.absolute(a)
+    array(1.5620499351813308)
 
-    if out is not None:
-        pass
-    elif where is not True:
-        pass
-    elif dtype is not None:
-        pass
-    elif subok is not True:
-        pass
-    elif dpnp.isscalar(x):
-        pass
-    else:
-        x_desc = dpnp.get_dpnp_descriptor(x, copy_when_nondefault_queue=False)
-        if x_desc:
-            if x_desc.dtype == dpnp.bool:
-                # return a copy of input array "x"
-                return dpnp.array(
-                    x,
-                    dtype=x.dtype,
-                    sycl_queue=x.sycl_queue,
-                    usm_type=x.usm_type,
-                )
-            return dpnp_absolute(x_desc).get_pyobj()
+    """
 
-    return call_origin(
+    return check_nd_call_func(
         numpy.absolute,
+        dpnp_abs,
         x,
         out=out,
         where=where,
+        order=order,
         dtype=dtype,
         subok=subok,
         **kwargs,
     )
 
 
+abs = absolute
+
+
 def add(
     x1,
     x2,
@@ -822,7 +805,7 @@ def fabs(x1, **kwargs):
 
     See Also
     --------
-    :obj:`dpnp.abs` : Calculate the absolute value element-wise.
+    :obj:`dpnp.absolute` : Calculate the absolute value element-wise.
 
     Examples
     --------
@@ -973,46 +956,214 @@ def floor_divide(
     )
 
 
-def fmax(*args, **kwargs):
+def fmax(x1, x2, /, out=None, *, where=True, dtype=None, subok=True, **kwargs):
     """
     Element-wise maximum of array elements.
 
     For full documentation refer to :obj:`numpy.fmax`.
 
+    Returns
+    -------
+    out : dpnp.ndarray
+        The maximum of `x1` and `x2`, element-wise, ignoring NaNs.
+
+    Limitations
+    -----------
+    Parameters `x1` and `x2` are supported as either scalar, :class:`dpnp.ndarray`
+    or :class:`dpctl.tensor.usm_ndarray`, but both `x1` and `x2` can not be scalars at the same time.
+    Parameters `where`, `dtype` and `subok` are supported with their default values.
+    Keyword argument `kwargs` is currently unsupported.
+    Otherwise the function will be executed sequentially on CPU.
+    Input array data types are limited by real-valued data types.
+
     See Also
     --------
-    :obj:`dpnp.maximum` : Element-wise maximum of array elements.
-    :obj:`dpnp.fmin` : Element-wise minimum of array elements.
+    :obj:`dpnp.maximum` : Element-wise maximum of array elements, propagates NaNs.
+    :obj:`dpnp.fmin` : Element-wise minimum of array elements, ignore NaNs.
+    :obj:`dpnp.minimum` : Element-wise minimum of array elements, propagates NaNs.
     :obj:`dpnp.fmod` : Calculate the element-wise remainder of division.
 
-    Notes
-    -----
-    This function works the same as :obj:`dpnp.maximum`
+    Examples
+    --------
+    >>> import dpnp as np
+    >>> x1 = np.array([2, 3, 4])
+    >>> x2 = np.array([1, 5, 2])
+    >>> np.fmax(x1, x2)
+    array([2, 5, 4])
+
+    >>> x1 = np.eye(2)
+    >>> x2 = np.array([0.5, 2])
+    >>> np.fmax(x1, x2) # broadcasting
+    array([[1. , 2. ],
+           [0.5, 2. ]])
+
+    >>> x1 = np.array([np.nan, 0, np.nan])
+    >>> x2 = np.array([0, np.nan, np.nan])
+    >>> np.fmax(x1, x2)
+    array([ 0.,  0., nan])
 
     """
 
-    return dpnp.maximum(*args, **kwargs)
+    if kwargs:
+        pass
+    elif where is not True:
+        pass
+    elif dtype is not None:
+        pass
+    elif subok is not True:
+        pass
+    elif dpnp.isscalar(x1) and dpnp.isscalar(x2):
+        # at least either x1 or x2 has to be an array
+        pass
+    else:
+        # get USM type and queue to copy scalar from the host memory into a USM allocation
+        usm_type, queue = (
+            get_usm_allocations([x1, x2])
+            if dpnp.isscalar(x1) or dpnp.isscalar(x2)
+            else (None, None)
+        )
 
+        x1_desc = dpnp.get_dpnp_descriptor(
+            x1,
+            copy_when_strides=False,
+            copy_when_nondefault_queue=False,
+            alloc_usm_type=usm_type,
+            alloc_queue=queue,
+        )
+        x2_desc = dpnp.get_dpnp_descriptor(
+            x2,
+            copy_when_strides=False,
+            copy_when_nondefault_queue=False,
+            alloc_usm_type=usm_type,
+            alloc_queue=queue,
+        )
+        if x1_desc and x2_desc:
+            if out is not None:
+                if not dpnp.is_supported_array_type(out):
+                    raise TypeError(
+                        "return array must be of supported array type"
+                    )
+                out_desc = (
+                    dpnp.get_dpnp_descriptor(
+                        out, copy_when_nondefault_queue=False
+                    )
+                    or None
+                )
+            else:
+                out_desc = None
 
-def fmin(*args, **kwargs):
+            return dpnp_fmax(
+                x1_desc, x2_desc, dtype=dtype, out=out_desc, where=where
+            ).get_pyobj()
+
+    return call_origin(
+        numpy.fmax, x1, x2, dtype=dtype, out=out, where=where, **kwargs
+    )
+
+
+def fmin(x1, x2, /, out=None, *, where=True, dtype=None, subok=True, **kwargs):
     """
     Element-wise minimum of array elements.
 
     For full documentation refer to :obj:`numpy.fmin`.
 
+    Returns
+    -------
+    out : dpnp.ndarray
+        The minimum of `x1` and `x2`, element-wise, ignoring NaNs.
+
+    Limitations
+    -----------
+    Parameters `x1` and `x2` are supported as either scalar, :class:`dpnp.ndarray`
+    or :class:`dpctl.tensor.usm_ndarray`, but both `x1` and `x2` can not be scalars at the same time.
+    Parameters `where`, `dtype` and `subok` are supported with their default values.
+    Keyword argument `kwargs` is currently unsupported.
+    Otherwise the function will be executed sequentially on CPU.
+    Input array data types are limited by real-valued data types.
+
     See Also
     --------
-    :obj:`dpnp.maximum` : Element-wise maximum of array elements.
-    :obj:`dpnp.fmax` : Element-wise maximum of array elements.
+    :obj:`dpnp.minimum` : Element-wise minimum of array elements, propagates NaNs.
+    :obj:`dpnp.fmax` : Element-wise maximum of array elements, ignore NaNs.
+    :obj:`dpnp.maximum` : Element-wise maximum of array elements, propagates NaNs.
     :obj:`dpnp.fmod` : Calculate the element-wise remainder of division.
 
-    Notes
-    -----
-    This function works the same as :obj:`dpnp.minimum`
+    Examples
+    --------
+    >>> import dpnp as np
+    >>> x1 = np.array([2, 3, 4])
+    >>> x2 = np.array([1, 5, 2])
+    >>> np.fmin(x1, x2)
+    array([1, 3, 2])
+
+    >>> x1 = np.eye(2)
+    >>> x2 = np.array([0.5, 2])
+    >>> np.fmin(x1, x2) # broadcasting
+    array([[0.5, 0. ],
+           [0. , 1. ]]
+
+    >>> x1 = np.array([np.nan, 0, np.nan])
+    >>> x2 = np.array([0, np.nan, np.nan])
+    >>> np.fmin(x1, x2)
+    array([ 0.,  0., nan])
 
     """
 
-    return dpnp.minimum(*args, **kwargs)
+    if kwargs:
+        pass
+    elif where is not True:
+        pass
+    elif dtype is not None:
+        pass
+    elif subok is not True:
+        pass
+    elif dpnp.isscalar(x1) and dpnp.isscalar(x2):
+        # at least either x1 or x2 has to be an array
+        pass
+    else:
+        # get USM type and queue to copy scalar from the host memory into a USM allocation
+        usm_type, queue = (
+            get_usm_allocations([x1, x2])
+            if dpnp.isscalar(x1) or dpnp.isscalar(x2)
+            else (None, None)
+        )
+
+        x1_desc = dpnp.get_dpnp_descriptor(
+            x1,
+            copy_when_strides=False,
+            copy_when_nondefault_queue=False,
+            alloc_usm_type=usm_type,
+            alloc_queue=queue,
+        )
+        x2_desc = dpnp.get_dpnp_descriptor(
+            x2,
+            copy_when_strides=False,
+            copy_when_nondefault_queue=False,
+            alloc_usm_type=usm_type,
+            alloc_queue=queue,
+        )
+        if x1_desc and x2_desc:
+            if out is not None:
+                if not dpnp.is_supported_array_type(out):
+                    raise TypeError(
+                        "return array must be of supported array type"
+                    )
+                out_desc = (
+                    dpnp.get_dpnp_descriptor(
+                        out, copy_when_nondefault_queue=False
+                    )
+                    or None
+                )
+            else:
+                out_desc = None
+
+            return dpnp_fmin(
+                x1_desc, x2_desc, dtype=dtype, out=out_desc, where=where
+            ).get_pyobj()
+
+    return call_origin(
+        numpy.fmin, x1, x2, dtype=dtype, out=out, where=where, **kwargs
+    )
 
 
 def fmod(x1, x2, /, out=None, *, where=True, dtype=None, subok=True, **kwargs):
@@ -1138,8 +1289,8 @@ def gradient(x1, *varargs, **kwargs):
     Otherwise the function will be executed sequentially on CPU.
     Input array data types are limited by supported DPNP :ref:`Data types`.
 
-    Example
-    -------
+    Examples
+    --------
     >>> import dpnp as np
     >>> y = np.array([1, 2, 4, 7, 11, 16], dtype=float)
     >>> result = np.gradient(y)
@@ -1213,7 +1364,16 @@ def imag(x):
 
 
 def maximum(
-    x1, x2, /, out=None, *, where=True, dtype=None, subok=True, **kwargs
+    x1,
+    x2,
+    /,
+    out=None,
+    *,
+    where=True,
+    order="K",
+    dtype=None,
+    subok=True,
+    **kwargs,
 ):
     """
     Element-wise maximum of array elements.
@@ -1223,7 +1383,7 @@ def maximum(
     Returns
     -------
     out : dpnp.ndarray
-        The maximum of `x1` and `x2`, element-wise.
+        The maximum of `x1` and `x2`, element-wise, propagating NaNs.
 
     Limitations
     -----------
@@ -1244,8 +1404,8 @@ def maximum(
     :obj:`dpnp.amix` : The minimum value of an array along a given axis, propagates NaNs.
     :obj:`dpnp.nanmix` : The minimum value of an array along a given axis, ignores NaNs.
 
-    Example
-    -------
+    Examples
+    --------
     >>> import dpnp as np
     >>> x1 = np.array([2, 3, 4])
     >>> x2 = np.array([1, 5, 2])
@@ -1261,72 +1421,38 @@ def maximum(
     >>> x1 = np.array([np.nan, 0, np.nan])
     >>> x2 = np.array([0, np.nan, np.nan])
     >>> np.maximum(x1, x2)
-    array([ 0.,  0., nan])
+    array([nan, nan, nan])
 
     >>> np.maximum(np.array(np.Inf), 1)
     array(inf)
 
     """
 
-    if kwargs:
-        pass
-    elif where is not True:
-        pass
-    elif dtype is not None:
-        pass
-    elif subok is not True:
-        pass
-    elif dpnp.isscalar(x1) and dpnp.isscalar(x2):
-        # at least either x1 or x2 has to be an array
-        pass
-    else:
-        # get USM type and queue to copy scalar from the host memory into a USM allocation
-        usm_type, queue = (
-            get_usm_allocations([x1, x2])
-            if dpnp.isscalar(x1) or dpnp.isscalar(x2)
-            else (None, None)
-        )
-
-        x1_desc = dpnp.get_dpnp_descriptor(
-            x1,
-            copy_when_strides=False,
-            copy_when_nondefault_queue=False,
-            alloc_usm_type=usm_type,
-            alloc_queue=queue,
-        )
-        x2_desc = dpnp.get_dpnp_descriptor(
-            x2,
-            copy_when_strides=False,
-            copy_when_nondefault_queue=False,
-            alloc_usm_type=usm_type,
-            alloc_queue=queue,
-        )
-        if x1_desc and x2_desc:
-            if out is not None:
-                if not dpnp.is_supported_array_type(out):
-                    raise TypeError(
-                        "return array must be of supported array type"
-                    )
-                out_desc = (
-                    dpnp.get_dpnp_descriptor(
-                        out, copy_when_nondefault_queue=False
-                    )
-                    or None
-                )
-            else:
-                out_desc = None
-
-            return dpnp_maximum(
-                x1_desc, x2_desc, dtype=dtype, out=out_desc, where=where
-            ).get_pyobj()
-
-    return call_origin(
-        numpy.maximum, x1, x2, dtype=dtype, out=out, where=where, **kwargs
+    return check_nd_call_func(
+        numpy.maximum,
+        dpnp_maximum,
+        x1,
+        x2,
+        out=out,
+        where=where,
+        order=order,
+        dtype=dtype,
+        subok=subok,
+        **kwargs,
     )
 
 
 def minimum(
-    x1, x2, /, out=None, *, where=True, dtype=None, subok=True, **kwargs
+    x1,
+    x2,
+    /,
+    out=None,
+    *,
+    where=True,
+    order="K",
+    dtype=None,
+    subok=True,
+    **kwargs,
 ):
     """
     Element-wise minimum of array elements.
@@ -1336,7 +1462,7 @@ def minimum(
     Returns
     -------
     out : dpnp.ndarray
-        The minimum of `x1` and `x2`, element-wise.
+        The minimum of `x1` and `x2`, element-wise, propagating NaNs.
 
     Limitations
     -----------
@@ -1357,8 +1483,8 @@ def minimum(
     :obj:`dpnp.amax` : The maximum value of an array along a given axis, propagates NaNs.
     :obj:`dpnp.nanmax` : The maximum value of an array along a given axis, ignores NaNs.
 
-    Example
-    -------
+    Examples
+    --------
     >>> import dpnp as np
     >>> x1 = np.array([2, 3, 4])
     >>> x2 = np.array([1, 5, 2])
@@ -1374,67 +1500,24 @@ def minimum(
     >>> x1 = np.array([np.nan, 0, np.nan])
     >>> x2 = np.array([0, np.nan, np.nan])
     >>> np.minimum(x1, x2)
-    array([ 0.,  0., nan])
+    array([nan, nan, nan])
 
     >>> np.minimum(np.array(-np.Inf), 1)
     array(-inf)
 
     """
 
-    if kwargs:
-        pass
-    elif where is not True:
-        pass
-    elif dtype is not None:
-        pass
-    elif subok is not True:
-        pass
-    elif dpnp.isscalar(x1) and dpnp.isscalar(x2):
-        # at least either x1 or x2 has to be an array
-        pass
-    else:
-        # get USM type and queue to copy scalar from the host memory into a USM allocation
-        usm_type, queue = (
-            get_usm_allocations([x1, x2])
-            if dpnp.isscalar(x1) or dpnp.isscalar(x2)
-            else (None, None)
-        )
-
-        x1_desc = dpnp.get_dpnp_descriptor(
-            x1,
-            copy_when_strides=False,
-            copy_when_nondefault_queue=False,
-            alloc_usm_type=usm_type,
-            alloc_queue=queue,
-        )
-        x2_desc = dpnp.get_dpnp_descriptor(
-            x2,
-            copy_when_strides=False,
-            copy_when_nondefault_queue=False,
-            alloc_usm_type=usm_type,
-            alloc_queue=queue,
-        )
-        if x1_desc and x2_desc:
-            if out is not None:
-                if not dpnp.is_supported_array_type(out):
-                    raise TypeError(
-                        "return array must be of supported array type"
-                    )
-                out_desc = (
-                    dpnp.get_dpnp_descriptor(
-                        out, copy_when_nondefault_queue=False
-                    )
-                    or None
-                )
-            else:
-                out_desc = None
-
-            return dpnp_minimum(
-                x1_desc, x2_desc, dtype=dtype, out=out_desc, where=where
-            ).get_pyobj()
-
-    return call_origin(
-        numpy.minimum, x1, x2, dtype=dtype, out=out, where=where, **kwargs
+    return check_nd_call_func(
+        numpy.minimum,
+        dpnp_minimum,
+        x1,
+        x2,
+        out=out,
+        where=where,
+        order=order,
+        dtype=dtype,
+        subok=subok,
+        **kwargs,
     )
 
 
@@ -1741,7 +1824,7 @@ def negative(
     **kwargs,
 ):
     """
-    Negative element-wise.
+    Numerical negative, element-wise.
 
     For full documentation refer to :obj:`numpy.negative`.
 
@@ -1760,6 +1843,7 @@ def negative(
 
     See Also
     --------
+    :obj:`dpnp.positive` : Return the numerical positive of each element of `x`.
     :obj:`dpnp.copysign` : Change the sign of `x1` to that of `x2`, element-wise.
 
     Examples
@@ -1789,6 +1873,71 @@ def negative(
     )
 
 
+def positive(
+    x,
+    /,
+    out=None,
+    *,
+    order="K",
+    where=True,
+    dtype=None,
+    subok=True,
+    **kwargs,
+):
+    """
+    Numerical positive, element-wise.
+
+    For full documentation refer to :obj:`numpy.positive`.
+
+    Returns
+    -------
+    out : dpnp.ndarray
+        The numerical positive of each element of `x`.
+
+    Limitations
+    -----------
+    Parameters `x` is only supported as either :class:`dpnp.ndarray` or :class:`dpctl.tensor.usm_ndarray`.
+    Parameters `where`, `dtype` and `subok` are supported with their default values.
+    Keyword argument `kwargs` is currently unsupported.
+    Otherwise the function will be executed sequentially on CPU.
+    Input array data types are limited by supported DPNP :ref:`Data types`.
+
+    See Also
+    --------
+    :obj:`dpnp.negative` : Return the numerical negative of each element of `x`.
+    :obj:`dpnp.copysign` : Change the sign of `x1` to that of `x2`, element-wise.
+
+    Note
+    ----
+    Equivalent to `x.copy()`, but only defined for types that support arithmetic.
+
+    Examples
+    --------
+    >>> import dpnp as np
+    >>> np.positive(np.array([1., -1.]))
+    array([ 1., -1.])
+
+    The ``+`` operator can be used as a shorthand for ``positive`` on
+    :class:`dpnp.ndarray`.
+
+    >>> x = np.array([1., -1.])
+    >>> +x
+    array([ 1., -1.])
+    """
+
+    return check_nd_call_func(
+        numpy.positive,
+        dpnp_positive,
+        x,
+        out=out,
+        where=where,
+        order=order,
+        dtype=dtype,
+        subok=subok,
+        **kwargs,
+    )
+
+
 def power(
     x1,
     x2,
@@ -1830,8 +1979,8 @@ def power(
     :obj:`dpnp.fmod` : Calculate the element-wise remainder of division.
 
 
-    Example
-    -------
+    Examples
+    --------
     >>> import dpnp as dp
     >>> a = dp.arange(6)
     >>> dp.power(a, 3)
@@ -1973,7 +2122,7 @@ def proj(
 
     See Also
     --------
-    :obj:`dpnp.abs` : Returns the magnitude of a complex number, element-wise.
+    :obj:`dpnp.absolute` : Returns the magnitude of a complex number, element-wise.
     :obj:`dpnp.conj` : Return the complex conjugate, element-wise.
 
     Examples
@@ -2091,8 +2240,8 @@ def remainder(
     :obj:`dpnp.floor_divide` : Compute the largest integer smaller or equal to the division of the inputs.
     :obj:`dpnp.mod` : Calculate the element-wise remainder of division.
 
-    Example
-    -------
+    Examples
+    --------
     >>> import dpnp as np
     >>> np.remainder(np.array([4, 7]), np.array([2, 3]))
     array([0, 1])
@@ -2392,8 +2541,8 @@ def subtract(
     Otherwise the function will be executed sequentially on CPU.
     Input array data types are limited by supported DPNP :ref:`Data types`.
 
-    Example
-    -------
+    Examples
+    --------
     >>> import dpnp as np
     >>> np.subtract(dp.array([4, 3]), np.array([2, 7]))
     array([ 2, -4])
diff --git a/dpnp/dpnp_iface_searching.py b/dpnp/dpnp_iface_searching.py
index bb19e547fe3..26fc1528a0f 100644
--- a/dpnp/dpnp_iface_searching.py
+++ b/dpnp/dpnp_iface_searching.py
@@ -61,8 +61,8 @@ def argmax(x1, axis=None, out=None):
     -----------
     Input array is supported as :obj:`dpnp.ndarray`.
     Otherwise the function will be executed sequentially on CPU.
-    Parameter ``axis`` is supported only with default value ``None``.
-    Parameter ``out`` is supported only with default value ``None``.
+    Parameter `axis` is supported only with default value ``None``.
+    Parameter `out` is supported only with default value ``None``.
     Input array data types are limited by supported DPNP :ref:`Data types`.
 
     See Also
@@ -116,8 +116,8 @@ def argmin(x1, axis=None, out=None):
     -----------
     Input array is supported as :obj:`dpnp.ndarray`.
     Otherwise the function will be executed sequentially on CPU.
-    Parameter ``axis`` is supported only with default value ``None``.
-    Parameter ``out`` is supported only with default value ``None``.
+    Parameter `axis` is supported only with default value ``None``.
+    Parameter `out` is supported only with default value ``None``.
     Input array data types are limited by supported DPNP :ref:`Data types`.
 
     See Also
diff --git a/dpnp/dpnp_iface_sorting.py b/dpnp/dpnp_iface_sorting.py
index c02fbddd8d2..6e7c116a913 100644
--- a/dpnp/dpnp_iface_sorting.py
+++ b/dpnp/dpnp_iface_sorting.py
@@ -59,9 +59,9 @@ def argsort(in_array1, axis=-1, kind=None, order=None):
     -----------
     Input array is supported as :obj:`dpnp.ndarray`.
     Otherwise the function will be executed sequentially on CPU.
-    Prameters ``axis`` is supported only with default value ``-1``.
-    Prameters ``kind`` is supported only with default value ``None``.
-    Prameters ``order`` is supported only with default value ``None``.
+    Parameter `axis` is supported only with default value ``-1``.
+    Parameter `kind` is supported only with default value ``None``.
+    Parameter `order` is supported only with default value ``None``.
     Input array data types are limited by supported DPNP :ref:`Data types`.
 
     See Also
@@ -108,7 +108,8 @@ def partition(x1, kth, axis=-1, kind="introselect", order=None):
     -----------
     Input array is supported as :obj:`dpnp.ndarray`.
     Input kth is supported as :obj:`int`.
-    Parameters ``axis``, ``kind`` and ``order`` are supported only with default values.
+    Parameters `axis`, `kind` and `order` are supported only with default values.
+
     """
 
     x1_desc = dpnp.get_dpnp_descriptor(x1, copy_when_nondefault_queue=False)
@@ -142,7 +143,8 @@ def searchsorted(x1, x2, side="left", sorter=None):
     Input arrays is supported as :obj:`dpnp.ndarray`.
     Input array is supported only sorted.
     Input side is supported only values ``left``, ``right``.
-    Parameters ``sorter`` is supported only with default values.
+    Parameter `sorter` is supported only with default values.
+
     """
 
     x1_desc = dpnp.get_dpnp_descriptor(x1, copy_when_nondefault_queue=False)
diff --git a/dpnp/dpnp_iface_statistics.py b/dpnp/dpnp_iface_statistics.py
index 2594901039f..c7254ad6d01 100644
--- a/dpnp/dpnp_iface_statistics.py
+++ b/dpnp/dpnp_iface_statistics.py
@@ -136,9 +136,9 @@ def average(x1, axis=None, weights=None, returned=False):
     Limitations
     -----------
     Input array is supported as :obj:`dpnp.ndarray`.
-    Prameters ``axis`` is supported only with default value ``None``.
-    Prameters ``weights`` is supported only with default value ``None``.
-    Prameters ``returned`` is supported only with default value ``False``.
+    Parameter `axis` is supported only with default value ``None``.
+    Parameter `weights` is supported only with default value ``None``.
+    Parameter `returned` is supported only with default value ``False``.
     Otherwise the function will be executed sequentially on CPU.
     Input array data types are limited by supported DPNP :ref:`Data types`.
 
@@ -206,7 +206,7 @@ def correlate(x1, x2, mode="valid"):
     -----------
     Input arrays are supported as :obj:`dpnp.ndarray`.
     Size and shape of input arrays are supported to be equal.
-    Prameters ``mode`` is supported only with default value ``"valid``.
+    Parameter `mode` is supported only with default value ``"valid``.
     Otherwise the function will be executed sequentially on CPU.
     Input array data types are limited by supported DPNP :ref:`Data types`.
 
@@ -267,11 +267,11 @@ def cov(
     Input array ``m`` is supported as :obj:`dpnp.ndarray`.
     Dimension of input array ``m`` is limited by ``m.ndim <= 2``.
     Size and shape of input arrays are supported to be equal.
-    Prameters ``y`` is supported only with default value ``None``.
-    Prameters ``bias`` is supported only with default value ``False``.
-    Prameters ``ddof`` is supported only with default value ``None``.
-    Prameters ``fweights`` is supported only with default value ``None``.
-    Prameters ``aweights`` is supported only with default value ``None``.
+    Parameter `y` is supported only with default value ``None``.
+    Parameter `bias` is supported only with default value ``False``.
+    Parameter `ddof` is supported only with default value ``None``.
+    Parameter `fweights` is supported only with default value ``None``.
+    Parameter `aweights` is supported only with default value ``None``.
     Otherwise the function will be executed sequentially on CPU.
     Input array data types are limited by supported DPNP :ref:`Data types`.
 
@@ -360,7 +360,7 @@ def max(x1, axis=None, out=None, keepdims=False, initial=None, where=True):
     -----------
     Input array is supported as :obj:`dpnp.ndarray`.
     Otherwise the function will be executed sequentially on CPU.
-    Prameters ``out`` is supported only with default value ``None``.
+    Parameter `out` is supported only with default value ``None``.
     Input array data types are limited by supported DPNP :ref:`Data types`.
 
     Examples
@@ -523,10 +523,10 @@ def median(x1, axis=None, out=None, overwrite_input=False, keepdims=False):
     Limitations
     -----------
     Input array is supported as :obj:`dpnp.ndarray`.
-    Prameters ``axis`` is supported only with default value ``None``.
-    Prameters ``out`` is supported only with default value ``None``.
-    Prameters ``overwrite_input`` is supported only with default value ``False``.
-    Prameters ``keepdims`` is supported only with default value ``False``.
+    Parameter `axis` is supported only with default value ``None``.
+    Parameter `out` is supported only with default value ``None``.
+    Parameter `overwrite_input` is supported only with default value ``False``.
+    Parameter `keepdims` is supported only with default value ``False``.
     Otherwise the function will be executed sequentially on CPU.
     Input array data types are limited by supported DPNP :ref:`Data types`.
 
@@ -572,7 +572,7 @@ def min(x1, axis=None, out=None, keepdims=False, initial=None, where=True):
     -----------
     Input array is supported as :obj:`dpnp.ndarray`.
     Otherwise the function will be executed sequentially on CPU.
-    Prameters ``out`` is supported only with default value ``None``.
+    Parameter `out` is supported only with default value ``None``.
     Input array data types are limited by supported DPNP :ref:`Data types`.
 
     Examples
@@ -616,10 +616,10 @@ def nanvar(x1, axis=None, dtype=None, out=None, ddof=0, keepdims=False):
     Limitations
     -----------
     Input array is supported as :obj:`dpnp.ndarray`.
-    Prameters ``axis`` is supported only with default value ``None``.
-    Prameters ``dtype`` is supported only with default value ``None``.
-    Prameters ``out`` is supported only with default value ``None``.
-    Prameters ``keepdims`` is supported only with default value ``numpy._NoValue``.
+    Parameter `axis` is supported only with default value ``None``.
+    Parameter `dtype` is supported only with default value ``None``.
+    Parameter `out` is supported only with default value ``None``.
+    Parameter `keepdims` is supported only with default value ``numpy._NoValue``.
     Otherwise the function will be executed sequentially on CPU.
     """
 
@@ -662,10 +662,10 @@ def std(x1, axis=None, dtype=None, out=None, ddof=0, keepdims=False):
     -----------
     Input array is supported as :obj:`dpnp.ndarray`.
     Size of input array is limited by ``a.size > 0``.
-    Prameters ``axis`` is supported only with default value ``None``.
-    Prameters ``dtype`` is supported only with default value ``None``.
-    Prameters ``out`` is supported only with default value ``None``.
-    Prameters ``keepdims`` is supported only with default value ``numpy._NoValue``.
+    Parameter `axis` is supported only with default value ``None``.
+    Parameter `dtype` is supported only with default value ``None``.
+    Parameter `out` is supported only with default value ``None``.
+    Parameter `keepdims` is supported only with default value ``numpy._NoValue``.
     Otherwise the function will be executed sequentially on CPU.
     Input array data types are limited by supported DPNP :ref:`Data types`.
 
@@ -720,10 +720,10 @@ def var(x1, axis=None, dtype=None, out=None, ddof=0, keepdims=False):
     -----------
     Input array is supported as :obj:`dpnp.ndarray`.
     Size of input array is limited by ``a.size > 0``.
-    Prameters ``axis`` is supported only with default value ``None``.
-    Prameters ``dtype`` is supported only with default value ``None``.
-    Prameters ``out`` is supported only with default value ``None``.
-    Prameters ``keepdims`` is supported only with default value ``numpy._NoValue``.
+    Parameter `axis` is supported only with default value ``None``.
+    Parameter `dtype` is supported only with default value ``None``.
+    Parameter `out` is supported only with default value ``None``.
+    Parameter `keepdims` is supported only with default value ``numpy._NoValue``.
     Otherwise the function will be executed sequentially on CPU.
     Input array data types are limited by supported DPNP :ref:`Data types`.
 
diff --git a/dpnp/dpnp_iface_trigonometric.py b/dpnp/dpnp_iface_trigonometric.py
index 3ed6de42e99..608639f0030 100644
--- a/dpnp/dpnp_iface_trigonometric.py
+++ b/dpnp/dpnp_iface_trigonometric.py
@@ -57,7 +57,14 @@
     dpnp_atanh,
     dpnp_cos,
     dpnp_cosh,
+    dpnp_exp,
+    dpnp_expm1,
+    dpnp_hypot,
     dpnp_log,
+    dpnp_log1p,
+    dpnp_log2,
+    dpnp_log10,
+    dpnp_logaddexp,
     dpnp_sin,
     dpnp_sinh,
     dpnp_sqrt,
@@ -87,6 +94,7 @@
     "log10",
     "log1p",
     "log2",
+    "logaddexp",
     "rad2deg",
     "radians",
     "reciprocal",
@@ -723,15 +731,33 @@ def degrees(x1):
     return call_origin(numpy.degrees, x1, **kwargs)
 
 
-def exp(x1, out=None, **kwargs):
+def exp(
+    x,
+    /,
+    out=None,
+    *,
+    order="K",
+    where=True,
+    dtype=None,
+    subok=True,
+    **kwargs,
+):
     """
     Calculate the exponential, element-wise.
 
     For full documentation refer to :obj:`numpy.exp`.
 
+    Returns
+    -------
+    out : dpnp.ndarray
+        The exponential of `x`, element-wise.
+
     Limitations
     -----------
-    Input array is supported as :obj:`dpnp.ndarray`.
+    Parameter `x` is only supported as either :class:`dpnp.ndarray` or :class:`dpctl.tensor.usm_ndarray`.
+    Parameters `where`, `dtype` and `subok` are supported with their default values.
+    Keyword argument `kwargs` is currently unsupported.
+    Otherwise the function will be executed sequentially on CPU.
     Input array data types are limited by supported DPNP :ref:`Data types`.
 
     See Also
@@ -743,24 +769,22 @@ def exp(x1, out=None, **kwargs):
     --------
     >>> import dpnp as np
     >>> x = np.arange(3.)
-    >>> out = np.exp(x)
-    >>> [i for i in out]
-    [1.0, 2.718281828, 7.389056099]
+    >>> np.exp(x)
+    array([1.0, 2.718281828, 7.389056099])
 
     """
 
-    x1_desc = dpnp.get_dpnp_descriptor(
-        x1, copy_when_strides=False, copy_when_nondefault_queue=False
+    return check_nd_call_func(
+        numpy.exp,
+        dpnp_exp,
+        x,
+        out=out,
+        where=where,
+        order=order,
+        dtype=dtype,
+        subok=subok,
+        **kwargs,
     )
-    if x1_desc:
-        out_desc = (
-            dpnp.get_dpnp_descriptor(out, copy_when_nondefault_queue=False)
-            if out is not None
-            else None
-        )
-        return dpnp_exp(x1_desc, out_desc).get_pyobj()
-
-    return call_origin(numpy.exp, x1, out=out, **kwargs)
 
 
 def exp2(x1):
@@ -798,39 +822,81 @@ def exp2(x1):
     return call_origin(numpy.exp2, x1)
 
 
-def expm1(x1):
+def expm1(
+    x,
+    /,
+    out=None,
+    *,
+    order="K",
+    where=True,
+    dtype=None,
+    subok=True,
+    **kwargs,
+):
     """
     Return the exponential of the input array minus one, element-wise.
 
     For full documentation refer to :obj:`numpy.expm1`.
 
+    Returns
+    -------
+    out : dpnp.ndarray
+        The exponential of `x` minus one, element-wise.
+
     Limitations
     -----------
-    Input array is supported as :obj:`dpnp.ndarray`.
+    Parameter `x` is only supported as either :class:`dpnp.ndarray` or :class:`dpctl.tensor.usm_ndarray`.
+    Parameters `where`, `dtype` and `subok` are supported with their default values.
+    Keyword argument `kwargs` is currently unsupported.
+    Otherwise the function will be executed sequentially on CPU.
     Input array data types are limited by supported DPNP :ref:`Data types`.
 
-    .. seealso:: :obj:`dpnp.log1p` ``log(1 + x)``, the inverse of expm1.
+    See Also
+    --------
+    :obj:`dpnp.exp` : Calculate exponential for all elements in the array.
+    :obj:`dpnp.exp2` : Calculate `2**x` for all elements in the array.
+    :obj:`dpnp.log1p` : Callculate ``log(1 + x)``, the inverse of expm1.
 
     Examples
     --------
     >>> import dpnp as np
     >>> x = np.arange(3.)
-    >>> out = np.expm1(x)
-    >>> [i for i in out]
-    [0.0, 1.718281828, 6.389056099]
+    >>> np.expm1(x)
+    array([0.0, 1.718281828, 6.389056099])
+
+    >>> np.expm1(np.array(1e-10))
+    array(1.00000000005e-10)
+
+    >>> np.exp(np.array(1e-10)) - 1
+    array(1.000000082740371e-10)
 
     """
 
-    x1_desc = dpnp.get_dpnp_descriptor(
-        x1, copy_when_strides=False, copy_when_nondefault_queue=False
+    return check_nd_call_func(
+        numpy.expm1,
+        dpnp_expm1,
+        x,
+        out=out,
+        where=where,
+        order=order,
+        dtype=dtype,
+        subok=subok,
+        **kwargs,
     )
-    if x1_desc:
-        return dpnp_expm1(x1_desc).get_pyobj()
 
-    return call_origin(numpy.expm1, x1)
 
-
-def hypot(x1, x2, /, out=None, *, where=True, dtype=None, subok=True, **kwargs):
+def hypot(
+    x1,
+    x2,
+    /,
+    out=None,
+    *,
+    where=True,
+    order="K",
+    dtype=None,
+    subok=True,
+    **kwargs,
+):
     """
     Given the "legs" of a right triangle, return its hypotenuse.
 
@@ -848,7 +914,7 @@ def hypot(x1, x2, /, out=None, *, where=True, dtype=None, subok=True, **kwargs):
     Parameters `where`, `dtype` and `subok` are supported with their default values.
     Keyword argument `kwargs` is currently unsupported.
     Otherwise the function will be executed sequentially on CPU.
-    Input array data types are limited by supported DPNP :ref:`Data types`.
+    Input array data types are limited by supported real-valued data types.
 
     Examples
     --------
@@ -869,60 +935,17 @@ def hypot(x1, x2, /, out=None, *, where=True, dtype=None, subok=True, **kwargs):
 
     """
 
-    if kwargs:
-        pass
-    elif where is not True:
-        pass
-    elif dtype is not None:
-        pass
-    elif subok is not True:
-        pass
-    elif dpnp.isscalar(x1) and dpnp.isscalar(x2):
-        # at least either x1 or x2 has to be an array
-        pass
-    else:
-        # get USM type and queue to copy scalar from the host memory into a USM allocation
-        usm_type, queue = (
-            get_usm_allocations([x1, x2])
-            if dpnp.isscalar(x1) or dpnp.isscalar(x2)
-            else (None, None)
-        )
-
-        x1_desc = dpnp.get_dpnp_descriptor(
-            x1,
-            copy_when_strides=False,
-            copy_when_nondefault_queue=False,
-            alloc_usm_type=usm_type,
-            alloc_queue=queue,
-        )
-        x2_desc = dpnp.get_dpnp_descriptor(
-            x2,
-            copy_when_strides=False,
-            copy_when_nondefault_queue=False,
-            alloc_usm_type=usm_type,
-            alloc_queue=queue,
-        )
-        if x1_desc and x2_desc:
-            if out is not None:
-                if not dpnp.is_supported_array_type(out):
-                    raise TypeError(
-                        "return array must be of supported array type"
-                    )
-                out_desc = (
-                    dpnp.get_dpnp_descriptor(
-                        out, copy_when_nondefault_queue=False
-                    )
-                    or None
-                )
-            else:
-                out_desc = None
-
-            return dpnp_hypot(
-                x1_desc, x2_desc, dtype=dtype, out=out_desc, where=where
-            ).get_pyobj()
-
-    return call_origin(
-        numpy.hypot, x1, x2, dtype=dtype, out=out, where=where, **kwargs
+    return check_nd_call_func(
+        numpy.hypot,
+        dpnp_hypot,
+        x1,
+        x2,
+        out=out,
+        where=where,
+        order=order,
+        dtype=dtype,
+        subok=subok,
+        **kwargs,
     )
 
 
@@ -987,106 +1010,252 @@ def log(
     )
 
 
-def log10(x1):
+def log10(
+    x,
+    /,
+    out=None,
+    *,
+    order="K",
+    where=True,
+    dtype=None,
+    subok=True,
+    **kwargs,
+):
     """
     Return the base 10 logarithm of the input array, element-wise.
 
     For full documentation refer to :obj:`numpy.log10`.
 
+    Returns
+    -------
+    out : dpnp.ndarray
+        The base 10 logarithm of `x`, element-wise.
+
     Limitations
     -----------
-    Input array is supported as :obj:`dpnp.ndarray`.
+    Parameter `x` is only supported as either :class:`dpnp.ndarray` or :class:`dpctl.tensor.usm_ndarray`.
+    Parameters `where`, `dtype` and `subok` are supported with their default values.
+    Keyword argument `kwargs` is currently unsupported.
+    Otherwise the function will be executed sequentially on CPU.
     Input array data types are limited by supported DPNP :ref:`Data types`.
 
+    See Also
+    --------
+    :obj:`dpnp.log` : Natural logarithm, element-wise.
+    :obj:`dpnp.log2` : Return the base 2 logarithm of the input array, element-wise.
+    :obj:`dpnp.log1p` : Return the natural logarithm of one plus the input array, element-wise.
+
     Examples
     --------
     >>> import dpnp as np
     >>> x = np.arange(3.)
-    >>> out = np.log10(x)
-    >>> [i for i in out]
-    [-inf, 0.0, 0.30102999566]
+    >>> np.log10(x)
+    array([-inf, 0.0, 0.30102999566])
+
+    >>> np.log10(np.array([1e-15, -3.]))
+    array([-15.,  nan])
 
     """
 
-    x1_desc = dpnp.get_dpnp_descriptor(
-        x1, copy_when_strides=False, copy_when_nondefault_queue=False
+    return check_nd_call_func(
+        numpy.log10,
+        dpnp_log10,
+        x,
+        out=out,
+        where=where,
+        order=order,
+        dtype=dtype,
+        subok=subok,
+        **kwargs,
     )
-    if x1_desc:
-        return dpnp_log10(x1_desc).get_pyobj()
-
-    return call_origin(numpy.log10, x1)
 
 
-def log1p(x1):
+def log1p(
+    x,
+    /,
+    out=None,
+    *,
+    order="K",
+    where=True,
+    dtype=None,
+    subok=True,
+    **kwargs,
+):
     """
     Return the natural logarithm of one plus the input array, element-wise.
 
     For full documentation refer to :obj:`numpy.log1p`.
 
+    Returns
+    -------
+    out : dpnp.ndarray
+        The natural logarithm of `1+x`, element-wise.
+
     Limitations
     -----------
-    Input array is supported as :obj:`dpnp.ndarray`.
+    Parameter `x` is only supported as either :class:`dpnp.ndarray` or :class:`dpctl.tensor.usm_ndarray`.
+    Parameters `where`, `dtype` and `subok` are supported with their default values.
+    Keyword argument `kwargs` is currently unsupported.
+    Otherwise the function will be executed sequentially on CPU.
     Input array data types are limited by supported DPNP :ref:`Data types`.
 
     See Also
     --------
     :obj:`dpnp.expm1` : ``exp(x) - 1``, the inverse of :obj:`dpnp.log1p`.
+    :obj:`dpnp.log` : Natural logarithm, element-wise.
+    :obj:`dpnp.log10` : Return the base 10 logarithm of the input array, element-wise.
+    :obj:`dpnp.log2` : Return the base 2 logarithm of the input array, element-wise.
 
     Examples
     --------
     >>> import dpnp as np
     >>> x = np.arange(3.)
-    >>> out = np.log1p(x)
-    >>> [i for i in out]
-    [0.0, 0.69314718, 1.09861229]
+    >>> np.log1p(x)
+    array([0.0, 0.69314718, 1.09861229])
+
+    >>> np.log1p(array(1e-99))
+    array(1e-99)
+
+    >>> np.log(array(1 + 1e-99))
+    array(0.0)
 
     """
 
-    x1_desc = dpnp.get_dpnp_descriptor(
-        x1, copy_when_strides=False, copy_when_nondefault_queue=False
+    return check_nd_call_func(
+        numpy.log1p,
+        dpnp_log1p,
+        x,
+        out=out,
+        where=where,
+        order=order,
+        dtype=dtype,
+        subok=subok,
+        **kwargs,
     )
-    if x1_desc:
-        return dpnp_log1p(x1_desc).get_pyobj()
-
-    return call_origin(numpy.log1p, x1)
 
 
-def log2(x1):
+def log2(
+    x,
+    /,
+    out=None,
+    *,
+    order="K",
+    where=True,
+    dtype=None,
+    subok=True,
+    **kwargs,
+):
     """
     Return the base 2 logarithm of the input array, element-wise.
 
     For full documentation refer to :obj:`numpy.log2`.
 
+    Returns
+    -------
+    out : dpnp.ndarray
+        The base 2 logarithm of `x`, element-wise.
+
     Limitations
     -----------
-    Input array is supported as :obj:`dpnp.ndarray`.
+    Parameter `x` is only supported as either :class:`dpnp.ndarray` or :class:`dpctl.tensor.usm_ndarray`.
+    Parameters `where`, `dtype` and `subok` are supported with their default values.
+    Keyword argument `kwargs` is currently unsupported.
+    Otherwise the function will be executed sequentially on CPU.
     Input array data types are limited by supported DPNP :ref:`Data types`.
 
     See Also
     --------
     :obj:`dpnp.log` : Natural logarithm, element-wise.
-    :obj:`dpnp.log10` : Return the base 10 logarithm of the input array,
-                        element-wise.
-    :obj:`dpnp.log1p` : Return the natural logarithm of one plus
-                        the input array, element-wise.
+    :obj:`dpnp.log10` : Return the base 10 logarithm of the input array, element-wise.
+    :obj:`dpnp.log1p` : Return the natural logarithm of one plus the input array, element-wise.
 
     Examples
     --------
     >>> import dpnp as np
     >>> x = np.array([0, 1, 2, 2**4])
-    >>> out = np.log2(x)
-    >>> [i for i in out]
-    [-inf, 0.0, 1.0, 4.0]
+    >>> np.log2(x)
+    array([-inf, 0.0, 1.0, 4.0])
+
+    >>> xi = np.array([0+1.j, 1, 2+0.j, 4.j])
+    >>> np.log2(xi)
+    array([ 0.+2.26618007j,  0.+0.j        ,  1.+0.j        ,  2.+2.26618007j])
 
     """
 
-    x1_desc = dpnp.get_dpnp_descriptor(
-        x1, copy_when_strides=False, copy_when_nondefault_queue=False
+    return check_nd_call_func(
+        numpy.log2,
+        dpnp_log2,
+        x,
+        out=out,
+        where=where,
+        order=order,
+        dtype=dtype,
+        subok=subok,
+        **kwargs,
     )
-    if x1_desc:
-        return dpnp_log2(x1_desc).get_pyobj()
 
-    return call_origin(numpy.log2, x1)
+
+def logaddexp(
+    x1,
+    x2,
+    /,
+    out=None,
+    *,
+    where=True,
+    order="K",
+    dtype=None,
+    subok=True,
+    **kwargs,
+):
+    """
+    Calculates ``log(exp(x1) + exp(x2))``, element-wise.
+
+    For full documentation refer to :obj:`numpy.logaddexp`.
+
+    Returns
+    -------
+    out : dpnp.ndarray
+        Logarithm of ``exp(x1) + exp(x2)``, element-wise.
+
+    Limitations
+    -----------
+    Parameters `x1` and `x2` are supported as either scalar, :class:`dpnp.ndarray`
+    or :class:`dpctl.tensor.usm_ndarray`, but both `x1` and `x2` can not be scalars at the same time.
+    Parameters `where`, `dtype` and `subok` are supported with their default values.
+    Keyword arguments `kwargs` are currently unsupported.
+    Otherwise the function will be executed sequentially on CPU.
+    Input array data types are limited by supported DPNP :ref:`Data types`.
+
+    See Also
+    --------
+    :obj:`dpnp.log` : Natural logarithm, element-wise.
+    :obj:`dpnp.exp` : Exponential, element-wise.
+
+    Examples
+    --------
+    >>> import dpnp as np
+    >>> prob1 = np.log(np.array(1e-50))
+    >>> prob2 = np.log(np.array(2.5e-50))
+    >>> prob12 = np.logaddexp(prob1, prob2)
+    >>> prob12
+    array(-113.87649168)
+    >>> np.exp(prob12)
+    array(3.5e-50)
+
+    """
+
+    return check_nd_call_func(
+        numpy.logaddexp,
+        dpnp_logaddexp,
+        x1,
+        x2,
+        out=out,
+        where=where,
+        order=order,
+        dtype=dtype,
+        subok=subok,
+        **kwargs,
+    )
 
 
 def reciprocal(x1, **kwargs):
diff --git a/dpnp/dpnp_iface_types.py b/dpnp/dpnp_iface_types.py
index 68da06583fe..69a713f26d4 100644
--- a/dpnp/dpnp_iface_types.py
+++ b/dpnp/dpnp_iface_types.py
@@ -34,8 +34,11 @@
 This module provides public type interface file for the library
 """
 
+import dpctl.tensor as dpt
 import numpy
 
+from dpnp.dpnp_array import dpnp_array
+
 __all__ = [
     "bool",
     "bool_",
@@ -50,12 +53,14 @@
     "dtype",
     "e",
     "euler_gamma",
+    "finfo",
     "float",
     "float_",
     "float16",
     "float32",
     "float64",
     "floating",
+    "iinfo",
     "inexact",
     "Inf",
     "inf",
@@ -67,6 +72,7 @@
     "int64",
     "integer",
     "intc",
+    "intp",
     "isscalar",
     "issubdtype",
     "issubsctype",
@@ -114,6 +120,7 @@
 int64 = numpy.int64
 integer = numpy.integer
 intc = numpy.intc
+intp = numpy.intp
 number = numpy.number
 signedinteger = numpy.signedinteger
 single = numpy.single
@@ -140,6 +147,85 @@
 PZERO = numpy.PZERO
 
 
+def finfo(dtype):
+    """
+    Returns machine limits for floating-point data types.
+
+    For full documentation refer to :obj:`numpy.finfo`.
+
+    Parameters
+    ----------
+    dtype : dtype, dpnp_array
+        Floating-point dtype or an array with floating point data type.
+        If complex, the information is about its component data type.
+
+    Returns
+    -------
+    out : finfo_object
+        An object have the following attributes
+        * bits: int
+            number of bits occupied by dtype.
+        * dtype: dtype
+            real-valued floating-point data type.
+        * eps: float
+            difference between 1.0 and the next smallest representable
+            real-valued floating-point number larger than 1.0 according
+            to the IEEE-754 standard.
+        * epsneg: float
+            difference between 1.0 and the next smallest representable real-valued
+            floating-point number smaller than 1.0 according to the IEEE-754
+            standard.
+        * max: float
+            largest representable real-valued number.
+        * min: float
+            smallest representable real-valued number.
+        * precision: float
+            the approximate number of decimal digits to which this kind of
+            floating point type is precise.
+        * resolution: float
+            the approximate decimal resolution of this type.
+        * tiny: float
+            an alias for `smallest_normal`
+        * smallest_normal: float
+            smallest positive real-valued floating-point number with
+            full precision.
+
+    """
+    if isinstance(dtype, dpnp_array):
+        dtype = dtype.dtype
+    return dpt.finfo(dtype)
+
+
+def iinfo(dtype):
+    """
+    Returns machine limits for integer data types.
+
+    For full documentation refer to :obj:`numpy.iinfo`.
+
+    Parameters
+    ----------
+    dtype : dtype, dpnp_array
+        Integer dtype or an array with integer dtype.
+
+    Returns
+    -------
+    out : iinfo_object
+        An object with the following attributes
+        * bits: int
+            number of bits occupied by the data type
+        * dtype: dtype
+            integer data type.
+        * max: int
+            largest representable number.
+        * min: int
+            smallest representable number.
+
+    """
+    if isinstance(dtype, dpnp_array):
+        dtype = dtype.dtype
+    return dpt.iinfo(dtype)
+
+
 def isscalar(obj):
     """
     Returns True if the type of `obj` is a scalar type.
diff --git a/dpnp/dpnp_utils/dpnp_algo_utils.pyx b/dpnp/dpnp_utils/dpnp_algo_utils.pyx
index 9ec9174d400..aca73463a91 100644
--- a/dpnp/dpnp_utils/dpnp_algo_utils.pyx
+++ b/dpnp/dpnp_utils/dpnp_algo_utils.pyx
@@ -28,7 +28,7 @@
 
 """Module Utilities
 
-This module contains differnt helpers and utilities
+This module contains different helpers and utilities
 
 """
 
@@ -129,7 +129,7 @@ def call_origin(function, *args, **kwargs):
     allow_fallback = kwargs.pop("allow_fallback", False)
 
     if not allow_fallback and config.__DPNP_RAISE_EXCEPION_ON_NUMPY_FALLBACK__ == 1:
-        raise NotImplementedError(f"Requested funtion={function.__name__} with args={args} and kwargs={kwargs} "
+        raise NotImplementedError(f"Requested function={function.__name__} with args={args} and kwargs={kwargs} "
                                    "isn't currently supported and would fall back on NumPy implementation. "
                                    "Define environment variable `DPNP_RAISE_EXCEPION_ON_NUMPY_FALLBACK` to `0` "
                                    "if the fall back is required to be supported without raising an exception.")
@@ -166,7 +166,7 @@ def call_origin(function, *args, **kwargs):
     exec_q = dpu.get_execution_queue(alloc_queues)
     if exec_q is None:
         exec_q = dpnp.get_normalized_queue_device(sycl_queue=sycl_queue)
-    # print(f"DPNP call_origin(): bakend called. \n\t function={function}, \n\t args_new={args_new}, \n\t kwargs_new={kwargs_new}, \n\t dpnp_inplace={dpnp_inplace}")
+    # print(f"DPNP call_origin(): backend called. \n\t function={function}, \n\t args_new={args_new}, \n\t kwargs_new={kwargs_new}, \n\t dpnp_inplace={dpnp_inplace}")
     # TODO need to put array memory into NumPy call
     result_origin = function(*args_new, **kwargs_new)
     # print(f"DPNP call_origin(): result from backend. \n\t result_origin={result_origin}, \n\t args_new={args_new}, \n\t kwargs_new={kwargs_new}, \n\t dpnp_inplace={dpnp_inplace}")
@@ -255,7 +255,7 @@ def get_usm_allocations(objects):
     Given a list of objects returns a tuple of USM type and SYCL queue
     which can be used for a memory allocation and to follow compute follows data paradigm,
     or returns `(None, None)` if the default USM type and SYCL queue can be used.
-    An exception will be raised, if the paradigm is broked for the given list of objects.
+    An exception will be raised, if the paradigm is broken for the given list of objects.
 
     """
 
@@ -333,7 +333,7 @@ cpdef checker_throw_type_error(function_name, given_type):
 cpdef checker_throw_value_error(function_name, param_name, param, expected):
     # import sys
     # sys.tracebacklimit = 0
-    err_msg = f"{ERROR_PREFIX} in function {function_name}() paramenter '{param_name}'"
+    err_msg = f"{ERROR_PREFIX} in function {function_name}() parameter '{param_name}'"
     err_msg += f" expected `{expected}`, but '{param}' provided"
     raise ValueError(err_msg)
 
@@ -682,18 +682,18 @@ cdef (DPNPFuncType, void *) get_ret_type_and_func(DPNPFuncData kernel_data,
 
 cdef class dpnp_descriptor:
     def __init__(self, obj, dpnp_descriptor orig_desc=None):
-        """ Initialze variables """
+        """ Initialize variables """
         self.origin_pyobj = None
         self.origin_desc = None
         self.descriptor = None
         self.dpnp_descriptor_data_size = 0
         self.dpnp_descriptor_is_scalar = True
 
-        """ Accure DPCTL data container storage """
+        """ Acquire DPCTL data container storage """
         self.descriptor = getattr(obj, "__sycl_usm_array_interface__", None)
         if self.descriptor is None:
 
-            """ Accure main data storage """
+            """ Acquire main data storage """
             self.descriptor = getattr(obj, "__array_interface__", None)
             if self.descriptor is None:
                 return
diff --git a/dpnp/fft/dpnp_algo_fft.pyx b/dpnp/fft/dpnp_algo_fft.pyx
index b751354a1e0..0ffb4b032ce 100644
--- a/dpnp/fft/dpnp_algo_fft.pyx
+++ b/dpnp/fft/dpnp_algo_fft.pyx
@@ -74,7 +74,7 @@ cpdef utils.dpnp_descriptor dpnp_fft(utils.dpnp_descriptor input,
     cdef DPNPFuncType return_type = ret_type_and_func[0]
     cdef fptr_dpnp_fft_fft_t func = < fptr_dpnp_fft_fft_t > ret_type_and_func[1]
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(output_shape,
                                                                        return_type,
                                                                        None,
@@ -133,7 +133,7 @@ cpdef utils.dpnp_descriptor dpnp_rfft(utils.dpnp_descriptor input,
     cdef DPNPFuncType return_type = ret_type_and_func[0]
     cdef fptr_dpnp_fft_fft_t func = < fptr_dpnp_fft_fft_t > ret_type_and_func[1]
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(output_shape,
                                                                        return_type,
                                                                        None,
diff --git a/dpnp/fft/dpnp_iface_fft.py b/dpnp/fft/dpnp_iface_fft.py
index 0e1a5a98223..c82b3609649 100644
--- a/dpnp/fft/dpnp_iface_fft.py
+++ b/dpnp/fft/dpnp_iface_fft.py
@@ -818,7 +818,7 @@ def rfftfreq(n=None, d=1.0):
 
     Limitations
     -----------
-    Parameter ``d`` is unsupported.
+    Parameter `d` is unsupported.
 
     """
 
diff --git a/dpnp/linalg/dpnp_algo_linalg.pyx b/dpnp/linalg/dpnp_algo_linalg.pyx
index f5ddbc678fb..31eff554dc2 100644
--- a/dpnp/linalg/dpnp_algo_linalg.pyx
+++ b/dpnp/linalg/dpnp_algo_linalg.pyx
@@ -88,7 +88,7 @@ cpdef utils.dpnp_descriptor dpnp_cholesky(utils.dpnp_descriptor input_):
 
     input_obj = input_.get_array()
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(input_.shape,
                                                                        kernel_data.return_type,
                                                                        None,
@@ -152,7 +152,7 @@ cpdef utils.dpnp_descriptor dpnp_det(utils.dpnp_descriptor input):
 
     input_obj = input.get_array()
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape,
                                                                        kernel_data.return_type,
                                                                        None,
@@ -242,7 +242,7 @@ cpdef utils.dpnp_descriptor dpnp_eigvals(utils.dpnp_descriptor input):
     cdef DPNPFuncType return_type = ret_type_and_func[0]
     cdef custom_linalg_1in_1out_with_size_func_ptr_t_ func = < custom_linalg_1in_1out_with_size_func_ptr_t_ > ret_type_and_func[1]
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef utils.dpnp_descriptor res_val = utils.create_output_descriptor((size,),
                                                                          return_type,
                                                                          None,
@@ -282,7 +282,7 @@ cpdef utils.dpnp_descriptor dpnp_inv(utils.dpnp_descriptor input):
     cdef DPNPFuncType return_type = ret_type_and_func[0]
     cdef custom_linalg_1in_1out_func_ptr_t func = < custom_linalg_1in_1out_func_ptr_t > ret_type_and_func[1]
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(input_shape,
                                                                        return_type,
                                                                        None,
@@ -316,7 +316,7 @@ cpdef utils.dpnp_descriptor dpnp_matrix_rank(utils.dpnp_descriptor input):
 
     input_obj = input.get_array()
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor((1,),
                                                                        kernel_data.return_type,
                                                                        None,
diff --git a/dpnp/linalg/dpnp_utils_linalg.py b/dpnp/linalg/dpnp_utils_linalg.py
index e818835ecbe..54c01c20248 100644
--- a/dpnp/linalg/dpnp_utils_linalg.py
+++ b/dpnp/linalg/dpnp_utils_linalg.py
@@ -45,7 +45,7 @@ def dpnp_eigh(a, UPLO):
     Return the eigenvalues and eigenvectors of a complex Hermitian
     (conjugate symmetric) or a real symmetric matrix.
 
-    The main calculation is done by calling an extention function
+    The main calculation is done by calling an extension function
     for LAPACK library of OneMKL. Depending on input type of `a` array,
     it will be either ``heevd`` (for complex types) or ``syevd`` (for others).
 
diff --git a/dpnp/random/dpnp_algo_random.pyx b/dpnp/random/dpnp_algo_random.pyx
index e9206bd6682..5fb1e4ae00d 100644
--- a/dpnp/random/dpnp_algo_random.pyx
+++ b/dpnp/random/dpnp_algo_random.pyx
@@ -298,7 +298,7 @@ cdef class _Engine:
         if sycl_queue is None:
             raise ValueError("SyclQueue isn't defined")
 
-        # keep a refference on SYCL queue
+        # keep a reference on SYCL queue
         self.q = <c_dpctl.SyclQueue> sycl_queue
         self.q_ref = c_dpctl.DPCTLQueue_Copy((self.q).get_queue_ref())
         if self.q_ref is NULL:
@@ -344,7 +344,7 @@ cdef class _Engine:
         # get the FPTR data structure
         kernel_data = get_dpnp_function_ptr(DPNP_FN_RNG_NORMAL_EXT, param1_type, param1_type)
 
-        # ceate result array with type given by FPTR data
+        # create result array with type given by FPTR data
         result = utils.create_output_descriptor(result_shape,
                                                 kernel_data.return_type,
                                                 None,
@@ -379,7 +379,7 @@ cdef class _Engine:
         # get the FPTR data structure
         kernel_data = get_dpnp_function_ptr(DPNP_FN_RNG_UNIFORM_EXT, param1_type, param1_type)
 
-        # ceate result array with type given by FPTR data
+        # create result array with type given by FPTR data
         result = utils.create_output_descriptor(result_shape,
                                                 kernel_data.return_type,
                                                 None,
@@ -462,7 +462,7 @@ cdef class MT19937(_Engine):
         if value < 0:
             return False
 
-        max_val = numpy.iinfo(numpy.uint32).max
+        max_val = dpnp.iinfo(numpy.uint32).max
         if isinstance(value, dpnp_array):
             max_val = dpnp.array(max_val, dtype=numpy.uint32)
         return value <= max_val
@@ -499,7 +499,7 @@ cdef class MCG59(_Engine):
         if value < 0:
             return False
 
-        max_val = numpy.iinfo(numpy.uint64).max
+        max_val = dpnp.iinfo(numpy.uint64).max
         if isinstance(value, dpnp_array):
             max_val = dpnp.array(max_val, dtype=numpy.uint64)
         return value <= max_val
@@ -519,7 +519,7 @@ cpdef utils.dpnp_descriptor dpnp_rng_beta(double a, double b, size):
     # get the FPTR data structure
     cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_RNG_BETA_EXT, param1_type, param1_type)
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef shape_type_c result_shape = utils._object_to_tuple(size)
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape, kernel_data.return_type, None)
 
@@ -558,7 +558,7 @@ cpdef utils.dpnp_descriptor dpnp_rng_binomial(int ntrial, double p, size):
     # get the FPTR data structure
     kernel_data = get_dpnp_function_ptr(DPNP_FN_RNG_BINOMIAL_EXT, param1_type, param1_type)
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef shape_type_c result_shape = utils._object_to_tuple(size)
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape, kernel_data.return_type, None)
 
@@ -591,7 +591,7 @@ cpdef utils.dpnp_descriptor dpnp_rng_chisquare(int df, size):
     # get the FPTR data structure
     cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_RNG_CHISQUARE_EXT, param1_type, param1_type)
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef shape_type_c result_shape = utils._object_to_tuple(size)
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape, kernel_data.return_type, None)
 
@@ -626,7 +626,7 @@ cpdef utils.dpnp_descriptor dpnp_rng_exponential(double beta, size):
     # get the FPTR data structure
     cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_RNG_EXPONENTIAL_EXT, param1_type, param1_type)
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef shape_type_c result_shape = utils._object_to_tuple(size)
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape, kernel_data.return_type, None)
 
@@ -659,7 +659,7 @@ cpdef utils.dpnp_descriptor dpnp_rng_f(double df_num, double df_den, size):
     # get the FPTR data structure
     cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_RNG_F_EXT, param1_type, param1_type)
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef shape_type_c result_shape = utils._object_to_tuple(size)
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape, kernel_data.return_type, None)
 
@@ -695,7 +695,7 @@ cpdef utils.dpnp_descriptor dpnp_rng_gamma(double shape, double scale, size):
 
     kernel_data = get_dpnp_function_ptr(DPNP_FN_RNG_GAMMA_EXT, param1_type, param1_type)
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef shape_type_c result_shape = utils._object_to_tuple(size)
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape, kernel_data.return_type, None)
 
@@ -734,7 +734,7 @@ cpdef utils.dpnp_descriptor dpnp_rng_geometric(float p, size):
     # get the FPTR data structure
     kernel_data = get_dpnp_function_ptr(DPNP_FN_RNG_GEOMETRIC_EXT, param1_type, param1_type)
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef shape_type_c result_shape = utils._object_to_tuple(size)
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape, kernel_data.return_type, None)
 
@@ -769,7 +769,7 @@ cpdef utils.dpnp_descriptor dpnp_rng_gumbel(double loc, double scale, size):
     param1_type = dpnp_dtype_to_DPNPFuncType(dtype)
     kernel_data = get_dpnp_function_ptr(DPNP_FN_RNG_GUMBEL_EXT, param1_type, param1_type)
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef shape_type_c result_shape = utils._object_to_tuple(size)
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape, kernel_data.return_type, None)
 
@@ -807,7 +807,7 @@ cpdef utils.dpnp_descriptor dpnp_rng_hypergeometric(int l, int s, int m, size):
     # get the FPTR data structure
     kernel_data = get_dpnp_function_ptr(DPNP_FN_RNG_HYPERGEOMETRIC_EXT, param1_type, param1_type)
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef shape_type_c result_shape = utils._object_to_tuple(size)
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape, kernel_data.return_type, None)
 
@@ -845,7 +845,7 @@ cpdef utils.dpnp_descriptor dpnp_rng_laplace(double loc, double scale, size):
     # get the FPTR data structure
     kernel_data = get_dpnp_function_ptr(DPNP_FN_RNG_LAPLACE_EXT, param1_type, param1_type)
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef shape_type_c result_shape = utils._object_to_tuple(size)
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape, kernel_data.return_type, None)
 
@@ -878,7 +878,7 @@ cpdef utils.dpnp_descriptor dpnp_rng_logistic(double loc, double scale, size):
     # get the FPTR data structure
     cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_RNG_LOGISTIC_EXT, param1_type, param1_type)
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef shape_type_c result_shape = utils._object_to_tuple(size)
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape, kernel_data.return_type, None)
 
@@ -916,7 +916,7 @@ cpdef utils.dpnp_descriptor dpnp_rng_lognormal(double mean, double stddev, size)
     # get the FPTR data structure
     kernel_data = get_dpnp_function_ptr(DPNP_FN_RNG_LOGNORMAL_EXT, param1_type, param1_type)
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef shape_type_c result_shape = utils._object_to_tuple(size)
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape, kernel_data.return_type, None)
 
@@ -958,7 +958,7 @@ cpdef utils.dpnp_descriptor dpnp_rng_multinomial(int ntrial, utils.dpnp_descript
     # get the FPTR data structure
     kernel_data = get_dpnp_function_ptr(DPNP_FN_RNG_MULTINOMIAL_EXT, param1_type, param1_type)
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef shape_type_c result_shape = utils._object_to_tuple(size)
 
     p_obj = p.get_array()
@@ -1011,7 +1011,7 @@ cpdef utils.dpnp_descriptor dpnp_rng_multivariate_normal(utils.dpnp_descriptor m
     # get the FPTR data structure
     kernel_data = get_dpnp_function_ptr(DPNP_FN_RNG_MULTIVARIATE_NORMAL, param1_type, param1_type)
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef shape_type_c result_shape = utils._object_to_tuple(size)
     result_sycl_device, result_usm_type, result_sycl_queue = utils.get_common_usm_allocation(mean, cov)
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape,
@@ -1052,7 +1052,7 @@ cpdef utils.dpnp_descriptor dpnp_rng_negative_binomial(double a, double p, size)
 
     result_shape = utils._object_to_tuple(size)
     if p == 0.0:
-        filled_val = numpy.iinfo(dtype).min
+        filled_val = dpnp.iinfo(dtype).min
         return utils.dpnp_descriptor(dpnp.full(result_shape, filled_val, dtype=dtype))
     elif p == 1.0:
         return utils.dpnp_descriptor(dpnp.full(result_shape, 0, dtype=dtype))
@@ -1063,7 +1063,7 @@ cpdef utils.dpnp_descriptor dpnp_rng_negative_binomial(double a, double p, size)
         # get the FPTR data structure
         kernel_data = get_dpnp_function_ptr(DPNP_FN_RNG_NEGATIVE_BINOMIAL_EXT, param1_type, param1_type)
 
-        # ceate result array with type given by FPTR data
+        # create result array with type given by FPTR data
         result = utils.create_output_descriptor(result_shape, kernel_data.return_type, None)
 
         result_sycl_queue = result.get_array().sycl_queue
@@ -1095,7 +1095,7 @@ cpdef utils.dpnp_descriptor dpnp_rng_noncentral_chisquare(double df, double nonc
     # get the FPTR data structure
     cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_RNG_NONCENTRAL_CHISQUARE_EXT, param1_type, param1_type)
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef shape_type_c result_shape = utils._object_to_tuple(size)
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape, kernel_data.return_type, None)
 
@@ -1129,7 +1129,7 @@ cpdef utils.dpnp_descriptor dpnp_rng_pareto(double alpha, size):
     # get the FPTR data structure
     cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_RNG_PARETO_EXT, param1_type, param1_type)
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef shape_type_c result_shape = utils._object_to_tuple(size)
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape, kernel_data.return_type, None)
 
@@ -1177,7 +1177,7 @@ cpdef utils.dpnp_descriptor dpnp_rng_poisson(double lam, size):
         # get the FPTR data structure
         kernel_data = get_dpnp_function_ptr(DPNP_FN_RNG_POISSON_EXT, param1_type, param1_type)
 
-        # ceate result array with type given by FPTR data
+        # create result array with type given by FPTR data
         result = utils.create_output_descriptor(result_shape, kernel_data.return_type, None)
 
         result_sycl_queue = result.get_array().sycl_queue
@@ -1209,7 +1209,7 @@ cpdef utils.dpnp_descriptor dpnp_rng_power(double alpha, size):
     # get the FPTR data structure
     cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_RNG_POWER_EXT, param1_type, param1_type)
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef shape_type_c result_shape = utils._object_to_tuple(size)
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape, kernel_data.return_type, None)
 
@@ -1256,7 +1256,7 @@ cpdef utils.dpnp_descriptor dpnp_rng_rayleigh(double scale, size):
         # get the FPTR data structure
         kernel_data = get_dpnp_function_ptr(DPNP_FN_RNG_RAYLEIGH_EXT, param1_type, param1_type)
 
-        # ceate result array with type given by FPTR data
+        # create result array with type given by FPTR data
         result = utils.create_output_descriptor(result_shape, kernel_data.return_type, None)
 
         result_sycl_queue = result.get_array().sycl_queue
@@ -1335,7 +1335,7 @@ cpdef utils.dpnp_descriptor dpnp_rng_standard_cauchy(size):
     # get the FPTR data structure
     cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_RNG_STANDARD_CAUCHY_EXT, param1_type, param1_type)
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef shape_type_c result_shape = utils._object_to_tuple(size)
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape, kernel_data.return_type, None)
 
@@ -1370,7 +1370,7 @@ cpdef utils.dpnp_descriptor dpnp_rng_standard_exponential(size):
     # get the FPTR data structure
     cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_RNG_STANDARD_EXPONENTIAL_EXT, param1_type, param1_type)
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef shape_type_c result_shape = utils._object_to_tuple(size)
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape, kernel_data.return_type, None)
 
@@ -1417,7 +1417,7 @@ cpdef utils.dpnp_descriptor dpnp_rng_standard_gamma(double shape, size):
         # get the FPTR data structure
         kernel_data = get_dpnp_function_ptr(DPNP_FN_RNG_STANDARD_GAMMA_EXT, param1_type, param1_type)
 
-        # ceate result array with type given by FPTR data
+        # create result array with type given by FPTR data
         result = utils.create_output_descriptor(result_shape, kernel_data.return_type, None)
 
         result_sycl_queue = result.get_array().sycl_queue
@@ -1449,7 +1449,7 @@ cpdef utils.dpnp_descriptor dpnp_rng_standard_t(double df, size):
     # get the FPTR data structure
     cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_RNG_STANDARD_T_EXT, param1_type, param1_type)
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef shape_type_c result_shape = utils._object_to_tuple(size)
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape, kernel_data.return_type, None)
 
@@ -1483,7 +1483,7 @@ cpdef utils.dpnp_descriptor dpnp_rng_triangular(double left, double mode, double
     # get the FPTR data structure
     cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_RNG_TRIANGULAR_EXT, param1_type, param1_type)
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef shape_type_c result_shape = utils._object_to_tuple(size)
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape, kernel_data.return_type, None)
 
@@ -1516,7 +1516,7 @@ cpdef utils.dpnp_descriptor dpnp_rng_vonmises(double mu, double kappa, size):
     # get the FPTR data structure
     cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_RNG_VONMISES_EXT, param1_type, param1_type)
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef shape_type_c result_shape = utils._object_to_tuple(size)
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape, kernel_data.return_type, None)
 
@@ -1550,7 +1550,7 @@ cpdef utils.dpnp_descriptor dpnp_rng_wald(double mean, double scale, size):
     # get the FPTR data structure
     cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_RNG_WALD_EXT, param1_type, param1_type)
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef shape_type_c result_shape = utils._object_to_tuple(size)
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape, kernel_data.return_type, None)
 
@@ -1588,7 +1588,7 @@ cpdef utils.dpnp_descriptor dpnp_rng_weibull(double a, size):
     # get the FPTR data structure
     kernel_data = get_dpnp_function_ptr(DPNP_FN_RNG_WEIBULL_EXT, param1_type, param1_type)
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef shape_type_c result_shape = utils._object_to_tuple(size)
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape, kernel_data.return_type, None)
 
@@ -1621,7 +1621,7 @@ cpdef utils.dpnp_descriptor dpnp_rng_zipf(double a, size):
     # get the FPTR data structure
     cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_RNG_ZIPF_EXT, param1_type, param1_type)
 
-    # ceate result array with type given by FPTR data
+    # create result array with type given by FPTR data
     cdef shape_type_c result_shape = utils._object_to_tuple(size)
     cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape, kernel_data.return_type, None)
 
diff --git a/dpnp/random/dpnp_iface_random.py b/dpnp/random/dpnp_iface_random.py
index 7a7f981f094..1f2137a0807 100644
--- a/dpnp/random/dpnp_iface_random.py
+++ b/dpnp/random/dpnp_iface_random.py
@@ -127,7 +127,7 @@ def beta(a, b, size=None):
 
     Limitations
     -----------
-    Parameters ``a`` and ``b`` are supported as scalar.
+    Parameters `a` and `b` are supported as scalar.
     Otherwise, :obj:`numpy.random.beta(a, b, size)` samples are drawn.
     Output array data type is :obj:`dpnp.float64`.
 
@@ -166,7 +166,7 @@ def binomial(n, p, size=None):
     Limitations
     -----------
     Output array data type is :obj:`dpnp.int32`.
-    Parameters ``n`` and ``p`` are supported as scalar.
+    Parameters `n` and `p` are supported as scalar.
     Otherwise, :obj:`numpy.random.binomial(n, p, size)` samples are drawn.
 
     Examples
@@ -228,7 +228,7 @@ def chisquare(df, size=None):
 
     Limitations
     -----------
-    Parameter ``df`` is supported as a scalar.
+    Parameter `df` is supported as a scalar.
     Otherwise, :obj:`numpy.random.chisquare(df, size)` samples are drawn.
     Output array data type is default float type.
 
@@ -296,7 +296,7 @@ def exponential(scale=1.0, size=None):
 
     Limitations
     -----------
-    Parameter ``scale`` is supported as a scalar.
+    Parameter `scale` is supported as a scalar.
     Otherwise, :obj:`numpy.random.exponential(scale, size)` samples are drawn.
     Output array data type is :obj:`dpnp.float64`.
 
@@ -330,9 +330,10 @@ def f(dfnum, dfden, size=None):
 
     Limitations
     -----------
-    Parameters ``dfnum`` and ``dfden`` are supported as scalar.
+    Parameters `dfnum` and `dfden` are supported as scalar.
     Otherwise, :obj:`numpy.random.f(dfnum, dfden, size)` samples are drawn.
     Output array data type is :obj:`dpnp.float64`.
+
     Examples
     --------
     >>> dfnum, dfden = 3., 2.
@@ -366,7 +367,7 @@ def gamma(shape, scale=1.0, size=None):
 
     Limitations
     -----------
-    Parameters ``shape`` and ``scale`` are supported as scalar.
+    Parameters `shape` and `scale` are supported as scalar.
     Otherwise, :obj:`numpy.random.gamma(shape, scale, size)` samples are drawn.
     Output array data type is :obj:`dpnp.float64`.
 
@@ -404,7 +405,7 @@ def geometric(p, size=None):
 
     Limitations
     -----------
-    Parameter ``p`` is supported as a scalar.
+    Parameter `p` is supported as a scalar.
     Otherwise, :obj:`numpy.random.geometric(p, size)` samples are drawn.
     Output array data type is :obj:`dpnp.int32`.
 
@@ -438,7 +439,7 @@ def gumbel(loc=0.0, scale=1.0, size=None):
 
     Limitations
     -----------
-    Parameters ``loc`` and ``scale`` are supported as scalar.
+    Parameters `loc` and `scale` are supported as scalar.
     Otherwise, :obj:`numpy.random.gumbel(loc, scale, size)` samples are drawn.
     Output array data type is :obj:`dpnp.float64`.
 
@@ -474,7 +475,7 @@ def hypergeometric(ngood, nbad, nsample, size=None):
 
     Limitations
     -----------
-    Parameters ``ngood``, ``nbad`` and ``nsample`` are supported as scalar.
+    Parameters `ngood`, `nbad` and `nsample` are supported as scalar.
     Otherwise, :obj:`numpy.random.hypergeometric(shape, scale, size)` samples
     are drawn.
     Output array data type is :obj:`dpnp.int32`.
@@ -526,7 +527,7 @@ def laplace(loc=0.0, scale=1.0, size=None):
 
     Limitations
     -----------
-    Parameters ``loc`` and ``scale`` are supported as scalar.
+    Parameters `loc` and `scale` are supported as scalar.
     Otherwise, :obj:`numpy.random.laplace(loc, scale, size)` samples are drawn.
     Output array data type is :obj:`dpnp.float64`.
 
@@ -561,7 +562,7 @@ def logistic(loc=0.0, scale=1.0, size=None):
 
     Limitations
     -----------
-    Parameters ``loc`` and ``scale`` are supported as scalar.
+    Parameters `loc` and `scale` are supported as scalar.
     Otherwise, :obj:`numpy.random.logistic(loc, scale, size)` samples are drawn.
     Output array data type is :obj:`dpnp.float64`.
 
@@ -600,7 +601,7 @@ def lognormal(mean=0.0, sigma=1.0, size=None):
 
     Limitations
     -----------
-    Parameters ``mean`` and ``sigma`` are supported as scalar.
+    Parameters `mean` and `sigma` are supported as scalar.
     Otherwise, :obj:`numpy.random.lognormal(mean, sigma, size)` samples
     are drawn.
     Output array data type is :obj:`dpnp.float64`.
@@ -654,7 +655,7 @@ def multinomial(n, pvals, size=None):
 
     Limitations
     -----------
-    Parameter ``n`` limited with int32 max. See, `numpy.iinfo(numpy.int32).max`.
+    Parameter `n` limited with int32 max. See, `numpy.iinfo(numpy.int32).max`.
     Sum of ``pvals``, `sum(pvals)` should be between (0, 1).
     Otherwise, :obj:`numpy.random.multinomial(n, pvals, size)`
     samples are drawn.
@@ -674,7 +675,7 @@ def multinomial(n, pvals, size=None):
         d = len(pvals)
         if n < 0:
             pass
-        elif n > numpy.iinfo(dpnp.int32).max:
+        elif n > dpnp.iinfo(dpnp.int32).max:
             pass
         elif pvals_sum > 1.0:
             pass
@@ -703,7 +704,7 @@ def multivariate_normal(mean, cov, size=None, check_valid="warn", tol=1e-8):
 
     Limitations
     -----------
-    Parameters ``check_valid`` and ``tol`` are not supported.
+    Parameters `check_valid` and `tol` are not supported.
     Otherwise, :obj:`numpy.random.multivariate_normal(mean, cov, size, check_valid, tol)`
     samples are drawn.
 
@@ -753,7 +754,7 @@ def negative_binomial(n, p, size=None):
 
     Limitations
     -----------
-    Parameters ``n`` and ``p`` are supported as scalar.
+    Parameters `n` and `p` are supported as scalar.
     Otherwise, :obj:`numpy.random.negative_binomial(n, p, size)` samples
     are drawn.
     Output array data type is :obj:`dpnp.int32`.
@@ -898,7 +899,7 @@ def pareto(a, size=None):
 
     Limitations
     -----------
-    Parameter ``a`` is supported as a scalar.
+    Parameter `a` is supported as a scalar.
     Otherwise, :obj:`numpy.random.pareto(a, size)` samples are drawn.
     Output array data type is :obj:`dpnp.float64`.
 
@@ -967,7 +968,7 @@ def poisson(lam=1.0, size=None):
 
     Limitations
     -----------
-    Parameter ``lam`` is supported as a scalar.
+    Parameter `lam` is supported as a scalar.
     Otherwise, :obj:`numpy.random.poisson(lam, size)` samples are drawn.
     Output array data type is :obj:`dpnp.int32`.
 
@@ -1002,7 +1003,7 @@ def power(a, size=None):
 
     Limitations
     -----------
-    Parameter ``a`` is supported as a scalar.
+    Parameter `a` is supported as a scalar.
     Otherwise, :obj:`numpy.random.power(a, size)` samples are drawn.
     Output array data type is :obj:`dpnp.float64`.
 
@@ -1380,7 +1381,7 @@ def rayleigh(scale=1.0, size=None):
 
     Limitations
     -----------
-    Parameter ``scale`` is supported as a scalar.
+    Parameter `scale` is supported as a scalar.
     Otherwise, :obj:`numpy.random.rayleigh(scale, size)` samples are drawn.
     Output array data type is :obj:`dpnp.float64`.
 
@@ -1586,7 +1587,7 @@ def standard_gamma(shape, size=None):
 
     Limitations
     -----------
-    Parameter ``shape`` is supported as a scalar.
+    Parameter `shape` is supported as a scalar.
     Otherwise, :obj:`numpy.random.standard_gamma(shape, size)` samples
     are drawn.
     Output array data type is :obj:`dpnp.float64`.
@@ -1659,7 +1660,7 @@ def standard_t(df, size=None):
 
     Limitations
     -----------
-    Parameter ``df`` is supported as a scalar.
+    Parameter `df` is supported as a scalar.
     Otherwise, :obj:`numpy.random.standard_t(df, size)` samples
     are drawn.
     Output array data type is :obj:`dpnp.float64`.
@@ -1695,7 +1696,7 @@ def triangular(left, mode, right, size=None):
 
     Limitations
     -----------
-    Parameter ``left``, ``mode`` and ``right`` are supported as scalar.
+    Parameters `left`, `mode` and `right` are supported as scalar.
     Otherwise, :obj:`numpy.random.triangular(left, mode, right, size)`
     samples are drawn.
     Output array data type is :obj:`dpnp.float64`.
@@ -1799,7 +1800,7 @@ def vonmises(mu, kappa, size=None):
 
     Limitations
     -----------
-    Parameter ``mu`` and ``kappa`` are supported as scalar.
+    Parameters `mu` and `kappa` are supported as scalar.
     Otherwise, :obj:`numpy.random.vonmises(mu, kappa, size)`
     samples are drawn.
     Output array data type is :obj:`dpnp.float64`.
@@ -1838,7 +1839,7 @@ def wald(mean, scale, size=None):
 
     Limitations
     -----------
-    Parameters ``mean`` and ``scale`` are supported as scalar.
+    Parameters `mean` and `scale` are supported as scalar.
     Otherwise, :obj:`numpy.random.wald(mean, scale, size)` samples are drawn.
     Output array data type is :obj:`dpnp.float64`.
 
@@ -1875,7 +1876,7 @@ def weibull(a, size=None):
 
     Limitations
     -----------
-    Parameter ``a`` is supported as a scalar.
+    Parameter `a` is supported as a scalar.
     Otherwise, :obj:`numpy.random.weibull(a, size)` samples are drawn.
     Output array data type is :obj:`dpnp.float64`.
 
@@ -1908,7 +1909,7 @@ def zipf(a, size=None):
 
     Limitations
     -----------
-    Parameter ``a`` is supported as a scalar.
+    Parameter `a`` is supported as a scalar.
     Otherwise, :obj:`numpy.zipf.weibull(a, size)` samples are drawn.
     Output array data type is :obj:`dpnp.float64`.
 
diff --git a/dpnp/random/dpnp_random_state.py b/dpnp/random/dpnp_random_state.py
index 4d6f8d22a71..c53ae620b2c 100644
--- a/dpnp/random/dpnp_random_state.py
+++ b/dpnp/random/dpnp_random_state.py
@@ -81,7 +81,7 @@ def __init__(self, seed=None, device=None, sycl_queue=None):
         is_cpu = self._sycl_device.is_cpu
         if seed is None:
             low = 0
-            high = numpy.iinfo(numpy.int32).max + 1
+            high = dpnp.iinfo(numpy.int32).max + 1
 
             if is_cpu:
                 # ask NumPy to generate an array of three random integers as default seed value
@@ -237,8 +237,8 @@ def normal(
                 dtype = self._validate_float_dtype(
                     dtype, (dpnp.float32, dpnp.float64)
                 )
-                min_floating = numpy.finfo(dtype).min
-                max_floating = numpy.finfo(dtype).max
+                min_floating = dpnp.finfo(dtype).min
+                max_floating = dpnp.finfo(dtype).max
 
                 if (
                     loc >= max_floating or loc <= min_floating
@@ -371,8 +371,8 @@ def randint(self, low, high=None, size=None, dtype=int, usm_type="device"):
                         high = low
                         low = 0
 
-                    min_int = numpy.iinfo("int32").min
-                    max_int = numpy.iinfo("int32").max
+                    min_int = dpnp.iinfo("int32").min
+                    max_int = dpnp.iinfo("int32").max
 
                     if (
                         not self._is_finite_scalar(low)
@@ -587,8 +587,8 @@ def uniform(
             elif not dpnp.isscalar(high):
                 pass
             else:
-                min_double = numpy.finfo("double").min
-                max_double = numpy.finfo("double").max
+                min_double = dpnp.finfo("double").min
+                max_double = dpnp.finfo("double").max
 
                 if (
                     not self._is_finite_scalar(low)
diff --git a/dpnp/to_numba/dpnp_iface_to_numba.py b/dpnp/to_numba/dpnp_iface_to_numba.py
index 85499968d9e..fc1ee2dbc10 100644
--- a/dpnp/to_numba/dpnp_iface_to_numba.py
+++ b/dpnp/to_numba/dpnp_iface_to_numba.py
@@ -31,7 +31,7 @@
 -----
 This module represents DPNP Algo interface to Numba JIT
 
-The code idea gathered from numba-scipy and needs to be syncronized with
+The code idea gathered from numba-scipy and needs to be synchronized with
 https://github.com/numba/numba-scipy/blob/master/numba_scipy/special/
 """
 
diff --git a/examples/example2.py b/examples/example2.py
index 55408d3df49..9f0539be2dd 100644
--- a/examples/example2.py
+++ b/examples/example2.py
@@ -27,11 +27,11 @@
 
 """Example 2.
 
-This example shows usage of diffrent input data types
+This example shows usage of different input data types
 with same third party library call
 
 Also, it produces performance comparison between a same third party function call
-over diffrent types of input data
+over different types of input data
 
 """
 
diff --git a/examples/example4.py b/examples/example4.py
index 967d30600b9..19adde92bfc 100644
--- a/examples/example4.py
+++ b/examples/example4.py
@@ -58,7 +58,7 @@
         data = numpy.array([1, 2, 3, 4], dtype=test_type)
         result = function(data)
         print(
-            f"input:{data.dtype.name:10}: outout:{result.dtype.name:10}: name:{function.__name__}"
+            f"input:{data.dtype.name:10}: output:{result.dtype.name:10}: name:{function.__name__}"
         )
 
 """
diff --git a/scripts/gen_coverage.py b/scripts/gen_coverage.py
index cdb6188d2a7..5af2ccb3fc6 100644
--- a/scripts/gen_coverage.py
+++ b/scripts/gen_coverage.py
@@ -82,10 +82,14 @@ def find_objects():
         objects = []
         dpnp_path = os.getcwd()
         search_path = os.path.join(dpnp_path, "dpnp")
-        files = os.listdir(search_path)
-        for file in files:
-            if file.endswith("_c.so"):
-                objects.extend(["-object", os.path.join(search_path, file)])
+        for root, _, files in os.walk(search_path):
+            for file in files:
+                if (
+                    file.endswith("_c.so")
+                    or root.find("extensions") != -1
+                    and file.find("_impl.cpython") != -1
+                ):
+                    objects.extend(["-object", os.path.join(root, file)])
         return objects
 
     objects = find_objects()
@@ -112,7 +116,8 @@ def find_objects():
                 "-ignore-filename-regex=/tmp/icpx*",
                 "-instr-profile=" + instr_profile_fn,
             ]
-            + objects,
+            + objects
+            + ["-sources", "dpnp"],
             stdout=fh,
         )
 
diff --git a/scripts/install_system_deps_win.bat b/scripts/install_system_deps_win.bat
index 28975bccacd..1baf9e66391 100644
--- a/scripts/install_system_deps_win.bat
+++ b/scripts/install_system_deps_win.bat
@@ -87,7 +87,7 @@ start /b /wait webimage.exe -s -x -f webimage_extracted
 del webimage.exe
 
 echo ========================= install onepai =================================
-:: it is expected that multy-line end-line symbol will be diffrent on MS :-)
+:: it is expected that multy-line end-line symbol will be different on MS :-)
 call webimage_extracted\bootstrapper.exe -s --action install                   ^
                                             --eula=accept                      ^
                                             --continue-with-optional-error=yes ^


Test patch:
diff --git a/dpnp/backend/tests/test_random.cpp b/dpnp/backend/tests/test_random.cpp
index 8535c450db4..170014b052e 100644
--- a/dpnp/backend/tests/test_random.cpp
+++ b/dpnp/backend/tests/test_random.cpp
@@ -36,7 +36,7 @@
 // TODO
 // * data management will be redesigned: allocation as chars (and casting on
 // teste suits)
-// * this class will be generlized
+// * this class will be generalized
 class RandomTestCase : public ::testing::Test
 {
 public:
diff --git a/tests/helper.py b/tests/helper.py
index bb8ccd378a2..b3d816e769a 100644
--- a/tests/helper.py
+++ b/tests/helper.py
@@ -18,7 +18,7 @@ def assert_dtype_allclose(dpnp_arr, numpy_arr, check_type=True):
     is_inexact = lambda x: dpnp.issubdtype(x.dtype, dpnp.inexact)
     if is_inexact(dpnp_arr) or is_inexact(numpy_arr):
         tol = 8 * max(
-            numpy.finfo(dpnp_arr.dtype).resolution,
+            dpnp.finfo(dpnp_arr).resolution,
             numpy.finfo(numpy_arr.dtype).resolution,
         )
         assert_allclose(dpnp_arr.asnumpy(), numpy_arr, atol=tol, rtol=tol)
diff --git a/tests/skipped_tests.tbl b/tests/skipped_tests.tbl
index 98cdc65136a..60b9408b690 100644
--- a/tests/skipped_tests.tbl
+++ b/tests/skipped_tests.tbl
@@ -3,7 +3,13 @@ tests/test_histograms.py::TestHistogram::test_density
 tests/test_random.py::TestDistributionsMultivariateNormal::test_moments
 tests/test_random.py::TestDistributionsMultivariateNormal::test_output_shape_check
 tests/test_random.py::TestDistributionsMultivariateNormal::test_seed
+tests/test_random.py::TestPermutationsTestShuffle::test_shuffle1[lambda x: dpnp.asarray(x).astype(dpnp.complex64)]
+tests/test_random.py::TestPermutationsTestShuffle::test_shuffle1[lambda x: dpnp.astype(dpnp.asarray(x), dpnp.int8)]
+tests/test_random.py::TestPermutationsTestShuffle::test_shuffle1[lambda x: dpnp.astype(dpnp.asarray(x), object)]
 tests/test_random.py::TestPermutationsTestShuffle::test_shuffle1[lambda x: dpnp.vstack([x, x]).T]
+tests/test_random.py::TestPermutationsTestShuffle::test_shuffle1[lambda x: (dpnp.asarray([(i, i) for i in x], [("a", int), ("b", int)]).view(dpnp.recarray))]
+tests/test_random.py::TestPermutationsTestShuffle::test_shuffle1[lambda x: dpnp.asarray([(i, i) for i in x], [("a", object), ("b", dpnp.int32)])]]
+tests/test_random.py::TestPermutationsTestShuffle::test_shuffle1[lambda x: dpnp.asarray(x).astype(dpnp.int8)]
 
 tests/test_sycl_queue.py::test_1in_1out[opencl:gpu:0-trapz-data19]
 tests/test_sycl_queue.py::test_1in_1out[opencl:cpu:0-trapz-data19]
@@ -34,8 +40,6 @@ tests/third_party/cupy/fft_tests/test_fft.py::TestFftn_param_23_{axes=None, norm
 
 tests/third_party/intel/test_zero_copy_test1.py::test_dpnp_interaction_with_dpctl_memory
 
-tests/test_arraymanipulation.py::TestVstack::test_generator
-
 tests/test_linalg.py::test_cond[-1-[[1, 2, 3], [4, 5, 6], [7, 8, 9]]]
 tests/test_linalg.py::test_cond[1-[[1, 2, 3], [4, 5, 6], [7, 8, 9]]]
 tests/test_linalg.py::test_cond[-2-[[1, 0, -1], [0, 1, 0], [1, 0, 1]]]
@@ -72,21 +76,11 @@ tests/test_linalg.py::test_norm1[None-3-[7]]
 tests/test_linalg.py::test_norm1[None-3-[1, 2]]
 tests/test_linalg.py::test_norm1[None-3-[1, 0]]
 
-tests/test_random.py::TestPermutationsTestShuffle::test_shuffle1[lambda x: dpnp.asarray([[i, i] for i in x])]
-tests/test_random.py::TestPermutationsTestShuffle::test_shuffle1[lambda x: (dpnp.asarray([(i, i) for i in x], [("a", int), ("b", int)]).view(dpnp.recarray))]
-tests/test_random.py::TestPermutationsTestShuffle::test_shuffle1[lambda x: dpnp.asarray([(i, i) for i in x], [("a", object), ("b", dpnp.int32)])]]
-tests/test_random.py::TestPermutationsTestShuffle::test_shuffle1[lambda x: dpnp.asarray(x).astype(dpnp.int8)]
-
 tests/test_strides.py::test_strides_1arg[(10,)-None-cbrt]
 tests/test_strides.py::test_strides_1arg[(10,)-None-degrees]
-tests/test_strides.py::test_strides_1arg[(10,)-None-exp]
 tests/test_strides.py::test_strides_1arg[(10,)-None-exp2]
-tests/test_strides.py::test_strides_1arg[(10,)-None-expm1]
 tests/test_strides.py::test_strides_1arg[(10,)-None-fabs]
-tests/test_strides.py::test_strides_1arg[(10,)-None-log1p]
 tests/test_strides.py::test_strides_1arg[(10,)-None-radians]
-tests/test_strides.py::test_strides_1arg[(10,)-None-log2]
-tests/test_strides.py::test_strides_1arg[(10,)-None-log10]
 tests/test_strides.py::test_strides_erf[(10,)-None]
 tests/test_strides.py::test_strides_reciprocal[(10,)-None]
 
@@ -107,50 +101,25 @@ tests/test_umath.py::test_umaths[('ldexp', 'fi')]
 tests/test_umath.py::test_umaths[('ldexp', 'fl')]
 tests/test_umath.py::test_umaths[('ldexp', 'di')]
 tests/test_umath.py::test_umaths[('ldexp', 'dl')]
-tests/test_umath.py::test_umaths[('logaddexp', 'ff')]
-tests/test_umath.py::test_umaths[('logaddexp', 'dd')]
 tests/test_umath.py::test_umaths[('logaddexp2', 'ff')]
 tests/test_umath.py::test_umaths[('logaddexp2', 'dd')]
 tests/test_umath.py::test_umaths[('nextafter', 'ff')]
 tests/test_umath.py::test_umaths[('nextafter', 'dd')]
-tests/test_umath.py::test_umaths[('positive', 'i')]
-tests/test_umath.py::test_umaths[('positive', 'l')]
-tests/test_umath.py::test_umaths[('positive', 'f')]
-tests/test_umath.py::test_umaths[('positive', 'd')]
 tests/test_umath.py::test_umaths[('spacing', 'f')]
 tests/test_umath.py::test_umaths[('spacing', 'd')]
 
 tests/third_party/cupy/core_tests/test_ndarray_complex_ops.py::TestAngle::test_angle
 tests/third_party/cupy/core_tests/test_ndarray_complex_ops.py::TestRealImag::test_imag_inplace
 tests/third_party/cupy/core_tests/test_ndarray_complex_ops.py::TestRealImag::test_real_inplace
-tests/third_party/cupy/core_tests/test_ndarray_complex_ops.py::TestScalarConversion::test_scalar_conversion
 tests/third_party/cupy/core_tests/test_ndarray_conversion.py::TestNdarrayToBytes_param_0_{shape=()}::test_item
 tests/third_party/cupy/core_tests/test_ndarray_conversion.py::TestNdarrayToBytes_param_1_{shape=(1,)}::test_item
 tests/third_party/cupy/core_tests/test_ndarray_conversion.py::TestNdarrayToBytes_param_2_{shape=(2, 3)}::test_item
 tests/third_party/cupy/core_tests/test_ndarray_conversion.py::TestNdarrayToBytes_param_3_{order='C', shape=(2, 3)}::test_item
 tests/third_party/cupy/core_tests/test_ndarray_conversion.py::TestNdarrayToBytes_param_4_{order='F', shape=(2, 3)}::test_item
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayCopyAndView::test_astype
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayCopyAndView::test_astype_type
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayCopyAndView::test_astype_strides
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayCopyAndView::test_astype_strides_broadcast
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayCopyAndView::test_astype_strides_negative
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayCopyAndView::test_astype_strides_swapped
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayCopyAndView::test_astype_type_c_contiguous_no_copy
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayCopyAndView::test_astype_type_f_contiguous_no_copy
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayCopyAndView::test_flatten
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayCopyAndView::test_flatten_copied
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayCopyAndView::test_isinstance_numpy_copy
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayCopyAndView::test_isinstance_numpy_copy_not_slice
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayCopyAndView::test_isinstance_numpy_copy_wrong_dtype
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayCopyAndView::test_isinstance_numpy_copy_wrong_shape
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayCopyAndView::test_view
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayCopyAndView::test_view_0d
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayCopyAndView::test_view_0d_raise
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayCopyAndView::test_view_itemsize
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayCopyAndView::test_view_non_contiguous_raise
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestNumPyArrayCopyView_param_0_{src_order='C'}::test_isinstance_numpy_view_copy_f
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestNumPyArrayCopyView_param_1_{src_order='F'}::test_isinstance_numpy_view_copy_f
 
+tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayFlatten::test_flatten_order
+tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayFlatten::test_flatten_order_copied
+tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayFlatten::test_flatten_order_transposed
 
 tests/third_party/cupy/core_tests/test_ndarray_reduction.py::TestArrayReduction::test_min_nan
 tests/third_party/cupy/core_tests/test_ndarray_reduction.py::TestArrayReduction::test_ptp_all
@@ -438,37 +407,23 @@ tests/third_party/cupy/logic_tests/test_comparison.py::TestArrayEqual::test_arra
 tests/third_party/cupy/logic_tests/test_comparison.py::TestArrayEqual::test_array_equal_diff_length
 tests/third_party/cupy/logic_tests/test_comparison.py::TestArrayEqual::test_array_equal_is_equal
 tests/third_party/cupy/logic_tests/test_comparison.py::TestArrayEqual::test_array_equal_not_equal
+
 tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_0_{shapes=[(), ()]}::test_broadcast
-tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_0_{shapes=[(), ()]}::test_broadcast_arrays
 tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_10_{shapes=[(0, 1, 1, 0, 3), (5, 2, 0, 1, 0, 0, 3), (2, 1, 0, 0, 0, 3)]}::test_broadcast
-tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_10_{shapes=[(0, 1, 1, 0, 3), (5, 2, 0, 1, 0, 0, 3), (2, 1, 0, 0, 0, 3)]}::test_broadcast_arrays
 tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_1_{shapes=[(0,), (0,)]}::test_broadcast
-tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_1_{shapes=[(0,), (0,)]}::test_broadcast_arrays
 tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_2_{shapes=[(1,), (1,)]}::test_broadcast
-tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_2_{shapes=[(1,), (1,)]}::test_broadcast_arrays
 tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_3_{shapes=[(2,), (2,)]}::test_broadcast
-tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_3_{shapes=[(2,), (2,)]}::test_broadcast_arrays
 tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_4_{shapes=[(0,), (1,)]}::test_broadcast
-tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_4_{shapes=[(0,), (1,)]}::test_broadcast_arrays
 tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_5_{shapes=[(2, 3), (1, 3)]}::test_broadcast
-tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_5_{shapes=[(2, 3), (1, 3)]}::test_broadcast_arrays
 tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_6_{shapes=[(2, 1, 3, 4), (3, 1, 4)]}::test_broadcast
-tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_6_{shapes=[(2, 1, 3, 4), (3, 1, 4)]}::test_broadcast_arrays
 tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_7_{shapes=[(4, 3, 2, 3), (2, 3)]}::test_broadcast
-tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_7_{shapes=[(4, 3, 2, 3), (2, 3)]}::test_broadcast_arrays
 tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_8_{shapes=[(2, 0, 1, 1, 3), (2, 1, 0, 0, 3)]}::test_broadcast
-tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_8_{shapes=[(2, 0, 1, 1, 3), (2, 1, 0, 0, 3)]}::test_broadcast_arrays
 tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_9_{shapes=[(0, 1, 1, 3), (2, 1, 0, 0, 3)]}::test_broadcast
-tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_9_{shapes=[(0, 1, 1, 3), (2, 1, 0, 0, 3)]}::test_broadcast_arrays
-
 tests/third_party/cupy/manipulation_tests/test_dims.py::TestInvalidBroadcast_param_0_{shapes=[(3,), (2,)]}::test_invalid_broadcast
-tests/third_party/cupy/manipulation_tests/test_dims.py::TestInvalidBroadcast_param_0_{shapes=[(3,), (2,)]}::test_invalid_broadcast_arrays
 tests/third_party/cupy/manipulation_tests/test_dims.py::TestInvalidBroadcast_param_1_{shapes=[(3, 2), (2, 3)]}::test_invalid_broadcast
-tests/third_party/cupy/manipulation_tests/test_dims.py::TestInvalidBroadcast_param_1_{shapes=[(3, 2), (2, 3)]}::test_invalid_broadcast_arrays
 tests/third_party/cupy/manipulation_tests/test_dims.py::TestInvalidBroadcast_param_2_{shapes=[(3, 2), (3, 4)]}::test_invalid_broadcast
-tests/third_party/cupy/manipulation_tests/test_dims.py::TestInvalidBroadcast_param_2_{shapes=[(3, 2), (3, 4)]}::test_invalid_broadcast_arrays
 tests/third_party/cupy/manipulation_tests/test_dims.py::TestInvalidBroadcast_param_3_{shapes=[(0,), (2,)]}::test_invalid_broadcast
-tests/third_party/cupy/manipulation_tests/test_dims.py::TestInvalidBroadcast_param_3_{shapes=[(0,), (2,)]}::test_invalid_broadcast_arrays
+
 tests/third_party/cupy/manipulation_tests/test_shape.py::TestRavel::test_ravel2
 tests/third_party/cupy/manipulation_tests/test_shape.py::TestRavel::test_ravel3
 tests/third_party/cupy/manipulation_tests/test_shape.py::TestRavel::test_external_ravel
@@ -478,14 +433,6 @@ tests/third_party/cupy/manipulation_tests/test_shape.py::TestReshape::test_resha
 
 tests/third_party/cupy/manipulation_tests/test_tiling.py::TestRepeatRepeatsNdarray::test_func
 tests/third_party/cupy/manipulation_tests/test_tiling.py::TestRepeatRepeatsNdarray::test_method
-tests/third_party/cupy/manipulation_tests/test_tiling.py::TestTileFailure_param_0_{reps=-1}::test_tile_failure
-tests/third_party/cupy/manipulation_tests/test_tiling.py::TestTileFailure_param_1_{reps=(-1, -2)}::test_tile_failure
-tests/third_party/cupy/manipulation_tests/test_tiling.py::TestTile_param_0_{reps=0}::test_array_tile
-tests/third_party/cupy/manipulation_tests/test_tiling.py::TestTile_param_1_{reps=1}::test_array_tile
-tests/third_party/cupy/manipulation_tests/test_tiling.py::TestTile_param_2_{reps=2}::test_array_tile
-tests/third_party/cupy/manipulation_tests/test_tiling.py::TestTile_param_3_{reps=(0, 1)}::test_array_tile
-tests/third_party/cupy/manipulation_tests/test_tiling.py::TestTile_param_4_{reps=(2, 3)}::test_array_tile
-tests/third_party/cupy/manipulation_tests/test_tiling.py::TestTile_param_5_{reps=(2, 3, 4, 5)}::test_array_tile
 tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_457_{arg1=array([[1, 2, 3],       [4, 5, 6]], dtype=int32), arg2=array([[0, 1, 2],       [3, 4, 5]], dtype=int32), dtype=float64, name='fmod', use_dtype=False}::test_binary
 tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_465_{arg1=array([[1, 2, 3],       [4, 5, 6]], dtype=int32), arg2=array([[0, 1, 2],       [3, 4, 5]]), dtype=float64, name='fmod', use_dtype=False}::test_binary
 tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_537_{arg1=array([[1, 2, 3],       [4, 5, 6]]), arg2=array([[0, 1, 2],       [3, 4, 5]], dtype=int32), dtype=float64, name='fmod', use_dtype=False}::test_binary
@@ -494,7 +441,6 @@ tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticModf::test_m
 
 tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticRaisesWithNumpyInput_param_3_{name='angle', nargs=1}::test_raises_with_numpy_input
 
-tests/third_party/cupy/math_tests/test_explog.py::TestExplog::test_logaddexp
 tests/third_party/cupy/math_tests/test_explog.py::TestExplog::test_logaddexp2
 tests/third_party/cupy/math_tests/test_explog.py::TestExplog::test_logaddexp2_infinities
 tests/third_party/cupy/math_tests/test_floating.py::TestFloating::test_copysign_float
@@ -505,9 +451,6 @@ tests/third_party/cupy/math_tests/test_floating.py::TestFloating::test_nextafter
 
 tests/third_party/cupy/math_tests/test_misc.py::TestMisc::test_clip_min_max_none
 tests/third_party/cupy/math_tests/test_misc.py::TestMisc::test_external_clip4
-tests/third_party/cupy/math_tests/test_misc.py::TestMisc::test_absolute_negative
-tests/third_party/cupy/math_tests/test_misc.py::TestMisc::test_maximum_nan
-tests/third_party/cupy/math_tests/test_misc.py::TestMisc::test_minimum_nan
 tests/third_party/cupy/math_tests/test_misc.py::TestMisc::test_fmax_nan
 tests/third_party/cupy/math_tests/test_misc.py::TestMisc::test_fmin_nan
 tests/third_party/cupy/math_tests/test_misc.py::TestMisc::test_nan_to_num
@@ -872,10 +815,6 @@ tests/third_party/cupy/random_tests/test_sample.py::TestRandomIntegers::test_hig
 tests/third_party/cupy/random_tests/test_sample.py::TestRandomIntegers::test_normal
 tests/third_party/cupy/random_tests/test_sample.py::TestRandomIntegers::test_size_is_not_none
 
-tests/third_party/cupy/sorting_tests/test_count.py::TestCount::test_count_nonzero
-tests/third_party/cupy/sorting_tests/test_count.py::TestCount::test_count_nonzero_int_axis
-tests/third_party/cupy/sorting_tests/test_count.py::TestCount::test_count_nonzero_tuple_axis
-tests/third_party/cupy/sorting_tests/test_count.py::TestCount::test_count_nonzero_zero_dim
 tests/third_party/cupy/sorting_tests/test_search.py::TestArgMinMaxDtype_param_0_{func='argmin', is_module=True, shape=(3, 4)}::test_argminmax_dtype
 tests/third_party/cupy/sorting_tests/test_search.py::TestArgMinMaxDtype_param_1_{func='argmin', is_module=True, shape=()}::test_argminmax_dtype
 tests/third_party/cupy/sorting_tests/test_search.py::TestArgMinMaxDtype_param_2_{func='argmin', is_module=False, shape=(3, 4)}::test_argminmax_dtype
diff --git a/tests/skipped_tests_gpu.tbl b/tests/skipped_tests_gpu.tbl
index 3ab40ed4d04..fc9931e93d6 100644
--- a/tests/skipped_tests_gpu.tbl
+++ b/tests/skipped_tests_gpu.tbl
@@ -9,8 +9,13 @@ tests/test_random.py::TestPermutationsTestShuffle::test_no_miss_numbers[float32]
 tests/test_random.py::TestPermutationsTestShuffle::test_no_miss_numbers[float64]
 tests/test_random.py::TestPermutationsTestShuffle::test_no_miss_numbers[int32]
 tests/test_random.py::TestPermutationsTestShuffle::test_no_miss_numbers[int64]
-tests/test_random.py::TestPermutationsTestShuffle::test_shuffle1[lambda x: dpnp.array([])]
-tests/test_random.py::TestPermutationsTestShuffle::test_shuffle1[lambda x: dpnp.astype(dpnp.asarray(x), dpnp.float32)]
+tests/test_random.py::TestPermutationsTestShuffle::test_shuffle1[lambda x: dpnp.asarray(x).astype(dpnp.complex64)]
+tests/test_random.py::TestPermutationsTestShuffle::test_shuffle1[lambda x: dpnp.astype(dpnp.asarray(x), dpnp.int8)]
+tests/test_random.py::TestPermutationsTestShuffle::test_shuffle1[lambda x: dpnp.astype(dpnp.asarray(x), object)]
+tests/test_random.py::TestPermutationsTestShuffle::test_shuffle1[lambda x: dpnp.vstack([x, x]).T]
+tests/test_random.py::TestPermutationsTestShuffle::test_shuffle1[lambda x: (dpnp.asarray([(i, i) for i in x], [("a", int), ("b", int)]).view(dpnp.recarray))]
+tests/test_random.py::TestPermutationsTestShuffle::test_shuffle1[lambda x: dpnp.asarray([(i, i) for i in x], [("a", object), ("b", dpnp.int32)])]]
+tests/test_random.py::TestPermutationsTestShuffle::test_shuffle1[lambda x: dpnp.asarray(x).astype(dpnp.int8)]
 
 tests/test_sycl_queue.py::test_1in_1out[opencl:gpu:0-copy-data3]
 tests/test_sycl_queue.py::test_1in_1out[opencl:gpu:0-cumprod-data4]
@@ -53,16 +58,10 @@ tests/test_umath.py::test_umaths[('ldexp', 'fi')]
 tests/test_umath.py::test_umaths[('ldexp', 'fl')]
 tests/test_umath.py::test_umaths[('ldexp', 'di')]
 tests/test_umath.py::test_umaths[('ldexp', 'dl')]
-tests/test_umath.py::test_umaths[('logaddexp', 'ff')]
-tests/test_umath.py::test_umaths[('logaddexp', 'dd')]
 tests/test_umath.py::test_umaths[('logaddexp2', 'ff')]
 tests/test_umath.py::test_umaths[('logaddexp2', 'dd')]
 tests/test_umath.py::test_umaths[('nextafter', 'ff')]
 tests/test_umath.py::test_umaths[('nextafter', 'dd')]
-tests/test_umath.py::test_umaths[('positive', 'i')]
-tests/test_umath.py::test_umaths[('positive', 'l')]
-tests/test_umath.py::test_umaths[('positive', 'f')]
-tests/test_umath.py::test_umaths[('positive', 'd')]
 tests/test_umath.py::test_umaths[('spacing', 'f')]
 tests/test_umath.py::test_umaths[('spacing', 'd')]
 
@@ -137,13 +136,8 @@ tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsPois
 tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsPoisson_param_2_{lam_shape=(3, 2), shape=(4, 3, 2)}::test_poisson
 tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsPoisson_param_3_{lam_shape=(3, 2), shape=(3, 2)}::test_poisson
 
-tests/test_random.py::TestPermutationsTestShuffle::test_shuffle1[lambda x: dpnp.asarray([[i, i] for i in x])]
-
 tests/test_histograms.py::TestHistogram::test_density
 
-tests/test_random.py::TestPermutationsTestShuffle::test_shuffle1[lambda x: dpnp.astype(dpnp.asarray(x), dpnp.int8)]
-tests/test_random.py::TestPermutationsTestShuffle::test_shuffle1[lambda x: dpnp.astype(dpnp.asarray(x), object)]
-tests/test_random.py::TestPermutationsTestShuffle::test_shuffle1[lambda x: dpnp.vstack([x, x]).T]
 tests/third_party/cupy/core_tests/test_ndarray_conversion.py::TestNdarrayItemRaise_param_0_{shape=(0,)}::test_item
 tests/third_party/cupy/core_tests/test_ndarray_conversion.py::TestNdarrayItemRaise_param_1_{shape=(2, 3)}::test_item
 tests/third_party/cupy/core_tests/test_ndarray_conversion.py::TestNdarrayItemRaise_param_2_{shape=(1, 0, 1)}::test_item
@@ -216,7 +210,6 @@ tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsMult
 tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsMultivariateNormal_param_3_{d=4, shape=(3, 2)}::test_normal
 
 tests/third_party/intel/test_zero_copy_test1.py::test_dpnp_interaction_with_dpctl_memory
-tests/test_arraymanipulation.py::TestVstack::test_generator
 
 tests/test_linalg.py::test_cond[-1-[[1, 2, 3], [4, 5, 6], [7, 8, 9]]]
 tests/test_linalg.py::test_cond[1-[[1, 2, 3], [4, 5, 6], [7, 8, 9]]]
@@ -244,35 +237,13 @@ tests/test_linalg.py::test_matrix_rank[None-[[1, 2], [3, 4]]-float32]
 tests/test_linalg.py::test_matrix_rank[None-[[1, 2], [3, 4]]-int64]
 tests/test_linalg.py::test_matrix_rank[None-[[1, 2], [3, 4]]-int32]
 
-tests/test_random.py::TestPermutationsTestShuffle::test_shuffle1[lambda x: (dpnp.asarray([(i, i) for i in x], [("a", int), ("b", int)]).view(dpnp.recarray))]
-tests/test_random.py::TestPermutationsTestShuffle::test_shuffle1[lambda x: dpnp.asarray([(i, i) for i in x], [("a", object), ("b", dpnp.int32)])]]
-tests/test_random.py::TestPermutationsTestShuffle::test_shuffle1[lambda x: dpnp.asarray(x).astype(dpnp.int8)]
-
 tests/third_party/cupy/core_tests/test_ndarray_complex_ops.py::TestAngle::test_angle
 tests/third_party/cupy/core_tests/test_ndarray_complex_ops.py::TestRealImag::test_imag_inplace
 tests/third_party/cupy/core_tests/test_ndarray_complex_ops.py::TestRealImag::test_real_inplace
-tests/third_party/cupy/core_tests/test_ndarray_complex_ops.py::TestScalarConversion::test_scalar_conversion
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayCopyAndView::test_astype
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayCopyAndView::test_astype_type
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayCopyAndView::test_astype_strides
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayCopyAndView::test_astype_strides_broadcast
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayCopyAndView::test_astype_strides_negative
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayCopyAndView::test_astype_strides_swapped
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayCopyAndView::test_astype_type_c_contiguous_no_copy
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayCopyAndView::test_astype_type_f_contiguous_no_copy
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayCopyAndView::test_flatten_copied
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayCopyAndView::test_flatten
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayCopyAndView::test_isinstance_numpy_copy
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayCopyAndView::test_isinstance_numpy_copy_not_slice
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayCopyAndView::test_isinstance_numpy_copy_wrong_dtype
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayCopyAndView::test_isinstance_numpy_copy_wrong_shape
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayCopyAndView::test_view
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayCopyAndView::test_view_0d
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayCopyAndView::test_view_0d_raise
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayCopyAndView::test_view_itemsize
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayCopyAndView::test_view_non_contiguous_raise
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestNumPyArrayCopyView_param_0_{src_order='C'}::test_isinstance_numpy_view_copy_f
-tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestNumPyArrayCopyView_param_1_{src_order='F'}::test_isinstance_numpy_view_copy_f
+
+tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayFlatten::test_flatten_order
+tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayFlatten::test_flatten_order_copied
+tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py::TestArrayFlatten::test_flatten_order_transposed
 
 tests/third_party/cupy/core_tests/test_ndarray_reduction.py::TestArrayReduction::test_ptp_all
 tests/third_party/cupy/core_tests/test_ndarray_reduction.py::TestArrayReduction::test_ptp_all_keepdims
@@ -579,36 +550,21 @@ tests/third_party/cupy/logic_tests/test_comparison.py::TestArrayEqual::test_arra
 tests/third_party/cupy/logic_tests/test_comparison.py::TestArrayEqual::test_array_equal_not_equal
 
 tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_0_{shapes=[(), ()]}::test_broadcast
-tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_0_{shapes=[(), ()]}::test_broadcast_arrays
 tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_10_{shapes=[(0, 1, 1, 0, 3), (5, 2, 0, 1, 0, 0, 3), (2, 1, 0, 0, 0, 3)]}::test_broadcast
-tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_10_{shapes=[(0, 1, 1, 0, 3), (5, 2, 0, 1, 0, 0, 3), (2, 1, 0, 0, 0, 3)]}::test_broadcast_arrays
 tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_1_{shapes=[(0,), (0,)]}::test_broadcast
-tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_1_{shapes=[(0,), (0,)]}::test_broadcast_arrays
 tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_2_{shapes=[(1,), (1,)]}::test_broadcast
-tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_2_{shapes=[(1,), (1,)]}::test_broadcast_arrays
 tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_3_{shapes=[(2,), (2,)]}::test_broadcast
-tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_3_{shapes=[(2,), (2,)]}::test_broadcast_arrays
 tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_4_{shapes=[(0,), (1,)]}::test_broadcast
-tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_4_{shapes=[(0,), (1,)]}::test_broadcast_arrays
 tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_5_{shapes=[(2, 3), (1, 3)]}::test_broadcast
-tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_5_{shapes=[(2, 3), (1, 3)]}::test_broadcast_arrays
 tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_6_{shapes=[(2, 1, 3, 4), (3, 1, 4)]}::test_broadcast
-tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_6_{shapes=[(2, 1, 3, 4), (3, 1, 4)]}::test_broadcast_arrays
 tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_7_{shapes=[(4, 3, 2, 3), (2, 3)]}::test_broadcast
-tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_7_{shapes=[(4, 3, 2, 3), (2, 3)]}::test_broadcast_arrays
 tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_8_{shapes=[(2, 0, 1, 1, 3), (2, 1, 0, 0, 3)]}::test_broadcast
-tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_8_{shapes=[(2, 0, 1, 1, 3), (2, 1, 0, 0, 3)]}::test_broadcast_arrays
 tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_9_{shapes=[(0, 1, 1, 3), (2, 1, 0, 0, 3)]}::test_broadcast
-tests/third_party/cupy/manipulation_tests/test_dims.py::TestBroadcast_param_9_{shapes=[(0, 1, 1, 3), (2, 1, 0, 0, 3)]}::test_broadcast_arrays
-
 tests/third_party/cupy/manipulation_tests/test_dims.py::TestInvalidBroadcast_param_0_{shapes=[(3,), (2,)]}::test_invalid_broadcast
-tests/third_party/cupy/manipulation_tests/test_dims.py::TestInvalidBroadcast_param_0_{shapes=[(3,), (2,)]}::test_invalid_broadcast_arrays
 tests/third_party/cupy/manipulation_tests/test_dims.py::TestInvalidBroadcast_param_1_{shapes=[(3, 2), (2, 3)]}::test_invalid_broadcast
-tests/third_party/cupy/manipulation_tests/test_dims.py::TestInvalidBroadcast_param_1_{shapes=[(3, 2), (2, 3)]}::test_invalid_broadcast_arrays
 tests/third_party/cupy/manipulation_tests/test_dims.py::TestInvalidBroadcast_param_2_{shapes=[(3, 2), (3, 4)]}::test_invalid_broadcast
-tests/third_party/cupy/manipulation_tests/test_dims.py::TestInvalidBroadcast_param_2_{shapes=[(3, 2), (3, 4)]}::test_invalid_broadcast_arrays
 tests/third_party/cupy/manipulation_tests/test_dims.py::TestInvalidBroadcast_param_3_{shapes=[(0,), (2,)]}::test_invalid_broadcast
-tests/third_party/cupy/manipulation_tests/test_dims.py::TestInvalidBroadcast_param_3_{shapes=[(0,), (2,)]}::test_invalid_broadcast_arrays
+
 tests/third_party/cupy/manipulation_tests/test_shape.py::TestRavel::test_ravel2
 tests/third_party/cupy/manipulation_tests/test_shape.py::TestRavel::test_ravel3
 tests/third_party/cupy/manipulation_tests/test_shape.py::TestRavel::test_external_ravel
@@ -618,18 +574,9 @@ tests/third_party/cupy/manipulation_tests/test_shape.py::TestReshape::test_resha
 
 tests/third_party/cupy/manipulation_tests/test_tiling.py::TestRepeatRepeatsNdarray::test_func
 tests/third_party/cupy/manipulation_tests/test_tiling.py::TestRepeatRepeatsNdarray::test_method
-tests/third_party/cupy/manipulation_tests/test_tiling.py::TestTileFailure_param_0_{reps=-1}::test_tile_failure
-tests/third_party/cupy/manipulation_tests/test_tiling.py::TestTileFailure_param_1_{reps=(-1, -2)}::test_tile_failure
-tests/third_party/cupy/manipulation_tests/test_tiling.py::TestTile_param_0_{reps=0}::test_array_tile
-tests/third_party/cupy/manipulation_tests/test_tiling.py::TestTile_param_1_{reps=1}::test_array_tile
-tests/third_party/cupy/manipulation_tests/test_tiling.py::TestTile_param_2_{reps=2}::test_array_tile
-tests/third_party/cupy/manipulation_tests/test_tiling.py::TestTile_param_3_{reps=(0, 1)}::test_array_tile
-tests/third_party/cupy/manipulation_tests/test_tiling.py::TestTile_param_4_{reps=(2, 3)}::test_array_tile
-tests/third_party/cupy/manipulation_tests/test_tiling.py::TestTile_param_5_{reps=(2, 3, 4, 5)}::test_array_tile
 
 tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticRaisesWithNumpyInput_param_3_{name='angle', nargs=1}::test_raises_with_numpy_input
 
-tests/third_party/cupy/math_tests/test_explog.py::TestExplog::test_logaddexp
 tests/third_party/cupy/math_tests/test_explog.py::TestExplog::test_logaddexp2
 tests/third_party/cupy/math_tests/test_explog.py::TestExplog::test_logaddexp2_infinities
 tests/third_party/cupy/math_tests/test_floating.py::TestFloating::test_copysign_float
@@ -640,9 +587,6 @@ tests/third_party/cupy/math_tests/test_floating.py::TestFloating::test_nextafter
 
 tests/third_party/cupy/math_tests/test_misc.py::TestMisc::test_clip_min_max_none
 tests/third_party/cupy/math_tests/test_misc.py::TestMisc::test_external_clip4
-tests/third_party/cupy/math_tests/test_misc.py::TestMisc::test_absolute_negative
-tests/third_party/cupy/math_tests/test_misc.py::TestMisc::test_maximum_nan
-tests/third_party/cupy/math_tests/test_misc.py::TestMisc::test_minimum_nan
 tests/third_party/cupy/math_tests/test_misc.py::TestMisc::test_fmax_nan
 tests/third_party/cupy/math_tests/test_misc.py::TestMisc::test_fmin_nan
 tests/third_party/cupy/math_tests/test_misc.py::TestMisc::test_nan_to_num
@@ -958,10 +902,6 @@ tests/third_party/cupy/random_tests/test_sample.py::TestRandomIntegers2::test_bo
 tests/third_party/cupy/random_tests/test_sample.py::TestRandomIntegers2::test_goodness_of_fit
 tests/third_party/cupy/random_tests/test_sample.py::TestRandomIntegers2::test_goodness_of_fit_2
 
-tests/third_party/cupy/sorting_tests/test_count.py::TestCount::test_count_nonzero
-tests/third_party/cupy/sorting_tests/test_count.py::TestCount::test_count_nonzero_int_axis
-tests/third_party/cupy/sorting_tests/test_count.py::TestCount::test_count_nonzero_tuple_axis
-tests/third_party/cupy/sorting_tests/test_count.py::TestCount::test_count_nonzero_zero_dim
 tests/third_party/cupy/sorting_tests/test_search.py::TestArgMinMaxDtype_param_0_{func='argmin', is_module=True, shape=(3, 4)}::test_argminmax_dtype
 tests/third_party/cupy/sorting_tests/test_search.py::TestArgMinMaxDtype_param_1_{func='argmin', is_module=True, shape=()}::test_argminmax_dtype
 tests/third_party/cupy/sorting_tests/test_search.py::TestArgMinMaxDtype_param_2_{func='argmin', is_module=False, shape=(3, 4)}::test_argminmax_dtype
diff --git a/tests/skipped_tests_gpu_no_fp64.tbl b/tests/skipped_tests_gpu_no_fp64.tbl
index 21aad4100b5..8d197a8d28c 100644
--- a/tests/skipped_tests_gpu_no_fp64.tbl
+++ b/tests/skipped_tests_gpu_no_fp64.tbl
@@ -17,45 +17,22 @@ tests/test_mathematical.py::TestGradient::test_gradient_y1_dx[3.5-array2]
 
 tests/test_strides.py::test_strides_1arg[(10,)-int32-cbrt]
 tests/test_strides.py::test_strides_1arg[(10,)-int32-degrees]
-tests/test_strides.py::test_strides_1arg[(10,)-int32-exp]
 tests/test_strides.py::test_strides_1arg[(10,)-int32-exp2]
-tests/test_strides.py::test_strides_1arg[(10,)-int32-expm1]
 tests/test_strides.py::test_strides_1arg[(10,)-int32-fabs]
-tests/test_strides.py::test_strides_1arg[(10,)-int32-log10]
-tests/test_strides.py::test_strides_1arg[(10,)-int32-log1p]
-tests/test_strides.py::test_strides_1arg[(10,)-int32-log2]
 tests/test_strides.py::test_strides_1arg[(10,)-int32-radians]
 tests/test_strides.py::test_strides_1arg[(10,)-int64-cbrt]
 tests/test_strides.py::test_strides_1arg[(10,)-int64-degrees]
-tests/test_strides.py::test_strides_1arg[(10,)-int64-exp]
 tests/test_strides.py::test_strides_1arg[(10,)-int64-exp2]
-tests/test_strides.py::test_strides_1arg[(10,)-int64-expm1]
 tests/test_strides.py::test_strides_1arg[(10,)-int64-fabs]
-tests/test_strides.py::test_strides_1arg[(10,)-int64-log10]
-tests/test_strides.py::test_strides_1arg[(10,)-int64-log1p]
-tests/test_strides.py::test_strides_1arg[(10,)-int64-log2]
 tests/test_strides.py::test_strides_1arg[(10,)-int64-radians]
 tests/test_strides.py::test_strides_1arg[(10,)-None-cbrt]
 tests/test_strides.py::test_strides_1arg[(10,)-None-degrees]
-tests/test_strides.py::test_strides_1arg[(10,)-None-exp]
 tests/test_strides.py::test_strides_1arg[(10,)-None-exp2]
-tests/test_strides.py::test_strides_1arg[(10,)-None-expm1]
 tests/test_strides.py::test_strides_1arg[(10,)-None-fabs]
-tests/test_strides.py::test_strides_1arg[(10,)-None-log10]
-tests/test_strides.py::test_strides_1arg[(10,)-None-log1p]
-tests/test_strides.py::test_strides_1arg[(10,)-None-log2]
 tests/test_strides.py::test_strides_1arg[(10,)-None-radians]
 
 tests/test_umath.py::test_umaths[('floor_divide', 'ff')]
 
-tests/test_umath.py::TestExp::test_exp
-tests/test_umath.py::TestExp::test_invalid_dtype[numpy.float32]
-tests/test_umath.py::TestExp::test_invalid_dtype[numpy.int64]
-tests/test_umath.py::TestExp::test_invalid_dtype[numpy.int32]
-tests/test_umath.py::TestExp::test_invalid_shape[(0,)]
-tests/test_umath.py::TestExp::test_invalid_shape[(15, )]
-tests/test_umath.py::TestExp::test_invalid_shape[(2,2)]
-
 tests/test_umath.py::TestSqrt::test_sqrt_complex[complex64]
 
 tests/third_party/cupy/linalg_tests/test_eigenvalue.py::TestEigenvalue_param_0_{UPLO='U'}::test_eigh_batched
@@ -146,272 +123,6 @@ tests/third_party/cupy/linalg_tests/test_product.py::TestDotFor0Dim_param_9_{sha
 tests/third_party/cupy/linalg_tests/test_product.py::TestDotFor0Dim_param_10_{shape=((4, 2), ()), trans_a=False, trans_b=True}::test_dot
 tests/third_party/cupy/linalg_tests/test_product.py::TestDotFor0Dim_param_11_{shape=((4, 2), ()), trans_a=False, trans_b=False}::test_dot
 
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticUnary_param_29_{arg1=2.0, name='reciprocal'}::test_unary
-
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_280_{arg1=array([[1., 2., 3.],       [4., 5., 6.]], dtype=float32), arg2=array([[0., 1., 2.],       [3., 4., 5.]], dtype=float32), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_288_{arg1=array([[1., 2., 3.],       [4., 5., 6.]], dtype=float32), arg2=array([[0., 1., 2.],       [3., 4., 5.]]), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_289_{arg1=array([[1., 2., 3.],       [4., 5., 6.]], dtype=float32), arg2=array([[0., 1., 2.],       [3., 4., 5.]]), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_296_{arg1=array([[1., 2., 3.],       [4., 5., 6.]], dtype=float32), arg2=array([[0, 1, 2],       [3, 4, 5]], dtype=int32), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_297_{arg1=array([[1., 2., 3.],       [4., 5., 6.]], dtype=float32), arg2=array([[0, 1, 2],       [3, 4, 5]], dtype=int32), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_304_{arg1=array([[1., 2., 3.],       [4., 5., 6.]], dtype=float32), arg2=array([[0, 1, 2],       [3, 4, 5]]), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_305_{arg1=array([[1., 2., 3.],       [4., 5., 6.]], dtype=float32), arg2=array([[0, 1, 2],       [3, 4, 5]]), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_312_{arg1=array([[1., 2., 3.],       [4., 5., 6.]], dtype=float32), arg2=0, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_320_{arg1=array([[1., 2., 3.],       [4., 5., 6.]], dtype=float32), arg2=0.0, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_328_{arg1=array([[1., 2., 3.],       [4., 5., 6.]], dtype=float32), arg2=2, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_336_{arg1=array([[1., 2., 3.],       [4., 5., 6.]], dtype=float32), arg2=2.0, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_344_{arg1=array([[1., 2., 3.],       [4., 5., 6.]], dtype=float32), arg2=-2, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_352_{arg1=array([[1., 2., 3.],       [4., 5., 6.]], dtype=float32), arg2=-2.0, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_360_{arg1=array([[1., 2., 3.],       [4., 5., 6.]], dtype=float32), arg2=array([[0., 1., 2.],       [3., 4., 5.]], dtype=float32), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_368_{arg1=array([[1., 2., 3.],       [4., 5., 6.]], dtype=float32), arg2=array([[0., 1., 2.],       [3., 4., 5.]]), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_369_{arg1=array([[1., 2., 3.],       [4., 5., 6.]], dtype=float32), arg2=array([[0., 1., 2.],       [3., 4., 5.]]), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_376_{arg1=array([[1., 2., 3.],       [4., 5., 6.]], dtype=float32), arg2=array([[0, 1, 2],       [3, 4, 5]], dtype=int32), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_377_{arg1=array([[1., 2., 3.],       [4., 5., 6.]], dtype=float32), arg2=array([[0, 1, 2],       [3, 4, 5]], dtype=int32), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_384_{arg1=array([[1., 2., 3.],       [4., 5., 6.]], dtype=float32), arg2=array([[0, 1, 2],       [3, 4, 5]]), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_385_{arg1=array([[1., 2., 3.],       [4., 5., 6.]], dtype=float32), arg2=array([[0, 1, 2],       [3, 4, 5]]), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_392_{arg1=array([[1., 2., 3.],       [4., 5., 6.]], dtype=float32), arg2=0, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_400_{arg1=array([[1., 2., 3.],       [4., 5., 6.]], dtype=float32), arg2=0.0, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_408_{arg1=array([[1., 2., 3.],       [4., 5., 6.]], dtype=float32), arg2=2, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_416_{arg1=array([[1., 2., 3.],       [4., 5., 6.]], dtype=float32), arg2=2.0, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_424_{arg1=array([[1., 2., 3.],       [4., 5., 6.]], dtype=float32), arg2=-2, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_432_{arg1=array([[1., 2., 3.],       [4., 5., 6.]], dtype=float32), arg2=-2.0, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_440_{arg1=array([[1, 2, 3],       [4, 5, 6]], dtype=int32), arg2=array([[0., 1., 2.],       [3., 4., 5.]], dtype=float32), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_441_{arg1=array([[1, 2, 3],       [4, 5, 6]], dtype=int32), arg2=array([[0., 1., 2.],       [3., 4., 5.]], dtype=float32), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_448_{arg1=array([[1, 2, 3],       [4, 5, 6]], dtype=int32), arg2=array([[0., 1., 2.],       [3., 4., 5.]]), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_449_{arg1=array([[1, 2, 3],       [4, 5, 6]], dtype=int32), arg2=array([[0., 1., 2.],       [3., 4., 5.]]), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_456_{arg1=array([[1, 2, 3],       [4, 5, 6]], dtype=int32), arg2=array([[0, 1, 2],       [3, 4, 5]], dtype=int32), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_464_{arg1=array([[1, 2, 3],       [4, 5, 6]], dtype=int32), arg2=array([[0, 1, 2],       [3, 4, 5]]), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_472_{arg1=array([[1, 2, 3],       [4, 5, 6]], dtype=int32), arg2=0, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_480_{arg1=array([[1, 2, 3],       [4, 5, 6]], dtype=int32), arg2=0.0, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_481_{arg1=array([[1, 2, 3],       [4, 5, 6]], dtype=int32), arg2=0.0, dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_488_{arg1=array([[1, 2, 3],       [4, 5, 6]], dtype=int32), arg2=2, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_496_{arg1=array([[1, 2, 3],       [4, 5, 6]], dtype=int32), arg2=2.0, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_497_{arg1=array([[1, 2, 3],       [4, 5, 6]], dtype=int32), arg2=2.0, dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_504_{arg1=array([[1, 2, 3],       [4, 5, 6]], dtype=int32), arg2=-2, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_512_{arg1=array([[1, 2, 3],       [4, 5, 6]], dtype=int32), arg2=-2.0, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_513_{arg1=array([[1, 2, 3],       [4, 5, 6]], dtype=int32), arg2=-2.0, dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_520_{arg1=array([[1, 2, 3],       [4, 5, 6]]), arg2=array([[0., 1., 2.],       [3., 4., 5.]], dtype=float32), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_521_{arg1=array([[1, 2, 3],       [4, 5, 6]]), arg2=array([[0., 1., 2.],       [3., 4., 5.]], dtype=float32), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_528_{arg1=array([[1, 2, 3],       [4, 5, 6]]), arg2=array([[0., 1., 2.],       [3., 4., 5.]]), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_529_{arg1=array([[1, 2, 3],       [4, 5, 6]]), arg2=array([[0., 1., 2.],       [3., 4., 5.]]), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_536_{arg1=array([[1, 2, 3],       [4, 5, 6]]), arg2=array([[0, 1, 2],       [3, 4, 5]], dtype=int32), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_544_{arg1=array([[1, 2, 3],       [4, 5, 6]]), arg2=array([[0, 1, 2],       [3, 4, 5]]), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_552_{arg1=array([[1, 2, 3],       [4, 5, 6]]), arg2=0, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_560_{arg1=array([[1, 2, 3],       [4, 5, 6]]), arg2=0.0, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_561_{arg1=array([[1, 2, 3],       [4, 5, 6]]), arg2=0.0, dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_568_{arg1=array([[1, 2, 3],       [4, 5, 6]]), arg2=2, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_576_{arg1=array([[1, 2, 3],       [4, 5, 6]]), arg2=2.0, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_577_{arg1=array([[1, 2, 3],       [4, 5, 6]]), arg2=2.0, dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_584_{arg1=array([[1, 2, 3],       [4, 5, 6]]), arg2=-2, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_592_{arg1=array([[1, 2, 3],       [4, 5, 6]]), arg2=-2.0, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_593_{arg1=array([[1, 2, 3],       [4, 5, 6]]), arg2=-2.0, dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_600_{arg1=0, arg2=array([[0., 1., 2.],       [3., 4., 5.]], dtype=float32), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_608_{arg1=0, arg2=array([[0., 1., 2.],       [3., 4., 5.]]), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_609_{arg1=0, arg2=array([[0., 1., 2.],       [3., 4., 5.]]), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_616_{arg1=0, arg2=array([[0, 1, 2],       [3, 4, 5]], dtype=int32), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_624_{arg1=0, arg2=array([[0, 1, 2],       [3, 4, 5]]), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_680_{arg1=0.0, arg2=array([[0., 1., 2.],       [3., 4., 5.]], dtype=float32), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_688_{arg1=0.0, arg2=array([[0., 1., 2.],       [3., 4., 5.]]), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_689_{arg1=0.0, arg2=array([[0., 1., 2.],       [3., 4., 5.]]), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_696_{arg1=0.0, arg2=array([[0, 1, 2],       [3, 4, 5]], dtype=int32), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_697_{arg1=0.0, arg2=array([[0, 1, 2],       [3, 4, 5]], dtype=int32), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_704_{arg1=0.0, arg2=array([[0, 1, 2],       [3, 4, 5]]), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_705_{arg1=0.0, arg2=array([[0, 1, 2],       [3, 4, 5]]), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_760_{arg1=2, arg2=array([[0., 1., 2.],       [3., 4., 5.]], dtype=float32), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_768_{arg1=2, arg2=array([[0., 1., 2.],       [3., 4., 5.]]), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_769_{arg1=2, arg2=array([[0., 1., 2.],       [3., 4., 5.]]), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_776_{arg1=2, arg2=array([[0, 1, 2],       [3, 4, 5]], dtype=int32), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_784_{arg1=2, arg2=array([[0, 1, 2],       [3, 4, 5]]), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_840_{arg1=2.0, arg2=array([[0., 1., 2.],       [3., 4., 5.]], dtype=float32), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_848_{arg1=2.0, arg2=array([[0., 1., 2.],       [3., 4., 5.]]), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_849_{arg1=2.0, arg2=array([[0., 1., 2.],       [3., 4., 5.]]), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_856_{arg1=2.0, arg2=array([[0, 1, 2],       [3, 4, 5]], dtype=int32), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_857_{arg1=2.0, arg2=array([[0, 1, 2],       [3, 4, 5]], dtype=int32), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_864_{arg1=2.0, arg2=array([[0, 1, 2],       [3, 4, 5]]), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_865_{arg1=2.0, arg2=array([[0, 1, 2],       [3, 4, 5]]), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_920_{arg1=-2, arg2=array([[0., 1., 2.],       [3., 4., 5.]], dtype=float32), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_928_{arg1=-2, arg2=array([[0., 1., 2.],       [3., 4., 5.]]), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_929_{arg1=-2, arg2=array([[0., 1., 2.],       [3., 4., 5.]]), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_936_{arg1=-2, arg2=array([[0, 1, 2],       [3, 4, 5]], dtype=int32), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_944_{arg1=-2, arg2=array([[0, 1, 2],       [3, 4, 5]]), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1000_{arg1=-2.0, arg2=array([[0., 1., 2.],       [3., 4., 5.]], dtype=float32), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1008_{arg1=-2.0, arg2=array([[0., 1., 2.],       [3., 4., 5.]]), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1009_{arg1=-2.0, arg2=array([[0., 1., 2.],       [3., 4., 5.]]), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1016_{arg1=-2.0, arg2=array([[0, 1, 2],       [3, 4, 5]], dtype=int32), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1017_{arg1=-2.0, arg2=array([[0, 1, 2],       [3, 4, 5]], dtype=int32), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1024_{arg1=-2.0, arg2=array([[0, 1, 2],       [3, 4, 5]]), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1025_{arg1=-2.0, arg2=array([[0, 1, 2],       [3, 4, 5]]), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1080_{arg1=array([-3., -2., -1.,  1.,  2.,  3.], dtype=float32), arg2=array([-3., -2., -1.,  1.,  2.,  3.], dtype=float32), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1088_{arg1=array([-3., -2., -1.,  1.,  2.,  3.], dtype=float32), arg2=array([-3., -2., -1.,  1.,  2.,  3.]), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1089_{arg1=array([-3., -2., -1.,  1.,  2.,  3.], dtype=float32), arg2=array([-3., -2., -1.,  1.,  2.,  3.]), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1096_{arg1=array([-3., -2., -1.,  1.,  2.,  3.], dtype=float32), arg2=array([-3, -2, -1,  1,  2,  3], dtype=int32), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1097_{arg1=array([-3., -2., -1.,  1.,  2.,  3.], dtype=float32), arg2=array([-3, -2, -1,  1,  2,  3], dtype=int32), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1104_{arg1=array([-3., -2., -1.,  1.,  2.,  3.], dtype=float32), arg2=array([-3, -2, -1,  1,  2,  3]), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1105_{arg1=array([-3., -2., -1.,  1.,  2.,  3.], dtype=float32), arg2=array([-3, -2, -1,  1,  2,  3]), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1112_{arg1=array([-3., -2., -1.,  1.,  2.,  3.], dtype=float32), arg2=0, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1120_{arg1=array([-3., -2., -1.,  1.,  2.,  3.], dtype=float32), arg2=0.0, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1128_{arg1=array([-3., -2., -1.,  1.,  2.,  3.], dtype=float32), arg2=2, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1136_{arg1=array([-3., -2., -1.,  1.,  2.,  3.], dtype=float32), arg2=2.0, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1144_{arg1=array([-3., -2., -1.,  1.,  2.,  3.], dtype=float32), arg2=-2, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1152_{arg1=array([-3., -2., -1.,  1.,  2.,  3.], dtype=float32), arg2=-2.0, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1160_{arg1=array([-3., -2., -1.,  1.,  2.,  3.]), arg2=array([-3., -2., -1.,  1.,  2.,  3.], dtype=float32), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1161_{arg1=array([-3., -2., -1.,  1.,  2.,  3.]), arg2=array([-3., -2., -1.,  1.,  2.,  3.], dtype=float32), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1168_{arg1=array([-3., -2., -1.,  1.,  2.,  3.]), arg2=array([-3., -2., -1.,  1.,  2.,  3.]), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1169_{arg1=array([-3., -2., -1.,  1.,  2.,  3.]), arg2=array([-3., -2., -1.,  1.,  2.,  3.]), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1176_{arg1=array([-3., -2., -1.,  1.,  2.,  3.]), arg2=array([-3, -2, -1,  1,  2,  3], dtype=int32), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1177_{arg1=array([-3., -2., -1.,  1.,  2.,  3.]), arg2=array([-3, -2, -1,  1,  2,  3], dtype=int32), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1184_{arg1=array([-3., -2., -1.,  1.,  2.,  3.]), arg2=array([-3, -2, -1,  1,  2,  3]), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1185_{arg1=array([-3., -2., -1.,  1.,  2.,  3.]), arg2=array([-3, -2, -1,  1,  2,  3]), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1192_{arg1=array([-3., -2., -1.,  1.,  2.,  3.]), arg2=0, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1193_{arg1=array([-3., -2., -1.,  1.,  2.,  3.]), arg2=0, dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1200_{arg1=array([-3., -2., -1.,  1.,  2.,  3.]), arg2=0.0, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1201_{arg1=array([-3., -2., -1.,  1.,  2.,  3.]), arg2=0.0, dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1208_{arg1=array([-3., -2., -1.,  1.,  2.,  3.]), arg2=2, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1209_{arg1=array([-3., -2., -1.,  1.,  2.,  3.]), arg2=2, dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1216_{arg1=array([-3., -2., -1.,  1.,  2.,  3.]), arg2=2.0, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1217_{arg1=array([-3., -2., -1.,  1.,  2.,  3.]), arg2=2.0, dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1224_{arg1=array([-3., -2., -1.,  1.,  2.,  3.]), arg2=-2, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1225_{arg1=array([-3., -2., -1.,  1.,  2.,  3.]), arg2=-2, dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1232_{arg1=array([-3., -2., -1.,  1.,  2.,  3.]), arg2=-2.0, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1233_{arg1=array([-3., -2., -1.,  1.,  2.,  3.]), arg2=-2.0, dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1240_{arg1=array([-3, -2, -1,  1,  2,  3], dtype=int32), arg2=array([-3., -2., -1.,  1.,  2.,  3.], dtype=float32), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1241_{arg1=array([-3, -2, -1,  1,  2,  3], dtype=int32), arg2=array([-3., -2., -1.,  1.,  2.,  3.], dtype=float32), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1248_{arg1=array([-3, -2, -1,  1,  2,  3], dtype=int32), arg2=array([-3., -2., -1.,  1.,  2.,  3.]), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1249_{arg1=array([-3, -2, -1,  1,  2,  3], dtype=int32), arg2=array([-3., -2., -1.,  1.,  2.,  3.]), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1256_{arg1=array([-3, -2, -1,  1,  2,  3], dtype=int32), arg2=array([-3, -2, -1,  1,  2,  3], dtype=int32), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1264_{arg1=array([-3, -2, -1,  1,  2,  3], dtype=int32), arg2=array([-3, -2, -1,  1,  2,  3]), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1272_{arg1=array([-3, -2, -1,  1,  2,  3], dtype=int32), arg2=0, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1280_{arg1=array([-3, -2, -1,  1,  2,  3], dtype=int32), arg2=0.0, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1281_{arg1=array([-3, -2, -1,  1,  2,  3], dtype=int32), arg2=0.0, dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1288_{arg1=array([-3, -2, -1,  1,  2,  3], dtype=int32), arg2=2, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1296_{arg1=array([-3, -2, -1,  1,  2,  3], dtype=int32), arg2=2.0, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1297_{arg1=array([-3, -2, -1,  1,  2,  3], dtype=int32), arg2=2.0, dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1304_{arg1=array([-3, -2, -1,  1,  2,  3], dtype=int32), arg2=-2, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1312_{arg1=array([-3, -2, -1,  1,  2,  3], dtype=int32), arg2=-2.0, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1313_{arg1=array([-3, -2, -1,  1,  2,  3], dtype=int32), arg2=-2.0, dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1320_{arg1=array([-3, -2, -1,  1,  2,  3]), arg2=array([-3., -2., -1.,  1.,  2.,  3.], dtype=float32), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1321_{arg1=array([-3, -2, -1,  1,  2,  3]), arg2=array([-3., -2., -1.,  1.,  2.,  3.], dtype=float32), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1328_{arg1=array([-3, -2, -1,  1,  2,  3]), arg2=array([-3., -2., -1.,  1.,  2.,  3.]), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1329_{arg1=array([-3, -2, -1,  1,  2,  3]), arg2=array([-3., -2., -1.,  1.,  2.,  3.]), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1336_{arg1=array([-3, -2, -1,  1,  2,  3]), arg2=array([-3, -2, -1,  1,  2,  3], dtype=int32), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1344_{arg1=array([-3, -2, -1,  1,  2,  3]), arg2=array([-3, -2, -1,  1,  2,  3]), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1352_{arg1=array([-3, -2, -1,  1,  2,  3]), arg2=0, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1360_{arg1=array([-3, -2, -1,  1,  2,  3]), arg2=0.0, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1361_{arg1=array([-3, -2, -1,  1,  2,  3]), arg2=0.0, dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1368_{arg1=array([-3, -2, -1,  1,  2,  3]), arg2=2, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1376_{arg1=array([-3, -2, -1,  1,  2,  3]), arg2=2.0, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1377_{arg1=array([-3, -2, -1,  1,  2,  3]), arg2=2.0, dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1384_{arg1=array([-3, -2, -1,  1,  2,  3]), arg2=-2, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1392_{arg1=array([-3, -2, -1,  1,  2,  3]), arg2=-2.0, dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1393_{arg1=array([-3, -2, -1,  1,  2,  3]), arg2=-2.0, dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1400_{arg1=0, arg2=array([-3., -2., -1.,  1.,  2.,  3.], dtype=float32), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1408_{arg1=0, arg2=array([-3., -2., -1.,  1.,  2.,  3.]), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1409_{arg1=0, arg2=array([-3., -2., -1.,  1.,  2.,  3.]), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1416_{arg1=0, arg2=array([-3, -2, -1,  1,  2,  3], dtype=int32), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1424_{arg1=0, arg2=array([-3, -2, -1,  1,  2,  3]), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1480_{arg1=0.0, arg2=array([-3., -2., -1.,  1.,  2.,  3.], dtype=float32), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1488_{arg1=0.0, arg2=array([-3., -2., -1.,  1.,  2.,  3.]), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1489_{arg1=0.0, arg2=array([-3., -2., -1.,  1.,  2.,  3.]), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1496_{arg1=0.0, arg2=array([-3, -2, -1,  1,  2,  3], dtype=int32), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1497_{arg1=0.0, arg2=array([-3, -2, -1,  1,  2,  3], dtype=int32), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1504_{arg1=0.0, arg2=array([-3, -2, -1,  1,  2,  3]), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1505_{arg1=0.0, arg2=array([-3, -2, -1,  1,  2,  3]), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1560_{arg1=2, arg2=array([-3., -2., -1.,  1.,  2.,  3.], dtype=float32), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1568_{arg1=2, arg2=array([-3., -2., -1.,  1.,  2.,  3.]), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1569_{arg1=2, arg2=array([-3., -2., -1.,  1.,  2.,  3.]), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1576_{arg1=2, arg2=array([-3, -2, -1,  1,  2,  3], dtype=int32), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1584_{arg1=2, arg2=array([-3, -2, -1,  1,  2,  3]), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1640_{arg1=2.0, arg2=array([-3., -2., -1.,  1.,  2.,  3.], dtype=float32), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1648_{arg1=2.0, arg2=array([-3., -2., -1.,  1.,  2.,  3.]), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1649_{arg1=2.0, arg2=array([-3., -2., -1.,  1.,  2.,  3.]), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1656_{arg1=2.0, arg2=array([-3, -2, -1,  1,  2,  3], dtype=int32), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1657_{arg1=2.0, arg2=array([-3, -2, -1,  1,  2,  3], dtype=int32), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1664_{arg1=2.0, arg2=array([-3, -2, -1,  1,  2,  3]), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1665_{arg1=2.0, arg2=array([-3, -2, -1,  1,  2,  3]), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1720_{arg1=-2, arg2=array([-3., -2., -1.,  1.,  2.,  3.], dtype=float32), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1728_{arg1=-2, arg2=array([-3., -2., -1.,  1.,  2.,  3.]), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1729_{arg1=-2, arg2=array([-3., -2., -1.,  1.,  2.,  3.]), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1736_{arg1=-2, arg2=array([-3, -2, -1,  1,  2,  3], dtype=int32), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1744_{arg1=-2, arg2=array([-3, -2, -1,  1,  2,  3]), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1800_{arg1=-2.0, arg2=array([-3., -2., -1.,  1.,  2.,  3.], dtype=float32), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1808_{arg1=-2.0, arg2=array([-3., -2., -1.,  1.,  2.,  3.]), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1809_{arg1=-2.0, arg2=array([-3., -2., -1.,  1.,  2.,  3.]), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1816_{arg1=-2.0, arg2=array([-3, -2, -1,  1,  2,  3], dtype=int32), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1817_{arg1=-2.0, arg2=array([-3, -2, -1,  1,  2,  3], dtype=int32), dtype=float64, name='fmod', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1824_{arg1=-2.0, arg2=array([-3, -2, -1,  1,  2,  3]), dtype=float64, name='fmod', use_dtype=True}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_1825_{arg1=-2.0, arg2=array([-3, -2, -1,  1,  2,  3]), dtype=float64, name='fmod', use_dtype=False}::test_binary
-
-tests/third_party/cupy/math_tests/test_explog.py::TestExplog::test_exp
-tests/third_party/cupy/math_tests/test_explog.py::TestExplog::test_exp2
-tests/third_party/cupy/math_tests/test_explog.py::TestExplog::test_expm1
-tests/third_party/cupy/math_tests/test_explog.py::TestExplog::test_log
-tests/third_party/cupy/math_tests/test_explog.py::TestExplog::test_log10
-tests/third_party/cupy/math_tests/test_explog.py::TestExplog::test_log1p
-tests/third_party/cupy/math_tests/test_explog.py::TestExplog::test_log2
-
-tests/third_party/cupy/math_tests/test_floating.py::TestFloating::test_copysign_combination
-
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_0_{axis=0, func='nansum', keepdims=True, shape=(2, 3, 4), transpose_axes=True}::test_nansum_all
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_0_{axis=0, func='nansum', keepdims=True, shape=(2, 3, 4), transpose_axes=True}::test_nansum_axis_transposed
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_1_{axis=0, func='nansum', keepdims=True, shape=(2, 3, 4), transpose_axes=False}::test_nansum_all
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_1_{axis=0, func='nansum', keepdims=True, shape=(2, 3, 4), transpose_axes=False}::test_nansum_axis_transposed
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_2_{axis=0, func='nansum', keepdims=True, shape=(20, 30, 40), transpose_axes=True}::test_nansum_all
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_2_{axis=0, func='nansum', keepdims=True, shape=(20, 30, 40), transpose_axes=True}::test_nansum_axis_transposed
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_3_{axis=0, func='nansum', keepdims=True, shape=(20, 30, 40), transpose_axes=False}::test_nansum_all
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_3_{axis=0, func='nansum', keepdims=True, shape=(20, 30, 40), transpose_axes=False}::test_nansum_axis_transposed
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_4_{axis=0, func='nansum', keepdims=False, shape=(2, 3, 4), transpose_axes=True}::test_nansum_all
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_4_{axis=0, func='nansum', keepdims=False, shape=(2, 3, 4), transpose_axes=True}::test_nansum_axis_transposed
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_5_{axis=0, func='nansum', keepdims=False, shape=(2, 3, 4), transpose_axes=False}::test_nansum_all
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_5_{axis=0, func='nansum', keepdims=False, shape=(2, 3, 4), transpose_axes=False}::test_nansum_axis_transposed
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_6_{axis=0, func='nansum', keepdims=False, shape=(20, 30, 40), transpose_axes=True}::test_nansum_all
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_6_{axis=0, func='nansum', keepdims=False, shape=(20, 30, 40), transpose_axes=True}::test_nansum_axis_transposed
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_7_{axis=0, func='nansum', keepdims=False, shape=(20, 30, 40), transpose_axes=False}::test_nansum_all
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_7_{axis=0, func='nansum', keepdims=False, shape=(20, 30, 40), transpose_axes=False}::test_nansum_axis_transposed
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_8_{axis=0, func='nanprod', keepdims=True, shape=(2, 3, 4), transpose_axes=True}::test_nansum_all
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_8_{axis=0, func='nanprod', keepdims=True, shape=(2, 3, 4), transpose_axes=True}::test_nansum_axis_transposed
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_10_{axis=0, func='nanprod', keepdims=True, shape=(20, 30, 40), transpose_axes=True}::test_nansum_all
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_10_{axis=0, func='nanprod', keepdims=True, shape=(20, 30, 40), transpose_axes=True}::test_nansum_axis_transposed
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_12_{axis=0, func='nanprod', keepdims=False, shape=(2, 3, 4), transpose_axes=True}::test_nansum_all
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_12_{axis=0, func='nanprod', keepdims=False, shape=(2, 3, 4), transpose_axes=True}::test_nansum_axis_transposed
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_14_{axis=0, func='nanprod', keepdims=False, shape=(20, 30, 40), transpose_axes=True}::test_nansum_all
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_14_{axis=0, func='nanprod', keepdims=False, shape=(20, 30, 40), transpose_axes=True}::test_nansum_axis_transposed
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_16_{axis=1, func='nansum', keepdims=True, shape=(2, 3, 4), transpose_axes=True}::test_nansum_all
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_16_{axis=1, func='nansum', keepdims=True, shape=(2, 3, 4), transpose_axes=True}::test_nansum_axis_transposed
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_17_{axis=1, func='nansum', keepdims=True, shape=(2, 3, 4), transpose_axes=False}::test_nansum_all
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_17_{axis=1, func='nansum', keepdims=True, shape=(2, 3, 4), transpose_axes=False}::test_nansum_axis_transposed
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_18_{axis=1, func='nansum', keepdims=True, shape=(20, 30, 40), transpose_axes=True}::test_nansum_all
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_18_{axis=1, func='nansum', keepdims=True, shape=(20, 30, 40), transpose_axes=True}::test_nansum_axis_transposed
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_19_{axis=1, func='nansum', keepdims=True, shape=(20, 30, 40), transpose_axes=False}::test_nansum_all
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_19_{axis=1, func='nansum', keepdims=True, shape=(20, 30, 40), transpose_axes=False}::test_nansum_axis_transposed
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_20_{axis=1, func='nansum', keepdims=False, shape=(2, 3, 4), transpose_axes=True}::test_nansum_all
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_20_{axis=1, func='nansum', keepdims=False, shape=(2, 3, 4), transpose_axes=True}::test_nansum_axis_transposed
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_21_{axis=1, func='nansum', keepdims=False, shape=(2, 3, 4), transpose_axes=False}::test_nansum_all
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_21_{axis=1, func='nansum', keepdims=False, shape=(2, 3, 4), transpose_axes=False}::test_nansum_axis_transposed
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_22_{axis=1, func='nansum', keepdims=False, shape=(20, 30, 40), transpose_axes=True}::test_nansum_all
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_22_{axis=1, func='nansum', keepdims=False, shape=(20, 30, 40), transpose_axes=True}::test_nansum_axis_transposed
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_23_{axis=1, func='nansum', keepdims=False, shape=(20, 30, 40), transpose_axes=False}::test_nansum_all
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_23_{axis=1, func='nansum', keepdims=False, shape=(20, 30, 40), transpose_axes=False}::test_nansum_axis_transposed
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_24_{axis=1, func='nanprod', keepdims=True, shape=(2, 3, 4), transpose_axes=True}::test_nansum_all
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_24_{axis=1, func='nanprod', keepdims=True, shape=(2, 3, 4), transpose_axes=True}::test_nansum_axis_transposed
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_25_{axis=1, func='nanprod', keepdims=True, shape=(2, 3, 4), transpose_axes=False}::test_nansum_all
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_25_{axis=1, func='nanprod', keepdims=True, shape=(2, 3, 4), transpose_axes=False}::test_nansum_axis_transposed
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_26_{axis=1, func='nanprod', keepdims=True, shape=(20, 30, 40), transpose_axes=True}::test_nansum_all
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_26_{axis=1, func='nanprod', keepdims=True, shape=(20, 30, 40), transpose_axes=True}::test_nansum_axis_transposed
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_27_{axis=1, func='nanprod', keepdims=True, shape=(20, 30, 40), transpose_axes=False}::test_nansum_all
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_27_{axis=1, func='nanprod', keepdims=True, shape=(20, 30, 40), transpose_axes=False}::test_nansum_axis_transposed
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_28_{axis=1, func='nanprod', keepdims=False, shape=(2, 3, 4), transpose_axes=True}::test_nansum_all
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_28_{axis=1, func='nanprod', keepdims=False, shape=(2, 3, 4), transpose_axes=True}::test_nansum_axis_transposed
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_29_{axis=1, func='nanprod', keepdims=False, shape=(2, 3, 4), transpose_axes=False}::test_nansum_all
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_29_{axis=1, func='nanprod', keepdims=False, shape=(2, 3, 4), transpose_axes=False}::test_nansum_axis_transposed
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_30_{axis=1, func='nanprod', keepdims=False, shape=(20, 30, 40), transpose_axes=True}::test_nansum_all
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_30_{axis=1, func='nanprod', keepdims=False, shape=(20, 30, 40), transpose_axes=True}::test_nansum_axis_transposed
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_31_{axis=1, func='nanprod', keepdims=False, shape=(20, 30, 40), transpose_axes=False}::test_nansum_all
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_31_{axis=1, func='nanprod', keepdims=False, shape=(20, 30, 40), transpose_axes=False}::test_nansum_axis_transposed
-tests/third_party/cupy/math_tests/test_sumprod.py::TestDiff::test_diff_2dim_with_scalar_append
-
-tests/third_party/cupy/math_tests/test_trigonometric.py::TestTrigonometric::test_deg2rad
-tests/third_party/cupy/math_tests/test_trigonometric.py::TestTrigonometric::test_hypot
-tests/third_party/cupy/math_tests/test_trigonometric.py::TestTrigonometric::test_rad2deg
-
 tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsBeta_param_6_{a_shape=(3, 2), b_shape=(3, 2), shape=(4, 3, 2)}::test_beta
 tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsBeta_param_7_{a_shape=(3, 2), b_shape=(3, 2), shape=(3, 2)}::test_beta
 tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsChisquare_param_0_{df_shape=(), shape=(4, 3, 2)}::test_chisquare
diff --git a/tests/test_arraycreation.py b/tests/test_arraycreation.py
index aead310b5dc..9c7fd6bf060 100644
--- a/tests/test_arraycreation.py
+++ b/tests/test_arraycreation.py
@@ -293,13 +293,15 @@ def test_trace(array, offset, type, dtype):
 
 
 @pytest.mark.parametrize("N", [0, 1, 2, 3, 4], ids=["0", "1", "2", "3", "4"])
-@pytest.mark.parametrize("M", [0, 1, 2, 3, 4], ids=["0", "1", "2", "3", "4"])
+@pytest.mark.parametrize(
+    "M", [None, 0, 1, 2, 3, 4], ids=["None", "0", "1", "2", "3", "4"]
+)
 @pytest.mark.parametrize(
     "k",
     [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
     ids=["-5", "-4", "-3", "-2", "-1", "0", "1", "2", "3", "4", "5"],
 )
-@pytest.mark.parametrize("dtype", get_all_dtypes(no_bool=True, no_complex=True))
+@pytest.mark.parametrize("dtype", get_all_dtypes())
 def test_tri(N, M, k, dtype):
     func = lambda xp: xp.tri(N, M, k, dtype=dtype)
     assert_array_equal(func(dpnp), func(numpy))
diff --git a/tests/test_arraymanipulation.py b/tests/test_arraymanipulation.py
index 1c98c487dfc..455b1881e07 100644
--- a/tests/test_arraymanipulation.py
+++ b/tests/test_arraymanipulation.py
@@ -305,7 +305,6 @@ def test_concatenate_3d(self, dtype):
         dp_res = dpnp.concatenate((dp_a0.T, dp_a1.T, dp_a2.T), axis=0)
         assert_array_equal(dp_res.asnumpy(), np_res)
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     @pytest.mark.parametrize(
         "dtype", get_all_dtypes(no_bool=True, no_none=True)
     )
@@ -329,7 +328,6 @@ def test_concatenate_out(self, dtype):
         assert_array_equal(dp_out.asnumpy(), np_out)
         assert_array_equal(dp_res.asnumpy(), np_res)
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     @pytest.mark.parametrize(
         "dtype", get_all_dtypes(no_bool=True, no_none=True)
     )
@@ -487,7 +485,6 @@ def test_empty_arrays_input(self, dtype):
         dp_res = dpnp.stack(dp_arrays, axis=1)
         assert_array_equal(dp_res.asnumpy(), np_res)
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     @pytest.mark.parametrize("dtype", get_all_dtypes())
     def test_out(self, dtype):
         np_a = numpy.array([1, 2, 3], dtype=dtype)
@@ -536,7 +533,6 @@ def test_generator_input(self):
         with pytest.raises(TypeError):
             dpnp.stack((x for x in range(3)))
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     @pytest.mark.usefixtures("suppress_complex_warning")
     @pytest.mark.parametrize("arr_dtype", get_all_dtypes())
     @pytest.mark.parametrize("dtype", get_all_dtypes(no_none=True))
@@ -552,7 +548,6 @@ def test_casting_dtype(self, arr_dtype, dtype):
         dp_res = dpnp.stack((dp_a, dp_b), axis=1, casting="unsafe", dtype=dtype)
         assert_array_equal(dp_res.asnumpy(), np_res)
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     @pytest.mark.parametrize("arr_dtype", get_float_complex_dtypes())
     @pytest.mark.parametrize("dtype", [dpnp.bool, dpnp.int32, dpnp.int64])
     def test_invalid_casting_dtype(self, arr_dtype, dtype):
@@ -583,11 +578,9 @@ class TestVstack:
     def test_non_iterable(self):
         assert_raises(TypeError, dpnp.vstack, 1)
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     def test_empty_input(self):
-        assert_raises(ValueError, dpnp.vstack, ())
+        assert_raises(TypeError, dpnp.vstack, ())
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     def test_0D_array(self):
         a = dpnp.array(1)
         b = dpnp.array(2)
@@ -595,7 +588,6 @@ def test_0D_array(self):
         desired = dpnp.array([[1], [2]])
         assert_array_equal(res, desired)
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     def test_1D_array(self):
         a = dpnp.array([1])
         b = dpnp.array([2])
@@ -603,7 +595,6 @@ def test_1D_array(self):
         desired = dpnp.array([[1], [2]])
         assert_array_equal(res, desired)
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     def test_2D_array(self):
         a = dpnp.array([[1], [2]])
         b = dpnp.array([[1], [2]])
@@ -611,7 +602,6 @@ def test_2D_array(self):
         desired = dpnp.array([[1], [2], [1], [2]])
         assert_array_equal(res, desired)
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     def test_2D_array2(self):
         a = dpnp.array([1, 2])
         b = dpnp.array([1, 2])
@@ -620,8 +610,8 @@ def test_2D_array2(self):
         assert_array_equal(res, desired)
 
     def test_generator(self):
-        with assert_warns(FutureWarning):
-            dpnp.vstack((numpy.arange(3) for _ in range(2)))
+        with pytest.raises(TypeError):
+            dpnp.vstack((dpnp.arange(3) for _ in range(2)))
 
 
 class TestAtleast1d:
@@ -655,12 +645,6 @@ def test_3D_array(self):
         desired = [a, b]
         assert_array_equal(res, desired)
 
-    def test_r1array(self):
-        assert dpnp.atleast_1d(3).shape == (1,)
-        assert dpnp.atleast_1d(3j).shape == (1,)
-        assert dpnp.atleast_1d(3.0).shape == (1,)
-        assert dpnp.atleast_1d([[2, 3], [4, 5]]).shape == (2, 2)
-
 
 class TestRollaxis:
     data = [
@@ -725,3 +709,242 @@ def test_results(self):
             jp = j + 1 if j < 4 else j
             res = dpnp.rollaxis(dp_a, axis=-ip, start=-jp)
             exp = numpy.rollaxis(np_a, axis=-ip, start=-jp)
+
+
+class TestAtleast2d:
+    def test_0D_array(self):
+        a = dpnp.array(1)
+        b = dpnp.array(2)
+        res = [dpnp.atleast_2d(a), dpnp.atleast_2d(b)]
+        desired = [dpnp.array([[1]]), dpnp.array([[2]])]
+        assert_array_equal(res, desired)
+
+    def test_1D_array(self):
+        a = dpnp.array([1, 2])
+        b = dpnp.array([2, 3])
+        res = [dpnp.atleast_2d(a), dpnp.atleast_2d(b)]
+        desired = [dpnp.array([[1, 2]]), dpnp.array([[2, 3]])]
+        assert_array_equal(res, desired)
+
+    def test_2D_array(self):
+        a = dpnp.array([[1, 2], [1, 2]])
+        b = dpnp.array([[2, 3], [2, 3]])
+        res = [dpnp.atleast_2d(a), dpnp.atleast_2d(b)]
+        desired = [a, b]
+        assert_array_equal(res, desired)
+
+    def test_3D_array(self):
+        a = dpnp.array([[1, 2], [1, 2]])
+        b = dpnp.array([[2, 3], [2, 3]])
+        a = dpnp.array([a, a])
+        b = dpnp.array([b, b])
+        res = [dpnp.atleast_2d(a), dpnp.atleast_2d(b)]
+        desired = [a, b]
+        assert_array_equal(res, desired)
+
+
+class TestAtleast3d:
+    def test_0D_array(self):
+        a = dpnp.array(1)
+        b = dpnp.array(2)
+        res = [dpnp.atleast_3d(a), dpnp.atleast_3d(b)]
+        desired = [dpnp.array([[[1]]]), dpnp.array([[[2]]])]
+        assert_array_equal(res, desired)
+
+    def test_1D_array(self):
+        a = dpnp.array([1, 2])
+        b = dpnp.array([2, 3])
+        res = [dpnp.atleast_3d(a), dpnp.atleast_3d(b)]
+        desired = [dpnp.array([[[1], [2]]]), dpnp.array([[[2], [3]]])]
+        assert_array_equal(res, desired)
+
+    def test_2D_array(self):
+        a = dpnp.array([[1, 2], [1, 2]])
+        b = dpnp.array([[2, 3], [2, 3]])
+        res = [dpnp.atleast_3d(a), dpnp.atleast_3d(b)]
+        desired = [a[:, :, dpnp.newaxis], b[:, :, dpnp.newaxis]]
+        assert_array_equal(res, desired)
+
+    def test_3D_array(self):
+        a = dpnp.array([[1, 2], [1, 2]])
+        b = dpnp.array([[2, 3], [2, 3]])
+        a = dpnp.array([a, a])
+        b = dpnp.array([b, b])
+        res = [dpnp.atleast_3d(a), dpnp.atleast_3d(b)]
+        desired = [a, b]
+        assert_array_equal(res, desired)
+
+
+def assert_broadcast_correct(input_shapes):
+    np_arrays = [numpy.zeros(s, dtype="i1") for s in input_shapes]
+    out_np_arrays = numpy.broadcast_arrays(*np_arrays)
+    dpnp_arrays = [dpnp.asarray(Xnp) for Xnp in np_arrays]
+    out_dpnp_arrays = dpnp.broadcast_arrays(*dpnp_arrays)
+    for Xnp, X in zip(out_np_arrays, out_dpnp_arrays):
+        assert_array_equal(
+            Xnp, dpnp.asnumpy(X), err_msg=f"Failed for {input_shapes})"
+        )
+
+
+def assert_broadcast_arrays_raise(input_shapes):
+    dpnp_arrays = [dpnp.asarray(numpy.zeros(s)) for s in input_shapes]
+    pytest.raises(ValueError, dpnp.broadcast_arrays, *dpnp_arrays)
+
+
+def test_broadcast_arrays_same():
+    Xnp = numpy.arange(10)
+    Ynp = numpy.arange(10)
+    res_Xnp, res_Ynp = numpy.broadcast_arrays(Xnp, Ynp)
+    X = dpnp.asarray(Xnp)
+    Y = dpnp.asarray(Ynp)
+    res_X, res_Y = dpnp.broadcast_arrays(X, Y)
+    assert_array_equal(res_Xnp, dpnp.asnumpy(res_X))
+    assert_array_equal(res_Ynp, dpnp.asnumpy(res_Y))
+
+
+def test_broadcast_arrays_one_off():
+    Xnp = numpy.array([[1, 2, 3]])
+    Ynp = numpy.array([[1], [2], [3]])
+    res_Xnp, res_Ynp = numpy.broadcast_arrays(Xnp, Ynp)
+    X = dpnp.asarray(Xnp)
+    Y = dpnp.asarray(Ynp)
+    res_X, res_Y = dpnp.broadcast_arrays(X, Y)
+    assert_array_equal(res_Xnp, dpnp.asnumpy(res_X))
+    assert_array_equal(res_Ynp, dpnp.asnumpy(res_Y))
+
+
+@pytest.mark.parametrize(
+    "shapes",
+    [
+        (),
+        (1,),
+        (3,),
+        (0, 1),
+        (0, 3),
+        (1, 0),
+        (3, 0),
+        (1, 3),
+        (3, 1),
+        (3, 3),
+    ],
+)
+def test_broadcast_arrays_same_shapes(shapes):
+    for shape in shapes:
+        single_input_shapes = [shape]
+        assert_broadcast_correct(single_input_shapes)
+        double_input_shapes = [shape, shape]
+        assert_broadcast_correct(double_input_shapes)
+        triple_input_shapes = [shape, shape, shape]
+        assert_broadcast_correct(triple_input_shapes)
+
+
+@pytest.mark.parametrize(
+    "shapes",
+    [
+        [[(1,), (3,)]],
+        [[(1, 3), (3, 3)]],
+        [[(3, 1), (3, 3)]],
+        [[(1, 3), (3, 1)]],
+        [[(1, 1), (3, 3)]],
+        [[(1, 1), (1, 3)]],
+        [[(1, 1), (3, 1)]],
+        [[(1, 0), (0, 0)]],
+        [[(0, 1), (0, 0)]],
+        [[(1, 0), (0, 1)]],
+        [[(1, 1), (0, 0)]],
+        [[(1, 1), (1, 0)]],
+        [[(1, 1), (0, 1)]],
+    ],
+)
+def test_broadcast_arrays_same_len_shapes(shapes):
+    # Check that two different input shapes of the same length, but some have
+    # ones, broadcast to the correct shape.
+
+    for input_shapes in shapes:
+        assert_broadcast_correct(input_shapes)
+        assert_broadcast_correct(input_shapes[::-1])
+
+
+@pytest.mark.parametrize(
+    "shapes",
+    [
+        [[(), (3,)]],
+        [[(3,), (3, 3)]],
+        [[(3,), (3, 1)]],
+        [[(1,), (3, 3)]],
+        [[(), (3, 3)]],
+        [[(1, 1), (3,)]],
+        [[(1,), (3, 1)]],
+        [[(1,), (1, 3)]],
+        [[(), (1, 3)]],
+        [[(), (3, 1)]],
+        [[(), (0,)]],
+        [[(0,), (0, 0)]],
+        [[(0,), (0, 1)]],
+        [[(1,), (0, 0)]],
+        [[(), (0, 0)]],
+        [[(1, 1), (0,)]],
+        [[(1,), (0, 1)]],
+        [[(1,), (1, 0)]],
+        [[(), (1, 0)]],
+        [[(), (0, 1)]],
+    ],
+)
+def test_broadcast_arrays_different_len_shapes(shapes):
+    # Check that two different input shapes (of different lengths) broadcast
+    # to the correct shape.
+
+    for input_shapes in shapes:
+        assert_broadcast_correct(input_shapes)
+        assert_broadcast_correct(input_shapes[::-1])
+
+
+@pytest.mark.parametrize(
+    "shapes",
+    [
+        [[(3,), (4,)]],
+        [[(2, 3), (2,)]],
+        [[(3,), (3,), (4,)]],
+        [[(1, 3, 4), (2, 3, 3)]],
+    ],
+)
+def test_incompatible_shapes_raise_valueerror(shapes):
+    for input_shapes in shapes:
+        assert_broadcast_arrays_raise(input_shapes)
+        assert_broadcast_arrays_raise(input_shapes[::-1])
+
+
+def test_broadcast_arrays_empty_input():
+    assert dpnp.broadcast_arrays() == []
+
+
+def test_subok_error():
+    x = dpnp.ones((4))
+    with pytest.raises(NotImplementedError):
+        dpnp.broadcast_arrays(x, subok=True)
+        dpnp.broadcast_to(x, (4, 4), subok=True)
+
+
+def test_can_cast():
+    X = dpnp.ones((2, 2), dtype=dpnp.int64)
+    pytest.raises(TypeError, dpnp.can_cast, X, 1)
+    pytest.raises(TypeError, dpnp.can_cast, X, X)
+
+    X_np = numpy.ones((2, 2), dtype=numpy.int64)
+    assert dpnp.can_cast(X, "float32") == numpy.can_cast(X_np, "float32")
+    assert dpnp.can_cast(X, dpnp.int32) == numpy.can_cast(X_np, numpy.int32)
+    assert dpnp.can_cast(X, dpnp.int64) == numpy.can_cast(X_np, numpy.int64)
+
+
+def test_concatenate_out_dtype():
+    x = dpnp.ones((5, 5))
+    out = dpnp.empty_like(x)
+    with pytest.raises(TypeError):
+        dpnp.concatenate([x], out=out, dtype="i4")
+
+
+def test_stack_out_dtype():
+    x = dpnp.ones((5, 5))
+    out = dpnp.empty_like(x)
+    with pytest.raises(TypeError):
+        dpnp.stack([x], out=out, dtype="i4")
diff --git a/tests/test_counting.py b/tests/test_counting.py
index fa39ad9aee8..c906fffcbe6 100644
--- a/tests/test_counting.py
+++ b/tests/test_counting.py
@@ -1,17 +1,24 @@
 import numpy
 import pytest
+from numpy.testing import (
+    assert_allclose,
+)
 
 import dpnp
 
-
-@pytest.mark.parametrize(
-    "type",
-    [numpy.float64, numpy.float32, numpy.int64, numpy.int32],
-    ids=["float64", "float32", "int64", "int32"],
+from .helper import (
+    get_all_dtypes,
 )
+
+
+@pytest.mark.parametrize("dtype", get_all_dtypes(no_none=True))
 @pytest.mark.parametrize("size", [2, 4, 8, 16, 3, 9, 27, 81])
-def test_count_nonzero(type, size):
-    a = numpy.arange(size, dtype=type)
+def test_count_nonzero(dtype, size):
+    if dtype != dpnp.bool:
+        a = numpy.arange(size, dtype=dtype)
+    else:
+        a = numpy.resize(numpy.arange(2, dtype=dtype), size)
+
     for i in range(int(size / 2)):
         a[(i * (int(size / 3) - 1)) % size] = 0
 
@@ -20,4 +27,4 @@ def test_count_nonzero(type, size):
     np_res = numpy.count_nonzero(a)
     dpnp_res = dpnp.count_nonzero(ia)
 
-    numpy.testing.assert_allclose(dpnp_res, np_res)
+    assert_allclose(dpnp_res, np_res)
diff --git a/tests/test_dparray.py b/tests/test_dparray.py
index 47d8c5ca931..e3f4e80a4cb 100644
--- a/tests/test_dparray.py
+++ b/tests/test_dparray.py
@@ -13,6 +13,7 @@
 )
 
 
+@pytest.mark.usefixtures("suppress_complex_warning")
 @pytest.mark.parametrize("res_dtype", get_all_dtypes())
 @pytest.mark.parametrize("arr_dtype", get_all_dtypes())
 @pytest.mark.parametrize(
@@ -28,6 +29,12 @@ def test_astype(arr, arr_dtype, res_dtype):
     assert_allclose(expected, result)
 
 
+def test_astype_subok_error():
+    x = dpnp.ones((4))
+    with pytest.raises(NotImplementedError):
+        x.astype("i4", subok=False)
+
+
 @pytest.mark.parametrize("arr_dtype", get_all_dtypes())
 @pytest.mark.parametrize(
     "arr",
diff --git a/tests/test_mathematical.py b/tests/test_mathematical.py
index 46dbab5c30a..2a25e7de573 100644
--- a/tests/test_mathematical.py
+++ b/tests/test_mathematical.py
@@ -159,6 +159,18 @@ def test_copysign(self, dtype, lhs, rhs):
     def test_divide(self, dtype, lhs, rhs):
         self._test_mathematical("divide", dtype, lhs, rhs)
 
+    @pytest.mark.parametrize(
+        "dtype", get_all_dtypes(no_bool=True, no_complex=True)
+    )
+    def test_fmax(self, dtype, lhs, rhs):
+        self._test_mathematical("fmax", dtype, lhs, rhs, check_type=False)
+
+    @pytest.mark.parametrize(
+        "dtype", get_all_dtypes(no_bool=True, no_complex=True)
+    )
+    def test_fmin(self, dtype, lhs, rhs):
+        self._test_mathematical("fmin", dtype, lhs, rhs, check_type=False)
+
     @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     @pytest.mark.parametrize(
         "dtype", get_all_dtypes(no_bool=True, no_complex=True)
@@ -187,24 +199,17 @@ def test_floor_divide(self, dtype, lhs, rhs):
             "floor_divide", dtype, lhs, rhs, check_type=False
         )
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     @pytest.mark.parametrize(
         "dtype", get_all_dtypes(no_bool=True, no_complex=True)
     )
     def test_hypot(self, dtype, lhs, rhs):
         self._test_mathematical("hypot", dtype, lhs, rhs)
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
-    @pytest.mark.parametrize(
-        "dtype", get_all_dtypes(no_bool=True, no_complex=True)
-    )
+    @pytest.mark.parametrize("dtype", get_all_dtypes())
     def test_maximum(self, dtype, lhs, rhs):
         self._test_mathematical("maximum", dtype, lhs, rhs, check_type=False)
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
-    @pytest.mark.parametrize(
-        "dtype", get_all_dtypes(no_bool=True, no_complex=True)
-    )
+    @pytest.mark.parametrize("dtype", get_all_dtypes())
     def test_minimum(self, dtype, lhs, rhs):
         self._test_mathematical("minimum", dtype, lhs, rhs, check_type=False)
 
@@ -428,6 +433,32 @@ def test_negative_boolean():
         dpnp.negative(dpnp_a)
 
 
+@pytest.mark.parametrize(
+    "data",
+    [[[1.0, -1.0], [0.1, -0.1]], [-2, -1, 0, 1, 2]],
+    ids=["[[1., -1.], [0.1, -0.1]]", "[-2, -1, 0, 1, 2]"],
+)
+@pytest.mark.parametrize("dtype", get_all_dtypes(no_bool=True))
+def test_positive(data, dtype):
+    np_a = numpy.array(data, dtype=dtype)
+    dpnp_a = dpnp.array(data, dtype=dtype)
+
+    result = dpnp.positive(dpnp_a)
+    expected = numpy.positive(np_a)
+    assert_allclose(result, expected)
+
+    result = +dpnp_a
+    expected = +np_a
+    assert_allclose(result, expected)
+
+
+def test_positive_boolean():
+    dpnp_a = dpnp.array([True, False])
+
+    with pytest.raises(TypeError):
+        dpnp.positive(dpnp_a)
+
+
 @pytest.mark.parametrize(
     "data",
     [[2, 0, -2], [1.1, -1.1]],
@@ -934,6 +965,414 @@ def test_invalid_out(self, out):
         assert_raises(TypeError, numpy.add, a.asnumpy(), 2, out)
 
 
+class TestHypot:
+    @pytest.mark.parametrize("dtype", get_float_dtypes())
+    def test_hypot(self, dtype):
+        array1_data = numpy.arange(10)
+        array2_data = numpy.arange(5, 15)
+        out = numpy.empty(10, dtype=dtype)
+
+        # DPNP
+        dp_array1 = dpnp.array(array1_data, dtype=dtype)
+        dp_array2 = dpnp.array(array2_data, dtype=dtype)
+        dp_out = dpnp.array(out, dtype=dtype)
+        result = dpnp.hypot(dp_array1, dp_array2, out=dp_out)
+
+        # original
+        np_array1 = numpy.array(array1_data, dtype=dtype)
+        np_array2 = numpy.array(array2_data, dtype=dtype)
+        expected = numpy.hypot(np_array1, np_array2, out=out)
+
+        assert_allclose(expected, result)
+        assert_allclose(out, dp_out)
+
+    @pytest.mark.parametrize("dtype", get_float_dtypes())
+    def test_out_dtypes(self, dtype):
+        size = 10
+
+        np_array1 = numpy.arange(size, 2 * size, dtype=dtype)
+        np_array2 = numpy.arange(size, dtype=dtype)
+        np_out = numpy.empty(size, dtype=numpy.float32)
+        expected = numpy.hypot(np_array1, np_array2, out=np_out)
+
+        dp_array1 = dpnp.arange(size, 2 * size, dtype=dtype)
+        dp_array2 = dpnp.arange(size, dtype=dtype)
+
+        dp_out = dpnp.empty(size, dtype=dpnp.float32)
+        if dtype != dpnp.float32:
+            # dtype of out mismatches types of input arrays
+            with pytest.raises(TypeError):
+                dpnp.hypot(dp_array1, dp_array2, out=dp_out)
+
+            # allocate new out with expected type
+            dp_out = dpnp.empty(size, dtype=dtype)
+
+        result = dpnp.hypot(dp_array1, dp_array2, out=dp_out)
+
+        tol = numpy.finfo(numpy.float32).resolution
+        assert_allclose(expected, result, rtol=tol, atol=tol)
+
+    @pytest.mark.parametrize("dtype", get_float_dtypes())
+    def test_out_overlap(self, dtype):
+        size = 15
+        # DPNP
+        dp_a = dpnp.arange(2 * size, dtype=dtype)
+        dpnp.hypot(dp_a[size::], dp_a[::2], out=dp_a[:size:])
+
+        # original
+        np_a = numpy.arange(2 * size, dtype=dtype)
+        numpy.hypot(np_a[size::], np_a[::2], out=np_a[:size:])
+
+        tol = numpy.finfo(numpy.float32).resolution
+        assert_allclose(np_a, dp_a, rtol=tol, atol=tol)
+
+    @pytest.mark.parametrize(
+        "shape", [(0,), (15,), (2, 2)], ids=["(0,)", "(15, )", "(2,2)"]
+    )
+    def test_invalid_shape(self, shape):
+        dp_array1 = dpnp.arange(10)
+        dp_array2 = dpnp.arange(5, 15)
+        dp_out = dpnp.empty(shape)
+
+        with pytest.raises(ValueError):
+            dpnp.hypot(dp_array1, dp_array2, out=dp_out)
+
+    @pytest.mark.parametrize(
+        "out",
+        [4, (), [], (3, 7), [2, 4]],
+        ids=["4", "()", "[]", "(3, 7)", "[2, 4]"],
+    )
+    def test_invalid_out(self, out):
+        a = dpnp.arange(10)
+
+        assert_raises(TypeError, dpnp.hypot, a, 2, out)
+        assert_raises(TypeError, numpy.hypot, a.asnumpy(), 2, out)
+
+
+class TestFmax:
+    @pytest.mark.parametrize(
+        "dtype", get_all_dtypes(no_bool=True, no_complex=True, no_none=True)
+    )
+    def test_fmax(self, dtype):
+        array1_data = numpy.arange(10)
+        array2_data = numpy.arange(5, 15)
+        out = numpy.empty(10, dtype=dtype)
+
+        # DPNP
+        dp_array1 = dpnp.array(array1_data, dtype=dtype)
+        dp_array2 = dpnp.array(array2_data, dtype=dtype)
+        dp_out = dpnp.array(out, dtype=dtype)
+        result = dpnp.fmax(dp_array1, dp_array2, out=dp_out)
+
+        # original
+        np_array1 = numpy.array(array1_data, dtype=dtype)
+        np_array2 = numpy.array(array2_data, dtype=dtype)
+        expected = numpy.fmax(np_array1, np_array2, out=out)
+
+        assert_allclose(expected, result)
+        assert_allclose(out, dp_out)
+
+    @pytest.mark.parametrize(
+        "dtype", get_all_dtypes(no_bool=True, no_complex=True, no_none=True)
+    )
+    def test_out_dtypes(self, dtype):
+        size = 10
+
+        np_array1 = numpy.arange(size, 2 * size, dtype=dtype)
+        np_array2 = numpy.arange(size, dtype=dtype)
+        np_out = numpy.empty(size, dtype=numpy.float32)
+        expected = numpy.fmax(np_array1, np_array2, out=np_out)
+
+        dp_array1 = dpnp.arange(size, 2 * size, dtype=dtype)
+        dp_array2 = dpnp.arange(size, dtype=dtype)
+        with pytest.raises(TypeError):
+            dpnp.fmax(dp_array1, dp_array2, out=np_out)
+
+        dp_out = dpnp.empty(size, dtype=dpnp.float32)
+        result = dpnp.fmax(dp_array1, dp_array2, out=dp_out)
+        assert_array_equal(expected, result)
+
+    @pytest.mark.parametrize(
+        "dtype", get_all_dtypes(no_bool=True, no_complex=True, no_none=True)
+    )
+    def test_out_overlap(self, dtype):
+        size = 15
+        # DPNP
+        dp_a = dpnp.arange(2 * size, dtype=dtype)
+        dpnp.fmax(dp_a[size::], dp_a[::2], out=dp_a[:size:])
+
+        # original
+        np_a = numpy.arange(2 * size, dtype=dtype)
+        numpy.fmax(np_a[size::], np_a[::2], out=np_a[:size:])
+
+        assert_allclose(np_a, dp_a)
+
+    @pytest.mark.parametrize(
+        "shape", [(0,), (15,), (2, 2)], ids=["(0,)", "(15, )", "(2,2)"]
+    )
+    def test_invalid_shape(self, shape):
+        dp_array1 = dpnp.arange(10)
+        dp_array2 = dpnp.arange(5, 15)
+        dp_out = dpnp.empty(shape)
+
+        with pytest.raises(ValueError):
+            dpnp.fmax(dp_array1, dp_array2, out=dp_out)
+
+    @pytest.mark.parametrize(
+        "out",
+        [4, (), [], (3, 7), [2, 4]],
+        ids=["4", "()", "[]", "(3, 7)", "[2, 4]"],
+    )
+    def test_invalid_out(self, out):
+        a = dpnp.arange(10)
+
+        assert_raises(TypeError, dpnp.fmax, a, 2, out)
+        assert_raises(TypeError, numpy.fmax, a.asnumpy(), 2, out)
+
+
+class TestFmin:
+    @pytest.mark.parametrize(
+        "dtype", get_all_dtypes(no_bool=True, no_complex=True, no_none=True)
+    )
+    def test_fmin(self, dtype):
+        array1_data = numpy.arange(10)
+        array2_data = numpy.arange(5, 15)
+        out = numpy.empty(10, dtype=dtype)
+
+        # DPNP
+        dp_array1 = dpnp.array(array1_data, dtype=dtype)
+        dp_array2 = dpnp.array(array2_data, dtype=dtype)
+        dp_out = dpnp.array(out, dtype=dtype)
+        result = dpnp.fmin(dp_array1, dp_array2, out=dp_out)
+
+        # original
+        np_array1 = numpy.array(array1_data, dtype=dtype)
+        np_array2 = numpy.array(array2_data, dtype=dtype)
+        expected = numpy.fmin(np_array1, np_array2, out=out)
+
+        assert_allclose(expected, result)
+        assert_allclose(out, dp_out)
+
+    @pytest.mark.parametrize(
+        "dtype", get_all_dtypes(no_bool=True, no_complex=True, no_none=True)
+    )
+    def test_out_dtypes(self, dtype):
+        size = 10
+
+        np_array1 = numpy.arange(size, 2 * size, dtype=dtype)
+        np_array2 = numpy.arange(size, dtype=dtype)
+        np_out = numpy.empty(size, dtype=numpy.float32)
+        expected = numpy.fmin(np_array1, np_array2, out=np_out)
+
+        dp_array1 = dpnp.arange(size, 2 * size, dtype=dtype)
+        dp_array2 = dpnp.arange(size, dtype=dtype)
+        with pytest.raises(TypeError):
+            dpnp.fmin(dp_array1, dp_array2, out=np_out)
+
+        dp_out = dpnp.empty(size, dtype=dpnp.float32)
+        result = dpnp.fmin(dp_array1, dp_array2, out=dp_out)
+        assert_array_equal(expected, result)
+
+    @pytest.mark.parametrize(
+        "dtype", get_all_dtypes(no_bool=True, no_complex=True, no_none=True)
+    )
+    def test_out_overlap(self, dtype):
+        size = 15
+        # DPNP
+        dp_a = dpnp.arange(2 * size, dtype=dtype)
+        dpnp.fmin(dp_a[size::], dp_a[::2], out=dp_a[:size:])
+
+        # original
+        np_a = numpy.arange(2 * size, dtype=dtype)
+        numpy.fmin(np_a[size::], np_a[::2], out=np_a[:size:])
+
+        assert_allclose(np_a, dp_a)
+
+    @pytest.mark.parametrize(
+        "shape", [(0,), (15,), (2, 2)], ids=["(0,)", "(15, )", "(2,2)"]
+    )
+    def test_invalid_shape(self, shape):
+        dp_array1 = dpnp.arange(10)
+        dp_array2 = dpnp.arange(5, 15)
+        dp_out = dpnp.empty(shape)
+
+        with pytest.raises(ValueError):
+            dpnp.fmin(dp_array1, dp_array2, out=dp_out)
+
+    @pytest.mark.parametrize(
+        "out",
+        [4, (), [], (3, 7), [2, 4]],
+        ids=["4", "()", "[]", "(3, 7)", "[2, 4]"],
+    )
+    def test_invalid_out(self, out):
+        a = dpnp.arange(10)
+
+        assert_raises(TypeError, dpnp.fmin, a, 2, out)
+        assert_raises(TypeError, numpy.fmin, a.asnumpy(), 2, out)
+
+
+class TestMaximum:
+    @pytest.mark.parametrize("dtype", get_all_dtypes(no_none=True))
+    def test_maximum(self, dtype):
+        array1_data = numpy.arange(10)
+        array2_data = numpy.arange(5, 15)
+        out = numpy.empty(10, dtype=dtype)
+
+        # DPNP
+        dp_array1 = dpnp.array(array1_data, dtype=dtype)
+        dp_array2 = dpnp.array(array2_data, dtype=dtype)
+        dp_out = dpnp.array(out, dtype=dtype)
+        result = dpnp.maximum(dp_array1, dp_array2, out=dp_out)
+
+        # original
+        np_array1 = numpy.array(array1_data, dtype=dtype)
+        np_array2 = numpy.array(array2_data, dtype=dtype)
+        expected = numpy.maximum(np_array1, np_array2, out=out)
+
+        assert_allclose(expected, result)
+        assert_allclose(out, dp_out)
+
+    @pytest.mark.parametrize("dtype", get_all_dtypes(no_none=True))
+    def test_out_dtypes(self, dtype):
+        size = 2 if dtype == dpnp.bool else 10
+
+        np_array1 = numpy.arange(size, 2 * size, dtype=dtype)
+        np_array2 = numpy.arange(size, dtype=dtype)
+        np_out = numpy.empty(size, dtype=numpy.complex64)
+        expected = numpy.maximum(np_array1, np_array2, out=np_out)
+
+        dp_array1 = dpnp.arange(size, 2 * size, dtype=dtype)
+        dp_array2 = dpnp.arange(size, dtype=dtype)
+
+        dp_out = dpnp.empty(size, dtype=dpnp.complex64)
+        if dtype != dpnp.complex64:
+            # dtype of out mismatches types of input arrays
+            with pytest.raises(TypeError):
+                dpnp.maximum(dp_array1, dp_array2, out=dp_out)
+
+            # allocate new out with expected type
+            dp_out = dpnp.empty(size, dtype=dtype)
+
+        result = dpnp.maximum(dp_array1, dp_array2, out=dp_out)
+        assert_array_equal(expected, result)
+
+    @pytest.mark.parametrize("dtype", get_all_dtypes(no_none=True))
+    def test_out_overlap(self, dtype):
+        size = 1 if dtype == dpnp.bool else 15
+        # DPNP
+        dp_a = dpnp.arange(2 * size, dtype=dtype)
+        dpnp.maximum(dp_a[size::], dp_a[::2], out=dp_a[:size:])
+
+        # original
+        np_a = numpy.arange(2 * size, dtype=dtype)
+        numpy.maximum(np_a[size::], np_a[::2], out=np_a[:size:])
+
+        assert_allclose(np_a, dp_a)
+
+    @pytest.mark.parametrize(
+        "shape", [(0,), (15,), (2, 2)], ids=["(0,)", "(15, )", "(2,2)"]
+    )
+    def test_invalid_shape(self, shape):
+        dp_array1 = dpnp.arange(10)
+        dp_array2 = dpnp.arange(5, 15)
+        dp_out = dpnp.empty(shape)
+
+        with pytest.raises(ValueError):
+            dpnp.maximum(dp_array1, dp_array2, out=dp_out)
+
+    @pytest.mark.parametrize(
+        "out",
+        [4, (), [], (3, 7), [2, 4]],
+        ids=["4", "()", "[]", "(3, 7)", "[2, 4]"],
+    )
+    def test_invalid_out(self, out):
+        a = dpnp.arange(10)
+
+        assert_raises(TypeError, dpnp.maximum, a, 2, out)
+        assert_raises(TypeError, numpy.maximum, a.asnumpy(), 2, out)
+
+
+class TestMinimum:
+    @pytest.mark.parametrize("dtype", get_all_dtypes(no_none=True))
+    def test_minimum(self, dtype):
+        array1_data = numpy.arange(10)
+        array2_data = numpy.arange(5, 15)
+        out = numpy.empty(10, dtype=dtype)
+
+        # DPNP
+        dp_array1 = dpnp.array(array1_data, dtype=dtype)
+        dp_array2 = dpnp.array(array2_data, dtype=dtype)
+        dp_out = dpnp.array(out, dtype=dtype)
+        result = dpnp.minimum(dp_array1, dp_array2, out=dp_out)
+
+        # original
+        np_array1 = numpy.array(array1_data, dtype=dtype)
+        np_array2 = numpy.array(array2_data, dtype=dtype)
+        expected = numpy.minimum(np_array1, np_array2, out=out)
+
+        assert_allclose(expected, result)
+        assert_allclose(out, dp_out)
+
+    @pytest.mark.parametrize("dtype", get_all_dtypes(no_none=True))
+    def test_out_dtypes(self, dtype):
+        size = 2 if dtype == dpnp.bool else 10
+
+        np_array1 = numpy.arange(size, 2 * size, dtype=dtype)
+        np_array2 = numpy.arange(size, dtype=dtype)
+        np_out = numpy.empty(size, dtype=numpy.complex64)
+        expected = numpy.minimum(np_array1, np_array2, out=np_out)
+
+        dp_array1 = dpnp.arange(size, 2 * size, dtype=dtype)
+        dp_array2 = dpnp.arange(size, dtype=dtype)
+
+        dp_out = dpnp.empty(size, dtype=dpnp.complex64)
+        if dtype != dpnp.complex64:
+            # dtype of out mismatches types of input arrays
+            with pytest.raises(TypeError):
+                dpnp.minimum(dp_array1, dp_array2, out=dp_out)
+
+            # allocate new out with expected type
+            dp_out = dpnp.empty(size, dtype=dtype)
+
+        result = dpnp.minimum(dp_array1, dp_array2, out=dp_out)
+        assert_array_equal(expected, result)
+
+    @pytest.mark.parametrize("dtype", get_all_dtypes(no_none=True))
+    def test_out_overlap(self, dtype):
+        size = 1 if dtype == dpnp.bool else 15
+        # DPNP
+        dp_a = dpnp.arange(2 * size, dtype=dtype)
+        dpnp.minimum(dp_a[size::], dp_a[::2], out=dp_a[:size:])
+
+        # original
+        np_a = numpy.arange(2 * size, dtype=dtype)
+        numpy.minimum(np_a[size::], np_a[::2], out=np_a[:size:])
+
+        assert_allclose(np_a, dp_a)
+
+    @pytest.mark.parametrize(
+        "shape", [(0,), (15,), (2, 2)], ids=["(0,)", "(15, )", "(2,2)"]
+    )
+    def test_invalid_shape(self, shape):
+        dp_array1 = dpnp.arange(10)
+        dp_array2 = dpnp.arange(5, 15)
+        dp_out = dpnp.empty(shape)
+
+        with pytest.raises(ValueError):
+            dpnp.minimum(dp_array1, dp_array2, out=dp_out)
+
+    @pytest.mark.parametrize(
+        "out",
+        [4, (), [], (3, 7), [2, 4]],
+        ids=["4", "()", "[]", "(3, 7)", "[2, 4]"],
+    )
+    def test_invalid_out(self, out):
+        a = dpnp.arange(10)
+
+        assert_raises(TypeError, dpnp.minimum, a, 2, out)
+        assert_raises(TypeError, numpy.minimum, a.asnumpy(), 2, out)
+
+
 class TestMultiply:
     @pytest.mark.parametrize("dtype", get_all_dtypes(no_none=True))
     def test_multiply(self, dtype):
@@ -1208,6 +1647,7 @@ def test_sum_empty_out(dtype):
     assert_array_equal(out.asnumpy(), numpy.array(0, dtype=dtype))
 
 
+@pytest.mark.usefixtures("suppress_complex_warning")
 @pytest.mark.parametrize(
     "shape",
     [
diff --git a/tests/test_random.py b/tests/test_random.py
index 93026f64b0d..1fd058e2d13 100644
--- a/tests/test_random.py
+++ b/tests/test_random.py
@@ -151,9 +151,7 @@ def test_randn_normal_distribution():
     assert math.isclose(mean, expected_mean, abs_tol=0.03)
 
 
-@pytest.mark.skipif(
-    not has_support_aspect64(), reason="Failed on Iris Xe: SAT-5989"
-)
+@pytest.mark.skipif(not has_support_aspect64(), reason="Failed on Iris Xe")
 @pytest.mark.usefixtures("allow_fall_back_on_numpy")
 class TestDistributionsBeta(TestDistribution):
     def test_moments(self):
@@ -179,9 +177,7 @@ def test_seed(self):
         self.check_seed("beta", {"a": a, "b": b})
 
 
-@pytest.mark.skipif(
-    not has_support_aspect64(), reason="Failed on Iris Xe: SAT-5989"
-)
+@pytest.mark.skipif(not has_support_aspect64(), reason="Failed on Iris Xe")
 @pytest.mark.usefixtures("allow_fall_back_on_numpy")
 class TestDistributionsBinomial(TestDistribution):
     def test_extreme_value(self):
@@ -220,9 +216,7 @@ def test_seed(self):
         self.check_seed("binomial", {"n": n, "p": p})
 
 
-@pytest.mark.skipif(
-    not has_support_aspect64(), reason="Failed on Iris Xe: SAT-5989"
-)
+@pytest.mark.skipif(not has_support_aspect64(), reason="Failed on Iris Xe")
 @pytest.mark.usefixtures("allow_fall_back_on_numpy")
 class TestDistributionsChisquare(TestDistribution):
     def test_invalid_args(self):
@@ -234,9 +228,7 @@ def test_seed(self):
         self.check_seed("chisquare", {"df": df})
 
 
-@pytest.mark.skipif(
-    not has_support_aspect64(), reason="Failed on Iris Xe: SAT-5989"
-)
+@pytest.mark.skipif(not has_support_aspect64(), reason="Failed on Iris Xe")
 @pytest.mark.usefixtures("allow_fall_back_on_numpy")
 class TestDistributionsExponential(TestDistribution):
     def test_invalid_args(self):
@@ -248,9 +240,7 @@ def test_seed(self):
         self.check_seed("exponential", {"scale": scale})
 
 
-@pytest.mark.skipif(
-    not has_support_aspect64(), reason="Failed on Iris Xe: SAT-5989"
-)
+@pytest.mark.skipif(not has_support_aspect64(), reason="Failed on Iris Xe")
 @pytest.mark.usefixtures("allow_fall_back_on_numpy")
 class TestDistributionsF(TestDistribution):
     def test_moments(self):
@@ -284,9 +274,7 @@ def test_seed(self):
         self.check_seed("f", {"dfnum": dfnum, "dfden": dfden})
 
 
-@pytest.mark.skipif(
-    not has_support_aspect64(), reason="Failed on Iris Xe: SAT-5989"
-)
+@pytest.mark.skipif(not has_support_aspect64(), reason="Failed on Iris Xe")
 @pytest.mark.usefixtures("allow_fall_back_on_numpy")
 class TestDistributionsGamma(TestDistribution):
     def test_moments(self):
@@ -337,9 +325,7 @@ def test_seed(self):
         self.check_seed("geometric", {"p": p})
 
 
-@pytest.mark.skipif(
-    not has_support_aspect64(), reason="Failed on Iris Xe: SAT-5989"
-)
+@pytest.mark.skipif(not has_support_aspect64(), reason="Failed on Iris Xe")
 @pytest.mark.usefixtures("allow_fall_back_on_numpy")
 class TestDistributionsGumbel(TestDistribution):
     def test_extreme_value(self):
@@ -371,9 +357,7 @@ def test_seed(self):
         self.check_seed("gumbel", {"loc": loc, "scale": scale})
 
 
-@pytest.mark.skipif(
-    not has_support_aspect64(), reason="Failed on Iris Xe: SAT-6001"
-)
+@pytest.mark.skipif(not has_support_aspect64(), reason="Failed on Iris Xe")
 @pytest.mark.usefixtures("allow_fall_back_on_numpy")
 class TestDistributionsHypergeometric(TestDistribution):
     def test_extreme_value(self):
@@ -460,9 +444,7 @@ def test_seed(self):
         )
 
 
-@pytest.mark.skipif(
-    not has_support_aspect64(), reason="Failed on Iris Xe: SAT-5989"
-)
+@pytest.mark.skipif(not has_support_aspect64(), reason="Failed on Iris Xe")
 @pytest.mark.usefixtures("allow_fall_back_on_numpy")
 class TestDistributionsLaplace(TestDistribution):
     def test_extreme_value(self):
@@ -493,9 +475,7 @@ def test_seed(self):
         self.check_seed("laplace", {"loc": loc, "scale": scale})
 
 
-@pytest.mark.skipif(
-    not has_support_aspect64(), reason="Failed on Iris Xe: SAT-5989"
-)
+@pytest.mark.skipif(not has_support_aspect64(), reason="Failed on Iris Xe")
 @pytest.mark.usefixtures("allow_fall_back_on_numpy")
 class TestDistributionsLogistic(TestDistribution):
     def test_moments(self):
@@ -521,9 +501,7 @@ def test_seed(self):
         self.check_seed("logistic", {"loc": loc, "scale": scale})
 
 
-@pytest.mark.skipif(
-    not has_support_aspect64(), reason="Failed on Iris Xe: SAT-5989"
-)
+@pytest.mark.skipif(not has_support_aspect64(), reason="Failed on Iris Xe")
 @pytest.mark.usefixtures("allow_fall_back_on_numpy")
 class TestDistributionsLognormal(TestDistribution):
     def test_extreme_value(self):
@@ -559,9 +537,7 @@ def test_seed(self):
         self.check_seed("lognormal", {"mean": mean, "sigma": sigma})
 
 
-@pytest.mark.skipif(
-    not has_support_aspect64(), reason="Failed on Iris Xe: SAT-5989"
-)
+@pytest.mark.skipif(not has_support_aspect64(), reason="Failed on Iris Xe")
 @pytest.mark.usefixtures("allow_fall_back_on_numpy")
 class TestDistributionsMultinomial(TestDistribution):
     def test_extreme_value(self):
@@ -658,9 +634,7 @@ def test_seed(self):
         self.check_seed("multivariate_normal", {"mean": mean, "cov": cov})
 
 
-@pytest.mark.skipif(
-    not has_support_aspect64(), reason="Failed on Iris Xe: SAT-5989"
-)
+@pytest.mark.skipif(not has_support_aspect64(), reason="Failed on Iris Xe")
 @pytest.mark.usefixtures("allow_fall_back_on_numpy")
 class TestDistributionsNegativeBinomial(TestDistribution):
     def test_extreme_value(self):
@@ -674,10 +648,10 @@ def test_extreme_value(self):
         )
         n = 5
         p = 0.0
-        res = dpnp.asnumpy(dpnp.random.negative_binomial(n=n, p=p, size=10))
-        check_val = numpy.iinfo(res.dtype).min
-        assert len(numpy.unique(res)) == 1
-        assert numpy.unique(res)[0] == check_val
+        res = dpnp.random.negative_binomial(n=n, p=p, size=10)
+        check_val = dpnp.iinfo(res).min
+        assert len(dpnp.unique(res)) == 1
+        assert dpnp.unique(res)[0] == check_val
 
     def test_invalid_args(self):
         n = 10  # parameter `n`, OK
@@ -692,9 +666,7 @@ def test_seed(self):
         self.check_seed("negative_binomial", {"n": n, "p": p})
 
 
-@pytest.mark.skipif(
-    not has_support_aspect64(), reason="Failed on Iris Xe: SAT-5989"
-)
+@pytest.mark.skipif(not has_support_aspect64(), reason="Failed on Iris Xe")
 class TestDistributionsNormal(TestDistribution):
     def test_extreme_value(self):
         loc = 5
@@ -724,9 +696,7 @@ def test_seed(self):
         self.check_seed("normal", {"loc": loc, "scale": scale})
 
 
-@pytest.mark.skipif(
-    not has_support_aspect64(), reason="Failed on Iris Xe: SAT-5989"
-)
+@pytest.mark.skipif(not has_support_aspect64(), reason="Failed on Iris Xe")
 @pytest.mark.usefixtures("allow_fall_back_on_numpy")
 class TestDistributionsNoncentralChisquare:
     @pytest.mark.parametrize(
@@ -772,9 +742,7 @@ def test_seed(self, df):
         assert_allclose(a1, a2, rtol=1e-07, atol=0)
 
 
-@pytest.mark.skipif(
-    not has_support_aspect64(), reason="Failed on Iris Xe: SAT-5989"
-)
+@pytest.mark.skipif(not has_support_aspect64(), reason="Failed on Iris Xe")
 @pytest.mark.usefixtures("allow_fall_back_on_numpy")
 class TestDistributionsPareto(TestDistribution):
     def test_moments(self):
@@ -793,9 +761,7 @@ def test_seed(self):
         self.check_seed("pareto", {"a": a})
 
 
-@pytest.mark.skipif(
-    not has_support_aspect64(), reason="Failed on Iris Xe: SAT-5989"
-)
+@pytest.mark.skipif(not has_support_aspect64(), reason="Failed on Iris Xe")
 @pytest.mark.usefixtures("allow_fall_back_on_numpy")
 class TestDistributionsPoisson(TestDistribution):
     def test_extreme_value(self):
@@ -817,9 +783,7 @@ def test_seed(self):
         self.check_seed("poisson", {"lam": lam})
 
 
-@pytest.mark.skipif(
-    not has_support_aspect64(), reason="Failed on Iris Xe: SAT-5989"
-)
+@pytest.mark.skipif(not has_support_aspect64(), reason="Failed on Iris Xe")
 @pytest.mark.usefixtures("allow_fall_back_on_numpy")
 class TestDistributionsPower(TestDistribution):
     def test_moments(self):
@@ -839,9 +803,7 @@ def test_seed(self):
         self.check_seed("power", {"a": a})
 
 
-@pytest.mark.skipif(
-    not has_support_aspect64(), reason="Failed on Iris Xe: SAT-5989"
-)
+@pytest.mark.skipif(not has_support_aspect64(), reason="Failed on Iris Xe")
 @pytest.mark.usefixtures("allow_fall_back_on_numpy")
 class TestDistributionsRayleigh(TestDistribution):
     def test_extreme_value(self):
@@ -883,9 +845,7 @@ def test_seed(self):
         self.check_seed("standard_exponential", {})
 
 
-@pytest.mark.skipif(
-    not has_support_aspect64(), reason="Failed on Iris Xe: SAT-5989"
-)
+@pytest.mark.skipif(not has_support_aspect64(), reason="Failed on Iris Xe")
 @pytest.mark.usefixtures("allow_fall_back_on_numpy")
 class TestDistributionsStandardGamma(TestDistribution):
     def test_extreme_value(self):
@@ -917,9 +877,7 @@ def test_seed(self):
         self.check_seed("standard_normal", {})
 
 
-@pytest.mark.skipif(
-    not has_support_aspect64(), reason="Failed on Iris Xe: SAT-5989"
-)
+@pytest.mark.skipif(not has_support_aspect64(), reason="Failed on Iris Xe")
 @pytest.mark.usefixtures("allow_fall_back_on_numpy")
 class TestDistributionsStandardT(TestDistribution):
     def test_moments(self):
@@ -938,9 +896,7 @@ def test_seed(self):
         self.check_seed("standard_t", {"df": 10.0})
 
 
-@pytest.mark.skipif(
-    not has_support_aspect64(), reason="Failed on Iris Xe: SAT-5989"
-)
+@pytest.mark.skipif(not has_support_aspect64(), reason="Failed on Iris Xe")
 @pytest.mark.usefixtures("allow_fall_back_on_numpy")
 class TestDistributionsTriangular(TestDistribution):
     def test_moments(self):
@@ -987,9 +943,7 @@ def test_seed(self):
         )
 
 
-@pytest.mark.skipif(
-    not has_support_aspect64(), reason="Failed on Iris Xe: SAT-5989"
-)
+@pytest.mark.skipif(not has_support_aspect64(), reason="Failed on Iris Xe")
 class TestDistributionsUniform(TestDistribution):
     def test_extreme_value(self):
         low = 1.0
@@ -1014,9 +968,7 @@ def test_seed(self):
         self.check_seed("uniform", {"low": low, "high": high})
 
 
-@pytest.mark.skipif(
-    not has_support_aspect64(), reason="Failed on Iris Xe: SAT-5989"
-)
+@pytest.mark.skipif(not has_support_aspect64(), reason="Failed on Iris Xe")
 @pytest.mark.usefixtures("allow_fall_back_on_numpy")
 class TestDistributionsVonmises:
     @pytest.mark.parametrize(
@@ -1057,9 +1009,7 @@ def test_seed(self, kappa):
         assert_allclose(a1, a2, rtol=1e-07, atol=0)
 
 
-@pytest.mark.skipif(
-    not has_support_aspect64(), reason="Failed on Iris Xe: SAT-5989"
-)
+@pytest.mark.skipif(not has_support_aspect64(), reason="Failed on Iris Xe")
 @pytest.mark.usefixtures("allow_fall_back_on_numpy")
 class TestDistributionsWald(TestDistribution):
     def test_moments(self):
@@ -1091,9 +1041,7 @@ def test_seed(self):
         self.check_seed("wald", {"mean": mean, "scale": scale})
 
 
-@pytest.mark.skipif(
-    not has_support_aspect64(), reason="Failed on Iris Xe: SAT-5989"
-)
+@pytest.mark.skipif(not has_support_aspect64(), reason="Failed on Iris Xe")
 @pytest.mark.usefixtures("allow_fall_back_on_numpy")
 class TestDistributionsWeibull(TestDistribution):
     def test_extreme_value(self):
@@ -1110,9 +1058,7 @@ def test_seed(self):
         self.check_seed("weibull", {"a": a})
 
 
-@pytest.mark.skipif(
-    not has_support_aspect64(), reason="Failed on Iris Xe: SAT-5989"
-)
+@pytest.mark.skipif(not has_support_aspect64(), reason="Failed on Iris Xe")
 @pytest.mark.usefixtures("allow_fall_back_on_numpy")
 class TestDistributionsZipf(TestDistribution):
     def test_invalid_args(self):
@@ -1159,14 +1105,15 @@ def test_no_miss_numbers(self, dtype):
         actual_x = dpnp.sort(output_x)
         assert_array_equal(actual_x, desired_x)
 
+    @pytest.mark.skipif(not has_support_aspect64(), reason="Failed on Iris Xe")
     @pytest.mark.parametrize(
         "conv",
         [
             lambda x: dpnp.array([]),
-            # lambda x: dpnp.astype(dpnp.asarray(x), dpnp.int8),
+            lambda x: dpnp.astype(dpnp.asarray(x), dpnp.int8),
             lambda x: dpnp.astype(dpnp.asarray(x), dpnp.float32),
-            # lambda x: dpnp.asarray(x).astype(dpnp.complex64),
-            # lambda x: dpnp.astype(dpnp.asarray(x), object),
+            lambda x: dpnp.asarray(x).astype(dpnp.complex64),
+            lambda x: dpnp.astype(dpnp.asarray(x), object),
             lambda x: dpnp.asarray([[i, i] for i in x]),
             lambda x: dpnp.vstack([x, x]).T,
             lambda x: (
@@ -1180,10 +1127,10 @@ def test_no_miss_numbers(self, dtype):
         ],
         ids=[
             "lambda x: dpnp.array([])",
-            # 'lambda x: dpnp.astype(dpnp.asarray(x), dpnp.int8)',
+            "lambda x: dpnp.astype(dpnp.asarray(x), dpnp.int8)",
             "lambda x: dpnp.astype(dpnp.asarray(x), dpnp.float32)",
-            # 'lambda x: dpnp.asarray(x).astype(dpnp.complex64)',
-            # 'lambda x: dpnp.astype(dpnp.asarray(x), object)',
+            "lambda x: dpnp.asarray(x).astype(dpnp.complex64)",
+            "lambda x: dpnp.astype(dpnp.asarray(x), object)",
             "lambda x: dpnp.asarray([[i, i] for i in x])",
             "lambda x: dpnp.vstack([x, x]).T",
             "lambda x: (dpnp.asarray([(i, i) for i in x], ["
diff --git a/tests/test_random_state.py b/tests/test_random_state.py
index f6be26202fb..4771eadc42e 100644
--- a/tests/test_random_state.py
+++ b/tests/test_random_state.py
@@ -91,9 +91,9 @@ def test_distr(self, dtype, usm_type):
                 )
         # TODO: discuss with opneMKL: there is a difference between CPU and GPU
         # generated samples since 9 digit while precision=15 for float64
-        # precision = numpy.finfo(dtype=dtype).precision
+        # precision = dpnp.finfo(dtype=dtype).precision
         precision = (
-            8 if dtype == dpnp.float64 else numpy.finfo(dtype=dtype).precision
+            8 if dtype == dpnp.float64 else dpnp.finfo(dtype=dtype).precision
         )
         assert_array_almost_equal(
             dpnp_data.asnumpy(), expected, decimal=precision
@@ -136,8 +136,8 @@ def test_scale(self, dtype, usm_type):
         [
             numpy.inf,
             -numpy.inf,
-            numpy.nextafter(numpy.finfo(get_default_floating()).max, 0),
-            numpy.nextafter(numpy.finfo(get_default_floating()).min, 0),
+            numpy.nextafter(dpnp.finfo(get_default_floating()).max, 0),
+            numpy.nextafter(dpnp.finfo(get_default_floating()).min, 0),
         ],
         ids=[
             "numpy.inf",
@@ -170,8 +170,8 @@ def test_inf_loc_scale(self, loc):
 
     def test_extreme_bounds(self):
         dtype = get_default_floating()
-        fmin = numpy.finfo(dtype).min
-        fmax = numpy.finfo(dtype).max
+        fmin = dpnp.finfo(dtype).min
+        fmax = dpnp.finfo(dtype).max
 
         size = 1000
         func = RandomState(34567).normal
@@ -228,7 +228,7 @@ def test_fallback(self, loc, scale):
         )
 
         dtype = get_default_floating()
-        precision = numpy.finfo(dtype=dtype).precision
+        precision = dpnp.finfo(dtype=dtype).precision
         assert_array_almost_equal(actual, expected, decimal=precision)
 
         # check if compute follows data isn't broken
@@ -310,7 +310,7 @@ def test_distr(self, usm_type):
                 dtype=dtype,
             )
 
-        precision = numpy.finfo(dtype=dtype).precision
+        precision = dpnp.finfo(dtype=dtype).precision
         assert_array_almost_equal(data.asnumpy(), expected, decimal=precision)
         assert_cfd(data, sycl_queue, usm_type)
 
@@ -464,8 +464,8 @@ def test_negative_interval(self):
     def test_bounds_checking(self):
         dtype = dpnp.int32
         func = RandomState().randint
-        low = numpy.iinfo(dtype).min
-        high = numpy.iinfo(dtype).max
+        low = dpnp.iinfo(dtype).min
+        high = dpnp.iinfo(dtype).max
 
         # inf can't be converted to int boundary
         assert_raises(OverflowError, func, -numpy.inf, 0)
@@ -486,8 +486,8 @@ def test_bounds_checking(self):
     def test_rng_zero_and_extremes(self):
         dtype = dpnp.int32
         func = RandomState().randint
-        low = numpy.iinfo(dtype).min
-        high = numpy.iinfo(dtype).max
+        low = dpnp.iinfo(dtype).min
+        high = dpnp.iinfo(dtype).max
 
         sycl_device = dpctl.SyclQueue().sycl_device
         if sycl_device.has_aspect_gpu and not sycl_device.has_aspect_fp64:
@@ -507,8 +507,8 @@ def test_rng_zero_and_extremes(self):
 
     def test_full_range(self):
         dtype = dpnp.int32
-        low = numpy.iinfo(dtype).min
-        high = numpy.iinfo(dtype).max
+        low = dpnp.iinfo(dtype).min
+        high = dpnp.iinfo(dtype).max
 
         try:
             RandomState().randint(low, high)
@@ -642,8 +642,8 @@ def test_distr(self, usm_type):
 
         # TODO: discuss with opneMKL: there is a difference between CPU and GPU
         # generated samples since 9 digit while precision=15 for float64
-        # precision = numpy.finfo(dtype=numpy.float64).precision
-        precision = numpy.finfo(dtype=numpy.float32).precision
+        # precision = dpnp.finfo(dtype=numpy.float64).precision
+        precision = dpnp.finfo(dtype=numpy.float32).precision
         assert_array_almost_equal(data.asnumpy(), expected, decimal=precision)
 
         # call with the same seed has to draw the same values
@@ -707,7 +707,7 @@ def test_scalar(self, func):
         rs = RandomState(seed)
         a2 = getattr(rs, func)(size=size).asnumpy()
 
-        precision = numpy.finfo(dtype=numpy.float64).precision
+        precision = dpnp.finfo(dtype=numpy.float64).precision
         assert_array_almost_equal(a1, a2, decimal=precision)
 
     @pytest.mark.usefixtures("allow_fall_back_on_numpy")
@@ -782,8 +782,8 @@ def test_invalid_type(self, seed):
             range(-1, -11, -1),
             numpy.arange(4, dtype=numpy.int32),
             dpnp.arange(-3, 3, dtype=numpy.int32),
-            numpy.iinfo(numpy.uint32).max + 1,
-            (1, 7, numpy.iinfo(numpy.uint32).max + 1),
+            dpnp.iinfo(numpy.uint32).max + 1,
+            (1, 7, dpnp.iinfo(numpy.uint32).max + 1),
         ],
         ids=[
             "-1",
@@ -794,8 +794,8 @@ def test_invalid_type(self, seed):
             "range(-1, -11, -1)",
             "numpy.arange(4, dtype=numpy.int32)",
             "dpnp.arange(-3, 3, dtype=numpy.int32)",
-            "numpy.iinfo(numpy.uint32).max + 1",
-            "(1, 7, numpy.iinfo(numpy.uint32).max + 1)",
+            "dpnp.iinfo(numpy.uint32).max + 1",
+            "(1, 7, dpnp.iinfo(numpy.uint32).max + 1)",
         ],
     )
     def test_invalid_value(self, seed):
@@ -879,8 +879,8 @@ def test_distr(self, usm_type):
 
         # TODO: discuss with opneMKL: there is a difference between CPU and GPU
         # generated samples since 9 digit while precision=15 for float64
-        # precision = numpy.finfo(dtype=numpy.float64).precision
-        precision = numpy.finfo(dtype=numpy.float32).precision
+        # precision = dpnp.finfo(dtype=numpy.float64).precision
+        precision = dpnp.finfo(dtype=numpy.float32).precision
         assert_array_almost_equal(data.asnumpy(), expected, decimal=precision)
 
         # call with the same seed has to draw the same values
@@ -957,7 +957,7 @@ def test_distr(self, usm_type):
                 dtype=dtype,
             )
 
-        precision = numpy.finfo(dtype=dtype).precision
+        precision = dpnp.finfo(dtype=dtype).precision
         assert_array_almost_equal(data.asnumpy(), expected, decimal=precision)
 
         # call with omitted dimensions has to draw the first element from expected
@@ -1042,7 +1042,7 @@ def test_distr(self, bounds, dtype, usm_type):
                     ]
                 )
                 assert_array_almost_equal(
-                    actual, expected, decimal=numpy.finfo(dtype=dtype).precision
+                    actual, expected, decimal=dpnp.finfo(dtype=dtype).precision
                 )
             else:
                 expected = numpy.array([[3, 8], [2, 4], [1, 4]])
@@ -1057,7 +1057,7 @@ def test_distr(self, bounds, dtype, usm_type):
                     ]
                 )
                 assert_array_almost_equal(
-                    actual, expected, decimal=numpy.finfo(dtype=dtype).precision
+                    actual, expected, decimal=dpnp.finfo(dtype=dtype).precision
                 )
             else:
                 expected = numpy.array([[1, 4], [5, 1], [3, 7]])
@@ -1101,13 +1101,13 @@ def test_low_high_equal(self, dtype, usm_type):
             assert_array_equal(actual, expected)
         else:
             assert_array_almost_equal(
-                actual, expected, decimal=numpy.finfo(dtype=dtype).precision
+                actual, expected, decimal=dpnp.finfo(dtype=dtype).precision
             )
 
     @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     def test_range_bounds(self):
-        fmin = numpy.finfo("double").min
-        fmax = numpy.finfo("double").max
+        fmin = dpnp.finfo("double").min
+        fmax = dpnp.finfo("double").max
         func = RandomState().uniform
 
         assert_raises(OverflowError, func, -numpy.inf, 0)
@@ -1146,7 +1146,7 @@ def test_fallback(self, low, high):
         )
 
         dtype = get_default_floating()
-        precision = numpy.finfo(dtype=dtype).precision
+        precision = dpnp.finfo(dtype=dtype).precision
         assert_array_almost_equal(actual, expected, decimal=precision)
 
         # check if compute follows data isn't broken
diff --git a/tests/test_strides.py b/tests/test_strides.py
index 84e794cd053..098ff53f1e0 100644
--- a/tests/test_strides.py
+++ b/tests/test_strides.py
@@ -68,6 +68,7 @@ def test_strides(func_name, dtype):
         "log1p",
         "log2",
         "negative",
+        "positive",
         "radians",
         "sign",
         "sin",
@@ -163,7 +164,10 @@ def test_strides_reciprocal(dtype, shape):
         "add",
         "arctan2",
         "divide",
+        "fmax",
+        "fmin",
         "hypot",
+        "logaddexp",
         "maximum",
         "minimum",
         "multiply",
diff --git a/tests/test_sycl_queue.py b/tests/test_sycl_queue.py
index ac20e508d4e..44852b5f513 100644
--- a/tests/test_sycl_queue.py
+++ b/tests/test_sycl_queue.py
@@ -85,8 +85,10 @@ def vvsort(val, vec, size, xp):
         pytest.param("arange", [-25.7], {"stop": 10**8, "step": 15}),
         pytest.param("full", [(2, 2)], {"fill_value": 5}),
         pytest.param("eye", [4, 2], {}),
+        pytest.param("identity", [4], {}),
         pytest.param("linspace", [0, 4, 8], {}),
         pytest.param("ones", [(2, 2)], {}),
+        pytest.param("tri", [3, 5, 2], {}),
         pytest.param("zeros", [(2, 2)], {}),
     ],
 )
@@ -236,26 +238,34 @@ def test_meshgrid(device_x, device_y):
         pytest.param("arctanh", [-0.5, 0.0, 0.5]),
         pytest.param("ceil", [-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]),
         pytest.param("conjugate", [[1.0 + 1.0j, 0.0], [0.0, 1.0 + 1.0j]]),
+        pytest.param("copy", [1.0, 2.0, 3.0]),
         pytest.param(
             "cos", [-dpnp.pi / 2, -dpnp.pi / 4, 0.0, dpnp.pi / 4, dpnp.pi / 2]
         ),
         pytest.param("cosh", [-5.0, -3.5, 0.0, 3.5, 5.0]),
-        pytest.param("copy", [1.0, 2.0, 3.0]),
+        pytest.param("count_nonzero", [3, 0, 2, -1.2]),
         pytest.param("cumprod", [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]),
         pytest.param("cumsum", [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]),
         pytest.param("diff", [1.0, 2.0, 4.0, 7.0, 0.0]),
         pytest.param("ediff1d", [1.0, 2.0, 4.0, 7.0, 0.0]),
+        pytest.param("exp", [1.0, 2.0, 4.0, 7.0]),
+        pytest.param("expm1", [1.0e-10, 1.0, 2.0, 4.0, 7.0]),
         pytest.param("fabs", [-1.2, 1.2]),
         pytest.param("floor", [-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]),
         pytest.param("gradient", [1.0, 2.0, 4.0, 7.0, 11.0, 16.0]),
         pytest.param(
             "imag", [complex(1.0, 2.0), complex(3.0, 4.0), complex(5.0, 6.0)]
         ),
+        pytest.param("log", [1.0, 2.0, 4.0, 7.0]),
+        pytest.param("log10", [1.0, 2.0, 4.0, 7.0]),
+        pytest.param("log1p", [1.0e-10, 1.0, 2.0, 4.0, 7.0]),
+        pytest.param("log2", [1.0, 2.0, 4.0, 7.0]),
         pytest.param("nancumprod", [1.0, dpnp.nan]),
         pytest.param("nancumsum", [1.0, dpnp.nan]),
         pytest.param("nanprod", [1.0, dpnp.nan]),
         pytest.param("nansum", [1.0, dpnp.nan]),
         pytest.param("negative", [1.0, 0.0, -1.0]),
+        pytest.param("positive", [1.0, 0.0, -1.0]),
         pytest.param("prod", [1.0, 2.0]),
         pytest.param(
             "real", [complex(1.0, 2.0), complex(3.0, 4.0), complex(5.0, 6.0)]
@@ -357,11 +367,23 @@ def test_proj(device):
         pytest.param(
             "floor_divide", [1.0, 2.0, 3.0, 4.0], [2.5, 2.5, 2.5, 2.5]
         ),
+        pytest.param("fmax", [2.0, 3.0, 4.0], [1.0, 5.0, 2.0]),
+        pytest.param("fmin", [2.0, 3.0, 4.0], [1.0, 5.0, 2.0]),
         pytest.param(
             "fmod",
             [-3.0, -2.0, -1.0, 1.0, 2.0, 3.0],
             [2.0, 2.0, 2.0, 2.0, 2.0, 2.0],
         ),
+        pytest.param(
+            "hypot",
+            [[1.0, 2.0, 3.0, 4.0]],
+            [[-1.0, -2.0, -4.0, -5.0]],
+        ),
+        pytest.param(
+            "logaddexp",
+            [[-1, 2, 5, 9]],
+            [[4, -3, 2, -8]],
+        ),
         pytest.param(
             "matmul", [[1.0, 0.0], [0.0, 1.0]], [[4.0, 1.0], [1.0, 2.0]]
         ),
diff --git a/tests/test_umath.py b/tests/test_umath.py
index 791e9eb3022..2b0db66ec0d 100644
--- a/tests/test_umath.py
+++ b/tests/test_umath.py
@@ -509,39 +509,69 @@ def test_invalid_shape(self, shape):
 
 
 class TestExp:
-    def test_exp(self):
-        array_data = numpy.arange(10)
-        out = numpy.empty(10, dtype=numpy.float64)
+    @pytest.mark.parametrize(
+        "dtype", get_all_dtypes(no_bool=True, no_complex=True)
+    )
+    def test_exp(self, dtype):
+        np_array = numpy.arange(10, dtype=dtype)
+        np_out = numpy.empty(10, dtype=numpy.float64)
+
+        # DPNP
+        dp_out_dtype = dpnp.float32
+        if has_support_aspect64() and dtype != dpnp.float32:
+            dp_out_dtype = dpnp.float64
+
+        dp_array = dpnp.array(np_array, dtype=dp_out_dtype)
+        dp_out = dpnp.array(np_out, dtype=dp_out_dtype)
+        result = dpnp.exp(dp_array, out=dp_out)
+
+        # original
+        expected = numpy.exp(np_array, out=np_out)
+
+        tol = numpy.finfo(dtype=result.dtype).resolution
+        assert_allclose(expected, result.asnumpy(), rtol=tol)
+
+    @pytest.mark.parametrize("dtype", get_complex_dtypes())
+    def test_exp_complex(self, dtype):
+        x1 = numpy.linspace(0, 8, num=10)
+        x2 = numpy.linspace(0, 6, num=10)
+        Xnp = x1 + 1j * x2
+        np_array = numpy.asarray(Xnp, dtype=dtype)
+        np_out = numpy.empty(10, dtype=numpy.complex128)
 
         # DPNP
-        dp_array = dpnp.array(array_data, dtype=dpnp.float64)
-        dp_out = dpnp.array(out, dtype=dpnp.float64)
+        dp_out_dtype = dpnp.complex64
+        if has_support_aspect64() and dtype != dpnp.complex64:
+            dp_out_dtype = dpnp.complex128
+
+        dp_array = dpnp.array(np_array, dtype=dp_out_dtype)
+        dp_out = dpnp.array(np_out, dtype=dp_out_dtype)
         result = dpnp.exp(dp_array, out=dp_out)
 
         # original
-        np_array = numpy.array(array_data, dtype=numpy.float64)
-        expected = numpy.exp(np_array, out=out)
+        expected = numpy.exp(np_array, out=np_out)
 
-        assert_array_equal(expected, result)
+        tol = numpy.finfo(dtype=result.dtype).resolution
+        assert_allclose(expected, result.asnumpy(), rtol=tol)
 
     @pytest.mark.parametrize(
-        "dtype",
-        [numpy.float32, numpy.int64, numpy.int32],
-        ids=["numpy.float32", "numpy.int64", "numpy.int32"],
+        "dtype", get_all_dtypes(no_complex=True, no_none=True)[:-1]
     )
     def test_invalid_dtype(self, dtype):
-        dp_array = dpnp.arange(10, dtype=dpnp.float64)
+        dpnp_dtype = get_all_dtypes(no_complex=True, no_none=True)[-1]
+        dp_array = dpnp.arange(10, dtype=dpnp_dtype)
         dp_out = dpnp.empty(10, dtype=dtype)
 
-        with pytest.raises(ValueError):
+        with pytest.raises(TypeError):
             dpnp.exp(dp_array, out=dp_out)
 
+    @pytest.mark.parametrize("dtype", get_float_dtypes())
     @pytest.mark.parametrize(
         "shape", [(0,), (15,), (2, 2)], ids=["(0,)", "(15, )", "(2,2)"]
     )
-    def test_invalid_shape(self, shape):
-        dp_array = dpnp.arange(10, dtype=dpnp.float64)
-        dp_out = dpnp.empty(shape, dtype=dpnp.float64)
+    def test_invalid_shape(self, shape, dtype):
+        dp_array = dpnp.arange(10, dtype=dtype)
+        dp_out = dpnp.empty(shape, dtype=dtype)
 
         with pytest.raises(ValueError):
             dpnp.exp(dp_array, out=dp_out)
diff --git a/tests/test_usm_type.py b/tests/test_usm_type.py
index bd55670b2a6..fd94ff01fdb 100644
--- a/tests/test_usm_type.py
+++ b/tests/test_usm_type.py
@@ -2,10 +2,14 @@
 
 import dpctl.tensor as dpt
 import dpctl.utils as du
+import numpy
 import pytest
+from numpy.testing import assert_allclose
 
 import dpnp as dp
 
+from .helper import assert_dtype_allclose
+
 list_of_usm_types = ["device", "shared", "host"]
 
 
@@ -147,7 +151,7 @@ def test_coerced_usm_types_power(usm_type_x, usm_type_y):
 )
 @pytest.mark.parametrize("usm_type_x", list_of_usm_types, ids=list_of_usm_types)
 @pytest.mark.parametrize("usm_type_y", list_of_usm_types, ids=list_of_usm_types)
-def test_array_creation(func, args, usm_type_x, usm_type_y):
+def test_array_creation_from_an_array(func, args, usm_type_x, usm_type_y):
     x0 = dp.full(10, 3, usm_type=usm_type_x)
     new_args = [eval(val, {"x0": x0}) for val in args]
 
@@ -158,6 +162,33 @@ def test_array_creation(func, args, usm_type_x, usm_type_y):
     assert y.usm_type == usm_type_y
 
 
+@pytest.mark.parametrize(
+    "func, arg, kwargs",
+    [
+        pytest.param("arange", [-25.7], {"stop": 10**8, "step": 15}),
+        pytest.param("full", [(2, 2)], {"fill_value": 5}),
+        pytest.param("eye", [4, 2], {}),
+        pytest.param("identity", [4], {}),
+        pytest.param("linspace", [0, 4, 8], {}),
+        pytest.param("ones", [(2, 2)], {}),
+        pytest.param("tri", [3, 5, 2], {}),
+        pytest.param("zeros", [(2, 2)], {}),
+    ],
+)
+@pytest.mark.parametrize("usm_type", list_of_usm_types, ids=list_of_usm_types)
+def test_array_creation_from_scratch(func, arg, kwargs, usm_type):
+    dpnp_kwargs = dict(kwargs)
+    dpnp_kwargs["usm_type"] = usm_type
+    dpnp_array = getattr(dp, func)(*arg, **dpnp_kwargs)
+    numpy_array = getattr(numpy, func)(*arg, dtype=dpnp_array.dtype, **kwargs)
+
+    tol = 1e-06
+    assert_allclose(dpnp_array, numpy_array, rtol=tol, atol=tol)
+    assert dpnp_array.shape == numpy_array.shape
+    assert_dtype_allclose(dpnp_array, numpy_array)
+    assert dpnp_array.usm_type == usm_type
+
+
 @pytest.mark.parametrize(
     "func",
     [
@@ -294,6 +325,7 @@ def test_meshgrid(usm_type_x, usm_type_y):
 @pytest.mark.parametrize(
     "func,data",
     [
+        pytest.param("abs", [-1.2, 1.2]),
         pytest.param("arccos", [-0.5, 0.0, 0.5]),
         pytest.param("arccosh", [1.5, 3.5, 5.0]),
         pytest.param("arcsin", [-0.5, 0.0, 0.5]),
@@ -306,11 +338,19 @@ def test_meshgrid(usm_type_x, usm_type_y):
             "cos", [-dp.pi / 2, -dp.pi / 4, 0.0, dp.pi / 4, dp.pi / 2]
         ),
         pytest.param("cosh", [-5.0, -3.5, 0.0, 3.5, 5.0]),
+        pytest.param("count_nonzero", [0, 1, 7, 0]),
+        pytest.param("exp", [1.0, 2.0, 4.0, 7.0]),
+        pytest.param("expm1", [1.0e-10, 1.0, 2.0, 4.0, 7.0]),
         pytest.param("floor", [-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]),
         pytest.param(
             "imag", [complex(1.0, 2.0), complex(3.0, 4.0), complex(5.0, 6.0)]
         ),
+        pytest.param("log", [1.0, 2.0, 4.0, 7.0]),
+        pytest.param("log10", [1.0, 2.0, 4.0, 7.0]),
+        pytest.param("log1p", [1.0e-10, 1.0, 2.0, 4.0, 7.0]),
+        pytest.param("log2", [1.0, 2.0, 4.0, 7.0]),
         pytest.param("negative", [1.0, 0.0, -1.0]),
+        pytest.param("positive", [1.0, 0.0, -1.0]),
         pytest.param("proj", [complex(1.0, 2.0), complex(dp.inf, -1.0)]),
         pytest.param(
             "real", [complex(1.0, 2.0), complex(3.0, 4.0), complex(5.0, 6.0)]
@@ -355,6 +395,36 @@ def test_1in_1out(func, data, usm_type):
             [[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]],
             [[4.0, 4.0], [4.0, 4.0], [4.0, 4.0]],
         ),
+        pytest.param(
+            "fmax",
+            [[0.0, 1.0, 2.0]],
+            [[3.0, 4.0, 5.0]],
+        ),
+        pytest.param(
+            "fmin",
+            [[0.0, 1.0, 2.0]],
+            [[3.0, 4.0, 5.0]],
+        ),
+        pytest.param(
+            "hypot",
+            [[1.0, 2.0, 3.0, 4.0]],
+            [[-1.0, -2.0, -4.0, -5.0]],
+        ),
+        pytest.param(
+            "logaddexp",
+            [[-1, 2, 5, 9]],
+            [[4, -3, 2, -8]],
+        ),
+        pytest.param(
+            "maximum",
+            [[0.0, 1.0, 2.0]],
+            [[3.0, 4.0, 5.0]],
+        ),
+        pytest.param(
+            "minimum",
+            [[0.0, 1.0, 2.0]],
+            [[3.0, 4.0, 5.0]],
+        ),
     ],
 )
 @pytest.mark.parametrize("usm_type_x", list_of_usm_types, ids=list_of_usm_types)
diff --git a/tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py b/tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py
index 096f891e239..dd5e56b0a81 100644
--- a/tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py
+++ b/tests/third_party/cupy/core_tests/test_ndarray_copy_and_view.py
@@ -1,13 +1,9 @@
-import unittest
-
 import numpy
 import pytest
 
 import dpnp as cupy
 from tests.third_party.cupy import testing
 
-# from cupy import util
-
 
 def astype_without_warning(x, dtype, *args, **kwargs):
     dtype = numpy.dtype(dtype)
@@ -18,8 +14,14 @@ def astype_without_warning(x, dtype, *args, **kwargs):
         return x.astype(dtype, *args, **kwargs)
 
 
-@testing.gpu
-class TestArrayCopyAndView(unittest.TestCase):
+def get_strides(xp, a):
+    if xp is numpy:
+        return tuple(el // a.itemsize for el in a.strides)
+    return a.strides
+
+
+@pytest.mark.skip("'dpnp_array' object has no attribute 'view' yet")
+class TestView:
     @testing.numpy_cupy_array_equal()
     def test_view(self, xp):
         a = testing.shaped_arange((4,), xp, dtype=numpy.float32)
@@ -54,6 +56,173 @@ def test_view_non_contiguous_raise(self, dtype):
             with pytest.raises(ValueError):
                 a.view(dtype=dtype)
 
+    @testing.for_dtypes([numpy.int16, numpy.int64])
+    @testing.with_requires("numpy>=1.23")
+    def test_view_f_contiguous(self, dtype):
+        for xp in (numpy, cupy):
+            a = testing.shaped_arange((2, 2, 2), xp, dtype=numpy.float32)
+            a = a.T
+            with pytest.raises(ValueError):
+                a.view(dtype=dtype)
+
+    def test_view_assert_divisible(self):
+        for xp in (numpy, cupy):
+            a = testing.shaped_arange((3,), xp, dtype=numpy.int32)
+            with pytest.raises(ValueError):
+                a.view(dtype=numpy.int64)
+
+    @testing.for_dtypes([numpy.float32, numpy.float64])
+    @testing.numpy_cupy_array_equal(strides_check=True)
+    def test_view_relaxed_contiguous(self, xp, dtype):
+        a = testing.shaped_arange((1, 3, 5), xp, dtype=dtype)
+        a = xp.moveaxis(a, 0, 2)  # (3, 5, 1)
+        b = a.view(dtype=numpy.int32)
+        return b
+
+    @pytest.mark.parametrize(
+        ("order", "shape"),
+        [
+            ("C", (3,)),
+            ("C", (3, 5)),
+            ("C", (0,)),
+            ("C", (1, 3)),
+            ("C", (3, 1)),
+        ],
+        ids=str,
+    )
+    @testing.numpy_cupy_equal()
+    def test_view_flags_smaller(self, xp, order, shape):
+        a = xp.zeros(shape, numpy.int32, order)
+        b = a.view(numpy.int16)
+        return b.flags.c_contiguous, b.flags.f_contiguous, b.flags.owndata
+
+    @pytest.mark.parametrize(
+        ("order", "shape"),
+        [
+            ("F", (3, 5)),
+        ],
+        ids=str,
+    )
+    @testing.with_requires("numpy>=1.23")
+    def test_view_flags_smaller_invalid(self, order, shape):
+        for xp in (numpy, cupy):
+            a = xp.zeros(shape, numpy.int32, order)
+            with pytest.raises(ValueError):
+                a.view(numpy.int16)
+
+    @pytest.mark.parametrize(
+        ("order", "shape"),
+        [
+            ("C", (6,)),
+            ("C", (3, 10)),
+            ("C", (0,)),
+            ("C", (1, 6)),
+            ("C", (3, 2)),
+        ],
+        ids=str,
+    )
+    @testing.numpy_cupy_equal()
+    def test_view_flags_larger(self, xp, order, shape):
+        a = xp.zeros(shape, numpy.int16, order)
+        b = a.view(numpy.int32)
+        return b.flags.c_contiguous, b.flags.f_contiguous, b.flags.owndata
+
+    @pytest.mark.parametrize(
+        ("order", "shape"),
+        [
+            ("F", (6, 5)),
+            ("F", (2, 3)),
+        ],
+        ids=str,
+    )
+    @testing.with_requires("numpy>=1.23")
+    def test_view_flags_larger_invalid(self, order, shape):
+        for xp in (numpy, cupy):
+            a = xp.zeros(shape, numpy.int16, order)
+            with pytest.raises(ValueError):
+                a.view(numpy.int32)
+
+    @testing.with_requires("numpy>=1.23")
+    @testing.numpy_cupy_array_equal()
+    def test_view_smaller_dtype_multiple(self, xp):
+        # x is non-contiguous
+        x = xp.arange(10, dtype=xp.int32)[::2]
+        with pytest.raises(ValueError):
+            x.view(xp.int16)
+        return x[:, xp.newaxis].view(xp.int16)
+
+    @testing.with_requires("numpy>=1.23")
+    @testing.numpy_cupy_array_equal()
+    def test_view_smaller_dtype_multiple2(self, xp):
+        # x is non-contiguous, and stride[-1] != 0
+        x = xp.ones((3, 4), xp.int32)[:, :1:2]
+        return x.view(xp.int16)
+
+    @testing.with_requires("numpy>=1.23")
+    @testing.numpy_cupy_array_equal()
+    def test_view_larger_dtype_multiple(self, xp):
+        # x is non-contiguous in the first dimension, contiguous in the last
+        x = xp.arange(20, dtype=xp.int16).reshape(10, 2)[::2, :]
+        return x.view(xp.int32)
+
+    @testing.with_requires("numpy>=1.23")
+    @testing.numpy_cupy_array_equal()
+    def test_view_non_c_contiguous(self, xp):
+        # x is contiguous in axis=-1, but not C-contiguous in other axes
+        x = (
+            xp.arange(2 * 3 * 4, dtype=xp.int8)
+            .reshape(2, 3, 4)
+            .transpose(1, 0, 2)
+        )
+        return x.view(xp.int16)
+
+    @testing.numpy_cupy_array_equal()
+    def test_view_larger_dtype_zero_sized(self, xp):
+        x = xp.ones((3, 20), xp.int16)[:0, ::2]
+        return x.view(xp.int32)
+
+
+class TestArrayCopy:
+    @testing.for_orders("CF")
+    @testing.for_dtypes(
+        [numpy.int16, numpy.int64, numpy.float16, numpy.float64]
+    )
+    @testing.numpy_cupy_array_equal()
+    def test_isinstance_numpy_copy(self, xp, dtype, order):
+        a = numpy.arange(100, dtype=dtype).reshape(10, 10, order=order)
+        b = xp.empty(a.shape, dtype=dtype, order=order)
+        b[:] = a
+        return b
+
+    @pytest.mark.skip("Doesn't raise ValueError in numpy")
+    def test_isinstance_numpy_copy_wrong_dtype(self):
+        a = numpy.arange(100, dtype=numpy.float32).reshape(10, 10)
+        b = cupy.empty(a.shape, dtype=numpy.int32)
+        with pytest.raises(ValueError):
+            b[:] = a
+
+    def test_isinstance_numpy_copy_wrong_shape(self):
+        for xp in (numpy, cupy):
+            a = numpy.arange(100, dtype=numpy.float32).reshape(10, 10)
+            b = cupy.empty(100, dtype=a.dtype)
+            with pytest.raises(ValueError):
+                b[:] = a
+
+    @testing.numpy_cupy_array_equal()
+    def test_isinstance_numpy_copy_not_slice(self, xp):
+        a = xp.arange(5, dtype=numpy.float32)
+        a[a < 3] = 0
+        return a
+
+    @pytest.mark.skip("copy from host to device is allowed")
+    def test_copy_host_to_device_view(self):
+        dev = cupy.empty((10, 10), dtype=numpy.float32)[2:5, 1:8]
+        host = numpy.arange(3 * 7, dtype=numpy.float32).reshape(3, 7)
+        with pytest.raises(ValueError):
+            dev[:] = host
+
+
+class TestArrayFlatten:
     @testing.numpy_cupy_array_equal()
     def test_flatten(self, xp):
         a = testing.shaped_arange((2, 3, 4), xp)
@@ -67,10 +236,32 @@ def test_flatten_copied(self, xp):
         return b
 
     @testing.numpy_cupy_array_equal()
-    def test_transposed_flatten(self, xp):
+    def test_flatten_transposed(self, xp):
         a = testing.shaped_arange((2, 3, 4), xp).transpose(2, 0, 1)
         return a.flatten()
 
+    @testing.for_orders("CFAK")
+    @testing.numpy_cupy_array_equal()
+    def test_flatten_order(self, xp, order):
+        a = testing.shaped_arange((2, 3, 4), xp)
+        return a.flatten(order)
+
+    @testing.for_orders("CFAK")
+    @testing.numpy_cupy_array_equal()
+    def test_flatten_order_copied(self, xp, order):
+        a = testing.shaped_arange((4,), xp)
+        b = a.flatten(order=order)
+        a[:] = 1
+        return b
+
+    @testing.for_orders("CFAK")
+    @testing.numpy_cupy_array_equal()
+    def test_flatten_order_transposed(self, xp, order):
+        a = testing.shaped_arange((2, 3, 4), xp).transpose(2, 0, 1)
+        return a.flatten(order=order)
+
+
+class TestArrayFill:
     @testing.for_all_dtypes()
     @testing.numpy_cupy_array_equal()
     def test_fill(self, xp, dtype):
@@ -78,18 +269,32 @@ def test_fill(self, xp, dtype):
         a.fill(1)
         return a
 
-    @testing.for_all_dtypes()
-    @testing.numpy_cupy_array_equal()
-    def test_fill_with_numpy_scalar_ndarray(self, xp, dtype):
-        a = testing.shaped_arange((2, 3, 4), xp, dtype)
-        a.fill(numpy.ones((), dtype=dtype))
+    @testing.with_requires("numpy>=1.24.0")
+    @testing.for_all_dtypes_combination(("dtype1", "dtype2"))
+    @testing.numpy_cupy_array_equal(accept_error=numpy.ComplexWarning)
+    def test_fill_with_numpy_scalar_ndarray(self, xp, dtype1, dtype2):
+        a = testing.shaped_arange((2, 3, 4), xp, dtype1)
+        a.fill(numpy.ones((), dtype=dtype2))
+        return a
+
+    @testing.with_requires("numpy>=1.24.0")
+    @testing.for_all_dtypes_combination(("dtype1", "dtype2"))
+    @testing.numpy_cupy_array_equal(accept_error=numpy.ComplexWarning)
+    def test_fill_with_cupy_scalar_ndarray(self, xp, dtype1, dtype2):
+        a = testing.shaped_arange((2, 3, 4), xp, dtype1)
+        b = xp.ones((), dtype=dtype2)
+        a.fill(b)
         return a
 
+    @pytest.mark.skip(
+        "it's allowed to broadcast dpnp array while filling, no exception then"
+    )
     @testing.for_all_dtypes()
-    def test_fill_with_numpy_nonscalar_ndarray(self, dtype):
+    def test_fill_with_nonscalar_ndarray(self, dtype):
         a = testing.shaped_arange((2, 3, 4), cupy, dtype)
-        with self.assertRaises(ValueError):
-            a.fill(numpy.ones((1,), dtype=dtype))
+        for xp in (numpy, cupy):
+            with pytest.raises(ValueError):
+                a.fill(xp.ones((1,), dtype=dtype))
 
     @testing.for_all_dtypes()
     @testing.numpy_cupy_array_equal()
@@ -99,6 +304,8 @@ def test_transposed_fill(self, xp, dtype):
         b.fill(1)
         return b
 
+
+class TestArrayAsType:
     @testing.for_orders(["C", "F", "A", "K", None])
     @testing.for_all_dtypes_combination(("src_dtype", "dst_dtype"))
     @testing.numpy_cupy_array_equal()
@@ -106,6 +313,13 @@ def test_astype(self, xp, src_dtype, dst_dtype, order):
         a = testing.shaped_arange((2, 3, 4), xp, src_dtype)
         return astype_without_warning(a, dst_dtype, order=order)
 
+    @testing.for_orders(["C", "F", "A", "K", None])
+    @testing.for_all_dtypes_combination(("src_dtype", "dst_dtype"))
+    @testing.numpy_cupy_array_equal()
+    def test_astype_empty(self, xp, src_dtype, dst_dtype, order):
+        a = testing.shaped_arange((2, 0, 4), xp, src_dtype)
+        return astype_without_warning(a, dst_dtype, order=order)
+
     @testing.for_orders("CFAK")
     @testing.for_all_dtypes_combination(("src_dtype", "dst_dtype"))
     def test_astype_type(self, src_dtype, dst_dtype, order):
@@ -113,14 +327,14 @@ def test_astype_type(self, src_dtype, dst_dtype, order):
         b = astype_without_warning(a, dst_dtype, order=order)
         a_cpu = testing.shaped_arange((2, 3, 4), numpy, src_dtype)
         b_cpu = astype_without_warning(a_cpu, dst_dtype, order=order)
-        self.assertEqual(b.dtype.type, b_cpu.dtype.type)
+        assert b.dtype.type == b_cpu.dtype.type
 
     @testing.for_orders("CAK")
     @testing.for_all_dtypes()
     def test_astype_type_c_contiguous_no_copy(self, dtype, order):
         a = testing.shaped_arange((2, 3, 4), cupy, dtype)
         b = a.astype(dtype, order=order, copy=False)
-        self.assertTrue(b is a)
+        assert b is a
 
     @testing.for_orders("FAK")
     @testing.for_all_dtypes()
@@ -128,100 +342,68 @@ def test_astype_type_f_contiguous_no_copy(self, dtype, order):
         a = testing.shaped_arange((2, 3, 4), cupy, dtype)
         a = cupy.asfortranarray(a)
         b = a.astype(dtype, order=order, copy=False)
-        self.assertTrue(b is a)
+        assert b is a
 
     @testing.for_all_dtypes_combination(("src_dtype", "dst_dtype"))
-    @testing.numpy_cupy_array_equal()
+    @testing.numpy_cupy_equal()
     def test_astype_strides(self, xp, src_dtype, dst_dtype):
-        src = xp.empty((1, 2, 3), dtype=src_dtype)
-        return numpy.array(
-            astype_without_warning(src, dst_dtype, order="K").strides
-        )
+        src = testing.shaped_arange((1, 2, 3), xp, dtype=src_dtype)
+        dst = astype_without_warning(src, dst_dtype, order="K")
+        return get_strides(xp, dst)
 
     @testing.for_all_dtypes_combination(("src_dtype", "dst_dtype"))
-    @testing.numpy_cupy_array_equal()
+    @testing.numpy_cupy_equal()
     def test_astype_strides_negative(self, xp, src_dtype, dst_dtype):
-        src = xp.empty((2, 3), dtype=src_dtype)[::-1, :]
-        return numpy.array(
-            astype_without_warning(src, dst_dtype, order="K").strides
-        )
+        src = testing.shaped_arange((2, 3), xp, dtype=src_dtype)
+        src = src[::-1, :]
+        dst = astype_without_warning(src, dst_dtype, order="K")
+        return tuple(abs(x) for x in get_strides(xp, dst))
 
     @testing.for_all_dtypes_combination(("src_dtype", "dst_dtype"))
-    @testing.numpy_cupy_array_equal()
+    @testing.numpy_cupy_equal()
     def test_astype_strides_swapped(self, xp, src_dtype, dst_dtype):
-        src = xp.swapaxes(xp.empty((2, 3, 4), dtype=src_dtype), 1, 0)
-        return numpy.array(
-            astype_without_warning(src, dst_dtype, order="K").strides
-        )
+        src = testing.shaped_arange((2, 3, 4), xp, dtype=src_dtype)
+        src = xp.swapaxes(src, 1, 0)
+        dst = astype_without_warning(src, dst_dtype, order="K")
+        return get_strides(xp, dst)
 
     @testing.for_all_dtypes_combination(("src_dtype", "dst_dtype"))
-    @testing.numpy_cupy_array_equal()
+    @testing.numpy_cupy_equal()
     def test_astype_strides_broadcast(self, xp, src_dtype, dst_dtype):
-        src, _ = xp.broadcast_arrays(
-            xp.empty((2,), dtype=src_dtype),
-            xp.empty((2, 3, 2), dtype=src_dtype),
-        )
-        return numpy.array(
-            astype_without_warning(src, dst_dtype, order="K").strides
-        )
+        src1 = testing.shaped_arange((2, 3, 2), xp, dtype=src_dtype)
+        src2 = testing.shaped_arange((2,), xp, dtype=src_dtype)
+        src, _ = xp.broadcast_arrays(src1, src2)
+        dst = astype_without_warning(src, dst_dtype, order="K")
+        return get_strides(xp, dst)
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
+    @pytest.mark.skip("'dpnp_array' object has no attribute 'view' yet")
+    @testing.numpy_cupy_array_equal()
+    def test_astype_boolean_view(self, xp):
+        # See #4354
+        a = xp.array([0, 1, 2], dtype=numpy.int8).view(dtype=numpy.bool_)
+        return a.astype(numpy.int8)
+
+
+@pytest.mark.usefixtures("allow_fall_back_on_numpy")
+class TestArrayDiagonal:
     @testing.for_all_dtypes()
     @testing.numpy_cupy_array_equal()
     def test_diagonal1(self, xp, dtype):
         a = testing.shaped_arange((3, 4, 5), xp, dtype)
         return a.diagonal(1, 2, 0)
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     @testing.for_all_dtypes()
     @testing.numpy_cupy_array_equal()
     def test_diagonal2(self, xp, dtype):
         a = testing.shaped_arange((3, 4, 5), xp, dtype)
         return a.diagonal(-1, 2, 0)
 
-    # @unittest.skipUnless(util.ENABLE_SLICE_COPY, 'Special copy disabled')
-    @testing.for_orders("CF")
-    @testing.for_dtypes(
-        [numpy.int16, numpy.int64, numpy.float16, numpy.float64]
-    )
-    @testing.numpy_cupy_array_equal()
-    def test_isinstance_numpy_copy(self, xp, dtype, order):
-        a = numpy.arange(100, dtype=dtype).reshape(10, 10, order=order)
-        b = xp.empty(a.shape, dtype=dtype, order=order)
-        b[:] = a
-        return b
-
-    # @unittest.skipUnless(util.ENABLE_SLICE_COPY, 'Special copy disabled')
-    def test_isinstance_numpy_copy_wrong_dtype(self):
-        for xp in (numpy, cupy):
-            a = numpy.arange(100, dtype=numpy.float64).reshape(10, 10)
-            b = cupy.empty(a.shape, dtype=numpy.int32)
-            with pytest.raises(ValueError):
-                b[:] = a
-
-    # @unittest.skipUnless(util.ENABLE_SLICE_COPY, 'Special copy disabled')
-    def test_isinstance_numpy_copy_wrong_shape(self):
-        for xp in (numpy, cupy):
-            a = numpy.arange(100, dtype=numpy.float64).reshape(10, 10)
-            b = cupy.empty(100, dtype=a.dtype)
-            with pytest.raises(ValueError):
-                b[:] = a
-
-    # @unittest.skipUnless(util.ENABLE_SLICE_COPY, 'Special copy disabled')
-    @testing.numpy_cupy_array_equal()
-    def test_isinstance_numpy_copy_not_slice(self, xp):
-        a = xp.arange(5, dtype=numpy.float64)
-        a[a < 3] = 0
-        return a
-
 
 @testing.parameterize(
     {"src_order": "C"},
     {"src_order": "F"},
 )
-@testing.gpu
-class TestNumPyArrayCopyView(unittest.TestCase):
-    # @unittest.skipUnless(util.ENABLE_SLICE_COPY, 'Special copy disabled')
+class TestNumPyArrayCopyView:
     @testing.for_orders("CF")
     @testing.for_dtypes(
         [numpy.int16, numpy.int64, numpy.float16, numpy.float64]
@@ -233,3 +415,66 @@ def test_isinstance_numpy_view_copy_f(self, xp, dtype, order):
         b = xp.empty(a.shape, dtype=dtype, order=order)
         b[:] = a
         return b
+
+
+class C_cp(cupy.ndarray):
+    def __new__(cls, *args, info=None, **kwargs):
+        obj = super().__new__(cls, *args, **kwargs)
+        obj.info = info
+        return obj
+
+    def __array_finalize__(self, obj):
+        if obj is None:
+            return
+        self.info = getattr(obj, "info", None)
+
+
+class C_np(numpy.ndarray):
+    def __new__(cls, *args, info=None, **kwargs):
+        obj = super().__new__(cls, *args, **kwargs)
+        obj.info = info
+        return obj
+
+    def __array_finalize__(self, obj):
+        if obj is None:
+            return
+        self.info = getattr(obj, "info", None)
+
+
+@pytest.mark.skip("'dpnp_array' object has no attribute 'view' yet")
+class TestSubclassArrayView:
+    def test_view_casting(self):
+        for xp, C in [(numpy, C_np), (cupy, C_cp)]:
+            a = xp.arange(5, dtype="i").view("F")
+            assert type(a) is xp.ndarray
+            assert a.dtype == xp.float32
+
+            a = xp.arange(5, dtype="i").view(dtype="F")
+            assert type(a) is xp.ndarray
+            assert a.dtype == xp.float32
+
+            with pytest.raises(TypeError):
+                xp.arange(5, dtype="i").view("F", dtype="F")
+
+            a = xp.arange(5, dtype="i").view(C)
+            assert type(a) is C
+            assert a.dtype == xp.int32
+            assert a.info is None
+
+            a = xp.arange(5, dtype="i").view(type=C)
+            assert type(a) is C
+            assert a.dtype == xp.int32
+            assert a.info is None
+
+            # When an instance of ndarray's subclass is supplied to `dtype`,
+            # view() interprets it as if it is supplied to `type`
+            a = xp.arange(5, dtype="i").view(dtype=C)
+            assert type(a) is C
+            assert a.dtype == xp.int32
+            assert a.info is None
+
+            with pytest.raises(TypeError):
+                xp.arange(5).view("F", C, type=C)
+
+        with pytest.raises(ValueError):
+            cupy.arange(5).view(type=numpy.ndarray)
diff --git a/tests/third_party/cupy/core_tests/test_ndarray_unary_op.py b/tests/third_party/cupy/core_tests/test_ndarray_unary_op.py
new file mode 100644
index 00000000000..9622decd981
--- /dev/null
+++ b/tests/third_party/cupy/core_tests/test_ndarray_unary_op.py
@@ -0,0 +1,144 @@
+import operator
+import unittest
+
+import numpy
+import pytest
+
+import dpnp as cupy
+from tests.third_party.cupy import testing
+
+
+class TestArrayBoolOp(unittest.TestCase):
+    @pytest.mark.skip("The truth value of an empty array is ambiguous")
+    @testing.for_all_dtypes()
+    def test_bool_empty(self, dtype):
+        with testing.assert_warns(DeprecationWarning):
+            assert not bool(cupy.array((), dtype=dtype))
+
+    def test_bool_scalar_bool(self):
+        assert bool(cupy.array(True, dtype=numpy.bool_))
+        assert not bool(cupy.array(False, dtype=numpy.bool_))
+
+    @testing.for_all_dtypes()
+    def test_bool_scalar(self, dtype):
+        assert bool(cupy.array(1, dtype=dtype))
+        assert not bool(cupy.array(0, dtype=dtype))
+
+    def test_bool_one_element_bool(self):
+        assert bool(cupy.array([True], dtype=numpy.bool_))
+        assert not bool(cupy.array([False], dtype=numpy.bool_))
+
+    @testing.for_all_dtypes()
+    def test_bool_one_element(self, dtype):
+        assert bool(cupy.array([1], dtype=dtype))
+        assert not bool(cupy.array([0], dtype=dtype))
+
+    @testing.for_all_dtypes()
+    def test_bool_two_elements(self, dtype):
+        with self.assertRaises(ValueError):
+            bool(cupy.array([1, 2], dtype=dtype))
+
+
+class TestArrayUnaryOp(unittest.TestCase):
+    @testing.for_all_dtypes(no_bool=True)
+    @testing.numpy_cupy_allclose()
+    def check_array_op(self, op, xp, dtype):
+        a = testing.shaped_arange((2, 3), xp, dtype)
+        return op(a)
+
+    @testing.for_all_dtypes()
+    @testing.numpy_cupy_allclose()
+    def check_array_op_full(self, op, xp, dtype):
+        a = testing.shaped_arange((2, 3), xp, dtype)
+        return op(a)
+
+    @testing.for_all_dtypes(no_bool=True)
+    @testing.numpy_cupy_allclose()
+    def test_neg_array(self, xp, dtype):
+        a = testing.shaped_arange((2, 3), xp, dtype)
+        return operator.neg(a)
+
+    @testing.for_all_dtypes(no_bool=True)
+    @testing.numpy_cupy_allclose()
+    def test_pos_array(self, xp, dtype):
+        a = testing.shaped_arange((2, 3), xp, dtype)
+        assert a is not +a
+        return +a
+
+    @pytest.mark.skip(
+        "dpnp boolean positive, the `+` operator, is not supported"
+    )
+    @testing.with_requires("numpy<1.25")
+    def test_pos_boolarray(self):
+        for xp in (numpy, cupy):
+            a = xp.array(True, dtype=xp.bool_)
+            with pytest.deprecated_call():
+                assert a is not +a
+
+    @testing.with_requires("numpy<1.16")
+    def test_pos_array_full(self):
+        self.check_array_op_full(operator.pos)
+
+    def test_abs_array(self):
+        self.check_array_op_full(operator.abs)
+
+    @testing.for_all_dtypes(no_bool=True)
+    @testing.numpy_cupy_allclose()
+    def check_zerodim_op(self, op, xp, dtype):
+        a = xp.array(-2).astype(dtype)
+        return op(a)
+
+    @testing.for_all_dtypes()
+    @testing.numpy_cupy_allclose()
+    def check_zerodim_op_full(self, op, xp, dtype):
+        a = xp.array(-2).astype(dtype)
+        return op(a)
+
+    @testing.for_all_dtypes(no_bool=True)
+    @testing.numpy_cupy_allclose()
+    def test_neg_zerodim(self, xp, dtype):
+        a = xp.array(-2).astype(dtype)
+        return operator.neg(a)
+
+    def test_pos_zerodim(self):
+        self.check_zerodim_op(operator.pos)
+
+    def test_abs_zerodim(self):
+        self.check_zerodim_op_full(operator.abs)
+
+    def test_abs_zerodim_full(self):
+        self.check_zerodim_op_full(operator.abs)
+
+
+class TestArrayIntUnaryOp(unittest.TestCase):
+    @testing.for_int_dtypes()
+    @testing.numpy_cupy_allclose()
+    def check_array_op(self, op, xp, dtype):
+        a = testing.shaped_arange((2, 3), xp, dtype)
+        return op(a)
+
+    def test_invert_array(self):
+        self.check_array_op(operator.invert)
+
+    @testing.for_all_dtypes()
+    @testing.numpy_cupy_allclose(accept_error=TypeError)
+    def check_zerodim_op(self, op, xp, dtype):
+        a = xp.array(-2).astype(dtype)
+        return op(a)
+
+    def test_invert_zerodim(self):
+        self.check_zerodim_op(operator.invert)
+
+
+@testing.parameterize(
+    *testing.product({"xp": [numpy, cupy], "shape": [(3, 2), (), (3, 0, 2)]})
+)
+class TestBoolNeg(unittest.TestCase):
+    def test_bool_neg(self):
+        xp = self.xp
+        if xp is numpy and not testing.numpy_satisfies(">=1.13.0"):
+            raise unittest.SkipTest("NumPy<1.13.0")
+        shape = self.shape
+        x = testing.shaped_random(shape, xp, dtype=numpy.bool_)
+        with pytest.raises(TypeError):
+            -x
diff --git a/tests/third_party/cupy/creation_tests/test_ranges.py b/tests/third_party/cupy/creation_tests/test_ranges.py
index c165b4e94a2..be2f113a318 100644
--- a/tests/third_party/cupy/creation_tests/test_ranges.py
+++ b/tests/third_party/cupy/creation_tests/test_ranges.py
@@ -141,13 +141,13 @@ def test_linspace_neg_num(self):
     @testing.numpy_cupy_allclose()
     def test_linspace_float_overflow(self, xp):
         dtype = cupy.default_float_type()
-        return xp.linspace(0.0, numpy.finfo(dtype).max / 5, 10, dtype=dtype)
+        return xp.linspace(0.0, xp.finfo(dtype).max / 5, 10, dtype=dtype)
 
     @testing.numpy_cupy_allclose()
     def test_linspace_float_underflow(self, xp):
         # find minimum subnormal number
         dtype = cupy.default_float_type()
-        x = numpy.finfo(dtype).min
+        x = xp.finfo(dtype).min
         while x / 2 > 0:
             x /= 2
         return xp.linspace(0.0, x, 10, dtype=dtype)
diff --git a/tests/third_party/cupy/manipulation_tests/test_dims.py b/tests/third_party/cupy/manipulation_tests/test_dims.py
index 461c0bb2ec2..cab15703202 100644
--- a/tests/third_party/cupy/manipulation_tests/test_dims.py
+++ b/tests/third_party/cupy/manipulation_tests/test_dims.py
@@ -7,7 +7,6 @@
 from tests.third_party.cupy import testing
 
 
-@testing.gpu
 class TestDims(unittest.TestCase):
     def check_atleast(self, func, xp):
         a = testing.shaped_arange((), xp)
@@ -18,6 +17,7 @@ def check_atleast(self, func, xp):
         f = numpy.float32(1)
         return func(a, b, c, d, e, f)
 
+    @pytest.mark.skip(reason="Scalar input is not supported")
     @testing.numpy_cupy_array_equal()
     def test_atleast_1d1(self, xp):
         return self.check_atleast(xp.atleast_1d, xp)
@@ -27,7 +27,7 @@ def test_atleast_1d2(self, xp):
         a = testing.shaped_arange((1, 3, 2), xp)
         return xp.atleast_1d(a)
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
+    @pytest.mark.skip(reason="Scalar input is not supported")
     @testing.numpy_cupy_array_equal()
     def test_atleast_2d1(self, xp):
         return self.check_atleast(xp.atleast_2d, xp)
@@ -37,7 +37,7 @@ def test_atleast_2d2(self, xp):
         a = testing.shaped_arange((1, 3, 2), xp)
         return xp.atleast_2d(a)
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
+    @pytest.mark.skip(reason="Scalar input is not supported")
     @testing.numpy_cupy_array_equal()
     def test_atleast_3d1(self, xp):
         return self.check_atleast(xp.atleast_3d, xp)
@@ -55,6 +55,13 @@ def test_broadcast_to(self, xp, dtype):
         b = xp.broadcast_to(a, (2, 3, 3, 4))
         return b
 
+    @testing.numpy_cupy_array_equal()
+    def test_broadcast_to_int(self, xp):
+        # Broadcast 0-dim array to 1-dim.
+        a = xp.array(10, dtype=xp.float32)
+        b = xp.broadcast_to(a, 10)
+        return b
+
     @testing.for_all_dtypes()
     def test_broadcast_to_fail(self, dtype):
         for xp in (numpy, cupy):
@@ -286,7 +293,6 @@ def test_external_squeeze(self, xp):
     {"shapes": [(0, 1, 1, 3), (2, 1, 0, 0, 3)]},
     {"shapes": [(0, 1, 1, 0, 3), (5, 2, 0, 1, 0, 0, 3), (2, 1, 0, 0, 0, 3)]},
 )
-@testing.gpu
 class TestBroadcast(unittest.TestCase):
     def _broadcast(self, xp, dtype, shapes):
         arrays = [testing.shaped_arange(s, xp, dtype) for s in shapes]
@@ -296,9 +302,9 @@ def _broadcast(self, xp, dtype, shapes):
     def test_broadcast(self, dtype):
         broadcast_np = self._broadcast(numpy, dtype, self.shapes)
         broadcast_cp = self._broadcast(cupy, dtype, self.shapes)
-        self.assertEqual(broadcast_np.shape, broadcast_cp.shape)
-        self.assertEqual(broadcast_np.size, broadcast_cp.size)
-        self.assertEqual(broadcast_np.nd, broadcast_cp.nd)
+        assert broadcast_np.shape == broadcast_cp.shape
+        assert broadcast_np.size == broadcast_cp.size
+        assert broadcast_np.nd == broadcast_cp.nd
 
     @testing.for_all_dtypes()
     @testing.numpy_cupy_array_equal()
@@ -329,7 +335,6 @@ def test_broadcast_arrays(self, xp, dtype):
     },
     {"shapes": [(0,), (2,)]},
 )
-@testing.gpu
 class TestInvalidBroadcast(unittest.TestCase):
     @testing.for_all_dtypes()
     def test_invalid_broadcast(self, dtype):
diff --git a/tests/third_party/cupy/manipulation_tests/test_join.py b/tests/third_party/cupy/manipulation_tests/test_join.py
index 8bffce98d87..6f8eb33fa27 100644
--- a/tests/third_party/cupy/manipulation_tests/test_join.py
+++ b/tests/third_party/cupy/manipulation_tests/test_join.py
@@ -145,7 +145,6 @@ def test_concatenate_wrong_shape(self):
         with pytest.raises(ValueError):
             cupy.concatenate((a, b, c))
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     @testing.for_all_dtypes(name="dtype")
     @testing.numpy_cupy_array_equal()
     def test_concatenate_out(self, xp, dtype):
@@ -156,7 +155,6 @@ def test_concatenate_out(self, xp, dtype):
         xp.concatenate((a, b, c), axis=1, out=out)
         return out
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     @testing.numpy_cupy_array_equal()
     def test_concatenate_out_same_kind(self, xp):
         a = testing.shaped_arange((3, 4), xp, xp.float32)
@@ -166,7 +164,6 @@ def test_concatenate_out_same_kind(self, xp):
         xp.concatenate((a, b, c), axis=1, out=out)
         return out
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     def test_concatenate_out_invalid_shape(self):
         for xp in (numpy, cupy):
             a = testing.shaped_arange((3, 4), xp, xp.float32)
@@ -176,7 +173,6 @@ def test_concatenate_out_invalid_shape(self):
             with pytest.raises(ValueError):
                 xp.concatenate((a, b, c), axis=1, out=out)
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     def test_concatenate_out_invalid_shape_2(self):
         for xp in (numpy, cupy):
             a = testing.shaped_arange((3, 4), xp, xp.float32)
@@ -186,7 +182,6 @@ def test_concatenate_out_invalid_shape_2(self):
             with pytest.raises(ValueError):
                 xp.concatenate((a, b, c), axis=1, out=out)
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     def test_concatenate_out_invalid_dtype(self):
         for xp in (numpy, cupy):
             a = testing.shaped_arange((3, 4), xp, xp.float32)
@@ -204,7 +199,6 @@ def test_concatenate_different_dtype(self, xp, dtype1, dtype2):
         b = testing.shaped_arange((3, 4), xp, dtype2)
         return xp.concatenate((a, b))
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     @testing.for_all_dtypes_combination(names=["dtype1", "dtype2"])
     @testing.numpy_cupy_array_equal(accept_error=TypeError)
     def test_concatenate_out_different_dtype(self, xp, dtype1, dtype2):
@@ -213,7 +207,6 @@ def test_concatenate_out_different_dtype(self, xp, dtype1, dtype2):
         out = xp.zeros((6, 4), dtype=dtype2)
         return xp.concatenate((a, b), out=out)
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     @testing.with_requires("numpy>=1.20.0")
     @testing.for_all_dtypes_combination(names=["dtype1", "dtype2"])
     @testing.numpy_cupy_array_equal(accept_error=TypeError)
@@ -222,7 +215,6 @@ def test_concatenate_dtype(self, xp, dtype1, dtype2):
         b = testing.shaped_arange((3, 4), xp, dtype1)
         return xp.concatenate((a, b), dtype=dtype2)
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     @testing.with_requires("numpy>=1.20.0")
     def test_concatenate_dtype_invalid_out(self):
         for xp in (numpy, cupy):
@@ -232,7 +224,6 @@ def test_concatenate_dtype_invalid_out(self):
             with pytest.raises(TypeError):
                 xp.concatenate((a, b), out=out, dtype=xp.int64)
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     @testing.with_requires("numpy>=1.20.0")
     @testing.for_castings()
     @testing.for_all_dtypes_combination(names=["dtype1", "dtype2"])
@@ -290,7 +281,6 @@ def test_hstack(self, xp):
         c = testing.shaped_arange((2, 3), xp)
         return xp.hstack((a, b, c))
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     @testing.with_requires("numpy>=1.24.0")
     @testing.for_all_dtypes_combination(names=["dtype1", "dtype2"])
     @testing.numpy_cupy_array_equal(accept_error=TypeError)
@@ -299,7 +289,6 @@ def test_hstack_dtype(self, xp, dtype1, dtype2):
         b = testing.shaped_arange((3, 4), xp, dtype1)
         return xp.hstack((a, b), dtype=dtype2)
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     @testing.with_requires("numpy>=1.24.0")
     @testing.for_castings()
     @testing.for_all_dtypes_combination(names=["dtype1", "dtype2"])
@@ -312,27 +301,23 @@ def test_hstack_casting(self, xp, dtype1, dtype2, casting):
         # may raise TypeError or ComplexWarning
         return xp.hstack((a, b), dtype=dtype2, casting=casting)
 
-    @pytest.mark.skip("dpnp.vstack() is not implemented yet")
     @testing.numpy_cupy_array_equal()
     def test_vstack_vectors(self, xp):
         a = xp.arange(3)
         b = xp.arange(2, -1, -1)
         return xp.vstack((a, b))
 
-    @pytest.mark.skip("dpnp.vstack() is not implemented yet")
     @testing.numpy_cupy_array_equal()
     def test_vstack_single_element(self, xp):
         a = xp.arange(3)
         return xp.vstack((a,))
 
-    @pytest.mark.skip("dpnp.vstack() is not implemented yet")
     def test_vstack_wrong_ndim(self):
         a = cupy.empty((3,))
         b = cupy.empty((3, 1))
         with pytest.raises(ValueError):
             cupy.vstack((a, b))
 
-    @pytest.mark.skip("dpnp.vstack() is not implemented yet")
     @testing.with_requires("numpy>=1.24.0")
     @testing.for_all_dtypes_combination(names=["dtype1", "dtype2"])
     @testing.numpy_cupy_array_equal(accept_error=TypeError)
@@ -341,18 +326,8 @@ def test_vstack_dtype(self, xp, dtype1, dtype2):
         b = testing.shaped_arange((3, 4), xp, dtype1)
         return xp.vstack((a, b), dtype=dtype2)
 
-    @pytest.mark.skip("dpnp.vstack() is not implemented yet")
     @testing.with_requires("numpy>=1.24.0")
-    @pytest.mark.parametrize(
-        "casting",
-        [
-            "no",
-            "equiv",
-            "safe",
-            "same_kind",
-            "unsafe",
-        ],
-    )
+    @testing.for_castings()
     @testing.for_all_dtypes_combination(names=["dtype1", "dtype2"])
     @testing.numpy_cupy_array_equal(
         accept_error=(TypeError, numpy.ComplexWarning)
@@ -435,7 +410,6 @@ def test_stack_out_of_bounds2(self):
         with pytest.raises(numpy.AxisError):
             return cupy.stack([a, a], axis=3)
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     @testing.for_all_dtypes(name="dtype")
     @testing.numpy_cupy_array_equal()
     def test_stack_out(self, xp, dtype):
@@ -446,7 +420,6 @@ def test_stack_out(self, xp, dtype):
         xp.stack((a, b, c), axis=1, out=out)
         return out
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     @testing.numpy_cupy_array_equal()
     def test_stack_out_same_kind(self, xp):
         a = testing.shaped_arange((3, 4), xp, xp.float32)
@@ -456,7 +429,6 @@ def test_stack_out_same_kind(self, xp):
         xp.stack((a, b, c), axis=1, out=out)
         return out
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     def test_stack_out_invalid_shape(self):
         for xp in (numpy, cupy):
             a = testing.shaped_arange((3, 4), xp, xp.float32)
@@ -466,7 +438,6 @@ def test_stack_out_invalid_shape(self):
             with pytest.raises(ValueError):
                 xp.stack((a, b, c), axis=1, out=out)
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     def test_stack_out_invalid_shape_2(self):
         for xp in (numpy, cupy):
             a = testing.shaped_arange((3, 4), xp, xp.float32)
@@ -476,7 +447,6 @@ def test_stack_out_invalid_shape_2(self):
             with pytest.raises(ValueError):
                 xp.stack((a, b, c), axis=1, out=out)
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     def test_stack_out_invalid_dtype(self):
         for xp in (numpy, cupy):
             a = testing.shaped_arange((3, 4), xp, xp.float32)
@@ -486,7 +456,6 @@ def test_stack_out_invalid_dtype(self):
             with pytest.raises(TypeError):
                 xp.stack((a, b, c), axis=1, out=out)
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     @testing.with_requires("numpy>=1.24.0")
     @testing.for_all_dtypes_combination(names=["dtype1", "dtype2"])
     @testing.numpy_cupy_array_equal(accept_error=TypeError)
@@ -495,7 +464,6 @@ def test_stack_dtype(self, xp, dtype1, dtype2):
         b = testing.shaped_arange((3, 4), xp, dtype1)
         return xp.stack((a, b), dtype=dtype2)
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     @testing.with_requires("numpy>=1.24.0")
     @testing.for_castings()
     @testing.for_all_dtypes_combination(names=["dtype1", "dtype2"])
diff --git a/tests/third_party/cupy/math_tests/test_arithmetic.py b/tests/third_party/cupy/math_tests/test_arithmetic.py
index 23691ac9baf..6c0dea51750 100644
--- a/tests/third_party/cupy/math_tests/test_arithmetic.py
+++ b/tests/third_party/cupy/math_tests/test_arithmetic.py
@@ -210,7 +210,7 @@ def check_binary(self, xp):
             if dtype1 in (numpy.float16, numpy.float32):
                 y = y.astype(numpy.complex64)
 
-        # NumPy returns an output array of another type than DPNP when input ones have diffrent types.
+        # NumPy returns an output array of another type than DPNP when input ones have different types.
         if xp is numpy and dtype1 != dtype2:
             is_array_arg1 = not xp.isscalar(arg1)
             is_array_arg2 = not xp.isscalar(arg2)
diff --git a/tests/third_party/cupy/math_tests/test_explog.py b/tests/third_party/cupy/math_tests/test_explog.py
index 9d68b125a1d..85f3baa96ba 100644
--- a/tests/third_party/cupy/math_tests/test_explog.py
+++ b/tests/third_party/cupy/math_tests/test_explog.py
@@ -1,14 +1,16 @@
 import unittest
+import warnings
 
 import numpy
 import pytest
 
+from tests.helper import has_support_aspect64
 from tests.third_party.cupy import testing
 
 
 class TestExplog(unittest.TestCase):
     @testing.for_all_dtypes()
-    @testing.numpy_cupy_allclose(atol=1e-5)
+    @testing.numpy_cupy_allclose(atol=1e-5, type_check=has_support_aspect64())
     def check_unary(self, name, xp, dtype, no_complex=False):
         if no_complex:
             if numpy.dtype(dtype).kind == "c":
@@ -17,7 +19,7 @@ def check_unary(self, name, xp, dtype, no_complex=False):
         return getattr(xp, name)(a)
 
     @testing.for_all_dtypes()
-    @testing.numpy_cupy_allclose(atol=1e-5)
+    @testing.numpy_cupy_allclose(atol=1e-5, type_check=has_support_aspect64())
     def check_binary(self, name, xp, dtype, no_complex=False):
         if no_complex:
             if numpy.dtype(dtype).kind == "c":
@@ -62,3 +64,21 @@ def test_logaddexp2(self):
     def test_logaddexp2_infinities(self, xp, dtype, val):
         a = xp.full((2, 3), val, dtype=dtype)
         return xp.logaddexp2(a, a)
+
+
+@pytest.mark.parametrize("val", [numpy.inf, -numpy.inf])
+@testing.for_float_dtypes()
+@testing.numpy_cupy_allclose()
+def test_logaddexp_infinities(xp, dtype, val):
+    a = xp.full((2, 3), val, dtype=dtype)
+    return xp.logaddexp(a, a)
+
+
+@testing.for_float_dtypes()
+@testing.numpy_cupy_allclose()
+def test_logaddexp_nan(xp, dtype):
+    a = xp.full((2, 3), xp.nan, dtype=dtype)
+    with warnings.catch_warnings():
+        warnings.filterwarnings("ignore", category=RuntimeWarning)
+        result = xp.logaddexp(a, a)
+    return result
diff --git a/tests/third_party/cupy/math_tests/test_floating.py b/tests/third_party/cupy/math_tests/test_floating.py
index 2df027aee03..eeb9000a75a 100644
--- a/tests/third_party/cupy/math_tests/test_floating.py
+++ b/tests/third_party/cupy/math_tests/test_floating.py
@@ -3,6 +3,7 @@
 import numpy
 
 import dpnp as cupy
+from tests.helper import has_support_aspect64
 from tests.third_party.cupy import testing
 
 
@@ -15,7 +16,7 @@ def test_signbit(self, xp, dtype):
         return xp.signbit(a)
 
     @testing.for_all_dtypes_combination(("dtype_a", "dtype_b"), no_complex=True)
-    @testing.numpy_cupy_array_equal()
+    @testing.numpy_cupy_array_equal(type_check=has_support_aspect64())
     def test_copysign_combination(self, xp, dtype_a, dtype_b):
         a = testing.shaped_arange((2, 3), xp, dtype_a)
         b = testing.shaped_reverse_arange((2, 3), xp, dtype_b)
diff --git a/tests/third_party/cupy/math_tests/test_sumprod.py b/tests/third_party/cupy/math_tests/test_sumprod.py
index 9c1d6a0ed2e..e6b7adfa5c5 100644
--- a/tests/third_party/cupy/math_tests/test_sumprod.py
+++ b/tests/third_party/cupy/math_tests/test_sumprod.py
@@ -276,7 +276,7 @@ def _test(self, xp, dtype):
         return func(a, axis=self.axis, keepdims=self.keepdims)
 
     @testing.for_all_dtypes(no_bool=True, no_float16=True)
-    @testing.numpy_cupy_allclose()
+    @testing.numpy_cupy_allclose(type_check=has_support_aspect64())
     def test_nansum_all(self, xp, dtype):
         if (
             not self._numpy_nanprod_implemented()
@@ -286,7 +286,9 @@ def test_nansum_all(self, xp, dtype):
         return self._test(xp, dtype)
 
     @testing.for_all_dtypes(no_bool=True, no_float16=True)
-    @testing.numpy_cupy_allclose(contiguous_check=False)
+    @testing.numpy_cupy_allclose(
+        contiguous_check=False, type_check=has_support_aspect64()
+    )
     def test_nansum_axis_transposed(self, xp, dtype):
         if (
             not self._numpy_nanprod_implemented()
@@ -609,7 +611,7 @@ def test_diff_2dim_with_append(self, xp, dtype):
     @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     @testing.with_requires("numpy>=1.16")
     @testing.for_all_dtypes()
-    @testing.numpy_cupy_allclose()
+    @testing.numpy_cupy_allclose(type_check=has_support_aspect64())
     def test_diff_2dim_with_scalar_append(self, xp, dtype):
         a = testing.shaped_arange((4, 5), xp, dtype)
         return xp.diff(a, prepend=1, append=0)
diff --git a/tests/third_party/cupy/sorting_tests/test_count.py b/tests/third_party/cupy/sorting_tests/test_count.py
index 368676102da..117f3be94f6 100644
--- a/tests/third_party/cupy/sorting_tests/test_count.py
+++ b/tests/third_party/cupy/sorting_tests/test_count.py
@@ -6,7 +6,6 @@
 from tests.third_party.cupy import testing
 
 
-@testing.gpu
 class TestCount(unittest.TestCase):
     @testing.for_all_dtypes()
     def test_count_nonzero(self, dtype):
@@ -17,12 +16,12 @@ def func(xp):
             if xp is cupy:
                 # CuPy returns zero-dimensional array instead of
                 # returning a scalar value
-                self.assertIsInstance(c, xp.ndarray)
-                self.assertEqual(c.dtype, "l")
-                self.assertEqual(c.shape, ())
+                assert isinstance(c, xp.ndarray)
+                assert c.dtype == "p"
+                assert c.shape == ()
             return int(c)
 
-        self.assertEqual(func(numpy), func(cupy))
+        assert func(numpy) == func(cupy)
 
     @testing.for_all_dtypes()
     def test_count_nonzero_zero_dim(self, dtype):
@@ -32,12 +31,12 @@ def func(xp):
             if xp is cupy:
                 # CuPy returns zero-dimensional array instead of
                 # returning a scalar value
-                self.assertIsInstance(c, xp.ndarray)
-                self.assertEqual(c.dtype, "l")
-                self.assertEqual(c.shape, ())
+                assert isinstance(c, xp.ndarray)
+                assert c.dtype == "p"
+                assert c.shape == ()
             return int(c)
 
-        self.assertEqual(func(numpy), func(cupy))
+        assert func(numpy) == func(cupy)
 
     @testing.for_all_dtypes()
     def test_count_nonzero_int_axis(self, dtype):
diff --git a/tests/third_party/cupy/statistics_tests/test_meanvar.py b/tests/third_party/cupy/statistics_tests/test_meanvar.py
index 738057a99f4..f7689a46393 100644
--- a/tests/third_party/cupy/statistics_tests/test_meanvar.py
+++ b/tests/third_party/cupy/statistics_tests/test_meanvar.py
@@ -181,6 +181,8 @@ def test_external_mean_axis(self, xp, dtype):
     @testing.for_all_dtypes(no_complex=True)
     @testing.numpy_cupy_allclose(rtol=1e-06)
     def test_mean_all_float32_dtype(self, xp, dtype):
+        if dtype == xp.int32:
+            pytest.skip("skip until issue #1468 is solved in dpctl")
         a = xp.full((2, 3, 4), 123456789, dtype=dtype)
         return xp.mean(a, dtype=numpy.float32)
 
diff --git a/tests/third_party/cupy/test_type_routines.py b/tests/third_party/cupy/test_type_routines.py
new file mode 100644
index 00000000000..6a274158bcd
--- /dev/null
+++ b/tests/third_party/cupy/test_type_routines.py
@@ -0,0 +1,102 @@
+import unittest
+
+import numpy
+import pytest
+
+import dpnp as cupy
+from tests.third_party.cupy import testing
+
+
+def _generate_type_routines_input(xp, dtype, obj_type):
+    dtype = numpy.dtype(dtype)
+    if obj_type == "dtype":
+        return dtype
+    if obj_type == "specifier":
+        return str(dtype)
+    if obj_type == "scalar":
+        return dtype.type(3)
+    if obj_type == "array":
+        return xp.zeros(3, dtype=dtype)
+    if obj_type == "primitive":
+        return type(dtype.type(3).tolist())
+    assert False
+
+
+@testing.parameterize(
+    *testing.product(
+        {
+            "obj_type": ["dtype", "specifier", "scalar", "array", "primitive"],
+        }
+    )
+)
+class TestCanCast(unittest.TestCase):
+    @testing.for_all_dtypes_combination(names=("from_dtype", "to_dtype"))
+    @testing.numpy_cupy_equal()
+    def test_can_cast(self, xp, from_dtype, to_dtype):
+        if self.obj_type == "scalar":
+            pytest.skip("to be aligned with NEP-50")
+
+        from_obj = _generate_type_routines_input(xp, from_dtype, self.obj_type)
+
+        ret = xp.can_cast(from_obj, to_dtype)
+        assert isinstance(ret, bool)
+        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) == type
+        return ret
+
+    @testing.for_all_dtypes(no_bool=True)
+    @testing.numpy_cupy_equal()
+    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) == type
+        return ret
+
+    @testing.for_all_dtypes_combination(
+        names=("dtype1", "dtype2"), no_bool=True
+    )
+    @testing.numpy_cupy_equal()
+    def test_common_type_two_arguments(self, xp, dtype1, dtype2):
+        array1 = _generate_type_routines_input(xp, dtype1, "array")
+        array2 = _generate_type_routines_input(xp, dtype2, "array")
+        ret = xp.common_type(array1, array2)
+        assert type(ret) == type
+        return ret
+
+    @testing.for_all_dtypes()
+    def test_common_type_bool(self, dtype):
+        for xp in (numpy, cupy):
+            array1 = _generate_type_routines_input(xp, dtype, "array")
+            array2 = _generate_type_routines_input(xp, "bool_", "array")
+            with pytest.raises(TypeError):
+                xp.common_type(array1, array2)
+
+
+@testing.parameterize(
+    *testing.product(
+        {
+            "obj_type1": ["dtype", "specifier", "scalar", "array", "primitive"],
+            "obj_type2": ["dtype", "specifier", "scalar", "array", "primitive"],
+        }
+    )
+)
+class TestResultType(unittest.TestCase):
+    @testing.for_all_dtypes_combination(names=("dtype1", "dtype2"))
+    @testing.numpy_cupy_equal()
+    def test_result_type(self, xp, dtype1, dtype2):
+        if "scalar" in {self.obj_type1, self.obj_type2}:
+            pytest.skip("to be aligned with NEP-50")
+
+        input1 = _generate_type_routines_input(xp, dtype1, self.obj_type1)
+
+        input2 = _generate_type_routines_input(xp, dtype2, self.obj_type2)
+        ret = xp.result_type(input1, input2)
+        assert isinstance(ret, numpy.dtype)
+        return ret
diff --git a/tests/third_party/cupy/testing/helper.py b/tests/third_party/cupy/testing/helper.py
index 9cf8403cdf2..3d239c273a6 100644
--- a/tests/third_party/cupy/testing/helper.py
+++ b/tests/third_party/cupy/testing/helper.py
@@ -1176,7 +1176,7 @@ def for_signed_dtypes(name="dtype"):
 
 
 def for_unsigned_dtypes(name="dtype"):
-    """Decorator that checks the fixture with unsinged dtypes.
+    """Decorator that checks the fixture with unsigned dtypes.
 
     Args:
          name(str): Argument name to which specified dtypes are passed.