mkl-devel-dpcpp 2025.0.0__py2.py3-none-manylinux_2_28_x86_64.whl

mkl_devel_dpcpp-2025.0.0.data/data/include/oneapi/mkl/blas.hpp

@@ -0,0 +1,33 @@
+/*******************************************************************************
+* Copyright 2018-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 _BLAS_HPP__
+#define _BLAS_HPP__
+
+#ifndef MKL_BLAS_COMPUTE_MODE
+#define MKL_BLAS_COMPUTE_MODE compute_mode::unset
+#endif
+
+#include <sycl/sycl.hpp>
+#include <cstdint>
+#include <complex>
+
+#include "oneapi/mkl/types.hpp"
+#include "oneapi/mkl/exceptions.hpp"
+
+#include "oneapi/mkl/blas/types.hpp"
+#include "oneapi/mkl/blas/buffer.hpp"
+#include "oneapi/mkl/blas/usm.hpp"
+
+#endif  /* _BLAS_HPP__ */

mkl_devel_dpcpp-2025.0.0.data/data/include/oneapi/mkl/dft.hpp

@@ -0,0 +1,253 @@
+/*******************************************************************************
+* Copyright 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
+* 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 _DFT_HPP_
+#define _DFT_HPP_
+
+#include <cinttypes>    // std::int64_t
+#include <vector>       // std::vector
+#include <sycl/sycl.hpp>  // sycl::
+#include "mkl_dfti.h"   // DFTI_DESCRIPTOR_HANDLE
+
+typedef struct SYCL_DFTI_DESCRIPTOR* SYCL_DFTI_DESCRIPTOR_HANDLE;
+
+namespace oneapi {
+namespace mkl {
+namespace dft {
+
+enum class precision {
+    SINGLE = DFTI_SINGLE,
+    DOUBLE = DFTI_DOUBLE
+};
+
+enum class domain {
+    REAL = DFTI_REAL,
+    COMPLEX = DFTI_COMPLEX
+};
+
+enum class config_param {
+    FORWARD_DOMAIN                          = DFTI_FORWARD_DOMAIN,
+    DIMENSION                               = DFTI_DIMENSION,
+    LENGTHS                                 = DFTI_LENGTHS,
+    PRECISION                               = DFTI_PRECISION,
+    FORWARD_SCALE                           = DFTI_FORWARD_SCALE,
+    BACKWARD_SCALE                          = DFTI_BACKWARD_SCALE,
+    NUMBER_OF_TRANSFORMS                    = DFTI_NUMBER_OF_TRANSFORMS,
+    COMPLEX_STORAGE                         = DFTI_COMPLEX_STORAGE,
+    CONJUGATE_EVEN_STORAGE  [[deprecated]]  = DFTI_CONJUGATE_EVEN_STORAGE,
+    PLACEMENT                               = DFTI_PLACEMENT,
+    INPUT_STRIDES           [[deprecated("Use FWD/BWD strides instead.")]]
+                                            = DFTI_INPUT_STRIDES,
+    OUTPUT_STRIDES          [[deprecated("Use FWD/BWD strides instead.")]]
+                                            = DFTI_OUTPUT_STRIDES,
+    FWD_DISTANCE                            = DFTI_FWD_DISTANCE,
+    BWD_DISTANCE                            = DFTI_BWD_DISTANCE,
+    WORKSPACE                               = DFTI_WORKSPACE,
+    PACKED_FORMAT           [[deprecated]]  = DFTI_PACKED_FORMAT,
+    COMMIT_STATUS                           = DFTI_COMMIT_STATUS,
+    VERSION                 [[deprecated]]  = DFTI_VERSION,
+    THREAD_LIMIT                            = DFTI_THREAD_LIMIT,
+    DESTROY_INPUT                           = DFTI_DESTROY_INPUT,
+    WORKSPACE_ESTIMATE_BYTES,
+    WORKSPACE_BYTES,
+    FWD_STRIDES,
+    BWD_STRIDES,
+    WORKSPACE_PLACEMENT,        // alias for WORKSPACE
+    WORKSPACE_EXTERNAL_BYTES    // alias for WORKSPACE_BYTES
+};
+
+enum class config_value {
+    COMMITTED                               = DFTI_COMMITTED,
+    UNCOMMITTED                             = DFTI_UNCOMMITTED,
+    COMPLEX_COMPLEX                         = DFTI_COMPLEX_COMPLEX,
+    REAL_REAL                               = DFTI_REAL_REAL,
+    INPLACE                                 = DFTI_INPLACE,
+    NOT_INPLACE                             = DFTI_NOT_INPLACE,
+    WORKSPACE_AUTOMATIC,            // alias for WORKSPACE_INTERNAL
+    COMPLEX_REAL            [[deprecated]]  = DFTI_COMPLEX_REAL,
+    ALLOW                                   = DFTI_ALLOW,
+    AVOID                                   = DFTI_AVOID,
+    CCE_FORMAT              [[deprecated]]  = DFTI_CCE_FORMAT,
+    PERM_FORMAT             [[deprecated]]  = DFTI_PERM_FORMAT,
+    PACK_FORMAT             [[deprecated]]  = DFTI_PACK_FORMAT,
+    CCS_FORMAT              [[deprecated]]  = DFTI_CCS_FORMAT,
+    WORKSPACE_INTERNAL,
+    WORKSPACE_EXTERNAL
+};
+
+// Compute functions which will be friends with the descriptor class
+template<typename descriptor_type, typename data_type>
+void compute_forward(
+    descriptor_type &desc,
+    sycl::buffer<data_type, 1> &inout);
+
+template<typename descriptor_type, typename input_type, typename output_type>
+void compute_forward(
+    descriptor_type &desc,
+    sycl::buffer<input_type, 1> &in,
+    sycl::buffer<output_type, 1> &out);
+
+template<typename descriptor_type, typename data_type>
+void compute_backward(
+    descriptor_type &desc,
+    sycl::buffer<data_type, 1> &inout);
+
+template<typename descriptor_type, typename input_type, typename output_type>
+void compute_backward(
+    descriptor_type &desc,
+    sycl::buffer<input_type, 1> &in,
+    sycl::buffer<output_type, 1> &out);
+
+template <typename descriptor_type, typename data_type>
+sycl::event compute_forward(
+    descriptor_type &desc,
+    data_type *inout,
+    const std::vector<sycl::event> &dependencies = {});
+
+template<typename descriptor_type, typename input_type, typename output_type>
+sycl::event compute_forward(
+    descriptor_type &desc,
+    input_type *in,
+    output_type *out,
+    const std::vector<sycl::event> &dependencies = {});
+
+template <typename descriptor_type, typename data_type>
+sycl::event compute_backward(
+    descriptor_type &desc,
+    data_type *inout,
+    const std::vector<sycl::event> &dependencies = {});
+
+template<typename descriptor_type, typename input_type, typename output_type>
+sycl::event compute_backward(
+    descriptor_type &desc,
+    input_type *in,
+    output_type *out,
+    const std::vector<sycl::event> &dependencies = {});
+
+template <precision prec, domain dom>
+class descriptor {
+    using real_scalar_t = std::conditional_t<prec == precision::DOUBLE, double, float>;
+ public:
+    // initializes the FFT description for a multi-dimensional FFT
+    descriptor(std::vector<std::int64_t> dimensions);
+    // initializes the FFT description for a one-dimensional FFT
+    descriptor(std::int64_t length);
+    ~descriptor();
+    descriptor(const descriptor&) = delete;
+    descriptor& operator=(const descriptor&) = delete;
+
+    void commit(sycl::queue &in);
+
+    // in place forward computation; buffer API
+    template <typename descriptor_type, typename data_type>
+    friend void compute_forward(
+        descriptor_type &desc,
+        sycl::buffer<data_type, 1> &inout);
+    // out of place forward computation; buffer API
+    template<typename descriptor_type, typename input_type, typename output_type>
+    friend void compute_forward(
+        descriptor_type &desc,
+        sycl::buffer<input_type, 1> &in,
+        sycl::buffer<output_type, 1> &out);
+    // in place backward computation; buffer API
+    template <typename descriptor_type, typename data_type>
+    friend void compute_backward(
+        descriptor_type &desc,
+        sycl::buffer<data_type, 1> &inout);
+    // out of place backward computation; buffer API
+    template<typename descriptor_type, typename input_type, typename output_type>
+    friend void compute_backward(
+        descriptor_type &desc,
+        sycl::buffer<input_type, 1> &in,
+        sycl::buffer<output_type, 1> &out);
+    // in place forward computation; USM API
+    template <typename descriptor_type, typename data_type>
+    friend sycl::event compute_forward(
+        descriptor_type &desc,
+        data_type *inout,
+        const std::vector<sycl::event> &dependencies);
+    // out of place forward computation; USM API
+    template<typename descriptor_type, typename input_type, typename output_type>
+    friend sycl::event compute_forward(
+        descriptor_type &desc,
+        input_type *in,
+        output_type *out,
+        const std::vector<sycl::event> &dependencies);
+    // in place backward computation; USM API
+    template <typename descriptor_type, typename data_type>
+    friend sycl::event compute_backward(
+        descriptor_type &desc,
+        data_type *inout,
+        const std::vector<sycl::event> &dependencies);
+    // out of place backward computation; USM API
+    template<typename descriptor_type, typename input_type, typename output_type>
+    friend sycl::event compute_backward(
+        descriptor_type &desc,
+        input_type *in,
+        output_type *out,
+        const std::vector<sycl::event> &dependencies);
+
+    // configuration-setting member functions:
+    [[deprecated("Use set_value(config_param, config_value) instead.")]]
+    void set_value(config_param, DFTI_CONFIG_VALUE);
+    void set_value(config_param, config_value);
+    void set_value(config_param, std::int64_t);
+    void set_value(config_param, real_scalar_t);
+    [[deprecated("Use set_value(config_param, const std::vector<std::int64_t>&) instead.")]]
+    void set_value(config_param, const std::int64_t*);
+    void set_value(config_param, const std::vector<std::int64_t>&);
+    template <typename T, std::enable_if_t<std::is_integral_v<T>, bool> = true>
+    void set_value(config_param param, T value) {
+        set_value(param, static_cast<std::int64_t>(value));
+    }
+    template <typename T, std::enable_if_t<std::is_floating_point_v<T>, bool> = true>
+    void set_value(config_param param, T value) {
+        set_value(param, static_cast<real_scalar_t>(value));
+    }
+    [[deprecated("This set_value member function is deprecated.")]]
+    void set_value(config_param, ...);
+    // configuration-querying member functions:
+    [[deprecated("Use MKL_Get_Version_String(char*, int) instead.")]]
+    void get_value(config_param, char*) const;
+    [[deprecated("Use get_value(config_param, config_value*), "
+                 "get_value(config_param, domain*) or "
+                 "get_value(config_param, precision*) instead.")]]
+    void get_value(config_param, DFTI_CONFIG_VALUE*) const;
+    void get_value(config_param, config_value*) const;
+    void get_value(config_param, domain*) const;
+    void get_value(config_param, precision*) const;
+    [[deprecated("Use get_value(config_param, std::int64_t*) instead.")]]
+    void get_value(config_param, size_t*) const;
+    void get_value(config_param, std::int64_t*) const;
+    void get_value(config_param, real_scalar_t*) const;
+    void get_value(config_param, std::vector<std::int64_t>*) const;
+    [[deprecated("This get_value member function is deprecated.")]]
+    void get_value(config_param, ...) const;
+
+    template<typename data_type>
+    void set_workspace(sycl::buffer<data_type, 1> &workspace);
+    template<typename data_type>
+    void set_workspace(data_type *workspace);
+
+ private:
+    DFTI_DESCRIPTOR_HANDLE handle;
+    SYCL_DFTI_DESCRIPTOR_HANDLE device_handle;
+    sycl::buffer<SYCL_DFTI_DESCRIPTOR_HANDLE, 1> handle_buffer;
+};
+
+}  // namespace dft
+}  // namespace mkl
+} // namespace oneapi
+
+#endif  /* _DFT_HPP_ */

mkl_devel_dpcpp-2025.0.0.data/data/include/oneapi/mkl/dfti.hpp

@@ -0,0 +1,22 @@
+/*******************************************************************************
+* 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 _DFTI_HPP_
+#define _DFTI_HPP_
+
+#warning "Header 'oneapi/mkl/dfti.hpp' is deprecated. Please use oneapi/mkl/dft.hpp instead"
+
+#include "oneapi/mkl/dft.hpp"
+
+#endif  /* _DFTI_HPP_ */

mkl_devel_dpcpp-2025.0.0.data/data/include/oneapi/mkl/exceptions.hpp

@@ -0,0 +1,110 @@
+/*******************************************************************************
+* Copyright 2020-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 _MKL_EXCEPTIONS_HPP__
+#define _MKL_EXCEPTIONS_HPP__
+
+#include <exception>
+#include <string>
+#include <sycl/sycl.hpp>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wweak-vtables"
+
+namespace oneapi {
+namespace mkl {
+    class exception : public std::exception {
+        std::string msg_;
+        public:
+            exception(const std::string &domain = "", const std::string &function = "", const std::string &info = "") : std::exception() {
+                msg_ = "oneapi::mkl";
+
+                if (0 != domain.length() && 0 != function.length()) {
+                    msg_ += "::" + domain + "::" + function;
+                } else if (0 != domain.length() && 0 == function.length()) {
+                    msg_ += "::" + domain;
+                } else if (0 == domain.length() && 0 != function.length()) {
+                    msg_ += "::" + function;
+                }
+                if (0 != info.length()) { msg_ += ": " + info; }
+            }
+
+            const char* what() const noexcept override {
+                return msg_.c_str();
+            }
+    };
+
+    class unsupported_device : public oneapi::mkl::exception {
+        public:
+            unsupported_device(const std::string &domain, const std::string &function, const sycl::device &device)
+                : oneapi::mkl::exception(domain, function, "unsupported device: "+device.get_info<sycl::info::device::name>()) {
+            }
+    };
+
+    class host_bad_alloc : public oneapi::mkl::exception {
+        public:
+            host_bad_alloc(const std::string &domain, const std::string &function)
+                : oneapi::mkl::exception(domain, function, "cannot allocate memory on host") {
+            }
+    };
+
+    class device_bad_alloc : public oneapi::mkl::exception {
+        public:
+            device_bad_alloc(const std::string &domain, const std::string &function, const sycl::device &device)
+                : oneapi::mkl::exception(domain, function, "cannot allocate memory on "+device.get_info<sycl::info::device::name>()) {
+            }
+    };
+
+    class unimplemented : public oneapi::mkl::exception {
+        public:
+            unimplemented(const std::string &domain, const std::string &function, const std::string &info = "")
+                : oneapi::mkl::exception(domain, function, "unimplemented functionality"+((info.length() !=0) ? (": "+info) : "")) {
+            }
+    };
+
+    class invalid_argument : public oneapi::mkl::exception {
+        public:
+            invalid_argument(const std::string &domain, const std::string &function, const std::string &info = "")
+                : oneapi::mkl::exception(domain, function, "invalid argument"+((info.length() !=0) ? (": "+info) : "")) {
+            }
+    };
+
+    class uninitialized : public oneapi::mkl::exception {
+        public:
+            uninitialized(const std::string &domain, const std::string &function, const std::string &info = "")
+                : oneapi::mkl::exception(domain, function, "uninitialized object"+((info.length() !=0) ? (": "+info) : "")) {
+            }
+    };
+
+    class computation_error : public oneapi::mkl::exception {
+        public:
+            computation_error(const std::string &domain, const std::string &function, const std::string &info = "")
+                : oneapi::mkl::exception(domain, function, "computation error"+((info.length() != 0) ? (": "+info) : "")) {
+            }
+    };
+
+    class batch_error : public oneapi::mkl::exception {
+        public:
+            batch_error(const std::string &domain, const std::string &function, const std::string &info = "")
+                : oneapi::mkl::exception(domain, function, "batch error"+((info.length() != 0) ? (": "+info) : "")) {
+            }
+    };
+
+} // namespace mkl
+} // namespace oneapi
+
+#pragma clang diagnostic pop
+
+#endif // _MKL_EXCEPTIONS_HPP__
+

mkl_devel_dpcpp-2025.0.0.data/data/include/oneapi/mkl/experimental/data_fitting/interpolate.hpp

@@ -0,0 +1,67 @@
+/*******************************************************************************
+* Copyright 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 __DATA_FITTING_INTERPOLATE_HPP__
+#define __DATA_FITTING_INTERPOLATE_HPP__
+
+#include <cstdint>
+#include <vector>
+#include <bitset>
+
+#include <sycl/sycl.hpp>
+
+#include "oneapi/mkl/exceptions.hpp"
+#include "oneapi/mkl/experimental/data_fitting/spline_and_data_params.hpp"
+
+namespace oneapi::mkl::experimental::data_fitting {
+
+// Each bit in der_indicator indicates if we need to compute corresponding derivative or not.
+// E.g., der_indicator=0x1 - means that we need only function values,
+// der_indicator=0x2 - only 1-st derivative, der_indicator=5 - function value and 2nd derivative.
+
+// Interpolant is taken by non-const reference because non-const Interpolant's function members are called
+template <typename Interpolant>
+sycl::event interpolate(Interpolant& interpolant, typename Interpolant::fp_type* sites,
+                        std::int64_t n_sites, typename Interpolant::fp_type* results,
+                        std::bitset<32> der_indicator, const std::vector<sycl::event>& dependencies = {},
+                        interpolate_hint result_hint = interpolate_hint::funcs_sites_ders,
+                        site_hint SiteHint = site_hint::non_uniform);
+
+// Interpolant is taken by non-const reference because non-const Interpolant's function members are called
+template <typename Interpolant>
+sycl::event interpolate(Interpolant& interpolant, typename Interpolant::fp_type* sites,
+                        std::int64_t n_sites, typename Interpolant::fp_type* results,
+                        const std::vector<sycl::event>& dependencies = {},
+                        interpolate_hint result_hint = interpolate_hint::funcs_sites_ders,
+                        site_hint SiteHint = site_hint::non_uniform);
+
+template <typename Interpolant>
+sycl::event interpolate(sycl::queue& q, const Interpolant& interpolant,
+                        typename Interpolant::fp_type* sites, std::int64_t n_sites,
+                        typename Interpolant::fp_type* results,
+                        std::bitset<32> der_indicator, const std::vector<sycl::event>& dependencies = {},
+                        interpolate_hint result_hint = interpolate_hint::funcs_sites_ders,
+                        site_hint SiteHint = site_hint::non_uniform);
+
+template <typename Interpolant>
+sycl::event interpolate(sycl::queue& q, const Interpolant& interpolant,
+                        typename Interpolant::fp_type* sites, std::int64_t n_sites,
+                        typename Interpolant::fp_type* results,
+                        const std::vector<sycl::event>& dependencies = {},
+                        interpolate_hint result_hint = interpolate_hint::funcs_sites_ders,
+                        site_hint SiteHint = site_hint::non_uniform);
+
+} // namespace oneapi::mkl::experimental::data_fitting
+
+#endif // __DATA_FITTING_INTERPOLATE_HPP__

mkl_devel_dpcpp-2025.0.0.data/data/include/oneapi/mkl/experimental/data_fitting/spline_and_data_params.hpp

@@ -0,0 +1,68 @@
+/*******************************************************************************
+* Copyright 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 __SPLINE_AND_DATA_PARAMS__
+#define __SPLINE_AND_DATA_PARAMS__
+
+#include <cstdint>
+
+namespace oneapi::mkl::experimental::data_fitting {
+
+enum class partition_hint : std::int64_t { non_uniform = 0x1, quasi_uniform = 0x2, uniform = 0x4 };
+
+enum class function_hint : std::int64_t {
+    row_major = INT64_C(0x10),
+    col_major = INT64_C(0x20)
+};
+
+enum class coefficient_hint : std::int64_t {
+    row_major = INT64_C(0x10),
+    col_major = INT64_C(0x20)
+};
+
+enum class interpolate_hint : std::int64_t {
+    funcs_sites_ders = INT64_C(0x10),
+    funcs_ders_sites = INT64_C(0x20),
+    sites_funcs_ders = INT64_C(0x100),
+    sites_ders_funcs = INT64_C(0x200)
+};
+
+enum class bc_type : std::int64_t {
+    free_end = INT64_C(0x2),
+    first_left_der = INT64_C(0x4),
+    first_right_der = INT64_C(0x8),
+    second_left_der = INT64_C(0x10),
+    second_right_der = INT64_C(0x20),
+    periodic = INT64_C(0x40)
+};
+
+enum class site_hint : std::int64_t { non_uniform = INT64_C(0x1), uniform = INT64_C(0x4), sorted = INT64_C(0x40) };
+
+namespace linear_spline {
+struct default_type {};
+} // namespace linear_spline
+
+namespace cubic_spline {
+struct hermite {};
+} // namespace cubic_spline
+
+enum class derivatives : std::int32_t { zero = INT32_C(0x1), first = INT32_C(0x2), second = INT32_C(0x4), third = INT32_C(0x8) };
+
+inline std::int32_t operator|(derivatives lhs, derivatives rhs) {
+    return (static_cast<std::int32_t>(lhs) | static_cast<std::int32_t>(rhs));
+}
+
+} // namespace oneapi::mkl::experimental::data_fitting
+
+#endif // __SPLINE_AND_DATA_PARAMS__