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/stats.hpp

@@ -0,0 +1,356 @@
+/*******************************************************************************
+* 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 _STATS_HPP__
+#define _STATS_HPP__
+
+#include <type_traits>
+#include <vector>
+
+#include <sycl/sycl.hpp>
+
+#include "oneapi/mkl/export.hpp"
+#include "oneapi/mkl/exceptions.hpp"
+
+namespace oneapi {
+namespace mkl {
+namespace stats {
+
+enum class method : std::int64_t {
+    fast = 0x00000001,
+    one_pass = 0x00000002
+};
+
+
+enum class layout : std::int64_t {
+    row_major = 0x00010000,
+    col_major = 0x00020000
+};
+
+template<layout ObservationsLayout = layout::row_major, typename Type = float*>
+struct dataset {};
+
+// Specialization for USM API
+template<layout ObservationsLayout, typename Type>
+struct dataset<ObservationsLayout, Type*> {
+    static_assert(std::is_same<Type, float>::value | std::is_same<Type, double>::value,
+        "oneMKL: stats/dataset: template type is not supported");
+
+    // Constructor
+    explicit dataset(std::int64_t n_dims_, std::int64_t n_observations_, Type* observations_,
+                    Type* weights_ = nullptr, std::int64_t* indices_ = nullptr) :
+                    n_dims(n_dims_), n_observations(n_observations_), observations(observations_),
+                    weights(weights_), indices(indices_) {
+        if(n_dims_ <= 0) {
+            throw oneapi::mkl::invalid_argument("stats", "dataset", "number of dimensions <= 0");
+        }
+        if(n_observations_ <= 0) {
+            throw oneapi::mkl::invalid_argument("stats", "dataset", "number of observations <= 0");
+        }
+        if(observations_ == nullptr) {
+            throw oneapi::mkl::invalid_argument("stats", "dataset", "observations is nullptr");
+        }
+    };
+
+    std::int64_t n_dims;
+    std::int64_t n_observations;
+    Type* observations;
+    Type* weights = nullptr;
+    std::int64_t* indices = nullptr;
+    static constexpr oneapi::mkl::stats::layout layout = ObservationsLayout;
+};
+
+// Specialization for buffer-based API
+template<layout ObservationsLayout, typename Type>
+struct dataset<ObservationsLayout, sycl::buffer<Type, 1>> {
+    static_assert(std::is_same<Type, float>::value | std::is_same<Type, double>::value,
+        "oneMKL: stats/dataset: template type is not supported");
+
+    // Constructor
+    explicit dataset(std::int64_t n_dims_, std::int64_t n_observations_,
+                    sycl::buffer<Type, 1> observations_, sycl::buffer<Type, 1> weights_ = {0},
+                    sycl::buffer<std::int64_t, 1> indices_ = {0}) :
+                    n_dims(n_dims_), n_observations(n_observations_), observations(observations_),
+                    weights(weights_), indices(indices_) {
+        if(n_dims_ <= 0) {
+            throw oneapi::mkl::invalid_argument("stats", "dataset", "number of dimensions <= 0");
+        }
+        if(n_observations_ <= 0) {
+            throw oneapi::mkl::invalid_argument("stats", "dataset", "number of observations <= 0");
+        }
+        if(observations_.size() == 0) {
+            throw oneapi::mkl::invalid_argument("stats", "dataset", "observations is empty");
+        }
+    };
+
+    std::int64_t n_dims;
+    std::int64_t n_observations;
+    sycl::buffer<Type, 1> observations;
+    sycl::buffer<Type, 1> weights = {0};
+    sycl::buffer<std::int64_t, 1> indices = {0};
+    static constexpr oneapi::mkl::stats::layout layout = ObservationsLayout;
+};
+
+// Helper funtions to make dataset
+template<layout ObservationsLayout = layout::row_major, typename Type>
+dataset<ObservationsLayout, Type*> make_dataset(std::int64_t n_dims, std::int64_t n_observations,
+                                   Type* observations, Type* weights = nullptr,
+                                   std::int64_t* indices = nullptr) {
+    return dataset<ObservationsLayout, Type*>(n_dims, n_observations, observations, weights, indices);
+}
+
+
+template<layout ObservationsLayout = layout::row_major, typename Type>
+dataset<ObservationsLayout, sycl::buffer<Type, 1>> make_dataset(std::int64_t n_dims,
+                                    std::int64_t n_observations,
+                                    sycl::buffer<Type, 1> observations,
+                                    sycl::buffer<Type, 1> weights = {0},
+                                    sycl::buffer<std::int64_t, 1> indices = {0}) {
+    return dataset<ObservationsLayout, sycl::buffer<Type, 1>>(n_dims, n_observations,
+                                                        observations, weights, indices);
+}
+
+// Raw sum computation
+template<method Method = method::fast, typename Type, layout ObservationsLayout>
+void raw_sum(sycl::queue& queue,
+    const dataset<ObservationsLayout, sycl::buffer<Type, 1>>& data,
+    sycl::buffer<Type, 1> sum,
+    sycl::buffer<Type, 1> raw_sum_2 = {0},
+    sycl::buffer<Type, 1> raw_sum_3 = {0},
+    sycl::buffer<Type, 1> raw_sum_4 = {0});
+
+template<method Method = method::fast, typename Type, layout ObservationsLayout>
+sycl::event raw_sum(sycl::queue& queue,
+    const dataset<ObservationsLayout, Type*>& data,
+    Type* sum,
+    Type* raw_sum_2 = nullptr,
+    Type* raw_sum_3 = nullptr,
+    Type* raw_sum_4 = nullptr,
+    const std::vector<sycl::event> &dependencies = {});
+
+// Central sum computation
+template<method Method = method::fast, typename Type, layout ObservationsLayout>
+void central_sum(sycl::queue& queue,
+    const dataset<ObservationsLayout, sycl::buffer<Type, 1>>& data,
+    sycl::buffer<Type, 1> central_sum_2,
+    sycl::buffer<Type, 1> central_sum_3 = {0},
+    sycl::buffer<Type, 1> central_sum_4 = {0});
+
+template<method Method = method::fast, typename Type, layout ObservationsLayout>
+sycl::event central_sum(sycl::queue& queue,
+    const dataset<ObservationsLayout, Type*>& data,
+    Type* central_sum_2,
+    Type* central_sum_3 = nullptr,
+    Type* central_sum_4 = nullptr,
+    const std::vector<sycl::event> &dependencies = {});
+
+// Central sum with user mean
+template<method Method = method::fast, typename Type, layout ObservationsLayout>
+void central_sum(sycl::queue& queue,
+    sycl::buffer<Type, 1> mean,
+    const dataset<ObservationsLayout, sycl::buffer<Type, 1>>& data,
+    sycl::buffer<Type, 1> central_sum_2,
+    sycl::buffer<Type, 1> central_sum_3 = {0},
+    sycl::buffer<Type, 1> central_sum_4 = {0});
+
+template<method Method = method::fast, typename Type, layout ObservationsLayout>
+sycl::event central_sum(sycl::queue& queue,
+    Type* mean,
+    const dataset<ObservationsLayout, Type*>& data,
+    Type* central_sum_2,
+    Type* central_sum_3 = nullptr,
+    Type* central_sum_4 = nullptr,
+    const std::vector<sycl::event> &dependencies = {});
+
+// Raw moment
+template<method Method = method::fast, typename Type, layout ObservationsLayout>
+void raw_moment(sycl::queue& queue,
+    const dataset<ObservationsLayout, sycl::buffer<Type, 1>>& data,
+    sycl::buffer<Type, 1> mean,
+    sycl::buffer<Type, 1> raw_moment_2 = {0},
+    sycl::buffer<Type, 1> raw_moment_3 = {0},
+    sycl::buffer<Type, 1> raw_moment_4 = {0});
+
+template<method Method = method::fast, typename Type, layout ObservationsLayout>
+sycl::event raw_moment(sycl::queue& queue,
+    const dataset<ObservationsLayout, Type*>& data,
+    Type* mean,
+    Type* raw_moment_2 = nullptr,
+    Type* raw_moment_3 = nullptr,
+    Type* raw_moment_4 = nullptr,
+    const std::vector<sycl::event> &dependencies = {});
+
+// Central moment computation
+template<method Method = method::fast, typename Type, layout ObservationsLayout>
+void central_moment(sycl::queue& queue,
+    const dataset<ObservationsLayout, sycl::buffer<Type, 1>>& data,
+    sycl::buffer<Type, 1> central_moment_2,
+    sycl::buffer<Type, 1> central_moment_3 = {0},
+    sycl::buffer<Type, 1> central_moment_4 = {0});
+
+template<method Method = method::fast, typename Type, layout ObservationsLayout>
+sycl::event central_moment(sycl::queue& queue,
+    const dataset<ObservationsLayout, Type*>& data,
+    Type* central_moment_2,
+    Type* central_moment_3 = nullptr,
+    Type* central_moment_4 = nullptr,
+    const std::vector<sycl::event> &dependencies = {});
+
+// Central moment with user mean
+template<method Method = method::fast, typename Type, layout ObservationsLayout>
+void central_moment(sycl::queue& queue,
+    sycl::buffer<Type, 1> mean,
+    const dataset<ObservationsLayout, sycl::buffer<Type, 1>>& data,
+    sycl::buffer<Type, 1> central_moment_2,
+    sycl::buffer<Type, 1> central_moment_3 = {0},
+    sycl::buffer<Type, 1> central_moment_4 = {0});
+
+template<method Method = method::fast, typename Type, layout ObservationsLayout>
+sycl::event central_moment(sycl::queue& queue,
+    Type* mean,
+    const dataset<ObservationsLayout, Type*>& data,
+    Type* central_moment_2,
+    Type* central_moment_3 = nullptr,
+    Type* central_moment_4 = nullptr,
+    const std::vector<sycl::event> &dependencies = {});
+
+// Mean computation
+template<method Method = method::fast, typename Type, layout ObservationsLayout>
+void mean(sycl::queue& queue,
+    const dataset<ObservationsLayout, sycl::buffer<Type, 1>>& data,
+    sycl::buffer<Type, 1> mean);
+
+template<method Method = method::fast, typename Type, layout ObservationsLayout>
+sycl::event mean(sycl::queue& queue,
+    const dataset<ObservationsLayout, Type*>& data,
+    Type* mean,
+    const std::vector<sycl::event> &dependencies = {});
+
+// Variation computation
+template<method Method = method::fast, typename Type, layout ObservationsLayout>
+void variation(sycl::queue& queue,
+    const dataset<ObservationsLayout, sycl::buffer<Type, 1>>& data,
+    sycl::buffer<Type, 1> variation);
+
+template<method Method = method::fast, typename Type, layout ObservationsLayout>
+sycl::event variation(sycl::queue& queue,
+    const dataset<ObservationsLayout, Type*>& data,
+    Type* variation,
+    const std::vector<sycl::event> &dependencies = {});
+
+template<method Method = method::fast, typename Type, layout ObservationsLayout>
+void variation(sycl::queue& queue,
+    sycl::buffer<Type, 1> mean,
+    const dataset<ObservationsLayout, sycl::buffer<Type, 1>>& data,
+    sycl::buffer<Type, 1> variation);
+
+template<method Method = method::fast, typename Type, layout ObservationsLayout>
+sycl::event variation(sycl::queue& queue,
+    Type* mean,
+    const dataset<ObservationsLayout, Type*>& data,
+    Type* variation,
+    const std::vector<sycl::event> &dependencies = {});
+
+// Skewness computation
+template<method Method = method::fast, typename Type, layout ObservationsLayout>
+void skewness(sycl::queue& queue,
+    const dataset<ObservationsLayout, sycl::buffer<Type, 1>>& data,
+    sycl::buffer<Type, 1> skewness);
+
+template<method Method = method::fast, typename Type, layout ObservationsLayout>
+sycl::event skewness(sycl::queue& queue,
+    const dataset<ObservationsLayout, Type*>& data,
+    Type* skewness,
+    const std::vector<sycl::event> &dependencies = {});
+
+// Skewness computation for user-defined mean
+template<method Method = method::fast, typename Type, layout ObservationsLayout>
+void skewness(sycl::queue& queue,
+    sycl::buffer<Type, 1> mean,
+    const dataset<ObservationsLayout, sycl::buffer<Type, 1>>& data,
+    sycl::buffer<Type, 1> skewness);
+
+template<method Method = method::fast, typename Type, layout ObservationsLayout>
+sycl::event skewness(sycl::queue& queue,
+    Type* mean,
+    const dataset<ObservationsLayout, Type*>& data,
+    Type* skewness,
+    const std::vector<sycl::event> &dependencies = {});
+
+// Kurtosis computation
+template<method Method = method::fast, typename Type, layout ObservationsLayout>
+void kurtosis(sycl::queue& queue,
+    const dataset<ObservationsLayout, sycl::buffer<Type, 1>>& data,
+    sycl::buffer<Type, 1> kurtosis);
+
+template<method Method = method::fast, typename Type, layout ObservationsLayout>
+sycl::event kurtosis(sycl::queue& queue,
+    const dataset<ObservationsLayout, Type*>& data,
+    Type* kurtosis,
+    const std::vector<sycl::event> &dependencies = {});
+
+template<method Method = method::fast, typename Type, layout ObservationsLayout>
+void kurtosis(sycl::queue& queue,
+    sycl::buffer<Type, 1> mean,
+    const dataset<ObservationsLayout, sycl::buffer<Type, 1>>& data,
+    sycl::buffer<Type, 1> kurtosis);
+
+template<method Method = method::fast, typename Type, layout ObservationsLayout>
+sycl::event kurtosis(sycl::queue& queue,
+    Type* mean,
+    const dataset<ObservationsLayout, Type*>& data,
+    Type* kurtosis,
+    const std::vector<sycl::event> &dependencies = {});
+
+// Min computation
+template<method Method = method::fast, typename Type, layout ObservationsLayout>
+void min(sycl::queue& queue,
+    const dataset<ObservationsLayout, sycl::buffer<Type, 1>>& data,
+    sycl::buffer<Type, 1> min);
+
+template<method Method = method::fast, typename Type, layout ObservationsLayout>
+sycl::event min(sycl::queue& queue,
+    const dataset<ObservationsLayout, Type*>& data,
+    Type* min,
+    const std::vector<sycl::event> &dependencies = {});
+
+// Max computation
+template<method Method = method::fast, typename Type, layout ObservationsLayout>
+void max(sycl::queue& queue,
+    const dataset<ObservationsLayout, sycl::buffer<Type, 1>>& data,
+    sycl::buffer<Type, 1> max);
+
+template<method Method = method::fast, typename Type, layout ObservationsLayout>
+sycl::event max(sycl::queue& queue,
+    const dataset<ObservationsLayout, Type*>& data,
+    Type* max,
+    const std::vector<sycl::event> &dependencies = {});
+
+// Min and Max computation
+template<method Method = method::fast, typename Type, layout ObservationsLayout>
+void min_max(sycl::queue& queue,
+    const dataset<ObservationsLayout, sycl::buffer<Type, 1>>& data,
+    sycl::buffer<Type, 1> min, sycl::buffer<Type, 1> max);
+
+template<method Method = method::fast, typename Type, layout ObservationsLayout>
+sycl::event min_max(sycl::queue& queue,
+    const dataset<ObservationsLayout, Type*>& data,
+    Type* min, Type* max,
+    const std::vector<sycl::event> &dependencies = {});
+
+} // stats
+} // mkl
+} // namespace oneapi
+
+#endif // _STATS_HPP__

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

@@ -0,0 +1,321 @@
+/*******************************************************************************
+* 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 _TYPES_HPP__
+#define _TYPES_HPP__
+
+#include <cstdint>
+#include <cstddef> // for std::size_t
+#include "mkl_types.h"
+#include "mkl_cblas.h"
+#include "oneapi/mkl/bfloat16.hpp"
+
+namespace oneapi {
+namespace mkl {
+
+
+// BLAS flag types.
+enum class transpose : char {
+    nontrans = 0,
+    trans = 1,
+    conjtrans = 3,
+    N = 0,
+    T = 1,
+    C = 3
+};
+
+enum class uplo : char {
+    upper = 0,
+    lower = 1,
+    U = 0,
+    L = 1
+};
+
+enum class diag : char {
+    nonunit = 0,
+    unit = 1,
+    N = 0,
+    U = 1
+};
+
+enum class side : char {
+    left = 0,
+    right = 1,
+    L = 0,
+    R = 1
+};
+
+enum class offset : char {
+    row = 0,
+    column = 1,
+    fix = 2,
+    R = 0,
+    C = 1,
+    F = 2
+};
+
+// LAPACK flag types.
+enum class job : char {
+    novec = 0,
+    vec = 1,
+    updatevec = 2,
+    allvec = 3,
+    somevec = 4,
+    overwritevec = 5,
+    N = 0,
+    V = 1,
+    U = 2,
+    A = 3,
+    S = 4,
+    O = 5
+};
+
+enum class generate : char {
+    q = 0,
+    p = 1,
+    none = 2,
+    both = 3,
+    Q = 0,
+    P = 1,
+    N = 2,
+    V = 3
+};
+
+enum class compz : char {
+    novectors = 0,
+    vectors = 1,
+    initvectors = 2,
+    N = 0,
+    V = 1,
+    I = 2,
+};
+
+enum class direct : char {
+    forward = 0,
+    backward = 1,
+    F = 0,
+    B = 1,
+};
+
+enum class storev : char {
+    columnwise = 0,
+    rowwise = 1,
+    C = 0,
+    R = 1,
+};
+
+enum class rangev : char {
+    all = 0,
+    values = 1,
+    indices = 2,
+    A = 0,
+    V = 1,
+    I = 2,
+};
+
+enum class order : char {
+    block = 0,
+    entire = 1,
+    B = 0,
+    E = 1,
+};
+
+enum class jobsvd : char {
+    novec = 0,
+    vectors = 1,
+    vectorsina = 2,
+    somevec = 3,
+    N = 0,
+    A = 1,
+    O = 2,
+    S = 3
+};
+// Conversion functions to traditional Fortran characters.
+inline const char * fortran_char(transpose t) {
+    if (t == transpose::nontrans)  return "N";
+    if (t == transpose::trans)     return "T";
+    if (t == transpose::conjtrans) return "C";
+    return "N";
+}
+
+inline const char * fortran_char(offset t) {
+    if (t == offset::fix)  return "F";
+    if (t == offset::row)  return "R";
+    if (t == offset::column)  return "C";
+    return "N";
+}
+
+inline const char * fortran_char(uplo u) {
+    if (u == uplo::upper) return "U";
+    if (u == uplo::lower) return "L";
+    return "U";
+}
+
+inline const char * fortran_char(diag d) {
+    if (d == diag::nonunit) return "N";
+    if (d == diag::unit)    return "U";
+    return "N";
+}
+
+inline const char * fortran_char(side s) {
+    if (s == side::left)  return "L";
+    if (s == side::right) return "R";
+    return "L";
+}
+
+inline const char * fortran_char(job j) {
+    if (j == job::novec)  return "N";
+    if (j == job::vec)  return "V";
+    if (j == job::updatevec)  return "U";
+    if (j == job::allvec)  return "A";
+    if (j == job::somevec)  return "S";
+    if (j == job::overwritevec)  return "O";
+    return "N";
+}
+inline const char * fortran_char(jobsvd j) {
+    if (j == jobsvd::novec)  return "N";
+    if (j == jobsvd::vectors)  return "A";
+    if (j == jobsvd::vectorsina)  return "O";
+    if (j == jobsvd::somevec)  return "S";
+    return "N";
+}
+
+inline const char * fortran_char(generate v) {
+    if (v == generate::q)  return "Q";
+    if (v == generate::p)  return "P";
+    if (v == generate::none)  return "N";
+    if (v == generate::both)  return "B";
+    return "Q";
+}
+
+inline const char * fortran_char(compz c) {
+    if (c == compz::vectors) return "V";
+    if (c == compz::initvectors) return "I";
+    return "N";
+}
+
+inline const char * fortran_char(direct d) {
+    if (d == direct::backward) return "B";
+    return "F";
+}
+
+inline const char * fortran_char(storev s) {
+    if (s == storev::rowwise) return "R";
+    return "C";
+}
+
+inline const char * fortran_char(rangev r) {
+    if (r == rangev::values) return "V";
+    if (r == rangev::indices) return "I";
+    return "A";
+}
+
+inline const char * fortran_char(order o) {
+    if (o == order::entire) return "E";
+    return "B";
+}
+
+// Conversion functions to CBLAS enums.
+inline MKL_TRANSPOSE cblas_convert(transpose t) {
+    if (t == transpose::nontrans)  return MKL_NOTRANS;
+    if (t == transpose::trans)     return MKL_TRANS;
+    if (t == transpose::conjtrans) return MKL_CONJTRANS;
+    return MKL_NOTRANS;
+}
+
+inline MKL_UPLO cblas_convert(uplo u) {
+    if (u == uplo::upper) return MKL_UPPER;
+    if (u == uplo::lower) return MKL_LOWER;
+    return MKL_UPPER;
+}
+
+inline MKL_DIAG cblas_convert(diag d) {
+    if (d == diag::nonunit) return MKL_NONUNIT;
+    if (d == diag::unit)    return MKL_UNIT;
+    return MKL_NONUNIT;
+}
+
+inline MKL_SIDE cblas_convert(side s) {
+    if (s == side::left)  return MKL_LEFT;
+    if (s == side::right) return MKL_RIGHT;
+    return MKL_LEFT;
+}
+
+enum class index_base : char {
+    zero = 0,
+    one  = 1,
+};
+
+enum class layout : char {
+    row_major = 0,
+    col_major = 1,
+    R = 0,
+    C = 1,
+};
+
+#ifndef _ONEAPI_MKL_SLICE_
+#define _ONEAPI_MKL_SLICE_ 1
+struct slice {
+    std::size_t start;
+    std::size_t size;
+    std::int64_t stride;
+
+    constexpr slice(): start(0), size(0), stride(0) { }
+    constexpr slice(slice const &rhs) = default;
+    constexpr slice& operator =(slice const &rhs) = default;
+
+    constexpr slice(std::size_t _start, std::size_t _size, std::int64_t _stride): start(_start), size(_size), stride(_stride) { }
+}; /* struct slice */
+#endif
+
+template <typename T>
+class value_or_pointer {
+    T value_;
+    const T *ptr_;
+
+public:
+    // Constructor from value. Accepts not only type T but anything convertible to T.
+    template <typename U, std::enable_if_t<std::is_convertible_v<U, T>, int> = 0>
+    value_or_pointer(U value) : value_(value), ptr_(nullptr) {}
+
+    // Constructor from pointer, assumed to be device-accessible.
+    value_or_pointer(const T *ptr): value_(T(0)), ptr_(ptr) {}
+
+    bool fixed() const {
+        return ptr_ == nullptr;
+    }
+
+    T get_fixed_value() const {
+        return value_;
+    }
+
+    const T* get_pointer() const {
+        return ptr_;
+    }
+
+    T get() const {
+        return ptr_ ? *ptr_ : value_;
+    }
+
+    void make_device_accessible(sycl::queue& queue) {
+        if (!fixed() && sycl::get_pointer_type(ptr_, queue.get_context()) == sycl::usm::alloc::unknown) {
+            *this = *ptr_;
+        }
+    }
+};
+
+} /* namespace mkl */
+} // namespace oneapi
+
+#endif /* _TYPES_HPP__ */