mkl-devel-dpcpp 2024.0.0__py2.py3-none-manylinux1_x86_64.whl → 2024.2.0__py2.py3-none-manylinux1_x86_64.whl

mkl_devel_dpcpp-2024.2.0.data/data/include/oneapi/mkl/spblas/sparse_structures.hpp

@@ -0,0 +1,194 @@
+/*******************************************************************************
+* Copyright 2019-2023 Intel Corporation.
+*
+* This software and the related documents are Intel copyrighted  materials,  and
+* your use of  them is  governed by the  express license  under which  they were
+* provided to you (License).  Unless the License provides otherwise, you may not
+* use, modify, copy, publish, distribute,  disclose or transmit this software or
+* the related documents without Intel's prior written permission.
+*
+* This software and the related documents  are provided as  is,  with no express
+* or implied  warranties,  other  than those  that are  expressly stated  in the
+* License.
+*******************************************************************************/
+
+#ifndef _ONEMKL_SPARSE_STRUCTURES_HPP_
+#define _ONEMKL_SPARSE_STRUCTURES_HPP_
+
+#include <sycl/sycl.hpp>
+#include <complex>
+#include <cstddef>
+#include <cstdint>
+#include <stdexcept>
+
+#include "oneapi/mkl/export.hpp"
+#include "oneapi/mkl/types.hpp"
+#include "oneapi/mkl/exceptions.hpp"
+
+namespace oneapi {
+namespace mkl {
+namespace sparse {
+
+/******************************************************************************/
+struct matrix_handle;
+typedef struct matrix_handle *matrix_handle_t;
+
+DLL_EXPORT void init_matrix_handle(matrix_handle_t *p_spMat);
+
+// non-blocking version of release_matrix_handle, will schedule clean up of handle
+// asychronously pending dependencies and return an event to track it
+DLL_EXPORT sycl::event
+release_matrix_handle(sycl::queue &queue,
+                      matrix_handle_t *p_spMat,
+                      const std::vector<sycl::event> &dependencies = {});
+
+[[deprecated("Use oneapi::mkl::sparse::release_matrix_handle(queue, p_spMat, dependencies) instead.")]]
+DLL_EXPORT void
+release_matrix_handle(matrix_handle_t *p_spMat,
+                      const std::vector<sycl::event> &dependencies = {});
+
+/******************************************************************************/
+//
+// PROPERTY of matrix arrays/data. The property must be consistent with the
+// data; this consistency is not verified and assumed to be true when provided
+// by the user for performance reasons. If user-supplied data properties are
+// inconsistent from actual matrix arrays/data, then applications may
+// crash/hang/produce incorrect results.
+enum class property : char {
+    symmetric = 0,
+    sorted    = 1,
+};
+
+DLL_EXPORT void set_matrix_property(matrix_handle_t spMat, property property_value);
+
+/******************************************************************************/
+#define ONEMKL_DECLARE_SPARSE_SET_CSR_DATA(IntType, FpType) \
+    DLL_EXPORT void set_csr_data(sycl::queue &queue, \
+                                 matrix_handle_t spMat, \
+                                 const IntType nrows, \
+                                 const IntType ncols, \
+                                 index_base index, \
+                                 sycl::buffer<IntType, 1> &row_ptr, \
+                                 sycl::buffer<IntType, 1> &col_ind, \
+                                 sycl::buffer<FpType, 1> &values); \
+    DLL_EXPORT sycl::event set_csr_data(sycl::queue &queue, \
+                                        matrix_handle_t spMat, \
+                                        const IntType nrows, \
+                                        const IntType ncols, \
+                                        index_base index, \
+                                        IntType *row_ptr, \
+                                        IntType *col_ind, \
+                                        FpType *values, \
+                                        const std::vector<sycl::event> &dependencies = {})
+
+ONEMKL_DECLARE_SPARSE_SET_CSR_DATA(std::int32_t, float);
+ONEMKL_DECLARE_SPARSE_SET_CSR_DATA(std::int32_t, double);
+ONEMKL_DECLARE_SPARSE_SET_CSR_DATA(std::int32_t, std::complex<float>);
+ONEMKL_DECLARE_SPARSE_SET_CSR_DATA(std::int32_t, std::complex<double>);
+ONEMKL_DECLARE_SPARSE_SET_CSR_DATA(std::int64_t, float);
+ONEMKL_DECLARE_SPARSE_SET_CSR_DATA(std::int64_t, double);
+ONEMKL_DECLARE_SPARSE_SET_CSR_DATA(std::int64_t, std::complex<float>);
+ONEMKL_DECLARE_SPARSE_SET_CSR_DATA(std::int64_t, std::complex<double>);
+
+#undef ONEMKL_DECLARE_SPARSE_SET_CSR_DATA
+
+#define ONEMKL_DECLARE_DEPRECATED_SPARSE_SET_CSR_DATA(IntType, FpType) \
+    [[deprecated("Use oneapi::mkl::sparse::set_csr_data(queue, spMat, ...) instead.")]] \
+    DLL_EXPORT void set_csr_data(matrix_handle_t spMat, \
+                                 const IntType nrows, \
+                                 const IntType ncols, \
+                                 index_base index, \
+                                 sycl::buffer<IntType, 1> &row_ptr, \
+                                 sycl::buffer<IntType, 1> &col_ind, \
+                                 sycl::buffer<FpType, 1> &values); \
+    [[deprecated("Use oneapi::mkl::sparse::set_csr_data(queue, spMat, ...) instead.")]] \
+    DLL_EXPORT void set_csr_data(matrix_handle_t spMat, \
+                                 const IntType nrows, \
+                                 const IntType ncols, \
+                                 index_base index, \
+                                 IntType *row_ptr, \
+                                 IntType *col_ind, \
+                                 FpType *values)
+
+ONEMKL_DECLARE_DEPRECATED_SPARSE_SET_CSR_DATA(std::int32_t, float);
+ONEMKL_DECLARE_DEPRECATED_SPARSE_SET_CSR_DATA(std::int32_t, double);
+ONEMKL_DECLARE_DEPRECATED_SPARSE_SET_CSR_DATA(std::int32_t, std::complex<float>);
+ONEMKL_DECLARE_DEPRECATED_SPARSE_SET_CSR_DATA(std::int32_t, std::complex<double>);
+ONEMKL_DECLARE_DEPRECATED_SPARSE_SET_CSR_DATA(std::int64_t, float);
+ONEMKL_DECLARE_DEPRECATED_SPARSE_SET_CSR_DATA(std::int64_t, double);
+ONEMKL_DECLARE_DEPRECATED_SPARSE_SET_CSR_DATA(std::int64_t, std::complex<float>);
+ONEMKL_DECLARE_DEPRECATED_SPARSE_SET_CSR_DATA(std::int64_t, std::complex<double>);
+
+#undef ONEMKL_DECLARE_DEPRECATED_SPARSE_SET_CSR_DATA
+
+/******************************************************************************/
+#define ONEMKL_DECLARE_SPARSE_SET_COO_DATA(IntType, FpType) \
+    DLL_EXPORT void set_coo_data(sycl::queue &queue, \
+                                 matrix_handle_t spMat, \
+                                 const IntType nrows, \
+                                 const IntType ncols, \
+                                 const IntType nnz, \
+                                 index_base index, \
+                                 sycl::buffer<IntType, 1> &row_ind, \
+                                 sycl::buffer<IntType, 1> &col_ind, \
+                                 sycl::buffer<FpType, 1> &values); \
+    DLL_EXPORT sycl::event set_coo_data(sycl::queue &queue, \
+                                        matrix_handle_t spMat, \
+                                        const IntType nrows, \
+                                        const IntType ncols, \
+                                        const IntType nnz, \
+                                        index_base index, \
+                                        IntType *row_ind, \
+                                        IntType *col_ind, \
+                                        FpType *values, \
+                                        const std::vector<sycl::event> &dependencies = {})
+
+ONEMKL_DECLARE_SPARSE_SET_COO_DATA(std::int32_t, float);
+ONEMKL_DECLARE_SPARSE_SET_COO_DATA(std::int32_t, double);
+ONEMKL_DECLARE_SPARSE_SET_COO_DATA(std::int32_t, std::complex<float>);
+ONEMKL_DECLARE_SPARSE_SET_COO_DATA(std::int32_t, std::complex<double>);
+ONEMKL_DECLARE_SPARSE_SET_COO_DATA(std::int64_t, float);
+ONEMKL_DECLARE_SPARSE_SET_COO_DATA(std::int64_t, double);
+ONEMKL_DECLARE_SPARSE_SET_COO_DATA(std::int64_t, std::complex<float>);
+ONEMKL_DECLARE_SPARSE_SET_COO_DATA(std::int64_t, std::complex<double>);
+
+#undef ONEMKL_DECLARE_SPARSE_SET_COO_DATA
+
+/******************************************************************************/
+//
+// Types, Objects and APIs for Sparse Matrix * Sparse Matrix (matmat) multiplication
+//
+
+//
+// Different VIEWS of matrix data (which may be different from the data itself)
+// Views are different from the `enum class property` which describes the fixed
+// property of data supplied to the matrix handle.
+//
+enum class matrix_view_descr : std::int32_t { general = 1 };
+
+enum class matmat_request : std::int32_t {
+    get_work_estimation_buf_size = 1,
+    work_estimation = 2,
+
+    get_compute_structure_buf_size = 3,
+    compute_structure = 4,
+    finalize_structure = 5,
+
+    get_compute_buf_size = 6,
+    compute = 7,
+    get_nnz = 8,
+    finalize = 9,
+};
+
+struct matmat_descr;
+typedef matmat_descr *matmat_descr_t;
+
+DLL_EXPORT void init_matmat_descr(matmat_descr_t *p_desc);
+DLL_EXPORT void release_matmat_descr(matmat_descr_t *p_desc);
+
+
+} /* namespace oneapi::mkl::sparse */
+} /* namespace mkl */
+} // namespace oneapi
+
+#endif // #ifndef _ONEMKL_SPARSE_STRUCTURES_HPP_

mkl_devel_dpcpp-2024.2.0.data/data/include/oneapi/mkl/spblas.hpp

@@ -0,0 +1,32 @@
+/*******************************************************************************
+* Copyright 2019-2022 Intel Corporation.
+*
+* This software and the related documents are Intel copyrighted  materials,  and
+* your use of  them is  governed by the  express license  under which  they were
+* provided to you (License).  Unless the License provides otherwise, you may not
+* use, modify, copy, publish, distribute,  disclose or transmit this software or
+* the related documents without Intel's prior written permission.
+*
+* This software and the related documents  are provided as  is,  with no express
+* or implied  warranties,  other  than those  that are  expressly stated  in the
+* License.
+*******************************************************************************/
+
+#ifndef _ONEMKL_SPBLAS_HPP_
+#define _ONEMKL_SPBLAS_HPP_
+
+#include <sycl/sycl.hpp>
+#include <complex>
+#include <cstddef>
+#include <cstdint>
+#include <stdexcept>
+
+#include "oneapi/mkl/export.hpp"
+#include "oneapi/mkl/types.hpp"
+#include "oneapi/mkl/exceptions.hpp"
+
+#include "oneapi/mkl/spblas/sparse_structures.hpp"
+#include "oneapi/mkl/spblas/sparse_operations.hpp"
+#include "oneapi/mkl/spblas/sparse_auxiliary.hpp"
+
+#endif /* _ONEMKL_SPBLAS_HPP_ */

{mkl_devel_dpcpp-2024.0.0.data → mkl_devel_dpcpp-2024.2.0.data}/data/include/oneapi/mkl/stats.hpp

@@ -68,7 +68,7 @@ struct dataset<ObservationsLayout, Type*> {
     Type* observations;
     Type* weights = nullptr;
     std::int64_t* indices = nullptr;
-    static constexpr layout layout = ObservationsLayout;
+    static constexpr oneapi::mkl::stats::layout layout = ObservationsLayout;
 };
 
 // Specialization for buffer-based API
@@ -99,7 +99,7 @@ struct dataset<ObservationsLayout, sycl::buffer<Type, 1>> {
     sycl::buffer<Type, 1> observations;
     sycl::buffer<Type, 1> weights = {0};
     sycl::buffer<std::int64_t, 1> indices = {0};
-    static constexpr layout layout = ObservationsLayout;
+    static constexpr oneapi::mkl::stats::layout layout = ObservationsLayout;
 };
 
 // Helper funtions to make dataset

{mkl_devel_dpcpp-2024.0.0.data → mkl_devel_dpcpp-2024.2.0.data}/data/include/oneapi/mkl/vm/buffer.hpp

@@ -1,6 +1,6 @@
 /* -== file: buffer.hpp ==- */
 /*******************************************************************************
-* Copyright 2019-2023 Intel Corporation.
+* Copyright 2019-2024 Intel Corporation.
 *
 * This software and the related documents are Intel copyrighted  materials,  and
 * your use of  them is  governed by the  express license  under which  they were
@@ -1887,6 +1887,34 @@ j1(sycl::queue& queue, sycl::buffer<double, 1>& a, oneapi::mkl::slice sa,
    sycl::buffer<double, 1>& y, oneapi::mkl::slice sy,
    oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined);
 
+// function jn
+ONEAPI_MKL_VM_EXPORT sycl::event
+jn(sycl::queue& queue, int64_t n, sycl::buffer<sycl::half, 1>& a, sycl::half b,
+   sycl::buffer<sycl::half, 1>& y,
+   oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined);
+ONEAPI_MKL_VM_EXPORT sycl::event
+jn(sycl::queue& queue, sycl::buffer<sycl::half, 1>& a, oneapi::mkl::slice sa,
+   sycl::half b, sycl::buffer<sycl::half, 1>& y, oneapi::mkl::slice sy,
+   oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined);
+
+ONEAPI_MKL_VM_EXPORT sycl::event
+jn(sycl::queue& queue, int64_t n, sycl::buffer<float, 1>& a, float b,
+   sycl::buffer<float, 1>& y,
+   oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined);
+ONEAPI_MKL_VM_EXPORT sycl::event
+jn(sycl::queue& queue, sycl::buffer<float, 1>& a, oneapi::mkl::slice sa,
+   float b, sycl::buffer<float, 1>& y, oneapi::mkl::slice sy,
+   oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined);
+
+ONEAPI_MKL_VM_EXPORT sycl::event
+jn(sycl::queue& queue, int64_t n, sycl::buffer<double, 1>& a, double b,
+   sycl::buffer<double, 1>& y,
+   oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined);
+ONEAPI_MKL_VM_EXPORT sycl::event
+jn(sycl::queue& queue, sycl::buffer<double, 1>& a, oneapi::mkl::slice sa,
+   double b, sycl::buffer<double, 1>& y, oneapi::mkl::slice sy,
+   oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined);
+
 // function lgamma
 ONEAPI_MKL_VM_EXPORT sycl::event
 lgamma(sycl::queue& queue, int64_t n, sycl::buffer<sycl::half, 1>& a,
@@ -3462,6 +3490,40 @@ y1(sycl::queue& queue, sycl::buffer<double, 1>& a, oneapi::mkl::slice sa,
    sycl::buffer<double, 1>& y, oneapi::mkl::slice sy,
    oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined);
 
+// function yn
+ONEAPI_MKL_VM_EXPORT sycl::event
+yn(sycl::queue& queue, int64_t n, sycl::buffer<sycl::half, 1>& a, sycl::half b,
+   sycl::buffer<sycl::half, 1>& y,
+   oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined,
+   oneapi::mkl::vm::error_handler<sycl::half> const& eh = {});
+ONEAPI_MKL_VM_EXPORT sycl::event
+yn(sycl::queue& queue, sycl::buffer<sycl::half, 1>& a, oneapi::mkl::slice sa,
+   sycl::half b, sycl::buffer<sycl::half, 1>& y, oneapi::mkl::slice sy,
+   oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined,
+   oneapi::mkl::vm::error_handler<sycl::half> const& eh = {});
+
+ONEAPI_MKL_VM_EXPORT sycl::event
+yn(sycl::queue& queue, int64_t n, sycl::buffer<float, 1>& a, float b,
+   sycl::buffer<float, 1>& y,
+   oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined,
+   oneapi::mkl::vm::error_handler<float> const& eh = {});
+ONEAPI_MKL_VM_EXPORT sycl::event
+yn(sycl::queue& queue, sycl::buffer<float, 1>& a, oneapi::mkl::slice sa,
+   float b, sycl::buffer<float, 1>& y, oneapi::mkl::slice sy,
+   oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined,
+   oneapi::mkl::vm::error_handler<float> const& eh = {});
+
+ONEAPI_MKL_VM_EXPORT sycl::event
+yn(sycl::queue& queue, int64_t n, sycl::buffer<double, 1>& a, double b,
+   sycl::buffer<double, 1>& y,
+   oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined,
+   oneapi::mkl::vm::error_handler<double> const& eh = {});
+ONEAPI_MKL_VM_EXPORT sycl::event
+yn(sycl::queue& queue, sycl::buffer<double, 1>& a, oneapi::mkl::slice sa,
+   double b, sycl::buffer<double, 1>& y, oneapi::mkl::slice sy,
+   oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined,
+   oneapi::mkl::vm::error_handler<double> const& eh = {});
+
 } // namespace oneapi::mkl::vm
 
 #endif // ONEAPI_MKL_VM_BUFFER_HPP

{mkl_devel_dpcpp-2024.0.0.data → mkl_devel_dpcpp-2024.2.0.data}/data/include/oneapi/mkl/vm/decls.hpp

@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright 2019-2023 Intel Corporation.
+* Copyright 2019-2024 Intel Corporation.
 *
 * This software and the related documents are Intel copyrighted  materials,  and
 * your use of  them is  governed by the  express license  under which  they were
@@ -85,7 +85,7 @@ enum class mode : std::uint32_t {
   verbose_mask = 0x7000000,
 
   default_mode = (ha | global_status_quiet | slice_normal | badarg_exception |
-                  fallback_enabled | verbose_quiet)
+                  fallback_permissive | verbose_quiet)
 };
 
 enum class status : std::uint32_t {

{mkl_devel_dpcpp-2024.0.0.data → mkl_devel_dpcpp-2024.2.0.data}/data/include/oneapi/mkl/vm/device/detail/decls.hpp

@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright 2019-2023 Intel Corporation.
+* Copyright 2019-2024 Intel Corporation.
 *
 * This software and the related documents are Intel copyrighted  materials,  and
 * your use of  them is  governed by the  express license  under which  they were

{mkl_devel_dpcpp-2024.0.0.data → mkl_devel_dpcpp-2024.2.0.data}/data/include/oneapi/mkl/vm/device/detail/dispatch.hpp

@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright 2019-2023 Intel Corporation.
+* Copyright 2019-2024 Intel Corporation.
 *
 * This software and the related documents are Intel copyrighted  materials,  and
 * your use of  them is  governed by the  express license  under which  they were

{mkl_devel_dpcpp-2024.0.0.data → mkl_devel_dpcpp-2024.2.0.data}/data/include/oneapi/mkl/vm/device/detail/ep.hpp

@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright 2019-2023 Intel Corporation.
+* Copyright 2019-2024 Intel Corporation.
 *
 * This software and the related documents are Intel copyrighted  materials,  and
 * your use of  them is  governed by the  express license  under which  they were

{mkl_devel_dpcpp-2024.0.0.data → mkl_devel_dpcpp-2024.2.0.data}/data/include/oneapi/mkl/vm/device/detail/ha.hpp

@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright 2019-2023 Intel Corporation.
+* Copyright 2019-2024 Intel Corporation.
 *
 * This software and the related documents are Intel copyrighted  materials,  and
 * your use of  them is  governed by the  express license  under which  they were

{mkl_devel_dpcpp-2024.0.0.data → mkl_devel_dpcpp-2024.2.0.data}/data/include/oneapi/mkl/vm/device/detail/la.hpp

@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright 2019-2023 Intel Corporation.
+* Copyright 2019-2024 Intel Corporation.
 *
 * This software and the related documents are Intel copyrighted  materials,  and
 * your use of  them is  governed by the  express license  under which  they were

{mkl_devel_dpcpp-2024.0.0.data → mkl_devel_dpcpp-2024.2.0.data}/data/include/oneapi/mkl/vm/device/detail/rts.hpp

@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright 2019-2023 Intel Corporation.
+* Copyright 2019-2024 Intel Corporation.
 *
 * This software and the related documents are Intel copyrighted  materials,  and
 * your use of  them is  governed by the  express license  under which  they were

{mkl_devel_dpcpp-2024.0.0.data → mkl_devel_dpcpp-2024.2.0.data}/data/include/oneapi/mkl/vm/device/detail/scalar.hpp

@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright 2019-2023 Intel Corporation.
+* Copyright 2019-2024 Intel Corporation.
 *
 * This software and the related documents are Intel copyrighted  materials,  and
 * your use of  them is  governed by the  express license  under which  they were

{mkl_devel_dpcpp-2024.0.0.data → mkl_devel_dpcpp-2024.2.0.data}/data/include/oneapi/mkl/vm/device/vm.hpp

@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright 2019-2023 Intel Corporation.
+* Copyright 2019-2024 Intel Corporation.
 *
 * This software and the related documents are Intel copyrighted  materials,  and
 * your use of  them is  governed by the  express license  under which  they were

{mkl_devel_dpcpp-2024.0.0.data → mkl_devel_dpcpp-2024.2.0.data}/data/include/oneapi/mkl/vm/span.hpp

@@ -1,6 +1,6 @@
 /* -== file: span.hpp ==- */
 /*******************************************************************************
-* Copyright 2019-2023 Intel Corporation.
+* Copyright 2019-2024 Intel Corporation.
 *
 * This software and the related documents are Intel copyrighted  materials,  and
 * your use of  them is  governed by the  express license  under which  they were
@@ -2043,6 +2043,37 @@ j1(sycl::queue& queue, sycl::span<const double> a, oneapi::mkl::slice sa,
    std::vector<sycl::event> const& depends = {},
    oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined);
 
+// function jn
+ONEAPI_MKL_VM_EXPORT sycl::event
+jn(sycl::queue& queue, sycl::span<const sycl::half> a, sycl::half b,
+   sycl::span<sycl::half> y, std::vector<sycl::event> const& depends = {},
+   oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined);
+ONEAPI_MKL_VM_EXPORT sycl::event
+jn(sycl::queue& queue, sycl::span<const sycl::half> a, oneapi::mkl::slice sa,
+   sycl::half b, sycl::span<sycl::half> y, oneapi::mkl::slice sy,
+   std::vector<sycl::event> const& depends = {},
+   oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined);
+
+ONEAPI_MKL_VM_EXPORT sycl::event
+jn(sycl::queue& queue, sycl::span<const float> a, float b, sycl::span<float> y,
+   std::vector<sycl::event> const& depends = {},
+   oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined);
+ONEAPI_MKL_VM_EXPORT sycl::event
+jn(sycl::queue& queue, sycl::span<const float> a, oneapi::mkl::slice sa,
+   float b, sycl::span<float> y, oneapi::mkl::slice sy,
+   std::vector<sycl::event> const& depends = {},
+   oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined);
+
+ONEAPI_MKL_VM_EXPORT sycl::event
+jn(sycl::queue& queue, sycl::span<const double> a, double b,
+   sycl::span<double> y, std::vector<sycl::event> const& depends = {},
+   oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined);
+ONEAPI_MKL_VM_EXPORT sycl::event
+jn(sycl::queue& queue, sycl::span<const double> a, oneapi::mkl::slice sa,
+   double b, sycl::span<double> y, oneapi::mkl::slice sy,
+   std::vector<sycl::event> const& depends = {},
+   oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined);
+
 // function lgamma
 ONEAPI_MKL_VM_EXPORT sycl::event
 lgamma(sycl::queue& queue, sycl::span<const sycl::half> a,
@@ -3740,6 +3771,43 @@ y1(sycl::queue& queue, sycl::span<const double> a, oneapi::mkl::slice sa,
    std::vector<sycl::event> const& depends = {},
    oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined);
 
+// function yn
+ONEAPI_MKL_VM_EXPORT sycl::event
+yn(sycl::queue& queue, sycl::span<const sycl::half> a, sycl::half b,
+   sycl::span<sycl::half> y, std::vector<sycl::event> const& depends = {},
+   oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined,
+   oneapi::mkl::vm::error_handler<sycl::half> const& eh = {});
+ONEAPI_MKL_VM_EXPORT sycl::event
+yn(sycl::queue& queue, sycl::span<const sycl::half> a, oneapi::mkl::slice sa,
+   sycl::half b, sycl::span<sycl::half> y, oneapi::mkl::slice sy,
+   std::vector<sycl::event> const& depends = {},
+   oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined,
+   oneapi::mkl::vm::error_handler<sycl::half> const& eh = {});
+
+ONEAPI_MKL_VM_EXPORT sycl::event
+yn(sycl::queue& queue, sycl::span<const float> a, float b, sycl::span<float> y,
+   std::vector<sycl::event> const& depends = {},
+   oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined,
+   oneapi::mkl::vm::error_handler<float> const& eh = {});
+ONEAPI_MKL_VM_EXPORT sycl::event
+yn(sycl::queue& queue, sycl::span<const float> a, oneapi::mkl::slice sa,
+   float b, sycl::span<float> y, oneapi::mkl::slice sy,
+   std::vector<sycl::event> const& depends = {},
+   oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined,
+   oneapi::mkl::vm::error_handler<float> const& eh = {});
+
+ONEAPI_MKL_VM_EXPORT sycl::event
+yn(sycl::queue& queue, sycl::span<const double> a, double b,
+   sycl::span<double> y, std::vector<sycl::event> const& depends = {},
+   oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined,
+   oneapi::mkl::vm::error_handler<double> const& eh = {});
+ONEAPI_MKL_VM_EXPORT sycl::event
+yn(sycl::queue& queue, sycl::span<const double> a, oneapi::mkl::slice sa,
+   double b, sycl::span<double> y, oneapi::mkl::slice sy,
+   std::vector<sycl::event> const& depends = {},
+   oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined,
+   oneapi::mkl::vm::error_handler<double> const& eh = {});
+
 } // namespace oneapi::mkl::vm
 
 #endif // ONEAPI_MKL_VM_SPAN_HPP

{mkl_devel_dpcpp-2024.0.0.data → mkl_devel_dpcpp-2024.2.0.data}/data/include/oneapi/mkl/vm/usm.hpp

@@ -1,6 +1,6 @@
 /* -== file: usm.hpp ==- */
 /*******************************************************************************
-* Copyright 2019-2023 Intel Corporation.
+* Copyright 2019-2024 Intel Corporation.
 *
 * This software and the related documents are Intel copyrighted  materials,  and
 * your use of  them is  governed by the  express license  under which  they were
@@ -1917,6 +1917,36 @@ j1(sycl::queue& queue, const double* a, oneapi::mkl::slice sa, double* y,
    oneapi::mkl::slice sy, std::vector<sycl::event> const& depends = {},
    oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined);
 
+// function jn
+ONEAPI_MKL_VM_EXPORT sycl::event
+jn(sycl::queue& queue, int64_t n, const sycl::half* a, sycl::half b,
+   sycl::half* y, std::vector<sycl::event> const& depends = {},
+   oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined);
+ONEAPI_MKL_VM_EXPORT sycl::event
+jn(sycl::queue& queue, const sycl::half* a, oneapi::mkl::slice sa, sycl::half b,
+   sycl::half* y, oneapi::mkl::slice sy,
+   std::vector<sycl::event> const& depends = {},
+   oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined);
+
+ONEAPI_MKL_VM_EXPORT sycl::event
+jn(sycl::queue& queue, int64_t n, const float* a, float b, float* y,
+   std::vector<sycl::event> const& depends = {},
+   oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined);
+ONEAPI_MKL_VM_EXPORT sycl::event
+jn(sycl::queue& queue, const float* a, oneapi::mkl::slice sa, float b, float* y,
+   oneapi::mkl::slice sy, std::vector<sycl::event> const& depends = {},
+   oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined);
+
+ONEAPI_MKL_VM_EXPORT sycl::event
+jn(sycl::queue& queue, int64_t n, const double* a, double b, double* y,
+   std::vector<sycl::event> const& depends = {},
+   oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined);
+ONEAPI_MKL_VM_EXPORT sycl::event
+jn(sycl::queue& queue, const double* a, oneapi::mkl::slice sa, double b,
+   double* y, oneapi::mkl::slice sy,
+   std::vector<sycl::event> const& depends = {},
+   oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined);
+
 // function lgamma
 ONEAPI_MKL_VM_EXPORT sycl::event
 lgamma(sycl::queue& queue, int64_t n, const sycl::half* a, sycl::half* y,
@@ -3510,6 +3540,42 @@ y1(sycl::queue& queue, const double* a, oneapi::mkl::slice sa, double* y,
    oneapi::mkl::slice sy, std::vector<sycl::event> const& depends = {},
    oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined);
 
+// function yn
+ONEAPI_MKL_VM_EXPORT sycl::event
+yn(sycl::queue& queue, int64_t n, const sycl::half* a, sycl::half b,
+   sycl::half* y, std::vector<sycl::event> const& depends = {},
+   oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined,
+   oneapi::mkl::vm::error_handler<sycl::half> const& eh = {});
+ONEAPI_MKL_VM_EXPORT sycl::event
+yn(sycl::queue& queue, const sycl::half* a, oneapi::mkl::slice sa, sycl::half b,
+   sycl::half* y, oneapi::mkl::slice sy,
+   std::vector<sycl::event> const& depends = {},
+   oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined,
+   oneapi::mkl::vm::error_handler<sycl::half> const& eh = {});
+
+ONEAPI_MKL_VM_EXPORT sycl::event
+yn(sycl::queue& queue, int64_t n, const float* a, float b, float* y,
+   std::vector<sycl::event> const& depends = {},
+   oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined,
+   oneapi::mkl::vm::error_handler<float> const& eh = {});
+ONEAPI_MKL_VM_EXPORT sycl::event
+yn(sycl::queue& queue, const float* a, oneapi::mkl::slice sa, float b, float* y,
+   oneapi::mkl::slice sy, std::vector<sycl::event> const& depends = {},
+   oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined,
+   oneapi::mkl::vm::error_handler<float> const& eh = {});
+
+ONEAPI_MKL_VM_EXPORT sycl::event
+yn(sycl::queue& queue, int64_t n, const double* a, double b, double* y,
+   std::vector<sycl::event> const& depends = {},
+   oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined,
+   oneapi::mkl::vm::error_handler<double> const& eh = {});
+ONEAPI_MKL_VM_EXPORT sycl::event
+yn(sycl::queue& queue, const double* a, oneapi::mkl::slice sa, double b,
+   double* y, oneapi::mkl::slice sy,
+   std::vector<sycl::event> const& depends = {},
+   oneapi::mkl::vm::mode mode = oneapi::mkl::vm::mode::not_defined,
+   oneapi::mkl::vm::error_handler<double> const& eh = {});
+
 } // namespace oneapi::mkl::vm
 
 #endif // ONEAPI_MKL_VM_USM_HPP

mkl_devel_dpcpp-2024.2.0.data/data/lib/libmkl_sycl.so

@@ -0,0 +1 @@
+INPUT(-lmkl_sycl_blas -lmkl_sycl_lapack -lmkl_sycl_sparse -lmkl_sycl_dft -lmkl_sycl_vm -lmkl_sycl_rng -lmkl_sycl_stats -lmkl_sycl_data_fitting)

{mkl_devel_dpcpp-2024.0.0.dist-info → mkl_devel_dpcpp-2024.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mkl-devel-dpcpp
-Version: 2024.0.0
+Version: 2024.2.0
 Summary: Intel® oneAPI Math Kernel Library
 Home-page: https://www.intel.com/content/www/us/en/developer/tools/oneapi/onemkl.html
 Author: Intel Corporation
@@ -17,8 +17,8 @@ Classifier: Intended Audience :: Science/Research
 Classifier: Topic :: Software Development :: Libraries
 Classifier: License :: Other/Proprietary License
 License-File: LICENSE.txt
-Requires-Dist: mkl-dpcpp (==2024.0.0)
-Requires-Dist: mkl-devel (==2024.0.0)
+Requires-Dist: mkl-dpcpp (==2024.2.0)
+Requires-Dist: mkl-devel (==2024.2.0)
 
 Intel® oneAPI Math Kernel Library (Intel® oneMKL) is a computing math library of highly optimized, extensively threaded routines for applications that require maximum performance. This package provides C and Data Parallel C++ (DPC++) programming language interfaces. Intel MKL C language interfaces can be called from applications written in either C or C++, as well as in any other language that can reference a C interface. Use it to optimize code for current and future generations of Intel® CPUs and GPUs.