Início / coding / Perguntas / 78929343
Accepted
Adrian McCarthy
Asked: 2024-08-30 03:17:38 +0800 CST

Selecionando um tipo de distribuição uniforme da biblioteca padrão

  • 772

tl;dr: Dado um tipo numérico T, existe uma maneira concisa de declarar uma variável como std::uniform_int_distribution<T>ou std::uniform_real_distribution<T>dependendo se T é integral ou de ponto flutuante?

Eu precisava produzir std::chrono::durations aleatórios uniformemente distribuídos em um intervalo definido pelo chamador, então criei um uniform_duration_distributionmodelo de classe modelado com base nos modelos de classe de distribuição da biblioteca padrão.

Primeiro, escrevi um conceito para restringir minha distribuição a uma duração cronológica (ou tipo similar).

// Is T similar enough to std::chrono::duration for our purposes?
template <typename T>
concept chrono_duration = requires (T d) {
    { d.count() } -> std::same_as<typename T::rep>;
    { d.zero()  } -> std::same_as<T>;
    { d.max()   } -> std::same_as<T>;
};

Uma duração tem uma representação numérica chamada contagem. Minha classe contém uma distribuição uniforme numérica da biblioteca padrão, usa-a para gerar uma contagem e constrói uma duração a partir dessa contagem.

template<chrono_duration DurationT>
class uniform_duration_distribution {
  // ...
  private:
    using rep = typename DurationT::rep;
    std::uniform_distribution<rep> m_distribution;  // Whoops!
};

E aí está o problema. O tipo da contagem da duração pode ser um tipo integral ou um tipo de ponto flutuante, então o tipo de m_distributionnão é tão simples std::uniform_distribution<T>porque não existe tal modelo.

Eu não queria fazer várias especializações da minha classe, e não queria limitar os chamadores a uma instanciação específica de uma duração. Eu só queria escolher o tipo para a distribuição contida com base no tipo de rep da duração.

Minha primeira tentativa foi usar um modelo de alias de tipo restrito por conceitos.

template <std::integral IntT>
using dist_selector = std::uniform_int_distribution<IntT>;

template <std::floating_point FloatT>
using dist_selector = std::uniform_real_distribution<FloatT>;

Isso não parece ser permitido. Eu posso (aparentemente) restringir um único modelo de alias using com um conceito, mas não posso usar conceitos para selecionar entre diferentes aliases. Pelo menos, não como eu tentei. Existe uma maneira de fazer isso?

Também aprendi que não posso me especializar usando modelos de alias.

No final, criei um modelo de estrutura com especializações para os tipos numéricos.

// Select the appropriate distribution type based on the value type.
template <typename T> struct dist_selector {};
template <> struct dist_selector<long double>        { using t = std::uniform_real_distribution<long double>; };
template <> struct dist_selector<double>             { using t = std::uniform_real_distribution<double>; };
template <> struct dist_selector<float>              { using t = std::uniform_real_distribution<float>; };
template <> struct dist_selector<long long>          { using t = std::uniform_int_distribution<long long>; };
template <> struct dist_selector<long>               { using t = std::uniform_int_distribution<long>; };
template <> struct dist_selector<int>                { using t = std::uniform_int_distribution<int>; };
template <> struct dist_selector<short>              { using t = std::uniform_int_distribution<short>; };
template <> struct dist_selector<unsigned long long> { using t = std::uniform_int_distribution<unsigned long long>; };
template <> struct dist_selector<unsigned long>      { using t = std::uniform_int_distribution<unsigned long>; };
// ...

Então a variável membro é definida como:

using rep = typename DurationT::rep;
using dist_type = typename dist_selector<rep>::t;
dist_type m_distribution;

Isso funciona, mas parece que estou voltando para um hack antigo. Estou esquecendo de uma maneira mais moderna de fazer isso?

c++

2 respostas

  1. Eu começaria com uma característica/conceito de tipo para restringir o parâmetro do modelo a ser de um std::chrono::durationtipo:

    template<class>
struct is_duration : std::false_type {};

template<class Rep, class Period>
struct is_duration<std::chrono::duration<Rep, Period>> : std::true_type {};

template<class T>
concept chrono_duration = is_duration<T>::value;

    Então, um seletor de distribuição poderia se parecer com isto, onde uma instância de Tdeve corresponder a uma das testfunções restritas:

    template<class T>
struct distribution_selector {
    template<class I>
        requires std::integral<I>
    static auto test(I) -> std::uniform_int_distribution<I>;

    template<class F>
        requires std::floating_point <F>
    static auto test(F) -> std::uniform_real_distribution<F>;

    using type = decltype(test(std::declval<T>()));
};

template<class T>
using distribution_selector_t = distribution_selector<T>::type;

    Montando tudo:

    template<chrono_duration DurationT>
class uniform_duration_distribution {
public:
    using rep = DurationT::rep;

    distribution_selector_t<rep> m_distribution;
};

    Demonstração

    • 2
  2. Best Answer

    Você pode usar um modelo de classe para a especialização por meio dos conceitos e, em seguida, adicionar o modelo de alias para maior conveniência:

    #include <random>
#include <concepts>
#include <type_traits>

template <typename T> struct dist_selector;

template <typename T> requires std::integral<T>
struct dist_selector<T> {
     using type = std::uniform_int_distribution<T>; 
};

template <typename T> requires std::floating_point<T>
struct dist_selector<T> { 
    using type = std::uniform_real_distribution<T>; 
};

template <typename T>
using dist_selector_t = dist_selector<T>::type;


int main () {
    static_assert(std::is_same_v<std::uniform_int_distribution<int>,dist_selector_t<int>>);
    static_assert(std::is_same_v<std::uniform_real_distribution<float>,dist_selector_t<float>>);
}

    Demonstração ao vivo

    Alternativamente, você pode usar std::conditional:

    template <typename T>
using dis_sel = std::conditional_t<std::is_floating_point_v<T>,
                            std::type_identity<std::uniform_real_distribution<T>>,
                            std::type_identity<std::uniform_int_distribution<T>>>::type;

    Demonstração ao vivo

    Observe como std::type_identityevita solicitar o ::typealias de membro que não existe (por exemplo, std::type_identity<std::uniform_int_distribution<double>>é do tipo "ok", mas não tem typealias de membro).

    • 1

relate perguntas