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/experimental/data_fitting/splines.hpp

@@ -0,0 +1,177 @@
+/*******************************************************************************
+* 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_SPLINES_HPP__
+#define __DATA_FITTING_SPLINES_HPP__
+
+#include <cstdint>
+#include <memory>
+#include <vector>
+#include <type_traits>
+#include <bitset>
+
+#include <sycl/sycl.hpp>
+
+#include "oneapi/mkl/export.hpp"
+#include "oneapi/mkl/exceptions.hpp"
+#include "oneapi/mkl/experimental/data_fitting/spline_and_data_params.hpp"
+
+namespace oneapi::mkl::experimental::data_fitting {
+
+namespace detail {
+
+template <typename FpType, typename SplineType, int Dimensions>
+class spline_base;
+
+} // namespace detail
+
+template <typename FpType, typename SplineType, int Dimensions = 1>
+class spline;
+
+template <typename FpType, int Dimensions>
+class spline<FpType, linear_spline::default_type, Dimensions> {
+public:
+    static_assert(1 == Dimensions, "Only 1D splines are supported");
+    static_assert(std::is_same_v<float, FpType> || std::is_same_v<double, FpType>,
+                  "Only float/double types are supported for FpType template parameter of spline");
+    using spline_type = linear_spline::default_type;
+    using fp_type = FpType;
+
+    // copy ctor and assignment operator were deleted since we don't want
+    // to perform deep copy of data and responsibility of memory management is on user's side
+    spline(const sycl::queue& q, std::int64_t ny = 1, bool were_coeffs_computed = false);
+    spline(const sycl::device& dev, const sycl::context& ctx, std::int64_t ny = 1,
+           bool were_coeffs_computed = false);
+
+    spline(spline<FpType, linear_spline::default_type, Dimensions>&& other) = delete;
+
+    spline(const spline<FpType, linear_spline::default_type, Dimensions>& other) = delete;
+
+    spline<FpType, linear_spline::default_type, Dimensions>& operator=(
+        const spline<FpType, linear_spline::default_type, Dimensions>& other) = delete;
+
+    spline<FpType, linear_spline::default_type, Dimensions>& operator=(
+        spline<FpType, linear_spline::default_type, Dimensions>&& other) = delete;
+    ~spline();
+
+    spline<FpType, linear_spline::default_type, Dimensions>& set_partitions(
+        FpType* data, std::int64_t nx, partition_hint PartitionHint = partition_hint::non_uniform);
+
+    spline<FpType, linear_spline::default_type, Dimensions>& set_coefficients(
+        FpType* data, coefficient_hint CoeffHint = coefficient_hint::row_major);
+    // in case of first coordinate will be called inside loop
+    spline<FpType, linear_spline::default_type, Dimensions>& set_function_values(
+        FpType* data, function_hint FunctionHint = function_hint::row_major);
+
+    bool is_initialized() const;
+
+    std::int64_t get_required_coeffs_size() const;
+
+    sycl::event construct(
+        const std::vector<sycl::event>&
+            dependencies = {});
+
+private:
+    std::unique_ptr<detail::spline_base<FpType, linear_spline::default_type, Dimensions>> impl_;
+
+    template <typename Interpolant>
+    friend sycl::event interpolate(Interpolant&, typename Interpolant::fp_type*, std::int64_t,
+                                   typename Interpolant::fp_type*, std::bitset<32>,
+                                   const std::vector<sycl::event>&, interpolate_hint, site_hint);
+    template <typename Interpolant>
+    friend sycl::event interpolate(Interpolant&, typename Interpolant::fp_type*, std::int64_t,
+                                   typename Interpolant::fp_type*, const std::vector<sycl::event>&,
+                                   interpolate_hint, site_hint);
+    template <typename Interpolant>
+    friend sycl::event interpolate(sycl::queue&, const Interpolant&, typename Interpolant::fp_type*,
+                                   std::int64_t, typename Interpolant::fp_type*, std::bitset<32>,
+                                   const std::vector<sycl::event>&, interpolate_hint,
+                                   site_hint);
+    template <typename Interpolant>
+    friend sycl::event interpolate(sycl::queue&, const Interpolant&, typename Interpolant::fp_type*,
+                                   std::int64_t, typename Interpolant::fp_type*,
+                                   const std::vector<sycl::event>&, interpolate_hint, site_hint);
+};
+
+template <typename FpType, int Dimensions>
+class spline<FpType, cubic_spline::hermite, Dimensions> {
+public:
+    static_assert(1 == Dimensions, "Only 1D splines are supported");
+    static_assert(std::is_same_v<float, FpType> || std::is_same_v<double, FpType>,
+                  "Only float/double types are supported for FpType template parameter of spline");
+    using spline_type = cubic_spline::hermite;
+    using fp_type = FpType;
+
+    // copy ctor and assignment operator were deleted since we don't want
+    // to perform deep copy of data and responsibility of memory management is on user's side
+    spline(const sycl::queue& q, std::int64_t ny = 1, bool were_coeffs_computed = false);
+    spline(const sycl::device& dev, const sycl::context& ctx, std::int64_t ny = 1,
+           bool were_coeffs_computed = false);
+
+    spline(spline<FpType, cubic_spline::hermite, Dimensions>&& other) = delete;
+
+    spline(const spline<FpType, cubic_spline::hermite, Dimensions>& other) = delete;
+
+    spline<FpType, cubic_spline::hermite, Dimensions>& operator=(
+        const spline<FpType, cubic_spline::hermite, Dimensions>& other) = delete;
+
+    spline<FpType, cubic_spline::hermite, Dimensions>& operator=(
+        spline<FpType, cubic_spline::hermite, Dimensions>&& other) = delete;
+    ~spline();
+
+    spline<FpType, cubic_spline::hermite, Dimensions>& set_partitions(
+        FpType* data, std::int64_t nx, partition_hint PartitionHint = partition_hint::non_uniform);
+
+    spline<FpType, cubic_spline::hermite, Dimensions>& set_coefficients(
+        FpType* data, coefficient_hint CoeffHint = coefficient_hint::row_major);
+    // in case of first coordinate will be called inside loop
+    spline<FpType, cubic_spline::hermite, Dimensions>& set_function_values(
+        FpType* data, function_hint FunctionHint = function_hint::row_major);
+    spline<FpType, cubic_spline::hermite, Dimensions>& set_internal_conditions(FpType* data);
+    spline<FpType, cubic_spline::hermite, Dimensions>& set_boundary_conditions(
+        bc_type BCType = bc_type::free_end, FpType value = 0.0);
+
+    bool is_initialized() const;
+
+    std::int64_t get_required_coeffs_size() const;
+
+    sycl::event construct(
+        const std::vector<sycl::event>&
+            dependencies = {});
+
+private:
+    std::unique_ptr<detail::spline_base<FpType, cubic_spline::hermite, Dimensions>> impl_;
+
+    template <typename Interpolant>
+    friend sycl::event interpolate(Interpolant&, typename Interpolant::fp_type*, std::int64_t,
+                                   typename Interpolant::fp_type*, std::bitset<32>,
+                                   const std::vector<sycl::event>&, interpolate_hint, site_hint);
+    template <typename Interpolant>
+    friend sycl::event interpolate(Interpolant&, typename Interpolant::fp_type*, std::int64_t,
+                                   typename Interpolant::fp_type*, const std::vector<sycl::event>&,
+                                   interpolate_hint, site_hint);
+    template <typename Interpolant>
+    friend sycl::event interpolate(sycl::queue&, const Interpolant&, typename Interpolant::fp_type*,
+                                   std::int64_t, typename Interpolant::fp_type*, std::bitset<32>,
+                                   const std::vector<sycl::event>&, interpolate_hint,
+                                   site_hint);
+    template <typename Interpolant>
+    friend sycl::event interpolate(sycl::queue&, const Interpolant&, typename Interpolant::fp_type*,
+                                   std::int64_t, typename Interpolant::fp_type*,
+                                   const std::vector<sycl::event>&, interpolate_hint, site_hint);
+};
+
+} // namespace oneapi::mkl::experimental::data_fitting
+
+#endif // __DATA_FITTING_SPLINES_HPP__

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

@@ -0,0 +1,22 @@
+/*******************************************************************************
+* 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_HPP__
+#define __DATA_FITTING_HPP__
+
+#include "oneapi/mkl/experimental/data_fitting/splines.hpp"
+#include "oneapi/mkl/experimental/data_fitting/interpolate.hpp"
+#include "oneapi/mkl/experimental/data_fitting/spline_and_data_params.hpp"
+
+#endif // __DATA_FITTING_HPP__

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

@@ -0,0 +1,25 @@
+/*******************************************************************************
+* 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 _EXPORT_HPP__
+#define _EXPORT_HPP__
+
+#ifdef MKL_BUILD_DLL
+/* Build attribute on Windows */
+#define DLL_EXPORT __declspec(dllexport)
+#else
+#define DLL_EXPORT
+#endif
+
+#endif

mkl_devel_dpcpp-2025.0.0.data/data/include/oneapi/mkl/lapack/concepts.hpp

@@ -0,0 +1,55 @@
+/*******************************************************************************
+* 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 _ONEAPI_MKL_LAPACK_CONCEPTS_HPP__
+#define _ONEAPI_MKL_LAPACK_CONCEPTS_HPP__
+
+#include <complex>
+
+namespace oneapi {
+namespace mkl {
+namespace lapack {
+
+namespace internal
+
+{
+    template <bool, typename T=void> struct enable_if;
+    template <typename T> struct is_fp;
+    template <typename T> struct is_rfp;
+    template <typename T> struct is_cfp;
+    template <typename fp> using is_floating_point         = typename enable_if<is_fp<fp>::value>::type*;
+    template <typename fp> using is_real_floating_point    = typename enable_if<is_rfp<fp>::value>::type*;
+    template <typename fp> using is_complex_floating_point = typename enable_if<is_cfp<fp>::value>::type*;
+
+    // auxiliary typechecking templates
+    template<typename T>
+    struct enable_if<true,T> { using type = T; };
+
+    template<> struct is_fp<float>                { static constexpr bool value{true}; };
+    template<> struct is_fp<double>               { static constexpr bool value{true}; };
+    template<> struct is_fp<std::complex<float>>  { static constexpr bool value{true}; };
+    template<> struct is_fp<std::complex<double>> { static constexpr bool value{true}; };
+
+    template<> struct is_rfp<float>  { static constexpr bool value{true}; };
+    template<> struct is_rfp<double> { static constexpr bool value{true}; };
+
+    template<> struct is_cfp<std::complex<float>>  { static constexpr bool value{true}; };
+    template<> struct is_cfp<std::complex<double>> { static constexpr bool value{true}; };
+}
+
+} //namespace lapack
+} //namespace mkl
+} // namespace oneapi
+
+#endif // _ONEAPI_MKL_LAPACK_CONCEPTS_HPP__

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

@@ -0,0 +1,75 @@
+/*******************************************************************************
+* 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 _ONEAPI_MKL_LAPACK_EXCEPTIONS_HPP__
+#define _ONEAPI_MKL_LAPACK_EXCEPTIONS_HPP__
+
+#include <exception>
+#include "oneapi/mkl/export.hpp"
+#include "oneapi/mkl/exceptions.hpp"
+
+namespace oneapi {
+namespace mkl {
+namespace lapack {
+
+class DLL_EXPORT exception
+{
+    public:
+        exception(mkl::exception *_ex, std::int64_t info, std::int64_t detail = 0) : _info(info), _detail(detail), _ex(_ex) {}
+        std::int64_t info()   const { return _info; }
+        std::int64_t detail() const { return _detail; }
+        const char*  what()   const { return _ex->what(); }
+    private:
+        std::int64_t   _info;
+        std::int64_t   _detail;
+        mkl::exception *_ex;
+};
+
+class DLL_EXPORT computation_error : public oneapi::mkl::computation_error, public oneapi::mkl::lapack::exception
+{
+    public:
+        computation_error(const std::string &function, const std::string &info, std::int64_t code)
+            : oneapi::mkl::computation_error("lapack", function, info), oneapi::mkl::lapack::exception(this, code) {}
+        virtual ~computation_error();
+        using oneapi::mkl::computation_error::what;
+};
+
+class DLL_EXPORT batch_error : public oneapi::mkl::batch_error, public oneapi::mkl::lapack::exception
+{
+    public:
+        batch_error(const std::string &function, const std::string &info, std::int64_t num_errors, std::vector<std::int64_t> ids = {}, std::vector<std::exception_ptr> exceptions = {})
+            : oneapi::mkl::batch_error("lapack", function, info), oneapi::mkl::lapack::exception(this, num_errors), _ids(ids), _exceptions(exceptions) {}
+        virtual ~batch_error();
+        using oneapi::mkl::batch_error::what;
+        const std::vector<std::int64_t>& ids() const { return _ids; }
+        const std::vector<std::exception_ptr>& exceptions() const { return _exceptions; }
+    private:
+        std::vector<std::int64_t> _ids;
+        std::vector<std::exception_ptr> _exceptions;
+};
+
+class DLL_EXPORT invalid_argument : public oneapi::mkl::invalid_argument, public oneapi::mkl::lapack::exception
+{
+    public:
+        invalid_argument(const std::string &function, const std::string &info, std::int64_t arg_position = 0, std::int64_t detail = 0)
+            : oneapi::mkl::invalid_argument("lapack", function, info), oneapi::mkl::lapack::exception(this, arg_position, detail) {}
+        virtual ~invalid_argument();
+        using oneapi::mkl::invalid_argument::what;
+};
+
+} // namespace lapack
+} // namespace mkl
+} // namespace oneapi
+
+#endif // _ONEAPI_MKL_LAPACK_EXCEPTIONS_HPP__