mkl-devel-dpcpp 2024.2.2__py2.py3-none-win_amd64.whl → 2025.0.1__py2.py3-none-win_amd64.whl

{mkl_devel_dpcpp-2024.2.2.data → mkl_devel_dpcpp-2025.0.1.data}/data/Library/include/oneapi/mkl/rng/device/detail/vm_wrappers.hpp

@@ -112,6 +112,48 @@ static inline DataType ln_wrapper(DataType a) {
 #endif // MKL_RNG_USE_BINARY_CODE
 }
 
+template <typename DataType>
+static inline DataType pow_wrapper(DataType a, DataType b) {
+#if MKL_RNG_USE_BINARY_CODE
+    DataType t;
+    if constexpr (std::is_same_v<DataType, double>)
+        vm_d::pow(&a, &b, &t, vm_d::mode::ep);
+    else
+        t = sycl::pow(a, b);
+    return t;
+#else
+    return sycl::pow(a, b);
+#endif // MKL_RNG_USE_BINARY_CODE
+}
+
+template <typename DataType>
+static inline DataType powr_wrapper(DataType a, DataType b) {
+#if MKL_RNG_USE_BINARY_CODE
+    DataType t;
+    if constexpr (std::is_same_v<DataType, double>)
+        vm_d::powr(&a, &b, &t, vm_d::mode::ep);
+    else
+        t = sycl::powr(a, b);
+    return t;
+#else
+    return sycl::powr(a, b);
+#endif // MKL_RNG_USE_BINARY_CODE
+}
+
+template <typename DataType>
+static inline DataType exp_wrapper(DataType a) {
+#if MKL_RNG_USE_BINARY_CODE
+    DataType t;
+    if constexpr (std::is_same_v<DataType, double>)
+        vm_d::exp(&a, &t, vm_d::mode::ep);
+    else
+        t = sycl::exp(a);
+    return t;
+#else
+    return sycl::exp(a);
+#endif // MKL_RNG_USE_BINARY_CODE
+}
+
 #if MKL_RNG_USE_BINARY_CODE
 template <typename RealType>
 inline RealType erf_inv_wrapper(RealType x) {

{mkl_devel_dpcpp-2024.2.2.data → mkl_devel_dpcpp-2025.0.1.data}/data/Library/include/oneapi/mkl/rng/device/distributions.hpp

@@ -62,7 +62,9 @@ public:
 
     static_assert(std::is_same<Type, float>::value || std::is_same<Type, double>::value ||
                       std::is_same<Type, std::int32_t>::value ||
-                      std::is_same<Type, std::uint32_t>::value,
+                      std::is_same<Type, std::uint32_t>::value ||
+                      std::is_same<Type, std::int64_t>::value ||
+                      std::is_same<Type, std::uint64_t>::value,
                   "oneMKL: rng/uniform: type is not supported");
 
     using method_type = Method;
@@ -71,12 +73,14 @@ public:
 
     uniform()
             : detail::distribution_base<uniform<Type, Method>>(
-                  static_cast<Type>(0.0),
+                  Type(0.0),
                   std::is_integral<Type>::value
-                      ? (std::is_same<Method, uniform_method::standard>::value
-                             ? (1 << 23)
-                             : (std::numeric_limits<Type>::max)())
-                      : static_cast<Type>(1.0)) {}
+                      ? ((std::is_same_v<Type, std::uint64_t> || std::is_same_v<Type, std::int64_t>)
+                          ? (std::numeric_limits<Type>::max)()
+                          : (std::is_same<Method, uniform_method::standard>::value
+                                 ? (1 << 23)
+                                 : (std::numeric_limits<Type>::max)()))
+                      : Type(1.0)) {}
 
     explicit uniform(Type a, Type b) : detail::distribution_base<uniform<Type, Method>>(a, b) {}
     explicit uniform(const param_type& pt)
@@ -144,8 +148,7 @@ public:
     using param_type = typename detail::distribution_base<gaussian<RealType, Method>>::param_type;
 
     gaussian()
-            : detail::distribution_base<gaussian<RealType, Method>>(static_cast<RealType>(0.0),
-                                                                    static_cast<RealType>(1.0)) {}
+            : detail::distribution_base<gaussian<RealType, Method>>(RealType(0.0), RealType(1.0)) {}
 
     explicit gaussian(RealType mean, RealType stddev)
             : detail::distribution_base<gaussian<RealType, Method>>(mean, stddev) {}
@@ -208,11 +211,10 @@ public:
 
     lognormal()
             : detail::distribution_base<lognormal<RealType, Method>>(
-                  static_cast<RealType>(0.0), static_cast<RealType>(1.0),
-                  static_cast<RealType>(0.0), static_cast<RealType>(1.0)) {}
+                  RealType(0.0), RealType(1.0), RealType(0.0), RealType(1.0)) {}
 
-    explicit lognormal(RealType m, RealType s, RealType displ = static_cast<RealType>(0.0),
-                       RealType scale = static_cast<RealType>(1.0))
+    explicit lognormal(RealType m, RealType s, RealType displ = RealType(0.0),
+                       RealType scale = RealType(1.0))
             : detail::distribution_base<lognormal<RealType, Method>>(m, s, displ, scale) {}
     explicit lognormal(const param_type& pt)
             : detail::distribution_base<lognormal<RealType, Method>>(pt.m_, pt.s_, pt.displ_,
@@ -250,6 +252,157 @@ public:
     friend typename Distr::result_type generate_single(Distr& distr, Engine& engine);
 };
 
+// Class template oneapi::mkl::rng::device::beta
+//
+// Represents continuous beta random number distribution
+//
+// Supported types:
+//      float
+//      double
+//
+// Supported methods:
+//      oneapi::mkl::rng::device::beta_method::cja
+//      oneapi::mkl::rng::device::beta_method::cja_accurate
+//
+// Input arguments:
+//      p - shape. 1.0 by default
+//      q - shape. 0.0 by default
+//      a - displacement. 1.0 by default
+//      b - scalefactor. 1.0 by default
+//
+template <typename RealType, typename Method>
+class beta : detail::distribution_base<beta<RealType, Method>> {
+public:
+    static_assert(std::is_same<Method, beta_method::cja>::value ||
+                      std::is_same<Method, beta_method::cja_accurate>::value,
+                  "oneMKL: rng/beta: method is incorrect");
+
+    static_assert(std::is_same<RealType, float>::value || std::is_same<RealType, double>::value,
+                  "oneMKL: rng/beta: type is not supported");
+
+    using method_type = Method;
+    using result_type = RealType;
+    using param_type = typename detail::distribution_base<beta<RealType, Method>>::param_type;
+
+    beta()
+            : detail::distribution_base<beta<RealType, Method>>(RealType(1.0), RealType(1.0),
+                                                                RealType(0.0), RealType(1.0)) {}
+
+    explicit beta(RealType p, RealType q, RealType a, RealType b)
+            : detail::distribution_base<beta<RealType, Method>>(p, q, a, b) {}
+
+    explicit beta(const param_type& pt)
+            : detail::distribution_base<beta<RealType, Method>>(pt.p_, pt.q_, pt.a_, pt.b_) {}
+
+    RealType p() const {
+        return detail::distribution_base<beta<RealType, Method>>::p();
+    }
+
+    RealType q() const {
+        return detail::distribution_base<beta<RealType, Method>>::q();
+    }
+
+    RealType a() const {
+        return detail::distribution_base<beta<RealType, Method>>::a();
+    }
+
+    RealType b() const {
+        return detail::distribution_base<beta<RealType, Method>>::b();
+    }
+
+    param_type param() const {
+        return detail::distribution_base<beta<RealType, Method>>::param();
+    }
+
+    std::size_t count_rejected_numbers() const {
+        return detail::distribution_base<beta<RealType, Method>>::count_rejected_numbers();
+    }
+
+    void param(const param_type& pt) {
+        detail::distribution_base<beta<RealType, Method>>::param(pt);
+    }
+
+    template <typename Distr, typename Engine>
+    friend auto generate(Distr& distr, Engine& engine) ->
+        typename std::conditional<Engine::vec_size == 1, typename Distr::result_type,
+                                  sycl::vec<typename Distr::result_type, Engine::vec_size>>::type;
+    template <typename Distr, typename Engine>
+    friend typename Distr::result_type generate_single(Distr& distr, Engine& engine);
+};
+
+// Class template oneapi::mkl::rng::device::gamma
+//
+// Represents continuous gamma random number distribution
+//
+// Supported types:
+//      float
+//      double
+//
+// Supported methods:
+//      oneapi::mkl::rng::device::gamma_method::marsaglia
+//      oneapi::mkl::rng::device::gamma_method::marsaglia_accurate
+//
+// Input arguments:
+//      alpha - shape. 1.0 by default
+//      a - displacement. 0.0 by default
+//      beta - scalefactor. 1.0 by default
+//
+template <typename RealType, typename Method>
+class gamma : detail::distribution_base<gamma<RealType, Method>> {
+public:
+    static_assert(std::is_same<Method, gamma_method::marsaglia>::value ||
+                      std::is_same<Method, gamma_method::marsaglia_accurate>::value,
+                  "oneMKL: rng/gamma: method is incorrect");
+
+    static_assert(std::is_same<RealType, float>::value || std::is_same<RealType, double>::value,
+                  "oneMKL: rng/gamma: type is not supported");
+
+    using method_type = Method;
+    using result_type = RealType;
+    using param_type = typename detail::distribution_base<gamma<RealType, Method>>::param_type;
+
+    gamma()
+            : detail::distribution_base<gamma<RealType, Method>>(RealType(1.0), RealType(0.0),
+                                                                 RealType(1.0)) {}
+
+    explicit gamma(RealType alpha, RealType a, RealType beta)
+            : detail::distribution_base<gamma<RealType, Method>>(alpha, a, beta) {}
+
+    explicit gamma(const param_type& pt)
+            : detail::distribution_base<gamma<RealType, Method>>(pt.alpha_, pt.a_, pt.beta_) {}
+
+    RealType alpha() const {
+        return detail::distribution_base<gamma<RealType, Method>>::alpha();
+    }
+
+    RealType a() const {
+        return detail::distribution_base<gamma<RealType, Method>>::a();
+    }
+
+    RealType beta() const {
+        return detail::distribution_base<gamma<RealType, Method>>::beta();
+    }
+
+    std::size_t count_rejected_numbers() const {
+        return detail::distribution_base<gamma<RealType, Method>>::count_rejected_numbers();
+    }
+
+    param_type param() const {
+        return detail::distribution_base<gamma<RealType, Method>>::param();
+    }
+
+    void param(const param_type& pt) {
+        detail::distribution_base<gamma<RealType, Method>>::param(pt);
+    }
+
+    template <typename Distr, typename Engine>
+    friend auto generate(Distr& distr, Engine& engine) ->
+        typename std::conditional<Engine::vec_size == 1, typename Distr::result_type,
+                                  sycl::vec<typename Distr::result_type, Engine::vec_size>>::type;
+    template <typename Distr, typename Engine>
+    friend typename Distr::result_type generate_single(Distr& distr, Engine& engine);
+};
+
 // Class template oneapi::mkl::rng::device::uniform_bits
 //
 // Represents discrete uniform bits random number distribution
@@ -334,8 +487,8 @@ public:
         typename detail::distribution_base<exponential<RealType, Method>>::param_type;
 
     exponential()
-            : detail::distribution_base<exponential<RealType, Method>>(
-                  static_cast<RealType>(0.0), static_cast<RealType>(1.0)) {}
+            : detail::distribution_base<exponential<RealType, Method>>(RealType(0.0),
+                                                                       RealType(1.0)) {}
 
     explicit exponential(RealType a, RealType beta)
             : detail::distribution_base<exponential<RealType, Method>>(a, beta) {}
@@ -442,7 +595,11 @@ public:
                   "oneMKL: rng/bernoulli: method is incorrect");
 
     static_assert(std::is_same<IntType, std::int32_t>::value ||
-                      std::is_same<IntType, std::uint32_t>::value,
+                      std::is_same<IntType, std::uint32_t>::value ||
+                      std::is_same<IntType, std::int16_t>::value ||
+                      std::is_same<IntType, std::uint16_t>::value ||
+                      std::is_same<IntType, std::int8_t>::value ||
+                      std::is_same<IntType, std::uint8_t>::value,
                   "oneMKL: rng/bernoulli: type is not supported");
 
     using method_type = Method;

{mkl_devel_dpcpp-2024.2.2.data → mkl_devel_dpcpp-2025.0.1.data}/data/Library/include/oneapi/mkl/rng/device/engines.hpp

@@ -139,9 +139,6 @@ public:
     mcg31m1(std::uint32_t seed, std::uint64_t offset = 0)
             : detail::engine_base<mcg31m1<VecSize>>(seed, offset) {}
 
-    mcg31m1(std::initializer_list<std::uint32_t> seed, std::uint64_t offset = 0)
-            : detail::engine_base<mcg31m1<VecSize>>(seed.size(), seed.begin(), offset) {}
-
 private:
     template <typename Engine>
     friend void skip_ahead(Engine& engine, std::uint64_t num_to_skip);
@@ -170,12 +167,9 @@ public:
 
     mcg59() : detail::engine_base<mcg59<VecSize>>(default_seed) {}
 
-    mcg59(std::uint32_t seed, std::uint64_t offset = 0)
+    mcg59(std::uint64_t seed, std::uint64_t offset = 0)
             : detail::engine_base<mcg59<VecSize>>(seed, offset) {}
 
-    mcg59(std::initializer_list<std::uint32_t> seed, std::uint64_t offset = 0)
-            : detail::engine_base<mcg59<VecSize>>(seed.size(), seed.begin(), offset) {}
-
 private:
     template <typename Engine>
     friend void skip_ahead(Engine& engine, std::uint64_t num_to_skip);

{mkl_devel_dpcpp-2024.2.2.data → mkl_devel_dpcpp-2025.0.1.data}/data/Library/include/oneapi/mkl/rng/device/types.hpp

@@ -57,6 +57,18 @@ struct icdf {};
 using by_default = icdf;
 } // namespace bernoulli_method
 
+namespace beta_method {
+struct cja {};
+struct cja_accurate {};
+using by_default = cja;
+} // namespace beta_method
+
+namespace gamma_method {
+struct marsaglia {};
+struct marsaglia_accurate {};
+using by_default = marsaglia;
+} // namespace gamma_method
+
 } // namespace oneapi::mkl::rng::device
 
 #endif // _MKL_RNG_DEVICE_TYPES_HPP_

{mkl_devel_dpcpp-2024.2.2.data → mkl_devel_dpcpp-2025.0.1.data}/data/Library/include/oneapi/mkl/rng/distributions.hpp

@@ -261,22 +261,12 @@ public:
     static constexpr layout layout_type = Layout;
 
     struct param_type {
-        [[deprecated("Use the constructor with sycl::span instead")]]
-        param_type(std::uint32_t dimen, std::vector<RealType> mean, std::vector<RealType> matrix)
-                : dimen_(dimen),
-                  mean_(mean),
-                  matrix_(matrix) {
-                    mean_span_ = sycl::span<RealType>{mean_.data(), mean_.size()};
-                    matrix_span_ = sycl::span<RealType>{matrix_.data(), matrix_.size()};
-                  }
         param_type(std::uint32_t dimen, sycl::span<RealType> mean, sycl::span<RealType> matrix)
                 : dimen_(dimen),
                   mean_span_(mean),
                   matrix_span_(matrix) {}
 
         std::uint32_t dimen_;
-        std::vector<RealType> mean_;
-        std::vector<RealType> matrix_;
         sycl::span<RealType> mean_span_;
         sycl::span<RealType> matrix_span_;
     };
@@ -295,28 +285,8 @@ public:
         }
     }
 
-    [[deprecated("Use the constructor with sycl::span instead")]]
-    explicit gaussian_mv(std::uint32_t dimen, std::vector<RealType> mean,
-                         std::vector<RealType> matrix)
-            : dimen_(dimen),
-              mean_(mean),
-              matrix_(matrix) {
-        mean_span_ = sycl::span<RealType>{mean_.data(), mean_.size()};
-        matrix_span_ = sycl::span<RealType>{matrix_.data(), matrix_.size()};
-
-        if ((mean.size() != dimen)) {
-            throw oneapi::mkl::invalid_argument("rng", "gaussian_mv", "'mean' vector size is incorrect");
-        }
-        if ((matrix.size() != dimen * dimen) && (matrix.size() != dimen) &&
-            (matrix.size() != dimen * (dimen + 1) / 2)) {
-            throw oneapi::mkl::invalid_argument("rng", "gaussian_mv", "'matrix' size is incorrect");
-        }
-    }
-
     explicit gaussian_mv(const param_type& pt)
             : dimen_(pt.dimen_),
-              mean_(pt.mean_),
-              matrix_(pt.matrix_),
               mean_span_(pt.mean_span_),
               matrix_span_(pt.matrix_span_) {
 
@@ -332,12 +302,12 @@ public:
         return dimen_;
     }
 
-    std::vector<RealType> mean() const {
-        return std::vector<RealType>(mean_span_.begin(), mean_span_.end());
+    sycl::span<RealType> mean() const {
+        return mean_span_;
     }
 
-    std::vector<RealType> matrix() const {
-        return std::vector<RealType>(matrix_span_.begin(), matrix_span_.end());
+    sycl::span<RealType> matrix() const {
+        return matrix_span_;
     }
 
     param_type param() const {
@@ -352,16 +322,12 @@ public:
             throw oneapi::mkl::invalid_argument("rng", "gaussian_mv", "'matrix' size is < 0");
         }
         dimen_ = pt.dimen_;
-        mean_ = pt.mean_;
-        matrix_ = pt.matrix_;
         mean_span_ = pt.mean_span_;
         matrix_span_ = pt.matrix_span_;
     }
 
 private:
     std::uint32_t dimen_;
-    std::vector<RealType> mean_;
-    std::vector<RealType> matrix_;
     sycl::span<RealType> mean_span_;
     sycl::span<RealType> matrix_span_;
 };
@@ -1628,28 +1594,12 @@ public:
     using result_type = IntType;
 
     struct param_type {
-        [[deprecated("Use the constructor with sycl::span instead")]]
-        param_type(std::int32_t ntrial, std::vector<double> p) : ntrial_(ntrial), p_(p) {
-            p_span_ = sycl::span<double>{p_.data(), p_.size()};
-        }
         param_type(std::int32_t ntrial, sycl::span<double> p) : ntrial_(ntrial), p_span_(p) {}
 
         std::int32_t ntrial_;
-        std::vector<double> p_;
         sycl::span<double> p_span_;
     };
 
-    [[deprecated("Use the constructor with sycl::span instead")]]
-    explicit multinomial(std::int32_t ntrial, std::vector<double> p) : ntrial_(ntrial), p_(p) {
-        p_span_ = sycl::span<double>{p_.data(), p_.size()};
-        if (ntrial < 0) {
-            throw oneapi::mkl::invalid_argument("rng", "multinomial", "ntrial < 0");
-        }
-        if (p.size() < 1) {
-            throw oneapi::mkl::invalid_argument("rng", "multinomial", "size of p < 1");
-        }
-    }
-
     explicit multinomial(std::int32_t ntrial, sycl::span<double> p) : ntrial_(ntrial), p_span_(p) {
         if (ntrial < 0) {
             throw oneapi::mkl::invalid_argument("rng", "multinomial", "ntrial < 0");
@@ -1659,7 +1609,7 @@ public:
         }
     }
 
-    explicit multinomial(const param_type& pt) : ntrial_(pt.ntrial_), p_(pt.p_), p_span_(pt.p_span_) {
+    explicit multinomial(const param_type& pt) : ntrial_(pt.ntrial_), p_span_(pt.p_span_) {
         if (pt.ntrial_ < 0) {
             throw oneapi::mkl::invalid_argument("rng", "multinomial", "ntrial < 0");
         }
@@ -1672,8 +1622,8 @@ public:
         return ntrial_;
     }
 
-    std::vector<double> p() const {
-        return std::vector<double>(p_span_.begin(), p_span_.end());
+    sycl::span<double> p() const {
+        return p_span_;
     }
 
     param_type param() const {
@@ -1688,13 +1638,11 @@ public:
             throw oneapi::mkl::invalid_argument("rng", "multinomial", "size of p < 1");
         }
         ntrial_ = pt.ntrial_;
-        p_ = pt.p_;
         p_span_ = pt.p_span_;
     }
 
 private:
     std::int32_t ntrial_;
-    std::vector<double> p_;
     sycl::span<double> p_span_;
 };
 
@@ -1867,7 +1815,7 @@ private:
 //      oneapi::mkl::rng::poisson_v_method::gaussian_icdf_based
 //
 // Input arguments:
-//      lambda - vector of distribution parameters
+//      lambda - span of distribution parameters
 
 namespace poisson_v_method {
 struct gaussian_icdf_based {};
@@ -1888,26 +1836,11 @@ public:
     using result_type = IntType;
 
     struct param_type {
-        [[deprecated("Use the constructor with sycl::span instead")]]
-        param_type(std::vector<double> lambda) : lambda_(lambda) {
-            lambda_span_ = sycl::span<double>{lambda_.data(), lambda_.size()};
-        }
         param_type(sycl::span<double> lambda) : lambda_span_(lambda) {}
 
-        std::vector<double> lambda_;
         sycl::span<double> lambda_span_;
     };
 
-    [[deprecated("Use the constructor with sycl::span instead")]]
-    explicit poisson_v(std::vector<double> lambda) : lambda_(lambda)
-    {
-        lambda_span_ = sycl::span<double>{lambda_.data(), lambda_.size()};
-        if ((lambda.size() <= 0)) {
-        throw oneapi::mkl::invalid_argument("rng", "poisson_v",
-                                            "size of lambda < 0");
-        }
-    }
-
     explicit poisson_v(sycl::span<double> lambda) : lambda_span_(lambda) {
         if ((lambda.size() <= 0)) {
         throw oneapi::mkl::invalid_argument("rng", "poisson_v",
@@ -1915,14 +1848,14 @@ public:
         }
     }
 
-    explicit poisson_v(const param_type& pt) : lambda_(pt.lambda_), lambda_span_(pt.lambda_span_) {
+    explicit poisson_v(const param_type& pt) : lambda_span_(pt.lambda_span_) {
         if ((pt.lambda_span_.size() <= 0)) {
             throw oneapi::mkl::invalid_argument("rng", "poisson_v", "size of lambda < 0");
         }
     }
 
-    std::vector<double> lambda() const {
-        return std::vector<double>(lambda_span_.begin(), lambda_span_.end());
+    sycl::span<double> lambda() const {
+        return lambda_span_;
     }
 
     param_type param() const {
@@ -1933,12 +1866,10 @@ public:
         if ((pt.lambda_span_.size() <= 0)) {
             throw oneapi::mkl::invalid_argument("rng", "poisson_v", "size of lambda < 0");
         }
-        lambda_ = pt.lambda_;
         lambda_span_ = pt.lambda_span_;
     }
 
 private:
-    std::vector<double> lambda_;
     sycl::span<double> lambda_span_;
 };
 

{mkl_devel_dpcpp-2024.2.2.data → mkl_devel_dpcpp-2025.0.1.data}/data/Library/include/oneapi/mkl/spblas/sparse_auxiliary.hpp

@@ -38,6 +38,49 @@ DLL_EXPORT sycl::event omatcopy(sycl::queue &queue,
                                 matrix_handle_t spMat_out,
                                 const std::vector<sycl::event> &dependencies = {});
 
+/******************************************************************************/
+DLL_EXPORT void omatconvert_buffer_size(
+    sycl::queue &queue,
+    matrix_handle_t spMat_in,
+    matrix_handle_t spMat_out,
+    omatconvert_alg alg,
+    omatconvert_descr_t descr,
+    std::int64_t &sizeTempWorkspace);
+
+DLL_EXPORT void omatconvert_analyze(
+    sycl::queue &queue,
+    matrix_handle_t spMat_in,
+    matrix_handle_t spMat_out,
+    omatconvert_alg alg,
+    omatconvert_descr_t descr,
+    sycl::buffer<std::uint8_t, 1> *tempWorkspace);
+
+DLL_EXPORT sycl::event omatconvert_analyze(
+    sycl::queue &queue,
+    matrix_handle_t spMat_in,
+    matrix_handle_t spMat_out,
+    omatconvert_alg alg,
+    omatconvert_descr_t descr,
+    void *tempWorkspace,
+    const std::vector<sycl::event> &dependencies = {});
+
+DLL_EXPORT void omatconvert_get_nnz(
+    sycl::queue &queue,
+    matrix_handle_t spMat_in,
+    matrix_handle_t spMat_out,
+    omatconvert_alg alg,
+    omatconvert_descr_t descr,
+    std::int64_t &nnzOut,
+    const std::vector<sycl::event> &dependencies = {});
+
+DLL_EXPORT sycl::event omatconvert (
+    sycl::queue &queue,
+    oneapi::mkl::sparse::matrix_handle_t spMat_in,
+    oneapi::mkl::sparse::matrix_handle_t spMat_out,
+    omatconvert_alg alg,
+    omatconvert_descr_t descr,
+    const std::vector<sycl::event> &dependencies = {});
+
 /******************************************************************************/
 DLL_EXPORT sycl::event sort_matrix(sycl::queue &queue,
                                    matrix_handle_t spMat,