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

@@ -1,464 +0,0 @@
-/*******************************************************************************
-* 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_BETA_IMPL_HPP_
-#define _MKL_RNG_DEVICE_BETA_IMPL_HPP_
-
-#include "vm_wrappers.hpp"
-
-namespace oneapi::mkl::rng::device::detail {
-
-enum class beta_algorithm { Johnk = 0, Atkinson1, Atkinson2, Atkinson3, Cheng, p1, q1, p1q1 };
-
-// log(4)=1.3862944..
-template <typename DataType>
-inline DataType log4() {
-    if constexpr (std::is_same_v<DataType, double>)
-        return 0x1.62e42fefa39efp+0;
-    else
-        return 0x1.62e43p+0f;
-}
-
-// K=0.85225521765372429631847
-template <typename DataType>
-inline DataType beta_k() {
-    if constexpr (std::is_same_v<DataType, double>)
-        return 0x1.b45acbbf56123p-1;
-    else
-        return 0x1.b45accp-1f;
-}
-
-// C=-0.956240971340815081432202
-template <typename DataType>
-inline DataType beta_c() {
-    if constexpr (std::is_same_v<DataType, double>)
-        return -0x1.e9986aa60216p-1;
-    else
-        return -0x1.e9986ap-1f;
-}
-
-template <typename RealType, typename Method>
-class distribution_base<oneapi::mkl::rng::device::beta<RealType, Method>> {
-public:
-    struct param_type {
-        param_type(RealType p, RealType q, RealType a, RealType b) : p_(p), q_(q), a_(a), b_(b) {}
-        RealType p_;
-        RealType q_;
-        RealType a_;
-        RealType b_;
-    };
-
-    distribution_base(RealType p, RealType q, RealType a, RealType b)
-            : p_(p),
-              q_(q),
-              a_(a),
-              b_(b),
-              count_(0) {
-        set_algorithm();
-#ifndef __SYCL_DEVICE_ONLY__
-        if (p <= RealType(0.0)) {
-            throw oneapi::mkl::invalid_argument("rng", "beta", "p <= 0");
-        }
-        else if (q <= RealType(0.0)) {
-            throw oneapi::mkl::invalid_argument("rng", "beta", "q <= 0");
-        }
-        else if (b <= RealType(0.0)) {
-            throw oneapi::mkl::invalid_argument("rng", "beta", "b <= 0");
-        }
-#endif
-    }
-
-    RealType p() const {
-        return p_;
-    }
-
-    RealType q() const {
-        return q_;
-    }
-
-    RealType a() const {
-        return a_;
-    }
-
-    RealType b() const {
-        return b_;
-    }
-
-    std::size_t count_rejected_numbers() const {
-        return count_;
-    }
-
-    param_type param() const {
-        return param_type(p_, q_, a_, b_);
-    }
-
-    void param(const param_type& pt) {
-#ifndef __SYCL_DEVICE_ONLY__
-        if (pt.p_ <= RealType(0.0)) {
-            throw oneapi::mkl::invalid_argument("rng", "beta", "p <= 0");
-        }
-        else if (pt.q_ <= RealType(0.0)) {
-            throw oneapi::mkl::invalid_argument("rng", "beta", "q <= 0");
-        }
-        else if (pt.b_ <= RealType(0.0)) {
-            throw oneapi::mkl::invalid_argument("rng", "beta", "b <= 0");
-        }
-#endif
-        p_ = pt.p_;
-        q_ = pt.q_;
-        a_ = pt.a_;
-        b_ = pt.b_;
-        set_algorithm();
-    }
-
-protected:
-    template <std::int32_t n, typename T>
-    T pq_kernel(T& z) {
-        for (std::int32_t i = 0; i < n; i++) {
-            if (p_ == RealType(1.0)) {
-                z[i] = pow_wrapper(z[i], RealType(1) / q_);
-                z[i] = RealType(1.0) - z[i];
-            }
-            if (q_ == RealType(1.0)) {
-                z[i] = pow_wrapper(z[i], RealType(1) / p_);
-            }
-        }
-        count_ = 0;
-
-        // p1q1
-        return a_ + b_ * z;
-    }
-
-    template <std::int32_t n, typename T, typename EngineType>
-    T acc_rej_kernel(T& z, EngineType& engine) {
-        RealType s, t;
-
-        RealType flKoef1, flKoef2, flKoef3, flKoef4, flKoef5, flKoef6;
-        RealType flDeg[2];
-
-        if (algorithm_ == beta_algorithm::Atkinson1) {
-            RealType flInv_s[2], flTmp[2];
-            flTmp[0] = p_ * (RealType(1.0) - p_);
-            flTmp[1] = q_ * (RealType(1.0) - q_);
-
-            flTmp[0] = sqrt_wrapper(flTmp[0]);
-            flTmp[1] = sqrt_wrapper(flTmp[1]);
-
-            t = flTmp[0] / (flTmp[0] + flTmp[1]);
-
-            s = q_ * t;
-            s = s / (s + p_ * (RealType(1.0) - t));
-
-            flInv_s[0] = RealType(1.0) / s;
-            flInv_s[1] = RealType(1.0) / (RealType(1.0) - s);
-            flDeg[0] = RealType(1.0) / p_;
-            flDeg[1] = RealType(1.0) / q_;
-
-            flInv_s[0] = pow_wrapper(flInv_s[0], flDeg[0]);
-            flInv_s[1] = pow_wrapper(flInv_s[1], flDeg[1]);
-
-            flKoef1 = t * flInv_s[0];
-            flKoef2 = (RealType(1.0) - t) * flInv_s[1];
-            flKoef3 = RealType(1.0) - q_;
-            flKoef4 = RealType(1.0) - p_;
-            flKoef5 = RealType(1.0) / (RealType(1.0) - t);
-            flKoef6 = RealType(1.0) / t;
-        }
-        else if (algorithm_ == beta_algorithm::Atkinson2) {
-            RealType flInv_s[2], flTmp;
-
-            t = RealType(1.0) - p_;
-            t /= (t + q_);
-
-            flTmp = RealType(1.0) - t;
-            flTmp = pow_wrapper(flTmp, q_);
-            s = q_ * t;
-            s /= (s + p_ * flTmp);
-
-            flInv_s[0] = RealType(1.0) / s;
-            flInv_s[1] = RealType(1.0) / (RealType(1.0) - s);
-            flDeg[0] = RealType(1.0) / p_;
-            flDeg[1] = RealType(1.0) / q_;
-
-            flInv_s[0] = pow_wrapper(flInv_s[0], flDeg[0]);
-            flInv_s[1] = pow_wrapper(flInv_s[1], flDeg[1]);
-
-            flKoef1 = t * flInv_s[0];
-            flKoef2 = (RealType(1.0) - t) * flInv_s[1];
-            flKoef3 = RealType(1.0) - q_;
-            flKoef4 = RealType(1.0) - p_;
-        }
-        else if (algorithm_ == beta_algorithm::Atkinson3) {
-            RealType flInv_s[2], flTmp;
-
-            t = RealType(1.0) - q_;
-            t /= (t + p_);
-
-            flTmp = RealType(1.0) - t;
-            flTmp = pow_wrapper(flTmp, p_);
-            s = p_ * t;
-            s /= (s + q_ * flTmp);
-
-            flInv_s[0] = RealType(1.0) / s;
-            flInv_s[1] = RealType(1.0) / (RealType(1.0) - s);
-            flDeg[0] = RealType(1.0) / q_;
-            flDeg[1] = RealType(1.0) / p_;
-
-            flInv_s[0] = pow_wrapper(flInv_s[0], flDeg[0]);
-            flInv_s[1] = pow_wrapper(flInv_s[1], flDeg[1]);
-
-            flKoef1 = t * flInv_s[0];
-            flKoef2 = (RealType(1.0) - t) * flInv_s[1];
-            flKoef3 = RealType(1.0) - p_;
-            flKoef4 = RealType(1.0) - q_;
-        }
-        else if (algorithm_ == beta_algorithm::Cheng) {
-            flKoef1 = p_ + q_;
-            flKoef2 = (flKoef1 - RealType(2.0)) / (RealType(2.0) * p_ * q_ - flKoef1);
-            flKoef2 = sqrt_wrapper(flKoef2);
-            flKoef3 = p_ + RealType(1.0) / flKoef2;
-        }
-
-        RealType z1, z2;
-
-        count_ = 0;
-        for (int i = 0; i < n; i++) {
-            while (1) { // looping until satisfied
-                z1 = engine.generate_single(RealType(0), RealType(1));
-                z2 = engine.generate_single(RealType(0), RealType(1));
-
-                if (algorithm_ == beta_algorithm::Johnk) {
-                    RealType flU1, flU2, flSum;
-                    z1 = ln_wrapper(z1) / p_;
-                    z2 = ln_wrapper(z2) / q_;
-
-                    z1 = exp_wrapper(z1);
-                    z2 = exp_wrapper(z2);
-
-                    flU1 = z1;
-                    flU2 = z2;
-                    flSum = flU1 + flU2;
-                    if (flSum > RealType(0.0) && flSum <= RealType(1.0)) {
-                        z[i] = flU1 / flSum;
-                        break;
-                    }
-                }
-                if (algorithm_ == beta_algorithm::Atkinson1) {
-                    RealType flU, flExp, flX, flLn;
-                    z2 = ln_wrapper(z2);
-
-                    flU = z1;
-                    flExp = z2;
-                    if (flU <= s) {
-                        flU = pow_wrapper(flU, flDeg[0]);
-                        flX = flKoef1 * flU;
-                        flLn = (RealType(1.0) - flX) * flKoef5;
-                        flLn = ln_wrapper(flLn);
-                        if (flKoef3 * flLn + flExp <= RealType(0.0)) {
-                            z[i] = flX;
-                            break;
-                        }
-                    }
-                    else {
-                        flU = RealType(1.0) - flU;
-                        flU = pow_wrapper(flU, flDeg[1]);
-                        flX = RealType(1.0) - flKoef2 * flU;
-
-                        flLn = flX * flKoef6;
-                        flLn = ln_wrapper(flLn);
-                        if (flKoef4 * flLn + flExp <= RealType(0.0)) {
-                            z[i] = flX;
-                            break;
-                        }
-                    }
-                }
-                if (algorithm_ == beta_algorithm::Atkinson2) {
-                    RealType flU, flExp, flX, flLn;
-                    z2 = ln_wrapper(z2);
-
-                    flU = z1;
-                    flExp = z2;
-                    if (flU <= s) {
-                        flU = pow_wrapper(flU, flDeg[0]);
-                        flX = flKoef1 * flU;
-                        flLn = (RealType(1.0) - flX);
-                        flLn = ln_wrapper(flLn);
-                        if (flKoef3 * flLn + flExp <= RealType(0.0)) {
-                            z[i] = flX;
-                            break;
-                        }
-                    }
-                    else {
-                        flU = RealType(1.0) - flU;
-                        flU = pow_wrapper(flU, flDeg[1]);
-                        flX = RealType(1.0) - flKoef2 * flU;
-
-                        flLn = flX / t;
-                        flLn = ln_wrapper(flLn);
-                        if (flKoef4 * flLn + flExp <= RealType(0.0)) {
-                            z[i] = flX;
-                            break;
-                        }
-                    }
-                }
-                if (algorithm_ == beta_algorithm::Atkinson3) {
-                    RealType flU, flExp, flX, flLn;
-                    z2 = ln_wrapper(z2);
-
-                    flU = z1;
-                    flExp = z2;
-                    if (flU <= s) {
-                        flU = pow_wrapper(flU, flDeg[0]);
-                        flX = flKoef1 * flU;
-                        flLn = (RealType(1.0) - flX);
-                        flLn = ln_wrapper(flLn);
-                        if (flKoef3 * flLn + flExp <= RealType(0.0)) {
-                            z[i] = RealType(1.0) - flX;
-                            break;
-                        }
-                    }
-                    else {
-                        flU = RealType(1.0) - flU;
-                        flU = pow_wrapper(flU, flDeg[1]);
-                        flX = RealType(1.0) - flKoef2 * flU;
-
-                        flLn = flX / t;
-                        flLn = ln_wrapper(flLn);
-                        if (flKoef4 * flLn + flExp <= RealType(0.0)) {
-                            z[i] = RealType(1.0) - flX;
-                            break;
-                        }
-                    }
-                }
-                if (algorithm_ == beta_algorithm::Cheng) {
-                    RealType flU1, flU2, flV, flW, flInv;
-                    RealType flTmp[2];
-                    flU1 = z1;
-                    flU2 = z2;
-
-                    flV = flU1 / (RealType(1.0) - flU1);
-
-                    flV = ln_wrapper(flV);
-
-                    flV = flKoef2 * flV;
-
-                    flW = flV;
-                    flW = exp_wrapper(flW);
-                    flW = p_ * flW;
-                    flInv = RealType(1.0) / (q_ + flW);
-                    flTmp[0] = flKoef1 * flInv;
-                    flTmp[1] = flU1 * flU1 * flU2;
-                    for (int i = 0; i < 2; i++) {
-                        flTmp[i] = ln_wrapper(flTmp[i]);
-                    }
-
-                    if (flKoef1 * flTmp[0] + flKoef3 * flV - log4<RealType>() >= flTmp[1]) {
-                        z[i] = flW * flInv;
-                        break;
-                    }
-                }
-                ++count_;
-            }
-        }
-        return a_ + b_ * z;
-    }
-
-    template <typename EngineType>
-    auto generate(EngineType& engine) ->
-        typename std::conditional<EngineType::vec_size == 1, RealType,
-                                  sycl::vec<RealType, EngineType::vec_size>>::type {
-        sycl::vec<RealType, EngineType::vec_size> res{};
-        if (algorithm_ == beta_algorithm::p1 || algorithm_ == beta_algorithm::q1 ||
-            algorithm_ == beta_algorithm::p1q1) {
-            res = engine.generate(RealType(0), RealType(1));
-            res = pq_kernel<EngineType::vec_size>(res);
-        }
-        else {
-            res = acc_rej_kernel<EngineType::vec_size>(res, engine);
-        }
-        if constexpr (std::is_same_v<Method, beta_method::cja_accurate>) {
-            if (res < a_)
-                res = a_;
-            if (res > a_ + b_)
-                res = a_ + b_;
-        }
-        return res;
-    }
-
-    template <typename EngineType>
-    RealType generate_single(EngineType& engine) {
-        RealType res{};
-        sycl::vec<RealType, 1> z{ res };
-        if (algorithm_ == beta_algorithm::p1 || algorithm_ == beta_algorithm::q1 ||
-            algorithm_ == beta_algorithm::p1q1) {
-            z[0] = engine.generate_single(RealType(0), RealType(1));
-            res = pq_kernel<1>(z);
-        }
-        else {
-            res = acc_rej_kernel<1>(z, engine);
-        }
-        if constexpr (std::is_same_v<Method, beta_method::cja_accurate>) {
-            if (res < a_)
-                res = a_;
-            if (res > a_ + b_)
-                res = a_ + b_;
-        }
-        return res;
-    }
-
-    void set_algorithm() {
-        if (p_ < RealType(1.0) && q_ < RealType(1.0)) {
-            if (q_ + beta_k<RealType>() * p_ * p_ + beta_c<RealType>() <= RealType(0.0)) {
-                algorithm_ = beta_algorithm::Johnk;
-            }
-            else {
-                algorithm_ = beta_algorithm::Atkinson1;
-            }
-        }
-        else if (p_ < RealType(1.0) && q_ > RealType(1.0)) {
-            algorithm_ = beta_algorithm::Atkinson2;
-        }
-        else if (p_ > RealType(1.0) && q_ < RealType(1.0)) {
-            algorithm_ = beta_algorithm::Atkinson3;
-        }
-        else if (p_ > RealType(1.0) && q_ > RealType(1.0)) {
-            algorithm_ = beta_algorithm::Cheng;
-        }
-        else if (p_ == RealType(1.0) && q_ != RealType(1.0)) {
-            algorithm_ = beta_algorithm::p1;
-        }
-        else if (q_ == RealType(1.0) && p_ != RealType(1.0)) {
-            algorithm_ = beta_algorithm::q1;
-        }
-        else {
-            algorithm_ = beta_algorithm::p1q1;
-        }
-    }
-
-    RealType p_;
-    RealType q_;
-    RealType a_;
-    RealType b_;
-    std::size_t count_;
-    beta_algorithm algorithm_;
-};
-
-} // namespace oneapi::mkl::rng::device::detail
-
-#endif // _MKL_RNG_DEVICE_BETA_IMPL_HPP_

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

@@ -1,71 +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_BITS_IMPL_HPP_
-#define _MKL_RNG_DEVICE_BITS_IMPL_HPP_
-
-#include "engine_base.hpp"
-
-namespace oneapi::mkl::rng::device::detail {
-
-template <typename UIntType>
-class distribution_base<oneapi::mkl::rng::device::bits<UIntType>> {
-protected:
-    template <typename EngineType>
-    auto generate(EngineType& engine) -> typename std::enable_if<
-        !std::is_same<EngineType, mcg59<EngineType::vec_size>>::value,
-        typename std::conditional<EngineType::vec_size == 1, UIntType,
-                                  sycl::vec<UIntType, EngineType::vec_size>>::type>::type {
-        static_assert(std::is_same<UIntType, uint32_t>::value,
-                      "oneMKL: bits works only with std::uint32_t");
-        return engine.generate();
-    }
-
-    template <typename EngineType>
-    auto generate(EngineType& engine) -> typename std::enable_if<
-        std::is_same<EngineType, mcg59<EngineType::vec_size>>::value,
-        typename std::conditional<EngineType::vec_size == 1, UIntType,
-                                  sycl::vec<UIntType, EngineType::vec_size>>::type>::type {
-        static_assert(std::is_same<UIntType, uint64_t>::value,
-                      "oneMKL: bits for mcg59 works only with std::uint64_t");
-        return engine.generate_bits();
-    }
-
-    template <typename EngineType>
-    typename std::enable_if<!std::is_same<EngineType, mcg59<EngineType::vec_size>>::value,
-                            UIntType>::type
-    generate_single(EngineType& engine) {
-        static_assert(std::is_same<UIntType, uint32_t>::value,
-                      "oneMKL: bits works only with std::uint32_t");
-        return engine.generate_single();
-    }
-
-    template <typename EngineType>
-    typename std::enable_if<std::is_same<EngineType, mcg59<EngineType::vec_size>>::value,
-                            UIntType>::type
-    generate_single(EngineType& engine) {
-        static_assert(std::is_same<UIntType, uint64_t>::value,
-                      "oneMKL: bits for mcg59 works only with std::uint64_t");
-        return engine.generate_single();
-    }
-};
-
-} // namespace oneapi::mkl::rng::device::detail
-
-#endif // _MKL_RNG_DEVICE_BITS_IMPL_HPP_

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

@@ -1,81 +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_DISTRIBUTION_BASE_HPP_
-#define _MKL_RNG_DISTRIBUTION_BASE_HPP_
-
-#include <sycl/sycl.hpp>
-
-#include "oneapi/mkl/exceptions.hpp"
-#include "oneapi/mkl/rng/device/types.hpp"
-
-namespace oneapi::mkl::rng::device {
-
-namespace detail {
-
-template <typename DistrType>
-class distribution_base {};
-
-} // namespace detail
-
-// declarations of distribution classes
-template <typename Type = float, typename Method = uniform_method::by_default>
-class uniform;
-
-template <typename RealType = float, typename Method = gaussian_method::by_default>
-class gaussian;
-
-template <typename RealType = float, typename Method = lognormal_method::by_default>
-class lognormal;
-
-template <typename UIntType = std::uint32_t>
-class uniform_bits;
-
-template <typename UIntType = std::uint32_t>
-class bits;
-
-template <typename RealType = float, typename Method = exponential_method::by_default>
-class exponential;
-
-template <typename RealType = float, typename Method = beta_method::by_default>
-class beta;
-
-template <typename RealType = float, typename Method = gamma_method::by_default>
-class gamma;
-
-template <typename IntType = std::int32_t, typename Method = poisson_method::by_default>
-class poisson;
-
-template <typename IntType = std::uint32_t, typename Method = bernoulli_method::by_default>
-class bernoulli;
-
-} // namespace oneapi::mkl::rng::device
-
-#include "oneapi/mkl/rng/device/detail/uniform_impl.hpp"
-#include "oneapi/mkl/rng/device/detail/gaussian_impl.hpp"
-#include "oneapi/mkl/rng/device/detail/lognormal_impl.hpp"
-#include "oneapi/mkl/rng/device/detail/bits_impl.hpp"
-#include "oneapi/mkl/rng/device/detail/uniform_bits_impl.hpp"
-#include "oneapi/mkl/rng/device/detail/exponential_impl.hpp"
-#include "oneapi/mkl/rng/device/detail/poisson_impl.hpp"
-#include "oneapi/mkl/rng/device/detail/bernoulli_impl.hpp"
-#include "oneapi/mkl/rng/device/detail/beta_impl.hpp"
-#include "oneapi/mkl/rng/device/detail/gamma_impl.hpp"
-
-#endif // _MKL_RNG_DISTRIBUTION_BASE_HPP_

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

@@ -1,43 +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_ENGINE_BASE_HPP_
-#define _MKL_RNG_DEVICE_ENGINE_BASE_HPP_
-
-#include <cstdint>
-
-#include <sycl/sycl.hpp>
-
-namespace oneapi::mkl::rng::device::detail {
-
-// internal structure to specify state of engine
-template <typename EngineType>
-struct engine_state {};
-
-template <typename EngineType>
-class engine_base {};
-
-} // namespace oneapi::mkl::rng::device::detail
-
-#include "oneapi/mkl/rng/device/detail/philox4x32x10_impl.hpp"
-#include "oneapi/mkl/rng/device/detail/mrg32k3a_impl.hpp"
-#include "oneapi/mkl/rng/device/detail/mcg31m1_impl.hpp"
-#include "oneapi/mkl/rng/device/detail/mcg59_impl.hpp"
-
-#endif // _MKL_RNG_DEVICE_ENGINE_BASE_HPP_