fix foundries examples

Were declaring forges for parameters, the old way.

eo/test/t-eoAlgoFoundryFastGA.cpp

@@ -22,12 +22,6 @@ int main(int /*argc*/, char** /*argv*/)
 
     eoAlgoFoundryFastGA<EOT> foundry(init, eval, pop_size*10);
 
-    /***** Variation rates *****/
-    for(double r = 0.0; r < 1.0; r+=0.1) {
-        foundry.crossover_rates.add<double>(r);
-        foundry. mutation_rates.add<double>(r);
-    }
-
     /***** Crossovers ****/
     foundry.crossovers.add< eo1PtBitXover<EOT> >();
     foundry.crossovers.add< eoUBitXover<EOT> >(0.5); // preference over 1
@@ -70,56 +64,42 @@ int main(int /*argc*/, char** /*argv*/)
         foundry.continuators.add< eoSteadyFitContinue<EOT> >(10,i);
     }
 
-    /***** Offspring population size *****/
-    foundry.offspring_sizes.add<size_t>(0); // 0 = same as parent pop
-    // for(size_t s = pop_size; s < 2*pop_size; s+=pop_size/10) {
-    //     foundry.offspring_sizes.add<size_t>(s);
-    // }
-
 
     size_t n =
-          foundry.crossover_rates.size()
+          foundry.crossover_selectors.size()
-        * foundry.crossover_selectors.size()
         * foundry.crossovers.size()
         * foundry.aftercross_selectors.size()
-        * foundry.mutation_rates.size()
         * foundry.mutation_selectors.size()
         * foundry.mutations.size()
         * foundry.replacements.size()
         * foundry.continuators.size()
-        * foundry.offspring_sizes.size();
+        ;
     std::clog << n << " possible algorithms instances." << std::endl;
 
     EOT best_sol;
     std::string best_algo = "";
 
     size_t i=0;
-    for(size_t i_crossrate = 0; i_crossrate < foundry.crossover_rates.size(); ++i_crossrate ) {
         for(size_t i_crossselect = 0; i_crossselect < foundry.crossover_selectors.size(); ++i_crossselect ) {
             for(size_t i_cross = 0; i_cross < foundry.crossovers.size(); ++i_cross ) {
                 for(size_t i_aftercrosel = 0; i_aftercrosel < foundry.aftercross_selectors.size(); ++i_aftercrosel ) {
-                    for(size_t i_mutrate = 0; i_mutrate < foundry.mutation_rates.size(); ++i_mutrate ) {
                         for(size_t i_mutselect = 0; i_mutselect < foundry.mutation_selectors.size(); ++i_mutselect ) {
                             for(size_t i_mut = 0; i_mut < foundry.mutations.size(); ++i_mut ) {
                                 for(size_t i_rep = 0; i_rep < foundry.replacements.size(); ++i_rep ) {
                                     for(size_t i_cont = 0; i_cont < foundry.continuators.size(); ++i_cont ) {
-                                        for(size_t i_pop = 0; i_pop < foundry.offspring_sizes.size(); ++i_pop ) {
                                             std::clog << "\r" << i++ << "/" << n-1; std::clog.flush();
 
                                             eoPop<EOT> pop;
                                             pop.append(pop_size, init);
 
                                             foundry.select({
-                                                i_crossrate,
                                                 i_crossselect,
                                                 i_cross,
                                                 i_aftercrosel,
-                                                i_mutrate,
                                                 i_mutselect,
                                                 i_mut,
                                                 i_rep,
-                                                i_cont,
+                                                i_cont
-                                                i_pop
                                             });
 
                                             // Actually perform a search
@@ -132,16 +112,13 @@ int main(int /*argc*/, char** /*argv*/)
                                                 best_sol = pop.best_element();
                                                 best_algo = foundry.name();
                                             }
-                                        }
                                     }
                                 }
                             }
                         }
-                    }
                 }
             }
         }
-    }
     std::cout << std::endl << "Best algo: " << best_algo << ", with " << best_sol << std::endl;
 
 }

eo/test/t-eoFoundryFastGA.cpp

@@ -20,15 +20,6 @@ eoAlgoFoundryFastGA<Bits>& make_foundry(eoFunctorStore& store, eoInit<Bits>& ini
         foundry.continuators.add< eoSteadyFitContinue<Bits> >(10,i);
     }
 
-    for(double i=0.1; i<1.0; i+=0.1) {
-        foundry.crossover_rates.add<double>(i);
-        foundry.mutation_rates.add<double>(i);
-    }
-
-    for(size_t i=5; i<100; i+=10) {
-        foundry.offspring_sizes.add<size_t>(i);
-    }
-
     /***** Crossovers ****/
     for(double i=0.1; i<0.9; i+=0.1) {
         foundry.crossovers.add< eoUBitXover<Bits> >(i); // preference over 1
@@ -65,12 +56,6 @@ eoAlgoFoundryFastGA<Bits>& make_foundry(eoFunctorStore& store, eoInit<Bits>& ini
         }
     }
 
-    /***** Variation rates *****/
-    for(double r = 0.0; r < 1.0; r+=0.1) {
-        foundry.crossover_rates.add<double>(r);
-        foundry. mutation_rates.add<double>(r);
-    }
-
     /***** Replacements ****/
     foundry.replacements.add< eoPlusReplacement<Bits> >();
     foundry.replacements.add< eoCommaReplacement<Bits> >();
@@ -100,16 +85,13 @@ int main(int /*argc*/, char** /*argv*/)
 
 
     size_t n =
-          foundry.crossover_rates.size()
+          foundry.crossover_selectors.size()
-        * foundry.crossover_selectors.size()
-        * foundry.crossovers.size()
         * foundry.aftercross_selectors.size()
-        * foundry.mutation_rates.size()
         * foundry.mutation_selectors.size()
         * foundry.mutations.size()
         * foundry.replacements.size()
         * foundry.continuators.size()
-        * foundry.offspring_sizes.size();
+        ;
 
         std::clog << n << " possible algorithms instances." << std::endl;
 
@@ -117,7 +99,7 @@ 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({0,0,0,0,0,0/*,0,0*/});
     foundry(pop);
 
     std::cout << "Done" << std::endl;