5667360036

# 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

This module contains interface functions between C backend layer
and the rest of the library

"""

import numpy

from dpnp.dpnp_algo cimport *

import dpnp
import dpnp.dpnp_utils as utils_py

cimport numpy

cimport dpnp.dpnp_utils as utils

__all__ = [
    "dpnp_cholesky",
    "dpnp_cond",
    "dpnp_det",
    "dpnp_eig",
    "dpnp_eigvals",
    "dpnp_inv",
    "dpnp_matrix_rank",
    "dpnp_norm",
    "dpnp_qr",
    "dpnp_svd",
]


# C function pointer to the C library template functions
ctypedef c_dpctl.DPCTLSyclEventRef(*custom_linalg_1in_1out_func_ptr_t)(c_dpctl.DPCTLSyclQueueRef,
                                                                       void *, void * ,shape_elem_type * ,
                                                                       size_t, const c_dpctl.DPCTLEventVectorRef)
ctypedef c_dpctl.DPCTLSyclEventRef(*custom_linalg_1in_1out_func_ptr_t_)(c_dpctl.DPCTLSyclQueueRef,
                                                                        void * , void * , size_t * ,
                                                                        const c_dpctl.DPCTLEventVectorRef)
ctypedef c_dpctl.DPCTLSyclEventRef(*custom_linalg_1in_1out_with_size_func_ptr_t_)(c_dpctl.DPCTLSyclQueueRef,
                                                                                  void *, void * , size_t,
                                                                                  const c_dpctl.DPCTLEventVectorRef)
ctypedef c_dpctl.DPCTLSyclEventRef(*custom_linalg_1in_1out_with_2size_func_ptr_t_)(c_dpctl.DPCTLSyclQueueRef,
                                                                                   void *, void * , size_t, size_t,
                                                                                   const c_dpctl.DPCTLEventVectorRef)
ctypedef c_dpctl.DPCTLSyclEventRef(*custom_linalg_1in_3out_shape_t)(c_dpctl.DPCTLSyclQueueRef,
                                                                    void *, void * , void * , void * ,
                                                                    size_t , size_t, const c_dpctl.DPCTLEventVectorRef)
ctypedef c_dpctl.DPCTLSyclEventRef(*custom_linalg_2in_1out_func_ptr_t)(c_dpctl.DPCTLSyclQueueRef,
                                                                       void *, void * , void * , size_t,
                                                                       const c_dpctl.DPCTLEventVectorRef)


cpdef utils.dpnp_descriptor dpnp_cholesky(utils.dpnp_descriptor input_):
    size_ = input_.shape[-1]

    cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(input_.dtype)

    cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_CHOLESKY_EXT, param1_type, param1_type)

    input_obj = input_.get_array()

    # ceate result array with type given by FPTR data
    cdef utils.dpnp_descriptor result = utils.create_output_descriptor(input_.shape,
                                                                       kernel_data.return_type,
                                                                       None,
                                                                       device=input_obj.sycl_device,
                                                                       usm_type=input_obj.usm_type,
                                                                       sycl_queue=input_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 custom_linalg_1in_1out_with_2size_func_ptr_t_ func = <custom_linalg_1in_1out_with_2size_func_ptr_t_ > kernel_data.ptr

    cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref,
                                                    input_.get_data(),
                                                    result.get_data(),
                                                    input_.size,
                                                    size_,
                                                    NULL)  # dep_events_ref

    with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)
    c_dpctl.DPCTLEvent_Delete(event_ref)

    return result


cpdef object dpnp_cond(object input, object p):
    if p in ('f', 'fro'):
        input = dpnp.ravel(input, order='K')
        sqnorm = dpnp.dot(input, input)
        res = dpnp.sqrt(sqnorm)
        ret = dpnp.array([res])
    elif p == dpnp.inf:
        dpnp_sum_val = dpnp.sum(dpnp.abs(input), axis=1)
        ret = dpnp.max(dpnp_sum_val)
    elif p == -dpnp.inf:
        dpnp_sum_val = dpnp.sum(dpnp.abs(input), axis=1)
        ret = dpnp.min(dpnp_sum_val)
    elif p == 1:
        dpnp_sum_val = dpnp.sum(dpnp.abs(input), axis=0)
        ret = dpnp.max(dpnp_sum_val)
    elif p == -1:
        dpnp_sum_val = dpnp.sum(dpnp.abs(input), axis=0)
        ret = dpnp.min(dpnp_sum_val)
    else:
        ret = dpnp.array([input.item(0)])
    return ret


cpdef utils.dpnp_descriptor dpnp_det(utils.dpnp_descriptor input):
    cdef shape_type_c input_shape = input.shape
    cdef size_t n = input.shape[-1]
    cdef size_t size_out = 1
    if input.ndim != 2:
        output_shape = tuple((list(input.shape))[:-2])
        for i in range(len(output_shape)):
            size_out *= output_shape[i]

    cdef shape_type_c result_shape = (size_out,)
    if size_out > 1:
        result_shape = output_shape

    cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(input.dtype)

    cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_DET_EXT, param1_type, param1_type)

    input_obj = input.get_array()

    # ceate result array with type given by FPTR data
    cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape,
                                                                       kernel_data.return_type,
                                                                       None,
                                                                       device=input_obj.sycl_device,
                                                                       usm_type=input_obj.usm_type,
                                                                       sycl_queue=input_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 custom_linalg_1in_1out_func_ptr_t func = <custom_linalg_1in_1out_func_ptr_t > kernel_data.ptr

    cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref,
                                                    input.get_data(),
                                                    result.get_data(),
                                                    input_shape.data(),
                                                    input.ndim,
                                                    NULL)  # dep_events_ref

    with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)
    c_dpctl.DPCTLEvent_Delete(event_ref)

    return result


cpdef tuple dpnp_eig(utils.dpnp_descriptor x1):
    cdef shape_type_c x1_shape = x1.shape

    cdef size_t size = 0 if x1_shape.empty() else x1_shape.front()

    cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(x1.dtype)
    cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_EIG_EXT, param1_type, param1_type)

    x1_obj = x1.get_array()

    cdef (DPNPFuncType, void *) ret_type_and_func = utils.get_ret_type_and_func(kernel_data,
                                                                                x1_obj.sycl_device.has_aspect_fp64)
    cdef DPNPFuncType return_type = ret_type_and_func[0]
    cdef custom_linalg_2in_1out_func_ptr_t func = < custom_linalg_2in_1out_func_ptr_t > ret_type_and_func[1]

    cdef utils.dpnp_descriptor res_val = utils.create_output_descriptor((size,),
                                                                        return_type,
                                                                        None,
                                                                        device=x1_obj.sycl_device,
                                                                        usm_type=x1_obj.usm_type,
                                                                        sycl_queue=x1_obj.sycl_queue)
    cdef utils.dpnp_descriptor res_vec = utils.create_output_descriptor(x1_shape,
                                                                        return_type,
                                                                        None,
                                                                        device=x1_obj.sycl_device,
                                                                        usm_type=x1_obj.usm_type,
                                                                        sycl_queue=x1_obj.sycl_queue)

    result_sycl_queue = res_val.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()

    # call FPTR function
    cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref,
                                                    x1.get_data(),
                                                    res_val.get_data(),
                                                    res_vec.get_data(),
                                                    size,
                                                    NULL)  # dep_events_ref

    with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)
    c_dpctl.DPCTLEvent_Delete(event_ref)

    return (res_val.get_pyobj(), res_vec.get_pyobj())


cpdef utils.dpnp_descriptor dpnp_eigvals(utils.dpnp_descriptor input):
    cdef shape_type_c input_shape = input.shape

    cdef size_t size = 0 if input_shape.empty() else input_shape.front()

    cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(input.dtype)
    cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_EIGVALS_EXT, param1_type, param1_type)

    input_obj = input.get_array()

    cdef (DPNPFuncType, void *) ret_type_and_func = utils.get_ret_type_and_func(kernel_data,
                                                                                input_obj.sycl_device.has_aspect_fp64)
    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
    cdef utils.dpnp_descriptor res_val = utils.create_output_descriptor((size,),
                                                                         return_type,
                                                                         None,
                                                                         device=input_obj.sycl_device,
                                                                         usm_type=input_obj.usm_type,
                                                                         sycl_queue=input_obj.sycl_queue)

    result_sycl_queue = res_val.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()

    # call FPTR function
    cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref,
                                                    input.get_data(),
                                                    res_val.get_data(),
                                                    size,
                                                    NULL)  # dep_events_ref

    with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)
    c_dpctl.DPCTLEvent_Delete(event_ref)

    return res_val


cpdef utils.dpnp_descriptor dpnp_inv(utils.dpnp_descriptor input):
    cdef shape_type_c input_shape = input.shape

    cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(input.dtype)

    cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_INV_EXT, param1_type, param1_type)

    input_obj = input.get_array()

    cdef (DPNPFuncType, void *) ret_type_and_func = utils.get_ret_type_and_func(kernel_data,
                                                                                input_obj.sycl_device.has_aspect_fp64)
    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
    cdef utils.dpnp_descriptor result = utils.create_output_descriptor(input_shape,
                                                                       return_type,
                                                                       None,
                                                                       device=input_obj.sycl_device,
                                                                       usm_type=input_obj.usm_type,
                                                                       sycl_queue=input_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 c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref,
                                                    input.get_data(),
                                                    result.get_data(),
                                                    input_shape.data(),
                                                    input.ndim,
                                                    NULL)  # dep_events_ref

    with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)
    c_dpctl.DPCTLEvent_Delete(event_ref)

    return result


cpdef utils.dpnp_descriptor dpnp_matrix_rank(utils.dpnp_descriptor input):
    cdef shape_type_c input_shape = input.shape
    cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(input.dtype)

    cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_MATRIX_RANK_EXT, param1_type, param1_type)

    input_obj = input.get_array()

    # ceate result array with type given by FPTR data
    cdef utils.dpnp_descriptor result = utils.create_output_descriptor((1,),
                                                                       kernel_data.return_type,
                                                                       None,
                                                                       device=input_obj.sycl_device,
                                                                       usm_type=input_obj.usm_type,
                                                                       sycl_queue=input_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 custom_linalg_1in_1out_func_ptr_t func = <custom_linalg_1in_1out_func_ptr_t > kernel_data.ptr

    cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref,
                                                    input.get_data(),
                                                    result.get_data(),
                                                    input_shape.data(),
                                                    input.ndim,
                                                    NULL)  # dep_events_ref

    with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)
    c_dpctl.DPCTLEvent_Delete(event_ref)

    return result


cpdef object dpnp_norm(object input, ord=None, axis=None):
    cdef long size_input = input.size
    cdef shape_type_c shape_input = input.shape

    dev = input.get_array().sycl_device
    if input.dtype == dpnp.float32 or not dev.has_aspect_fp64:
        res_type = dpnp.float32
    else:
        res_type = dpnp.float64

    if size_input == 0:
        return dpnp.array([dpnp.nan], dtype=res_type)

    if isinstance(axis, int):
        axis_ = tuple([axis])
    else:
        axis_ = axis

    ndim = input.ndim
    if axis is None:
        if ((ord is None) or
            (ord in ('f', 'fro') and ndim == 2) or
                (ord == 2 and ndim == 1)):

            input = dpnp.ravel(input, order='K')
            sqnorm = dpnp.dot(input, input)
            ret = dpnp.sqrt([sqnorm], dtype=res_type)
            return dpnp.array(ret.reshape(1, *ret.shape), dtype=res_type)

    len_axis = 1 if axis is None else len(axis_)
    if len_axis == 1:
        if ord == dpnp.inf:
            return dpnp.array([dpnp.abs(input).max(axis=axis)])
        elif ord == -dpnp.inf:
            return dpnp.array([dpnp.abs(input).min(axis=axis)])
        elif ord == 0:
            return input.dtype.type(dpnp.count_nonzero(input, axis=axis))
        elif ord is None or ord == 2:
            s = input * input
            return dpnp.sqrt(dpnp.sum(s, axis=axis), dtype=res_type)
        elif isinstance(ord, str):
            raise ValueError(f"Invalid norm order '{ord}' for vectors")
        else:
            absx = dpnp.abs(input)
            absx_size = absx.size
            absx_power = utils_py.create_output_descriptor_py((absx_size,), absx.dtype, None).get_pyobj()

            absx_flatiter = absx.flat

            for i in range(absx_size):
                absx_elem = absx_flatiter[i]
                absx_power[i] = absx_elem ** ord
            absx_ = dpnp.reshape(absx_power, absx.shape)
            ret = dpnp.sum(absx_, axis=axis)
            ret_size = ret.size
            ret_power = utils_py.create_output_descriptor_py((ret_size,), None, None).get_pyobj()

            ret_flatiter = ret.flat

            for i in range(ret_size):
                ret_elem = ret_flatiter[i]
                ret_power[i] = ret_elem ** (1 / ord)
            ret_ = dpnp.reshape(ret_power, ret.shape)
            return ret_
    elif len_axis == 2:
        row_axis, col_axis = axis_
        if row_axis == col_axis:
            raise ValueError('Duplicate axes given.')
        # if ord == 2:
        #     ret =  _multi_svd_norm(input, row_axis, col_axis, amax)
        # elif ord == -2:
        #     ret = _multi_svd_norm(input, row_axis, col_axis, amin)
        elif ord == 1:
            if col_axis > row_axis:
                col_axis -= 1
            dpnp_sum_val = dpnp.sum(dpnp.abs(input), axis=row_axis)
            ret = dpnp_sum_val.min(axis=col_axis)
        elif ord == dpnp.inf:
            if row_axis > col_axis:
                row_axis -= 1
            dpnp_sum_val = dpnp.sum(dpnp.abs(input), axis=col_axis)
            ret = dpnp_sum_val.max(axis=row_axis)
        elif ord == -1:
            if col_axis > row_axis:
                col_axis -= 1
            dpnp_sum_val = dpnp.sum(dpnp.abs(input), axis=row_axis)
            ret = dpnp_sum_val.min(axis=col_axis)
        elif ord == -dpnp.inf:
            if row_axis > col_axis:
                row_axis -= 1
            dpnp_sum_val = dpnp.sum(dpnp.abs(input), axis=col_axis)
            ret = dpnp_sum_val.min(axis=row_axis)
        elif ord in [None, 'fro', 'f']:
            ret = dpnp.sqrt(dpnp.sum(input * input, axis=axis))
        # elif ord == 'nuc':
        #     ret = _multi_svd_norm(input, row_axis, col_axis, sum)
        else:
            raise ValueError("Invalid norm order for matrices.")

        return ret
    else:
        raise ValueError("Improper number of dimensions to norm.")


cpdef tuple dpnp_qr(utils.dpnp_descriptor x1, str mode):
    cdef size_t size_m = x1.shape[0]
    cdef size_t size_n = x1.shape[1]
    cdef size_t min_m_n = min(size_m, size_n)
    cdef size_t size_tau = min_m_n

    cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(x1.dtype)
    cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_QR_EXT, param1_type, param1_type)

    x1_obj = x1.get_array()

    cdef (DPNPFuncType, void *) ret_type_and_func = utils.get_ret_type_and_func(kernel_data,
                                                                                x1_obj.sycl_device.has_aspect_fp64)
    cdef DPNPFuncType return_type = ret_type_and_func[0]
    cdef custom_linalg_1in_3out_shape_t func = < custom_linalg_1in_3out_shape_t > ret_type_and_func[1]

    cdef utils.dpnp_descriptor res_q = utils.create_output_descriptor((size_m, min_m_n),
                                                                       return_type,
                                                                       None,
                                                                       device=x1_obj.sycl_device,
                                                                       usm_type=x1_obj.usm_type,
                                                                       sycl_queue=x1_obj.sycl_queue)
    cdef utils.dpnp_descriptor res_r = utils.create_output_descriptor((min_m_n, size_n),
                                                                       return_type,
                                                                       None,
                                                                       device=x1_obj.sycl_device,
                                                                       usm_type=x1_obj.usm_type,
                                                                       sycl_queue=x1_obj.sycl_queue)
    cdef utils.dpnp_descriptor tau = utils.create_output_descriptor((size_tau, ),
                                                                     return_type,
                                                                     None,
                                                                     device=x1_obj.sycl_device,
                                                                     usm_type=x1_obj.usm_type,
                                                                     sycl_queue=x1_obj.sycl_queue)

    result_sycl_queue = res_q.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 c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref,
                                                    x1.get_data(),
                                                    res_q.get_data(),
                                                    res_r.get_data(),
                                                    tau.get_data(),
                                                    size_m,
                                                    size_n,
                                                    NULL)  # dep_events_ref

    with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)
    c_dpctl.DPCTLEvent_Delete(event_ref)

    return (res_q.get_pyobj(), res_r.get_pyobj())


cpdef tuple dpnp_svd(utils.dpnp_descriptor x1, cpp_bool full_matrices, cpp_bool compute_uv, cpp_bool hermitian):
    cdef size_t size_m = x1.shape[0]
    cdef size_t size_n = x1.shape[1]
    cdef size_t size_s = min(size_m, size_n)

    cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(x1.dtype)
    cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_SVD_EXT, param1_type, param1_type)

    x1_obj = x1.get_array()

    cdef (DPNPFuncType, void *) ret_type_and_func = utils.get_ret_type_and_func(kernel_data,
                                                                                x1_obj.sycl_device.has_aspect_fp64)
    cdef DPNPFuncType return_type = ret_type_and_func[0]
    cdef custom_linalg_1in_3out_shape_t func = < custom_linalg_1in_3out_shape_t > ret_type_and_func[1]

    cdef utils.dpnp_descriptor res_u = utils.create_output_descriptor((size_m, size_m),
                                                                       return_type,
                                                                       None,
                                                                       device=x1_obj.sycl_device,
                                                                       usm_type=x1_obj.usm_type,
                                                                       sycl_queue=x1_obj.sycl_queue)
    cdef utils.dpnp_descriptor res_s = utils.create_output_descriptor((size_s, ),
                                                                       return_type,
                                                                       None,
                                                                       device=x1_obj.sycl_device,
                                                                       usm_type=x1_obj.usm_type,
                                                                       sycl_queue=x1_obj.sycl_queue)
    cdef utils.dpnp_descriptor res_vt = utils.create_output_descriptor((size_n, size_n),
                                                                       return_type,
                                                                       None,
                                                                       device=x1_obj.sycl_device,
                                                                       usm_type=x1_obj.usm_type,
                                                                       sycl_queue=x1_obj.sycl_queue)

    result_sycl_queue = res_u.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 c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref,
                                                    x1.get_data(),
                                                    res_u.get_data(),
                                                    res_s.get_data(),
                                                    res_vt.get_data(),
                                                    size_m,
                                                    size_n,
                                                    NULL)  # dep_events_ref

    with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)
    c_dpctl.DPCTLEvent_Delete(event_ref)

    return (res_u.get_pyobj(), res_s.get_pyobj(), res_vt.get_pyobj())

1	# cython: language_level=3	1✔
2	# cython: linetrace=True
3	# -- coding: utf-8 --
4	# *****************************************************************************
5	# Copyright (c) 2016-2023, Intel Corporation
6	# All rights reserved.
7	#
8	# Redistribution and use in source and binary forms, with or without
9	# modification, are permitted provided that the following conditions are met:
10	# - Redistributions of source code must retain the above copyright notice,
11	# this list of conditions and the following disclaimer.
12	# - Redistributions in binary form must reproduce the above copyright notice,
13	# this list of conditions and the following disclaimer in the documentation
14	# and/or other materials provided with the distribution.
15	#
16	# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17	# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18	# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19	# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
20	# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21	# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22	# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23	# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24	# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25	# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
26	# THE POSSIBILITY OF SUCH DAMAGE.
27	# *****************************************************************************
28
29	"""Module Backend
30
31	This module contains interface functions between C backend layer
32	and the rest of the library
33
34	"""
35
36	import numpy	1✔
37
38	from dpnp.dpnp_algo cimport *
39
40	import dpnp	1✔
41	import dpnp.dpnp_utils as utils_py	1✔
42
43	cimport numpy
44
45	cimport dpnp.dpnp_utils as utils
46
47	__all__ = [	1✔
48	"dpnp_cholesky",
49	"dpnp_cond",
50	"dpnp_det",
51	"dpnp_eig",
52	"dpnp_eigvals",
53	"dpnp_inv",
54	"dpnp_matrix_rank",
55	"dpnp_norm",
56	"dpnp_qr",
57	"dpnp_svd",
58	]
59
60
61	# C function pointer to the C library template functions
62	ctypedef c_dpctl.DPCTLSyclEventRef(*custom_linalg_1in_1out_func_ptr_t)(c_dpctl.DPCTLSyclQueueRef,
63	void , void ,shape_elem_type * ,
64	size_t, const c_dpctl.DPCTLEventVectorRef)
65	ctypedef c_dpctl.DPCTLSyclEventRef(*custom_linalg_1in_1out_func_ptr_t_)(c_dpctl.DPCTLSyclQueueRef,
66	void * , void * , size_t * ,
67	const c_dpctl.DPCTLEventVectorRef)
68	ctypedef c_dpctl.DPCTLSyclEventRef(*custom_linalg_1in_1out_with_size_func_ptr_t_)(c_dpctl.DPCTLSyclQueueRef,
69	void , void , size_t,
70	const c_dpctl.DPCTLEventVectorRef)
71	ctypedef c_dpctl.DPCTLSyclEventRef(*custom_linalg_1in_1out_with_2size_func_ptr_t_)(c_dpctl.DPCTLSyclQueueRef,
72	void , void , size_t, size_t,
73	const c_dpctl.DPCTLEventVectorRef)
74	ctypedef c_dpctl.DPCTLSyclEventRef(*custom_linalg_1in_3out_shape_t)(c_dpctl.DPCTLSyclQueueRef,
75	void , void , void * , void * ,
76	size_t , size_t, const c_dpctl.DPCTLEventVectorRef)
77	ctypedef c_dpctl.DPCTLSyclEventRef(*custom_linalg_2in_1out_func_ptr_t)(c_dpctl.DPCTLSyclQueueRef,
78	void , void , void * , size_t,
79	const c_dpctl.DPCTLEventVectorRef)
80
81
82	cpdef utils.dpnp_descriptor dpnp_cholesky(utils.dpnp_descriptor input_):	1✔
83	size_ = input_.shape[-1]	1✔
84
85	cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(input_.dtype)	1✔
86
87	cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_CHOLESKY_EXT, param1_type, param1_type)	1✔
88
89	input_obj = input_.get_array()	1✔
90
91	# ceate result array with type given by FPTR data
92	cdef utils.dpnp_descriptor result = utils.create_output_descriptor(input_.shape,	1✔
93	kernel_data.return_type,
94	None,
95	device=input_obj.sycl_device,	1✔
96	usm_type=input_obj.usm_type,	1✔
97	sycl_queue=input_obj.sycl_queue)	1✔
98
99	result_sycl_queue = result.get_array().sycl_queue	1✔
100
101	cdef c_dpctl.SyclQueue q = <c_dpctl.SyclQueue> result_sycl_queue	1✔
102	cdef c_dpctl.DPCTLSyclQueueRef q_ref = q.get_queue_ref()	1✔
103
104	cdef custom_linalg_1in_1out_with_2size_func_ptr_t_ func = <custom_linalg_1in_1out_with_2size_func_ptr_t_ > kernel_data.ptr	1✔
105
106	cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref,	1✔
107	input_.get_data(),
108	result.get_data(),
109	input_.size,	1✔
110	size_,	1✔
111	NULL) # dep_events_ref
112
113	with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)	1✔
114	c_dpctl.DPCTLEvent_Delete(event_ref)	1✔
115
116	return result	1✔
117
118
119	cpdef object dpnp_cond(object input, object p):	1✔
120	if p in ('f', 'fro'):	1✔
121	input = dpnp.ravel(input, order='K')	×
122	sqnorm = dpnp.dot(input, input)	×
123	res = dpnp.sqrt(sqnorm)	×
124	ret = dpnp.array([res])	×
125	elif p == dpnp.inf:	1✔
126	dpnp_sum_val = dpnp.sum(dpnp.abs(input), axis=1)	1✔
127	ret = dpnp.max(dpnp_sum_val)	1✔
128	elif p == -dpnp.inf:	1✔
129	dpnp_sum_val = dpnp.sum(dpnp.abs(input), axis=1)	1✔
130	ret = dpnp.min(dpnp_sum_val)	1✔
131	elif p == 1:	1✔
132	dpnp_sum_val = dpnp.sum(dpnp.abs(input), axis=0)	1✔
133	ret = dpnp.max(dpnp_sum_val)	1✔
134	elif p == -1:	1✔
135	dpnp_sum_val = dpnp.sum(dpnp.abs(input), axis=0)	1✔
136	ret = dpnp.min(dpnp_sum_val)	1✔
137	else:
138	ret = dpnp.array([input.item(0)])	×
139	return ret	1✔
140
141
142	cpdef utils.dpnp_descriptor dpnp_det(utils.dpnp_descriptor input):	1✔
143	cdef shape_type_c input_shape = input.shape	1✔
144	cdef size_t n = input.shape[-1]	1✔
145	cdef size_t size_out = 1	1✔
146	if input.ndim != 2:	1✔
147	output_shape = tuple((list(input.shape))[:-2])	1✔
148	for i in range(len(output_shape)):	1✔
149	size_out *= output_shape[i]	1✔
150
151	cdef shape_type_c result_shape = (size_out,)	1✔
152	if size_out > 1:	1✔
153	result_shape = output_shape	1✔
154
155	cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(input.dtype)	1✔
156
157	cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_DET_EXT, param1_type, param1_type)	1✔
158
159	input_obj = input.get_array()	1✔
160
161	# ceate result array with type given by FPTR data
162	cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape,	1✔
163	kernel_data.return_type,
164	None,
165	device=input_obj.sycl_device,	1✔
166	usm_type=input_obj.usm_type,	1✔
167	sycl_queue=input_obj.sycl_queue)	1✔
168
169	result_sycl_queue = result.get_array().sycl_queue	1✔
170
171	cdef c_dpctl.SyclQueue q = <c_dpctl.SyclQueue> result_sycl_queue	1✔
172	cdef c_dpctl.DPCTLSyclQueueRef q_ref = q.get_queue_ref()	1✔
173
174	cdef custom_linalg_1in_1out_func_ptr_t func = <custom_linalg_1in_1out_func_ptr_t > kernel_data.ptr	1✔
175
176	cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref,	1✔
177	input.get_data(),
178	result.get_data(),
179	input_shape.data(),
180	input.ndim,	1✔
181	NULL) # dep_events_ref
182
183	with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)	1✔
184	c_dpctl.DPCTLEvent_Delete(event_ref)	1✔
185
186	return result	1✔
187
188
189	cpdef tuple dpnp_eig(utils.dpnp_descriptor x1):	1✔
190	cdef shape_type_c x1_shape = x1.shape	1✔
191
192	cdef size_t size = 0 if x1_shape.empty() else x1_shape.front()	1✔
193
194	cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(x1.dtype)	1✔
195	cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_EIG_EXT, param1_type, param1_type)	1✔
196
197	x1_obj = x1.get_array()	1✔
198
199	cdef (DPNPFuncType, void *) ret_type_and_func = utils.get_ret_type_and_func(kernel_data,	1✔
200	x1_obj.sycl_device.has_aspect_fp64)	1✔
201	cdef DPNPFuncType return_type = ret_type_and_func[0]	1✔
202	cdef custom_linalg_2in_1out_func_ptr_t func = < custom_linalg_2in_1out_func_ptr_t > ret_type_and_func[1]	1✔
203
204	cdef utils.dpnp_descriptor res_val = utils.create_output_descriptor((size,),	1✔
205	return_type,
206	None,
207	device=x1_obj.sycl_device,	1✔
208	usm_type=x1_obj.usm_type,	1✔
209	sycl_queue=x1_obj.sycl_queue)	1✔
210	cdef utils.dpnp_descriptor res_vec = utils.create_output_descriptor(x1_shape,	1✔
211	return_type,
212	None,
213	device=x1_obj.sycl_device,	1✔
214	usm_type=x1_obj.usm_type,	1✔
215	sycl_queue=x1_obj.sycl_queue)	1✔
216
217	result_sycl_queue = res_val.get_array().sycl_queue	1✔
218
219	cdef c_dpctl.SyclQueue q = <c_dpctl.SyclQueue> result_sycl_queue	1✔
220	cdef c_dpctl.DPCTLSyclQueueRef q_ref = q.get_queue_ref()	1✔
221
222	# call FPTR function
223	cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref,	1✔
224	x1.get_data(),
225	res_val.get_data(),
226	res_vec.get_data(),
227	size,
228	NULL) # dep_events_ref
229
230	with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)	1✔
231	c_dpctl.DPCTLEvent_Delete(event_ref)	1✔
232
233	return (res_val.get_pyobj(), res_vec.get_pyobj())	1✔
234
235
236	cpdef utils.dpnp_descriptor dpnp_eigvals(utils.dpnp_descriptor input):	1✔
237	cdef shape_type_c input_shape = input.shape	×
238
239	cdef size_t size = 0 if input_shape.empty() else input_shape.front()	×
240
241	cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(input.dtype)	×
242	cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_EIGVALS_EXT, param1_type, param1_type)	×
243
244	input_obj = input.get_array()	×
245
NEW 246	cdef (DPNPFuncType, void *) ret_type_and_func = utils.get_ret_type_and_func(kernel_data,	×
NEW 247	input_obj.sycl_device.has_aspect_fp64)	×
248	cdef DPNPFuncType return_type = ret_type_and_func[0]	×
249	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]	×
250
251	# ceate result array with type given by FPTR data
252	cdef utils.dpnp_descriptor res_val = utils.create_output_descriptor((size,),	×
253	return_type,
254	None,
255	device=input_obj.sycl_device,	×
256	usm_type=input_obj.usm_type,	×
257	sycl_queue=input_obj.sycl_queue)	×
258
259	result_sycl_queue = res_val.get_array().sycl_queue	×
260
261	cdef c_dpctl.SyclQueue q = <c_dpctl.SyclQueue> result_sycl_queue	×
262	cdef c_dpctl.DPCTLSyclQueueRef q_ref = q.get_queue_ref()	×
263
264	# call FPTR function
265	cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref,	×
266	input.get_data(),
267	res_val.get_data(),
268	size,
269	NULL) # dep_events_ref
270
271	with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)	×
272	c_dpctl.DPCTLEvent_Delete(event_ref)	×
273
274	return res_val	×
275
276
277	cpdef utils.dpnp_descriptor dpnp_inv(utils.dpnp_descriptor input):	1✔
278	cdef shape_type_c input_shape = input.shape	1✔
279
280	cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(input.dtype)	1✔
281
282	cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_INV_EXT, param1_type, param1_type)	1✔
283
284	input_obj = input.get_array()	1✔
285
286	cdef (DPNPFuncType, void *) ret_type_and_func = utils.get_ret_type_and_func(kernel_data,	1✔
287	input_obj.sycl_device.has_aspect_fp64)	1✔
288	cdef DPNPFuncType return_type = ret_type_and_func[0]	1✔
289	cdef custom_linalg_1in_1out_func_ptr_t func = < custom_linalg_1in_1out_func_ptr_t > ret_type_and_func[1]	1✔
290
291	# ceate result array with type given by FPTR data
292	cdef utils.dpnp_descriptor result = utils.create_output_descriptor(input_shape,	1✔
293	return_type,
294	None,
295	device=input_obj.sycl_device,	1✔
296	usm_type=input_obj.usm_type,	1✔
297	sycl_queue=input_obj.sycl_queue)	1✔
298
299	result_sycl_queue = result.get_array().sycl_queue	1✔
300
301	cdef c_dpctl.SyclQueue q = <c_dpctl.SyclQueue> result_sycl_queue	1✔
302	cdef c_dpctl.DPCTLSyclQueueRef q_ref = q.get_queue_ref()	1✔
303
304	cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref,	1✔
305	input.get_data(),
306	result.get_data(),
307	input_shape.data(),
308	input.ndim,	1✔
309	NULL) # dep_events_ref
310
311	with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)	1✔
312	c_dpctl.DPCTLEvent_Delete(event_ref)	1✔
313
314	return result	1✔
315
316
317	cpdef utils.dpnp_descriptor dpnp_matrix_rank(utils.dpnp_descriptor input):	1✔
318	cdef shape_type_c input_shape = input.shape	1✔
319	cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(input.dtype)	1✔
320
321	cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_MATRIX_RANK_EXT, param1_type, param1_type)	1✔
322
323	input_obj = input.get_array()	1✔
324
325	# ceate result array with type given by FPTR data
326	cdef utils.dpnp_descriptor result = utils.create_output_descriptor((1,),	1✔
327	kernel_data.return_type,
328	None,
329	device=input_obj.sycl_device,	1✔
330	usm_type=input_obj.usm_type,	1✔
331	sycl_queue=input_obj.sycl_queue)	1✔
332
333	result_sycl_queue = result.get_array().sycl_queue	1✔
334
335	cdef c_dpctl.SyclQueue q = <c_dpctl.SyclQueue> result_sycl_queue	1✔
336	cdef c_dpctl.DPCTLSyclQueueRef q_ref = q.get_queue_ref()	1✔
337
338	cdef custom_linalg_1in_1out_func_ptr_t func = <custom_linalg_1in_1out_func_ptr_t > kernel_data.ptr	1✔
339
340	cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref,	1✔
341	input.get_data(),
342	result.get_data(),
343	input_shape.data(),
344	input.ndim,	1✔
345	NULL) # dep_events_ref
346
347	with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)	1✔
348	c_dpctl.DPCTLEvent_Delete(event_ref)	1✔
349
350	return result	1✔
351
352
353	cpdef object dpnp_norm(object input, ord=None, axis=None):	1✔
354	cdef long size_input = input.size	1✔
355	cdef shape_type_c shape_input = input.shape	1✔
356
357	dev = input.get_array().sycl_device	1✔
358	if input.dtype == dpnp.float32 or not dev.has_aspect_fp64:	1✔
359	res_type = dpnp.float32	×
360	else:
361	res_type = dpnp.float64	1✔
362
363	if size_input == 0:	1✔
364	return dpnp.array([dpnp.nan], dtype=res_type)	×
365
366	if isinstance(axis, int):	1✔
367	axis_ = tuple([axis])	1✔
368	else:
369	axis_ = axis	1✔
370
371	ndim = input.ndim	1✔
372	if axis is None:	1✔
373	if ((ord is None) or	1✔
374	(ord in ('f', 'fro') and ndim == 2) or	1✔
375	(ord == 2 and ndim == 1)):	1✔
376
377	input = dpnp.ravel(input, order='K')	1✔
378	sqnorm = dpnp.dot(input, input)	1✔
379	ret = dpnp.sqrt([sqnorm], dtype=res_type)	1✔
380	return dpnp.array(ret.reshape(1, *ret.shape), dtype=res_type)	1✔
381
382	len_axis = 1 if axis is None else len(axis_)	1✔
383	if len_axis == 1:	1✔
384	if ord == dpnp.inf:	1✔
385	return dpnp.array([dpnp.abs(input).max(axis=axis)])	×
386	elif ord == -dpnp.inf:	1✔
387	return dpnp.array([dpnp.abs(input).min(axis=axis)])	×
388	elif ord == 0:	1✔
389	return input.dtype.type(dpnp.count_nonzero(input, axis=axis))	1✔
390	elif ord is None or ord == 2:	1✔
391	s = input * input	1✔
392	return dpnp.sqrt(dpnp.sum(s, axis=axis), dtype=res_type)	1✔
393	elif isinstance(ord, str):	×
394	raise ValueError(f"Invalid norm order '{ord}' for vectors")	×
395	else:
396	absx = dpnp.abs(input)	×
397	absx_size = absx.size	×
UNCOV 398	absx_power = utils_py.create_output_descriptor_py((absx_size,), absx.dtype, None).get_pyobj()	×
399
400	absx_flatiter = absx.flat	×
401
402	for i in range(absx_size):	×
403	absx_elem = absx_flatiter[i]	×
404	absx_power[i] = absx_elem ** ord	×
405	absx_ = dpnp.reshape(absx_power, absx.shape)	×
406	ret = dpnp.sum(absx_, axis=axis)	×
407	ret_size = ret.size	×
408	ret_power = utils_py.create_output_descriptor_py((ret_size,), None, None).get_pyobj()	×
409
410	ret_flatiter = ret.flat	×
411
412	for i in range(ret_size):	×
413	ret_elem = ret_flatiter[i]	×
414	ret_power[i] = ret_elem ** (1 / ord)	×
415	ret_ = dpnp.reshape(ret_power, ret.shape)	×
416	return ret_	×
417	elif len_axis == 2:
418	row_axis, col_axis = axis_	1✔
419	if row_axis == col_axis:	1✔
420	raise ValueError('Duplicate axes given.')	×
421	# if ord == 2:
422	# ret = _multi_svd_norm(input, row_axis, col_axis, amax)
423	# elif ord == -2:
424	# ret = _multi_svd_norm(input, row_axis, col_axis, amin)
425	elif ord == 1:	1✔
426	if col_axis > row_axis:	×
427	col_axis -= 1	×
428	dpnp_sum_val = dpnp.sum(dpnp.abs(input), axis=row_axis)	×
429	ret = dpnp_sum_val.min(axis=col_axis)	×
430	elif ord == dpnp.inf:	1✔
431	if row_axis > col_axis:	×
432	row_axis -= 1	×
433	dpnp_sum_val = dpnp.sum(dpnp.abs(input), axis=col_axis)	1✔
434	ret = dpnp_sum_val.max(axis=row_axis)	×
435	elif ord == -1:	1✔
UNCOV 436	if col_axis > row_axis:	×
437	col_axis -= 1	×
438	dpnp_sum_val = dpnp.sum(dpnp.abs(input), axis=row_axis)	×
439	ret = dpnp_sum_val.min(axis=col_axis)	×
440	elif ord == -dpnp.inf:	1✔
441	if row_axis > col_axis:	×
442	row_axis -= 1	×
443	dpnp_sum_val = dpnp.sum(dpnp.abs(input), axis=col_axis)	1✔
444	ret = dpnp_sum_val.min(axis=row_axis)	×
445	elif ord in [None, 'fro', 'f']:	1✔
446	ret = dpnp.sqrt(dpnp.sum(input * input, axis=axis))	1✔
447	# elif ord == 'nuc':
448	# ret = _multi_svd_norm(input, row_axis, col_axis, sum)
449	else:
450	raise ValueError("Invalid norm order for matrices.")	×
451
452	return ret	1✔
453	else:
UNCOV 454	raise ValueError("Improper number of dimensions to norm.")	×
455
456
457	cpdef tuple dpnp_qr(utils.dpnp_descriptor x1, str mode):	1✔
458	cdef size_t size_m = x1.shape[0]	1✔
459	cdef size_t size_n = x1.shape[1]	1✔
460	cdef size_t min_m_n = min(size_m, size_n)	1✔
461	cdef size_t size_tau = min_m_n	1✔
462
463	cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(x1.dtype)	1✔
464	cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_QR_EXT, param1_type, param1_type)	1✔
465
466	x1_obj = x1.get_array()	1✔
467
468	cdef (DPNPFuncType, void *) ret_type_and_func = utils.get_ret_type_and_func(kernel_data,	1✔
469	x1_obj.sycl_device.has_aspect_fp64)	1✔
470	cdef DPNPFuncType return_type = ret_type_and_func[0]	1✔
471	cdef custom_linalg_1in_3out_shape_t func = < custom_linalg_1in_3out_shape_t > ret_type_and_func[1]	1✔
472
473	cdef utils.dpnp_descriptor res_q = utils.create_output_descriptor((size_m, min_m_n),	1✔
474	return_type,
475	None,
476	device=x1_obj.sycl_device,	1✔
477	usm_type=x1_obj.usm_type,	1✔
478	sycl_queue=x1_obj.sycl_queue)	1✔
479	cdef utils.dpnp_descriptor res_r = utils.create_output_descriptor((min_m_n, size_n),	1✔
480	return_type,
481	None,
482	device=x1_obj.sycl_device,	1✔
483	usm_type=x1_obj.usm_type,	1✔
484	sycl_queue=x1_obj.sycl_queue)	1✔
485	cdef utils.dpnp_descriptor tau = utils.create_output_descriptor((size_tau, ),	1✔
486	return_type,
487	None,
488	device=x1_obj.sycl_device,	1✔
489	usm_type=x1_obj.usm_type,	1✔
490	sycl_queue=x1_obj.sycl_queue)	1✔
491
492	result_sycl_queue = res_q.get_array().sycl_queue	1✔
493
494	cdef c_dpctl.SyclQueue q = <c_dpctl.SyclQueue> result_sycl_queue	1✔
495	cdef c_dpctl.DPCTLSyclQueueRef q_ref = q.get_queue_ref()	1✔
496
497	cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref,	1✔
498	x1.get_data(),
499	res_q.get_data(),
500	res_r.get_data(),
501	tau.get_data(),
502	size_m,
503	size_n,
504	NULL) # dep_events_ref
505
506	with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)	1✔
507	c_dpctl.DPCTLEvent_Delete(event_ref)	1✔
508
509	return (res_q.get_pyobj(), res_r.get_pyobj())	1✔
510
511
512	cpdef tuple dpnp_svd(utils.dpnp_descriptor x1, cpp_bool full_matrices, cpp_bool compute_uv, cpp_bool hermitian):	1✔
513	cdef size_t size_m = x1.shape[0]	1✔
514	cdef size_t size_n = x1.shape[1]	1✔
515	cdef size_t size_s = min(size_m, size_n)	1✔
516
517	cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(x1.dtype)	1✔
518	cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_SVD_EXT, param1_type, param1_type)	1✔
519
520	x1_obj = x1.get_array()	1✔
521
522	cdef (DPNPFuncType, void *) ret_type_and_func = utils.get_ret_type_and_func(kernel_data,	1✔
523	x1_obj.sycl_device.has_aspect_fp64)	1✔
524	cdef DPNPFuncType return_type = ret_type_and_func[0]	1✔
525	cdef custom_linalg_1in_3out_shape_t func = < custom_linalg_1in_3out_shape_t > ret_type_and_func[1]	1✔
526
527	cdef utils.dpnp_descriptor res_u = utils.create_output_descriptor((size_m, size_m),	1✔
528	return_type,
529	None,
530	device=x1_obj.sycl_device,	1✔
531	usm_type=x1_obj.usm_type,	1✔
532	sycl_queue=x1_obj.sycl_queue)	1✔
533	cdef utils.dpnp_descriptor res_s = utils.create_output_descriptor((size_s, ),	1✔
534	return_type,
535	None,
536	device=x1_obj.sycl_device,	1✔
537	usm_type=x1_obj.usm_type,	1✔
538	sycl_queue=x1_obj.sycl_queue)	1✔
539	cdef utils.dpnp_descriptor res_vt = utils.create_output_descriptor((size_n, size_n),	1✔
540	return_type,
541	None,
542	device=x1_obj.sycl_device,	1✔
543	usm_type=x1_obj.usm_type,	1✔
544	sycl_queue=x1_obj.sycl_queue)	1✔
545
546	result_sycl_queue = res_u.get_array().sycl_queue	1✔
547
548	cdef c_dpctl.SyclQueue q = <c_dpctl.SyclQueue> result_sycl_queue	1✔
549	cdef c_dpctl.DPCTLSyclQueueRef q_ref = q.get_queue_ref()	1✔
550
551	cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref,	1✔
552	x1.get_data(),
553	res_u.get_data(),
554	res_s.get_data(),
555	res_vt.get_data(),
556	size_m,
557	size_n,
558	NULL) # dep_events_ref
559
560	with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)	1✔
561	c_dpctl.DPCTLEvent_Delete(event_ref)	1✔
562
563	return (res_u.get_pyobj(), res_s.get_pyobj(), res_vt.get_pyobj())	1✔

IntelPython / dpnp / 5667360036

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous