mkl-devel-dpcpp 2025.1.0__py2.py3-none-win_amd64.whl → 2025.2.0__py2.py3-none-win_amd64.whl

mkl_devel_dpcpp-2025.1.0.data/data/Library/include/oneapi/mkl/rng/device/detail/gaussian_impl.hpp

@@ -1,270 +0,0 @@
-/*******************************************************************************
-* Copyright (C) 2020 Intel Corporation
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-* http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing,
-* software distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions
-* and limitations under the License.
-*
-*
-* SPDX-License-Identifier: Apache-2.0
-*******************************************************************************/
-
-#ifndef _MKL_RNG_DEVICE_GAUSSIAN_IMPL_HPP_
-#define _MKL_RNG_DEVICE_GAUSSIAN_IMPL_HPP_
-
-#include "vm_wrappers.hpp"
-
-namespace oneapi::mkl::rng::device::detail {
-
-// sqrt(2)
-template <typename RealType = float>
-constexpr inline RealType sqrt2() {
-    return 0x1.6A09E6P+0f; // 1.414213562
-}
-
-template <>
-constexpr inline double sqrt2<double>() {
-    return 0x1.6A09E667F3BCDP+0; // 1.414213562
-}
-
-template <typename RealType>
-class distribution_base<
-    oneapi::mkl::rng::device::gaussian<RealType, gaussian_method::box_muller2>> {
-public:
-    struct param_type {
-        param_type(RealType mean, RealType stddev) : mean_(mean), stddev_(stddev) {}
-        RealType mean_;
-        RealType stddev_;
-    };
-
-    distribution_base(RealType mean, RealType stddev) : mean_(mean), stddev_(stddev) {
-        flag_ = false;
-#ifndef __SYCL_DEVICE_ONLY__
-        if (stddev <= RealType(0)) {
-            throw oneapi::mkl::invalid_argument("rng", "gaussian", "stddev <= 0");
-        }
-#endif
-    }
-
-    RealType mean() const {
-        return mean_;
-    }
-
-    RealType stddev() const {
-        return stddev_;
-    }
-
-    param_type param() const {
-        return param_type(mean_, stddev_);
-    }
-
-    void param(const param_type& pt) {
-#ifndef __SYCL_DEVICE_ONLY__
-        if (pt.stddev_ <= RealType(0)) {
-            throw oneapi::mkl::invalid_argument("rng", "gaussian", "stddev <= 0");
-        }
-#endif
-        mean_ = pt.mean_;
-        stddev_ = pt.stddev_;
-    }
-
-protected:
-    template <typename EngineType>
-    __attribute__((always_inline)) inline auto generate(EngineType& engine) ->
-        typename std::conditional<EngineType::vec_size == 1, RealType,
-                                  sycl::vec<RealType, EngineType::vec_size>>::type {
-        RealType u1, u2, u1_transformed;
-
-        if constexpr (EngineType::vec_size == 1) {
-            RealType res;
-            if (!flag_) {
-                u1 = engine.generate(RealType(0), RealType(1));
-                u2 = engine.generate(RealType(0), RealType(1));
-                u1_transformed = ln_wrapper(u1);
-                u1_transformed = sqrt_wrapper(static_cast<RealType>(-2.0) * u1_transformed);
-                res = u1_transformed * sinpi_wrapper(RealType(2) * u2) * stddev_ + mean_;
-                u1_transformed_ = u1_transformed;
-                u2_ = u2;
-                flag_ = true;
-                return res;
-            }
-            res = u1_transformed_ * cospi_wrapper(RealType(2) * u2_) * stddev_ + mean_;
-            flag_ = false;
-            return res;
-        }
-        else {
-            RealType sin, cos;
-            sycl::vec<RealType, EngineType::vec_size> res;
-            if (!flag_) {
-                constexpr std::int32_t tail = EngineType::vec_size % 2;
-                auto uniform_res = engine.generate(RealType(0), RealType(1));
-#pragma unroll
-                for (std::int32_t i = 0; i < EngineType::vec_size - tail; i += 2) {
-                    u1 = uniform_res[i];
-                    u2 = uniform_res[i + 1];
-                    u1_transformed = ln_wrapper(u1);
-                    u1_transformed = sqrt_wrapper(static_cast<RealType>(-2.0) * u1_transformed);
-                    sin = sincospi_wrapper(RealType(2.0) * u2, cos);
-                    res[i] = (u1_transformed * sin) * stddev_ + mean_;
-                    res[i + 1] = (u1_transformed * cos) * stddev_ + mean_;
-                }
-                if constexpr (tail) {
-                    u1 = uniform_res[EngineType::vec_size - 1];
-                    u2 = engine.generate_single(RealType(0), RealType(1));
-                    u1_transformed = ln_wrapper(u1);
-                    u1_transformed = sqrt_wrapper(static_cast<RealType>(-2.0) * u1_transformed);
-                    res[EngineType::vec_size - 1] =
-                        u1_transformed * sinpi_wrapper(RealType(2) * u2) * stddev_ + mean_;
-                    u1_transformed_ = u1_transformed;
-                    u2_ = u2;
-                    flag_ = true;
-                }
-                return res;
-            }
-
-            res[0] = u1_transformed_ * cospi_wrapper(RealType(2) * u2_) * stddev_ + mean_;
-            flag_ = false;
-            constexpr std::int32_t tail = (EngineType::vec_size - 1) % 2;
-#pragma unroll
-            for (std::int32_t i = 1; i < EngineType::vec_size - tail; i += 2) {
-                u1 = engine.generate_single(RealType(0), RealType(1));
-                u2 = engine.generate_single(RealType(0), RealType(1));
-                u1_transformed = ln_wrapper(u1);
-                u1_transformed = sqrt_wrapper(static_cast<RealType>(-2.0) * u1_transformed);
-                sin = sincospi_wrapper(RealType(2.0) * u2, cos);
-                res[i] = (u1_transformed * sin) * stddev_ + mean_;
-                res[i + 1] = (u1_transformed * cos) * stddev_ + mean_;
-            }
-            if constexpr (tail) {
-                u1 = engine.generate_single(RealType(0), RealType(1));
-                u2 = engine.generate_single(RealType(0), RealType(1));
-                u1_transformed = ln_wrapper(u1);
-                u1_transformed = sqrt_wrapper(static_cast<RealType>(-2.0) * u1_transformed);
-                res[EngineType::vec_size - 1] =
-                    u1_transformed * sinpi_wrapper(RealType(2) * u2) * stddev_ + mean_;
-                u1_transformed_ = u1_transformed;
-                u2_ = u2;
-                flag_ = true;
-            }
-            return res;
-        }
-    }
-
-    template <typename EngineType>
-    __attribute__((always_inline)) inline RealType generate_single(EngineType& engine) {
-        RealType u1, u2, u1_transformed;
-        RealType res;
-        if (!flag_) {
-            u1 = engine.generate_single(RealType(0), RealType(1));
-            u2 = engine.generate_single(RealType(0), RealType(1));
-            u1_transformed = ln_wrapper(u1);
-            u1_transformed = sqrt_wrapper(static_cast<RealType>(-2.0) * u1_transformed);
-            res = u1_transformed * sinpi_wrapper(RealType(2) * u2) * stddev_ + mean_;
-            u1_transformed_ = u1_transformed;
-            u2_ = u2;
-            flag_ = true;
-            return res;
-        }
-        res = u1_transformed_ * cospi_wrapper(RealType(2) * u2_) * stddev_ + mean_;
-        flag_ = false;
-        return res;
-    }
-
-    RealType mean_;
-    RealType stddev_;
-    bool flag_ = false;
-    RealType u1_transformed_;
-    RealType u2_;
-
-    friend class distribution_base<
-        oneapi::mkl::rng::device::lognormal<RealType, lognormal_method::box_muller2>>;
-    friend class distribution_base<
-        oneapi::mkl::rng::device::poisson<std::int32_t, poisson_method::devroye>>;
-    friend class distribution_base<
-        oneapi::mkl::rng::device::poisson<std::uint32_t, poisson_method::devroye>>;
-};
-
-#if MKL_RNG_USE_BINARY_CODE
-
-template <typename RealType>
-class distribution_base<oneapi::mkl::rng::device::gaussian<RealType, gaussian_method::icdf>> {
-public:
-    struct param_type {
-        param_type(RealType mean, RealType stddev) : mean_(mean), stddev_(stddev) {}
-        RealType mean_;
-        RealType stddev_;
-    };
-
-    distribution_base(RealType mean, RealType stddev) : mean_(mean), stddev_(stddev) {
-#ifndef __SYCL_DEVICE_ONLY__
-        if (stddev <= RealType(0)) {
-            throw oneapi::mkl::invalid_argument("rng", "gaussian", "stddev <= 0");
-        }
-#endif
-    }
-
-    RealType mean() const {
-        return mean_;
-    }
-
-    RealType stddev() const {
-        return stddev_;
-    }
-
-    param_type param() const {
-        return param_type(mean_, stddev_);
-    }
-
-    void param(const param_type& pt) {
-#ifndef __SYCL_DEVICE_ONLY__
-        if (pt.stddev_ <= RealType(0)) {
-            throw oneapi::mkl::invalid_argument("rng", "gaussian", "stddev <= 0");
-        }
-#endif
-        mean_ = pt.mean_;
-        stddev_ = pt.stddev_;
-    }
-
-protected:
-    template <typename EngineType>
-    __attribute__((always_inline)) inline auto generate(EngineType& engine) ->
-        typename std::conditional<EngineType::vec_size == 1, RealType,
-                                  sycl::vec<RealType, EngineType::vec_size>>::type {
-        if constexpr (EngineType::vec_size == 1) {
-            return generate_single(engine);
-        }
-        else {
-            RealType stddev = stddev_ * sqrt2<RealType>();
-            sycl::vec<RealType, EngineType::vec_size> res;
-            sycl::vec<RealType, EngineType::vec_size> u =
-                engine.generate(RealType(-1), RealType(1));
-            for (std::int32_t i = 0; i < EngineType::vec_size; i++) {
-                res[i] = erf_inv_wrapper(u[i]);
-            }
-            return res * stddev + mean_;
-        }
-    }
-
-    template <typename EngineType>
-    __attribute__((always_inline)) inline RealType generate_single(EngineType& engine) {
-        RealType stddev = stddev_ * sqrt2<RealType>();
-        RealType u = engine.generate_single(RealType(-1), RealType(1));
-        return sycl::fma(erf_inv_wrapper(u), stddev, mean_);
-    }
-
-    RealType mean_;
-    RealType stddev_;
-};
-#endif
-
-} // namespace oneapi::mkl::rng::device::detail
-
-#endif // _MKL_RNG_DEVICE_GAUSSIAN_IMPL_HPP_

mkl_devel_dpcpp-2025.1.0.data/data/Library/include/oneapi/mkl/rng/device/detail/geometric_impl.hpp

@@ -1,99 +0,0 @@
-/*******************************************************************************
-* Copyright (C) 2024 Intel Corporation
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-* http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing,
-* software distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions
-* and limitations under the License.
-*
-*
-* SPDX-License-Identifier: Apache-2.0
-*******************************************************************************/
-
-#ifndef _MKL_RNG_DEVICE_GEOMETRIC_IMPL_HPP_
-#define _MKL_RNG_DEVICE_GEOMETRIC_IMPL_HPP_
-
-namespace oneapi::mkl::rng::device::detail {
-
-template <typename IntType, typename Method>
-class distribution_base<oneapi::mkl::rng::device::geometric<IntType, Method>> {
-public:
-    struct param_type {
-        param_type(float p) : p_(p) {}
-        float p_;
-    };
-
-    distribution_base(float p) : p_(p) {
-#ifndef __SYCL_DEVICE_ONLY__
-        if ((p > 1.0f) || (p < 0.0f)) {
-            throw oneapi::mkl::invalid_argument("rng", "geometric", "p < 0 || p > 1");
-        }
-#endif
-    }
-
-    float p() const {
-        return p_;
-    }
-
-    param_type param() const {
-        return param_type(p_);
-    }
-
-    void param(const param_type& pt) {
-#ifndef __SYCL_DEVICE_ONLY__
-        if ((pt.p_ > 1.0f) || (pt.p_ < 0.0f)) {
-            throw oneapi::mkl::invalid_argument("rng", "geometric", "p < 0 || p > 1");
-        }
-#endif
-        p_ = pt.p_;
-    }
-
-protected:
-    template <typename EngineType>
-    auto generate(EngineType& engine) ->
-        typename std::conditional<EngineType::vec_size == 1, IntType,
-                                  sycl::vec<IntType, EngineType::vec_size>>::type {
-        using FpType = typename std::conditional<std::is_same_v<IntType, std::uint64_t> ||
-                                                     std::is_same_v<IntType, std::int64_t>,
-                                                 double, float>::type;
-
-        auto uni_res = engine.generate(FpType(0.0), FpType(1.0));
-        FpType inv_ln = ln_wrapper(FpType(1.0) - p_);
-        inv_ln = FpType(1.0) / inv_ln;
-        if constexpr (EngineType::vec_size == 1) {
-            return static_cast<IntType>(sycl::floor(ln_wrapper(uni_res) * inv_ln));
-        }
-        else {
-            sycl::vec<IntType, EngineType::vec_size> vec_out;
-            for (int i = 0; i < EngineType::vec_size; i++) {
-                vec_out[i] = static_cast<IntType>(sycl::floor(ln_wrapper(uni_res[i]) * inv_ln));
-            }
-            return vec_out;
-        }
-    }
-
-    template <typename EngineType>
-    IntType generate_single(EngineType& engine) {
-        using FpType = typename std::conditional<std::is_same_v<IntType, std::uint64_t> ||
-                                                     std::is_same_v<IntType, std::int64_t>,
-                                                 double, float>::type;
-
-        FpType uni_res = engine.generate_single(FpType(0.0), FpType(1.0));
-        FpType inv_ln = ln_wrapper(FpType(1.0) - p_);
-        inv_ln = FpType(1.0) / inv_ln;
-        return static_cast<IntType>(sycl::floor(ln_wrapper(uni_res) * inv_ln));
-    }
-
-    float p_;
-};
-
-} // namespace oneapi::mkl::rng::device::detail
-
-#endif // _MKL_RNG_DEVICE_GEOMETRIC_IMPL_HPP_

mkl_devel_dpcpp-2025.1.0.data/data/Library/include/oneapi/mkl/rng/device/detail/lognormal_impl.hpp

@@ -1,105 +0,0 @@
-/*******************************************************************************
-* Copyright (C) 2020 Intel Corporation
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-* http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing,
-* software distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions
-* and limitations under the License.
-*
-*
-* SPDX-License-Identifier: Apache-2.0
-*******************************************************************************/
-
-#ifndef _MKL_RNG_DEVICE_LOGNORMAL_IMPL_HPP_
-#define _MKL_RNG_DEVICE_LOGNORMAL_IMPL_HPP_
-
-namespace oneapi::mkl::rng::device::detail {
-
-template <typename RealType, typename Method>
-class distribution_base<oneapi::mkl::rng::device::lognormal<RealType, Method>> {
-public:
-    struct param_type {
-        param_type(RealType m, RealType s, RealType displ, RealType scale)
-                : m_(m),
-                  s_(s),
-                  displ_(displ),
-                  scale_(scale) {}
-        RealType m_;
-        RealType s_;
-        RealType displ_;
-        RealType scale_;
-    };
-
-    distribution_base(RealType m, RealType s, RealType displ, RealType scale)
-            : gaussian_(m, s),
-              displ_(displ),
-              scale_(scale) {
-#ifndef __SYCL_DEVICE_ONLY__
-        if (scale <= static_cast<RealType>(0.0)) {
-            throw oneapi::mkl::invalid_argument("rng", "lognormal", "scale <= 0");
-        }
-#endif
-    }
-
-    RealType m() const {
-        return gaussian_.mean();
-    }
-
-    RealType s() const {
-        return gaussian_.stddev();
-    }
-
-    RealType displ() const {
-        return displ_;
-    }
-
-    RealType scale() const {
-        return scale_;
-    }
-
-    param_type param() const {
-        return param_type(gaussian_.mean(), gaussian_.stddev(), displ_, scale_);
-    }
-
-    void param(const param_type& pt) {
-#ifndef __SYCL_DEVICE_ONLY__
-        if (pt.scale_ <= static_cast<RealType>(0.0)) {
-            throw oneapi::mkl::invalid_argument("rng", "lognormal", "scale <= 0");
-        }
-#endif
-        gaussian_.param({ pt.m_, pt.s_ });
-        displ_ = pt.displ_;
-        scale_ = pt.scale_;
-    }
-
-protected:
-    template <typename EngineType>
-    auto generate(EngineType& engine) ->
-        typename std::conditional<EngineType::vec_size == 1, RealType,
-                                  sycl::vec<RealType, EngineType::vec_size>>::type {
-        auto res = gaussian_.generate(engine);
-        return sycl::exp(res) * scale_ + displ_;
-    }
-
-    template <typename EngineType>
-    RealType generate_single(EngineType& engine) {
-        RealType res = gaussian_.generate_single(engine);
-        return sycl::exp(res) * scale_ + displ_;
-    }
-
-    distribution_base<oneapi::mkl::rng::device::gaussian<RealType, gaussian_method::box_muller2>>
-        gaussian_;
-    RealType displ_;
-    RealType scale_;
-};
-
-} // namespace oneapi::mkl::rng::device::detail
-
-#endif // _MKL_RNG_DEVICE_LOGNORMAL_IMPL_HPP_

mkl_devel_dpcpp-2025.1.0.data/data/Library/include/oneapi/mkl/rng/device/detail/mcg31m1_helpers_impl.hpp

@@ -1,117 +0,0 @@
-/*******************************************************************************
-* Copyright (C) 2023 Intel Corporation
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-* http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing,
-* software distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions
-* and limitations under the License.
-*
-*
-* SPDX-License-Identifier: Apache-2.0
-*******************************************************************************/
-
-#ifndef _MKL_RNG_DEVICE_MCG31M1_HELPERS_IMPL_HPP_
-#define _MKL_RNG_DEVICE_MCG31M1_HELPERS_IMPL_HPP_
-
-#include "oneapi/mkl/rng/device/detail/mcg31m1_impl.hpp"
-
-namespace oneapi::mkl::rng::device::detail {
-namespace mcg31m1_impl {
-
-template <std::int32_t VecSize>
-static inline void init(
-    engine_state<oneapi::mkl::rng::device::mcg31m1<VecSize>> &state, std::size_t id,
-    const sycl::accessor<std::uint32_t, 1, sycl::access::mode::read_write> &accessor) {
-    std::size_t num_elements_acc =
-        sizeof(engine_state<oneapi::mkl::rng::device::mcg31m1<VecSize>>) / sizeof(std::uint32_t);
-    state.s = accessor[id * num_elements_acc];
-}
-
-template <std::int32_t VecSize>
-static inline void store(
-    engine_state<oneapi::mkl::rng::device::mcg31m1<VecSize>> &state, std::size_t id,
-    const sycl::accessor<std::uint32_t, 1, sycl::access::mode::read_write> &accessor) {
-    std::size_t num_elements_acc =
-        sizeof(engine_state<oneapi::mkl::rng::device::mcg31m1<VecSize>>) / sizeof(std::uint32_t);
-    accessor[id * num_elements_acc] = state.s;
-}
-
-} // namespace mcg31m1_impl
-
-template <std::int32_t VecSize>
-class engine_accessor_base<oneapi::mkl::rng::device::mcg31m1<VecSize>> {
-public:
-    engine_accessor_base(sycl::buffer<std::uint32_t, 1> &state_buf, sycl::handler &cgh)
-            : states_accessor_(state_buf, cgh) {}
-
-    oneapi::mkl::rng::device::mcg31m1<VecSize> load(std::size_t id) const {
-        oneapi::mkl::rng::device::mcg31m1<VecSize> engine;
-        mcg31m1_impl::init(engine.state_, id, states_accessor_);
-        return engine;
-    }
-
-    void store(oneapi::mkl::rng::device::mcg31m1<VecSize> &engine, std::size_t id) const {
-        mcg31m1_impl::store(engine.state_, id, states_accessor_);
-    }
-
-protected:
-    sycl::accessor<std::uint32_t, 1, sycl::access::mode::read_write> states_accessor_;
-};
-
-template <std::int32_t VecSize>
-class engine_descriptor_base<oneapi::mkl::rng::device::mcg31m1<VecSize>> {
-public:
-    using engine_type = oneapi::mkl::rng::device::mcg31m1<VecSize>;
-
-    using accessor_type =
-        oneapi::mkl::rng::device::engine_accessor<oneapi::mkl::rng::device::mcg31m1<VecSize>>;
-
-    engine_descriptor_base(sycl::queue &queue, sycl::range<1> range, std::uint32_t seed,
-                           std::uint64_t offset)
-            : states_buffer_(range.get(0) * sizeof(engine_state<engine_type>) /
-                             sizeof(std::uint32_t)) {
-        queue.submit([&](sycl::handler &cgh) {
-            accessor_type states_accessor(states_buffer_, cgh);
-
-            cgh.parallel_for<class init_kernel<engine_type>>
-                (range, [=](sycl::item<1> item) {
-                std::size_t id = item.get_id(0);
-                oneapi::mkl::rng::device::mcg31m1<VecSize> engine(seed, offset *id);
-                states_accessor.store(engine, id);
-            });
-        });
-    }
-
-    template <typename InitEngineFunc>
-    engine_descriptor_base(sycl::queue &queue, sycl::range<1> range, InitEngineFunc func)
-            : states_buffer_(range.get(0) * sizeof(engine_state<engine_type>) /
-                             sizeof(std::uint32_t)) {
-        queue.submit([&](sycl::handler &cgh) {
-            accessor_type states_accessor(states_buffer_, cgh);
-
-            cgh.parallel_for<class init_kernel_ex<engine_type>>
-                (range, [=](sycl::item<1> item) {
-                std::size_t id = item.get_id(0);
-                states_accessor.store(func(item), id);
-            });
-        });
-    }
-
-    accessor_type get_access(sycl::handler &cgh) {
-        return accessor_type{ states_buffer_, cgh };
-    }
-
-protected:
-    sycl::buffer<std::uint32_t, 1> states_buffer_;
-};
-
-} // namespace oneapi::mkl::rng::device::detail
-
-#endif // _MKL_RNG_DEVICE_MCG31M1_HELPERS_IMPL_HPP_