Bonjour à toutes et à tous !
J'ai un petit souci technique, désolé du titre très peu évocateur, j'ai aucune idée du nom du problème que je rencontre !

Je cherche à comparer les temps d'exécution de différentes stratégies de simulation via des classes de politiques.
Mais je ne sais pas comment appeler la bonne version template de la fonction à évaluer, parce que je ne lui ai pas encore donné ses arguments ! J'imagine que c'est assez classique comme problème mais je ne sais pas trop où/quoi chercher, et ça fait une petite heure que je me tords le neurone

Voyez plutôt :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
 
template<typename F, typename... Args>
double execution_time(F func, Args&&... args){
    auto t1 = std::chrono::high_resolution_clock::now();
    func(std::forward<Args>(args)...);
    return std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now() - t1).count();
}
 
//! \remark Merger est une classe de politique donnant la stratégie de simulation
template<class Merger, typename Generator, typename... Args>
void repeat_WF(unsigned int n, unsigned int k, Generator& gen, Args&&... args){
  for(unsigned int i = 0; i < n; ++i){
    std::vector<int> v(k);
    auto model = model::make_discrete_time_wright_fisher<Merger>(v.begin(), v.end(), std::forward<Args>(args)... );
    model(gen);
  }
}
Le code suivant compile et tourne, mais la dernière ligne commentée ne marche évidemment pas. La version bourrine serait peut-être de préciser tous les arguments template avec l'argument de fonction, mais c'est super moche non ? Il y a moyen de faire autrement ? J'hésite à bricoler une fonction qui instantie une lambda...
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
int main(){
 
    using namespace coalescence;
    using BigInt = boost::multiprecision::cpp_int;
    using BigFloat = boost::multiprecision::cpp_dec_float_50;
    using SMM1_type = SimultaneousMultipleMerge<on_the_fly>;
    using SMM2_type = SimultaneousMultipleMerge<in_memoized_distribution<BigInt, BigFloat>>;
    using time_type = int;
    std::mt19937 gen;
 
    unsigned int k = 20;
    unsigned int N = 100;
    unsigned int g = 10;
    time_type t0 = 0;
 
    auto coal_event = std::plus<int>();
    auto init_parent = [](time_type t){return 0;};
 
    // ça c'est juste pour montrer qu'au moins on arrive à simuler selon différentes politiques/stratégies
    repeat_WF<BinaryMerge>(10, k, gen, N, g, t0, coal_event, init_parent);
    repeat_WF<SMM1_type>(10, k, gen, N, g, t0, coal_event, init_parent);
    repeat_WF<SMM2_type>(10, k, gen, N, g, t0, coal_event, init_parent);
 
    //std::cout << execution_time(repeat_WF<BinaryMerge>, 10, k, gen, N, g, t0, coal_event, init_parent) << std::endl; // ne marche pas, snif !
 
  return 0;
}
Merci d'avance !
Bien à vous,