mkl-devel-dpcpp 2024.2.1__py2.py3-none-win_amd64.whl → 2025.0.0__py2.py3-none-win_amd64.whl

mkl_devel_dpcpp-2025.0.0.data/data/Library/include/oneapi/mkl/rng/device/detail/gamma_impl.hpp

@@ -0,0 +1,285 @@
+/*******************************************************************************
+* Copyright 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_GAMMA_IMPL_HPP_
+#define _MKL_RNG_DEVICE_GAMMA_IMPL_HPP_
+
+#include "vm_wrappers.hpp"
+
+namespace oneapi::mkl::rng::device::detail {
+
+enum class gamma_algorithm { Exponential = 0, Vaduva, EPD_Transform, Marsaglia };
+
+// 1/3
+template <typename DataType>
+inline DataType gamma_c1() {
+    if constexpr (std::is_same_v<DataType, double>)
+        return 0x1.5555555555555p-2;
+    else
+        return 0x1.555556p-2f;
+}
+
+// 0.0331
+template <typename DataType>
+inline DataType gamma_c2() {
+    if constexpr (std::is_same_v<DataType, double>)
+        return 0x1.0f27bb2fec56dp-5;
+    else
+        return 0x1.0f27bcp-5f;
+}
+
+// 0.6
+template <typename DataType>
+inline DataType gamma_c06() {
+    if constexpr (std::is_same_v<DataType, double>)
+        return 0x1.3333333333333p-1;
+    else
+        return 0x1.333334p-1f;
+}
+
+template <typename RealType, typename Method>
+class distribution_base<oneapi::mkl::rng::device::gamma<RealType, Method>> {
+public:
+    struct param_type {
+        param_type(RealType alpha, RealType a, RealType beta) : alpha_(alpha), a_(a), beta_(beta) {}
+        RealType alpha_;
+        RealType a_;
+        RealType beta_;
+    };
+
+    distribution_base(RealType alpha, RealType a, RealType beta)
+            : alpha_(alpha),
+              a_(a),
+              beta_(beta),
+              count_(0) {
+        set_algorithm();
+#ifndef __SYCL_DEVICE_ONLY__
+        if (alpha <= RealType(0.0)) {
+            throw oneapi::mkl::invalid_argument("rng", "gamma", "alpha <= 0");
+        }
+        else if (beta <= RealType(0.0)) {
+            throw oneapi::mkl::invalid_argument("rng", "gamma", "beta <= 0");
+        }
+#endif
+    }
+
+    RealType alpha() const {
+        return alpha_;
+    }
+
+    RealType a() const {
+        return a_;
+    }
+
+    RealType beta() const {
+        return beta_;
+    }
+
+    std::size_t count_rejected_numbers() const {
+        return count_;
+    }
+
+    param_type param() const {
+        return param_type(alpha_, a_, beta_);
+    }
+
+    void param(const param_type& pt) {
+#ifndef __SYCL_DEVICE_ONLY__
+        if (pt.alpha_ <= RealType(0.0)) {
+            throw oneapi::mkl::invalid_argument("rng", "gamma", "alpha <= 0");
+        }
+        else if (pt.beta_ <= RealType(0.0)) {
+            throw oneapi::mkl::invalid_argument("rng", "gamma", "beta <= 0");
+        }
+#endif
+        alpha_ = pt.alpha_;
+        a_ = pt.a_;
+        beta_ = pt.beta_;
+        set_algorithm();
+    }
+
+protected:
+    void set_algorithm() {
+        if (alpha_ <= RealType(1.0)) {
+            if (alpha_ == RealType(1.0)) {
+                algorithm_ = gamma_algorithm::Exponential;
+            }
+            else if (alpha_ > gamma_c06<RealType>()) {
+                algorithm_ = gamma_algorithm::Vaduva;
+            }
+            else {
+                algorithm_ = gamma_algorithm::EPD_Transform;
+            }
+        }
+        else {
+            algorithm_ = gamma_algorithm::Marsaglia;
+        }
+    }
+
+    template <typename T, int vecSize>
+    inline std::pair<T, T> gauss_BM2_for_Marsaglia(const sycl::vec<T, vecSize>& vec) {
+        T tmp, sin, cos, gauss_1, gauss_2;
+        tmp = ln_wrapper(vec[0]);
+        tmp = sqrt_wrapper(T(-2.0) * tmp);
+        sin = sincospi_wrapper(T(2) * vec[2], cos);
+        gauss_1 = (tmp * sin);
+        gauss_2 = (tmp * cos);
+        return { gauss_1, gauss_2 };
+    }
+
+    template <std::int32_t n, typename T, typename EngineType>
+    T acc_rej_kernel(T& z, EngineType& engine) {
+        RealType flC, flD;
+        if (algorithm_ == gamma_algorithm::Vaduva) {
+            flC = RealType(1.0) / alpha_;
+            flD = (RealType(1.0) - alpha_) *
+                  exp_wrapper(ln_wrapper(alpha_) * alpha_ / (RealType(1.0) - alpha_));
+        }
+        else if (algorithm_ == gamma_algorithm::EPD_Transform) {
+            flC = RealType(1.0) / alpha_;
+            flD = (RealType(1.0) - alpha_);
+        }
+        else if (algorithm_ == gamma_algorithm::Marsaglia) {
+            flD = alpha_ - gamma_c1<RealType>();
+            flC = sqrt_wrapper(RealType(1.0) / (RealType(9.0) * alpha_ - RealType(3.0)));
+        }
+
+        count_ = 0;
+        RealType z1, z2, z3, z4;
+        for (int i = 0; i < n; i++) {
+            while (1) { // looping until satisfied
+                if (!flag_) {
+                    z1 = engine.generate_single(RealType(0), RealType(1));
+                    z2 = engine.generate_single(RealType(0), RealType(1));
+                }
+
+                if (algorithm_ == gamma_algorithm::Vaduva) {
+                    z1 = -ln_wrapper(z1);
+                    z2 = -ln_wrapper(z2);
+                    z[i] = powr_wrapper(z1, flC);
+                    if (z1 + z2 >= z[i] + flD) {
+                        break;
+                    }
+                }
+                if (algorithm_ == gamma_algorithm::EPD_Transform) {
+                    z2 = -ln_wrapper(z2);
+                    if (z1 <= flD) {
+                        z[i] = powr_wrapper(z1, flC);
+                        if (z[i] <= z2) {
+                            break;
+                        }
+                    }
+                    else {
+                        z1 = -ln_wrapper((RealType(1.0) - z1) * flC);
+                        z[i] = powr_wrapper(flD + alpha_ * z1, flC);
+                        if (z[i] <= z2 + z1) {
+                            break;
+                        }
+                    }
+                }
+                if (algorithm_ == gamma_algorithm::Marsaglia) {
+                    RealType local_uniform_2, local_gauss;
+                    if (!flag_) {
+                        z3 = engine.generate_single(RealType(0), RealType(1));
+                        z4 = engine.generate_single(RealType(0), RealType(1));
+                        auto gauss =
+                            gauss_BM2_for_Marsaglia(sycl::vec<RealType, 4>{ z1, z2, z3, z4 });
+                        local_uniform_2 = z2;
+                        local_gauss = gauss.first;
+
+                        saved_uniform_2_ = z4;
+                        saved_gauss_ = gauss.second;
+                    }
+                    else {
+                        local_uniform_2 = saved_uniform_2_;
+                        local_gauss = saved_gauss_;
+                    }
+                    flag_ = !flag_;
+                    z[i] = RealType(1.0) + flC * local_gauss;
+                    if (z[i] > RealType(0.0)) {
+                        z[i] = z[i] * z[i] * z[i];
+                        local_gauss = local_gauss * local_gauss;
+                        if (local_uniform_2 <
+                            RealType(1.0) - gamma_c2<RealType>() * local_gauss * local_gauss) {
+                            z[i] = flD * z[i];
+                            break;
+                        }
+                        else {
+                            RealType local_uniform_1 = ln_wrapper(z[i]);
+                            local_uniform_2 = ln_wrapper(local_uniform_2);
+                            if (local_uniform_2 <
+                                RealType(0.5) * local_gauss +
+                                    flD * (RealType(1.0) - z[i] + local_uniform_1)) {
+                                z[i] = flD * z[i];
+                                break;
+                            }
+                        }
+                    }
+                }
+                ++count_;
+            }
+        }
+        auto res = a_ + beta_ * z;
+        if constexpr (std::is_same_v<Method, gamma_method::marsaglia_accurate>) {
+            if (res < a_)
+                res = a_;
+        }
+        return res;
+    }
+
+    template <typename EngineType>
+    auto generate(EngineType& engine) ->
+        typename std::conditional<EngineType::vec_size == 1, RealType,
+                                  sycl::vec<RealType, EngineType::vec_size>>::type {
+        if (algorithm_ == gamma_algorithm::Exponential) {
+            distribution_base<oneapi::mkl::rng::device::exponential<RealType>> distr_exp(a_, beta_);
+            return distr_exp.generate(engine);
+        }
+        sycl::vec<RealType, EngineType::vec_size> res{};
+        res = acc_rej_kernel<EngineType::vec_size>(res, engine);
+
+        return res;
+    }
+
+    template <typename EngineType>
+    RealType generate_single(EngineType& engine) {
+        if (algorithm_ == gamma_algorithm::Exponential) {
+            distribution_base<oneapi::mkl::rng::device::exponential<RealType>> distr_exp(a_, beta_);
+            RealType z = distr_exp.generate_single(engine);
+            return z;
+        }
+        sycl::vec<RealType, 1> res{};
+        res = acc_rej_kernel<1>(res, engine);
+
+        return res[0];
+    }
+
+    RealType alpha_;
+    RealType a_;
+    RealType beta_;
+    RealType saved_gauss_;
+    RealType saved_uniform_2_;
+    bool flag_ = false;
+    std::size_t count_;
+    gamma_algorithm algorithm_;
+};
+
+} // namespace oneapi::mkl::rng::device::detail
+
+#endif // _MKL_RNG_DEVICE_GAMMA_IMPL_HPP_

{mkl_devel_dpcpp-2024.2.1.data → mkl_devel_dpcpp-2025.0.0.data}/data/Library/include/oneapi/mkl/rng/device/detail/mcg31m1_impl.hpp

@@ -138,14 +138,10 @@ static inline void skip_ahead(engine_state<oneapi::mkl::rng::device::mcg31m1<Vec
 
 template <std::int32_t VecSize>
 static inline void init(engine_state<oneapi::mkl::rng::device::mcg31m1<VecSize>>& state,
-                        std::uint64_t n, const std::uint32_t* seed_ptr, std::uint64_t offset) {
-    if (n == 0)
+                        std::uint32_t seed, std::uint64_t offset) {
+    state.s = custom_mod<std::uint32_t>(seed);
+    if (state.s == 0)
         state.s = 1;
-    else {
-        state.s = custom_mod<std::uint32_t>(seed_ptr[0]);
-        if (state.s == 0)
-            state.s = 1;
-    }
     skip_ahead(state, offset);
 }
 
@@ -173,11 +169,7 @@ template <std::int32_t VecSize>
 class engine_base<oneapi::mkl::rng::device::mcg31m1<VecSize>> {
 protected:
     engine_base(std::uint32_t seed, std::uint64_t offset = 0) {
-        mcg31m1_impl::init(this->state_, 1, &seed, offset);
-    }
-
-    engine_base(std::uint64_t n, const std::uint32_t* seed, std::uint64_t offset = 0) {
-        mcg31m1_impl::init(this->state_, n, seed, offset);
+        mcg31m1_impl::init(this->state_, seed, offset);
     }
 
     template <typename RealType>

{mkl_devel_dpcpp-2024.2.1.data → mkl_devel_dpcpp-2025.0.0.data}/data/Library/include/oneapi/mkl/rng/device/detail/mcg59_impl.hpp

@@ -107,16 +107,8 @@ static inline void skip_ahead(engine_state<oneapi::mkl::rng::device::mcg59<VecSi
 
 template <std::int32_t VecSize>
 static inline void init(engine_state<oneapi::mkl::rng::device::mcg59<VecSize>>& state,
-                        std::uint64_t n, std::uint32_t* seed_ptr, std::uint64_t offset) {
-    if (n < 1) {
-        state.s = 1;
-    }
-    else if (n == 1) {
-        state.s = static_cast<uint64_t>(seed_ptr[0]) & mcg59_param::m_64;
-    }
-    else {
-        state.s = *(reinterpret_cast<std::uint64_t*>(&seed_ptr[0])) & mcg59_param::m_64;
-    }
+                        std::uint64_t seed, std::uint64_t offset) {
+    state.s = seed & mcg59_param::m_64;
     if (state.s == 0)
         state.s = 1;
 
@@ -145,12 +137,8 @@ static inline std::uint64_t generate_single(
 template <std::int32_t VecSize>
 class engine_base<oneapi::mkl::rng::device::mcg59<VecSize>> {
 protected:
-    engine_base(std::uint32_t seed, std::uint64_t offset = 0) {
-        mcg59_impl::init(this->state_, 1, &seed, offset);
-    }
-
-    engine_base(std::uint64_t n, const std::uint32_t* seed, std::uint64_t offset = 0) {
-        mcg59_impl::init(this->state_, n, seed, offset);
+    engine_base(std::uint64_t seed, std::uint64_t offset = 0) {
+        mcg59_impl::init(this->state_, seed, offset);
     }
 
     template <typename RealType>
@@ -168,7 +156,7 @@ protected:
 
     auto generate() -> typename std::conditional<VecSize == 1, std::uint32_t,
                                                  sycl::vec<std::uint32_t, VecSize>>::type {
-        return mcg59_impl::generate(this->state_);
+        return mcg59_impl::generate(this->state_).template convert<std::uint32_t>();
     }
 
     auto generate_bits() -> typename std::conditional<VecSize == 1, std::uint64_t,
@@ -200,10 +188,10 @@ protected:
             auto uni_res2 = mcg59_impl::generate(this->state_);
 
             if constexpr (VecSize == 1) {
-                uni_res1 >>= 27;
-                uni_res2 >>= 27;
+                uni_res1 >>= UIntType(27);
+                uni_res2 >>= UIntType(27);
 
-                return (uni_res2 << 32) + uni_res1;
+                return (uni_res2 << UIntType(32)) + uni_res1;
             }
             else {
                 sycl::vec<std::uint64_t, VecSize> vec_out;

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

@@ -0,0 +1,289 @@
+/*******************************************************************************
+* 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_