5661145525

# 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(x1_obj.sycl_device, kernel_data)
    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(input_obj.sycl_device, kernel_data)
    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(input_obj.sycl_device, kernel_data)
    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(x1_obj.sycl_device, kernel_data)
    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(x1_obj.sycl_device, kernel_data)
    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(x1_obj.sycl_device, kernel_data)	1✔
200	cdef DPNPFuncType return_type = ret_type_and_func[0]	1✔
201	cdef custom_linalg_2in_1out_func_ptr_t func = < custom_linalg_2in_1out_func_ptr_t > ret_type_and_func[1]	1✔
202
203	cdef utils.dpnp_descriptor res_val = utils.create_output_descriptor((size,),	1✔
204	return_type,
205	None,
206	device=x1_obj.sycl_device,	1✔
207	usm_type=x1_obj.usm_type,	1✔
208	sycl_queue=x1_obj.sycl_queue)	1✔
209	cdef utils.dpnp_descriptor res_vec = utils.create_output_descriptor(x1_shape,	1✔
210	return_type,
211	None,
212	device=x1_obj.sycl_device,	1✔
213	usm_type=x1_obj.usm_type,	1✔
214	sycl_queue=x1_obj.sycl_queue)	1✔
215
216	result_sycl_queue = res_val.get_array().sycl_queue	1✔
217
218	cdef c_dpctl.SyclQueue q = <c_dpctl.SyclQueue> result_sycl_queue	1✔
219	cdef c_dpctl.DPCTLSyclQueueRef q_ref = q.get_queue_ref()	1✔
220
221	# call FPTR function
222	cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref,	1✔
223	x1.get_data(),
224	res_val.get_data(),
225	res_vec.get_data(),
226	size,
227	NULL) # dep_events_ref
228
229	with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)	1✔
230	c_dpctl.DPCTLEvent_Delete(event_ref)	1✔
231
232	return (res_val.get_pyobj(), res_vec.get_pyobj())	1✔
233
234
235	cpdef utils.dpnp_descriptor dpnp_eigvals(utils.dpnp_descriptor input):	1✔
236	cdef shape_type_c input_shape = input.shape	×
237
238	cdef size_t size = 0 if input_shape.empty() else input_shape.front()	×
239
240	cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(input.dtype)	×
241	cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_EIGVALS_EXT, param1_type, param1_type)	×
242
243	input_obj = input.get_array()	×
244
245	cdef (DPNPFuncType, void *) ret_type_and_func = utils.get_ret_type_and_func(input_obj.sycl_device, kernel_data)	1✔
NEW 246	cdef DPNPFuncType return_type = ret_type_and_func[0]	×
NEW 247	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]	×
248
249	# ceate result array with type given by FPTR data
250	cdef utils.dpnp_descriptor res_val = utils.create_output_descriptor((size,),	×
251	return_type,
252	None,
253	device=input_obj.sycl_device,	×
254	usm_type=input_obj.usm_type,	×
255	sycl_queue=input_obj.sycl_queue)	×
256
257	result_sycl_queue = res_val.get_array().sycl_queue	×
258
259	cdef c_dpctl.SyclQueue q = <c_dpctl.SyclQueue> result_sycl_queue	×
260	cdef c_dpctl.DPCTLSyclQueueRef q_ref = q.get_queue_ref()	×
261
262	# call FPTR function
263	cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref,	×
264	input.get_data(),
265	res_val.get_data(),
266	size,
267	NULL) # dep_events_ref
268
269	with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)	×
270	c_dpctl.DPCTLEvent_Delete(event_ref)	×
271
272	return res_val	×
273
274
275	cpdef utils.dpnp_descriptor dpnp_inv(utils.dpnp_descriptor input):	1✔
276	cdef shape_type_c input_shape = input.shape	1✔
277
278	cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(input.dtype)	1✔
279
280	cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_INV_EXT, param1_type, param1_type)	1✔
281
282	input_obj = input.get_array()	1✔
283
284	cdef (DPNPFuncType, void *) ret_type_and_func = utils.get_ret_type_and_func(input_obj.sycl_device, kernel_data)	1✔
285	cdef DPNPFuncType return_type = ret_type_and_func[0]	1✔
286	cdef custom_linalg_1in_1out_func_ptr_t func = < custom_linalg_1in_1out_func_ptr_t > ret_type_and_func[1]	1✔
287
288	# ceate result array with type given by FPTR data
289	cdef utils.dpnp_descriptor result = utils.create_output_descriptor(input_shape,	1✔
290	return_type,
291	None,
292	device=input_obj.sycl_device,	1✔
293	usm_type=input_obj.usm_type,	1✔
294	sycl_queue=input_obj.sycl_queue)	1✔
295
296	result_sycl_queue = result.get_array().sycl_queue	1✔
297
298	cdef c_dpctl.SyclQueue q = <c_dpctl.SyclQueue> result_sycl_queue	1✔
299	cdef c_dpctl.DPCTLSyclQueueRef q_ref = q.get_queue_ref()	1✔
300
301	cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref,	1✔
302	input.get_data(),
303	result.get_data(),
304	input_shape.data(),
305	input.ndim,	1✔
306	NULL) # dep_events_ref
307
308	with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)	1✔
309	c_dpctl.DPCTLEvent_Delete(event_ref)	1✔
310
311	return result	1✔
312
313
314	cpdef utils.dpnp_descriptor dpnp_matrix_rank(utils.dpnp_descriptor input):	1✔
315	cdef shape_type_c input_shape = input.shape	1✔
316	cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(input.dtype)	1✔
317
318	cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_MATRIX_RANK_EXT, param1_type, param1_type)	1✔
319
320	input_obj = input.get_array()	1✔
321
322	# ceate result array with type given by FPTR data
323	cdef utils.dpnp_descriptor result = utils.create_output_descriptor((1,),	1✔
324	kernel_data.return_type,
325	None,
326	device=input_obj.sycl_device,	1✔
327	usm_type=input_obj.usm_type,	1✔
328	sycl_queue=input_obj.sycl_queue)	1✔
329
330	result_sycl_queue = result.get_array().sycl_queue	1✔
331
332	cdef c_dpctl.SyclQueue q = <c_dpctl.SyclQueue> result_sycl_queue	1✔
333	cdef c_dpctl.DPCTLSyclQueueRef q_ref = q.get_queue_ref()	1✔
334
335	cdef custom_linalg_1in_1out_func_ptr_t func = <custom_linalg_1in_1out_func_ptr_t > kernel_data.ptr	1✔
336
337	cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref,	1✔
338	input.get_data(),
339	result.get_data(),
340	input_shape.data(),
341	input.ndim,	1✔
342	NULL) # dep_events_ref
343
344	with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)	1✔
345	c_dpctl.DPCTLEvent_Delete(event_ref)	1✔
346
347	return result	1✔
348
349
350	cpdef object dpnp_norm(object input, ord=None, axis=None):	1✔
351	cdef long size_input = input.size	1✔
352	cdef shape_type_c shape_input = input.shape	1✔
353
354	dev = input.get_array().sycl_device	1✔
355	if input.dtype == dpnp.float32 or not dev.has_aspect_fp64:	1✔
356	res_type = dpnp.float32	×
357	else:
358	res_type = dpnp.float64	1✔
359
360	if size_input == 0:	1✔
361	return dpnp.array([dpnp.nan], dtype=res_type)	×
362
363	if isinstance(axis, int):	1✔
364	axis_ = tuple([axis])	1✔
365	else:
366	axis_ = axis	1✔
367
368	ndim = input.ndim	1✔
369	if axis is None:	1✔
370	if ((ord is None) or	1✔
371	(ord in ('f', 'fro') and ndim == 2) or	1✔
372	(ord == 2 and ndim == 1)):	1✔
373
374	input = dpnp.ravel(input, order='K')	1✔
375	sqnorm = dpnp.dot(input, input)	1✔
376	ret = dpnp.sqrt([sqnorm], dtype=res_type)	1✔
377	return dpnp.array(ret.reshape(1, *ret.shape), dtype=res_type)	1✔
378
379	len_axis = 1 if axis is None else len(axis_)	1✔
380	if len_axis == 1:	1✔
381	if ord == dpnp.inf:	1✔
382	return dpnp.array([dpnp.abs(input).max(axis=axis)])	×
383	elif ord == -dpnp.inf:	1✔
384	return dpnp.array([dpnp.abs(input).min(axis=axis)])	×
385	elif ord == 0:	1✔
386	return input.dtype.type(dpnp.count_nonzero(input, axis=axis))	1✔
387	elif ord is None or ord == 2:	1✔
388	s = input * input	1✔
389	return dpnp.sqrt(dpnp.sum(s, axis=axis), dtype=res_type)	1✔
390	elif isinstance(ord, str):	×
391	raise ValueError(f"Invalid norm order '{ord}' for vectors")	×
392	else:
393	absx = dpnp.abs(input)	×
394	absx_size = absx.size	×
395	absx_power = utils_py.create_output_descriptor_py((absx_size,), absx.dtype, None).get_pyobj()	1✔
396
397	absx_flatiter = absx.flat	×
398
399	for i in range(absx_size):	×
400	absx_elem = absx_flatiter[i]	×
401	absx_power[i] = absx_elem ** ord	×
402	absx_ = dpnp.reshape(absx_power, absx.shape)	×
403	ret = dpnp.sum(absx_, axis=axis)	×
404	ret_size = ret.size	×
405	ret_power = utils_py.create_output_descriptor_py((ret_size,), None, None).get_pyobj()	×
406
407	ret_flatiter = ret.flat	×
408
409	for i in range(ret_size):	×
410	ret_elem = ret_flatiter[i]	×
411	ret_power[i] = ret_elem ** (1 / ord)	×
412	ret_ = dpnp.reshape(ret_power, ret.shape)	×
413	return ret_	×
414	elif len_axis == 2:
415	row_axis, col_axis = axis_	1✔
416	if row_axis == col_axis:	1✔
417	raise ValueError('Duplicate axes given.')	×
418	# if ord == 2:
419	# ret = _multi_svd_norm(input, row_axis, col_axis, amax)
420	# elif ord == -2:
421	# ret = _multi_svd_norm(input, row_axis, col_axis, amin)
422	elif ord == 1:	1✔
423	if col_axis > row_axis:	×
424	col_axis -= 1	×
425	dpnp_sum_val = dpnp.sum(dpnp.abs(input), axis=row_axis)	×
426	ret = dpnp_sum_val.min(axis=col_axis)	×
427	elif ord == dpnp.inf:	1✔
428	if row_axis > col_axis:	×
429	row_axis -= 1	×
430	dpnp_sum_val = dpnp.sum(dpnp.abs(input), axis=col_axis)	×
431	ret = dpnp_sum_val.max(axis=row_axis)	×
432	elif ord == -1:	1✔
433	if col_axis > row_axis:	1✔
434	col_axis -= 1	×
435	dpnp_sum_val = dpnp.sum(dpnp.abs(input), axis=row_axis)	×
436	ret = dpnp_sum_val.min(axis=col_axis)	×
437	elif ord == -dpnp.inf:	1✔
438	if row_axis > col_axis:	×
439	row_axis -= 1	×
440	dpnp_sum_val = dpnp.sum(dpnp.abs(input), axis=col_axis)	×
441	ret = dpnp_sum_val.min(axis=row_axis)	×
442	elif ord in [None, 'fro', 'f']:	1✔
443	ret = dpnp.sqrt(dpnp.sum(input * input, axis=axis))	1✔
444	# elif ord == 'nuc':
445	# ret = _multi_svd_norm(input, row_axis, col_axis, sum)
446	else:
447	raise ValueError("Invalid norm order for matrices.")	×
448
449	return ret	1✔
450	else:
451	raise ValueError("Improper number of dimensions to norm.")	1✔
452
453
454	cpdef tuple dpnp_qr(utils.dpnp_descriptor x1, str mode):	1✔
455	cdef size_t size_m = x1.shape[0]	1✔
456	cdef size_t size_n = x1.shape[1]	1✔
457	cdef size_t min_m_n = min(size_m, size_n)	1✔
458	cdef size_t size_tau = min_m_n	1✔
459
460	cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(x1.dtype)	1✔
461	cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_QR_EXT, param1_type, param1_type)	1✔
462
463	x1_obj = x1.get_array()	1✔
464
465	cdef (DPNPFuncType, void *) ret_type_and_func = utils.get_ret_type_and_func(x1_obj.sycl_device, kernel_data)	1✔
466	cdef DPNPFuncType return_type = ret_type_and_func[0]	1✔
467	cdef custom_linalg_1in_3out_shape_t func = < custom_linalg_1in_3out_shape_t > ret_type_and_func[1]	1✔
468
469	cdef utils.dpnp_descriptor res_q = utils.create_output_descriptor((size_m, min_m_n),	1✔
470	return_type,
471	None,
472	device=x1_obj.sycl_device,	1✔
473	usm_type=x1_obj.usm_type,	1✔
474	sycl_queue=x1_obj.sycl_queue)	1✔
475	cdef utils.dpnp_descriptor res_r = utils.create_output_descriptor((min_m_n, size_n),	1✔
476	return_type,
477	None,
478	device=x1_obj.sycl_device,	1✔
479	usm_type=x1_obj.usm_type,	1✔
480	sycl_queue=x1_obj.sycl_queue)	1✔
481	cdef utils.dpnp_descriptor tau = utils.create_output_descriptor((size_tau, ),	1✔
482	return_type,
483	None,
484	device=x1_obj.sycl_device,	1✔
485	usm_type=x1_obj.usm_type,	1✔
486	sycl_queue=x1_obj.sycl_queue)	1✔
487
488	result_sycl_queue = res_q.get_array().sycl_queue	1✔
489
490	cdef c_dpctl.SyclQueue q = <c_dpctl.SyclQueue> result_sycl_queue	1✔
491	cdef c_dpctl.DPCTLSyclQueueRef q_ref = q.get_queue_ref()	1✔
492
493	cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref,	1✔
494	x1.get_data(),
495	res_q.get_data(),
496	res_r.get_data(),
497	tau.get_data(),
498	size_m,
499	size_n,
500	NULL) # dep_events_ref
501
502	with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)	1✔
503	c_dpctl.DPCTLEvent_Delete(event_ref)	1✔
504
505	return (res_q.get_pyobj(), res_r.get_pyobj())	1✔
506
507
508	cpdef tuple dpnp_svd(utils.dpnp_descriptor x1, cpp_bool full_matrices, cpp_bool compute_uv, cpp_bool hermitian):	1✔
509	cdef size_t size_m = x1.shape[0]	1✔
510	cdef size_t size_n = x1.shape[1]	1✔
511	cdef size_t size_s = min(size_m, size_n)	1✔
512
513	cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(x1.dtype)	1✔
514	cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_SVD_EXT, param1_type, param1_type)	1✔
515
516	x1_obj = x1.get_array()	1✔
517
518	cdef (DPNPFuncType, void *) ret_type_and_func = utils.get_ret_type_and_func(x1_obj.sycl_device, kernel_data)	1✔
519	cdef DPNPFuncType return_type = ret_type_and_func[0]	1✔
520	cdef custom_linalg_1in_3out_shape_t func = < custom_linalg_1in_3out_shape_t > ret_type_and_func[1]	1✔
521
522	cdef utils.dpnp_descriptor res_u = utils.create_output_descriptor((size_m, size_m),	1✔
523	return_type,
524	None,
525	device=x1_obj.sycl_device,	1✔
526	usm_type=x1_obj.usm_type,	1✔
527	sycl_queue=x1_obj.sycl_queue)	1✔
528	cdef utils.dpnp_descriptor res_s = utils.create_output_descriptor((size_s, ),	1✔
529	return_type,
530	None,
531	device=x1_obj.sycl_device,	1✔
532	usm_type=x1_obj.usm_type,	1✔
533	sycl_queue=x1_obj.sycl_queue)	1✔
534	cdef utils.dpnp_descriptor res_vt = utils.create_output_descriptor((size_n, size_n),	1✔
535	return_type,
536	None,
537	device=x1_obj.sycl_device,	1✔
538	usm_type=x1_obj.usm_type,	1✔
539	sycl_queue=x1_obj.sycl_queue)	1✔
540
541	result_sycl_queue = res_u.get_array().sycl_queue	1✔
542
543	cdef c_dpctl.SyclQueue q = <c_dpctl.SyclQueue> result_sycl_queue	1✔
544	cdef c_dpctl.DPCTLSyclQueueRef q_ref = q.get_queue_ref()	1✔
545
546	cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref,	1✔
547	x1.get_data(),
548	res_u.get_data(),
549	res_s.get_data(),
550	res_vt.get_data(),
551	size_m,
552	size_n,
553	NULL) # dep_events_ref
554
555	with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)	1✔
556	c_dpctl.DPCTLEvent_Delete(event_ref)	1✔
557
558	return (res_u.get_pyobj(), res_s.get_pyobj(), res_vt.get_pyobj())	1✔

IntelPython / dpnp / 5661145525

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