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

@@ -1,223 +0,0 @@
-/*******************************************************************************
-* Copyright (C) 2021 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_IMPL_HPP_
-#define _MKL_RNG_DEVICE_MCG31M1_IMPL_HPP_
-
-namespace oneapi::mkl::rng::device {
-
-template <std::int32_t VecSize = 1>
-class mcg31m1;
-
-namespace detail {
-
-template <std::uint64_t VecSize>
-constexpr sycl::vec<std::uint64_t, VecSize> select_vector_a_mcg31m1() {
-    if constexpr (VecSize == 1)
-        return sycl::vec<std::uint64_t, 1>(UINT64_C(1));
-    else if constexpr (VecSize == 2)
-        return sycl::vec<std::uint64_t, 2>({ UINT64_C(1), UINT64_C(1132489760) });
-    else if constexpr (VecSize == 3)
-        return sycl::vec<std::uint64_t, 3>(
-            { UINT64_C(1), UINT64_C(1132489760), UINT64_C(826537482) });
-    else if constexpr (VecSize == 4)
-        return sycl::vec<std::uint64_t, 4>(
-            { UINT64_C(1), UINT64_C(1132489760), UINT64_C(826537482), UINT64_C(289798557) });
-    else if constexpr (VecSize == 8)
-        return sycl::vec<std::uint64_t, 8>({ UINT64_C(1), UINT64_C(1132489760), UINT64_C(826537482),
-                                             UINT64_C(289798557), UINT64_C(480863449),
-                                             UINT64_C(1381340036), UINT64_C(1582925527),
-                                             UINT64_C(1918178478) });
-    else
-        return sycl::vec<std::uint64_t, 16>(
-            { UINT64_C(1), UINT64_C(1132489760), UINT64_C(826537482), UINT64_C(289798557),
-              UINT64_C(480863449), UINT64_C(1381340036), UINT64_C(1582925527), UINT64_C(1918178478),
-              UINT64_C(1286028348), UINT64_C(482167044), UINT64_C(262060616), UINT64_C(1856662125),
-              UINT64_C(839877947), UINT64_C(1997268203), UINT64_C(458714024),
-              UINT64_C(650347998) });
-}
-
-template <std::uint64_t VecSize>
-struct mcg31m1_vector_a {
-    static constexpr sycl::vec<std::uint64_t, VecSize> vector_a =
-        select_vector_a_mcg31m1<VecSize>(); // powers of a
-};
-
-struct mcg31m1_param {
-    static constexpr std::uint32_t a = 1132489760;
-    static constexpr std::uint64_t m_64 = 0x000000007FFFFFFF; // 2^31 - 1
-    static constexpr double m_fl = 2147483647.0; // 2^31 - 1
-    static constexpr std::uint64_t bits = 31;
-};
-
-template <std::int32_t VecSize>
-struct engine_state<oneapi::mkl::rng::device::mcg31m1<VecSize>> {
-    std::uint32_t s;
-};
-
-namespace mcg31m1_impl {
-
-// Improved modulus x % (2^31 - 1) operation (possible to do for divisor (2^N
-// -1), but MCG31M1 needs only 2^31 - 1) if we want to do x % (2^N -1) we can
-// find out that: x = A + B * 2^N, where A = x % 2^N = x & 00..01..11 (binary)
-// where quantity of 1 is N, B = x / 2^N = x >> N also x = A + B * (2^N - 1 + 1)
-// = (A + B) + B * (2^N - 1), but (A + B) may be greater than (2^N - 1), that's
-// why we put x1 = A + B = A' + B' * 2^N = ... until new (A + B) < (2^N - 1) for
-// MCG31m1 N = 31
-template <typename T>
-static inline T custom_mod(std::uint64_t x) {
-    std::uint64_t b = x >> mcg31m1_param::bits;
-    std::uint64_t a = x & mcg31m1_param::m_64;
-    x = a + b;
-    b = x >> mcg31m1_param::bits;
-    a = x & mcg31m1_param::m_64;
-    return static_cast<T>(a + b);
-}
-
-template <std::int32_t VecSize>
-static inline sycl::vec<std::uint32_t, VecSize> custom_mod(
-    const sycl::vec<std::uint64_t, VecSize>& x) {
-    sycl::vec<std::uint64_t, VecSize> b = x >> mcg31m1_param::bits;
-    sycl::vec<std::uint64_t, VecSize> a = x & mcg31m1_param::m_64;
-    sycl::vec<std::uint64_t, VecSize> res = a + b;
-    b = res >> mcg31m1_param::bits;
-    a = res & mcg31m1_param::m_64;
-    res = a + b;
-    return res.template convert<std::uint32_t>();
-}
-
-static inline std::uint64_t power(std::uint64_t a, std::uint64_t n) {
-    std::uint64_t a2;
-    // initialize result by 1 for recurrence
-    std::uint32_t result = 1;
-
-    if (n == 0) {
-        // return (a^0)%m = 1
-        return std::uint64_t{ 1 };
-    }
-
-    // Recurrence loop
-    do {
-        // For each odd n
-        if (n & 1) {
-            a2 = static_cast<std::uint64_t>(result) * a;
-            result = custom_mod<std::uint32_t>(a2);
-        }
-        // n /= 2
-        n >>= 1;
-
-        a2 = a * a;
-        a = custom_mod<std::uint64_t>(a2);
-    } while (n);
-
-    return static_cast<std::uint64_t>(result);
-}
-
-template <std::int32_t VecSize>
-static inline void skip_ahead(engine_state<oneapi::mkl::rng::device::mcg31m1<VecSize>>& state,
-                              std::uint64_t num_to_skip) {
-    std::uint64_t loc_A = power(static_cast<std::uint64_t>(mcg31m1_param::a), num_to_skip);
-    state.s = custom_mod<std::uint32_t>(loc_A * static_cast<std::uint64_t>(state.s));
-}
-
-template <std::int32_t VecSize>
-static inline void init(engine_state<oneapi::mkl::rng::device::mcg31m1<VecSize>>& state,
-                        std::uint32_t seed, std::uint64_t offset) {
-    state.s = custom_mod<std::uint32_t>(seed);
-    if (state.s == 0)
-        state.s = 1;
-    skip_ahead(state, offset);
-}
-
-template <std::int32_t VecSize>
-static inline sycl::vec<std::uint32_t, VecSize> generate(
-    engine_state<oneapi::mkl::rng::device::mcg31m1<VecSize>>& state) {
-    sycl::vec<std::uint64_t, VecSize> x(state.s);
-    sycl::vec<std::uint32_t, VecSize> res = custom_mod(mcg31m1_vector_a<VecSize>::vector_a * x);
-    state.s =
-        custom_mod<std::uint32_t>(mcg31m1_param::a * static_cast<std::uint64_t>(res[VecSize - 1]));
-    return res;
-}
-
-template <std::int32_t VecSize>
-static inline std::uint32_t generate_single(
-    engine_state<oneapi::mkl::rng::device::mcg31m1<VecSize>>& state) {
-    std::uint32_t x = state.s;
-    state.s = custom_mod<std::uint32_t>(mcg31m1_param::a * static_cast<std::uint64_t>(state.s));
-    return x;
-}
-
-} // namespace mcg31m1_impl
-
-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_, seed, offset);
-    }
-
-    template <typename RealType>
-    auto generate(RealType a, RealType b) ->
-        typename std::conditional<VecSize == 1, RealType, sycl::vec<RealType, VecSize>>::type {
-        sycl::vec<RealType, VecSize> res;
-        sycl::vec<std::uint32_t, VecSize> res_uint;
-
-        RealType c = (b - a) / static_cast<RealType>(mcg31m1_param::m_fl);
-
-        res_uint = mcg31m1_impl::generate(this->state_);
-
-        res = res_uint.template convert<RealType>() * c + a;
-
-        return res;
-    }
-
-    auto generate() -> typename std::conditional<VecSize == 1, std::uint32_t,
-                                                 sycl::vec<std::uint32_t, VecSize>>::type {
-        return mcg31m1_impl::generate(this->state_);
-    }
-
-    template <typename RealType>
-    RealType generate_single(RealType a, RealType b) {
-        RealType res;
-        std::uint32_t res_uint;
-
-        RealType c = (b - a) / static_cast<RealType>(mcg31m1_param::m_fl);
-
-        res_uint = mcg31m1_impl::generate_single(this->state_);
-
-        res = static_cast<RealType>(res_uint) * c + a;
-        return res;
-    }
-
-    std::uint32_t generate_single() {
-        return mcg31m1_impl::generate_single(this->state_);
-    }
-
-    void skip_ahead(std::uint64_t num_to_skip) {
-        detail::mcg31m1_impl::skip_ahead(this->state_, num_to_skip);
-    }
-
-    engine_state<oneapi::mkl::rng::device::mcg31m1<VecSize>> state_;
-};
-
-} // namespace detail
-
-} // namespace oneapi::mkl::rng::device
-
-#endif // _MKL_RNG_DEVICE_MCG31M1_IMPL_HPP_

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

@@ -1,118 +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_MCG59_HELPERS_IMPL_HPP_
-#define _MKL_RNG_DEVICE_MCG59_HELPERS_IMPL_HPP_
-
-#include "oneapi/mkl/rng/device/detail/mcg59_impl.hpp"
-
-namespace oneapi::mkl::rng::device::detail {
-namespace mcg59_impl {
-
-template <std::int32_t VecSize>
-static inline void init(
-    engine_state<oneapi::mkl::rng::device::mcg59<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::mcg59<VecSize>>) / sizeof(std::uint32_t);
-    state.s = *(reinterpret_cast<std::uint64_t *>(&accessor[id * num_elements_acc]));
-}
-
-template <std::int32_t VecSize>
-static inline void store(
-    engine_state<oneapi::mkl::rng::device::mcg59<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::mcg59<VecSize>>) / sizeof(std::uint32_t);
-    accessor[id * num_elements_acc] = reinterpret_cast<std::uint32_t *>(&state.s)[0];
-    accessor[id * num_elements_acc + 1] = reinterpret_cast<std::uint32_t *>(&state.s)[1];
-}
-
-} // namespace mcg59_impl
-
-template <std::int32_t VecSize>
-class engine_accessor_base<oneapi::mkl::rng::device::mcg59<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::mcg59<VecSize> load(std::size_t id) const {
-        oneapi::mkl::rng::device::mcg59<VecSize> engine;
-        mcg59_impl::init(engine.state_, id, states_accessor_);
-        return engine;
-    }
-
-    void store(oneapi::mkl::rng::device::mcg59<VecSize> &engine, std::size_t id) const {
-        mcg59_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::mcg59<VecSize>> {
-public:
-    using engine_type = oneapi::mkl::rng::device::mcg59<VecSize>;
-
-    using accessor_type =
-        oneapi::mkl::rng::device::engine_accessor<oneapi::mkl::rng::device::mcg59<VecSize>>;
-
-    engine_descriptor_base(sycl::queue &queue, sycl::range<1> range, std::uint64_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::mcg59<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_MCG59_HELPERS_IMPL_HPP_

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

@@ -1,266 +0,0 @@
-/*******************************************************************************
-* Copyright (C) 2021 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_MCG59_IMPL_HPP_
-#define _MKL_RNG_DEVICE_MCG59_IMPL_HPP_
-
-namespace oneapi::mkl::rng::device {
-
-template <std::int32_t VecSize = 1>
-class mcg59;
-
-namespace detail {
-
-template <std::uint32_t VecSize>
-constexpr sycl::vec<uint64_t, VecSize> select_vector_a_mcg59() {
-    if constexpr (VecSize == 1)
-        return sycl::vec<uint64_t, 1>(UINT64_C(1));
-    else if constexpr (VecSize == 2)
-        return sycl::vec<uint64_t, 2>({ UINT64_C(1), UINT64_C(0x113769B23C5FD) });
-    else if constexpr (VecSize == 3)
-        return sycl::vec<uint64_t, 3>(
-            { UINT64_C(1), UINT64_C(0x113769B23C5FD), UINT64_C(0x65C69FC1A4D5C09) });
-    else if constexpr (VecSize == 4)
-        return sycl::vec<uint64_t, 4>({ UINT64_C(1), UINT64_C(0x113769B23C5FD),
-                                        UINT64_C(0x65C69FC1A4D5C09), UINT64_C(0x1CE44D68E81E1E5) });
-    else if constexpr (VecSize == 8)
-        return sycl::vec<uint64_t, 8>({ UINT64_C(1), UINT64_C(0x113769B23C5FD),
-                                        UINT64_C(0x65C69FC1A4D5C09), UINT64_C(0x1CE44D68E81E1E5),
-                                        UINT64_C(0x2F861CA52807851), UINT64_C(0x1CCDF2FE3A03D0D),
-                                        UINT64_C(0x707AB5B7C1E56D9), UINT64_C(0x6139AE457BD175) });
-    else
-        return sycl::vec<uint64_t, 16>(
-            { UINT64_C(1), UINT64_C(0x113769B23C5FD), UINT64_C(0x65C69FC1A4D5C09),
-              UINT64_C(0x1CE44D68E81E1E5), UINT64_C(0x2F861CA52807851), UINT64_C(0x1CCDF2FE3A03D0D),
-              UINT64_C(0x707AB5B7C1E56D9), UINT64_C(0x6139AE457BD175), UINT64_C(0x171CF606D8C09A1),
-              UINT64_C(0x3764DC8D2D1691D), UINT64_C(0x50A1576CCF32A9), UINT64_C(0x499F3083ADC1E05),
-              UINT64_C(0x7A30C00B05283F1), UINT64_C(0x4FE299EB607DA2D), UINT64_C(0x51CCFD803CE3F79),
-              UINT64_C(0x58145D06A37D795) });
-}
-
-template <std::uint32_t VecSize>
-struct mcg59_vector_a {
-    static constexpr sycl::vec<std::uint64_t, VecSize> vector_a =
-        select_vector_a_mcg59<VecSize>(); // powers of a
-};
-
-struct mcg59_param {
-    static constexpr uint64_t a = 0x113769B23C5FD; // 13^13
-    static constexpr uint64_t m_64 = 0x7FFFFFFFFFFFFFF; // 2^59 - 1
-    static constexpr float m_fl = 576460752303423488.0f; // 2^59
-};
-
-template <std::int32_t VecSize>
-struct engine_state<oneapi::mkl::rng::device::mcg59<VecSize>> {
-    std::uint64_t s;
-};
-
-namespace mcg59_impl {
-
-template <typename T>
-static inline T custom_mod(T x) {
-    return (x & mcg59_param::m_64);
-}
-
-static inline std::uint64_t power(std::uint64_t a, std::uint64_t n) {
-    // initialize result by 1 for recurrency
-    std::uint64_t result = 1;
-    if (n == 0) {
-        // return (a^0)%m = 1
-        return 1;
-    }
-    do {
-        // For each odd n
-        if (n & 1) {
-            result = custom_mod(result * a);
-        }
-        // n := n/2
-        n >>= 1;
-        a = custom_mod(a * a);
-    } while (n);
-
-    return result;
-}
-
-template <std::int32_t VecSize>
-static inline void skip_ahead(engine_state<oneapi::mkl::rng::device::mcg59<VecSize>>& state,
-                              std::uint64_t num_to_skip) {
-    std::uint64_t loc_A = power(mcg59_param::a, num_to_skip);
-    state.s = custom_mod(loc_A * state.s);
-}
-
-template <std::int32_t VecSize>
-static inline void init(engine_state<oneapi::mkl::rng::device::mcg59<VecSize>>& state,
-                        std::uint64_t seed, std::uint64_t offset) {
-    state.s = seed & mcg59_param::m_64;
-    if (state.s == 0)
-        state.s = 1;
-
-    skip_ahead(state, offset);
-}
-
-template <std::int32_t VecSize>
-static inline sycl::vec<std::uint64_t, VecSize> generate(
-    engine_state<oneapi::mkl::rng::device::mcg59<VecSize>>& state) {
-    sycl::vec<std::uint64_t, VecSize> res(state.s);
-    res = custom_mod(mcg59_vector_a<VecSize>::vector_a * res);
-    state.s = custom_mod(mcg59_param::a * res[VecSize - 1]);
-    return res;
-}
-
-template <std::int32_t VecSize>
-static inline std::uint64_t generate_single(
-    engine_state<oneapi::mkl::rng::device::mcg59<VecSize>>& state) {
-    std::uint64_t x = state.s;
-    state.s = custom_mod(mcg59_param::a * x);
-    return x;
-}
-
-} // namespace mcg59_impl
-
-template <std::int32_t VecSize>
-class engine_base<oneapi::mkl::rng::device::mcg59<VecSize>> {
-protected:
-    engine_base(std::uint64_t seed, std::uint64_t offset = 0) {
-        mcg59_impl::init(this->state_, seed, offset);
-    }
-
-    template <typename RealType>
-    auto generate(RealType a, RealType b) ->
-        typename std::conditional<VecSize == 1, RealType, sycl::vec<RealType, VecSize>>::type {
-        sycl::vec<RealType, VecSize> res;
-
-        RealType c = (b - a) / static_cast<RealType>(mcg59_param::m_fl);
-        sycl::vec<std::uint64_t, VecSize> res_uint = mcg59_impl::generate(this->state_);
-
-        res = res_uint.template convert<RealType>() * c + a;
-
-        return res;
-    }
-
-    auto generate() -> typename std::conditional<VecSize == 1, std::uint32_t,
-                                                 sycl::vec<std::uint32_t, VecSize>>::type {
-        return mcg59_impl::generate(this->state_).template convert<std::uint32_t>();
-    }
-
-    auto generate_bits() -> typename std::conditional<VecSize == 1, std::uint64_t,
-                                                      sycl::vec<std::uint64_t, VecSize>>::type {
-        return mcg59_impl::generate(this->state_);
-    }
-
-    template <typename UIntType>
-    auto generate_uniform_bits() ->
-        typename std::conditional<VecSize == 1, UIntType, sycl::vec<UIntType, VecSize>>::type {
-        if constexpr (std::is_same<UIntType, std::uint32_t>::value) {
-            auto uni_res = mcg59_impl::generate(this->state_);
-
-            if constexpr (VecSize == 1) {
-                return static_cast<std::uint32_t>(uni_res[0] >> 27);
-            }
-            else {
-                sycl::vec<std::uint32_t, VecSize> vec_out;
-
-                for (std::int32_t i = 0; i < VecSize; i++) {
-                    vec_out[i] = static_cast<std::uint32_t>(uni_res[i] >> 27);
-                }
-
-                return vec_out;
-            }
-        }
-        else {
-            auto uni_res1 = mcg59_impl::generate(this->state_);
-            auto uni_res2 = mcg59_impl::generate(this->state_);
-
-            if constexpr (VecSize == 1) {
-                uni_res1 >>= UIntType(27);
-                uni_res2 >>= UIntType(27);
-
-                return (uni_res2 << UIntType(32)) + uni_res1;
-            }
-            else {
-                sycl::vec<std::uint64_t, VecSize> vec_out;
-
-                for (int i = 0; i < VecSize; i++) {
-                    uni_res1[i] >>= 27;
-                    uni_res2[i] >>= 27;
-                }
-
-                if constexpr (VecSize != 3) {
-                    for (int i = 0; i < VecSize / 2; i++) {
-                        vec_out[i] = (uni_res1[2 * i + 1] << 32) + uni_res1[2 * i];
-                        vec_out[i + VecSize / 2] = (uni_res2[2 * i + 1] << 32) + uni_res2[2 * i];
-                    }
-                }
-                else {
-                    vec_out[0] = (uni_res1[1] << 32) + uni_res1[0];
-                    vec_out[1] = (uni_res2[0] << 32) + uni_res1[2];
-                    vec_out[2] = (uni_res2[2] << 32) + uni_res2[1];
-                }
-
-                return vec_out;
-            }
-        }
-    }
-
-    template <typename RealType>
-    RealType generate_single(RealType a, RealType b) {
-        RealType res;
-        std::uint64_t res_uint;
-
-        RealType c = (b - a) / static_cast<RealType>(mcg59_param::m_fl);
-
-        res_uint = mcg59_impl::generate_single(this->state_);
-        res = static_cast<RealType>(res_uint) * c + a;
-
-        return res;
-    }
-
-    auto generate_single() {
-        return mcg59_impl::generate_single(this->state_);
-    }
-
-    template <typename UIntType>
-    auto generate_single_uniform_bits() {
-        if constexpr (std::is_same<UIntType, std::uint32_t>::value) {
-            auto uni_res = mcg59_impl::generate_single(this->state_) >> 27;
-
-            return static_cast<std::uint32_t>(uni_res);
-        }
-        else {
-            auto uni_res1 = mcg59_impl::generate_single(this->state_);
-            auto uni_res2 = mcg59_impl::generate_single(this->state_);
-
-            uni_res1 >>= 27;
-            uni_res2 >>= 27;
-
-            return (uni_res2 << 32) + uni_res1;
-        }
-    }
-
-    void skip_ahead(std::uint64_t num_to_skip) {
-        detail::mcg59_impl::skip_ahead(this->state_, num_to_skip);
-    }
-
-    engine_state<oneapi::mkl::rng::device::mcg59<VecSize>> state_;
-};
-
-} // namespace detail
-} // namespace oneapi::mkl::rng::device
-
-#endif // _MKL_RNG_DEVICE_MCG59_IMPL_HPP_