fix eoAlgoFoundry management of numeric parameters

- Use a variant to avoid implicit casting to integer when selecting with brace-initialization.
- Add more doc around parameter forges.

eo/test/t-algo-forged.cpp

@@ -77,14 +77,13 @@ int main(int /*argc*/, char** /*argv*/)
                         pop.append(pop_size, init);
                         eval(pop,pop);
 
-                        foundry.at(foundry.continuators.index()) = i_cont;
-                        foundry.at(foundry.crossovers.index()) = i_cross;
-                        foundry.at(foundry.mutations.index()) = i_mut;
-                        foundry.at(foundry.selectors.index()) = i_sel;
-                        foundry.at(foundry.replacements.index()) = i_rep;
-
-                        // Or, if you know the order.
-                        foundry.select({i_cont, i_cross, i_mut, i_sel, i_rep});
+                        foundry.select({
+                                size_t{i_cont},
+                                size_t{i_cross},
+                                size_t{i_mut},
+                                size_t{i_sel},
+                                size_t{i_rep}
+                            });
 
                         // Actually perform a search
                         foundry(pop);

eo/test/t-eoAlgoFoundryFastGA.cpp

@@ -16,6 +16,7 @@ int main(int /*argc*/, char** /*argv*/)
     using EOT = eoBit<double>;
 
     oneMaxEval<EOT> eval;
+    eoPopLoopEval<EOT> popeval(eval);
 
     eoBooleanGenerator gen(0.5);
     eoInitFixedLength<EOT> init(dim, gen);
@@ -76,6 +77,8 @@ int main(int /*argc*/, char** /*argv*/)
         ;
     std::clog << n << " possible algorithms instances." << std::endl;
 
+    std::clog << "Running everything (this may take time)..." << std::endl;
+
     EOT best_sol;
     std::string best_algo = "";
 
@@ -91,15 +94,20 @@ int main(int /*argc*/, char** /*argv*/)
 
                                             eoPop<EOT> pop;
                                             pop.append(pop_size, init);
+                                            popeval(pop,pop);
 
+                                            // FIXME put the parameters in the test?
                                             foundry.select({
-                                                i_crossselect,
-                                                i_cross,
-                                                i_aftercrosel,
-                                                i_mutselect,
-                                                i_mut,
-                                                i_rep,
-                                                i_cont
+                                                double{0.5}, // crossover_rate
+                                                size_t{i_crossselect},
+                                                size_t{i_cross},
+                                                size_t{i_aftercrosel},
+                                                double{0.5}, // mutation_rate
+                                                size_t{i_mutselect},
+                                                size_t{i_mut},
+                                                size_t{i_rep},
+                                                size_t{i_cont},
+                                                size_t{pop_size} // offspring_size
                                             });
 
                                             // Actually perform a search

eo/test/t-eoFoundryFastGA.cpp

@@ -99,7 +99,18 @@ int main(int /*argc*/, char** /*argv*/)
     pop.append(5,init);
     ::apply(onemax_eval,pop);
 
-    foundry.select({0,0,0,0,0,0/*,0,0*/});
+    foundry.select({
+            /*crossover_rates     */ double{0.8},
+            /*crossover_selectors */ size_t{0},
+            /*crossovers          */ size_t{0},
+            /*aftercross_selectors*/ size_t{0},
+            /*mutation_rates      */ double{0.9},
+            /*mutation_selectors  */ size_t{0},
+            /*mutations           */ size_t{0},
+            /*replacements        */ size_t{0},
+            /*continuators        */ size_t{0},
+            /*offspring_sizes     */ size_t{1},
+        });
     foundry(pop);
 
     std::cout << "Done" << std::endl;