[C++] Wygodna funkcja do losowania dowolnego typu liczb

Question

Chciałbym zrobić wygodną funkcję do losowania dowolnego typu liczb. Bez konieczności deklarowania generatora pseudolosowego, maksymalnie wygodne.

#include <exception>
#include <iostream>
#include <random>
#include <type_traits>

template<typename T>
T random(T begin, T end)
{
	static std::random_device rd;
	static std::mt19937 gen(rd());

	if (std::is_floating_point<T>::value)
	{
		std::uniform_real_distribution<T> dis(begin, end);
		return dis(gen);
	}
	else if (std::is_integral<T>::value)
	{
		std::uniform_int_distribution<T> dis(begin, end);
		return dis(gen);
	}
	else throw std::invalid_argument("Function 'random' must have a numeric arguments");
}

int main()
{
	std::cout << std::fixed;

	typedef float type;
	type a = 0;
	type b = 1;

	for (size_t i = 0; i < 10; i++)
	{
		std::cout << random(a, b) << "\n";
	}
	
	std::cin.get();
}

Wszystko w miarę dobrze działało w momencie gdy nie przesyłałem typu jakiego chcę otrzymać:

std::uniform_real_distribution<> dis(begin, end);
std::uniform_int_distribution<> dis(begin, end);

Kod błędów:

error C2338: make_signed<T>/make_unsigned<T> require that T shall be a (possibly cv-qualified) integral type or enumeration but not a bool type.
error C2338: invalid template argument for uniform_int_distribution: N4606 26.6.1.1 [rand.req.genl]/1e requires one of short, int, long, long long, unsigned short, unsigned int, unsigned long, or unsigned long long

Czy dałoby się to naprawić? Czy może droga, którą podążam jest zła i może mógłbym to zrobić w inny sposób?

Answer 1

#include <iostream>
#include <random>
#include <type_traits>
#include <iomanip>

template<typename T>
T random_in_range(T begin, T end)
{
    using rand_distrib = typename std::conditional
    <
        std::is_floating_point<T>::value,
        std::uniform_real_distribution<T>,
        std::uniform_int_distribution<T>
    >::type;

    static std::random_device rd;
    static std::mt19937_64 gen(rd());

    rand_distrib dis(begin, end);
    return dis(gen);
}
 
int main()
{
    std::cout << std::setprecision(20) << std::fixed;

    using type_t = long double; 
    type_t a = 0;
    type_t b = 1;
 
    for (auto i = 0; i < 10; ++i)
    {
        std::cout << random_in_range(a, b) << "\n";
    }
}

O coś takiego Ci chodzło?

Comments

O a więc jest w std takie coś :D std::conditional

---

No jest. IMHO implementacja przez specjalizacje szablonów robiła by duży narzut kodu a konkretyzacja uniform_int_distribution i tak nie powiedzie się dla "niekompatybilnego" typu więc nie ma co się silić na statyczne asercje.

---

Dokładnie o to chodziło! Dziękuję :)

Nawet przemyślałeś użycie 64-bitowego generatora jestem pod wrażeniem.

Answer 2

Szablon generuje obie strony ifa (nawet te niespełnione), a X_distribution sprawdza poprawność typów w momencie kompilacji - dlatego się wywala.

Co ciekawe, w C++17 ten kod byłby poprawny i można by go użyć w tej formie - wystarczyłoby zamienić `if (std::...)` na `if constexpr (std::...)`, który w momencie kompilacji kompiluje tylko tą stronę if/else, która jest prawdziwa (kompilujący się przykład: https://godbolt.org/g/R8kbWK ).

A jak na razie, to "poprawnym" rozwiązaniem będzie zastąpienie if/else specjalizacjami funkcji. Można przez specjalizację na boolu, tag dispatch lub użycie SFINAE (enable_if) (zakładam że doguglujesz te tematy, jakby coś mogę dalej podpowiadać)

Comments

Okazało się, że bez `if constexpr` też da się coś takiego zrobić, ale dzięki za odpowiedź i wyjaśnienie problemu ;)

---

Okazało się, że bez `if constexpr` też da się coś takiego zrobić

(No tak, w trzecim akapicie napisałem jak to można zrobić. Criss dał konkretny przykład.)

---

(Wybacz źle się wysłowiłem - miałem na myśli - "Okazało się, że bez `if constexpr` też da się coś takiego zrobić tak jak mówiłeś". Criss dostał łapkę.)

Answer 3

Dopowiadając do odpowiedzi adriana:
Możesz sam sobie w prosty sposób napisać coś w rodzaju constexpr if-a:

template<typename T, bool IsFloatingPoint = std::is_floating_point<T>::value>
struct TypeDependentDist;

template<typename T>
struct TypeDependentDist<T, false> { using Type = std::uniform_int_distribution<T>; };

template<typename T>
struct TypeDependentDist<T, true> { using Type = std::uniform_real_distribution<T>; };
 
int main()
{
    std::mt19937 gen;
    std::cout << TypeDependentDist<float>::Type{1, 10}(gen) << '\n';
    std::cout << TypeDependentDist<int>::Type{1, 10}(gen);
}