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

mkl_devel_dpcpp-2025.0.1.data/data/Library/include/oneapi/mkl/rng/device/detail/uniform_impl.hpp

@@ -1,289 +0,0 @@
-/*******************************************************************************
-* Copyright 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_UNIFORM_IMPL_HPP_
-#define _MKL_RNG_DEVICE_UNIFORM_IMPL_HPP_
-
-#include <limits>
-
-#include "engine_base.hpp"
-
-namespace oneapi::mkl::rng::device::detail {
-
-static inline std::uint64_t umul_hi_64(const std::uint64_t a, const std::uint64_t b) {
-    const std::uint64_t a_lo = a & 0xFFFFFFFFULL;
-    const std::uint64_t a_hi = a >> 32;
-    const std::uint64_t b_lo = b & 0xFFFFFFFFULL;
-    const std::uint64_t b_hi = b >> 32;
-
-    const std::uint64_t ab_hi = a_hi * b_hi;
-    const std::uint64_t ab_lo = a_lo * b_lo;
-    const std::uint64_t ab_md = a_hi * b_lo;
-    const std::uint64_t ba_md = b_hi * a_lo;
-
-    const std::uint64_t bias = ((ab_md & 0xFFFFFFFFULL) + (ba_md & 0xFFFFFFFFULL) + (ab_lo >> 32)) >> 32;
-
-    return ab_hi + (ab_md >> 32) + (ba_md >> 32) + bias;
-}
-
-template <typename EngineType, typename Generator>
-static inline void generate_leftover(std::uint64_t range, Generator generate, 
-                                     std::uint64_t& res_64, std::uint64_t& leftover) {
-    if constexpr (std::is_same_v<EngineType, mcg31m1<EngineType::vec_size>>) {
-        std::uint32_t res_1 = generate();
-        std::uint32_t res_2 = generate();
-        std::uint32_t res_3 = generate();
-        res_64 = (static_cast<std::uint64_t>(res_3) << 62) + 
-            (static_cast<std::uint64_t>(res_2) << 31) + res_1;
-    }
-    else {
-        std::uint32_t res_1 = generate();
-        std::uint32_t res_2 = generate();
-        res_64 = (static_cast<std::uint64_t>(res_2) << 32) + res_1;
-    }
-
-    leftover = res_64 * range;
-}
-
-template <typename Type, typename Method>
-class distribution_base<oneapi::mkl::rng::device::uniform<Type, Method>> {
-public:
-    struct param_type {
-        param_type(Type a, Type b) : a_(a), b_(b) {}
-        Type a_;
-        Type b_;
-    };
-
-    distribution_base(Type a, Type b) : a_(a), b_(b) {
-#ifndef __SYCL_DEVICE_ONLY__
-        if (a >= b) {
-            throw oneapi::mkl::invalid_argument("rng", "uniform", "a >= b");
-        }
-#endif
-    }
-
-    Type a() const {
-        return a_;
-    }
-
-    Type b() const {
-        return b_;
-    }
-
-    param_type param() const {
-        return param_type(a_, b_);
-    }
-
-    void param(const param_type& pt) {
-#ifndef __SYCL_DEVICE_ONLY__
-        if (pt.a_ >= pt.b_) {
-            throw oneapi::mkl::invalid_argument("rng", "uniform", "a >= b");
-        }
-#endif
-        a_ = pt.a_;
-        b_ = pt.b_;
-    }
-
-protected:
-    template <typename FpType, typename OutType, typename EngineType>
-    OutType generate_single_int(EngineType& engine) {
-        sycl::vec<FpType, EngineType::vec_size> res_fp;
-        res_fp = engine.generate(static_cast<FpType>(a_), static_cast<FpType>(b_));
-        res_fp = sycl::floor(res_fp);
-        OutType res = res_fp.template convert<Type>();
-        return res;
-    }
-
-    template <typename EngineType>
-    auto generate(EngineType& engine) ->
-        typename std::conditional<EngineType::vec_size == 1, Type,
-                                  sycl::vec<Type, EngineType::vec_size>>::type {
-        using OutType = typename std::conditional<EngineType::vec_size == 1, Type,
-                                                  sycl::vec<Type, EngineType::vec_size>>::type;
-        using FpType =
-            typename std::conditional<std::is_same<Method, uniform_method::accurate>::value, double,
-                                      float>::type;
-        OutType res;
-        if constexpr (std::is_integral<Type>::value) {
-            if constexpr (std::is_same_v<Type, std::int32_t> || std::is_same_v<Type, std::uint32_t>) {
-                return generate_single_int<FpType, OutType>(engine);
-            }
-            else {
-                // Lemire's sample rejection method to exclude bias for uniform numbers
-                // https://arxiv.org/abs/1805.10941
-                
-                constexpr std::uint64_t uint_max64 = std::numeric_limits<std::uint64_t>::max();
-                constexpr std::uint64_t uint_max32 = std::numeric_limits<std::uint32_t>::max();
-
-                std::uint64_t range = b_ - a_;
-                std::uint64_t threshold = (uint_max64 - range) % range;
-
-                if (range <= uint_max32)
-                    return generate_single_int<FpType, OutType>(engine);
-
-                if constexpr (EngineType::vec_size == 1) {
-                    std::uint32_t res_1, res_2;
-                    std::uint64_t res_64, leftover;
-
-                    generate_leftover<EngineType>(range, [&engine](){return engine.generate();}, 
-                                                  res_64, leftover);
-
-                    if (range == uint_max64)
-                        return res_64;
-
-                    while (leftover < threshold) {
-                        generate_leftover<EngineType>(range, [&engine](){return engine.generate();}, 
-                                                      res_64, leftover);
-                    }
-
-                    res = a_ + umul_hi_64(res_64, range);
-
-                    return res;
-                }
-                else {
-                    std::uint64_t leftover;
-
-                    sycl::vec<std::uint32_t, EngineType::vec_size> res_1 = engine.generate();
-                    sycl::vec<std::uint32_t, EngineType::vec_size> res_2 = engine.generate();
-                    sycl::vec<std::uint64_t, EngineType::vec_size> res_64;
-                    
-                    if constexpr (std::is_same_v<EngineType, mcg31m1<EngineType::vec_size>>) {
-                        sycl::vec<std::uint32_t, EngineType::vec_size> res_3 = engine.generate();
-
-                        for (int i = 0; i < EngineType::vec_size; i++) {
-                            res_64[i] = (static_cast<std::uint64_t>(res_3[i]) << 62) + 
-                                (static_cast<std::uint64_t>(res_2[i]) << 31) + res_1[i];
-                        }
-                    }
-                    else {
-                        if constexpr (EngineType::vec_size == 3) {
-                            res_64[0] = (static_cast<std::uint64_t>(res_1[1]) << 32) +
-                                static_cast<std::uint64_t>(res_1[0]);
-                            res_64[1] = (static_cast<std::uint64_t>(res_2[0]) << 32) +
-                                static_cast<std::uint64_t>(res_1[2]);
-                            res_64[2] = (static_cast<std::uint64_t>(res_2[2]) << 32) +
-                                static_cast<std::uint64_t>(res_2[1]);
-                        } else {
-                            for (int i = 0; i < EngineType::vec_size / 2; i++) {
-                                res_64[i] = (static_cast<std::uint64_t>(res_1[2 * i + 1]) << 32) +
-                                        static_cast<std::uint64_t>(res_1[2 * i]);
-                                res_64[i + EngineType::vec_size / 2] = (static_cast<std::uint64_t>(res_2[2 * i + 1]) << 32) +
-                                                    static_cast<std::uint64_t>(res_2[2 * i]);
-                            }
-                        }
-                    }
-                    
-                    if (range == uint_max64)
-                        return res_64.template convert<Type>();
-
-                    for (int i = 0; i < EngineType::vec_size; i++) {
-                        leftover = res_64[i] * range;
-
-                        while (leftover < threshold) {
-                            generate_leftover<EngineType>(range, [&engine](){return engine.generate_single();}, 
-                                                          res_64[i], leftover);
-                        }
-
-                        res[i] = a_ + umul_hi_64(res_64[i], range);
-                    }
-
-                    return res;
-                }
-            }
-        }
-        else {
-            res = engine.generate(a_, b_);
-            if constexpr (std::is_same<Method, uniform_method::accurate>::value) {
-                res = sycl::fmax(res, a_);
-                res = sycl::fmin(res, b_);
-            }
-        }
-
-        return res;
-    }
-
-    template <typename EngineType>
-    Type generate_single(EngineType& engine) {
-        using FpType =
-            typename std::conditional<std::is_same<Method, uniform_method::accurate>::value, double,
-                                      float>::type;
-        Type res;
-        if constexpr (std::is_integral<Type>::value) {
-            if constexpr (std::is_same_v<Type, std::int32_t> || std::is_same_v<Type, std::uint32_t>) {
-                FpType res_fp =
-                    engine.generate_single(static_cast<FpType>(a_), static_cast<FpType>(b_));
-                res_fp = sycl::floor(res_fp);
-                res = static_cast<Type>(res_fp);
-                return res;
-            }
-            else {
-                // Lemire's sample rejection method to exclude bias for uniform numbers
-                // https://arxiv.org/abs/1805.10941
-                
-                constexpr std::uint64_t uint_max64 = std::numeric_limits<std::uint64_t>::max();
-                constexpr std::uint64_t uint_max32 = std::numeric_limits<std::uint32_t>::max();
-
-                std::uint64_t range = b_ - a_;
-                std::uint64_t threshold = (uint_max64 - range) % range;
-
-                if (range <= uint_max32) {
-                    FpType res_fp =
-                        engine.generate_single(static_cast<FpType>(a_), static_cast<FpType>(b_));
-                    res_fp = sycl::floor(res_fp);
-                    res = static_cast<Type>(res_fp);
-                    return res;
-                }
-
-                std::uint32_t res_1, res_2;
-                std::uint64_t res_64, leftover;
-
-                generate_leftover<EngineType>(range, [&engine](){return engine.generate_single();}, 
-                                              res_64, leftover);
-
-                if (range == uint_max64)
-                    return res_64;
-
-                while (leftover < threshold) {
-                    generate_leftover<EngineType>(range, [&engine](){return engine.generate_single();}, 
-                                                  res_64, leftover);
-                }
-
-                res = a_ + umul_hi_64(res_64, range);
-
-                return res;
-            }
-        }
-        else {
-            res = engine.generate_single(a_, b_);
-            if constexpr (std::is_same<Method, uniform_method::accurate>::value) {
-                res = sycl::fmax(res, a_);
-                res = sycl::fmin(res, b_);
-            }
-        }
-
-        return res;
-    }
-
-    Type a_;
-    Type b_;
-};
-
-} // namespace oneapi::mkl::rng::device::detail
-
-#endif // _MKL_RNG_DEVICE_UNIFORM_IMPL_HPP_

mkl_devel_dpcpp-2025.0.1.data/data/Library/include/oneapi/mkl/rng/device/detail/vm_wrappers.hpp

@@ -1,183 +0,0 @@
-/*******************************************************************************
-* Copyright 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_VM_WRAPPERS_HPP_
-#define _MKL_RNG_DEVICE_VM_WRAPPERS_HPP_
-
-#include <cmath>
-
-#if MKL_RNG_USE_BINARY_CODE
-#include "oneapi/mkl/vm/device/vm.hpp"
-#endif
-
-namespace oneapi::mkl::rng::device::detail {
-
-#if MKL_RNG_USE_BINARY_CODE
-namespace vm_d = oneapi::mkl::vm::device;
-#endif
-
-template <typename DataType>
-static inline DataType sqrt_wrapper(DataType a) {
-#if MKL_RNG_USE_BINARY_CODE
-    DataType t;
-    if constexpr (std::is_same_v<DataType, double>)
-        vm_d::sqrt(&a, &t, vm_d::mode::ep);
-    else
-        vm_d::sqrt(&a, &t, vm_d::mode::la);
-    return t;
-#else
-    return sycl::sqrt(a);
-#endif // MKL_RNG_USE_BINARY_CODE
-}
-
-template <typename DataType>
-static inline DataType sinpi_wrapper(DataType a) {
-#if MKL_RNG_USE_BINARY_CODE
-    DataType t;
-    if constexpr (std::is_same_v<DataType, double>)
-        vm_d::sinpi(&a, &t, vm_d::mode::ep);
-    else
-        vm_d::sinpi(&a, &t, vm_d::mode::la);
-    return t;
-#else
-    return sycl::sinpi(a);
-#endif // MKL_RNG_USE_BINARY_CODE
-}
-
-template <typename DataType>
-static inline DataType cospi_wrapper(DataType a) {
-#if MKL_RNG_USE_BINARY_CODE
-    DataType t;
-    if constexpr (std::is_same_v<DataType, double>)
-        vm_d::cospi(&a, &t, vm_d::mode::ep);
-    else
-        vm_d::cospi(&a, &t, vm_d::mode::la);
-    return t;
-#else
-    return sycl::cospi(a);
-#endif // MKL_RNG_USE_BINARY_CODE
-}
-
-template <typename DataType>
-static inline DataType sincospi_wrapper(DataType a, DataType& b) {
-#if MKL_RNG_USE_BINARY_CODE
-    DataType t;
-    if constexpr (std::is_same_v<DataType, double>) {
-        vm_d::sincospi(&a, &t, &b, vm_d::mode::ep);
-    }
-    else {
-        vm_d::sincospi(&a, &t, &b, vm_d::mode::la);
-    }
-    return t;
-#else
-    b = sycl::cospi(a);
-    return sycl::sinpi(a);
-#endif // MKL_RNG_USE_BINARY_CODE
-}
-
-template <typename DataType>
-static inline DataType ln_wrapper(DataType a) {
-    if (a == DataType(0)) {
-        if constexpr (std::is_same_v<DataType, double>)
-            return -0x1.74385446D71C3P+9; // ln(0.494065e-323) = -744.440072
-        else
-            return -0x1.9D1DA0P+6f; // ln(0.14012984e-44) = -103.278929
-    }
-
-#if MKL_RNG_USE_BINARY_CODE
-    DataType t;
-    if constexpr (std::is_same_v<DataType, double>)
-        vm_d::ln(&a, &t, vm_d::mode::ep);
-    else
-        vm_d::ln(&a, &t, vm_d::mode::la);
-    return t;
-#else
-    return sycl::log(a);
-#endif // MKL_RNG_USE_BINARY_CODE
-}
-
-template <typename DataType>
-static inline DataType pow_wrapper(DataType a, DataType b) {
-#if MKL_RNG_USE_BINARY_CODE
-    DataType t;
-    if constexpr (std::is_same_v<DataType, double>)
-        vm_d::pow(&a, &b, &t, vm_d::mode::ep);
-    else
-        t = sycl::pow(a, b);
-    return t;
-#else
-    return sycl::pow(a, b);
-#endif // MKL_RNG_USE_BINARY_CODE
-}
-
-template <typename DataType>
-static inline DataType powr_wrapper(DataType a, DataType b) {
-#if MKL_RNG_USE_BINARY_CODE
-    DataType t;
-    if constexpr (std::is_same_v<DataType, double>)
-        vm_d::powr(&a, &b, &t, vm_d::mode::ep);
-    else
-        t = sycl::powr(a, b);
-    return t;
-#else
-    return sycl::powr(a, b);
-#endif // MKL_RNG_USE_BINARY_CODE
-}
-
-template <typename DataType>
-static inline DataType exp_wrapper(DataType a) {
-#if MKL_RNG_USE_BINARY_CODE
-    DataType t;
-    if constexpr (std::is_same_v<DataType, double>)
-        vm_d::exp(&a, &t, vm_d::mode::ep);
-    else
-        t = sycl::exp(a);
-    return t;
-#else
-    return sycl::exp(a);
-#endif // MKL_RNG_USE_BINARY_CODE
-}
-
-#if MKL_RNG_USE_BINARY_CODE
-template <typename RealType>
-inline RealType erf_inv_wrapper(RealType x) {
-    if (std::fabs(x) == RealType(1)) {
-        if constexpr (std::is_same_v<RealType, float>) {
-            return std::copysign(0x1.EA8F96P+1f, x); // ErfInv(0.99999994039) = 3.83250689506
-        }
-        else {
-            return std::copysign(0x1.7744F8F74E94AP+2, x); // ErfInv(0.999999999) = 5.86358474875
-        }
-    }
-    else {
-        RealType res{};
-        if constexpr (std::is_same_v<RealType, double>) {
-            vm_d::erfinv(&x, &res, vm_d::mode::ep);
-        }
-        else {
-            vm_d::erfinv(&x, &res, vm_d::mode::la);
-        }
-        return res;
-    }
-}
-#endif
-
-} // namespace oneapi::mkl::rng::device::detail
-
-#endif // _MKL_RNG_DEVICE_VM_WRAPPERS_HPP_