5754747571

//*****************************************************************************
// 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.
//*****************************************************************************

/*
 * This header file contains internal function declarations related to FPTR
 * interface. It should not contains public declarations
 */

#pragma once
#ifndef BACKEND_FPTR_H // Cython compatibility
#define BACKEND_FPTR_H

#include <complex>
#include <map>

#include <CL/sycl.hpp>

#include <dpnp_iface_fptr.hpp>

/**
 * Data storage type of the FPTR interface
 *
 * map[FunctionName][InputType2][InputType2]
 *
 * Function name is enum DPNPFuncName
 * InputTypes are presented as enum DPNPFuncType
 *
 * contains structure with kernel information
 *
 * if the kernel requires only one input type - use same type for both
 * parameters
 *
 */
typedef std::map<DPNPFuncType, DPNPFuncData_t> map_2p_t;
typedef std::map<DPNPFuncType, map_2p_t> map_1p_t;
typedef std::map<DPNPFuncName, map_1p_t> func_map_t;

/**
 * Internal shortcuts for Data type enum values
 */
const DPNPFuncType eft_INT = DPNPFuncType::DPNP_FT_INT;
const DPNPFuncType eft_LNG = DPNPFuncType::DPNP_FT_LONG;
const DPNPFuncType eft_FLT = DPNPFuncType::DPNP_FT_FLOAT;
const DPNPFuncType eft_DBL = DPNPFuncType::DPNP_FT_DOUBLE;
const DPNPFuncType eft_C64 = DPNPFuncType::DPNP_FT_CMPLX64;
const DPNPFuncType eft_C128 = DPNPFuncType::DPNP_FT_CMPLX128;
const DPNPFuncType eft_BLN = DPNPFuncType::DPNP_FT_BOOL;

/**
 * An internal structure to build a pair of Data type enum value with C++ type
 */
template <DPNPFuncType FuncType, typename T>
struct func_type_pair_t
{
    using type = T;

    static func_type_pair_t
        get_pair(std::integral_constant<DPNPFuncType, FuncType>)
    {
        return {};
    }
};

/**
 * An internal structure to create a map of Data type enum value associated with
 * C++ type
 */
template <typename... Ps>
struct func_type_map_factory_t : public Ps...
{
    using Ps::get_pair...;

    template <DPNPFuncType FuncType>
    using find_type = typename decltype(get_pair(
        std::integral_constant<DPNPFuncType, FuncType>{}))::type;
};

/**
 * A map of the FPTR interface to link Data type enum value with accociated C++
 * type
 */
typedef func_type_map_factory_t<
    func_type_pair_t<eft_BLN, bool>,
    func_type_pair_t<eft_INT, std::int32_t>,
    func_type_pair_t<eft_LNG, std::int64_t>,
    func_type_pair_t<eft_FLT, float>,
    func_type_pair_t<eft_DBL, double>,
    func_type_pair_t<eft_C64, std::complex<float>>,
    func_type_pair_t<eft_C128, std::complex<double>>>
    func_type_map_t;

/**
 * Return an enum value of result type populated from input types.
 */
template <DPNPFuncType FT1, DPNPFuncType FT2>
static constexpr DPNPFuncType populate_func_types()
{
    if constexpr (FT1 == DPNPFuncType::DPNP_FT_NONE) {
        throw std::runtime_error("Templated enum value of FT1 is None");
    }
    else if constexpr (FT2 == DPNPFuncType::DPNP_FT_NONE) {
        throw std::runtime_error("Templated enum value of FT2 is None");
    }
    return (FT1 < FT2) ? FT2 : FT1;
}

/**
 * @brief A helper function to cast SYCL vector between types.
 */
template <typename Op, typename Vec, std::size_t... I>
static auto dpnp_vec_cast_impl(const Vec &v, std::index_sequence<I...>)
{
    return Op{v[I]...};
}

/**
 * @brief A casting function for SYCL vector.
 *
 * @tparam dstT A result type upon casting.
 * @tparam srcT An incoming type of the vector.
 * @tparam N A number of elements with the vector.
 * @tparam Indices A sequence of integers
 * @param s An incoming SYCL vector to cast.
 * @return SYCL vector casted to desctination type.
 */
template <typename dstT,
          typename srcT,
          std::size_t N,
          typename Indices = std::make_index_sequence<N>>
static auto dpnp_vec_cast(const sycl::vec<srcT, N> &s)
{
    return dpnp_vec_cast_impl<sycl::vec<dstT, N>, sycl::vec<srcT, N>>(
        s, Indices{});
}

/**
 * Removes parentheses for a passed list of types separated by comma.
 * It's intended to be used in operations macro.
 */
#define MACRO_UNPACK_TYPES(...) __VA_ARGS__

/**
 * Implements std::is_same<> with variadic number of types to compare with
 * and when type T has to match only one of types Ts.
 */
template <typename T, typename... Ts>
struct is_any : std::disjunction<std::is_same<T, Ts>...>
{
};

/**
 * Implements std::is_same<> with variadic number of types to compare with
 * and when type T has to match every type from Ts sequence.
 */
template <typename T, typename... Ts>
struct are_same : std::conjunction<std::is_same<T, Ts>...>
{
};

/**
 * A template constant to check if type T matches any type from Ts.
 */
template <typename T, typename... Ts>
constexpr auto is_any_v = is_any<T, Ts...>::value;

/**
 * A template constat to check if both types T1 and T2 match every type from Ts
 * sequence.
 */
template <typename T1, typename T2, typename... Ts>
constexpr auto both_types_are_same =
    std::conjunction_v<is_any<T1, Ts...>, are_same<T1, T2>>;

/**
 * A template constat to check if both types T1 and T2 match any type from Ts.
 */
template <typename T1, typename T2, typename... Ts>
constexpr auto both_types_are_any_of =
    std::conjunction_v<is_any<T1, Ts...>, is_any<T2, Ts...>>;

/**
 * A template constat to check if both types T1 and T2 don't match any type from
 * Ts sequence.
 */
template <typename T1, typename T2, typename... Ts>
constexpr auto none_of_both_types =
    !std::disjunction_v<is_any<T1, Ts...>, is_any<T2, Ts...>>;

/**
 * @brief If the type _Tp is a reference type, provides the member typedef type
 * which is the type referred to by _Tp with its topmost cv-qualifiers removed.
 * Otherwise type is _Tp with its topmost cv-qualifiers removed.
 *
 * @note std::remove_cvref is only available since c++20
 */
template <typename _Tp>
using dpnp_remove_cvref_t =
    typename std::remove_cv_t<typename std::remove_reference_t<_Tp>>;

/**
 * @brief "<" comparison with complex types support.
 *
 * @note return a result of lexicographical "<" comparison for complex types.
 */
class dpnp_less_comp
{
public:
    template <typename _Xp, typename _Yp>
    bool operator()(_Xp &&__x, _Yp &&__y) const
    {
        if constexpr (both_types_are_same<
                          dpnp_remove_cvref_t<_Xp>, dpnp_remove_cvref_t<_Yp>,
                          std::complex<float>, std::complex<double>>)
        {
            bool ret = false;
            _Xp a = std::forward<_Xp>(__x);
            _Yp b = std::forward<_Yp>(__y);

            if (a.real() < b.real()) {
                ret = (a.imag() == a.imag() || b.imag() != b.imag());
            }
            else if (a.real() > b.real()) {
                ret = (b.imag() != b.imag() && a.imag() == a.imag());
            }
            else if (a.real() == b.real() ||
                     (a.real() != a.real() && b.real() != b.real())) {
                ret = (a.imag() < b.imag() ||
                       (b.imag() != b.imag() && a.imag() == a.imag()));
            }
            else {
                ret = (b.real() != b.real());
            }
            return ret;
        }
        else {
            return std::forward<_Xp>(__x) < std::forward<_Yp>(__y);
        }
    }
};

/**
 * A template function that determines the default floating-point type
 * based on the value of the template parameter has_fp64.
 */
template <typename has_fp64 = std::true_type>
static constexpr DPNPFuncType get_default_floating_type()
{
    return has_fp64::value ? DPNPFuncType::DPNP_FT_DOUBLE
                           : DPNPFuncType::DPNP_FT_FLOAT;
}

/**
 * A template function that determines the resulting floating-point type
 * based on the value of the template parameter has_fp64.
 */
template <DPNPFuncType FT1,
          DPNPFuncType FT2,
          typename has_fp64 = std::true_type,
          typename keep_int = std::false_type>
static constexpr DPNPFuncType get_floating_res_type()
{
    constexpr auto widest_type = populate_func_types<FT1, FT2>();
    constexpr auto shortes_type = (widest_type == FT1) ? FT2 : FT1;

    // Return integer result type if save_int is True
    if constexpr (keep_int::value) {
        if constexpr (widest_type == DPNPFuncType::DPNP_FT_INT ||
                      widest_type == DPNPFuncType::DPNP_FT_LONG)
        {
            return widest_type;
        }
    }

    // Check for double
    if constexpr (widest_type == DPNPFuncType::DPNP_FT_DOUBLE) {
        return widest_type;
    }

    // Check for float
    else if constexpr (widest_type == DPNPFuncType::DPNP_FT_FLOAT) {
        // Check if the shortest type is also float
        if constexpr (shortes_type == DPNPFuncType::DPNP_FT_FLOAT) {
            return widest_type;
        }
    }

    // Default case
    return get_default_floating_type<has_fp64>();
}

/**
 * FPTR interface initialization functions
 */
void func_map_init_arraycreation(func_map_t &fmap);
void func_map_init_bitwise(func_map_t &fmap);
void func_map_init_elemwise(func_map_t &fmap);
void func_map_init_fft_func(func_map_t &fmap);
void func_map_init_indexing_func(func_map_t &fmap);
void func_map_init_linalg(func_map_t &fmap);
void func_map_init_linalg_func(func_map_t &fmap);
void func_map_init_logic(func_map_t &fmap);
void func_map_init_manipulation(func_map_t &fmap);
void func_map_init_mathematical(func_map_t &fmap);
void func_map_init_random(func_map_t &fmap);
void func_map_init_reduction(func_map_t &fmap);
void func_map_init_searching(func_map_t &fmap);
void func_map_init_sorting(func_map_t &fmap);
void func_map_init_statistics(func_map_t &fmap);

#endif // BACKEND_FPTR_H

1	//*****************************************************************************
2	// Copyright (c) 2016-2023, 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	//
13	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
14	// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15	// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
16	// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
17	// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18	// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19	// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20	// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21	// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22	// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23	// THE POSSIBILITY OF SUCH DAMAGE.
24	//*****************************************************************************
25
26	/*
27	* This header file contains internal function declarations related to FPTR
28	* interface. It should not contains public declarations
29	*/
30
31	#pragma once
32	#ifndef BACKEND_FPTR_H // Cython compatibility
33	#define BACKEND_FPTR_H
34
35	#include <complex>
36	#include <map>
37
38	#include <CL/sycl.hpp>
39
40	#include <dpnp_iface_fptr.hpp>
41
42	/**
43	* Data storage type of the FPTR interface
44	*
45	* map[FunctionName][InputType2][InputType2]
46	*
47	* Function name is enum DPNPFuncName
48	* InputTypes are presented as enum DPNPFuncType
49	*
50	* contains structure with kernel information
51	*
52	* if the kernel requires only one input type - use same type for both
53	* parameters
54	*
55	*/
56	typedef std::map<DPNPFuncType, DPNPFuncData_t> map_2p_t;
57	typedef std::map<DPNPFuncType, map_2p_t> map_1p_t;
58	typedef std::map<DPNPFuncName, map_1p_t> func_map_t;
59
60	/**
61	* Internal shortcuts for Data type enum values
62	*/
63	const DPNPFuncType eft_INT = DPNPFuncType::DPNP_FT_INT;
64	const DPNPFuncType eft_LNG = DPNPFuncType::DPNP_FT_LONG;
65	const DPNPFuncType eft_FLT = DPNPFuncType::DPNP_FT_FLOAT;
66	const DPNPFuncType eft_DBL = DPNPFuncType::DPNP_FT_DOUBLE;
67	const DPNPFuncType eft_C64 = DPNPFuncType::DPNP_FT_CMPLX64;
68	const DPNPFuncType eft_C128 = DPNPFuncType::DPNP_FT_CMPLX128;
69	const DPNPFuncType eft_BLN = DPNPFuncType::DPNP_FT_BOOL;
70
71	/**
72	* An internal structure to build a pair of Data type enum value with C++ type
73	*/
74	template <DPNPFuncType FuncType, typename T>
75	struct func_type_pair_t
76	{
77	using type = T;
78
79	static func_type_pair_t
80	get_pair(std::integral_constant<DPNPFuncType, FuncType>)
81	{
82	return {};
83	}
84	};
85
86	/**
87	* An internal structure to create a map of Data type enum value associated with
88	* C++ type
89	*/
90	template <typename... Ps>
91	struct func_type_map_factory_t : public Ps...
92	{
93	using Ps::get_pair...;
94
95	template <DPNPFuncType FuncType>
96	using find_type = typename decltype(get_pair(
97	std::integral_constant<DPNPFuncType, FuncType>{}))::type;
98	};
99
100	/**
101	* A map of the FPTR interface to link Data type enum value with accociated C++
102	* type
103	*/
104	typedef func_type_map_factory_t<
105	func_type_pair_t<eft_BLN, bool>,
106	func_type_pair_t<eft_INT, std::int32_t>,
107	func_type_pair_t<eft_LNG, std::int64_t>,
108	func_type_pair_t<eft_FLT, float>,
109	func_type_pair_t<eft_DBL, double>,
110	func_type_pair_t<eft_C64, std::complex<float>>,
111	func_type_pair_t<eft_C128, std::complex<double>>>
112	func_type_map_t;
113
114	/**
115	* Return an enum value of result type populated from input types.
116	*/
117	template <DPNPFuncType FT1, DPNPFuncType FT2>
118	static constexpr DPNPFuncType populate_func_types()
119	{	196✔
120	if constexpr (FT1 == DPNPFuncType::DPNP_FT_NONE) {	196✔
121	throw std::runtime_error("Templated enum value of FT1 is None");	196✔
122	}	196✔
123	else if constexpr (FT2 == DPNPFuncType::DPNP_FT_NONE) {	196✔
124	throw std::runtime_error("Templated enum value of FT2 is None");	196✔
125	}	196✔
126	return (FT1 < FT2) ? FT2 : FT1;	196✔
127	}	196✔
128
129	/**
130	* @brief A helper function to cast SYCL vector between types.
131	*/
132	template <typename Op, typename Vec, std::size_t... I>
133	static auto dpnp_vec_cast_impl(const Vec &v, std::index_sequence<I...>)
134	{	×
135	return Op{v[I]...};	×
136	}	×
137
138	/**
139	* @brief A casting function for SYCL vector.
140	*
141	* @tparam dstT A result type upon casting.
142	* @tparam srcT An incoming type of the vector.
143	* @tparam N A number of elements with the vector.
144	* @tparam Indices A sequence of integers
145	* @param s An incoming SYCL vector to cast.
146	* @return SYCL vector casted to desctination type.
147	*/
148	template <typename dstT,
149	typename srcT,
150	std::size_t N,
151	typename Indices = std::make_index_sequence<N>>
152	static auto dpnp_vec_cast(const sycl::vec<srcT, N> &s)
153	{	×
154	return dpnp_vec_cast_impl<sycl::vec<dstT, N>, sycl::vec<srcT, N>>(	×
155	s, Indices{});	×
156	}	×
157
158	/**
159	* Removes parentheses for a passed list of types separated by comma.
160	* It's intended to be used in operations macro.
161	*/
162	#define MACRO_UNPACK_TYPES(...) __VA_ARGS__
163
164	/**
165	* Implements std::is_same<> with variadic number of types to compare with
166	* and when type T has to match only one of types Ts.
167	*/
168	template <typename T, typename... Ts>
169	struct is_any : std::disjunction<std::is_same<T, Ts>...>
170	{
171	};
172
173	/**
174	* Implements std::is_same<> with variadic number of types to compare with
175	* and when type T has to match every type from Ts sequence.
176	*/
177	template <typename T, typename... Ts>
178	struct are_same : std::conjunction<std::is_same<T, Ts>...>
179	{
180	};
181
182	/**
183	* A template constant to check if type T matches any type from Ts.
184	*/
185	template <typename T, typename... Ts>
186	constexpr auto is_any_v = is_any<T, Ts...>::value;
187
188	/**
189	* A template constat to check if both types T1 and T2 match every type from Ts
190	* sequence.
191	*/
192	template <typename T1, typename T2, typename... Ts>
193	constexpr auto both_types_are_same =
194	std::conjunction_v<is_any<T1, Ts...>, are_same<T1, T2>>;
195
196	/**
197	* A template constat to check if both types T1 and T2 match any type from Ts.
198	*/
199	template <typename T1, typename T2, typename... Ts>
200	constexpr auto both_types_are_any_of =
201	std::conjunction_v<is_any<T1, Ts...>, is_any<T2, Ts...>>;
202
203	/**
204	* A template constat to check if both types T1 and T2 don't match any type from
205	* Ts sequence.
206	*/
207	template <typename T1, typename T2, typename... Ts>
208	constexpr auto none_of_both_types =
209	!std::disjunction_v<is_any<T1, Ts...>, is_any<T2, Ts...>>;
210
211	/**
212	* @brief If the type _Tp is a reference type, provides the member typedef type
213	* which is the type referred to by _Tp with its topmost cv-qualifiers removed.
214	* Otherwise type is _Tp with its topmost cv-qualifiers removed.
215	*
216	* @note std::remove_cvref is only available since c++20
217	*/
218	template <typename _Tp>
219	using dpnp_remove_cvref_t =
220	typename std::remove_cv_t<typename std::remove_reference_t<_Tp>>;
221
222	/**
223	* @brief "<" comparison with complex types support.
224	*
225	* @note return a result of lexicographical "<" comparison for complex types.
226	*/
227	class dpnp_less_comp
228	{
229	public:
230	template <typename _Xp, typename _Yp>
231	bool operator()(_Xp &&__x, _Yp &&__y) const
232	{	58,670,714✔
233	if constexpr (both_types_are_same<	58,670,714✔
234	dpnp_remove_cvref_t<_Xp>, dpnp_remove_cvref_t<_Yp>,	58,670,714✔
235	std::complex<float>, std::complex<double>>)	58,670,714✔
236	{	96✔
237	bool ret = false;	58,670,618✔
238	_Xp a = std::forward<_Xp>(__x);	58,670,618✔
239	_Yp b = std::forward<_Yp>(__y);	58,670,618✔
240
241	if (a.real() < b.real()) {	58,670,618!
242	ret = (a.imag() == a.imag() \|\| b.imag() != b.imag());	60!
243	}	60✔
244	else if (a.real() > b.real()) {	36!
245	ret = (b.imag() != b.imag() && a.imag() == a.imag());	36!
246	}	36✔
247	else if (a.real() == b.real() \|\|	×
248	(a.real() != a.real() && b.real() != b.real())) {	×
249	ret = (a.imag() < b.imag() \|\|	×
250	(b.imag() != b.imag() && a.imag() == a.imag()));	×
251	}	×
252	else {	×
253	ret = (b.real() != b.real());	×
254	}	×
255	return ret;	96✔
256	}	96✔
257	else {	58,670,618✔
258	return std::forward<_Xp>(__x) < std::forward<_Yp>(__y);	58,670,618✔
259	}	58,670,618✔
260	}	58,670,714✔
261	};
262
263	/**
264	* A template function that determines the default floating-point type
265	* based on the value of the template parameter has_fp64.
266	*/
267	template <typename has_fp64 = std::true_type>
268	static constexpr DPNPFuncType get_default_floating_type()
269	{	104✔
270	return has_fp64::value ? DPNPFuncType::DPNP_FT_DOUBLE	104✔
271	: DPNPFuncType::DPNP_FT_FLOAT;	104✔
272	}	104✔
273
274	/**
275	* A template function that determines the resulting floating-point type
276	* based on the value of the template parameter has_fp64.
277	*/
278	template <DPNPFuncType FT1,
279	DPNPFuncType FT2,
280	typename has_fp64 = std::true_type,
281	typename keep_int = std::false_type>
282	static constexpr DPNPFuncType get_floating_res_type()
283	{	224✔
284	constexpr auto widest_type = populate_func_types<FT1, FT2>();	224✔
285	constexpr auto shortes_type = (widest_type == FT1) ? FT2 : FT1;	224✔
286
287	// Return integer result type if save_int is True
288	if constexpr (keep_int::value) {	224✔
289	if constexpr (widest_type == DPNPFuncType::DPNP_FT_INT \|\|	128✔
290	widest_type == DPNPFuncType::DPNP_FT_LONG)	128✔
291	{	32✔
292	return widest_type;	32✔
293	}	32✔
294	}	128✔
295
296	// Check for double
297	if constexpr (widest_type == DPNPFuncType::DPNP_FT_DOUBLE) {	192✔
298	return widest_type;	94✔
299	}	94✔
300
301	// Check for float
302	else if constexpr (widest_type == DPNPFuncType::DPNP_FT_FLOAT) {	94✔
303	// Check if the shortest type is also float
304	if constexpr (shortes_type == DPNPFuncType::DPNP_FT_FLOAT) {	70✔
305	return widest_type;	14✔
306	}	14✔
307	}	70✔
308
309	// Default case
NEW 310	return get_default_floating_type<has_fp64>();	×
311	}	224✔
312
313	/**
314	* FPTR interface initialization functions
315	*/
316	void func_map_init_arraycreation(func_map_t &fmap);
317	void func_map_init_bitwise(func_map_t &fmap);
318	void func_map_init_elemwise(func_map_t &fmap);
319	void func_map_init_fft_func(func_map_t &fmap);
320	void func_map_init_indexing_func(func_map_t &fmap);
321	void func_map_init_linalg(func_map_t &fmap);
322	void func_map_init_linalg_func(func_map_t &fmap);
323	void func_map_init_logic(func_map_t &fmap);
324	void func_map_init_manipulation(func_map_t &fmap);
325	void func_map_init_mathematical(func_map_t &fmap);
326	void func_map_init_random(func_map_t &fmap);
327	void func_map_init_reduction(func_map_t &fmap);
328	void func_map_init_searching(func_map_t &fmap);
329	void func_map_init_sorting(func_map_t &fmap);
330	void func_map_init_statistics(func_map_t &fmap);
331
332	#endif // BACKEND_FPTR_H

IntelPython / dpnp / 5754747571

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