18463977845

Committed 13 Oct 2025 11:15AM UTC coverage: 72.021% (+0.006%) from 72.015%

Build # 18463977845

Build Type

Pull #2616

github

Committed by

web-flow

Commit Message

Merge 4683c32d6 into 800f642c9

Pull Request Pull Request #2616: Add `dpnp.exceptions` submodule to aggregate generic exceptions

Coverage Stats

5067 of 10224 branches covered (49.56%)

Branch coverage included in aggregate %.

8 of 8 new or added lines in 2 files covered. (100.0%)

2041 existing lines in 130 files now uncovered.

18659 of 22719 relevant lines covered (82.13%)

18876.68 hits per line

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

66.37

/dpnp/backend/kernels/dpnp_krnl_arraycreation.cpp

//*****************************************************************************
// Copyright (c) 2016, 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.
// - Neither the name of the copyright holder nor the names of its contributors
//   may be used to endorse or promote products derived from this software
//   without specific prior written permission.
//
// 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.
//*****************************************************************************

#include <iostream>

#include "dpnp_fptr.hpp"
#include "dpnp_iface.hpp"
#include "dpnp_utils.hpp"
#include "dpnpc_memory_adapter.hpp"
#include "queue_sycl.hpp"

template <typename _DataType>
class dpnp_ones_c_kernel;

template <typename _DataType>
DPCTLSyclEventRef dpnp_ones_c(DPCTLSyclQueueRef q_ref,
                              void *result,
                              size_t size,
                              const DPCTLEventVectorRef dep_event_vec_ref)
{
    sycl::queue q = *(reinterpret_cast<sycl::queue *>(q_ref));

    _DataType *fill_value = reinterpret_cast<_DataType *>(
        sycl::malloc_shared(sizeof(_DataType), q));
    fill_value[0] = 1;

    DPCTLSyclEventRef event_ref = dpnp_initval_c<_DataType>(
        q_ref, result, fill_value, size, dep_event_vec_ref);
    DPCTLEvent_WaitAndThrow(event_ref);
    DPCTLEvent_Delete(event_ref);

    sycl::free(fill_value, q);

    return nullptr;
}

template <typename _DataType>
void dpnp_ones_c(void *result, size_t size)
{
    DPCTLSyclQueueRef q_ref = reinterpret_cast<DPCTLSyclQueueRef>(&DPNP_QUEUE);
    DPCTLEventVectorRef dep_event_vec_ref = nullptr;
    DPCTLSyclEventRef event_ref =
        dpnp_ones_c<_DataType>(q_ref, result, size, dep_event_vec_ref);
    DPCTLEvent_WaitAndThrow(event_ref);
    DPCTLEvent_Delete(event_ref);
}

template <typename _DataType>
void (*dpnp_ones_default_c)(void *, size_t) = dpnp_ones_c<_DataType>;

template <typename _DataType>
DPCTLSyclEventRef dpnp_ones_like_c(DPCTLSyclQueueRef q_ref,
                                   void *result,
                                   size_t size,
                                   const DPCTLEventVectorRef dep_event_vec_ref)
{
    return dpnp_ones_c<_DataType>(q_ref, result, size, dep_event_vec_ref);
}

template <typename _DataType>
void dpnp_ones_like_c(void *result, size_t size)
{
    DPCTLSyclQueueRef q_ref = reinterpret_cast<DPCTLSyclQueueRef>(&DPNP_QUEUE);
    DPCTLEventVectorRef dep_event_vec_ref = nullptr;
    DPCTLSyclEventRef event_ref =
        dpnp_ones_like_c<_DataType>(q_ref, result, size, dep_event_vec_ref);
    DPCTLEvent_WaitAndThrow(event_ref);
    DPCTLEvent_Delete(event_ref);
}

template <typename _DataType>
void (*dpnp_ones_like_default_c)(void *, size_t) = dpnp_ones_like_c<_DataType>;

template <typename _DataType>
DPCTLSyclEventRef dpnp_zeros_c(DPCTLSyclQueueRef q_ref,
                               void *result,
                               size_t size,
                               const DPCTLEventVectorRef dep_event_vec_ref)
{
    sycl::queue q = *(reinterpret_cast<sycl::queue *>(q_ref));

    _DataType *fill_value = reinterpret_cast<_DataType *>(
        sycl::malloc_shared(sizeof(_DataType), q));
    fill_value[0] = 0;

    DPCTLSyclEventRef event_ref = dpnp_initval_c<_DataType>(
        q_ref, result, fill_value, size, dep_event_vec_ref);
    DPCTLEvent_WaitAndThrow(event_ref);
    DPCTLEvent_Delete(event_ref);

    sycl::free(fill_value, q);

    return nullptr;
}

template <typename _DataType>
void dpnp_zeros_c(void *result, size_t size)
{
    DPCTLSyclQueueRef q_ref = reinterpret_cast<DPCTLSyclQueueRef>(&DPNP_QUEUE);
    DPCTLEventVectorRef dep_event_vec_ref = nullptr;
    DPCTLSyclEventRef event_ref =
        dpnp_zeros_c<_DataType>(q_ref, result, size, dep_event_vec_ref);
    DPCTLEvent_WaitAndThrow(event_ref);
    DPCTLEvent_Delete(event_ref);
}

template <typename _DataType>
void (*dpnp_zeros_default_c)(void *, size_t) = dpnp_zeros_c<_DataType>;

template <typename _DataType>
DPCTLSyclEventRef dpnp_zeros_like_c(DPCTLSyclQueueRef q_ref,
                                    void *result,
                                    size_t size,
                                    const DPCTLEventVectorRef dep_event_vec_ref)
{
    return dpnp_zeros_c<_DataType>(q_ref, result, size, dep_event_vec_ref);
}

template <typename _DataType>
void dpnp_zeros_like_c(void *result, size_t size)
{
    DPCTLSyclQueueRef q_ref = reinterpret_cast<DPCTLSyclQueueRef>(&DPNP_QUEUE);
    DPCTLEventVectorRef dep_event_vec_ref = nullptr;
    DPCTLSyclEventRef event_ref =
        dpnp_zeros_like_c<_DataType>(q_ref, result, size, dep_event_vec_ref);
    DPCTLEvent_WaitAndThrow(event_ref);
    DPCTLEvent_Delete(event_ref);
}

template <typename _DataType>
void (*dpnp_zeros_like_default_c)(void *,
                                  size_t) = dpnp_zeros_like_c<_DataType>;

void func_map_init_arraycreation(func_map_t &fmap)
{
    // Used in dpnp_rng_geometric_c
    fmap[DPNPFuncName::DPNP_FN_ONES][eft_INT][eft_INT] = {
        eft_INT, (void *)dpnp_ones_default_c<int32_t>};
    fmap[DPNPFuncName::DPNP_FN_ONES][eft_LNG][eft_LNG] = {
        eft_LNG, (void *)dpnp_ones_default_c<int64_t>};
    fmap[DPNPFuncName::DPNP_FN_ONES][eft_FLT][eft_FLT] = {
        eft_FLT, (void *)dpnp_ones_default_c<float>};
    fmap[DPNPFuncName::DPNP_FN_ONES][eft_DBL][eft_DBL] = {
        eft_DBL, (void *)dpnp_ones_default_c<double>};
    fmap[DPNPFuncName::DPNP_FN_ONES][eft_BLN][eft_BLN] = {
        eft_BLN, (void *)dpnp_ones_default_c<bool>};
    fmap[DPNPFuncName::DPNP_FN_ONES][eft_C128][eft_C128] = {
        eft_C128, (void *)dpnp_ones_default_c<std::complex<double>>};

    fmap[DPNPFuncName::DPNP_FN_ONES_LIKE][eft_INT][eft_INT] = {
        eft_INT, (void *)dpnp_ones_like_default_c<int32_t>};
    fmap[DPNPFuncName::DPNP_FN_ONES_LIKE][eft_LNG][eft_LNG] = {
        eft_LNG, (void *)dpnp_ones_like_default_c<int64_t>};
    fmap[DPNPFuncName::DPNP_FN_ONES_LIKE][eft_FLT][eft_FLT] = {
        eft_FLT, (void *)dpnp_ones_like_default_c<float>};
    fmap[DPNPFuncName::DPNP_FN_ONES_LIKE][eft_DBL][eft_DBL] = {
        eft_DBL, (void *)dpnp_ones_like_default_c<double>};
    fmap[DPNPFuncName::DPNP_FN_ONES_LIKE][eft_BLN][eft_BLN] = {
        eft_BLN, (void *)dpnp_ones_like_default_c<bool>};
    fmap[DPNPFuncName::DPNP_FN_ONES_LIKE][eft_C128][eft_C128] = {
        eft_C128, (void *)dpnp_ones_like_default_c<std::complex<double>>};

    // Used in dpnp_rng_binomial_c, dpnp_rng_gamma_c, dpnp_rng_hypergeometric_c
    //         dpnp_rng_laplace_c, dpnp_rng_multinomial_c, dpnp_rng_weibull_c
    fmap[DPNPFuncName::DPNP_FN_ZEROS][eft_INT][eft_INT] = {
        eft_INT, (void *)dpnp_zeros_default_c<int32_t>};
    fmap[DPNPFuncName::DPNP_FN_ZEROS][eft_LNG][eft_LNG] = {
        eft_LNG, (void *)dpnp_zeros_default_c<int64_t>};
    fmap[DPNPFuncName::DPNP_FN_ZEROS][eft_FLT][eft_FLT] = {
        eft_FLT, (void *)dpnp_zeros_default_c<float>};
    fmap[DPNPFuncName::DPNP_FN_ZEROS][eft_DBL][eft_DBL] = {
        eft_DBL, (void *)dpnp_zeros_default_c<double>};
    fmap[DPNPFuncName::DPNP_FN_ZEROS][eft_BLN][eft_BLN] = {
        eft_BLN, (void *)dpnp_zeros_default_c<bool>};
    fmap[DPNPFuncName::DPNP_FN_ZEROS][eft_C128][eft_C128] = {
        eft_C128, (void *)dpnp_zeros_default_c<std::complex<double>>};

    fmap[DPNPFuncName::DPNP_FN_ZEROS_LIKE][eft_INT][eft_INT] = {
        eft_INT, (void *)dpnp_zeros_like_default_c<int32_t>};
    fmap[DPNPFuncName::DPNP_FN_ZEROS_LIKE][eft_LNG][eft_LNG] = {
        eft_LNG, (void *)dpnp_zeros_like_default_c<int64_t>};
    fmap[DPNPFuncName::DPNP_FN_ZEROS_LIKE][eft_FLT][eft_FLT] = {
        eft_FLT, (void *)dpnp_zeros_like_default_c<float>};
    fmap[DPNPFuncName::DPNP_FN_ZEROS_LIKE][eft_DBL][eft_DBL] = {
        eft_DBL, (void *)dpnp_zeros_like_default_c<double>};
    fmap[DPNPFuncName::DPNP_FN_ZEROS_LIKE][eft_BLN][eft_BLN] = {
        eft_BLN, (void *)dpnp_zeros_like_default_c<bool>};
    fmap[DPNPFuncName::DPNP_FN_ZEROS_LIKE][eft_C128][eft_C128] = {
        eft_C128, (void *)dpnp_zeros_like_default_c<std::complex<double>>};

    return;
}

1	//*****************************************************************************
2	// Copyright (c) 2016, Intel Corporation
3	// All rights reserved.
4	//
5	// Redistribution and use in source and binary forms, with or without
6	// modification, are permitted provided that the following conditions are met:
7	// - Redistributions of source code must retain the above copyright notice,
8	// this list of conditions and the following disclaimer.
9	// - Redistributions in binary form must reproduce the above copyright notice,
10	// this list of conditions and the following disclaimer in the documentation
11	// and/or other materials provided with the distribution.
12	// - Neither the name of the copyright holder nor the names of its contributors
13	// may be used to endorse or promote products derived from this software
14	// without specific prior written permission.
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	#include <iostream>
30
31	#include "dpnp_fptr.hpp"
32	#include "dpnp_iface.hpp"
33	#include "dpnp_utils.hpp"
34	#include "dpnpc_memory_adapter.hpp"
35	#include "queue_sycl.hpp"
36
37	template <typename _DataType>
38	class dpnp_ones_c_kernel;
39
40	template <typename _DataType>
41	DPCTLSyclEventRef dpnp_ones_c(DPCTLSyclQueueRef q_ref,
42	void *result,
43	size_t size,
44	const DPCTLEventVectorRef dep_event_vec_ref)
45	{	1✔
46	sycl::queue q = (reinterpret_cast<sycl::queue >(q_ref));	1✔
47
48	_DataType fill_value = reinterpret_cast<_DataType >(	1✔
49	sycl::malloc_shared(sizeof(_DataType), q));	1✔
50	fill_value[0] = 1;	1✔
51
52	DPCTLSyclEventRef event_ref = dpnp_initval_c<_DataType>(	1✔
53	q_ref, result, fill_value, size, dep_event_vec_ref);	1✔
54	DPCTLEvent_WaitAndThrow(event_ref);	1✔
55	DPCTLEvent_Delete(event_ref);	1✔
56
57	sycl::free(fill_value, q);	1✔
58
59	return nullptr;	1✔
60	}	1✔
61
62	template <typename _DataType>
63	void dpnp_ones_c(void *result, size_t size)
64	{	×
65	DPCTLSyclQueueRef q_ref = reinterpret_cast<DPCTLSyclQueueRef>(&DPNP_QUEUE);	×
66	DPCTLEventVectorRef dep_event_vec_ref = nullptr;	×
67	DPCTLSyclEventRef event_ref =	×
68	dpnp_ones_c<_DataType>(q_ref, result, size, dep_event_vec_ref);	×
UNCOV 69	DPCTLEvent_WaitAndThrow(event_ref);	×
UNCOV 70	DPCTLEvent_Delete(event_ref);	×
UNCOV 71	}	×
72
73	template <typename _DataType>
74	void (dpnp_ones_default_c)(void , size_t) = dpnp_ones_c<_DataType>;
75
76	template <typename _DataType>
77	DPCTLSyclEventRef dpnp_ones_like_c(DPCTLSyclQueueRef q_ref,
78	void *result,
79	size_t size,
80	const DPCTLEventVectorRef dep_event_vec_ref)
UNCOV 81	{	×
UNCOV 82	return dpnp_ones_c<_DataType>(q_ref, result, size, dep_event_vec_ref);	×
UNCOV 83	}	×
84
85	template <typename _DataType>
86	void dpnp_ones_like_c(void *result, size_t size)
87	{	×
88	DPCTLSyclQueueRef q_ref = reinterpret_cast<DPCTLSyclQueueRef>(&DPNP_QUEUE);	×
89	DPCTLEventVectorRef dep_event_vec_ref = nullptr;	×
90	DPCTLSyclEventRef event_ref =	×
91	dpnp_ones_like_c<_DataType>(q_ref, result, size, dep_event_vec_ref);	×
UNCOV 92	DPCTLEvent_WaitAndThrow(event_ref);	×
UNCOV 93	DPCTLEvent_Delete(event_ref);	×
UNCOV 94	}	×
95
96	template <typename _DataType>
97	void (dpnp_ones_like_default_c)(void , size_t) = dpnp_ones_like_c<_DataType>;
98
99	template <typename _DataType>
100	DPCTLSyclEventRef dpnp_zeros_c(DPCTLSyclQueueRef q_ref,
101	void *result,
102	size_t size,
103	const DPCTLEventVectorRef dep_event_vec_ref)
104	{	6✔
105	sycl::queue q = (reinterpret_cast<sycl::queue >(q_ref));	6✔
106
107	_DataType fill_value = reinterpret_cast<_DataType >(	6✔
108	sycl::malloc_shared(sizeof(_DataType), q));	6✔
109	fill_value[0] = 0;	6✔
110
111	DPCTLSyclEventRef event_ref = dpnp_initval_c<_DataType>(	6✔
112	q_ref, result, fill_value, size, dep_event_vec_ref);	6✔
113	DPCTLEvent_WaitAndThrow(event_ref);	6✔
114	DPCTLEvent_Delete(event_ref);	6✔
115
116	sycl::free(fill_value, q);	6✔
117
118	return nullptr;	6✔
119	}	6✔
120
121	template <typename _DataType>
122	void dpnp_zeros_c(void *result, size_t size)
123	{	×
124	DPCTLSyclQueueRef q_ref = reinterpret_cast<DPCTLSyclQueueRef>(&DPNP_QUEUE);	×
125	DPCTLEventVectorRef dep_event_vec_ref = nullptr;	×
126	DPCTLSyclEventRef event_ref =	×
127	dpnp_zeros_c<_DataType>(q_ref, result, size, dep_event_vec_ref);	×
UNCOV 128	DPCTLEvent_WaitAndThrow(event_ref);	×
UNCOV 129	DPCTLEvent_Delete(event_ref);	×
UNCOV 130	}	×
131
132	template <typename _DataType>
133	void (dpnp_zeros_default_c)(void , size_t) = dpnp_zeros_c<_DataType>;
134
135	template <typename _DataType>
136	DPCTLSyclEventRef dpnp_zeros_like_c(DPCTLSyclQueueRef q_ref,
137	void *result,
138	size_t size,
139	const DPCTLEventVectorRef dep_event_vec_ref)
UNCOV 140	{	×
UNCOV 141	return dpnp_zeros_c<_DataType>(q_ref, result, size, dep_event_vec_ref);	×
UNCOV 142	}	×
143
144	template <typename _DataType>
145	void dpnp_zeros_like_c(void *result, size_t size)
146	{	×
147	DPCTLSyclQueueRef q_ref = reinterpret_cast<DPCTLSyclQueueRef>(&DPNP_QUEUE);	×
148	DPCTLEventVectorRef dep_event_vec_ref = nullptr;	×
149	DPCTLSyclEventRef event_ref =	×
150	dpnp_zeros_like_c<_DataType>(q_ref, result, size, dep_event_vec_ref);	×
UNCOV 151	DPCTLEvent_WaitAndThrow(event_ref);	×
UNCOV 152	DPCTLEvent_Delete(event_ref);	×
UNCOV 153	}	×
154
155	template <typename _DataType>
156	void (dpnp_zeros_like_default_c)(void ,
157	size_t) = dpnp_zeros_like_c<_DataType>;
158
159	void func_map_init_arraycreation(func_map_t &fmap)
160	{	2✔
161	// Used in dpnp_rng_geometric_c
162	fmap[DPNPFuncName::DPNP_FN_ONES][eft_INT][eft_INT] = {	2✔
163	eft_INT, (void *)dpnp_ones_default_c<int32_t>};	2✔
164	fmap[DPNPFuncName::DPNP_FN_ONES][eft_LNG][eft_LNG] = {	2✔
165	eft_LNG, (void *)dpnp_ones_default_c<int64_t>};	2✔
166	fmap[DPNPFuncName::DPNP_FN_ONES][eft_FLT][eft_FLT] = {	2✔
167	eft_FLT, (void *)dpnp_ones_default_c<float>};	2✔
168	fmap[DPNPFuncName::DPNP_FN_ONES][eft_DBL][eft_DBL] = {	2✔
169	eft_DBL, (void *)dpnp_ones_default_c<double>};	2✔
170	fmap[DPNPFuncName::DPNP_FN_ONES][eft_BLN][eft_BLN] = {	2✔
171	eft_BLN, (void *)dpnp_ones_default_c<bool>};	2✔
172	fmap[DPNPFuncName::DPNP_FN_ONES][eft_C128][eft_C128] = {	2✔
173	eft_C128, (void *)dpnp_ones_default_c<std::complex<double>>};	2✔
174
175	fmap[DPNPFuncName::DPNP_FN_ONES_LIKE][eft_INT][eft_INT] = {	2✔
176	eft_INT, (void *)dpnp_ones_like_default_c<int32_t>};	2✔
177	fmap[DPNPFuncName::DPNP_FN_ONES_LIKE][eft_LNG][eft_LNG] = {	2✔
178	eft_LNG, (void *)dpnp_ones_like_default_c<int64_t>};	2✔
179	fmap[DPNPFuncName::DPNP_FN_ONES_LIKE][eft_FLT][eft_FLT] = {	2✔
180	eft_FLT, (void *)dpnp_ones_like_default_c<float>};	2✔
181	fmap[DPNPFuncName::DPNP_FN_ONES_LIKE][eft_DBL][eft_DBL] = {	2✔
182	eft_DBL, (void *)dpnp_ones_like_default_c<double>};	2✔
183	fmap[DPNPFuncName::DPNP_FN_ONES_LIKE][eft_BLN][eft_BLN] = {	2✔
184	eft_BLN, (void *)dpnp_ones_like_default_c<bool>};	2✔
185	fmap[DPNPFuncName::DPNP_FN_ONES_LIKE][eft_C128][eft_C128] = {	2✔
186	eft_C128, (void *)dpnp_ones_like_default_c<std::complex<double>>};	2✔
187
188	// Used in dpnp_rng_binomial_c, dpnp_rng_gamma_c, dpnp_rng_hypergeometric_c
189	// dpnp_rng_laplace_c, dpnp_rng_multinomial_c, dpnp_rng_weibull_c
190	fmap[DPNPFuncName::DPNP_FN_ZEROS][eft_INT][eft_INT] = {	2✔
191	eft_INT, (void *)dpnp_zeros_default_c<int32_t>};	2✔
192	fmap[DPNPFuncName::DPNP_FN_ZEROS][eft_LNG][eft_LNG] = {	2✔
193	eft_LNG, (void *)dpnp_zeros_default_c<int64_t>};	2✔
194	fmap[DPNPFuncName::DPNP_FN_ZEROS][eft_FLT][eft_FLT] = {	2✔
195	eft_FLT, (void *)dpnp_zeros_default_c<float>};	2✔
196	fmap[DPNPFuncName::DPNP_FN_ZEROS][eft_DBL][eft_DBL] = {	2✔
197	eft_DBL, (void *)dpnp_zeros_default_c<double>};	2✔
198	fmap[DPNPFuncName::DPNP_FN_ZEROS][eft_BLN][eft_BLN] = {	2✔
199	eft_BLN, (void *)dpnp_zeros_default_c<bool>};	2✔
200	fmap[DPNPFuncName::DPNP_FN_ZEROS][eft_C128][eft_C128] = {	2✔
201	eft_C128, (void *)dpnp_zeros_default_c<std::complex<double>>};	2✔
202
203	fmap[DPNPFuncName::DPNP_FN_ZEROS_LIKE][eft_INT][eft_INT] = {	2✔
204	eft_INT, (void *)dpnp_zeros_like_default_c<int32_t>};	2✔
205	fmap[DPNPFuncName::DPNP_FN_ZEROS_LIKE][eft_LNG][eft_LNG] = {	2✔
206	eft_LNG, (void *)dpnp_zeros_like_default_c<int64_t>};	2✔
207	fmap[DPNPFuncName::DPNP_FN_ZEROS_LIKE][eft_FLT][eft_FLT] = {	2✔
208	eft_FLT, (void *)dpnp_zeros_like_default_c<float>};	2✔
209	fmap[DPNPFuncName::DPNP_FN_ZEROS_LIKE][eft_DBL][eft_DBL] = {	2✔
210	eft_DBL, (void *)dpnp_zeros_like_default_c<double>};	2✔
211	fmap[DPNPFuncName::DPNP_FN_ZEROS_LIKE][eft_BLN][eft_BLN] = {	2✔
212	eft_BLN, (void *)dpnp_zeros_like_default_c<bool>};	2✔
213	fmap[DPNPFuncName::DPNP_FN_ZEROS_LIKE][eft_C128][eft_C128] = {	2✔
214	eft_C128, (void *)dpnp_zeros_like_default_c<std::complex<double>>};	2✔
215
216	return;	2✔
217	}	2✔

IntelPython / dpnp / 18463977845

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