Cleaning

.gitignore

@@ -1 +1,2 @@
-obj/*
+obj/*
+bin/Debug/*

bin/Release/complexity-ea-filtered.csv

@@ -0,0 +1,25 @@
+20;1;23;3105.72;71.0048
+20;3;23;3321.39;75.7266
+20;5;23;3486.28;73.5927
+20;7;23;3664.28;76.8451
+20;9;23;3784.52;75.2131
+20;11;23;3908.79;72.9449
+20;13;23;4118.55;79.2338
+20;15;23;4328.28;77.3135
+20;17;23;4453.01;80.8855
+20;19;23;4636.69;79.6221
+20;21;23;4727.97;74.8535
+20;23;23;4852.33;74.6824
+20;25;23;5089.35;77.7669
+20;27;23;5266.42;75.875
+20;29;23;5355.75;79.0589
+20;31;23;5538.76;74.5654
+20;33;23;5656.85;76.4977
+20;35;23;5811.2;74.5411
+20;37;23;6005.48;78.4641
+20;39;23;6223.22;82.8638
+20;41;23;6301.94;76.2252
+20;43;23;6553.38;85.532
+20;45;23;6604.3;77.2755
+20;47;23;6814.18;79.2386
+20;49;23;7007.51;83.6619

bin/Release/complexity-ea-n-1.csv

@@ -0,0 +1,537 @@
+1;1;1;1;0
+1;1;3;1;0
+1;1;5;1;0
+1;1;7;1;0
+1;1;9;1;0
+1;1;11;1;0
+1;1;13;1;0
+1;1;15;1;0
+1;1;17;1;0
+1;1;19;1;0
+1;1;21;1;0
+1;1;23;1;0
+1;1;25;1;0
+1;1;27;1;0
+1;1;29;1;0
+1;1;31;1;0
+1;1;33;1;0
+1;1;35;1;0
+1;1;37;1;0
+1;1;39;1;0
+1;1;41;1;0
+1;1;43;1;0
+1;1;45;1;0
+1;1;47;1;0
+1;1;49;1;0
+1;3;1;3;0
+1;3;3;3;0
+1;3;5;3;0
+1;3;7;3;0
+1;3;9;3;0
+1;3;11;3;0
+1;3;13;3;0
+1;3;15;3;0
+1;3;17;3;0
+1;3;19;3;0
+1;3;21;3;0
+1;3;23;3;0
+1;3;25;3;0
+1;3;27;3;0
+1;3;29;3;0
+1;3;31;3;0
+1;3;33;3;0
+1;3;35;3;0
+1;3;37;3;0
+1;3;39;3;0
+1;3;41;3;0
+1;3;43;3;0
+1;3;45;3;0
+1;3;47;3;0
+1;3;49;3;0
+1;5;1;5;0
+1;5;3;5;0
+1;5;5;5;0
+1;5;7;5;0
+1;5;9;5;0
+1;5;11;5;0
+1;5;13;5;0
+1;5;15;5;0
+1;5;17;5;0
+1;5;19;5;0
+1;5;21;5;0
+1;5;23;5;0
+1;5;25;5;0
+1;5;27;5;0
+1;5;29;5;0
+1;5;31;5;0
+1;5;33;5;0
+1;5;35;5;0
+1;5;37;5;0
+1;5;39;5;0
+1;5;41;5;0
+1;5;43;5;0
+1;5;45;5;0
+1;5;47;5;0
+1;5;49;5;0
+1;7;1;7;0
+1;7;3;7;0
+1;7;5;7;0
+1;7;7;7;0
+1;7;9;7;0
+1;7;11;7;0
+1;7;13;7;0
+1;7;15;7;0
+1;7;17;7;0
+1;7;19;7;0
+1;7;21;7;0
+1;7;23;7;0
+1;7;25;7;0
+1;7;27;7;0
+1;7;29;7;0
+1;7;31;7;0
+1;7;33;7;0
+1;7;35;7;0
+1;7;37;7;0
+1;7;39;7;0
+1;7;41;7;0
+1;7;43;7;0
+1;7;45;7;0
+1;7;47;7;0
+1;7;49;7;0
+1;9;1;9;0
+1;9;3;9;0
+1;9;5;9;0
+1;9;7;9;0
+1;9;9;9;0
+1;9;11;9;0
+1;9;13;9;0
+1;9;15;9;0
+1;9;17;9;0
+1;9;19;9;0
+1;9;21;9;0
+1;9;23;9;0
+1;9;25;9;0
+1;9;27;9;0
+1;9;29;9;0
+1;9;31;9;0
+1;9;33;9;0
+1;9;35;9;0
+1;9;37;9;0
+1;9;39;9;0
+1;9;41;9;0
+1;9;43;9;0
+1;9;45;9;0
+1;9;47;9;0
+1;9;49;9;0
+1;11;1;11;0
+1;11;3;11;0
+1;11;5;11;0
+1;11;7;11;0
+1;11;9;11;0
+1;11;11;11;0
+1;11;13;11;0
+1;11;15;11;0
+1;11;17;11;0
+1;11;19;11;0
+1;11;21;11;0
+1;11;23;11;0
+1;11;25;11;0
+1;11;27;11;0
+1;11;29;11;0
+1;11;31;11;0
+1;11;33;11;0
+1;11;35;11;0
+1;11;37;11;0
+1;11;39;11;0
+1;11;41;11;0
+1;11;43;11;0
+1;11;45;11;0
+1;11;47;11;0
+1;11;49;11;0
+1;13;1;13;0
+1;13;3;13;0
+1;13;5;13;0
+1;13;7;13;0
+1;13;9;13;0
+1;13;11;13;0
+1;13;13;13;0
+1;13;15;13;0
+1;13;17;13;0
+1;13;19;13;0
+1;13;21;13;0
+1;13;23;13;0
+1;13;25;13;0
+1;13;27;13;0
+1;13;29;13;0
+1;13;31;13;0
+1;13;33;13;0
+1;13;35;13;0
+1;13;37;13;0
+1;13;39;13;0
+1;13;41;13;0
+1;13;43;13;0
+1;13;45;13;0
+1;13;47;13;0
+1;13;49;13;0
+1;15;1;15;0
+1;15;3;15;0
+1;15;5;15;0
+1;15;7;15;0
+1;15;9;15;0
+1;15;11;15;0
+1;15;13;15;0
+1;15;15;15;0
+1;15;17;15;0
+1;15;19;15;0
+1;15;21;15;0
+1;15;23;15;0
+1;15;25;15;0
+1;15;27;15;0
+1;15;29;15;0
+1;15;31;15;0
+1;15;33;15;0
+1;15;35;15;0
+1;15;37;15;0
+1;15;39;15;0
+1;15;41;15;0
+1;15;43;15;0
+1;15;45;15;0
+1;15;47;15;0
+1;15;49;15;0
+1;17;1;17;0
+1;17;3;17;0
+1;17;5;17;0
+1;17;7;17;0
+1;17;9;17;0
+1;17;11;17;0
+1;17;13;17;0
+1;17;15;17;0
+1;17;17;17;0
+1;17;19;17;0
+1;17;21;17;0
+1;17;23;17;0
+1;17;25;17;0
+1;17;27;17;0
+1;17;29;17;0
+1;17;31;17;0
+1;17;33;17;0
+1;17;35;17;0
+1;17;37;17;0
+1;17;39;17;0
+1;17;41;17;0
+1;17;43;17;0
+1;17;45;17;0
+1;17;47;17;0
+1;17;49;17;0
+1;19;1;19;0
+1;19;3;19;0
+1;19;5;19;0
+1;19;7;19;0
+1;19;9;19;0
+1;19;11;19;0
+1;19;13;19;0
+1;19;15;19;0
+1;19;17;19;0
+1;19;19;19;0
+1;19;21;19;0
+1;19;23;19;0
+1;19;25;19;0
+1;19;27;19;0
+1;19;29;19;0
+1;19;31;19;0
+1;19;33;19;0
+1;19;35;19;0
+1;19;37;19;0
+1;19;39;19;0
+1;19;41;19;0
+1;19;43;19;0
+1;19;45;19;0
+1;19;47;19;0
+1;19;49;19;0
+1;21;1;21;0
+1;21;3;21;0
+1;21;5;21;0
+1;21;7;21;0
+1;21;9;21;0
+1;21;11;21;0
+1;21;13;21;0
+1;21;15;21;0
+1;21;17;21;0
+1;21;19;21;0
+1;21;21;21;0
+1;21;23;21;0
+1;21;25;21;0
+1;21;27;21;0
+1;21;29;21;0
+1;21;31;21;0
+1;21;33;21;0
+1;21;35;21;0
+1;21;37;21;0
+1;21;39;21;0
+1;21;41;21;0
+1;21;43;21;0
+1;21;45;21;0
+1;21;47;21;0
+1;21;49;21;0
+1;23;1;23;0
+1;23;3;23;0
+1;23;5;23;0
+1;23;7;23;0
+1;23;9;23;0
+1;23;11;23;0
+1;23;13;23;0
+1;23;15;23;0
+1;23;17;23;0
+1;23;19;23;0
+1;23;21;23;0
+1;23;23;23;0
+1;23;25;23;0
+1;23;27;23;0
+1;23;29;23;0
+1;23;31;23;0
+1;23;33;23;0
+1;23;35;23;0
+1;23;37;23;0
+1;23;39;23;0
+1;23;41;23;0
+1;23;43;23;0
+1;23;45;23;0
+1;23;47;23;0
+1;23;49;23;0
+1;25;1;25;0
+1;25;3;25;0
+1;25;5;25;0
+1;25;7;25;0
+1;25;9;25;0
+1;25;11;25;0
+1;25;13;25;0
+1;25;15;25;0
+1;25;17;25;0
+1;25;19;25;0
+1;25;21;25;0
+1;25;23;25;0
+1;25;25;25;0
+1;25;27;25;0
+1;25;29;25;0
+1;25;31;25;0
+1;25;33;25;0
+1;25;35;25;0
+1;25;37;25;0
+1;25;39;25;0
+1;25;41;25;0
+1;25;43;25;0
+1;25;45;25;0
+1;25;47;25;0
+1;25;49;25;0
+1;27;1;27;0
+1;27;3;27;0
+1;27;5;27;0
+1;27;7;27;0
+1;27;9;27;0
+1;27;11;27;0
+1;27;13;27;0
+1;27;15;27;0
+1;27;17;27;0
+1;27;19;27;0
+1;27;21;27;0
+1;27;23;27;0
+1;27;25;27;0
+1;27;27;27;0
+1;27;29;27;0
+1;27;31;27;0
+1;27;33;27;0
+1;27;35;27;0
+1;27;37;27;0
+1;27;39;27;0
+1;27;41;27;0
+1;27;43;27;0
+1;27;45;27;0
+1;27;47;27;0
+1;27;49;27;0
+1;29;1;29;0
+1;29;3;29;0
+1;29;5;29;0
+1;29;7;29;0
+1;29;9;29;0
+1;29;11;29;0
+1;29;13;29;0
+1;29;15;29;0
+1;29;17;29;0
+1;29;19;29;0
+1;29;21;29;0
+1;29;23;29;0
+1;29;25;29;0
+1;29;27;29;0
+1;29;29;29;0
+1;29;31;29;0
+1;29;33;29;0
+1;29;35;29;0
+1;29;37;29;0
+1;29;39;29;0
+1;29;41;29;0
+1;29;43;29;0
+1;29;45;29;0
+1;29;47;29;0
+1;29;49;29;0
+1;31;1;31;0
+1;31;3;31;0
+1;31;5;31;0
+1;31;7;31;0
+1;31;9;31;0
+1;31;11;31;0
+1;31;13;31;0
+1;31;15;31;0
+1;31;17;31;0
+1;31;19;31;0
+1;31;21;31;0
+1;31;23;31;0
+1;31;25;31;0
+1;31;27;31;0
+1;31;29;31;0
+1;31;31;31;0
+1;31;33;31;0
+1;31;35;31;0
+1;31;37;31;0
+1;31;39;31;0
+1;31;41;31;0
+1;31;43;31;0
+1;31;45;31;0
+1;31;47;31;0
+1;31;49;31;0
+1;33;1;33;0
+1;33;3;33;0
+1;33;5;33;0
+1;33;7;33;0
+1;33;9;33;0
+1;33;11;33;0
+1;33;13;33;0
+1;33;15;33;0
+1;33;17;33;0
+1;33;19;33;0
+1;33;21;33;0
+1;33;23;33;0
+1;33;25;33;0
+1;33;27;33;0
+1;33;29;33;0
+1;33;31;33;0
+1;33;33;33;0
+1;33;35;33;0
+1;33;37;33;0
+1;33;39;33;0
+1;33;41;33;0
+1;33;43;33;0
+1;33;45;33;0
+1;33;47;33;0
+1;33;49;33;0
+1;35;1;35;0
+1;35;3;35;0
+1;35;5;35;0
+1;35;7;35;0
+1;35;9;35;0
+1;35;11;35;0
+1;35;13;35;0
+1;35;15;35;0
+1;35;17;35;0
+1;35;19;35;0
+1;35;21;35;0
+1;35;23;35;0
+1;35;25;35;0
+1;35;27;35;0
+1;35;29;35;0
+1;35;31;35;0
+1;35;33;35;0
+1;35;35;35;0
+1;35;37;35;0
+1;35;39;35;0
+1;35;41;35;0
+1;35;43;35;0
+1;35;45;35;0
+1;35;47;35;0
+1;35;49;35;0
+1;37;1;37;0
+1;37;3;37;0
+1;37;5;37;0
+1;37;7;37;0
+1;37;9;37;0
+1;37;11;37;0
+1;37;13;37;0
+1;37;15;37;0
+1;37;17;37;0
+1;37;19;37;0
+1;37;21;37;0
+1;37;23;37;0
+1;37;25;37;0
+1;37;27;37;0
+1;37;29;37;0
+1;37;31;37;0
+1;37;33;37;0
+1;37;35;37;0
+1;37;37;37;0
+1;37;39;37;0
+1;37;41;37;0
+1;37;43;37;0
+1;37;45;37;0
+1;37;47;37;0
+1;37;49;37;0
+1;39;1;39;0
+1;39;3;39;0
+1;39;5;39;0
+1;39;7;39;0
+1;39;9;39;0
+1;39;11;39;0
+1;39;13;39;0
+1;39;15;39;0
+1;39;17;39;0
+1;39;19;39;0
+1;39;21;39;0
+1;39;23;39;0
+1;39;25;39;0
+1;39;27;39;0
+1;39;29;39;0
+1;39;31;39;0
+1;39;33;39;0
+1;39;35;39;0
+1;39;37;39;0
+1;39;39;39;0
+1;39;41;39;0
+1;39;43;39;0
+1;39;45;39;0
+1;39;47;39;0
+1;39;49;39;0
+1;41;1;41;0
+1;41;3;41;0
+1;41;5;41;0
+1;41;7;41;0
+1;41;9;41;0
+1;41;11;41;0
+1;41;13;41;0
+1;41;15;41;0
+1;41;17;41;0
+1;41;19;41;0
+1;41;21;41;0
+1;41;23;41;0
+1;41;25;41;0
+1;41;27;41;0
+1;41;29;41;0
+1;41;31;41;0
+1;41;33;41;0
+1;41;35;41;0
+1;41;37;41;0
+1;41;39;41;0
+1;41;41;41;0
+1;41;43;41;0
+1;41;45;41;0
+1;41;47;41;0
+1;41;49;41;0
+1;43;1;43;0
+1;43;3;43;0
+1;43;5;43;0
+1;43;7;43;0
+1;43;9;43;0
+1;43;11;43;0
+1;43;13;43;0
+1;43;15;43;0
+1;43;17;43;0
+1;43;19;43;0
+1;43;21;43;0
+1;43;23;43;0

bin/Release/complexity-ea-n-26.csv

@@ -0,0 +1,22 @@
+26;1;1;5450.43;132.211
+26;1;3;5445.87;129.854
+26;1;5;5465.11;128.355
+26;1;7;5524.36;118.343
+26;1;9;5561.13;131.298
+26;1;11;5483.36;124.717
+26;1;13;5686.47;132.918
+26;1;15;5687.05;133.905
+26;1;17;5644.49;133.398
+26;1;19;5797.73;132.814
+26;1;21;5834.32;138.027
+26;1;23;5701.87;127.491
+26;1;25;5679.45;128.342
+26;1;27;5836.7;135.008
+26;1;29;5834.64;123.616
+26;1;31;5794.81;129.001
+26;1;33;5885.4;127.851
+26;1;35;6095.13;138.534
+26;1;37;6003.4;135.471
+26;1;39;5979.15;132.497
+26;1;41;5996.1;134.774
+26;1;43;6046.54;127.261

bin/Release/complexity-ga-n-1.csv

@@ -0,0 +1,7 @@
+1;1;1
+11;603.874;736.386
+21;3097.32;3687.28
+31;7605.4;8646.42
+41;15005.4;16900.2
+51;25209.9;28948.1
+61;36061;40011.5

bin/Release/complexity-ga-n-10 - Copie.csv

@@ -0,0 +1,20 @@
+10;449,641;547,979
+20;2789,86;3257,66
+30;6943,37;8073,65
+40;13922;15841,5
+50;23186,2;26292,3
+60;34997,4;39563
+70;49356,1;55847,2
+80;64701,9;73487,2
+90;86415,5;97414,7
+100;114149;128831
+110;140424;156767
+120;175468;197570
+130;207240;229129
+140;227312;249716
+150;277252;306522
+160;317716;353406
+170;348165;379840
+180;425796;465399
+190;465479;518667
+200;503244;556793

bin/Release/complexity-ga-n-10.csv

@@ -0,0 +1,6 @@
+10;450.666;549.494
+20;2607.91;3068.89
+30;7314.28;8528
+40;13471.5;15371.2
+50;23789.8;26783.3
+60;37293.4;41851.4

bin/Release/complexity-rls-n-10 - Copie.csv

@@ -0,0 +1,29 @@
+10;236.579;277.161
+20;1276.17;1455.83
+30;3299.31;3728.59
+40;6588.44;7426.06
+50;10457.8;11838.7
+60;15620.1;17211.8
+70;21726.2;24080.3
+80;30742.1;33800.9
+90;38879.2;42216.9
+100;48550.6;53056.8
+120;73849.9;80028.8
+140;104190;114847
+160;142970;155903
+180;176611;192910
+200;224209;245058
+220;281514;312329
+240;333992;363563
+260;395581;434347
+280;456725;496921
+300;542401;595674
+320;629382;682367
+340;731752;801707
+360;804547;872362
+380;891730;961536
+400;974939;1.05046e+006
+420;1.14141e+006;1.23178e+006
+440;1.24668e+006;1.3253e+006
+460;1.35875e+006;1.47217e+006
+480;1.50166e+006;1.62047e+006

bin/Release/complexity-rls-n-10.csv

@@ -0,0 +1,31 @@
+10;236.579;277.161
+20;1276.17;1455.83
+30;3299.31;3728.59
+40;6588.44;7426.06
+50;10457.8;11838.7
+60;15620.1;17211.8
+70;21726.2;24080.3
+80;30742.1;33800.9
+90;38879.2;42216.9
+100;48550.6;53056.8
+120;73849.9;80028.8
+140;104190;114847
+160;142970;155903
+180;176611;192910
+200;224209;245058
+220;281514;312329
+240;333992;363563
+260;395581;434347
+280;456725;496921
+300;542401;595674
+320;629382;682367
+340;731752;801707
+360;804547;872362
+380;891730;961536
+400;974939;1.05046e+006
+420;1.14141e+006;1.23178e+006
+440;1.24668e+006;1.3253e+006
+460;1.35875e+006;1.47217e+006
+480;1.50166e+006;1.62047e+006
+500;1.64781e+006;1.77377e+006
+520;1.73294e+006;1.85168e+006

coeffs.csv

@@ -0,0 +1,486 @@
+84.344;0.00024;0.00768;-0.055;1.4089;-3.4084;1.0153;-2.9039;2.569;-7.297;22.9896;
+87.16;0.00024;0.00768;-0.066;1.4089;-3.4084;1.0153;-2.9039;2.569;-7.297;22.9896;
+87.992;0.00024;0.00768;-0.066;1.4089;-3.4084;1.0153;-3.19429;2.569;-7.297;22.9896;
+88.112;0.00024;0.00768;-0.0693;1.4089;-3.4084;1.06607;-3.354;2.569;-7.66185;24.1391;
+88.168;0.00024;0.008064;-0.0693;1.4089;-3.4084;1.06607;-3.5217;2.569;-7.66185;25.346;
+88.256;0.00024;0.008064;-0.0710325;1.4089;-3.4084;1.06607;-3.60975;2.569;-7.66185;25.9797;
+88.272;0.00024;0.0082656;-0.0710325;1.4089;-3.4084;1.06607;-3.69999;2.569;-7.66185;25.9797;
+88.312;0.000243;0.0082656;-0.0710325;1.4089;-3.4084;1.06607;-3.69999;2.569;-7.75762;26.6332;
+88.336;0.000246038;0.00836892;-0.0710325;1.4089;-3.4084;1.06607;-3.74624;2.569;-7.75762;26.9662;
+88.344;0.000246038;0.00836892;-0.0714765;1.4089;-3.4084;1.06607;-3.74624;2.569;-7.75762;27.1347;
+88.36;0.000246038;0.00844754;-0.0714765;1.4089;-3.4084;1.06607;-3.78144;2.569;-7.75762;27.1347;
+88.368;0.00024623;0.00845414;-0.0714765;1.4089;-3.4084;1.06607;-3.78144;2.569;-7.75762;27.1347;
+88.048;0.00024;0.00768;-0.055;1.4089;-3.4084;1.0153;-2.9039;2.569;-7.297;19.158;
+88.12;0.00024;0.00768;-0.066;1.4089;-3.4084;1.0153;-2.9039;2.569;-7.297;19.158;
+88.144;0.00024;0.008448;-0.0726;1.4089;-3.4084;1.0153;-2.9039;2.569;-7.297;19.158;
+88.16;0.00024;0.008448;-0.0726;1.4089;-3.4084;1.0153;-2.9039;2.569;-7.297;19.637;
+88.208;0.00024;0.008448;-0.0726;1.4089;-3.4084;1.0153;-2.9765;2.569;-7.297;19.637;
+88.232;0.00024;0.008448;-0.074415;1.4089;-3.4084;1.0153;-3.0137;2.569;-7.297;20.8921;
+88.248;0.00024;0.0085536;-0.074415;1.4089;-3.4084;1.0153;-3.0137;2.569;-7.38821;21.1533;
+88.384;0.00024;0.0085536;-0.074415;1.4089;-3.4084;1.0153;-3.0137;2.569;-7.38821;21.4177;
+88.392;0.00024;0.00858033;-0.074415;1.4089;-3.4084;1.0153;-3.03257;2.569;-7.38821;21.4177;
+88.408;0.00024;0.00858033;-0.0745313;1.4111;-3.4084;1.0153;-3.03257;2.569;-7.39976;21.4512;
+88.416;0.000240188;0.00859374;-0.0749983;1.4111;-3.41106;1.01609;-3.03257;2.569;-7.39976;21.4512;
+88.048;0.00024;0.00768;-0.055;1.4089;-3.4084;1.0153;-2.9039;2.569;-7.297;19.158;
+88.12;0.00024;0.00768;-0.066;1.4089;-3.4084;1.0153;-2.9039;2.569;-7.297;19.158;
+88.144;0.00024;0.008448;-0.0726;1.4089;-3.4084;1.0153;-2.9039;2.569;-7.297;19.158;
+82.384;0.00020001;0.0064;-0.0550027;1.40897;-3.4084;1.01535;-2.90404;2.569;-7.29736;19.158;
+82.392;0.00020001;0.00640031;-0.0550054;1.40897;-3.4084;1.0154;-2.90404;2.569;-7.29736;19.158;
+82.456;0.00020001;0.00640031;-0.0550054;1.40904;-3.4084;1.0154;-2.90404;2.56913;-7.29736;19.158;
+82.568;0.00020001;0.00640031;-0.0550081;1.40911;-3.40857;1.0155;-2.90404;2.56925;-7.29736;19.1589;
+82.576;0.00020002;0.00640063;-0.0550081;1.40911;-3.40857;1.01555;-2.90404;2.56925;-7.29736;19.1589;
+82.648;0.00020002;0.00640094;-0.0550107;1.40918;-3.40873;1.0156;-2.90404;2.56925;-7.29736;19.1589;
+82.784;0.000200029;0.00640094;-0.0550107;1.40924;-3.40873;1.0156;-2.90418;2.56938;-7.29736;19.1599;
+82.808;0.000200029;0.00640125;-0.0550107;1.40931;-3.40873;1.0156;-2.90433;2.5695;-7.29771;19.1608;
+82.856;0.000200039;0.00640156;-0.0550134;1.40938;-3.4089;1.0156;-2.90447;2.56963;-7.29807;19.1617;
+82.912;0.000200039;0.00640188;-0.0550134;1.40945;-3.4089;1.0156;-2.90447;2.56975;-7.29807;19.1617;
+82.92;0.000200039;0.00640188;-0.0550134;1.40945;-3.4089;1.01565;-2.90461;2.56975;-7.29807;19.1617;
+82.952;0.000200049;0.00640188;-0.0550134;1.40952;-3.40907;1.01565;-2.90461;2.56975;-7.29807;19.1627;
+83.008;0.000200059;0.00640219;-0.0550134;1.40959;-3.40907;1.01565;-2.90475;2.56975;-7.29807;19.1627;
+83.016;0.000200059;0.0064025;-0.0550161;1.40959;-3.40923;1.01565;-2.90475;2.56988;-7.29807;19.1636;
+83.128;0.000200068;0.0064025;-0.0550188;1.40966;-3.4094;1.01565;-2.90489;2.57;-7.29807;19.1645;
+83.144;0.000200068;0.0064025;-0.0550188;1.40966;-3.40957;1.0157;-2.90503;2.57013;-7.29807;19.1655;
+83.168;0.000200068;0.00640281;-0.0550188;1.40973;-3.40957;1.01575;-2.90518;2.57013;-7.29843;19.1664;
+83.272;0.000200078;0.00640313;-0.0550188;1.40979;-3.40973;1.01575;-2.90518;2.57013;-7.29843;19.1664;
+83.28;0.000200088;0.00640375;-0.0550242;1.40979;-3.40973;1.0158;-2.90532;2.57013;-7.29843;19.1674;
+83.304;0.000200088;0.00640375;-0.0550242;1.40986;-3.40973;1.0158;-2.90546;2.57013;-7.29878;19.1674;
+83.32;0.000200088;0.00640406;-0.0550242;1.40986;-3.40973;1.01585;-2.90546;2.57025;-7.29878;19.1674;
+83.368;0.000200088;0.00640438;-0.0550269;1.40993;-3.40973;1.01585;-2.9056;2.57025;-7.29878;19.1683;
+83.384;0.000200088;0.00640438;-0.0550295;1.40993;-3.40973;1.0159;-2.9056;2.57038;-7.29878;19.1683;
+83.392;0.000200098;0.00640438;-0.0550295;1.40993;-3.40973;1.01594;-2.90574;2.57038;-7.29878;19.1683;
+83.432;0.000200107;0.00640531;-0.0550322;1.41007;-3.41023;1.01604;-2.90589;2.57063;-7.29949;19.1692;
+83.448;0.000200107;0.00640531;-0.0550349;1.41014;-3.4104;1.01604;-2.90603;2.57063;-7.29985;19.1692;
+83.472;0.000200117;0.00640531;-0.0550349;1.41014;-3.41056;1.01604;-2.90603;2.57076;-7.30021;19.1692;
+83.528;0.000200117;0.00640531;-0.0550376;1.41014;-3.41056;1.01609;-2.90603;2.57088;-7.30021;19.1702;
+83.576;0.000200127;0.00640563;-0.0550376;1.41021;-3.41056;1.01609;-2.90603;2.57088;-7.30021;19.1711;
+83.64;0.000200137;0.00640594;-0.0550376;1.41028;-3.41056;1.01609;-2.90603;2.57101;-7.30021;19.172;
+83.672;0.000200137;0.00640594;-0.0550403;1.41028;-3.41056;1.01609;-2.90617;2.57113;-7.30056;19.173;
+83.72;0.000200137;0.00640625;-0.0550403;1.41035;-3.41073;1.01614;-2.90617;2.57113;-7.30056;19.173;
+83.76;0.000200147;0.00640657;-0.0550403;1.41041;-3.41073;1.01614;-2.90631;2.57113;-7.30056;19.173;
+83.856;0.000200147;0.00640657;-0.0550403;1.41048;-3.41073;1.01619;-2.90645;2.57113;-7.30056;19.173;
+83.904;0.000200176;0.00640688;-0.055043;1.41055;-3.41073;1.01624;-2.90674;2.57126;-7.30092;19.1748;
+83.936;0.000200176;0.00640688;-0.055043;1.41062;-3.41073;1.01624;-2.90674;2.57126;-7.30128;19.1748;
+84.008;0.000200176;0.00640719;-0.055043;1.41069;-3.41073;1.01624;-2.90688;2.57138;-7.30128;19.1758;
+84.016;0.000200186;0.00640782;-0.0550484;1.41076;-3.4109;1.01624;-2.90688;2.57151;-7.30163;19.1767;
+84.12;0.000200186;0.00640813;-0.0550484;1.41076;-3.4109;1.01629;-2.90702;2.57164;-7.30163;19.1777;
+84.168;0.000200186;0.00640844;-0.0550484;1.41076;-3.4109;1.01634;-2.90702;2.57164;-7.30163;19.1786;
+84.176;0.000200186;0.00640876;-0.0550484;1.41083;-3.41106;1.01634;-2.90702;2.57164;-7.30199;19.1786;
+84.192;0.000200195;0.00640876;-0.0550484;1.4109;-3.41106;1.01634;-2.90702;2.57164;-7.30235;19.1786;
+84.224;0.000200195;0.00640876;-0.055051;1.4109;-3.41106;1.01634;-2.90716;2.57176;-7.3027;19.1795;
+84.28;0.000200195;0.00640876;-0.055051;1.41097;-3.41106;1.01639;-2.9073;2.57189;-7.3027;19.1795;
+84.32;0.000200205;0.00640907;-0.0550537;1.41097;-3.41106;1.01644;-2.90759;2.57201;-7.3027;19.1805;
+84.352;0.000200215;0.00640907;-0.0550564;1.41097;-3.41106;1.01649;-2.90759;2.57201;-7.3027;19.1814;
+84.376;0.000200215;0.00640907;-0.0550564;1.41103;-3.41123;1.01649;-2.90773;2.57201;-7.30306;19.1823;
+84.416;0.000200215;0.00640938;-0.0550591;1.4111;-3.4114;1.01649;-2.90773;2.57214;-7.30306;19.1823;
+84.432;0.000200225;0.00641001;-0.0550618;1.4111;-3.41156;1.01649;-2.90787;2.57226;-7.30342;19.1833;
+84.464;0.000200235;0.00641001;-0.0550618;1.41117;-3.41156;1.01649;-2.90787;2.57226;-7.30377;19.1842;
+84.504;0.000200244;0.00641001;-0.0550645;1.41124;-3.41156;1.01654;-2.90787;2.57226;-7.30377;19.1842;
+84.552;0.000200244;0.00641032;-0.0550645;1.41131;-3.41156;1.01654;-2.90787;2.57239;-7.30449;19.1842;
+84.624;0.000200244;0.00641063;-0.0550645;1.41131;-3.41156;1.01654;-2.90787;2.57251;-7.30449;19.1851;
+84.64;0.000200254;0.00641126;-0.0550645;1.41131;-3.41173;1.01669;-2.90816;2.57264;-7.30449;19.1861;
+84.672;0.000200254;0.00641126;-0.0550645;1.41138;-3.4119;1.01669;-2.90816;2.57264;-7.30449;19.187;
+84.72;0.000200254;0.00641157;-0.0550645;1.41138;-3.4119;1.01669;-2.90816;2.57277;-7.30449;19.188;
+84.768;0.000200254;0.00641157;-0.0550645;1.41138;-3.4119;1.01669;-2.90816;2.57289;-7.30449;19.188;
+84.792;0.000200264;0.00641157;-0.0550645;1.41145;-3.4119;1.01669;-2.90816;2.57302;-7.30484;19.188;
+84.8;0.000200274;0.00641157;-0.0550645;1.41145;-3.41206;1.01669;-2.9083;2.57314;-7.30484;19.188;
+84.872;0.000200283;0.00641189;-0.0550672;1.41152;-3.41206;1.01669;-2.9083;2.57327;-7.3052;19.1889;
+84.92;0.000200293;0.0064122;-0.0550699;1.41159;-3.41206;1.01669;-2.9083;2.57339;-7.3052;19.1889;
+84.944;0.000200303;0.00641251;-0.0550699;1.41165;-3.41223;1.01669;-2.9083;2.57339;-7.30556;19.1889;
+84.952;0.000200303;0.00641283;-0.0550726;1.41172;-3.4124;1.01669;-2.9083;2.57339;-7.30556;19.1898;
+84.968;0.000200313;0.00641283;-0.0550752;1.41172;-3.41256;1.01674;-2.90844;2.57352;-7.30591;19.1898;
+85.008;0.000200323;0.00641283;-0.0550779;1.41172;-3.41256;1.01674;-2.90844;2.57365;-7.30591;19.1908;
+85.072;0.000200323;0.00641283;-0.0550779;1.41179;-3.41256;1.01679;-2.90858;2.57377;-7.30591;19.1908;
+85.096;0.000200332;0.00641283;-0.0550779;1.41179;-3.41256;1.01684;-2.90858;2.5739;-7.30591;19.1908;
+85.104;0.000200342;0.00641283;-0.0550779;1.41179;-3.41273;1.01684;-2.90858;2.5739;-7.30591;19.1917;
+85.112;0.000200352;0.00641283;-0.0550779;1.41179;-3.41273;1.01684;-2.90858;2.5739;-7.30627;19.1917;
+85.144;0.000200362;0.00641283;-0.0550806;1.41179;-3.4129;1.01689;-2.90858;2.57402;-7.30627;19.1936;
+85.168;0.000200371;0.00641283;-0.0550806;1.41186;-3.41306;1.01689;-2.90858;2.57402;-7.30663;19.1936;
+85.216;0.000200381;0.00641314;-0.0550806;1.41193;-3.41306;1.01689;-2.90872;2.57402;-7.30663;19.1945;
+85.296;0.000200381;0.00641376;-0.0550806;1.412;-3.41306;1.01689;-2.90872;2.57415;-7.30698;19.1945;
+85.352;0.000200391;0.00641408;-0.0550806;1.412;-3.41323;1.01694;-2.90872;2.57427;-7.30698;19.1945;
+85.384;0.000200401;0.00641408;-0.0550833;1.41207;-3.4134;1.01699;-2.90872;2.5744;-7.30734;19.1955;
+85.416;0.000200401;0.00641439;-0.0550833;1.41214;-3.4134;1.01699;-2.90887;2.5744;-7.3077;19.1955;
+85.432;0.00020042;0.00641502;-0.0550914;1.41221;-3.41356;1.01709;-2.90915;2.57453;-7.30841;19.1983;
+85.448;0.00020044;0.00641502;-0.0550941;1.41227;-3.41373;1.01719;-2.90929;2.57453;-7.30841;19.1983;
+85.472;0.00020045;0.00641502;-0.0550941;1.41234;-3.41373;1.01724;-2.90944;2.57453;-7.30877;19.1983;
+85.48;0.00020045;0.00641533;-0.0550941;1.41234;-3.4139;1.01724;-2.90944;2.57453;-7.30912;19.1992;
+85.552;0.00020046;0.00641533;-0.0550968;1.41248;-3.41423;1.01724;-2.90944;2.57465;-7.30948;19.2001;
+85.568;0.00020046;0.00641564;-0.0550995;1.41255;-3.41423;1.01724;-2.90944;2.57465;-7.30948;19.2011;
+85.6;0.000200479;0.00641596;-0.0551021;1.41255;-3.41423;1.01724;-2.90972;2.57478;-7.30984;19.202;
+85.624;0.000200489;0.00641596;-0.0551021;1.41262;-3.4144;1.01728;-2.90986;2.5749;-7.30984;19.202;
+85.64;0.000200499;0.00641596;-0.0551021;1.41262;-3.4144;1.01728;-2.90986;2.5749;-7.31019;19.202;
+85.696;0.000200499;0.00641627;-0.0551021;1.41262;-3.41456;1.01728;-2.90986;2.57503;-7.31019;19.202;
+85.712;0.000200508;0.00641627;-0.0551021;1.41269;-3.41456;1.01733;-2.90986;2.57503;-7.31055;19.202;
+85.76;0.000200508;0.00641658;-0.0551048;1.41276;-3.41456;1.01738;-2.91;2.57503;-7.31055;19.203;
+85.768;0.000200518;0.0064169;-0.0551075;1.41276;-3.41456;1.01743;-2.91;2.57503;-7.31091;19.203;
+85.784;0.000200518;0.00641721;-0.0551075;1.41276;-3.41456;1.01743;-2.91015;2.57515;-7.31091;19.203;
+85.832;0.000200518;0.00641721;-0.0551075;1.41283;-3.41456;1.01743;-2.91015;2.57528;-7.31091;19.2039;
+85.88;0.000200518;0.00641752;-0.0551102;1.4129;-3.41456;1.01743;-2.91029;2.57528;-7.31091;19.2039;
+85.944;0.000200518;0.00641784;-0.0551102;1.4129;-3.41456;1.01748;-2.91043;2.57541;-7.31091;19.2039;
+85.968;0.000200518;0.00641784;-0.0551102;1.4129;-3.41456;1.01753;-2.91043;2.57553;-7.31091;19.2039;
+85.976;0.000200538;0.00641815;-0.0551129;1.41303;-3.4149;1.01763;-2.91071;2.57566;-7.31162;19.2058;
+86.008;0.000200538;0.00641815;-0.0551183;1.4131;-3.41506;1.01768;-2.91071;2.57566;-7.31198;19.2067;
+86.04;0.000200548;0.00641846;-0.0551183;1.41317;-3.41506;1.01773;-2.91071;2.57566;-7.31198;19.2067;
+86.048;0.000200557;0.00641878;-0.055121;1.41317;-3.41506;1.01773;-2.91086;2.57566;-7.31198;19.2067;
+86.072;0.000200567;0.0064194;-0.0551237;1.41324;-3.41523;1.01783;-2.91128;2.57578;-7.31234;19.2067;
+86.096;0.000200567;0.0064194;-0.0551264;1.41331;-3.41523;1.01783;-2.91128;2.57578;-7.31269;19.2067;
+86.144;0.000200577;0.00641972;-0.0551264;1.41338;-3.4154;1.01783;-2.91128;2.57578;-7.31269;19.2067;
+86.176;0.000200597;0.00641972;-0.0551264;1.41345;-3.4154;1.01788;-2.91142;2.57578;-7.31269;19.2076;
+86.224;0.000200606;0.00642003;-0.0551291;1.41352;-3.41556;1.01788;-2.91142;2.57578;-7.31269;19.2076;
+86.28;0.000200606;0.00642003;-0.0551291;1.41359;-3.41573;1.01788;-2.91142;2.57591;-7.31269;19.2076;
+86.36;0.000200606;0.00642003;-0.0551317;1.41365;-3.41573;1.01793;-2.91142;2.57603;-7.31269;19.2086;
+86.416;0.000200616;0.00642003;-0.0551344;1.41372;-3.4159;1.01793;-2.91157;2.57603;-7.31269;19.2095;
+86.424;0.000200626;0.00642003;-0.0551344;1.41372;-3.41606;1.01798;-2.91171;2.57603;-7.31305;19.2095;
+86.432;0.000200636;0.00642034;-0.0551371;1.41372;-3.41623;1.01803;-2.91171;2.57603;-7.31305;19.2105;
+86.448;0.000200675;0.00642066;-0.0551425;1.41386;-3.41673;1.01818;-2.91185;2.57603;-7.31341;19.2133;
+86.456;0.000200685;0.00642066;-0.0551452;1.41393;-3.4169;1.01828;-2.91199;2.57616;-7.31376;19.2142;
+86.488;0.000200695;0.00642066;-0.0551506;1.41407;-3.41723;1.01833;-2.91214;2.57629;-7.31448;19.2151;
+86.504;0.000200695;0.00642097;-0.0551533;1.41414;-3.41757;1.01833;-2.91214;2.57629;-7.31448;19.2151;
+86.536;0.000200695;0.0064216;-0.0551587;1.41428;-3.4179;1.01843;-2.91242;2.57654;-7.31555;19.2161;
+86.56;0.000200704;0.00642191;-0.0551641;1.41435;-3.41807;1.01843;-2.91242;2.57654;-7.31555;19.217;
+86.576;0.000200714;0.00642191;-0.0551668;1.41435;-3.41807;1.01848;-2.91242;2.57654;-7.31555;19.218;
+86.584;0.000200724;0.00642191;-0.0551668;1.41435;-3.41823;1.01853;-2.91242;2.57654;-7.31591;19.218;
+86.6;0.000200734;0.00642223;-0.0551668;1.41441;-3.41823;1.01853;-2.91256;2.57654;-7.31627;19.218;
+86.616;0.000200734;0.00642254;-0.0551694;1.41441;-3.4184;1.01863;-2.9127;2.57666;-7.31662;19.2189;
+86.664;0.000200744;0.00642254;-0.0551721;1.41448;-3.4184;1.01868;-2.91285;2.57666;-7.31662;19.2189;
+86.704;0.000200744;0.00642254;-0.0551721;1.41455;-3.4184;1.01873;-2.91299;2.57666;-7.31662;19.2198;
+86.72;0.000200744;0.00642285;-0.0551748;1.41462;-3.41857;1.01878;-2.91313;2.57666;-7.31698;19.2198;
+86.784;0.000200744;0.00642317;-0.0551775;1.41469;-3.41857;1.01878;-2.91327;2.57679;-7.31698;19.2198;
+86.792;0.000200753;0.00642317;-0.0551802;1.41476;-3.41873;1.01883;-2.91327;2.57679;-7.31734;19.2198;
+86.824;0.000200753;0.00642379;-0.0551829;1.4149;-3.4189;1.01888;-2.91327;2.57679;-7.31805;19.2198;
+86.84;0.000200753;0.00642379;-0.0551829;1.4149;-3.4189;1.01893;-2.91342;2.57679;-7.31805;19.2198;
+86.848;0.000200753;0.00642379;-0.0551856;1.41497;-3.4189;1.01898;-2.91356;2.57679;-7.31841;19.2198;
+86.856;0.000200753;0.00642379;-0.0551856;1.41497;-3.4189;1.01902;-2.91356;2.57679;-7.31877;19.2198;
+86.872;0.000200753;0.00642411;-0.0551883;1.41504;-3.41907;1.01902;-2.91356;2.57679;-7.31912;19.2208;
+86.88;0.000200763;0.00642442;-0.055191;1.41504;-3.41923;1.01902;-2.91356;2.57691;-7.31912;19.2208;
+86.888;0.000200763;0.00642473;-0.0551937;1.4151;-3.4194;1.01902;-2.91356;2.57691;-7.31912;19.2217;
+86.896;0.000200773;0.00642473;-0.0551964;1.4151;-3.4194;1.01907;-2.91356;2.57691;-7.31912;19.2217;
+86.904;0.000200783;0.00642505;-0.0552018;1.4151;-3.41974;1.01912;-2.9137;2.57717;-7.31948;19.2245;
+86.944;0.000200793;0.00642568;-0.0552072;1.41531;-3.4199;1.01912;-2.91413;2.57742;-7.31984;19.2264;
+86.96;0.000200793;0.00642568;-0.0552072;1.41538;-3.4199;1.01912;-2.91413;2.57742;-7.3202;19.2264;
+87.024;0.000200802;0.00642568;-0.0552072;1.41545;-3.4199;1.01917;-2.91427;2.57742;-7.32055;19.2264;
+87.056;0.000200812;0.00642568;-0.0552072;1.41552;-3.42024;1.01917;-2.91455;2.57742;-7.32055;19.2292;
+87.072;0.000200822;0.00642568;-0.0552072;1.41552;-3.42024;1.01922;-2.91455;2.57754;-7.32091;19.2292;
+87.08;0.000200832;0.00642568;-0.0552099;1.41559;-3.4204;1.01922;-2.9147;2.57767;-7.32091;19.2302;
+87.088;0.000200842;0.00642599;-0.0552126;1.41566;-3.42057;1.01922;-2.91484;2.57767;-7.32127;19.2311;
+87.096;0.000200851;0.00642599;-0.0552153;1.41573;-3.42057;1.01932;-2.91498;2.57767;-7.32127;19.2311;
+87.104;0.000200861;0.00642599;-0.0552207;1.41573;-3.42074;1.01942;-2.91527;2.57767;-7.32163;19.233;
+87.112;0.0002009;0.00642787;-0.0552314;1.41587;-3.42107;1.01967;-2.91583;2.57767;-7.32306;19.2349;
+87.128;0.00020091;0.0064285;-0.0552341;1.41593;-3.42124;1.01972;-2.91598;2.5778;-7.32306;19.2349;
+87.168;0.00020091;0.00642881;-0.0552341;1.41593;-3.42141;1.01977;-2.91598;2.57792;-7.32306;19.2358;
+87.192;0.00020091;0.00642913;-0.0552368;1.416;-3.42157;1.01977;-2.91612;2.57792;-7.32306;19.2358;
+87.2;0.000200979;0.00643101;-0.0552557;1.41607;-3.42291;1.01997;-2.91712;2.57792;-7.32377;19.2424;
+87.208;0.000200989;0.00643101;-0.0552557;1.41607;-3.42324;1.01997;-2.91726;2.57792;-7.32377;19.2443;
+87.216;0.000201018;0.0064329;-0.0552611;1.41607;-3.42341;1.02002;-2.91797;2.57792;-7.32413;19.248;
+86.256;0.0002;0.00768;-0.055;1.4089;-3.4084;1.0153;-2.32312;2.569;-7.297;15.3264;
+87.512;0.00016;0.00768;-0.044;1.4089;-3.4084;1.0153;-2.78774;2.569;-7.297;18.3917;
+87.592;0.000192;0.00768;-0.0352;1.4089;-3.4084;1.0153;-3.34529;2.569;-7.297;18.3917;
+87.864;0.0001536;0.00768;-0.0352;1.4089;-3.4084;1.0153;-3.34529;2.569;-7.297;22.07;
+88.504;0.00018432;0.00768;-0.04224;1.4089;-3.4084;1.0153;-3.34529;2.569;-7.297;22.07;
+88.632;0.000202752;0.00768;-0.046464;1.4089;-3.4084;1.0153;-3.34529;2.569;-7.297;22.07;
+88.72;0.000202752;0.00768;-0.046464;1.4089;-3.4084;1.0153;-3.17803;2.569;-7.297;20.9665;
+88.736;0.000202752;0.007872;-0.0488162;1.4089;-3.32319;1.0153;-3.17604;2.569;-7.47942;20.9665;
+88.848;0.000207821;0.007872;-0.0500366;1.4089;-3.32319;1.0153;-3.17604;2.569;-7.47942;20.9665;
+88.976;0.000207821;0.007872;-0.0512876;1.4089;-3.32319;1.0153;-3.17604;2.569;-7.47942;21.4907;
+89;0.000213016;0.007872;-0.0525698;1.4089;-3.32319;1.0153;-3.17604;2.569;-7.47942;21.4907;
+89.008;0.000207691;0.007872;-0.0525698;1.4089;-3.32319;1.0153;-3.17604;2.569;-7.47942;21.4907;
+89.016;0.000212883;0.007872;-0.0525698;1.4089;-3.32319;1.0153;-3.17604;2.569;-7.47942;21.4907;
+89.04;0.000207561;0.0076752;-0.053884;1.4089;-3.32319;1.0153;-3.09664;2.569;-7.47942;22.0279;
+89.064;0.00021275;0.0076752;-0.0552311;1.4089;-3.32319;1.0153;-3.09664;2.569;-7.47942;22.0279;
+89.072;0.000202246;0.00806376;-0.0580272;1.4089;-3.32319;1.0153;-3.09664;2.569;-7.47942;22.0279;
+89.104;0.000202246;0.00806376;-0.0565765;1.4089;-3.32319;1.0153;-3.09664;2.569;-7.47942;21.4772;
+89.16;0.000197189;0.00806376;-0.0565765;1.4089;-3.32319;1.0153;-3.01922;2.569;-7.47942;20.9403;
+89.168;0.000199654;0.00816455;-0.0565765;1.4089;-3.32319;1.0153;-3.01922;2.569;-7.47942;20.6786;
+89.184;0.000199654;0.0080625;-0.0572837;1.4089;-3.32319;1.0153;-2.98148;2.569;-7.47942;20.6786;
+89.192;0.000199654;0.00796172;-0.0587247;1.4089;-3.28165;1.0153;-2.98148;2.569;-7.47942;20.4201;
+89.216;0.00020215;0.00796172;-0.0587247;1.4089;-3.28165;1.0153;-2.98148;2.569;-7.47942;20.1648;
+89.224;0.000207235;0.00786219;-0.0587156;1.4089;-3.28165;1.0153;-2.98148;2.569;-7.47942;20.1648;
+89.248;0.000207235;0.00786219;-0.0594495;1.4089;-3.28165;1.0153;-2.94422;2.569;-7.47942;20.1648;
+89.296;0.000204645;0.00786219;-0.0601926;1.4089;-3.28165;1.0153;-2.94422;2.569;-7.47942;20.4169;
+89.304;0.000205924;0.00786219;-0.0605688;1.4089;-3.28165;1.0153;-2.94422;2.569;-7.47942;20.4169;
+89.32;0.000205924;0.00786219;-0.0609474;1.4089;-3.28165;1.0153;-2.92581;2.569;-7.47942;20.2893;
+89.328;0.000203979;0.00793567;-0.0613235;1.4089;-3.28165;1.0153;-2.92579;2.569;-7.47942;20.2257;
+89.336;0.000203342;0.00791087;-0.0615151;1.4089;-3.27139;1.0153;-2.92579;2.569;-7.47942;20.2257;
+89.344;0.000203978;0.00791087;-0.0615151;1.4089;-3.27139;1.0153;-2.92579;2.569;-7.47942;20.2257;
+89.352;0.000203336;0.00791064;-0.0620924;1.4089;-3.26117;1.0153;-2.91664;2.569;-7.47942;20.0995;
+89.36;0.000202067;0.00796016;-0.0626758;1.4089;-3.26117;1.0153;-2.9075;2.569;-7.47942;20.0367;
+89.368;0.000202699;0.00796016;-0.0628716;1.4089;-3.26117;1.0153;-2.9075;2.569;-7.47942;19.974;
+89.376;0.000202689;0.00796016;-0.0627703;1.4089;-3.26117;1.0153;-2.9075;2.569;-7.47942;19.974;
+89.384;0.000202689;0.00796016;-0.0628684;1.4089;-3.26117;1.0153;-2.9075;2.569;-7.47942;20.0053;
+89.408;0.000202847;0.00796637;-0.0628193;1.41;-3.26627;1.01689;-2.9075;2.56699;-7.49112;20.0053;
+89.424;0.000202847;0.00796015;-0.0628193;1.41;-3.26627;1.01689;-2.9075;2.56699;-7.49112;19.9896;
+89.44;0.000203006;0.00795393;-0.0628193;1.41;-3.26882;1.01689;-2.9075;2.56699;-7.48526;20.0209;
+89.456;0.000203164;0.00795393;-0.0628193;1.41;-3.26882;1.01689;-2.90977;2.56699;-7.48526;20.0209;
+89.464;0.000203006;0.00794772;-0.0628684;1.41;-3.26627;1.01689;-2.91204;2.56699;-7.48526;20.0209;
+89.472;0.000202688;0.00797257;-0.0628683;1.41;-3.26882;1.01689;-2.91204;2.56699;-7.48526;20.0052;
+89.48;0.000202528;0.00797878;-0.0630215;1.41;-3.26754;1.01748;-2.91429;2.56699;-7.49184;20.0285;
+82.48;0.0002;0.00636;-0.0553437;1.4089;-3.4084;1.0153;-2.92205;2.569;-7.25139;19.158;
+84.56;0.0002;0.00636;-0.0553437;1.4089;-3.4297;1.02165;-2.94031;2.58506;-7.20607;19.158;
+85.008;0.0002;0.00636;-0.0553437;1.4089;-3.4297;1.02803;-2.94031;2.58506;-7.25111;19.0383;
+85.2;0.00020125;0.00639975;-0.0553437;1.4089;-3.4297;1.02803;-2.94031;2.58506;-7.29643;19.0383;
+85.568;0.000202508;0.00643975;-0.0553437;1.4089;-3.4297;1.03446;-2.95869;2.58506;-7.34203;19.1573;
+87.936;0.000201242;0.00643975;-0.0553437;1.41771;-3.45114;1.04092;-2.9402;2.5689;-7.29614;19.1573;
+89.136;0.000199984;0.00643975;-0.0553437;1.42657;-3.45114;1.04743;-2.9402;2.55284;-7.34175;19.277;
+89.208;0.000199984;0.00648;-0.0549979;1.42657;-3.45114;1.04743;-2.9402;2.55284;-7.38763;19.277;
+89.216;0.000198734;0.00648;-0.0549979;1.42657;-3.45114;1.04743;-2.9402;2.55284;-7.38763;19.3975;
+89.232;0.000199977;0.0065205;-0.0553416;1.42657;-3.45114;1.04743;-2.9402;2.55284;-7.38763;19.2762;
+89.288;0.000199977;0.0065205;-0.0553416;1.42657;-3.42957;1.04743;-2.9402;2.55284;-7.38763;19.2762;
+89.304;0.000198727;0.00656125;-0.0556875;1.42657;-3.42957;1.04743;-2.95857;2.55284;-7.38763;19.2762;
+89.32;0.000199969;0.00656125;-0.0556875;1.42657;-3.42957;1.04743;-2.95857;2.55284;-7.38763;19.1558;
+89.368;0.000199969;0.00656125;-0.0560355;1.42657;-3.40813;1.04743;-2.97706;2.55284;-7.38763;19.1558;
+89.408;0.000199969;0.00656125;-0.0556853;1.42657;-3.40813;1.04743;-2.97706;2.55284;-7.38763;19.1558;
+89.424;0.000201219;0.00656125;-0.0556853;1.42657;-3.40813;1.04743;-2.99567;2.55284;-7.38763;19.2755;
+89.44;0.000201219;0.00656125;-0.0556853;1.42657;-3.40813;1.04743;-3.01439;2.55284;-7.38763;19.2755;
+89.448;0.000201219;0.00656125;-0.0556853;1.42657;-3.40813;1.04743;-3.03323;2.55284;-7.38763;19.396;
+89.464;0.000201219;0.00660226;-0.0553373;1.42657;-3.40813;1.04743;-3.03323;2.55284;-7.38763;19.396;
+89.52;0.000201219;0.00664352;-0.0553373;1.42657;-3.40813;1.04743;-3.05219;2.55284;-7.38763;19.2747;
+89.592;0.000202476;0.00668504;-0.0549914;1.42657;-3.40813;1.04743;-3.05219;2.55284;-7.38763;19.1543;
+89.6;0.000203742;0.00668478;-0.0553351;1.42657;-3.40813;1.04743;-3.05219;2.55284;-7.38763;19.1543;
+89.608;0.000203742;0.00668478;-0.0549893;1.42657;-3.40813;1.04743;-3.05219;2.55284;-7.38763;19.1543;
+89.616;0.000203742;0.0067686;-0.0556788;1.42657;-3.40813;1.04743;-3.05219;2.55284;-7.38763;19.0345;
+89.656;0.000202468;0.00681091;-0.0563769;1.42657;-3.40813;1.04743;-3.05207;2.55284;-7.38763;19.1535;
+89.672;0.000202437;0.00685321;-0.0570772;1.42657;-3.40813;1.04743;-3.05195;2.55284;-7.38763;19.1535;
+89.68;0.000202421;0.00693914;-0.0577906;1.42657;-3.40813;1.04743;-3.07091;2.55284;-7.38763;19.152;
+89.688;0.000199891;0.00702588;-0.0585129;1.42657;-3.40813;1.04743;-3.07091;2.55284;-7.38763;19.152;
+89.696;0.000198595;0.00706924;-0.0592443;1.42657;-3.40813;1.04743;-3.05148;2.55284;-7.38763;19.1498;
+89.704;0.000197354;0.00711342;-0.059242;1.42657;-3.40813;1.04743;-3.07043;2.55284;-7.38763;19.1498;
+89.728;0.000182799;0.00765582;-0.0637592;1.42657;-3.40813;1.04743;-3.07043;2.55284;-7.38763;19.1498;
+89.744;0.000173659;0.00803861;-0.0669472;1.42657;-3.40813;1.04743;-3.07043;2.55284;-7.38763;19.1498;
+89.752;0.00017583;0.00793813;-0.067784;1.42657;-3.40813;1.04743;-3.03205;2.55284;-7.38763;19.1498;
+89.76;0.000173632;0.00793688;-0.0686313;1.42657;-3.40813;1.04743;-3.06995;2.55284;-7.38763;19.3891;
+89.816;0.000173632;0.00793688;-0.0686313;1.42657;-3.40813;1.06052;-3.10832;2.55284;-7.47998;19.6315;
+89.872;0.000171461;0.0080361;-0.0686313;1.42657;-3.40813;1.06052;-3.14718;2.55284;-7.47998;19.8769;
+89.88;0.000171461;0.00806121;-0.0684168;1.42657;-3.41878;1.06052;-3.14718;2.55284;-7.47998;19.939;
+89.888;0.000170925;0.00806113;-0.068203;1.42657;-3.41878;1.06052;-3.14718;2.55284;-7.47998;19.8767;
+89.896;0.000171995;0.00803594;-0.0679899;1.42657;-3.41878;1.06052;-3.14718;2.55284;-7.47998;19.8767;
+89.904;0.000171789;0.00804514;-0.0680941;1.42657;-3.41878;1.06052;-3.14287;2.55284;-7.47998;19.8301;
+83.1086;0.00019875;0.0064;-0.0553437;1.4089;-3.3871;1.0153;-2.92205;2.569;-7.297;19.158;
+87.0781;0.00019875;0.00636;-0.0553437;1.41771;-3.36593;1.0153;-2.94031;2.569;-7.297;19.158;
+87.1619;0.00019875;0.00632025;-0.0553437;1.41771;-3.34489;1.0153;-2.95869;2.569;-7.25139;19.158;
+87.261;0.00019875;0.00635975;-0.0549979;1.41771;-3.34489;1.0153;-2.95869;2.569;-7.25139;19.158;
+87.4743;0.000199992;0.00635975;-0.0546541;1.41771;-3.34489;1.02165;-2.95869;2.569;-7.25139;19.158;
+87.8095;0.000198742;0.00635975;-0.0549957;1.42657;-3.3658;1.02165;-2.95869;2.55294;-7.25139;19.158;
+87.9086;0.0001975;0.0063995;-0.0553394;1.42657;-3.3658;1.02803;-2.95869;2.55294;-7.25139;19.2777;
+88.0152;0.000196266;0.00639925;-0.0553394;1.42657;-3.38683;1.02799;-2.95869;2.55294;-7.25139;19.1573;
+88.1219;0.000196266;0.00639925;-0.0553394;1.42657;-3.38683;1.02799;-2.9402;2.55294;-7.29671;19.1573;
+88.259;0.000195039;0.00643925;-0.0553394;1.42657;-3.408;1.03442;-2.9402;2.55294;-7.29671;19.277;
+88.2895;0.000195039;0.00643925;-0.0553394;1.42657;-3.4293;1.04088;-2.92182;2.55294;-7.34232;19.1565;
+88.2971;0.000195039;0.006399;-0.0553394;1.42657;-3.4293;1.04088;-2.92182;2.55294;-7.34232;19.1565;
+88.3048;0.00019382;0.00643899;-0.0553394;1.42657;-3.4293;1.04088;-2.92182;2.55294;-7.34232;19.1565;
+88.32;0.00019382;0.00643899;-0.0553394;1.42657;-3.45073;1.04088;-2.92182;2.55294;-7.29643;19.1565;
+88.3352;0.00019382;0.00647924;-0.0553394;1.42657;-3.45073;1.04088;-2.92182;2.55294;-7.34203;19.2762;
+88.3429;0.000192609;0.00651973;-0.0553394;1.42657;-3.45073;1.04088;-2.92182;2.55294;-7.34203;19.3967;
+88.4267;0.000192609;0.00651973;-0.0560333;1.42657;-3.42917;1.04088;-2.95846;2.55294;-7.34203;19.2755;
+88.48;0.000192609;0.00656048;-0.0556831;1.42657;-3.42917;1.04088;-2.97695;2.55294;-7.34203;19.155;
+88.541;0.000192609;0.00660148;-0.0560311;1.42657;-3.42917;1.04088;-2.97695;2.55294;-7.29614;19.155;
+88.5486;0.000192609;0.00660148;-0.0563813;1.42657;-3.4506;1.04088;-2.97695;2.55294;-7.29614;19.0353;
+88.579;0.000192609;0.00664274;-0.0563813;1.42657;-3.42903;1.04088;-2.99555;2.55294;-7.25054;19.0353;
+88.6705;0.000192609;0.00664274;-0.0563813;1.42657;-3.42903;1.04088;-3.01428;2.55294;-7.25054;18.9163;
+88.7162;0.000192609;0.00664274;-0.0563813;1.42657;-3.42903;1.04088;-3.01428;2.55294;-7.25054;18.7981;
+88.739;0.000192609;0.00660123;-0.056029;1.42657;-3.45046;1.04088;-3.01416;2.55294;-7.25054;18.9156;
+88.7467;0.000192609;0.00660123;-0.0556788;1.42657;-3.45046;1.04088;-3.033;2.55294;-7.25054;18.9156;
+88.7695;0.000192609;0.00660123;-0.0560268;1.42657;-3.45046;1.04088;-3.033;2.55294;-7.25054;18.9156;
+88.7848;0.000192609;0.00660123;-0.0556766;1.42657;-3.45046;1.04088;-3.05195;2.55294;-7.25054;18.9156;
+88.8152;0.000192609;0.00660123;-0.0560246;1.42657;-3.45046;1.04088;-3.05195;2.55294;-7.20523;18.9156;
+88.8686;0.000195024;0.006684;-0.0563747;1.42657;-3.45033;1.04088;-3.05195;2.55294;-7.20523;18.9156;
+88.9067;0.000195024;0.00672577;-0.0563747;1.42657;-3.45033;1.04088;-3.07103;2.55294;-7.20523;19.0338;
+88.9295;0.000195024;0.00668374;-0.0560224;1.42657;-3.45033;1.04088;-3.09022;2.55294;-7.25026;19.0338;
+88.9905;0.000195024;0.00672551;-0.0563725;1.42657;-3.45033;1.04088;-3.07091;2.55294;-7.25026;19.0338;
+89.0057;0.000197469;0.00668348;-0.0563725;1.42657;-3.45033;1.04088;-3.0901;2.55294;-7.25026;19.2725;
+89.059;0.000197469;0.00672525;-0.0560202;1.42657;-3.45033;1.04088;-3.10941;2.55294;-7.25026;19.152;
+89.1276;0.000197469;0.00676728;-0.0560202;1.42657;-3.45033;1.04088;-3.12885;2.55294;-7.25026;19.152;
+89.1429;0.000198703;0.00672499;-0.0567226;1.42657;-3.45033;1.04088;-3.10929;2.55294;-7.25026;19.0323;
+89.1505;0.000198703;0.00672499;-0.0570772;1.42657;-3.45033;1.04088;-3.10929;2.55294;-7.20495;19.0323;
+89.1657;0.000199945;0.00676702;-0.0570772;1.42657;-3.45033;1.04088;-3.10929;2.55294;-7.24998;19.0323;
+89.1962;0.000199945;0.00676702;-0.0574339;1.42657;-3.45033;1.04088;-3.10929;2.55294;-7.20467;19.0323;
+89.2038;0.000201195;0.00676702;-0.0574339;1.42657;-3.45033;1.04088;-3.12873;2.55294;-7.20467;19.0323;
+89.2419;0.000198688;0.00689469;-0.0577929;1.42657;-3.45033;1.04739;-3.16796;2.55294;-7.24969;19.1505;
+89.2724;0.000198688;0.00689469;-0.0577929;1.42657;-3.45033;1.04739;-3.16796;2.55294;-7.24969;19.0308;
+89.341;0.000198688;0.00689469;-0.0577929;1.42657;-3.45033;1.04739;-3.18776;2.55294;-7.24969;19.0308;
+89.3486;0.000198688;0.00693779;-0.0581541;1.42657;-3.45033;1.04739;-3.18776;2.55294;-7.24969;19.0308;
+89.3714;0.000197446;0.00693779;-0.0585175;1.42657;-3.45033;1.05393;-3.20768;2.55294;-7.295;19.0308;
+89.4095;0.00019868;0.00698115;-0.0581518;1.42657;-3.45033;1.05393;-3.22773;2.55294;-7.295;18.9119;
+89.4171;0.000197438;0.00698087;-0.0577883;1.42657;-3.45033;1.05393;-3.2479;2.55294;-7.295;19.0301;
+89.4324;0.000194978;0.0070245;-0.0581495;1.42657;-3.45033;1.05393;-3.2479;2.55294;-7.295;19.0301;
+89.44;0.00019376;0.00711259;-0.0588787;1.42657;-3.45033;1.05393;-3.2479;2.55294;-7.295;19.0301;
+89.4476;0.000192549;0.00720177;-0.0599895;1.42657;-3.45033;1.05393;-3.2479;2.55294;-7.295;19.0301;
+89.4705;0.000191345;0.00724678;-0.0596146;1.42657;-3.45033;1.05393;-3.2479;2.55294;-7.295;19.0293;
+89.4781;0.000190149;0.00729207;-0.0596146;1.42657;-3.45033;1.05393;-3.2682;2.55294;-7.295;19.0293;
+89.4857;0.000187765;0.00738293;-0.0603574;1.42657;-3.45033;1.05393;-3.2682;2.55294;-7.295;19.0293;
+89.5162;0.000180783;0.0076609;-0.0626299;1.42657;-3.45033;1.05393;-3.2682;2.55294;-7.295;19.0293;
+89.5238;0.000176263;0.00785243;-0.0641956;1.42657;-3.45033;1.05393;-3.2682;2.55294;-7.295;19.0293;
+89.6229;0.000126909;0.00942291;-0.0770348;1.42657;-3.45033;1.05393;-3.2682;2.55294;-7.295;19.0293;
+89.6381;0.000114218;0.0103652;-0.0847382;1.42657;-3.45033;1.05393;-3.2682;2.55294;-7.295;19.0293;
+89.7448;0.000102797;0.0103652;-0.0847382;1.42657;-3.45033;1.05393;-3.2682;2.55294;-7.295;19.0293;
+89.7752;9.76567e-005;0.0108835;-0.0889751;1.42657;-3.45033;1.05393;-3.2682;2.55294;-7.295;19.0293;
+89.7981;9.76567e-005;0.0108835;-0.0911995;1.42657;-3.45033;1.05393;-3.2682;2.55294;-7.295;19.0293;
+89.8514;0.000100098;0.0108835;-0.0934795;1.42657;-3.45033;1.05393;-3.1865;2.55294;-7.295;19.0293;
+89.8743;0.000100098;0.0108835;-0.094648;1.42657;-3.4072;1.05393;-3.1865;2.55294;-7.38619;19.0293;
+89.9124;9.88469e-005;0.0107474;-0.0958311;1.42657;-3.4072;1.06711;-3.1865;2.55294;-7.38619;19.0293;
+89.92;9.88469e-005;0.0107474;-0.0958311;1.42657;-3.4072;1.06711;-3.22633;2.55294;-7.38619;19.2672;
+89.9352;9.88469e-005;0.0108818;-0.097029;1.42657;-3.4072;1.06711;-3.186;2.55294;-7.47852;19.508;
+89.9429;9.76114e-005;0.0108818;-0.0958161;1.42657;-3.4072;1.06711;-3.22582;2.55294;-7.47852;19.508;
+89.9733;9.63912e-005;0.0108818;-0.0958161;1.42657;-3.4072;1.06711;-3.22582;2.55294;-7.47852;19.508;
+89.981;9.54838e-005;0.0107457;-0.0946184;1.42657;-3.4072;1.06711;-3.1855;2.55294;-7.47852;19.6902;
+89.9886;9.5633e-005;0.0107457;-0.0946182;1.42657;-3.4072;1.06877;-3.19048;2.55294;-7.49021;19.6594;
+89.9962;9.54835e-005;0.0107457;-0.0944704;1.42657;-3.41252;1.06877;-3.19546;2.55294;-7.4785;19.6594;
+90.0114;9.54835e-005;0.0107457;-0.0943227;1.42657;-3.41252;1.06877;-3.20046;2.55294;-7.4785;19.6594;
+90.019;9.54833e-005;0.0107625;-0.0944699;1.42657;-3.41252;1.06877;-3.20046;2.55294;-7.4785;19.6286;
+90.0343;9.59295e-005;0.0107708;-0.0947644;1.42657;-3.40986;1.06877;-3.19545;2.55294;-7.4785;19.5826;
+90.0419;9.6004e-005;0.0107708;-0.0948013;1.42657;-3.40986;1.06877;-3.19295;2.55294;-7.4785;19.5596;
+87.939;0.0045;-0.0307912;1.41771;-3.4084;1.02165;-2.92205;2.569;-7.297;19.158;
+88.3505;0.00452813;-0.0307912;1.41771;-3.4084;1.02165;-2.94031;2.55294;-7.34261;19.158;
+88.8457;0.00452813;-0.0309837;1.42657;-3.4297;1.02165;-2.92194;2.55294;-7.34261;19.2777;
+89.0133;0.00452813;-0.0309837;1.42657;-3.4297;1.02165;-2.92194;2.55294;-7.3885;19.1573;
+89.0362;0.00452813;-0.03079;1.42657;-3.45114;1.02165;-2.9402;2.55294;-7.34232;19.1573;
+89.059;0.00449982;-0.0309825;1.42657;-3.45114;1.02165;-2.9402;2.55294;-7.29643;19.1573;
+89.0971;0.00452795;-0.0307888;1.42657;-3.47271;1.02165;-2.9402;2.55294;-7.29643;19.1573;
+89.1276;0.00449965;-0.0307888;1.42657;-3.49441;1.02803;-2.92182;2.55294;-7.34203;19.1573;
+89.1429;0.00447153;-0.0307888;1.42657;-3.49441;1.02803;-2.94008;2.55294;-7.34203;19.1573;
+89.1962;0.00444358;-0.0307888;1.42657;-3.49441;1.02803;-2.94008;2.55294;-7.29614;19.1573;
+89.2724;0.00444358;-0.0309813;1.42657;-3.49441;1.03446;-2.94008;2.55294;-7.34175;19.1573;
+89.2876;0.00441581;-0.0309813;1.42657;-3.47257;1.03446;-2.94008;2.55294;-7.34175;19.1573;
+89.2952;0.00444341;-0.0311749;1.42657;-3.47257;1.03446;-2.95846;2.55294;-7.34175;19.0375;
+89.3181;0.00441563;-0.0313698;1.42657;-3.45087;1.03446;-2.97695;2.55294;-7.34175;19.0375;
+89.3638;0.00436061;-0.0311737;1.42657;-3.47244;1.04092;-2.99555;2.55294;-7.34146;19.1565;
+89.3714;0.00433336;-0.0311737;1.42657;-3.47244;1.04092;-2.99555;2.55294;-7.34146;19.1565;
+89.3943;0.00433336;-0.0309789;1.42657;-3.47244;1.04092;-3.01428;2.55294;-7.34146;19.2762;
+89.4476;0.00433336;-0.0311725;1.42657;-3.47244;1.04092;-3.03312;2.55294;-7.34146;19.3967;
+88.5867;0.00447187;-0.0306;1.41771;-3.3871;1.0153;-2.9039;2.569;-7.34261;19.2777;
+88.6171;0.00449982;-0.0306;1.41771;-3.3871;1.00895;-2.9039;2.569;-7.34261;19.2777;
+88.7238;0.00449982;-0.0304087;1.41771;-3.36593;1.00895;-2.92205;2.569;-7.3885;19.1573;
+88.8305;0.00452795;-0.0304087;1.41771;-3.36593;1.00895;-2.92205;2.569;-7.43468;19.1573;
+88.8838;0.00449965;-0.0305988;1.41771;-3.36593;1.01526;-2.92205;2.569;-7.48114;19.0375;
+88.9371;0.00449965;-0.03079;1.41771;-3.36593;1.01526;-2.90379;2.569;-7.48114;19.0375;
+88.9905;0.00447153;-0.03079;1.41771;-3.36593;1.02161;-2.90379;2.569;-7.48114;18.9185;
+89.0286;0.00447153;-0.0305976;1.41771;-3.36593;1.02161;-2.90379;2.569;-7.48114;18.9185;
+88.6933;0.00447187;-0.0306;1.41771;-3.3871;1.0153;-2.92205;2.569;-7.34261;19.0383;
+88.9219;0.0044717;-0.0306;1.41771;-3.3871;1.02803;-2.88564;2.55294;-7.29671;19.1573;
+88.9981;0.00449965;-0.0306;1.41771;-3.3871;1.02803;-2.88553;2.55294;-7.29671;19.1565;
+89.0133;0.00447153;-0.0304087;1.41771;-3.3871;1.02803;-2.90356;2.55294;-7.29671;19.0368;
+89.0362;0.00444358;-0.0305988;1.41771;-3.36593;1.02803;-2.90356;2.55294;-7.29671;19.0368;
+89.0514;0.00444358;-0.03079;1.41771;-3.38697;1.02803;-2.92171;2.55294;-7.29671;19.0368;
+89.0819;0.00441581;-0.0309825;1.41771;-3.3658;1.02803;-2.92171;2.55294;-7.29671;19.0368;
+89.1581;0.00441581;-0.0309825;1.41771;-3.3658;1.02803;-2.92171;2.55294;-7.25111;19.0368;
+89.1733;0.00441581;-0.0311761;1.41771;-3.3658;1.02803;-2.92171;2.55294;-7.29643;19.1558;
+89.1962;0.00441581;-0.0309813;1.41771;-3.3658;1.02803;-2.93997;2.55294;-7.25083;19.1558;
+89.2495;0.00444341;-0.0311749;1.41771;-3.3658;1.02803;-2.93997;2.55294;-7.25083;19.036;
+89.28;0.00444341;-0.0311749;1.41771;-3.3658;1.02803;-2.95834;2.55294;-7.25083;19.155;
+89.3029;0.00444341;-0.0313698;1.41771;-3.3658;1.02803;-2.95834;2.55294;-7.25083;19.0353;
+89.3257;0.00444341;-0.0313698;1.41771;-3.3658;1.02803;-2.95834;2.55294;-7.25083;19.1543;
+89.341;0.00447118;-0.0313698;1.41771;-3.3658;1.02803;-2.97683;2.55294;-7.25083;19.1543;
+89.3486;0.00447118;-0.0313685;1.41771;-3.3658;1.02803;-2.97672;2.55294;-7.25083;19.274;
+89.379;0.00452724;-0.0315646;1.41771;-3.3658;1.02803;-3.01404;2.55294;-7.25083;19.2732;
+89.4019;0.00452724;-0.0317619;1.41771;-3.3658;1.02803;-3.01404;2.55294;-7.25083;19.3937;
+89.4095;0.00452724;-0.0315633;1.41771;-3.3658;1.02803;-3.03288;2.55294;-7.20551;19.152;
+81.6896;0.00452813;-0.0304087;1.4089;-3.3871;1.00895;-2.9039;2.569;-7.297;19.0383;
+81.7408;0.00455643;-0.0304087;1.4089;-3.3871;1.00895;-2.9039;2.569;-7.25139;19.0383;
+81.8944;0.00455643;-0.0305988;1.4089;-3.40827;1.01526;-2.9039;2.569;-7.29671;18.9193;
+81.9648;0.0045849;-0.0304076;1.4089;-3.40827;1.01526;-2.9039;2.569;-7.34232;18.801;
+82.0672;0.0045849;-0.0305976;1.4089;-3.42957;1.01526;-2.92205;2.569;-7.29643;18.6835;
+82.08;0.0045849;-0.0305976;1.41771;-3.42957;1.01526;-2.92205;2.55294;-7.25083;18.8003;
+82.112;0.00461356;-0.0307888;1.41771;-3.42957;1.01526;-2.92205;2.55294;-7.25083;18.8003;
+82.368;0.00461356;-0.0307888;1.40884;-3.42957;1.02161;-2.94031;2.5689;-7.25083;18.6828;
+82.4448;0.00461356;-0.0307888;1.40884;-3.42957;1.02161;-2.95869;2.5689;-7.25083;18.6828;
+82.4512;0.00461356;-0.0309813;1.40884;-3.42957;1.02161;-2.95869;2.5689;-7.20551;18.566;
+82.4896;0.00461356;-0.0309813;1.40884;-3.42957;1.02161;-2.95869;2.5689;-7.20551;18.45;
+82.6112;0.00461356;-0.0309813;1.40884;-3.451;1.02161;-2.97718;2.5689;-7.16048;18.45;
+82.6176;0.00461356;-0.0307876;1.40884;-3.451;1.02161;-2.99579;2.5689;-7.16048;18.45;
+82.7008;0.00461356;-0.0307876;1.40884;-3.451;1.02161;-3.01451;2.5689;-7.16048;18.45;
+82.7648;0.00461356;-0.0309801;1.40884;-3.42943;1.02161;-3.03335;2.5689;-7.16048;18.45;
+82.9888;0.00461356;-0.0307864;1.41765;-3.45087;1.02161;-3.03335;2.55284;-7.16048;18.3347;
+83.0912;0.00461356;-0.0307864;1.41765;-3.45087;1.02161;-3.03335;2.55284;-7.11572;18.4493;
+83.2064;0.00461356;-0.0309789;1.41765;-3.47244;1.02161;-3.01439;2.55284;-7.11572;18.4493;
+83.2448;0.00458472;-0.0311725;1.41765;-3.47244;1.02161;-3.03323;2.55284;-7.11572;18.4493;
+83.3472;0.00458472;-0.0309776;1.41765;-3.47244;1.02161;-3.03323;2.55284;-7.07125;18.334;
+83.5584;0.00458472;-0.0309776;1.41765;-3.49414;1.02161;-3.03323;2.55284;-7.02705;18.334;
+83.648;0.00461338;-0.0311713;1.41765;-3.49414;1.02161;-3.05219;2.55284;-7.02705;18.334;
+83.6928;0.00461338;-0.0309764;1.41765;-3.51598;1.02161;-3.05219;2.55284;-7.02705;18.2194;
+83.8464;0.00467123;-0.03117;1.41765;-3.53795;1.02799;-3.05219;2.55284;-7.07097;18.2194;
+83.9552;0.00464203;-0.03117;1.42651;-3.56006;1.02157;-3.05219;2.55284;-7.11517;18.2194;
+84.1024;0.00464203;-0.0313648;1.42651;-3.56006;1.02157;-3.03312;2.55284;-7.15964;18.3332;
+84.2432;0.00461302;-0.0313648;1.42651;-3.56006;1.02795;-3.05207;2.55284;-7.15964;18.3332;
+84.2816;0.00464185;-0.0311688;1.42651;-3.58232;1.02795;-3.05207;2.55284;-7.20438;18.4478;
+84.3264;0.00461284;-0.0313636;1.42651;-3.58232;1.02795;-3.033;2.55284;-7.15936;18.4478;
+84.4672;0.00458401;-0.0313636;1.42651;-3.6047;1.02795;-3.033;2.55284;-7.11461;18.4478;
+84.48;0.00461266;-0.0315596;1.42651;-3.6047;1.02795;-3.01404;2.55284;-7.11461;18.3325;
+84.5056;0.00464149;-0.0315596;1.42651;-3.6047;1.02795;-3.03288;2.55284;-7.11461;18.4471;
+84.5248;0.00461248;-0.0315596;1.42651;-3.6047;1.02795;-3.03288;2.55284;-7.11461;18.3318;
+84.5696;0.00461248;-0.0315596;1.42651;-3.62723;1.03438;-3.01392;2.55284;-7.11461;18.2172;
+84.6912;0.00461248;-0.0315596;1.43543;-3.6499;1.03438;-3.03276;2.53689;-7.07014;18.2172;
+84.768;0.00461248;-0.0317569;1.43543;-3.6499;1.03438;-3.03276;2.53689;-7.02596;18.2172;
+85.0624;0.00458365;-0.0319554;1.43543;-3.67272;1.03438;-3.03276;2.53689;-7.02596;18.2172;
+85.1648;0.00458365;-0.0319554;1.43543;-3.69567;1.04084;-3.01381;2.53689;-7.02596;18.2172;
+85.1776;0.00458365;-0.0319554;1.43543;-3.67257;1.03433;-3.03264;2.53689;-6.98204;18.2172;
+85.344;0.00458365;-0.0319554;1.43543;-3.69553;1.03433;-3.03264;2.53689;-6.93841;18.2172;
+85.376;0.004555;-0.0319554;1.43543;-3.69553;1.0408;-3.03264;2.53689;-6.93841;18.2172;
+85.3824;0.00458347;-0.0319554;1.43543;-3.69553;1.03429;-3.03264;2.53689;-6.93841;18.3311;
+85.4656;0.00458329;-0.0319554;1.43543;-3.74186;1.04726;-3.05148;2.53689;-6.93813;18.2158;
+85.472;0.00458329;-0.0319554;1.43543;-3.76525;1.04726;-3.07055;2.53689;-6.93813;18.2158;
+85.4784;0.00455465;-0.0319554;1.43543;-3.76525;1.04726;-3.05136;2.53689;-6.93813;18.2158;
+85.4848;0.00458311;-0.0321551;1.43543;-3.76525;1.04726;-3.05136;2.53689;-6.93813;18.2158;
+85.5232;0.00461176;-0.0321551;1.43543;-3.76525;1.04726;-3.05136;2.53689;-6.89477;18.102;
+85.536;0.00461176;-0.0323561;1.43543;-3.76525;1.04072;-3.05136;2.53689;-6.85168;17.9888;
+85.5616;0.00461176;-0.0323561;1.43543;-3.76525;1.04072;-3.03229;2.53689;-6.85168;17.9888;
+85.6064;0.00461176;-0.0323561;1.4444;-3.76525;1.04072;-3.03229;2.52103;-6.85168;17.9888;
+85.728;0.00461176;-0.0323561;1.4444;-3.76525;1.04072;-3.03229;2.52103;-6.80886;17.8764;
+85.7664;0.00461176;-0.0323561;1.4444;-3.76525;1.04072;-3.03229;2.52103;-6.80886;17.7647;
+85.792;0.00461176;-0.0325583;1.4444;-3.76525;1.04072;-3.01333;2.52103;-6.80886;17.7647;
+85.8496;0.00458293;-0.0325583;1.4444;-3.78878;1.04072;-3.01333;2.52103;-6.7663;17.7647;
+85.9904;0.00461158;-0.0325583;1.4444;-3.81246;1.04072;-2.9945;2.52103;-6.72401;17.7647;
+85.9968;0.00461158;-0.0323548;1.4444;-3.81246;1.04072;-3.01322;2.52103;-6.68199;17.6536;
+86.016;0.00461158;-0.0323548;1.4444;-3.81246;1.04072;-3.03205;2.52103;-6.72375;17.764;
+86.0864;0.00458275;-0.0323548;1.4444;-3.81246;1.04072;-3.03205;2.52103;-6.68173;17.764;
+86.1952;0.00455411;-0.0323548;1.4444;-3.83629;1.04722;-3.051;2.52103;-6.68173;17.764;
+86.2144;0.00458258;-0.0323548;1.4444;-3.83629;1.04722;-3.07007;2.52103;-6.68173;17.875;
+86.2208;0.00458258;-0.0331637;1.4444;-3.83629;1.04722;-2.99332;2.52103;-6.68173;17.4281;
+86.2272;0.00463986;-0.0331637;1.4444;-3.83629;1.03413;-2.9559;2.52103;-6.5982;17.2103;
+86.2464;0.00463986;-0.0327491;1.4444;-3.83629;1.03413;-2.99285;2.52103;-6.5982;17.2103;
+86.2528;0.00463986;-0.0325444;1.4444;-3.83629;1.03413;-2.99285;2.52103;-6.5982;17.1027;
+86.2592;0.00463986;-0.0325444;1.4444;-3.83629;1.03413;-2.99285;2.52103;-6.5982;16.9958;
+86.2784;0.00458204;-0.0325444;1.4444;-3.83629;1.0406;-3.01155;2.52103;-6.5982;16.9952;
+86.3104;0.00458204;-0.0327478;1.4444;-3.83629;1.0406;-2.99273;2.52103;-6.5982;16.9952;
+86.3232;0.00458204;-0.0326455;1.4444;-3.83629;1.03734;-2.99273;2.52103;-6.57758;16.995;
+86.3552;0.00457488;-0.0325945;1.4444;-3.83629;1.03734;-2.98806;2.52103;-6.57758;16.9419;
+86.3616;0.0045748;-0.0325048;1.4444;-3.83779;1.03815;-2.99155;2.52103;-6.58785;16.9551;
+86.368;0.0045748;-0.0325175;1.4444;-3.83779;1.03815;-2.99155;2.52103;-6.58785;16.965;
+86.3744;0.00457525;-0.0325461;1.44454;-3.83779;1.03805;-2.99097;2.52078;-6.58656;16.9799;
+86.3808;0.00457569;-0.0325397;1.44454;-3.83779;1.03795;-2.99126;2.52078;-6.58656;16.9799;
+88.6095;0.0045748;-0.0325175;1.4444;-3.8138;1.04464;-2.97285;2.52103;-6.62902;17.071;
+88.6705;0.0045748;-0.0327207;1.4444;-3.8138;1.04464;-2.97285;2.52103;-6.62902;17.071;
+88.6857;0.00460339;-0.0327207;1.4444;-3.8138;1.03811;-2.95427;2.52103;-6.62902;17.071;
+88.7619;0.00457462;-0.0327207;1.4444;-3.78997;1.03162;-2.95427;2.52103;-6.62902;17.071;
+88.8457;0.00457462;-0.0329252;1.4444;-3.78997;1.03162;-2.93581;2.52103;-6.58759;16.9643;
+88.8686;0.00457462;-0.0329252;1.4444;-3.78997;1.03162;-2.95416;2.52103;-6.54642;17.0704;
+88.9067;0.00454603;-0.0329252;1.4444;-3.76628;1.02517;-2.93569;2.52103;-6.54642;17.0704;
+88.9829;0.00457444;-0.033131;1.4444;-3.74274;1.02517;-2.95404;2.52103;-6.58734;16.9637;
+89.0743;0.00454585;-0.033131;1.4444;-3.71935;1.03158;-2.93558;2.52103;-6.58734;16.9637;
+89.0895;0.00451744;-0.0333381;1.4444;-3.71935;1.02513;-2.93558;2.52103;-6.54616;16.8577;
+89.1657;0.00454567;-0.0333381;1.4444;-3.71935;1.03154;-2.93558;2.52103;-6.58708;16.7523;
+89.181;0.00454567;-0.0333381;1.4444;-3.71935;1.03799;-2.93558;2.52103;-6.62825;16.7523;
+89.219;0.00454567;-0.0335465;1.4444;-3.71935;1.03799;-2.93558;2.52103;-6.62825;16.7523;
+89.2876;0.00451726;-0.0331284;1.4444;-3.71935;1.03799;-2.93558;2.52103;-6.62825;16.857;
+89.2952;0.00451726;-0.0331284;1.4444;-3.6961;1.0315;-2.95393;2.52103;-6.66967;16.857;
+89.3333;0.00451726;-0.0333355;1.4444;-3.673;1.0315;-2.95393;2.52103;-6.71136;16.857;
+89.3562;0.00448903;-0.0333355;1.4444;-3.67286;1.03795;-2.97239;2.52103;-6.71136;16.857;
+89.3943;0.00448903;-0.0333355;1.4444;-3.6499;1.03795;-2.99097;2.52103;-6.75331;16.857;
+89.4095;0.00446097;-0.0331271;1.4444;-3.6499;1.03795;-2.97227;2.52103;-6.75331;16.857;
+89.4476;0.00443309;-0.0331271;1.4444;-3.6499;1.03795;-2.97227;2.52103;-6.75331;16.857;
+89.4552;0.00443309;-0.0333342;1.4444;-3.6499;1.03795;-2.9537;2.52103;-6.75331;16.857;
+89.4933;0.00440539;-0.0333342;1.4444;-3.6499;1.03795;-2.93523;2.52103;-6.75331;16.9623;
+89.5238;0.00437785;-0.0333316;1.4444;-3.62709;1.04443;-2.99062;2.52103;-6.79551;16.8563;
+89.5314;0.00429628;-0.0331233;1.4444;-3.60442;1.04443;-3.00931;2.52103;-6.79551;16.8557;
+89.539;0.00429628;-0.0331233;1.4444;-3.60442;1.05096;-3.02811;2.52103;-6.79551;16.7503;
+89.6229;0.00426943;-0.0329162;1.4444;-3.60442;1.05096;-3.04704;2.52103;-6.79551;16.6456;
+89.6457;0.00424274;-0.0329162;1.4444;-3.60442;1.05096;-3.028;2.52103;-6.79551;16.6456;
+89.6533;0.00424274;-0.0327092;1.4444;-3.60442;1.05096;-3.028;2.52103;-6.79551;16.645;
+89.661;0.00424274;-0.032708;1.4444;-3.60442;1.05096;-3.04692;2.52103;-6.79551;16.8537;
+89.6762;0.00421623;-0.0323004;1.4444;-3.60442;1.05096;-3.06596;2.52103;-6.79551;16.8537;
+89.6914;0.00424258;-0.0320985;1.4444;-3.62695;1.05096;-3.0468;2.52103;-6.79551;16.959;
+89.7067;0.00424258;-0.0318979;1.4444;-3.62695;1.05096;-3.06584;2.52103;-6.79551;16.959;
+89.7219;0.00422932;-0.0318976;1.4444;-3.62695;1.05096;-3.06582;2.52103;-6.79551;17.1185;
+89.7295;0.00422932;-0.0317979;1.4444;-3.62695;1.05096;-3.0754;2.52103;-6.79551;17.172;
+89.7371;0.00422931;-0.0318476;1.4444;-3.62127;1.05096;-3.07539;2.52103;-6.79551;17.1184;
+89.7448;0.00422931;-0.0318475;1.4444;-3.62127;1.05096;-3.07535;2.52103;-6.79551;17.1248;
+89.7524;0.00423013;-0.0318288;1.44412;-3.61986;1.05137;-3.07775;2.52103;-6.79684;17.1215;
+89.76;0.0042293;-0.0317977;1.44412;-3.62056;1.05209;-3.08497;2.52103;-6.80015;17.1734;

filtered.csv

@@ -0,0 +1,49 @@
+21;1;3241.17;3407.51;3455.33
+21;2;3242.06;3409.06;3460.56
+21;3;3374.88;3559.2;3465.78
+21;4;3355.33;3524.57;3471
+21;5;3418.59;3588.69;3476.23
+21;6;3400.59;3569.59;3481.45
+21;7;3476.21;3653.19;3486.67
+21;8;3531.81;3713.39;3491.9
+21;9;3274.7;3425.38;3497.12
+21;10;3270.37;3411.15;3502.34
+21;11;3320.43;3465.03;3507.57
+21;12;3294.12;3438.34;3512.79
+21;13;3314.5;3457.78;3518.01
+21;14;3331.81;3466.65;3523.24
+21;15;3266.33;3405.85;3528.46
+21;16;3377.15;3524.01;3533.68
+21;17;3319.37;3450.67;3538.9
+21;18;3323.67;3455.59;3544.13
+21;19;3338.28;3478.36;3549.35
+21;20;3310.69;3435.35;3554.57
+21;21;3403.11;3540.33;3559.8
+21;22;3367.51;3501.33;3565.02
+21;23;3412.93;3547.93;3570.24
+21;24;3479.79;3619.07;3575.47
+21;25;3482.65;3628.41;3580.69
+21;26;3505.91;3651.83;3585.91
+21;27;3495.8;3634.46;3591.14
+21;28;3565;3710.3;3596.36
+21;29;3584.59;3737.21;3601.58
+21;30;3604.67;3756.01;3606.81
+21;31;3535.12;3681.74;3612.03
+21;32;3573.33;3718.45;3617.25
+21;33;3607.37;3758.29;3622.48
+21;34;3575.85;3730.61;3627.7
+21;35;3640.23;3797.75;3632.92
+21;36;3608.72;3763.94;3638.14
+21;37;3669.66;3821.96;3643.37
+21;38;3628.89;3785.13;3648.59
+21;39;3668.5;3816.22;3653.81
+21;40;3578.87;3720.17;3659.04
+21;41;3650.61;3800.15;3664.26
+21;42;3631.88;3778.02;3669.48
+21;43;3591.96;3736.02;3674.71
+21;44;3637.4;3783.02;3679.93
+21;45;3611.11;3764.29;3685.15
+21;46;3583.69;3731.41;3690.38
+21;47;3604.53;3750.69;3695.6
+21;48;3629.18;3783.26;3700.82
+21;49;3697.78;3853.42;3706.05

impact-lambda - Copie.csv

@@ -0,0 +1,99 @@
+1;3407.97;37.6032
+2;3468.27;38.583
+3;3431.31;37.0993
+4;3496.32;38.5737
+5;3517.95;38.8429
+6;3530.38;37.7182
+7;3524.97;37.1871
+8;3551.9;38.1269
+9;3571.1;37.5807
+10;3593.82;37.9687
+11;3650.61;39.206
+12;3649.15;37.5938
+13;3694.71;37.9227
+14;3688.14;37.6768
+15;3697.97;38.195
+16;3713.86;36.9783
+17;3737.08;36.8856
+18;3778.32;38.0069
+19;3759.8;36.1679
+20;3850.56;38.4909
+21;3805.96;36.5192
+22;3843.2;36.9704
+23;3858.54;37.5889
+24;3908.58;37.5819
+25;3922.44;37.8983
+26;3939.01;37.5963
+27;3950.52;38.0355
+28;3982.28;37.5184
+29;4022.9;37.04
+30;4038.63;37.6421
+31;4007.23;36.5339
+32;4063.76;37.739
+33;4076.37;36.8408
+34;4122.65;38.2033
+35;4101.74;36.9551
+36;4149.06;37.2197
+37;4120.23;36.928
+38;4180.13;36.6708
+39;4181.41;37.3759
+40;4176.33;36.13
+41;4233.03;37.5586
+42;4254.01;37.8361
+43;4293.66;36.8785
+44;4306.06;36.4557
+45;4327.15;38.1578
+46;4335.71;37.0621
+47;4344.45;37.5653
+48;4365.12;37.4226
+49;4382.72;36.042
+50;4389.76;37.9448
+51;4427.73;36.5744
+52;4439.57;37.237
+53;4480.63;38.9037
+54;4512.18;38.2965
+55;4475.09;37.0653
+56;4541.9;38.2028
+57;4554.78;36.6889
+58;4578.57;37.8288
+59;4587.66;37.7591
+60;4603.48;37.517
+61;4579.97;36.7068
+62;4607.55;37.7183
+63;4658.75;37.4106
+64;4679.79;38.2338
+65;4694.23;37.3044
+66;4708.36;38.6474
+67;4722.13;38.3787
+68;4733.93;37.5086
+69;4773.73;37.6634
+70;4784.66;37.1379
+71;4814.98;37.0443
+72;4838.61;37.6279
+73;4881.29;38.4268
+74;4852.19;37.2779
+75;4888.36;37.8126
+76;4943.9;38.9355
+77;4922.48;39.0129
+78;4966.35;38.2327
+79;4925.79;37.5493
+80;5010.54;38.3306
+81;4978.34;38.7417
+82;5050.89;37.7738
+83;5039.88;38.8694
+84;5066.53;38.0766
+85;5041.98;37.8061
+86;5079.27;38.0877
+87;5121.99;38.5636
+88;5128.17;38.3306
+89;5165.46;37.895
+90;5188.62;38.5746
+91;5147.91;37.3693
+92;5174.63;38.8134
+93;5213.91;37.8495
+94;5233.25;36.8422
+95;5245.21;37.8748
+96;5279.18;38.4963
+97;5329.58;38.1836
+98;5320.67;37.8848
+99;5303.88;38.0362

impact-lambda.csv

@@ -0,0 +1,49 @@
+1;3027.8;37.2305
+2;3078.78;36.8567
+3;3141.68;37.0528
+4;3162.82;37.3588
+5;3268.38;37.2791
+6;3344.11;38.4394
+7;3409.42;37.7098
+8;3441.67;36.8229
+9;3546.34;39.2688
+10;3611.22;37.9824
+11;3683.94;36.8596
+12;3736.49;36.6126
+13;3811.35;35.6844
+14;3904.45;37.5724
+15;3989.68;37.6852
+16;4019.79;38.0191
+17;4121.2;37.4222
+18;4201.8;38.353
+19;4310.22;38.3108
+20;4378.58;39.1458
+21;4433.89;38.8116
+22;4506.63;37.5953
+23;4597.03;38.0516
+24;4673.08;37.7613
+25;4727.35;37.9353
+26;4853.85;39.3914
+27;4917.49;39.1447
+28;4998.08;37.8948
+29;5066.01;38.6035
+30;5167.89;38.3904
+31;5212.59;37.3341
+32;5295.99;38.6233
+33;5374.47;39.0218
+34;5479.61;38.7075
+35;5566.78;39.1593
+36;5639.47;38.4097
+37;5734.27;39.2051
+38;5814.47;39.7168
+39;5877.58;39.0198
+40;5943.65;38.9073
+41;5993.95;38.1588
+42;6118.22;39.7875
+43;6153.85;38.9135
+44;6258.55;39.8649
+45;6371.57;39.9881
+46;6397.94;38.9843
+47;6531.56;39.8428
+48;6587.73;40.1406
+49;6636.05;40.4231

include/algo-complexity.h

@@ -1,14 +0,0 @@
-#ifndef ALGO_COMPLEXITY_H_INCLUDED
-#define ALGO_COMPLEXITY_H_INCLUDED
-
-#include <string>
-#include <vector>
-#include <fstream>
-
-#include "analysis.h"
-
-std::vector<Statistic> compute_complexity(std::default_random_engine& randomizer, SearchHeuristic* algo, int n_initial, int n_final, int n_step=1, int nb_tests=100, double slq=-1, bool displaying=true);
-void save_in_file(std::string namefile, std::vector<Statistic> stats);
-
-#endif // ALGO_COMPLEXITY_H_INCLUDED
-

include/ParameterOptimizer.h → include/analysis/ParameterOptimizer.h

@@ -7,8 +7,8 @@
 #include <sstream>
 #include <fstream>
 
-#include "SearchHeuristic.h"
-#include "analysis.h"
+#include "heuristics/SearchHeuristic.h"
+#include "analysis/analysis.h"
 
 struct ConfidenceInterval {
     ConfidenceInterval(double d, double m, double u, double t=-1) : down{d}, mean{m}, up{u}, thresold{t} {};

include/analysis.h → include/analysis/analysis.h

@@ -7,7 +7,7 @@
 #include <algorithm>
 #include <fstream>
 
-#include "SearchHeuristic.h"
+#include "heuristics/SearchHeuristic.h"
 
 struct Statistic {
     Statistic() : Statistic(0,0,0,0,0,0,0) {};
@@ -30,6 +30,7 @@ struct Statistic {
     double label;
 };
 
+// Chrono Functions
 std::chrono::time_point<std::chrono::system_clock> start_chrono();
 std::chrono::time_point<std::chrono::system_clock> stop_chrono();
 int interval_chrono(std::chrono::time_point<std::chrono::system_clock> start, std::chrono::time_point<std::chrono::system_clock> stop);
@@ -41,4 +42,9 @@ Statistic* derivate(Statistic* curve, unsigned int length);
 Statistic* compress(Statistic* curve, unsigned int length);
 Statistic* smooth(Statistic* curve, unsigned int length);
 
+std::vector<Statistic> compute_complexity(std::default_random_engine& randomizer, SearchHeuristic* algo, int n_initial, int n_final, int n_step=1, int nb_tests=100, double slq=-1, bool displaying=true);
+void save_in_file(std::string namefile, std::vector<Statistic> stats);
+
+void cmp_evolution(std::vector<SearchHeuristic*> algos, MasterMind& problem, std::string outfilename, int max_evolution, int nb_tests = 100);
+
 #endif // ANALYSIS_H_INCLUDED

include/experiences/bestPEA.h

@@ -0,0 +1,83 @@
+#ifndef BEST_PEA_H_INCLUDED
+#define BEST_PEA_H_INCLUDED
+
+#include <vector>
+#include "heuristics/PEA.h"
+
+class PEAMutationProbaOptimizer : public ParameterOptimizer {
+    public:
+        PEAMutationProbaOptimizer(unsigned int n_init, std::vector<double> probas, unsigned int flexive_point, std::default_random_engine& randomizer) : ParameterOptimizer(randomizer), n_initial{n_init}, m_probas{probas}, m_flexive_point{flexive_point} {};
+        SearchHeuristic* get_context(unsigned int i, double parameter, std::default_random_engine& randomizer) {
+            std::vector<double> probas(m_probas);
+            for(int k=m_flexive_point; k>=0; k--)
+                probas[k] = parameter;
+            /*probas[m_flexive_point] = parameter;
+            if(m_flexive_point == 0) {
+                for(int k=0; k<probas.size(); k++)
+                    probas[k] = parameter;
+            }*/
+            /*std::cout << "[" << m_flexive_point << "] ";
+            for(int i=0, s=probas.size(); i<s; i++)
+                std::cout << probas[i] << " ";
+            std::cout << std::endl;
+            */PEA* algo = new PEA(1, 1, PLUS, probas, randomizer);
+            MasterMind* mm = new MasterMind(n_initial+i, n_initial+i, randomizer);
+            algo->set_problem(mm);
+            return algo;
+        }
+        std::string display_context(unsigned int context) {
+           std::stringstream ss;
+           ss << "n=" << n_initial+context;
+           return ss.str();
+        }
+        std::string get_context_for_csvfile(unsigned int num_context) {
+           return std::to_string(n_initial+num_context);
+        }
+    private:
+        unsigned int n_initial;
+        std::vector<double> m_probas;
+        unsigned int m_flexive_point;
+};
+
+void pea_optimisation(unsigned int n, unsigned int subdivision_size, std::default_random_engine& randomizer) {
+    std::vector<double> probas;
+    for(unsigned int i=0; i<=subdivision_size; i++)
+        probas.push_back(0.);
+
+    for(unsigned int k=subdivision_size; k>=0; k--) {
+        PEAMutationProbaOptimizer pea_mpo(n, probas, k, randomizer);
+        pea_mpo.set_nb_contexts(1);
+        if(k==subdivision_size)
+            pea_mpo.set_study_interval(0.01, 0.3, 0.01);
+        else if(k > 15)
+            pea_mpo.set_study_interval(0.01, 0.5, 0.01);
+        else if(k > 10)
+            pea_mpo.set_study_interval(0.01, 0.7, 0.01);
+        else if(k > 5)
+            pea_mpo.set_study_interval(0.01, 0.9, 0.01);
+        else
+            pea_mpo.set_study_interval(0.01, 0.99, 0.01);
+
+        pea_mpo.add_test_wave(500, 2.2481733216, 0);
+        //pea_mpo.add_test_wave(8000, 2.243091696, 1);
+
+        std::vector<ConfidenceInterval> cis = pea_mpo.run(false);
+        std::cout << "STEP " << k << ": " << cis[0].down << ", " << cis[0].mean << ", " << cis[0].up << std::endl;
+
+        double p = (cis[0].down + cis[0].up)/2.;
+        probas[k] = p;
+        /*if(k==0) {
+            for(int j=0; j<=subdivision_size; j++)
+                probas[j] = p;
+        } else {
+            probas[k] = p;
+            if(k+1<=subdivision_size) probas[k+1] = (2*p+probas[k+1])/3;
+            if(k+2<=subdivision_size) probas[k+2] = (p+2*probas[k+2])/3;
+        }*/
+        std::cout << "==========> " << k << ", " << p << std::endl;
+    }
+}
+
+#endif // BEST_PEA_H_INCLUDED
+
+

include/bestPGA.h → include/experiences/bestPGA.h

@@ -2,7 +2,7 @@
 #define BEST_PGA_H_INCLUDED
 
 #include <vector>
-#include "PGA.h"
+#include "heuristics/PGA.h"
 
 class PGACrossoverProbaOptimizer : public ParameterOptimizer {
     public:
@@ -13,7 +13,7 @@ class PGACrossoverProbaOptimizer : public ParameterOptimizer {
             //    probas[k] = parameter;
             probas[m_flexive_point] = parameter;
             if(m_flexive_point == 0) {
-                for(int k=0; k<probas.size(); k++)
+                for(unsigned int k=0; k<probas.size(); k++)
                     probas[k] = parameter;
             }
             PGA* algo = new PGA(10, 10, PLUS, 1./(n_initial+i), probas, UNIFORM_CROSSOVER, GA_V1, randomizer);
@@ -35,9 +35,9 @@ class PGACrossoverProbaOptimizer : public ParameterOptimizer {
         unsigned int m_flexive_point;
 };
 
-void pga_optimisation(unsigned int n, int subdivision_size, std::default_random_engine& randomizer) {
+void pga_optimisation(unsigned int n, unsigned int subdivision_size, std::default_random_engine& randomizer) {
     std::vector<double> probas;
-    for(int i=0; i<=subdivision_size; i++)
+    for(unsigned int i=0; i<=subdivision_size; i++)
         probas.push_back(0.);
 
     for(unsigned int k=0; k<=subdivision_size; k++) {
@@ -52,7 +52,7 @@ void pga_optimisation(unsigned int n, int subdivision_size, std::default_random_
 
         double p = (cis[0].down + cis[0].up)/2.;
         if(k==0) {
-            for(int j=0; j<=subdivision_size; j++)
+            for(unsigned int j=0; j<=subdivision_size; j++)
                 probas[j] = p;
         } else {
             probas[k] = p;

include/experiences/compare-evolutions.h

@@ -0,0 +1,16 @@
+#ifndef COMPARE_EVOLUTIONS_H_INCLUDED
+#define COMPARE_EVOLUTIONS_H_INCLUDED
+
+#include <vector>
+
+#include "heuristics/RLS.h"
+#include "heuristics/EA.h"
+#include "heuristics/GA.h"
+#include "heuristics/PEA.h"
+
+#include "analysis/analysis.h"
+#include "experiences/crossover-rate.h"
+
+void script_cmp_evolution_algos(std::default_random_engine& randomizer);
+
+#endif // COMPARE_EVOLUTIONS_H_INCLUDED

include/experiences/complexity-ea.h

@@ -0,0 +1,19 @@
+#ifndef COMPLEXITY_EA_H_INCLUDED
+#define COMPLEXITY_EA_H_INCLUDED
+
+#include <string>
+#include <fstream>
+#include <sstream>
+#include <iostream>
+
+#include "problems/MasterMind.h"
+#include "heuristics/EA.h"
+#include "analysis/analysis.h"
+
+void study_complexity_of_ea(std::default_random_engine& randomizer, int option, int argc, char** argv);
+void study_complexity_of_ea_sample(std::default_random_engine& randomizer, std::string filename, int n_initial, int n_final, int n_step, bool displaying=true);
+void study_complexity_of_ea_filter(std::string input, std::string output, int filtered_n, int filtered_mu, int filtered_lda);
+void study_complexity_of_ea_treat(std::default_random_engine& randomizer, std::string filename, int n_initial, int n_final);
+
+#endif // COMPLEXITY_EA_H_INCLUDED
+

include/experiences/complexity-ga.h

@@ -0,0 +1,17 @@
+#ifndef COMPLEXITY_GA_H_INCLUDED
+#define COMPLEXITY_GA_H_INCLUDED
+
+#include <string>
+#include <fstream>
+#include <sstream>
+
+#include "heuristics/GA.h"
+#include "analysis/analysis.h"
+#include "experiences/crossover-rate.h"
+
+void study_complexity_of_ga(std::default_random_engine& randomizer, int option, int argc, char** argv);
+void study_complexity_of_ga_sample(std::default_random_engine& randomizer, std::string filename, int n_initial, int n_final, int n_step=10, bool displaying=true);
+void study_complexity_of_ga_global_sample(std::default_random_engine& randomizer, std::string filename, int n_initial, int n_final, int n_step=10, bool displaying=true);
+void study_complexity_of_ga_treat(std::default_random_engine& randomizer, std::string filename, int n_initial, int n_final);
+
+#endif // COMPLEXITY_GA_H_INCLUDED

include/experiences/complexity-rls.h

@@ -0,0 +1,14 @@
+#ifndef COMPLEXITY_RLS_H_INCLUDED
+#define COMPLEXITY_RLS_H_INCLUDED
+
+#include <sstream>
+#include <string>
+#include <fstream>
+
+#include "heuristics/RLS.h"
+#include "analysis/analysis.h"
+
+void study_complexity_of_rls(std::default_random_engine& randomizer, int option, int argc, char** argv);
+void study_complexity_of_rls_sample(std::default_random_engine& randomizer, std::string filename, int n_initial, int n_final, int n_step, bool displaying=true);
+
+#endif // COMPLEXITY_RLS_H_INCLUDED

include/crossover-rate.h → include/experiences/crossover-rate.h

@@ -1,15 +1,17 @@
-#ifndef CROSSOVER-RATE_H_INCLUDED
-#define CROSSOVER-RATE_H_INCLUDED
+#ifndef CROSSOVER_RATE_H_INCLUDED
+#define CROSSOVER_RATE_H_INCLUDED
 
 #include <vector>
 #include <fstream>
 
-#include "ParameterOptimizer.h"
-#include "GA.h"
+#include "analysis/ParameterOptimizer.h"
+#include "heuristics/GA.h"
 
+// Crossover Probability Optimizer
 class CrossoverProbaFromLambdaOptimizer : public ParameterOptimizer {
     public:
-        CrossoverProbaFromLambdaOptimizer(int nb_cases, int lda_initial, std::default_random_engine& randomizer) : ParameterOptimizer(randomizer), n{nb_cases}, lambda_initial{lda_initial} {};
+        CrossoverProbaFromLambdaOptimizer(int nb_cases, int lda_initial, std::default_random_engine& randomizer) :
+            ParameterOptimizer(randomizer), n{nb_cases}, lambda_initial{lda_initial} {};
         SearchHeuristic* get_context(unsigned int i, double parameter, std::default_random_engine& randomizer);
         std::string display_context(unsigned int num_context);
         std::string get_context_for_csvfile(unsigned int num_context);
@@ -19,11 +21,15 @@ class CrossoverProbaFromLambdaOptimizer : public ParameterOptimizer {
         int lambda_initial;
 };
 
+// Crossover Probability Optimization
+void crossover_model(std::default_random_engine& randomizer, int option, int argc, char** argv);
 void script_crossover_proba_global_optim(std::default_random_engine& randomizer, std::string namefile="global-crossover-proba.csv", bool restart=false, unsigned int restart_n=5, unsigned int restart_lambda=2);
 double crossover_model_linearization(double x);
 void crossover_model_filtering(std::string input, std::string output, std::string modeling, int filtered_n, int filtered_lda);
 void crossover_model_optimization(std::string namefile="global-crossover-proba.csv");
 void crossover_model_validation(std::string namefile, double slope1, double intercept1, double slope2, double intercept2);
+
+// Modeling
 double cr(int n, int lambda);
 
-#endif // CROSSOVER-RATE_H_INCLUDED
+#endif // CROSSOVER_RATE_H_INCLUDED

include/experiences/mutation-rate.h

@@ -0,0 +1,33 @@
+#ifndef MUTATION_RATE_H_INCLUDED
+#define MUTATION_RATE_H_INCLUDED
+
+#include <sstream>
+#include <string>
+
+#include "analysis/ParameterOptimizer.h"
+#include "heuristics/EA.h"
+#include "problems/MasterMind.h"
+
+class ProbaOptimizer : public ParameterOptimizer {
+    public:
+        ProbaOptimizer(int initial_n, std::default_random_engine& randomizer) : ParameterOptimizer(randomizer), m_initial_n{initial_n} {};
+        SearchHeuristic* get_context(unsigned int i, double parameter, std::default_random_engine& randomizer) {
+            EA* algo = new EA(1, 1, PLUS, parameter, randomizer);
+            MasterMind* mm = new MasterMind(m_initial_n+i, m_initial_n+i, randomizer);
+            algo->set_problem(mm);
+            return algo;
+        }
+        virtual std::string display_context(unsigned int context) {
+           std::stringstream ss;
+           ss << "n=" << context+m_initial_n;
+           return ss.str();
+        }
+        std::string get_context_for_csvfile(unsigned int num_context) {
+           return std::to_string(m_initial_n+num_context);
+        }
+
+    private:
+        int m_initial_n;
+};
+
+#endif // MUTATION_RATE_H_INCLUDED

include/experiences/scripts.h

@@ -0,0 +1,62 @@
+#ifndef SCRIPTS_H_INCLUDED
+#define SCRIPTS_H_INCLUDED
+
+#include <vector>
+#include <fstream>
+
+#include "analysis/analysis.h"
+#include "analysis/ParameterOptimizer.h"
+
+class CrossoverProbaOptimizer : public ParameterOptimizer {
+    public:
+        CrossoverProbaOptimizer(int n_init, double obj, std::default_random_engine& randomizer) : ParameterOptimizer(randomizer), n_initial{n_init}, objective{obj} {};
+        SearchHeuristic* get_context(unsigned int i, double parameter, std::default_random_engine& randomizer) {
+            GA* algo = new GA(5, 5, PLUS, 1./(n_initial+i), parameter, UNIFORM_CROSSOVER, GA_V1, randomizer);
+            MasterMind* mm = new MasterMind(n_initial+i, n_initial+i, randomizer);
+            algo->set_problem(mm);
+            algo->set_objective(objective);
+            return algo;
+        }
+        std::string display_context(unsigned int context) {
+           std::stringstream ss;
+           ss << "n=" << n_initial+context;
+           return ss.str();
+        }
+        std::string get_context_for_csvfile(unsigned int num_context) {
+           return std::to_string(n_initial+num_context);
+        }
+
+    private:
+        int n_initial;
+        double objective;
+};
+
+void script_crossover_proba_optim(std::default_random_engine& randomizer) {
+    std::string namefile = "crossover-proba.csv";
+    std::ofstream savefile(namefile);
+    {
+        int n_init=3, n_final=21;
+        double p_init=0.01, p_final=0.99, p_step=0.02;
+        CrossoverProbaOptimizer cpo(n_init, 1.00, randomizer);
+        cpo.set_nb_contexts(n_final - n_init);
+        cpo.set_study_interval(p_init, p_final, p_step);
+        cpo.add_test_wave(40, 2.5419828669, 0);
+        cpo.add_test_wave(400, 2.4429370465, 1);
+        cpo.add_test_wave(2000, 2.4344837209, 2);
+        cpo.save_run(namefile);
+        cpo.run();
+    }{
+        int n_init=21, n_final=40;
+        double p_init=0.01, p_final=0.3, p_step=0.02;
+        CrossoverProbaOptimizer cpo(n_init, 1.00, randomizer);
+        cpo.set_nb_contexts(n_final - n_init);
+        cpo.set_study_interval(p_init, p_final, p_step);
+        cpo.add_test_wave(80, 2.4860491262, 0);
+        cpo.add_test_wave(200, 2.4535822177, 1);
+        cpo.add_test_wave(400, 2.4429370465, 2);
+        cpo.save_run(namefile);
+        cpo.run();
+    }
+}
+
+#endif // SCRIPTS_H_INCLUDED

include/GA.h → include/heuristics/GA.h

@@ -7,11 +7,14 @@
 
 class GA : public GGA {
     public:
-        GA(int mu, int lda, int selection, double sbm_proba, double crossover_proba, int crossover_method, int version, std::default_random_engine& randomizer) : GGA(mu, lda, selection, sbm_proba, crossover_method, version, randomizer), m_crossover_proba{crossover_proba} {};
+        GA(int mu, int lda, int selection, double sbm_proba, double crossover_proba, int crossover_method, int version, std::default_random_engine& randomizer) :
+            GGA(mu, lda, selection, crossover_method, version, randomizer), m_crossover_proba{crossover_proba}, m_sbm_proba{sbm_proba} {};
         double get_crossover_proba(double progress);
+        double get_sbm_proba(double progress);
 
     protected:
         double m_crossover_proba;
+        double m_sbm_proba;
 };
 
 #endif // GA_H

include/GGA.h → include/heuristics/GGA.h

@@ -18,9 +18,9 @@
 class GGA : public SearchHeuristic
 {
     public:
-        GGA(int mu, int lda, int selection, double sbm_proba, int crossover_method, int version, std::default_random_engine& randomizer);
-        GGA(int mu, int lda, int selection, double sbm_proba, int crossover_method, std::default_random_engine& randomizer) :
-            GGA(mu, lda, selection, sbm_proba, crossover_method, GA_V1, randomizer) {};
+        GGA(int mu, int lda, int selection, int crossover_method, int version, std::default_random_engine& randomizer);
+        GGA(int mu, int lda, int selection, int crossover_method, std::default_random_engine& randomizer) :
+            GGA(mu, lda, selection, crossover_method, GA_V1, randomizer) {};
         void prepare_tab();
         virtual double get_crossover_proba(double progress) = 0;
         virtual double get_sbm_proba(double progress) = 0;
@@ -31,12 +31,10 @@ class GGA : public SearchHeuristic
         int m_mu;
         int m_lambda;
         int m_selection;
-        double m_sbm_proba;
         int m_crossover_method;
         int m_version;
 
         std::default_random_engine m_randomizer;
-        std::binomial_distribution<int> m_binomial_dist;
         std::uniform_int_distribution<int> m_uniform_dist;
         bool m_is_prepared;
         Candidate** x_tab;

include/heuristics/PEA.h

@@ -0,0 +1,19 @@
+#ifndef PEA_H
+#define PEA_H
+
+#include "heuristics/GGA.h"
+#include "problems/crossover.h"
+
+class PEA : public GGA
+{
+    public:
+        PEA(int mu, int lda, int selection, std::vector<double> mutation_probas, std::default_random_engine& randomizer) :
+            GGA(mu, lda, selection, UNIFORM_CROSSOVER, GA_V1, randomizer), m_mutation_probas{mutation_probas} {};
+        double get_crossover_proba(double progress);
+        double get_sbm_proba(double progress);
+
+    protected:
+        std::vector<double> m_mutation_probas;
+};
+
+#endif // PEA_H

include/PGA.h → include/heuristics/PGA.h

@@ -9,10 +9,13 @@
 
 class PGA : public GGA {
     public:
-        PGA(int mu, int lda, int selection, double sbm_proba, std::vector<double> crossover_probas, int crossover_method, int version, std::default_random_engine& randomizer) : GGA(mu, lda, selection, sbm_proba, crossover_method, version, randomizer), m_crossover_probas{crossover_probas} {};
+        PGA(int mu, int lda, int selection, double sbm_proba, std::vector<double> crossover_probas, int crossover_method, int version, std::default_random_engine& randomizer) :
+            GGA(mu, lda, selection, crossover_method, version, randomizer), m_sbm_proba{sbm_proba}, m_crossover_probas{crossover_probas} {};
         double get_crossover_proba(double progress);
+        double get_sbm_proba(double progress);
 
     protected:
+        double m_sbm_proba;
         std::vector<double> m_crossover_probas;
 };
 

include/SearchHeuristic.h → include/heuristics/SearchHeuristic.h

@@ -2,7 +2,7 @@
 #define SEARCHHEURISTIC_H
 
 #include <vector>
-#include "MasterMind.h"
+#include "problems/MasterMind.h"
 
 struct Point {
     Point() : Point(0,0) {};

include/scripts.h

@@ -1,483 +0,0 @@
-#ifndef SCRIPTS_H_INCLUDED
-#define SCRIPTS_H_INCLUDED
-
-#include <vector>
-
-#include "analysis.h"
-#include "ParameterOptimizer.h"
-
-using namespace std;
-
-class ProbaOptimizer : public ParameterOptimizer {
-    public:
-        ProbaOptimizer(int initial_n, std::default_random_engine& randomizer) : ParameterOptimizer(randomizer), m_initial_n{initial_n} {};
-        SearchHeuristic* get_context(unsigned int i, double parameter, std::default_random_engine& randomizer) {
-            EA* algo = new EA(1, 1, PLUS, parameter, randomizer);
-            MasterMind* mm = new MasterMind(m_initial_n+i, m_initial_n+i, randomizer);
-            algo->set_problem(mm);
-            return algo;
-        }
-        virtual std::string display_context(unsigned int context) {
-           std::stringstream ss;
-           ss << "n=" << context+m_initial_n;
-           return ss.str();
-        }
-        std::string get_context_for_csvfile(unsigned int num_context) {
-           return std::to_string(m_initial_n+num_context);
-        }
-
-    private:
-        int m_initial_n;
-};
-
-void optimal_proba_vmath3(int n_initial, int n_final, std::default_random_engine& randomizer, double p_init=0.05, double p_final=0.5, double p_step=0.01, vector<int> nb_tests_by_depth={}, vector<double> stq_by_depth={}) {
-    ProbaOptimizer po(n_initial, randomizer);
-    po.set_nb_contexts(n_final-n_initial);
-    po.set_study_interval(p_init, p_final, p_step);
-    for(int depth=0; depth<nb_tests_by_depth.size(); depth++)
-        po.add_test_wave(nb_tests_by_depth[depth], stq_by_depth[depth], depth);
-    po.run();
-}
-
-void script_optimal_proba(std::default_random_engine& randomizer) {
-    std::string namefile = "optimal-proba.csv";
-    {
-        int n_init=3, n_final=16;
-        double p_init=0.05, p_final=0.5, p_step=0.01;
-        ProbaOptimizer po(n_init, randomizer);
-        po.set_nb_contexts(n_final-n_init);
-        po.set_study_interval(p_init, p_final, p_step);
-        po.add_test_wave(20, 2.3362421597, 0);
-        po.add_test_wave(200, 2.3451370823, 1);
-        po.add_test_wave(2000, 2.2953981367, 2);
-        po.save_run(namefile);
-        po.run();
-    }
-    {
-        int n_init=16, n_final=28;
-        double p_init=0.03, p_final=0.2, p_step=0.01;
-        ProbaOptimizer po(n_init, randomizer);
-        po.set_nb_contexts(n_final-n_init);
-        po.set_study_interval(p_init, p_final, p_step);
-        po.add_test_wave(20, 2.6742086844, 0);
-        po.add_test_wave(100, 2.4755765532, 1);
-        po.add_test_wave(1000, 2.4365960683, 2);
-        po.save_run(namefile);
-        po.run();
-    }
-    {
-        int n_init=28, n_final=46;
-        double p_init=0.01, p_final=0.1, p_step=0.005;
-        ProbaOptimizer po(n_init, randomizer);
-        po.set_nb_contexts(n_final-n_init);
-        po.set_study_interval(p_init, p_final, p_step);
-        po.add_test_wave(20, 2.6742086844, 0);
-        po.add_test_wave(100, 2.4755765532, 1);
-        po.add_test_wave(1000, 2.4365960683, 2);
-        po.save_run(namefile);
-        po.run();
-    }
-}
-
-vector<ConfidenceInterval> optimal_proba_vmath2(int n_initial, int n_final, std::default_random_engine& randomizer, double p_init=0.05, double p_final=0.5, double p_step=0.01, int nb_tests=10, double student_law_quartile=-1, bool displaying=true) {
-    int nb_diff_proba = floor((p_final-p_init)/p_step);
-
-    // Initialize result file
-    ofstream probafile("probas-vmath.csv");
-    probafile << "n;";
-    for(int i=0; i<nb_diff_proba; i++)
-        probafile << p_init+i*p_step << ";";
-    probafile << endl;
-
-    vector<ConfidenceInterval> res;
-
-    for(int n=n_initial; n<n_final; n++) {
-        auto start_n = start_chrono();
-
-        Statistic stats[nb_diff_proba];
-        double thresold = 0;
-        // Realize the experiences
-        for(int ind=0; ind<nb_diff_proba; ind++) {
-            double p = p_init+ind*p_step;
-
-            EA algo(1, 1, PLUS, p, randomizer);
-            MasterMind mm(n, n, randomizer);
-            algo.set_problem(&mm);
-            stats[ind] = avg_calls(&algo, nb_tests, -1, student_law_quartile);
-            double potential_thresold = stats[ind].average + stats[ind].alea;
-            if(ind == 0 || thresold > potential_thresold)
-                thresold = potential_thresold;
-
-            auto stop_loop = stop_chrono();
-            int elapsed_milliseconds_loop = interval_chrono(start_n, stop_loop);
-            if(displaying) cout << '\r' << "n=" << n << ", p=" << p << "... executed in " << elapsed_milliseconds_loop/1000. << " s";
-        }
-
-        // Calculate the confidence interval of 95%
-        if(displaying) cout << '\r' << "n=" << n << ". Thresold=" << thresold << ". Keep best... ";
-        int min_possible = -1;
-        int max_possible = -1;
-        for(int i=0; i<nb_diff_proba; i++) {
-            double min_bound = stats[i].average - stats[i].alea;
-
-            if(min_possible < 0 && min_bound < thresold)
-                min_possible = i;
-            if(min_bound < thresold)
-                max_possible = i;
-        }
-        double pmin = p_init+min_possible*p_step;
-        double pmax = p_init+max_possible*p_step;
-
-        // Store the results in a file
-        probafile << n << ";";
-        for(int i=0; i<nb_diff_proba; i++) {
-            probafile << "("<<pmin<<","<<pmax<<")" << ";";
-        }
-        probafile << endl;
-
-        auto stop_n = stop_chrono();
-        int elapsed_milliseconds_n = interval_chrono(start_n, stop_n);
-        if(displaying) cout << "Interval=[" << pmin << ", " << pmax << "]" << endl;
-        if(displaying) cout << "... executed in " << elapsed_milliseconds_n/1000. << " seconds ";
-        if(displaying) cout << "with " << nb_tests*nb_diff_proba << " resolutions" << endl;
-
-        ConfidenceInterval ci(pmin, -1, pmax);
-        res.push_back(ci);
-    }
-
-    return res;
-}
-
-vector<ConfidenceInterval> optimal_proba_vmath2_rec(int n_initial, int n_final, std::default_random_engine& randomizer, double base_p_init=0.05, double base_p_final=0.5, double p_step=0.01, vector<int> nb_tests_by_depth={}, vector<double> stq_by_depth={}) {
-    vector<ConfidenceInterval> res;
-    for(int n=n_initial; n<n_final; n++) {
-        cout << "STUDY N=" << n << ":" << endl;
-        vector<ConfidenceInterval> cis;
-        int nb_tests = 0;
-        for(unsigned int depth=0; depth<nb_tests_by_depth.size(); depth++) {
-            double p_init = (depth == 0) ? base_p_init : cis[0].down-p_step/pow(2, depth-1);
-            double p_final = (depth == 0) ? base_p_final : cis[0].up+p_step/depth;
-
-            cout << " - depth=" << depth+1 << ": ";
-            cis = optimal_proba_vmath2(n, n+1, randomizer, p_init, p_final, p_step/pow(2, depth), nb_tests_by_depth[depth], stq_by_depth[depth], false);
-            nb_tests += nb_tests_by_depth[depth];
-            cout << "["<< cis[0].down <<","<< cis[0].up <<"]" << endl;
-        }
-        res.push_back(cis[0]);
-
-        ofstream probafile("probas-vmath-rec.csv", ios::app);
-        probafile << n << ";" << cis[0].down << ";" << cis[0].up << ";" << 1./cis[0].up << ";" << 1./cis[0].down << ";" << nb_tests << endl;
-    }
-
-    return res;
-}
-
-double calculate_up_bound(double x, int nb) {
-    return (x + 2./nb + sqrt(4./nb * (x - pow(x, 2) + 1./nb))) / (1. + 4./nb);
-}
-double calculate_down_bound(double x, int nb) {
-    return (x + 2./nb - sqrt(4./nb * (x - pow(x, 2) + 1./nb))) / (1. + 4./nb);
-}
-
-void optimal_proba_vmath(int n_initial, int n_final, std::default_random_engine& randomizer, double p_init=0.05, double p_final=0.5, double p_step=0.01, int nb_loops=1000) {
-    int nb_diff_proba = floor((p_final-p_init)/p_step);
-    int nb_tests = 10;
-
-    // Initialize result file
-    ofstream probafile("probas-vmath.csv");
-    probafile << "n;";
-    for(int i=0; i<nb_diff_proba; i++)
-        probafile << p_init+i*p_step << ";";
-    probafile << endl;
-
-    for(int n=n_initial; n<n_final; n++) {
-        auto start_n = start_chrono();
-
-        int nb_best[nb_diff_proba] = {0};
-        int nb_solved_problems = 0;
-
-        // Realize the experiences
-        int old_min_ind = 0;
-        int max_min_ind = 0;
-        for(int num_loop=1; num_loop<nb_loops; num_loop++) {
-            double min_avg = -1;
-            int min_ind;
-            // Realize the experience once
-            for(int ind2=-1; ind2<nb_diff_proba; ind2++) {
-                if(ind2 == old_min_ind) continue;
-                int ind = (ind2 >= 0) ? ind2 : old_min_ind;
-                double p = p_init+ind*p_step;
-
-                EA algo(1, 1, PLUS, p, randomizer);
-                MasterMind mm(n, n, randomizer);
-                algo.set_problem(&mm);
-                Statistic stat = avg_calls(&algo, nb_tests, min_avg+1);
-                nb_solved_problems += stat.nb;
-
-                double avg_nb_calls = stat.average;
-                if(min_avg < 0 || min_avg > avg_nb_calls) {
-                    min_avg = avg_nb_calls;
-                    min_ind = ind;
-                }
-            }
-
-            // Store the result of the experience
-            nb_best[min_ind]++;
-            if(nb_best[min_ind] > nb_best[max_min_ind])
-                max_min_ind = min_ind;
-            old_min_ind = min_ind;
-
-            // Display temporary results
-            auto stop_loop = stop_chrono();
-            int elapsed_milliseconds_loop = interval_chrono(start_n, stop_loop);
-            cout << "\r";
-            cout << "n=" << n << ", num_loop=" << num_loop << ": ";
-            cout << p_init+max_min_ind*p_step << " (" << nb_best[max_min_ind] << "), ";
-            cout << "executed in " <<elapsed_milliseconds_loop/1000. << " seconds [" << nb_solved_problems << "]";
-            cout << "    ";
-        }
-
-        // Display the global distribution
-        cout << '\r' << "===== Graph ====                     " << endl;
-        for(int j=9; j>=0; j--) {
-            for(int i=0; i<nb_diff_proba; i++) {
-                double pourcent = (double) nb_best[i]/nb_best[max_min_ind];
-                cout << ((pourcent >= j/10.) ? '#' : ' ');
-            }
-            cout << endl;
-        }
-        cout << endl;
-
-        // Calculate the confidence interval of 95%
-        double pbest = p_init+max_min_ind*p_step;
-        double x = (double) nb_best[max_min_ind]/nb_loops;
-        cout << "x=" << x << ',' << nb_loops << ',' << nb_best[max_min_ind] << endl;
-        double up_bound = calculate_up_bound(x, nb_loops);
-        double down_bound = calculate_down_bound(x, nb_loops);
-        cout << "\\mu_{p_best} \\in [" << down_bound << ", " << up_bound << "]" << endl;
-        cout << "Keep best..." << endl;
-
-        int min_possible = -1;
-        int max_possible = -1;
-        for(int i=0; i<nb_diff_proba; i++) {
-            double measured = (double) nb_best[i]/nb_loops;
-            double max_bound = calculate_up_bound(measured, nb_loops);
-
-            if(min_possible < 0 && max_bound >= down_bound)
-                min_possible = i;
-            if(max_bound >= down_bound)
-                max_possible = i;
-        }
-        double pmin = p_init+min_possible*p_step;
-        double pmax = p_init+max_possible*p_step;
-
-        // Store the results in a file
-        probafile << n << ";";
-        for(int i=0; i<nb_diff_proba; i++) {
-            probafile << "("<<pmin<<","<<pbest<<","<<pmax<<")" << ";";
-        }
-        probafile << endl;
-
-        auto stop_n = stop_chrono();
-        int elapsed_milliseconds_n = interval_chrono(start_n, stop_n);
-        cout << "n=" << n << ": We are sure at 95% that it is in [" << pmin << ", " << pmax << "], with p_best=" << pbest << "." << endl;
-        cout << "... executed in " << elapsed_milliseconds_n/1000. << " seconds ";
-        cout << "with " << nb_solved_problems << " resolutions";
-
-        for(int u=0; u<3; u++)
-            Beep(1568, 200);
-
-        //delete[] nb_best;
-    }
-}
-
-/// Bellow, it is just some tests of algorithm...
-
-struct Weight {
-    Weight() : Weight(0) {};
-    Weight(double w) {
-        weight = w;
-        nb_executed = 0;
-        nb_best = 0;
-    }
-
-    double weight;
-    int nb_executed;
-    int nb_best;
-};
-
-void optimal_proba_v2(int n_initial, int n_final, std::default_random_engine& randomizer, double p_init=0.05, double p_final=0.5, double p_step=0.01, int depth_initial=8) {
-    int nb_diff_proba = floor((p_final-p_init)/p_step);
-    double initial_value = 50;
-    int nb_test = 20;
-
-    double zero_limit = 2/3.;
-    double pa = -1./(pow(zero_limit, 2)-2*zero_limit+1);
-    double pb = -2*pa;
-    double pc = 1+pa;
-
-    ofstream probafile("probas.csv");
-    for(int i=0; i<nb_diff_proba; i++)
-        probafile << p_init+i*p_step << ";";
-    probafile << endl;
-
-    for(int n=n_initial; n<n_final; n++) {
-        auto start_n = start_chrono();
-
-        Weight* tab = new Weight[nb_diff_proba];
-        for(int i=0; i<nb_diff_proba; i++)
-            tab[i].weight = initial_value;
-        double max_weight = initial_value;
-        int max_weight_ind_proba = 0;
-        double second_weight = initial_value;
-        int second_weight_ind_proba = 1;
-
-        int nb_solved_problems = 0;
-        for(int depth=depth_initial; depth>0; depth/=2) {
-            double start_with_weight = max_weight;
-            for(int num_loop=1; second_weight + 2*initial_value > max_weight && max_weight < 20*initial_value+start_with_weight; num_loop++) {
-                int nb_new_problems = 0;
-                for(int k=0; k<20; k++) {
-                    double min_avg = -1;
-                    double min_proba;
-                    for(int ind2=-2; ind2<nb_diff_proba; ind2++) {
-                        if(ind2 == max_weight_ind_proba || ind2 == second_weight_ind_proba) continue;
-                        int ind = (ind2 >= 0) ? ind2 : ((ind2 == -2) ? max_weight_ind_proba: second_weight_ind_proba);
-                        if(ind % depth != 0) continue;
-
-                        double p = p_init+ind*p_step;
-
-                        double weight = tab[ind].weight;
-                        double execution_proba = weight/max_weight;
-                        if(ind-depth >= 0 && ind+depth < nb_diff_proba)
-                            execution_proba = ((tab[ind-depth].weight+weight+tab[ind+depth].weight)/3)/max_weight;
-                        else if(ind-depth >= 0)
-                            execution_proba = ((tab[ind-depth].weight + weight)/2)/max_weight;
-                        else if(ind+depth < nb_diff_proba)
-                            execution_proba = ((weight + tab[ind+depth].weight)/2)/max_weight;
-
-                        execution_proba = (2*execution_proba > 1) ? pa*pow(execution_proba, 2)+pb*execution_proba+pc : 0;
-                        std::bernoulli_distribution distribution(execution_proba);
-
-                        if(distribution(randomizer)) {
-                            tab[ind].nb_executed++;
-                            EA algo(1, 1, PLUS, p, randomizer);
-                            MasterMind mm(n, n, randomizer);
-                            algo.set_problem(&mm);
-                            Statistic stat = avg_calls(&algo, nb_test, min_avg+1);
-                            double avg = stat.average;
-
-                            if(min_avg < 0 || min_avg > avg) {
-                                min_avg = avg;
-                                min_proba = p;
-                            }
-
-                            nb_new_problems += stat.nb;
-                        }
-                    }
-                    int ind_p = round((min_proba - p_init)/p_step);
-                    tab[ind_p].weight++;
-
-                    if(tab[ind_p].weight > max_weight) {
-                        max_weight = tab[ind_p].weight;
-                        max_weight_ind_proba = ind_p;
-                    }
-
-                    tab[max_weight_ind_proba].nb_best++;
-                }
-
-                auto stop_loop = stop_chrono();
-                int elapsed_milliseconds_loop = interval_chrono(start_n, stop_loop);
-
-                second_weight = -1;
-                for(int i=0; i<nb_diff_proba; i++)
-                    if(i != max_weight_ind_proba)
-                        if(second_weight < 0 || second_weight < tab[i].weight) {
-                            second_weight = tab[i].weight;
-                            second_weight_ind_proba = i;
-                        }
-
-                nb_solved_problems += nb_new_problems;
-
-                cout << "\r";
-                cout << "n=" << n << ", depth=" << depth << ", num_loop=" << num_loop << ": ";
-                cout << p_init+max_weight_ind_proba*p_step << " (" << max_weight << "), ";
-                cout << p_init+second_weight_ind_proba*p_step << " (" << second_weight << "), ";
-                cout << "executed in " <<elapsed_milliseconds_loop/1000. << " seconds [.+" << nb_new_problems << "=" << nb_solved_problems << "]";
-                cout << "    ";
-            }
-
-            int fdepth = depth / 2;
-            if(fdepth) {
-                for(int ind=0; ind<nb_diff_proba; ind++) {
-                    if(ind%depth != 0 && ind%fdepth == 0) {
-                        if(ind+fdepth<nb_diff_proba)
-                            tab[ind].weight = max(tab[ind-fdepth].weight, tab[ind+fdepth].weight);
-                        else
-                            tab[ind].weight = tab[ind-fdepth].weight;
-                    }
-                }
-                second_weight = max_weight;
-            }
-        }
-
-        double p_best = p_init+max_weight_ind_proba*p_step;
-
-        double mean = 0;
-        for(int i=0; i<nb_diff_proba; i++)
-            mean += tab[i].nb_executed ? ((double) tab[i].nb_best/tab[i].nb_executed) * (p_init+i*p_step) : 0;
-
-        double stddev = 0;
-        for(int i=0; i<nb_diff_proba; i++)
-            stddev += tab[i].nb_executed ? ((double) tab[i].nb_best/tab[i].nb_executed) * pow(p_init+i*p_step, 2) : 0;
-        stddev -= pow(mean, 2);
-        cout << '%' << mean << "," << stddev  << endl;
-        stddev = sqrt(stddev);
-
-
-        for(int i=0; i<nb_diff_proba; i++)
-            probafile << (tab[i].nb_executed ? ((double) tab[i].nb_best/tab[i].nb_executed) * pow(p_init+i*p_step, 2) : 0) << ";";
-        probafile << endl;
-
-        auto stop_n = stop_chrono();
-        int elapsed_milliseconds_n = interval_chrono(start_n, stop_n);
-        cout << '\r' << "n=" << n << ", p_best=" << p_best << " (" << stddev << "), ";
-        cout << "executed in " << elapsed_milliseconds_n/1000. << " seconds ";
-        cout << "with " << nb_solved_problems << " resolutions";
-        cout << "                           " << endl;
-
-//        for(int u=0; u<3; u++)
-//            Beep(1568, 200);
-
-        delete[] tab;
-    }
-}
-
-void optimal_proba(int n_initial, int n_final, std::default_random_engine& randomizer, double p_init=0.05, double p_final=0.5, double p_step=0.01) {
-    for(int n=n_initial; n<n_final; n++) {
-        vector<double> avg_list;
-        vector<double> probas;
-
-        auto start = start_chrono();
-        for(double p=p_init; p<p_final; p+=p_step) {
-            EA algo(1, 1, PLUS, p, randomizer);
-            MasterMind mm(n, n, randomizer);
-            algo.set_problem(&mm);
-            Statistic stat = avg_calls(&algo);
-            double avg = stat.average;
-            avg_list.push_back(avg);
-            probas.push_back(p);
-        }
-        auto stop = stop_chrono();
-        int elapsed_milliseconds = interval_chrono(start, stop);
-
-        int min_ind = 0;
-        for(unsigned int i=1; i<avg_list.size(); i++)
-            if(avg_list[min_ind] > avg_list[i])
-                min_ind = i;
-        double p_best = probas[min_ind];
-        cout << "n=" << n << ": " << p_best << " in " << elapsed_milliseconds/1000. << " seconds " << "(" << 100*floor((p_final-p_init)/p_step) << " problems)" << endl;
-    }
-}
-
-#endif // SCRIPTS_H_INCLUDED

include/scripts2.h

@@ -1,133 +0,0 @@
-#ifndef SCRIPTS2_H_INCLUDED
-#define SCRIPTS2_H_INCLUDED
-
-#include <vector>
-#include <fstream>
-
-#include "analysis.h"
-#include "ParameterOptimizer.h"
-
-void cmp_evolution(std::vector<SearchHeuristic*> algos, MasterMind& problem, int max_evolution, int nb_tests = 100) {
-    int nb_algos = algos.size();
-    Statistic** values = new Statistic*[nb_algos];
-    for(int i=0; i<nb_algos; i++) {
-        algos[i]->set_problem(&problem);
-        values[i] = avg_evolution(algos[i], max_evolution, nb_tests);
-    }
-    std::ofstream statsfile("stats.csv");
-    for(int i=0; i<max_evolution; i++) {
-        statsfile << i << ";";
-        for(int k=0; k<nb_algos; k++)
-            statsfile << values[k][i].average << ";";
-        statsfile << std::endl;
-    }
-
-    for(int i=0; i<nb_algos; i++)
-        delete[] values[i];
-    delete[] values;
-}
-
-/// Max Lambda
-class LambdaOptimizer : public ParameterOptimizer {
-    public:
-        LambdaOptimizer(std::default_random_engine& randomizer) : ParameterOptimizer(randomizer) {};
-        SearchHeuristic* get_context(unsigned int i, double parameter, std::default_random_engine& randomizer) {
-            unsigned int n=20;
-            EA* algo = new EA(1+i, (int)parameter, PLUS, 1./n, randomizer);
-            MasterMind* mm = new MasterMind(n, n, randomizer);
-            algo->set_problem(mm);
-            return algo;
-        }
-        virtual std::string display_context(unsigned int context) {
-           std::stringstream ss;
-           ss << "mu=" << context+1;
-           return ss.str();
-        }
-};
-
-void optimal_lambda(int n, int mu_initial, int mu_final, std::default_random_engine& randomizer, int lambda_init, int lambda_final, int lambda_step=1, int nb_tests=10, double student_law_quartile=-1, bool displaying=true) {
-    LambdaOptimizer lo(randomizer);
-    lo.set_nb_contexts(50);
-    lo.set_study_interval(lambda_init, lambda_final, lambda_step);
-    lo.add_test_wave(nb_tests, student_law_quartile);
-    lo.run();
-}
-
-class MuLambdaOptimizer : public ParameterOptimizer {
-    public:
-        MuLambdaOptimizer(int n_init, std::default_random_engine& randomizer) : ParameterOptimizer(randomizer), n_initial{n_init} {};
-        SearchHeuristic* get_context(unsigned int i, double parameter, std::default_random_engine& randomizer) {
-            EA* algo = new EA((int)parameter, (int)parameter, PLUS, 1./(n_initial+i), randomizer);
-            MasterMind* mm = new MasterMind(n_initial+i, n_initial+i, randomizer);
-            algo->set_problem(mm);
-            return algo;
-        }
-        virtual std::string display_context(unsigned int context) {
-           std::stringstream ss;
-           ss << "n=" << n_initial+context;
-           return ss.str();
-        }
-    private:
-        int n_initial;
-};
-
-void optimal_mulambda(int initial_n, int final_n, std::default_random_engine& randomizer, int par_init, int par_final, int par_step=1, int nb_tests=10, double student_law_quartile=-1, bool displaying=true) {
-    MuLambdaOptimizer lo(initial_n, randomizer);
-    lo.set_nb_contexts(final_n - initial_n);
-    lo.set_study_interval(par_init, par_final, par_step);
-    lo.add_test_wave(nb_tests, student_law_quartile);
-    lo.run();
-}
-
-class CrossoverProbaOptimizer : public ParameterOptimizer {
-    public:
-        CrossoverProbaOptimizer(int n_init, double obj, std::default_random_engine& randomizer) : ParameterOptimizer(randomizer), n_initial{n_init}, objective{obj} {};
-        SearchHeuristic* get_context(unsigned int i, double parameter, std::default_random_engine& randomizer) {
-            GA* algo = new GA(5, 5, PLUS, 1./(n_initial+i), parameter, UNIFORM_CROSSOVER, GA_V1, randomizer);
-            MasterMind* mm = new MasterMind(n_initial+i, n_initial+i, randomizer);
-            algo->set_problem(mm);
-            algo->set_objective(objective);
-            return algo;
-        }
-        std::string display_context(unsigned int context) {
-           std::stringstream ss;
-           ss << "n=" << n_initial+context;
-           return ss.str();
-        }
-        std::string get_context_for_csvfile(unsigned int num_context) {
-           return std::to_string(n_initial+num_context);
-        }
-    private:
-        int n_initial;
-        double objective;
-};
-
-void script_crossover_proba_optim(std::default_random_engine& randomizer) {
-    std::string namefile = "crossover-proba.csv";
-    ofstream savefile(namefile);
-    {
-        int n_init=3, n_final=21;
-        double p_init=0.01, p_final=0.99, p_step=0.02;
-        CrossoverProbaOptimizer cpo(n_init, 1.00, randomizer);
-        cpo.set_nb_contexts(n_final - n_init);
-        cpo.set_study_interval(p_init, p_final, p_step);
-        cpo.add_test_wave(40, 2.5419828669, 0);
-        cpo.add_test_wave(400, 2.4429370465, 1);
-        cpo.add_test_wave(2000, 2.4344837209, 2);
-        cpo.save_run(namefile);
-        cpo.run();
-    }{
-        int n_init=21, n_final=40;
-        double p_init=0.01, p_final=0.3, p_step=0.02;
-        CrossoverProbaOptimizer cpo(n_init, 1.00, randomizer);
-        cpo.set_nb_contexts(n_final - n_init);
-        cpo.set_study_interval(p_init, p_final, p_step);
-        cpo.add_test_wave(80, 2.4860491262, 0);
-        cpo.add_test_wave(200, 2.4535822177, 1);
-        cpo.add_test_wave(400, 2.4429370465, 2);
-        cpo.save_run(namefile);
-        cpo.run();
-    }
-}
-
-#endif // SCRIPTS2_H_INCLUDED

main (conflicted copy 2020-02-03 100957).cpp

@@ -0,0 +1,336 @@
+#include <iostream>
+#include <cstdlib>
+#include <ctime>
+#include <numeric>
+#include <algorithm>
+#include <vector>
+#include <random>
+#include <chrono>
+#include <cmath>
+#include <windows.h>
+
+#include <limits>
+#include <fstream>
+#include <sstream>
+#include <stdlib.h>
+
+#include "EA.h"
+#include "RLS.h"
+#include "analysis.h"
+#include "PEA.h"
+
+#include "ea-complexity.h"
+#include "crossover-rate.h"
+#include "scripts.h"
+#include "scripts2.h"
+#include "bestPGA.h"
+#include "bestPGA.h"
+#include "bestPEA.h"
+#include "algo-complexity.h"
+
+using namespace std;
+
+struct Data {
+    Data() : nb_goods{0} {};
+
+    double r;
+    double s;
+    double t;
+    double u;
+
+    double a;
+    double b;
+    double c;
+    double d;
+
+    double alpha;
+    double beta;
+    double gamma;
+    double lambda;
+
+    int nb_goods;
+};
+
+int main(int argc, char** argv) {
+    srand(time(NULL));
+    std::default_random_engine randomizer{static_cast<long unsigned int>(time(0))};
+
+    if(argc >= 2) {
+        int num_experiment = atoi(argv[1]);
+        switch(num_experiment) {
+            case 1:
+                cout << "Experiment: Optimal Crossover probability" << endl;
+                switch(atoi(argv[2])) {
+                    case 0: // Start from beginning
+                        script_crossover_proba_global_optim(randomizer, "global-crossover-proba.csv", false, 5, 5);
+                        break;
+                    case 1: // Restart from a specific point
+                        {
+                            stringstream ss;
+                            ss << "global-crossover-proba-" << atoi(argv[3]) << "-" << atoi(argv[4]) << ".csv";
+                            script_crossover_proba_global_optim(randomizer, ss.str(), true, atoi(argv[3]), atoi(argv[4]));
+                        }break;
+                    case 2: // Filtering
+                        crossover_model_filtering(argv[3], argv[4], argv[5], atoi(argv[6]), atoi(argv[7]));
+                        break;
+                    case 3: // Local optimization of model
+                        crossover_model_optimization(argv[3]);
+                        break;
+                    case 4: // Validation of model
+                        crossover_model_validation(argv[3], atof(argv[4]), atof(argv[5]), atof(argv[6]), atof(argv[7]));
+                        break;
+                }
+                return 0;
+
+            case 2:
+                cout << "Experiment: EA Complexity" << endl;
+                switch(atoi(argv[2])) {
+                    case 1:
+                        {
+                            int n_initial = (argc>=4) ? atoi(argv[3]) : 3;
+                            stringstream ss;
+                            ss << "complexity-ea-n-" << n_initial << ".csv";
+                            ofstream outfile(ss.str());
+                            for(int n=n_initial; n<30; n++) {
+                                MasterMind mm(n, n, randomizer);
+                                for(int mu=1; mu<50; mu+=2) {
+                                    cout << " n=" << n << ": mu=" << mu << endl;
+                                    for(int lambda=1; lambda<50; lambda+=2) {
+                                        EA algo(mu, lambda, PLUS, 1./n, randomizer);
+                                        algo.set_problem(&mm);
+                                        Statistic stat = avg_calls(&algo, 1000, -1, 1.9623414611);
+                                        outfile << n << ";" << mu << ";" << lambda << ";" << stat.average << ";" << stat.alea << endl;
+                                    }
+                                }
+                            }
+                        }
+                        break;
+                    case 2: // Filtering
+                        ea_complexity_filtering(argv[3], argv[4], atoi(argv[5]), atoi(argv[6]), atoi(argv[7]));
+                        break;
+                }
+                return 0;
+        }
+    }
+    ////////////////////////////////////////////////////
+
+    Data datas[30];
+
+    std::ifstream infile("complexity-ea.csv");
+
+    std::string line;
+    while(getline(infile, line)) {
+        int n, mu, lda;
+        double avg, alea;
+        sscanf(line.c_str(), "%d;%d;%d;%lf;%lf", &n, &mu, &lda, &avg, &alea);
+
+        if((mu==5 || mu==45) && (lda==5 || lda==45)) {
+            if(mu==5) {
+                if(lda==5)
+                    datas[n].r = avg;
+                else
+                    datas[n].s = avg;
+            } else {
+                if(lda==5)
+                    datas[n].t = avg;
+                else
+                    datas[n].u = avg;
+            }
+        }
+    }
+
+    for(int n=5; n<30; n++) {
+        Data dat = datas[n];
+        datas[n].a = (dat.s - dat.r) / (45. - 5.);
+        datas[n].b = dat.s - 45.*datas[n].a;
+        datas[n].c = (dat.u - dat.t) / (45. - 5.);
+        datas[n].b = dat.u - 45.*datas[n].c;
+    }
+    for(int n=5; n<30; n++) {
+        Data dat = datas[n];
+        datas[n].alpha = (dat.c - dat.a) / (45. - 5.);
+        datas[n].gamma = dat.a - 5*datas[n].alpha;
+        datas[n].beta = (dat.d - dat.b) / (45. - 5.);
+        datas[n].lambda = dat.b - 5*datas[n].beta;
+    }
+
+    std::ifstream in2file("complexity-ea.csv");
+    while(getline(in2file, line)) {
+        int n, mu, lda;
+        double avg, alea;
+        sscanf(line.c_str(), "%d;%d;%d;%lf;%lf", &n, &mu, &lda, &avg, &alea);
+
+        Data d = datas[n];
+        double prev = d.alpha*mu*lda + d.beta*mu + d.gamma*lda + d.lambda;
+
+        if(abs(avg-prev) <= alea)
+            datas[n].nb_goods++;
+    }
+    for(int n=5; n<30; n++) {
+        Data d = datas[n];
+        cout << n << ": " << d.alpha << "*mu*lda + " << d.beta << "*mu + " << d.gamma << "*lda + " << d.lambda << " => " << 100*d.nb_goods/625. << "%" << endl;
+    }
+
+    return 0;
+
+
+/*    RLS algo;
+    vector<Statistic> stats = compute_complexity(randomizer, &algo, 10, 1000, 10, 100, 1.9842169516, true);
+    save_in_file("RLS-complexity", stats);
+    return 0;
+*/
+    //script_optimal_proba(randomizer);
+/*
+    pea_optimisation(10, 20, randomizer);
+    return 0;
+*/
+
+    int nb_colors = 20;
+    int nb_cases = 20;
+    int n=20;
+/*
+    MasterMind mm(nb_colors, nb_cases, randomizer);
+    RLS algo1;
+    EA algo2(1, 1, PLUS, 1./n, randomizer);
+    EA algo3(2, 1, PLUS, 1./n, randomizer);
+    EA algo4(4, 1, PLUS, 1./n, randomizer);
+    EA algo5(8, 1, PLUS, 1./n, randomizer);
+    EA algo6(16, 1, PLUS, 1./n, randomizer);
+    algo1.set_problem(&mm);
+    algo2.set_problem(&mm);
+    algo3.set_problem(&mm);
+    algo4.set_problem(&mm);
+    algo5.set_problem(&mm);
+    algo6.set_problem(&mm);
+    vector<SearchHeuristic*> algos = {&algo1, &algo2, &algo3, &algo4, &algo5, &algo6};
+*/
+    MasterMind mm(nb_colors, nb_cases, randomizer);
+    RLS algo1;
+    EA algo2(1, 1, PLUS, 1./n, randomizer);
+    PEA algo3(1, 1, PLUS, {}, randomizer);
+    algo1.set_problem(&mm);
+    algo2.set_problem(&mm);
+    algo3.set_problem(&mm);
+    vector<SearchHeuristic*> algos = {&algo1, &algo2, &algo3};
+
+    Statistic stat = avg_calls(&algo1, 20, -1, 3.883);
+    int max_nb_calls = ceil(stat.average+stat.alea)*2;
+    cmp_evolution(algos, mm, max_nb_calls, 100);
+    return 0;
+/*
+    Statistic* curves[6];
+    Statistic* dcurves[6];
+    int length = 0;
+    for(int i=0; i<algos.size(); i++) {
+        curves[i] = avg_evolution(algos[i], max_nb_calls, 20);
+        dcurves[i] = derivate(curves[i], max_nb_calls);
+        length = max_nb_calls-1;
+        for(int k=0; k<7; k++) {
+            Statistic* cdcurve = compress(dcurves[i], length);
+            delete[] dcurves[i];
+            dcurves[i] = cdcurve;
+            length = ceil(length/2.)-1;
+        }
+        for(int k=0; k<15; k++) {
+            Statistic* sdcurve = smooth(dcurves[i], length);
+            delete[] dcurves[i];
+            dcurves[i] = sdcurve;
+        }
+    }
+
+    ofstream testfile("42.csv");
+    for(int i=0; i<length; i++) {
+        for(int j=0; j<algos.size(); j++)
+            testfile << dcurves[j][i].average << ";";
+        testfile << endl;
+    }
+    ofstream testfile2("43.csv");
+    for(int i=0; i<max_nb_calls; i++) {
+        for(int j=0; j<algos.size(); j++)
+            testfile2 << curves[j][i].average << ";";
+        testfile2 << endl;
+    }
+    for(int j=0; j<algos.size(); j++) {
+        delete[] dcurves[j];
+        delete[] curves[j];
+    }
+
+    return 0;
+
+    int initial_n = 3;
+    int final_n = 25;
+
+    /// Mu-Lambda Optimisation
+    MuLambdaOptimizer mlo(initial_n, randomizer);
+    mlo.set_nb_contexts(final_n - initial_n);
+    mlo.set_study_interval(1, 100, 4);
+    mlo.add_test_wave(100, 2.4751374205, 0);
+    mlo.add_test_wave(1000, 2.4365918443, 1);
+    mlo.add_test_wave(10000, 2.4327997145, 2);
+    //mlo.run();
+
+
+/*
+    //optimal_mulambda(3, 16, randomizer, 1, 50, 1, 100, 1.9842169516);
+    return 0;
+
+    optimal_lambda(20, 1, 2, randomizer, 1, 100, 1, 50, 1.9842169516, true);
+    return 0;
+*/
+/*    int nb_tests = 100;
+    MasterMind mm(nb_colors, nb_cases, randomizer);
+    RLS algo1;
+    GA algo3(10, 10, PLUS, 1./nb_cases, 2./nb_cases, UNIFORM_CROSSOVER, GA_V1, randomizer);
+
+    algo1.set_problem(&mm);
+    Statistic stat = avg_calls(&algo1, 20, -1, 3.883);
+    int max_nb_calls = ceil(stat.average);
+
+    cmp_evolution({&algo1, &algo3}, mm, max_nb_calls, nb_tests);
+    return 0;
+*/
+    //cout << "=========================" << endl;
+    //optimal_proba(5,15, randomizer);
+    //optimal_proba_v2(5,15, randomizer);
+    //optimal_proba_vmath2_rec(3, 16, randomizer, 0.05, 0.5, 0.01, {20, 200, 2000}, {2.3362421597,2.3451370823,3.2953981367});
+    //optimal_proba_vmath2_rec(16, 25, randomizer, 0.02, 0.2, 0.005, {20, 200, 2000}, {2.3362421597,2.3451370823,3.2953981367});
+
+    cout << "FINISHED !" << endl;
+    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
+    std::cin.get();
+
+    return 0;
+
+    cout << "=========================" << endl;
+    for(int n=5; n<6; n++) {
+        vector<double> avg_list;
+        vector<double> lambdas;
+
+        int lambda_init = 1;
+        int lambda_final = 20;
+        int nb_tests = 10000;
+
+        auto start = start_chrono();
+        for(int lambda=lambda_init; lambda<lambda_final; lambda++) {
+            EA algo(1, lambda, PLUS, 1./n, randomizer);
+            MasterMind mm(n, n, randomizer);
+            algo.set_problem(&mm);
+            Statistic stat = avg_calls(&algo, nb_tests);
+            double avg = stat.average;
+            avg_list.push_back(avg);
+            lambdas.push_back(lambda);
+            cout << " -> lambda=" << lambda << ", nbcalls=" << avg << endl;
+        }
+        auto stop = stop_chrono();
+        int elapsed_milliseconds = interval_chrono(start, stop);
+
+        int min_ind = 0;
+        for(unsigned int i=1; i<avg_list.size(); i++)
+            if(avg_list[min_ind] > avg_list[i])
+                min_ind = i;
+        double lambda_best = lambdas[min_ind];
+        cout << "n=" << n << ": " << lambda_best << " in " << elapsed_milliseconds/1000. << " seconds " << "(" << nb_tests*(lambda_final-lambda_init) << " problems)" << endl;
+    }
+
+    return 0;
+}

main (conflicted copy 2020-02-03 104526).cpp

@@ -0,0 +1,381 @@
+#include <iostream>
+#include <cstdlib>
+#include <ctime>
+#include <numeric>
+#include <algorithm>
+#include <vector>
+#include <random>
+#include <chrono>
+#include <cmath>
+#include <windows.h>
+
+#include <limits>
+#include <fstream>
+#include <sstream>
+#include <stdlib.h>
+
+#include "EA.h"
+#include "RLS.h"
+#include "analysis.h"
+#include "PEA.h"
+
+#include "ea-complexity.h"
+#include "crossover-rate.h"
+#include "scripts.h"
+#include "scripts2.h"
+#include "bestPGA.h"
+#include "bestPGA.h"
+#include "bestPEA.h"
+#include "algo-complexity.h"
+
+using namespace std;
+
+struct Data {
+    Data() : nb_goods{0} {};
+
+    double r;
+    double s;
+    double t;
+    double u;
+
+    double a;
+    double b;
+    double c;
+    double d;
+
+    double alpha;
+    double beta;
+    double gamma;
+    double lambda;
+
+    int nb_goods;
+};
+
+struct StoredData {
+    StoredData(int n0, int mu0, int lda0, double avg0, double alea0) :
+        n{n0}, mu{mu0}, lda{lda0}, avg{avg0}, alea{alea0} {};
+    int n, mu, lda;
+    double avg, alea;
+};
+
+int main(int argc, char** argv) {
+    srand(time(NULL));
+    std::default_random_engine randomizer{static_cast<long unsigned int>(time(0))};
+/*
+    MasterMind mm1(1000, 1000, randomizer);
+    RLS algo;
+    algo.set_problem(&mm1);
+    avg_calls(&algo, 1);
+    return 0;
+*/
+    if(argc >= 2) {
+        int num_experiment = atoi(argv[1]);
+        switch(num_experiment) {
+            case 1:
+                cout << "Experiment: Optimal Crossover probability" << endl;
+                switch(atoi(argv[2])) {
+                    case 0: // Start from beginning
+                        script_crossover_proba_global_optim(randomizer, "global-crossover-proba.csv", false, 5, 5);
+                        break;
+                    case 1: // Restart from a specific point
+                        {
+                            stringstream ss;
+                            ss << "global-crossover-proba-" << atoi(argv[3]) << "-" << atoi(argv[4]) << ".csv";
+                            script_crossover_proba_global_optim(randomizer, ss.str(), true, atoi(argv[3]), atoi(argv[4]));
+                        }break;
+                    case 2: // Filtering
+                        crossover_model_filtering(argv[3], argv[4], argv[5], atoi(argv[6]), atoi(argv[7]));
+                        break;
+                    case 3: // Local optimization of model
+                        crossover_model_optimization(argv[3]);
+                        break;
+                    case 4: // Validation of model
+                        crossover_model_validation(argv[3], atof(argv[4]), atof(argv[5]), atof(argv[6]), atof(argv[7]));
+                        break;
+                }
+                return 0;
+
+            case 2:
+                cout << "Experiment: EA Complexity" << endl;
+                switch(atoi(argv[2])) {
+                    case 1:
+                        {
+                            int n_initial = (argc>=4) ? atoi(argv[3]) : 3;
+                            stringstream ss;
+                            ss << "complexity-ea-n-" << n_initial << ".csv";
+                            ofstream outfile(ss.str());
+                            for(int n=n_initial; n<30; n++) {
+                                MasterMind mm(n, n, randomizer);
+                                for(int mu=1; mu<50; mu+=2) {
+                                    cout << " n=" << n << ": mu=" << mu << endl;
+                                    for(int lambda=1; lambda<50; lambda+=2) {
+                                        EA algo(mu, lambda, PLUS, 1./n, randomizer);
+                                        algo.set_problem(&mm);
+                                        Statistic stat = avg_calls(&algo, 1000, -1, 1.9623414611);
+                                        outfile << n << ";" << mu << ";" << lambda << ";" << stat.average << ";" << stat.alea << endl;
+                                    }
+                                }
+                            }
+                        }
+                        break;
+                    case 2: // Filtering
+                        ea_complexity_filtering(argv[3], argv[4], atoi(argv[5]), atoi(argv[6]), atoi(argv[7]));
+                        break;
+                }
+                return 0;
+        }
+    }
+    ////////////////////////////////////////////////////
+
+    Data datas[30];
+    vector<StoredData> sdatas;
+
+    std::ifstream infile("complexity-ea.csv");
+
+    std::string line;
+    while(getline(infile, line)) {
+        int n, mu, lda;
+        double avg, alea;
+        sscanf(line.c_str(), "%d;%d;%d;%lf;%lf", &n, &mu, &lda, &avg, &alea);
+        sdatas.push_back(StoredData(n, mu, lda, avg, alea));
+
+        if((mu==5 || mu==45) && (lda==5 || lda==45)) {
+            if(mu==5) {
+                if(lda==5)
+                    datas[n].r = avg;
+                else
+                    datas[n].s = avg;
+            } else {
+                if(lda==5)
+                    datas[n].t = avg;
+                else
+                    datas[n].u = avg;
+            }
+        }
+    }
+
+    for(int n=5; n<30; n++) {
+        Data dat = datas[n];
+        datas[n].a = (dat.s - dat.r) / (45. - 5.);
+        datas[n].b = dat.s - 45.*datas[n].a;
+        datas[n].c = (dat.u - dat.t) / (45. - 5.);
+        datas[n].d = dat.u - 45.*datas[n].c;
+    }
+    for(int n=5; n<30; n++) {
+        Data dat = datas[n];
+        datas[n].alpha = (dat.c - dat.a) / (45. - 5.);
+        datas[n].gamma = dat.a - 5*datas[n].alpha;
+        datas[n].beta = (dat.d - dat.b) / (45. - 5.);
+        datas[n].lambda = dat.b - 5*datas[n].beta;
+    }
+    for(int i=0, s=sdatas.size(); i<s; i++) {
+        StoredData sd = sdatas[i];
+        Data d = datas[sd.n];
+        double prev = d.alpha*sd.mu*sd.lda + d.beta*sd.mu + d.gamma*sd.lda + d.lambda;
+
+        if(abs(sd.avg-prev) <= sd.alea)
+            datas[sd.n].nb_goods++;
+    }
+    std::uniform_int_distribution<int> distribution(1,4);
+    for(int n=5; n<30; n++) {
+        for(int k=0; k<10000; k++) {
+            int nb1 = distribution(randomizer);
+            int nb2 = distribution(randomizer) % 2;
+            int nb3 = distribution(randomizer);
+            datas[n].alpha += (nb1==1) ? pow(-1, nb2) * 0.01 * nb4 : 0;
+            datas[n].beta += (nb1==2) ? pow(-1, nb2) * 0.01 * nb4: 0;
+            datas[n].gamma += (nb1==3) ? pow(-1, nb2) * 0.01 * nb4: 0;
+            datas[n].lambda += (nb1==4) ? pow(-1, nb2) * 0.01 * nb4: 0;
+
+            int nb_goods = 0;
+            for(int i=0, s=sdatas.size(); i<s; i++) {
+                StoredData sd = sdatas[i];
+                if(sd.n != n) continue;
+                Data d = datas[sd.n];
+                double prev = d.alpha*sd.mu*sd.lda + d.beta*sd.mu + d.gamma*sd.lda + d.lambda;
+
+                if(abs(sd.avg-prev) <= sd.alea)
+                    nb_goods++;
+            }
+
+
+            if(nb_goods < datas[n].nb_goods) {
+                datas[n].alpha -= (nb1==1) ? pow(-1, nb2) * 0.01 * nb4 : 0;
+                datas[n].beta -= (nb1==2) ? pow(-1, nb2) * 0.01 * nb4: 0;
+                datas[n].gamma -= (nb1==3) ? pow(-1, nb2) * 0.01 * nb4: 0;
+                datas[n].lambda -= (nb1==4) ? pow(-1, nb2) * 0.01 * nb4: 0;
+            } else {
+                datas[n].nb_goods = nb_goods;
+            }
+        }
+    }
+
+    for(int n=5; n<30; n++) {
+        Data d = datas[n];
+        cout << n << ": a=" << d.a << ", b=" << d.b << ", c=" << d.c << ", d=" << d.d <<  endl;
+        cout << n << ": " << d.alpha << "*mu*lda + " << d.beta << "*mu + " << d.gamma << "*lda + " << d.lambda << " => " << 100*d.nb_goods/625. << "%" << endl;
+    }
+
+    return 0;
+
+
+/*    RLS algo;
+    vector<Statistic> stats = compute_complexity(randomizer, &algo, 10, 1000, 10, 100, 1.9842169516, true);
+    save_in_file("RLS-complexity", stats);
+    return 0;
+*/
+    //script_optimal_proba(randomizer);
+/*
+    pea_optimisation(10, 20, randomizer);
+    return 0;
+*/
+
+    int nb_colors = 20;
+    int nb_cases = 20;
+    int n=20;
+/*
+    MasterMind mm(nb_colors, nb_cases, randomizer);
+    RLS algo1;
+    EA algo2(1, 1, PLUS, 1./n, randomizer);
+    EA algo3(2, 1, PLUS, 1./n, randomizer);
+    EA algo4(4, 1, PLUS, 1./n, randomizer);
+    EA algo5(8, 1, PLUS, 1./n, randomizer);
+    EA algo6(16, 1, PLUS, 1./n, randomizer);
+    algo1.set_problem(&mm);
+    algo2.set_problem(&mm);
+    algo3.set_problem(&mm);
+    algo4.set_problem(&mm);
+    algo5.set_problem(&mm);
+    algo6.set_problem(&mm);
+    vector<SearchHeuristic*> algos = {&algo1, &algo2, &algo3, &algo4, &algo5, &algo6};
+*/
+    MasterMind mm(nb_colors, nb_cases, randomizer);
+    RLS algo1;
+    EA algo2(1, 1, PLUS, 1./n, randomizer);
+    PEA algo3(1, 1, PLUS, {}, randomizer);
+    algo1.set_problem(&mm);
+    algo2.set_problem(&mm);
+    algo3.set_problem(&mm);
+    vector<SearchHeuristic*> algos = {&algo1, &algo2, &algo3};
+
+    Statistic stat = avg_calls(&algo1, 20, -1, 3.883);
+    int max_nb_calls = ceil(stat.average+stat.alea)*2;
+    cmp_evolution(algos, mm, max_nb_calls, 100);
+    return 0;
+/*
+    Statistic* curves[6];
+    Statistic* dcurves[6];
+    int length = 0;
+    for(int i=0; i<algos.size(); i++) {
+        curves[i] = avg_evolution(algos[i], max_nb_calls, 20);
+        dcurves[i] = derivate(curves[i], max_nb_calls);
+        length = max_nb_calls-1;
+        for(int k=0; k<7; k++) {
+            Statistic* cdcurve = compress(dcurves[i], length);
+            delete[] dcurves[i];
+            dcurves[i] = cdcurve;
+            length = ceil(length/2.)-1;
+        }
+        for(int k=0; k<15; k++) {
+            Statistic* sdcurve = smooth(dcurves[i], length);
+            delete[] dcurves[i];
+            dcurves[i] = sdcurve;
+        }
+    }
+
+    ofstream testfile("42.csv");
+    for(int i=0; i<length; i++) {
+        for(int j=0; j<algos.size(); j++)
+            testfile << dcurves[j][i].average << ";";
+        testfile << endl;
+    }
+    ofstream testfile2("43.csv");
+    for(int i=0; i<max_nb_calls; i++) {
+        for(int j=0; j<algos.size(); j++)
+            testfile2 << curves[j][i].average << ";";
+        testfile2 << endl;
+    }
+    for(int j=0; j<algos.size(); j++) {
+        delete[] dcurves[j];
+        delete[] curves[j];
+    }
+
+    return 0;
+
+    int initial_n = 3;
+    int final_n = 25;
+
+    /// Mu-Lambda Optimisation
+    MuLambdaOptimizer mlo(initial_n, randomizer);
+    mlo.set_nb_contexts(final_n - initial_n);
+    mlo.set_study_interval(1, 100, 4);
+    mlo.add_test_wave(100, 2.4751374205, 0);
+    mlo.add_test_wave(1000, 2.4365918443, 1);
+    mlo.add_test_wave(10000, 2.4327997145, 2);
+    //mlo.run();
+
+
+/*
+    //optimal_mulambda(3, 16, randomizer, 1, 50, 1, 100, 1.9842169516);
+    return 0;
+
+    optimal_lambda(20, 1, 2, randomizer, 1, 100, 1, 50, 1.9842169516, true);
+    return 0;
+*/
+/*    int nb_tests = 100;
+    MasterMind mm(nb_colors, nb_cases, randomizer);
+    RLS algo1;
+    GA algo3(10, 10, PLUS, 1./nb_cases, 2./nb_cases, UNIFORM_CROSSOVER, GA_V1, randomizer);
+
+    algo1.set_problem(&mm);
+    Statistic stat = avg_calls(&algo1, 20, -1, 3.883);
+    int max_nb_calls = ceil(stat.average);
+
+    cmp_evolution({&algo1, &algo3}, mm, max_nb_calls, nb_tests);
+    return 0;
+*/
+    //cout << "=========================" << endl;
+    //optimal_proba(5,15, randomizer);
+    //optimal_proba_v2(5,15, randomizer);
+    //optimal_proba_vmath2_rec(3, 16, randomizer, 0.05, 0.5, 0.01, {20, 200, 2000}, {2.3362421597,2.3451370823,3.2953981367});
+    //optimal_proba_vmath2_rec(16, 25, randomizer, 0.02, 0.2, 0.005, {20, 200, 2000}, {2.3362421597,2.3451370823,3.2953981367});
+
+    cout << "FINISHED !" << endl;
+    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
+    std::cin.get();
+
+    return 0;
+
+    cout << "=========================" << endl;
+    for(int n=5; n<6; n++) {
+        vector<double> avg_list;
+        vector<double> lambdas;
+
+        int lambda_init = 1;
+        int lambda_final = 20;
+        int nb_tests = 10000;
+
+        auto start = start_chrono();
+        for(int lambda=lambda_init; lambda<lambda_final; lambda++) {
+            EA algo(1, lambda, PLUS, 1./n, randomizer);
+            MasterMind mm(n, n, randomizer);
+            algo.set_problem(&mm);
+            Statistic stat = avg_calls(&algo, nb_tests);
+            double avg = stat.average;
+            avg_list.push_back(avg);
+            lambdas.push_back(lambda);
+            cout << " -> lambda=" << lambda << ", nbcalls=" << avg << endl;
+        }
+        auto stop = stop_chrono();
+        int elapsed_milliseconds = interval_chrono(start, stop);
+
+        int min_ind = 0;
+        for(unsigned int i=1; i<avg_list.size(); i++)
+            if(avg_list[min_ind] > avg_list[i])
+                min_ind = i;
+        double lambda_best = lambdas[min_ind];
+        cout << "n=" << n << ": " << lambda_best << " in " << elapsed_milliseconds/1000. << " seconds " << "(" << nb_tests*(lambda_final-lambda_init) << " problems)" << endl;
+    }
+
+    return 0;
+}

main (conflicted copy 2020-02-03 125443).cpp

@@ -0,0 +1,407 @@
+#include <iostream>
+#include <cstdlib>
+#include <ctime>
+#include <numeric>
+#include <algorithm>
+#include <vector>
+#include <random>
+#include <chrono>
+#include <cmath>
+#include <windows.h>
+
+#include <limits>
+#include <fstream>
+#include <sstream>
+#include <stdlib.h>
+
+#include "EA.h"
+#include "RLS.h"
+#include "analysis.h"
+#include "PEA.h"
+
+#include "ea-complexity.h"
+#include "crossover-rate.h"
+#include "scripts.h"
+#include "scripts2.h"
+#include "bestPGA.h"
+#include "bestPGA.h"
+#include "bestPEA.h"
+#include "algo-complexity.h"
+
+using namespace std;
+
+struct Data {
+    Data() : nb_goods{0}, r{0}, s{0}, t{0}, u{0} {};
+
+    double r;
+    double s;
+    double t;
+    double u;
+
+    double a;
+    double b;
+    double c;
+    double d;
+
+    double alpha;
+    double beta;
+    double gamma;
+    double lambda;
+
+    int nb_goods;
+};
+
+struct StoredData {
+    StoredData(int n0, int mu0, int lda0, double avg0, double alea0) :
+        n{n0}, mu{mu0}, lda{lda0}, avg{avg0}, alea{alea0} {};
+    int n, mu, lda;
+    double avg, alea;
+};
+
+int main(int argc, char** argv) {
+    srand(time(NULL));
+    std::default_random_engine randomizer{static_cast<long unsigned int>(time(0))};
+/*
+    MasterMind mm1(1000, 1000, randomizer);
+    RLS algo;
+    algo.set_problem(&mm1);
+    avg_calls(&algo, 1);
+    return 0;
+*/
+    if(argc >= 2) {
+        int num_experiment = atoi(argv[1]);
+        switch(num_experiment) {
+            case 1:
+                cout << "Experiment: Optimal Crossover probability" << endl;
+                switch(atoi(argv[2])) {
+                    case 0: // Start from beginning
+                        script_crossover_proba_global_optim(randomizer, "global-crossover-proba.csv", false, 5, 5);
+                        break;
+                    case 1: // Restart from a specific point
+                        {
+                            stringstream ss;
+                            ss << "global-crossover-proba-" << atoi(argv[3]) << "-" << atoi(argv[4]) << ".csv";
+                            script_crossover_proba_global_optim(randomizer, ss.str(), true, atoi(argv[3]), atoi(argv[4]));
+                        }break;
+                    case 2: // Filtering
+                        crossover_model_filtering(argv[3], argv[4], argv[5], atoi(argv[6]), atoi(argv[7]));
+                        break;
+                    case 3: // Local optimization of model
+                        crossover_model_optimization(argv[3]);
+                        break;
+                    case 4: // Validation of model
+                        crossover_model_validation(argv[3], atof(argv[4]), atof(argv[5]), atof(argv[6]), atof(argv[7]));
+                        break;
+                }
+                return 0;
+
+            case 2:
+                cout << "Experiment: EA Complexity" << endl;
+                switch(atoi(argv[2])) {
+                    case 1:
+                        {
+                            int n_initial = (argc>=4) ? atoi(argv[3]) : 3;
+                            stringstream ss;
+                            ss << "complexity-ea-n-" << n_initial << ".csv";
+                            ofstream outfile(ss.str());
+                            for(int n=n_initial; n<30; n++) {
+                                MasterMind mm(n, n, randomizer);
+                                for(int mu=1; mu<50; mu+=2) {
+                                    cout << " n=" << n << ": mu=" << mu << endl;
+                                    for(int lambda=1; lambda<50; lambda+=2) {
+                                        EA algo(mu, lambda, PLUS, 1./n, randomizer);
+                                        algo.set_problem(&mm);
+                                        Statistic stat = avg_calls(&algo, 1000, -1, 1.9623414611);
+                                        outfile << n << ";" << mu << ";" << lambda << ";" << stat.average << ";" << stat.alea << endl;
+                                    }
+                                }
+                            }
+                        }
+                        break;
+                    case 2: // Filtering
+                        ea_complexity_filtering(argv[3], argv[4], atoi(argv[5]), atoi(argv[6]), atoi(argv[7]));
+                        break;
+                }
+                return 0;
+        }
+    }
+    ////////////////////////////////////////////////////
+
+    Data datas[30];
+    vector<StoredData> sdatas;
+
+    std::ifstream infile("complexity-ea.csv");
+
+    std::string line;
+    while(getline(infile, line)) {
+        int n, mu, lda;
+        double avg, alea;
+        sscanf(line.c_str(), "%d;%d;%d;%lf;%lf", &n, &mu, &lda, &avg, &alea);
+        sdatas.push_back(StoredData(n, mu, lda, avg, alea));
+
+        if(3 <= mu && mu <= 7) {
+            if(3 <= lda && lda <= 7)
+                datas[n].r += avg;
+            else if(43 <= lda && lda <= 47)
+                datas[n].s += avg;
+        } else if(43 <= mu && mu <= 47) {
+            if(3 <= lda && lda <= 7)
+                datas[n].t += avg;
+            else if(43 <= lda && lda <= 47)
+                datas[n].u += avg;
+        }
+    }
+
+    for(int n=5; n<30; n++) {
+        datas[n].r /= 9.;
+        datas[n].s /= 9.;
+        datas[n].t /= 9.;
+        datas[n].u /= 9.;
+
+        Data dat = datas[n];
+        datas[n].a = (dat.s - dat.r) / (45. - 5.);
+        datas[n].b = dat.s - 45.*datas[n].a;
+        datas[n].c = (dat.u - dat.t) / (45. - 5.);
+        datas[n].d = dat.u - 45.*datas[n].c;
+    }
+    for(int n=5; n<30; n++) {
+        Data dat = datas[n];
+        datas[n].alpha = (dat.c - dat.a) / (45. - 5.);
+        datas[n].gamma = dat.a - 5*datas[n].alpha;
+        datas[n].beta = (dat.d - dat.b) / (45. - 5.);
+        datas[n].lambda = dat.b - 5*datas[n].beta;
+    }
+    for(int i=0, s=sdatas.size(); i<s; i++) {
+        StoredData sd = sdatas[i];
+        Data d = datas[sd.n];
+        double prev = d.alpha*sd.mu*sd.lda + d.beta*sd.mu + d.gamma*sd.lda + d.lambda;
+
+        if(abs(sd.avg-prev) <= sd.alea)
+            datas[sd.n].nb_goods++;
+    }
+    std::uniform_int_distribution<int> distribution(1,16);
+    for(int n=5; n<30; n++) {
+        for(int k=0; k<100000; k++) {
+            int nb1 = (distribution(randomizer) % 4)+1;
+            int nb2 = distribution(randomizer) % 2;
+            int nb3 = distribution(randomizer);
+            datas[n].alpha += (nb1==1) ? pow(-1, nb2) * 0.01 * nb3 : 0;
+            datas[n].beta += (nb1==2) ? pow(-1, nb2) * 0.01 * nb3 : 0;
+            datas[n].gamma += (nb1==3) ? pow(-1, nb2) * 0.01 * nb3 : 0;
+            datas[n].lambda += (nb1==4) ? pow(-1, nb2) * 1 * nb3 : 0;
+
+            int nb_goods = 0;
+            for(int i=0, s=sdatas.size(); i<s; i++) {
+                StoredData sd = sdatas[i];
+                if(sd.n != n) continue;
+                Data d = datas[sd.n];
+                double prev = d.alpha*sd.mu*sd.lda + d.beta*sd.mu + d.gamma*sd.lda + d.lambda;
+
+                if(abs(sd.avg-prev) <= sd.alea)
+                    nb_goods++;
+            }
+
+
+            if(nb_goods < datas[n].nb_goods) {
+                datas[n].alpha -= (nb1==1) ? pow(-1, nb2) * 0.01 * nb3 : 0;
+                datas[n].beta -= (nb1==2) ? pow(-1, nb2) * 0.01 * nb3 : 0;
+                datas[n].gamma -= (nb1==3) ? pow(-1, nb2) * 0.01 * nb3 : 0;
+                datas[n].lambda -= (nb1==4) ? pow(-1, nb2) * 1 * nb3 : 0;
+            } else {
+                datas[n].nb_goods = nb_goods;
+            }
+        }
+    }
+
+    ofstream outfile("filtered.csv");
+    for(int i=0, s=sdatas.size(); i<s; i++) {
+        StoredData sd = sdatas[i];
+        Data d = datas[sd.n];
+        double prev = d.alpha*sd.mu*sd.lda + d.beta*sd.mu + d.gamma*sd.lda + d.lambda;
+
+        if(sd.n==5 && sd.mu==25)
+            outfile << sd.n << ";" << sd.mu << ";" << sd.lda << ";" << sd.avg - sd.alea << ";" << sd.avg + sd.alea << ";" << prev << ";" << (int) (abs(sd.avg-prev) <= sd.alea) << endl;
+    }
+
+    ofstream out2file("modeling.csv");
+    for(int n=5; n<30; n++) {
+        Data d = datas[n];
+        //cout << n << ": a=" << d.a << ", b=" << d.b << ", c=" << d.c << ", d=" << d.d <<  endl;
+        cout << n << ": " << d.alpha << "*mu*lda + " << d.beta << "*mu + " << d.gamma << "*lda + " << d.lambda << " => " << 100*d.nb_goods/(625.) << "%" << endl;
+        out2file << n << ";" << d.alpha << ";" << d.beta << ";" << d.gamma << ";" << d.lambda << endl;
+    }
+
+    int global_nb_goods = 0;
+    for(int n=5; n<30; n++) {
+        Data d = datas[n];
+
+        double prev = d.alpha*sd.mu*sd.lda + d.beta*sd.mu + d.gamma*sd.lda + d.lambda;
+
+        if(abs(sd.avg-prev) <= sd.alea)
+            global_nb_goods++;
+    }
+    cout << "GLOBAL: " << 100*global_nb_goods/(625.*25) << "%" << endl;;
+
+    return 0;
+
+
+/*    RLS algo;
+    vector<Statistic> stats = compute_complexity(randomizer, &algo, 10, 1000, 10, 100, 1.9842169516, true);
+    save_in_file("RLS-complexity", stats);
+    return 0;
+*/
+    //script_optimal_proba(randomizer);
+/*
+    pea_optimisation(10, 20, randomizer);
+    return 0;
+*/
+
+    int nb_colors = 20;
+    int nb_cases = 20;
+    int n=20;
+/*
+    MasterMind mm(nb_colors, nb_cases, randomizer);
+    RLS algo1;
+    EA algo2(1, 1, PLUS, 1./n, randomizer);
+    EA algo3(2, 1, PLUS, 1./n, randomizer);
+    EA algo4(4, 1, PLUS, 1./n, randomizer);
+    EA algo5(8, 1, PLUS, 1./n, randomizer);
+    EA algo6(16, 1, PLUS, 1./n, randomizer);
+    algo1.set_problem(&mm);
+    algo2.set_problem(&mm);
+    algo3.set_problem(&mm);
+    algo4.set_problem(&mm);
+    algo5.set_problem(&mm);
+    algo6.set_problem(&mm);
+    vector<SearchHeuristic*> algos = {&algo1, &algo2, &algo3, &algo4, &algo5, &algo6};
+*/
+    MasterMind mm(nb_colors, nb_cases, randomizer);
+    RLS algo1;
+    EA algo2(1, 1, PLUS, 1./n, randomizer);
+    PEA algo3(1, 1, PLUS, {}, randomizer);
+    algo1.set_problem(&mm);
+    algo2.set_problem(&mm);
+    algo3.set_problem(&mm);
+    vector<SearchHeuristic*> algos = {&algo1, &algo2, &algo3};
+
+    Statistic stat = avg_calls(&algo1, 20, -1, 3.883);
+    int max_nb_calls = ceil(stat.average+stat.alea)*2;
+    cmp_evolution(algos, mm, max_nb_calls, 100);
+    return 0;
+/*
+    Statistic* curves[6];
+    Statistic* dcurves[6];
+    int length = 0;
+    for(int i=0; i<algos.size(); i++) {
+        curves[i] = avg_evolution(algos[i], max_nb_calls, 20);
+        dcurves[i] = derivate(curves[i], max_nb_calls);
+        length = max_nb_calls-1;
+        for(int k=0; k<7; k++) {
+            Statistic* cdcurve = compress(dcurves[i], length);
+            delete[] dcurves[i];
+            dcurves[i] = cdcurve;
+            length = ceil(length/2.)-1;
+        }
+        for(int k=0; k<15; k++) {
+            Statistic* sdcurve = smooth(dcurves[i], length);
+            delete[] dcurves[i];
+            dcurves[i] = sdcurve;
+        }
+    }
+
+    ofstream testfile("42.csv");
+    for(int i=0; i<length; i++) {
+        for(int j=0; j<algos.size(); j++)
+            testfile << dcurves[j][i].average << ";";
+        testfile << endl;
+    }
+    ofstream testfile2("43.csv");
+    for(int i=0; i<max_nb_calls; i++) {
+        for(int j=0; j<algos.size(); j++)
+            testfile2 << curves[j][i].average << ";";
+        testfile2 << endl;
+    }
+    for(int j=0; j<algos.size(); j++) {
+        delete[] dcurves[j];
+        delete[] curves[j];
+    }
+
+    return 0;
+
+    int initial_n = 3;
+    int final_n = 25;
+
+    /// Mu-Lambda Optimisation
+    MuLambdaOptimizer mlo(initial_n, randomizer);
+    mlo.set_nb_contexts(final_n - initial_n);
+    mlo.set_study_interval(1, 100, 4);
+    mlo.add_test_wave(100, 2.4751374205, 0);
+    mlo.add_test_wave(1000, 2.4365918443, 1);
+    mlo.add_test_wave(10000, 2.4327997145, 2);
+    //mlo.run();
+
+
+/*
+    //optimal_mulambda(3, 16, randomizer, 1, 50, 1, 100, 1.9842169516);
+    return 0;
+
+    optimal_lambda(20, 1, 2, randomizer, 1, 100, 1, 50, 1.9842169516, true);
+    return 0;
+*/
+/*    int nb_tests = 100;
+    MasterMind mm(nb_colors, nb_cases, randomizer);
+    RLS algo1;
+    GA algo3(10, 10, PLUS, 1./nb_cases, 2./nb_cases, UNIFORM_CROSSOVER, GA_V1, randomizer);
+
+    algo1.set_problem(&mm);
+    Statistic stat = avg_calls(&algo1, 20, -1, 3.883);
+    int max_nb_calls = ceil(stat.average);
+
+    cmp_evolution({&algo1, &algo3}, mm, max_nb_calls, nb_tests);
+    return 0;
+*/
+    //cout << "=========================" << endl;
+    //optimal_proba(5,15, randomizer);
+    //optimal_proba_v2(5,15, randomizer);
+    //optimal_proba_vmath2_rec(3, 16, randomizer, 0.05, 0.5, 0.01, {20, 200, 2000}, {2.3362421597,2.3451370823,3.2953981367});
+    //optimal_proba_vmath2_rec(16, 25, randomizer, 0.02, 0.2, 0.005, {20, 200, 2000}, {2.3362421597,2.3451370823,3.2953981367});
+
+    cout << "FINISHED !" << endl;
+    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
+    std::cin.get();
+
+    return 0;
+
+    cout << "=========================" << endl;
+    for(int n=5; n<6; n++) {
+        vector<double> avg_list;
+        vector<double> lambdas;
+
+        int lambda_init = 1;
+        int lambda_final = 20;
+        int nb_tests = 10000;
+
+        auto start = start_chrono();
+        for(int lambda=lambda_init; lambda<lambda_final; lambda++) {
+            EA algo(1, lambda, PLUS, 1./n, randomizer);
+            MasterMind mm(n, n, randomizer);
+            algo.set_problem(&mm);
+            Statistic stat = avg_calls(&algo, nb_tests);
+            double avg = stat.average;
+            avg_list.push_back(avg);
+            lambdas.push_back(lambda);
+            cout << " -> lambda=" << lambda << ", nbcalls=" << avg << endl;
+        }
+        auto stop = stop_chrono();
+        int elapsed_milliseconds = interval_chrono(start, stop);
+
+        int min_ind = 0;
+        for(unsigned int i=1; i<avg_list.size(); i++)
+            if(avg_list[min_ind] > avg_list[i])
+                min_ind = i;
+        double lambda_best = lambdas[min_ind];
+        cout << "n=" << n << ": " << lambda_best << " in " << elapsed_milliseconds/1000. << " seconds " << "(" << nb_tests*(lambda_final-lambda_init) << " problems)" << endl;
+    }
+
+    return 0;
+}

main.cpp

@@ -14,205 +14,50 @@
 #include <sstream>
 #include <stdlib.h>
 
-#include "EA.h"
-#include "RLS.h"
-#include "analysis.h"
+#include "heuristics/RLS.h"
+#include "heuristics/EA.h"
+#include "heuristics/PEA.h"
+#include "analysis/analysis.h"
 
-#include "crossover-rate.h"
-#include "scripts.h"
-#include "scripts2.h"
-#include "bestPGA.h"
-#include "algo-complexity.h"
+#include "experiences/complexity-rls.h"
+#include "experiences/complexity-ea.h"
+#include "experiences/complexity-ga.h"
+#include "experiences/crossover-rate.h"
+
+#include "experiences/scripts.h"
+#include "experiences/bestPGA.h"
+#include "experiences/bestPEA.h"
 
 using namespace std;
 
 int main(int argc, char** argv) {
     srand(time(NULL));
     std::default_random_engine randomizer{static_cast<long unsigned int>(time(0))};
-
+    study_complexity_of_ga_treat(randomizer, "bin/Release/complexity-ga.csv", 3, 30);
+    return 0;
     if(argc >= 2) {
         int num_experiment = atoi(argv[1]);
         switch(num_experiment) {
             case 1:
                 cout << "Experiment: Optimal Crossover probability" << endl;
-                switch(atoi(argv[2])) {
-                    case 0: // Start from beginning
-                        script_crossover_proba_global_optim(randomizer, "global-crossover-proba.csv", false, 5, 5);
-                        break;
-                    case 1: // Restart from a specific point
-                        {
-                            stringstream ss;
-                            ss << "global-crossover-proba-" << atoi(argv[3]) << "-" << atoi(argv[4]) << ".csv";
-                            script_crossover_proba_global_optim(randomizer, ss.str(), true, atoi(argv[3]), atoi(argv[4]));
-                        }break;
-                    case 2: // Filtering
-                        crossover_model_filtering(argv[3], argv[4], argv[5], atoi(argv[6]), atoi(argv[7]));
-                        break;
-                    case 3: // Local optimization of model
-                        crossover_model_optimization(argv[3]);
-                        break;
-                    case 4: // Validation of model
-                        crossover_model_validation(argv[3], atof(argv[4]), atof(argv[5]), atof(argv[6]), atof(argv[7]));
-                        break;
-                }
-
-
-
+                crossover_model(randomizer, atoi(argv[2]), argc, argv);
                 return 0;
-        }
-    }
-    ////////////////////////////////////////////////////
-
-    RLS algo;
-    vector<Statistic> stats = compute_complexity(randomizer, &algo, 10, 1000, 10, 100, 1.9842169516, true);
-    save_in_file("RLS-complexity", stats);
-    return 0;
-
-    //script_optimal_proba(randomizer);
-
-    pga_optimisation(10, 20, randomizer);
-    return 0;
-
-
-    int nb_colors = 50;
-    int nb_cases = 50;
-
-    MasterMind mm(nb_colors, nb_cases, randomizer);
-    RLS algo1;
-    EA algo2(100, 100, PLUS, 1./nb_colors, randomizer);
-    GA algo3(100, 100, PLUS, 1./nb_cases, cr(nb_colors, 100), UNIFORM_CROSSOVER, GA_V1, randomizer);
-    cout << cr(nb_colors, 100) << endl;
-    EA algo4(500, 500, PLUS, 1./nb_colors, randomizer);
-    GA algo5(500, 500, PLUS, 1./nb_cases, cr(nb_colors, 500), UNIFORM_CROSSOVER, GA_V1, randomizer);
-    cout << cr(nb_colors, 500) << endl;
-    GA algo6(100, 100, PLUS, 1./nb_cases, 0.8, UNIFORM_CROSSOVER, GA_V1, randomizer);
-    algo1.set_problem(&mm);
-    algo2.set_problem(&mm);
-    algo3.set_problem(&mm);
-    algo4.set_problem(&mm);
-    algo5.set_problem(&mm);
-    algo6.set_problem(&mm);
-    vector<SearchHeuristic*> algos = {&algo1, &algo2, &algo3, &algo4, &algo5, &algo6};
-
-    Statistic stat = avg_calls(&algo1, 20, -1, 3.883);
-    int max_nb_calls = ceil(stat.average+stat.alea)*2;
-
-
-    cmp_evolution(algos, mm, max_nb_calls, 100);
-    return 0;
-/*
-    Statistic* curves[6];
-    Statistic* dcurves[6];
-    int length = 0;
-    for(int i=0; i<algos.size(); i++) {
-        curves[i] = avg_evolution(algos[i], max_nb_calls, 20);
-        dcurves[i] = derivate(curves[i], max_nb_calls);
-        length = max_nb_calls-1;
-        for(int k=0; k<7; k++) {
-            Statistic* cdcurve = compress(dcurves[i], length);
-            delete[] dcurves[i];
-            dcurves[i] = cdcurve;
-            length = ceil(length/2.)-1;
-        }
-        for(int k=0; k<15; k++) {
-            Statistic* sdcurve = smooth(dcurves[i], length);
-            delete[] dcurves[i];
-            dcurves[i] = sdcurve;
-        }
-    }
 
-    ofstream testfile("42.csv");
-    for(int i=0; i<length; i++) {
-        for(int j=0; j<algos.size(); j++)
-            testfile << dcurves[j][i].average << ";";
-        testfile << endl;
-    }
-    ofstream testfile2("43.csv");
-    for(int i=0; i<max_nb_calls; i++) {
-        for(int j=0; j<algos.size(); j++)
-            testfile2 << curves[j][i].average << ";";
-        testfile2 << endl;
-    }
-    for(int j=0; j<algos.size(); j++) {
-        delete[] dcurves[j];
-        delete[] curves[j];
-    }
-
-    return 0;
-
-    int initial_n = 3;
-    int final_n = 25;
-
-    /// Mu-Lambda Optimisation
-    MuLambdaOptimizer mlo(initial_n, randomizer);
-    mlo.set_nb_contexts(final_n - initial_n);
-    mlo.set_study_interval(1, 100, 4);
-    mlo.add_test_wave(100, 2.4751374205, 0);
-    mlo.add_test_wave(1000, 2.4365918443, 1);
-    mlo.add_test_wave(10000, 2.4327997145, 2);
-    //mlo.run();
-
-
-/*
-    //optimal_mulambda(3, 16, randomizer, 1, 50, 1, 100, 1.9842169516);
-    return 0;
-
-    optimal_lambda(20, 1, 2, randomizer, 1, 100, 1, 50, 1.9842169516, true);
-    return 0;
-*/
-/*    int nb_tests = 100;
-    MasterMind mm(nb_colors, nb_cases, randomizer);
-    RLS algo1;
-    GA algo3(10, 10, PLUS, 1./nb_cases, 2./nb_cases, UNIFORM_CROSSOVER, GA_V1, randomizer);
-
-    algo1.set_problem(&mm);
-    Statistic stat = avg_calls(&algo1, 20, -1, 3.883);
-    int max_nb_calls = ceil(stat.average);
-
-    cmp_evolution({&algo1, &algo3}, mm, max_nb_calls, nb_tests);
-    return 0;
-*/
-    //cout << "=========================" << endl;
-    //optimal_proba(5,15, randomizer);
-    //optimal_proba_v2(5,15, randomizer);
-    //optimal_proba_vmath2_rec(3, 16, randomizer, 0.05, 0.5, 0.01, {20, 200, 2000}, {2.3362421597,2.3451370823,3.2953981367});
-    //optimal_proba_vmath2_rec(16, 25, randomizer, 0.02, 0.2, 0.005, {20, 200, 2000}, {2.3362421597,2.3451370823,3.2953981367});
-
-    cout << "FINISHED !" << endl;
-    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
-    std::cin.get();
-
-    return 0;
-
-    cout << "=========================" << endl;
-    for(int n=5; n<6; n++) {
-        vector<double> avg_list;
-        vector<double> lambdas;
+            case 2:
+                cout << "Experiment: RLS Complexity" << endl;
+                study_complexity_of_rls(randomizer, atoi(argv[2]), argc, argv);
+                return 0;
 
-        int lambda_init = 1;
-        int lambda_final = 20;
-        int nb_tests = 10000;
+            case 3:
+                cout << "Experiment: EA Complexity" << endl;
+                study_complexity_of_ea(randomizer, atoi(argv[2]), argc, argv);
+                return 0;
 
-        auto start = start_chrono();
-        for(int lambda=lambda_init; lambda<lambda_final; lambda++) {
-            EA algo(1, lambda, PLUS, 1./n, randomizer);
-            MasterMind mm(n, n, randomizer);
-            algo.set_problem(&mm);
-            Statistic stat = avg_calls(&algo, nb_tests);
-            double avg = stat.average;
-            avg_list.push_back(avg);
-            lambdas.push_back(lambda);
-            cout << " -> lambda=" << lambda << ", nbcalls=" << avg << endl;
+            case 4:
+                cout << "Experiment: GA Complexity" << endl;
+                study_complexity_of_ga(randomizer, atoi(argv[2]), argc, argv);
+                return 0;
         }
-        auto stop = stop_chrono();
-        int elapsed_milliseconds = interval_chrono(start, stop);
-
-        int min_ind = 0;
-        for(unsigned int i=1; i<avg_list.size(); i++)
-            if(avg_list[min_ind] > avg_list[i])
-                min_ind = i;
-        double lambda_best = lambdas[min_ind];
-        cout << "n=" << n << ": " << lambda_best << " in " << elapsed_milliseconds/1000. << " seconds " << "(" << nb_tests*(lambda_final-lambda_init) << " problems)" << endl;
     }
 
     return 0;

mm-cpp.cbp

@@ -36,35 +36,43 @@
 			<Add option="-Wall" />
 			<Add option="-fexceptions" />
 		</Compiler>
-		<Unit filename="include/EA.h" />
-		<Unit filename="include/GA.h" />
-		<Unit filename="include/GGA.h" />
-		<Unit filename="include/MasterMind.h" />
-		<Unit filename="include/PGA.h" />
-		<Unit filename="include/ParameterOptimizer.h" />
-		<Unit filename="include/RLS.h" />
-		<Unit filename="include/SearchHeuristic.h" />
-		<Unit filename="include/algo-complexity.h" />
-		<Unit filename="include/analysis.h" />
-		<Unit filename="include/bestPGA.h" />
-		<Unit filename="include/crossover-rate.h" />
-		<Unit filename="include/crossover.h" />
-		<Unit filename="include/scripts.h" />
-		<Unit filename="include/scripts2.h" />
+		<Unit filename="include/analysis/ParameterOptimizer.h" />
+		<Unit filename="include/analysis/analysis.h" />
+		<Unit filename="include/experiences/bestPEA.h" />
+		<Unit filename="include/experiences/bestPGA.h" />
+		<Unit filename="include/experiences/compare-evolutions.h" />
+		<Unit filename="include/experiences/complexity-ea.h" />
+		<Unit filename="include/experiences/complexity-ga.h" />
+		<Unit filename="include/experiences/complexity-rls.h" />
+		<Unit filename="include/experiences/crossover-rate.h" />
+		<Unit filename="include/experiences/mutation-rate.h" />
+		<Unit filename="include/experiences/scripts.h" />
+		<Unit filename="include/heuristics/EA.h" />
+		<Unit filename="include/heuristics/GA.h" />
+		<Unit filename="include/heuristics/GGA.h" />
+		<Unit filename="include/heuristics/PEA.h" />
+		<Unit filename="include/heuristics/PGA.h" />
+		<Unit filename="include/heuristics/RLS.h" />
+		<Unit filename="include/heuristics/SearchHeuristic.h" />
+		<Unit filename="include/problems/MasterMind.h" />
+		<Unit filename="include/problems/crossover.h" />
 		<Unit filename="main.cpp" />
-		<Unit filename="src/EA.cpp" />
-		<Unit filename="src/GA.cpp" />
-		<Unit filename="src/GGA.cpp" />
-		<Unit filename="src/MasterMind.cpp" />
-		<Unit filename="src/PGA.cpp" />
-		<Unit filename="src/ParameterOptimizer.cpp">
-			<Option weight="59" />
-		</Unit>
-		<Unit filename="src/RLS.cpp" />
-		<Unit filename="src/SearchHeuristic.cpp" />
-		<Unit filename="src/algo-complexity.cpp" />
-		<Unit filename="src/analysis.cpp" />
-		<Unit filename="src/crossover-rate.cpp" />
+		<Unit filename="src/analysis/ParameterOptimizer.cpp" />
+		<Unit filename="src/analysis/analysis.cpp" />
+		<Unit filename="src/experiences/compare-evolutions.cpp" />
+		<Unit filename="src/experiences/complexity-ea.cpp" />
+		<Unit filename="src/experiences/complexity-ga.cpp" />
+		<Unit filename="src/experiences/complexity-rls.cpp" />
+		<Unit filename="src/experiences/crossover-rate.cpp" />
+		<Unit filename="src/experiences/mutation-rate.cpp" />
+		<Unit filename="src/heuristics/EA.cpp" />
+		<Unit filename="src/heuristics/GA.cpp" />
+		<Unit filename="src/heuristics/GGA.cpp" />
+		<Unit filename="src/heuristics/PEA.cpp" />
+		<Unit filename="src/heuristics/PGA.cpp" />
+		<Unit filename="src/heuristics/RLS.cpp" />
+		<Unit filename="src/heuristics/SearchHeuristic.cpp" />
+		<Unit filename="src/problems/MasterMind.cpp" />
 		<Extensions>
 			<code_completion />
 			<envvars />

mm-cpp.depend

@@ -138,3 +138,355 @@
 	<fstream>
 	"analysis.h"
 
+1580571757 source:c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\src\algo-complexity.cpp
+	"algo-complexity.h"
+
+1580571704 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\algo-complexity.h
+	<string>
+	<vector>
+	<fstream>
+	"analysis.h"
+
+1580571185 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\analysis.h
+	<iostream>
+	<chrono>
+	<vector>
+	<algorithm>
+	<fstream>
+	"SearchHeuristic.h"
+
+1579790033 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\searchheuristic.h
+	<vector>
+	"MasterMind.h"
+
+1579813071 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\mastermind.h
+	<iostream>
+	<ctime>
+	<random>
+	<vector>
+	<algorithm>
+	"crossover.h"
+
+1579640108 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\crossover.h
+
+1580211297 source:c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\src\analysis.cpp
+	"analysis.h"
+
+1580683883 source:c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\src\crossover-rate.cpp
+	"crossover-rate.h"
+
+1580480551 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\crossover-rate.h
+	<vector>
+	<fstream>
+	"ParameterOptimizer.h"
+	"GA.h"
+
+1580228991 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\parameteroptimizer.h
+	<iostream>
+	<vector>
+	<string>
+	<sstream>
+	<fstream>
+	"SearchHeuristic.h"
+	"analysis.h"
+
+1580657521 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\ga.h
+	<random>
+	"GGA.h"
+
+1580657392 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\gga.h
+	<iostream>
+	<vector>
+	<algorithm>
+	<random>
+	"SearchHeuristic.h"
+
+1579638586 source:c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\src\ea.cpp
+	"EA.h"
+
+1579813024 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\ea.h
+	<random>
+	"GA.h"
+
+1580657472 source:c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\src\ga.cpp
+	"GA.h"
+
+1580746399 source:c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\src\gga.cpp
+	"GGA.h"
+
+1579810278 source:c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\src\mastermind.cpp
+	"MasterMind.h"
+
+1580657592 source:c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\src\pga.cpp
+	"PGA.h"
+
+1580657599 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\pga.h
+	<vector>
+	<random>
+	"GGA.h"
+
+1579790133 source:c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\src\rls.cpp
+	"RLS.h"
+
+1578486688 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\rls.h
+	<iostream>
+	"SearchHeuristic.h"
+
+1579790104 source:c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\src\searchheuristic.cpp
+	"SearchHeuristic.h"
+
+1580229005 source:c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\src\parameteroptimizer.cpp
+	"ParameterOptimizer.h"
+
+1580747340 source:c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\src\pea.cpp
+	"PEA.h"
+
+1580659325 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\pea.h
+	"GGA.h"
+	"crossover.h"
+
+1580809644 source:c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\main.cpp
+	<iostream>
+	<cstdlib>
+	<ctime>
+	<numeric>
+	<algorithm>
+	<vector>
+	<random>
+	<chrono>
+	<cmath>
+	<windows.h>
+	<limits>
+	<fstream>
+	<sstream>
+	<stdlib.h>
+	"heuristics/RLS.h"
+	"heuristics/EA.h"
+	"heuristics/PEA.h"
+	"analysis/analysis.h"
+	"experiences/complexity-rls.h"
+	"experiences/complexity-ea.h"
+	"experiences/complexity-ga.h"
+	"experiences/crossover-rate.h"
+	"experiences/scripts.h"
+	"experiences/bestPGA.h"
+	"experiences/bestPEA.h"
+
+1580140031 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\scripts.h
+	<vector>
+	"analysis.h"
+	"ParameterOptimizer.h"
+
+1580478192 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\scripts2.h
+	<vector>
+	<fstream>
+	"analysis.h"
+	"ParameterOptimizer.h"
+
+1580483200 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\bestpga.h
+	<vector>
+	"PGA.h"
+
+1580661589 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\bestpea.h
+	<vector>
+	"PEA.h"
+
+1580738542 source:c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\src\ea-complexity.cpp
+	"ea-complexity.h"
+
+1580683039 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\ea-complexity.h
+	<string>
+	<fstream>
+	<iostream>
+
+1580732036 source:c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\src\problem.cpp
+	"Problem.h"
+
+1580732128 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\problem.h
+
+1580756984 source:c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\src\experiences\ea-complexity.cpp
+	"experiences/ea-complexity.h"
+
+1580683039 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\experiences\ea-complexity.h
+	<string>
+	<fstream>
+	<iostream>
+
+1580756993 source:c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\src\heuristics\ea.cpp
+	"heuristics/EA.h"
+
+1579813024 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\heuristics\ea.h
+	<random>
+	"GA.h"
+
+1580764766 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\heuristics\ga.h
+	<random>
+	"GGA.h"
+
+1580657392 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\heuristics\gga.h
+	<iostream>
+	<vector>
+	<algorithm>
+	<random>
+	"SearchHeuristic.h"
+
+1580766378 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\heuristics\searchheuristic.h
+	<vector>
+	"problems/MasterMind.h"
+
+1579813071 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\problems\mastermind.h
+	<iostream>
+	<ctime>
+	<random>
+	<vector>
+	<algorithm>
+	"crossover.h"
+
+1579640108 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\problems\crossover.h
+
+1580757000 source:c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\src\heuristics\ga.cpp
+	"heuristics/GA.h"
+
+1580757007 source:c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\src\heuristics\gga.cpp
+	"heuristics/GGA.h"
+
+1580757068 source:c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\src\heuristics\rls.cpp
+	"heuristics/RLS.h"
+
+1578486688 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\heuristics\rls.h
+	<iostream>
+	"SearchHeuristic.h"
+
+1580757079 source:c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\src\heuristics\pga.cpp
+	"heuristics/PGA.h"
+
+1580766200 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\heuristics\pga.h
+	<vector>
+	<random>
+	"GGA.h"
+
+1580757087 source:c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\src\heuristics\searchheuristic.cpp
+	"heuristics/SearchHeuristic.h"
+
+1580757094 source:c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\src\problems\mastermind.cpp
+	"problems/MasterMind.h"
+
+1580757100 source:c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\src\problems\problem.cpp
+	"problems/Problem.h"
+
+1580732128 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\problems\problem.h
+
+1580766365 source:c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\src\analysis\analysis.cpp
+	"analysis/analysis.h"
+
+1580765568 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\analysis\analysis.h
+	<iostream>
+	<chrono>
+	<vector>
+	<algorithm>
+	<fstream>
+	"heuristics/SearchHeuristic.h"
+
+1580756965 source:c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\src\analysis\parameteroptimizer.cpp
+	"analysis/ParameterOptimizer.h"
+
+1580757039 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\analysis\parameteroptimizer.h
+	<iostream>
+	<vector>
+	<string>
+	<sstream>
+	<fstream>
+	"heuristics/SearchHeuristic.h"
+	"analysis/analysis.h"
+
+1580762470 source:c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\src\experiences\crossover-rate.cpp
+	"experiences/crossover-rate.h"
+
+1580763612 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\experiences\crossover-rate.h
+	<vector>
+	<fstream>
+	"analysis/ParameterOptimizer.h"
+	"heuristics/GA.h"
+
+1580757014 source:c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\src\heuristics\pea.cpp
+	"heuristics/PEA.h"
+
+1580757132 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\heuristics\pea.h
+	"heuristics/GGA.h"
+	"problems/crossover.h"
+
+1580808686 source:c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\src\experiences\complexity-ea.cpp
+	"experiences/complexity-ea.h"
+
+1580764630 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\experiences\complexity-ea.h
+	<string>
+	<fstream>
+	<sstream>
+	<iostream>
+	"problems/MasterMind.h"
+	"heuristics/EA.h"
+	"analysis/analysis.h"
+
+1580810401 source:c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\src\experiences\complexity-ga.cpp
+	"experiences/complexity-ga.h"
+
+1580807649 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\experiences\complexity-ga.h
+	<string>
+	<fstream>
+	<sstream>
+	"heuristics/GA.h"
+	"analysis/analysis.h"
+	"experiences/crossover-rate.h"
+
+1580762404 source:c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\src\experiences\complexity-rls.cpp
+	"experiences/complexity-rls.h"
+
+1580763156 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\experiences\complexity-rls.h
+	<sstream>
+	<string>
+	<fstream>
+	"heuristics/RLS.h"
+	"analysis/analysis.h"
+
+1580767662 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\experiences\scripts.h
+	<vector>
+	<fstream>
+	"analysis/analysis.h"
+	"analysis/ParameterOptimizer.h"
+
+1580766104 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\experiences\scripts2.h
+	<vector>
+	<fstream>
+	"analysis/analysis.h"
+	"analysis/ParameterOptimizer.h"
+
+1580766257 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\experiences\bestpga.h
+	<vector>
+	"heuristics/PGA.h"
+
+1580766257 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\experiences\bestpea.h
+	<vector>
+	"heuristics/PEA.h"
+
+1580765660 source:c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\src\experiences\compare-evolutions.cpp
+	"experiences/compare-evolutions.h"
+
+1580766115 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\experiences\compare-evolutions.h
+	<vector>
+	"heuristics/RLS.h"
+	"heuristics/EA.h"
+	"heuristics/GA.h"
+	"heuristics/PEA.h"
+	"analysis/analysis.h"
+	"experiences/crossover-rate.h"
+
+1580769908 source:c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\src\experiences\mutation-rate.cpp
+	"experiences/mutation-rate.h"
+
+1580767540 c:\users\tfeneuil\nextcloud\apprentissage\telecom paristech\mpri\heuristiques de recherche\mastermind\include\experiences\mutation-rate.h
+	<sstream>
+	<string>
+	"analysis/ParameterOptimizer.h"
+	"heuristics/EA.h"
+	"problems/MasterMind.h"
+

mm-cpp.layout

@@ -2,139 +2,164 @@
 <CodeBlocks_layout_file>
 	<FileVersion major="1" minor="0" />
 	<ActiveTarget name="Release" />
-	<File name="src\algo-complexity.cpp" open="1" top="0" tabpos="2" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
+	<File name="main.cpp" open="1" top="0" tabpos="1" split="0" active="1" splitpos="0" zoom_1="-1" zoom_2="0">
 		<Cursor>
-			<Cursor1 position="502" topLine="0" />
+			<Cursor1 position="896" topLine="31" />
 		</Cursor>
 	</File>
-	<File name="src\crossover-rate.cpp" open="0" top="0" tabpos="5" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
+	<File name="include\analysis\analysis.h" open="1" top="0" tabpos="19" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
 		<Cursor>
-			<Cursor1 position="619" topLine="0" />
+			<Cursor1 position="1884" topLine="31" />
 		</Cursor>
 	</File>
-	<File name="include\bestPGA.h" open="0" top="0" tabpos="9" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
+	<File name="src\problems\MasterMind.cpp" open="1" top="0" tabpos="24" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
 		<Cursor>
-			<Cursor1 position="2647" topLine="42" />
+			<Cursor1 position="88" topLine="0" />
 		</Cursor>
 	</File>
-	<File name="include\crossover.h" open="0" top="0" tabpos="3" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
+	<File name="include\experiences\bestPGA.h" open="1" top="0" tabpos="14" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
 		<Cursor>
-			<Cursor1 position="0" topLine="0" />
+			<Cursor1 position="2488" topLine="48" />
 		</Cursor>
 	</File>
-	<File name="include\algo-complexity.h" open="1" top="0" tabpos="1" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
+	<File name="src\experiences\complexity-ga.cpp" open="1" top="1" tabpos="3" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
 		<Cursor>
-			<Cursor1 position="359" topLine="0" />
+			<Cursor1 position="1175" topLine="21" />
 		</Cursor>
 	</File>
-	<File name="main.cpp" open="1" top="0" tabpos="4" split="0" active="1" splitpos="0" zoom_1="-1" zoom_2="0">
+	<File name="src\heuristics\PEA.cpp" open="0" top="0" tabpos="0" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
 		<Cursor>
-			<Cursor1 position="2282" topLine="53" />
+			<Cursor1 position="27" topLine="0" />
 		</Cursor>
 	</File>
-	<File name="src\RLS.cpp" open="0" top="0" tabpos="3" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
+	<File name="include\experiences\complexity-ga.h" open="1" top="0" tabpos="2" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
 		<Cursor>
-			<Cursor1 position="498" topLine="6" />
+			<Cursor1 position="701" topLine="0" />
 		</Cursor>
 	</File>
-	<File name="include\analysis.h" open="1" top="0" tabpos="5" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
+	<File name="src\experiences\complexity-rls.cpp" open="1" top="0" tabpos="4" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
 		<Cursor>
-			<Cursor1 position="541" topLine="12" />
+			<Cursor1 position="853" topLine="0" />
 		</Cursor>
 	</File>
-	<File name="include\crossover-rate.h" open="1" top="0" tabpos="6" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
+	<File name="src\heuristics\RLS.cpp" open="0" top="0" tabpos="0" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
 		<Cursor>
-			<Cursor1 position="799" topLine="10" />
+			<Cursor1 position="27" topLine="0" />
 		</Cursor>
 	</File>
-	<File name="include\scripts.h" open="0" top="0" tabpos="8" split="0" active="1" splitpos="0" zoom_1="1" zoom_2="0">
+	<File name="src\experiences\crossover-rate.cpp" open="1" top="0" tabpos="6" split="0" active="1" splitpos="0" zoom_1="-2" zoom_2="0">
 		<Cursor>
-			<Cursor1 position="1685" topLine="40" />
+			<Cursor1 position="2564" topLine="46" />
 		</Cursor>
 	</File>
-	<File name="include\scripts2.h" open="1" top="0" tabpos="3" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
+	<File name="src\experiences\mutation-rate.cpp" open="1" top="0" tabpos="23" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
 		<Cursor>
-			<Cursor1 position="157" topLine="6" />
+			<Cursor1 position="712" topLine="12" />
 		</Cursor>
 	</File>
-	<File name="src\EA.cpp" open="0" top="0" tabpos="12" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
+	<File name="src\heuristics\PGA.cpp" open="0" top="0" tabpos="0" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
 		<Cursor>
-			<Cursor1 position="19" topLine="0" />
+			<Cursor1 position="27" topLine="0" />
 		</Cursor>
 	</File>
-	<File name="src\GA.cpp" open="0" top="0" tabpos="10" split="0" active="1" splitpos="0" zoom_1="-1" zoom_2="0">
+	<File name="include\experiences\bestPEA.h" open="1" top="0" tabpos="11" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
 		<Cursor>
-			<Cursor1 position="65" topLine="0" />
+			<Cursor1 position="1943" topLine="34" />
 		</Cursor>
 	</File>
-	<File name="src\MasterMind.cpp" open="0" top="0" tabpos="5" split="0" active="1" splitpos="0" zoom_1="-2" zoom_2="0">
+	<File name="src\heuristics\SearchHeuristic.cpp" open="0" top="0" tabpos="0" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
 		<Cursor>
-			<Cursor1 position="3234" topLine="78" />
+			<Cursor1 position="39" topLine="0" />
 		</Cursor>
 	</File>
-	<File name="src\analysis.cpp" open="0" top="0" tabpos="6" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
+	<File name="src\heuristics\EA.cpp" open="0" top="0" tabpos="0" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
 		<Cursor>
-			<Cursor1 position="1477" topLine="159" />
+			<Cursor1 position="26" topLine="0" />
 		</Cursor>
 	</File>
-	<File name="include\EA.h" open="0" top="0" tabpos="13" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
+	<File name="src\heuristics\GA.cpp" open="0" top="0" tabpos="0" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
 		<Cursor>
-			<Cursor1 position="261" topLine="0" />
+			<Cursor1 position="26" topLine="0" />
 		</Cursor>
 	</File>
-	<File name="include\GGA.h" open="1" top="1" tabpos="9" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
+	<File name="src\heuristics\GGA.cpp" open="1" top="0" tabpos="21" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
 		<Cursor>
-			<Cursor1 position="828" topLine="29" />
+			<Cursor1 position="1317" topLine="44" />
 		</Cursor>
 	</File>
-	<File name="include\MasterMind.h" open="0" top="0" tabpos="7" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
+	<File name="include\experiences\crossover-rate.h" open="1" top="0" tabpos="9" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
 		<Cursor>
-			<Cursor1 position="831" topLine="24" />
+			<Cursor1 position="1004" topLine="16" />
 		</Cursor>
 	</File>
-	<File name="src\SearchHeuristic.cpp" open="0" top="0" tabpos="6" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
+	<File name="include\heuristics\PGA.h" open="1" top="0" tabpos="13" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
 		<Cursor>
-			<Cursor1 position="373" topLine="10" />
+			<Cursor1 position="602" topLine="3" />
 		</Cursor>
 	</File>
-	<File name="include\RLS.h" open="0" top="0" tabpos="2" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
+	<File name="include\analysis\ParameterOptimizer.h" open="0" top="0" tabpos="0" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
 		<Cursor>
-			<Cursor1 position="85" topLine="0" />
+			<Cursor1 position="234" topLine="0" />
 		</Cursor>
 	</File>
-	<File name="include\SearchHeuristic.h" open="0" top="0" tabpos="9" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
+	<File name="include\heuristics\GA.h" open="1" top="0" tabpos="12" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
 		<Cursor>
-			<Cursor1 position="1352" topLine="51" />
+			<Cursor1 position="412" topLine="1" />
 		</Cursor>
 	</File>
-	<File name="src\PGA.cpp" open="0" top="0" tabpos="7" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
+	<File name="include\experiences\complexity-ea.h" open="1" top="0" tabpos="8" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
 		<Cursor>
-			<Cursor1 position="384" topLine="0" />
+			<Cursor1 position="767" topLine="0" />
 		</Cursor>
 	</File>
-	<File name="include\GA.h" open="0" top="0" tabpos="11" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
+	<File name="include\experiences\complexity-rls.h" open="1" top="0" tabpos="7" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
 		<Cursor>
-			<Cursor1 position="407" topLine="0" />
+			<Cursor1 position="19" topLine="0" />
 		</Cursor>
 	</File>
-	<File name="include\PGA.h" open="0" top="0" tabpos="8" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
+	<File name="include\heuristics\PEA.h" open="0" top="0" tabpos="0" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
 		<Cursor>
 			<Cursor1 position="477" topLine="0" />
 		</Cursor>
 	</File>
-	<File name="include\ParameterOptimizer.h" open="0" top="0" tabpos="16" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
+	<File name="include\experiences\mutation-rate.h" open="1" top="0" tabpos="22" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
+		<Cursor>
+			<Cursor1 position="1140" topLine="14" />
+		</Cursor>
+	</File>
+	<File name="include\experiences\compare-evolutions.h" open="1" top="0" tabpos="15" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
+		<Cursor>
+			<Cursor1 position="290" topLine="0" />
+		</Cursor>
+	</File>
+	<File name="src\analysis\analysis.cpp" open="1" top="0" tabpos="18" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
+		<Cursor>
+			<Cursor1 position="4712" topLine="116" />
+		</Cursor>
+	</File>
+	<File name="include\experiences\scripts.h" open="1" top="0" tabpos="10" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
+		<Cursor>
+			<Cursor1 position="1724" topLine="32" />
+		</Cursor>
+	</File>
+	<File name="src\experiences\compare-evolutions.cpp" open="1" top="0" tabpos="16" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
+		<Cursor>
+			<Cursor1 position="550" topLine="2" />
+		</Cursor>
+	</File>
+	<File name="include\heuristics\SearchHeuristic.h" open="1" top="0" tabpos="20" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
 		<Cursor>
-			<Cursor1 position="141" topLine="0" />
+			<Cursor1 position="576" topLine="23" />
 		</Cursor>
 	</File>
-	<File name="src\GGA.cpp" open="1" top="0" tabpos="8" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
+	<File name="src\analysis\ParameterOptimizer.cpp" open="1" top="0" tabpos="17" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
 		<Cursor>
-			<Cursor1 position="939" topLine="33" />
+			<Cursor1 position="1444" topLine="41" />
 		</Cursor>
 	</File>
-	<File name="src\ParameterOptimizer.cpp" open="1" top="0" tabpos="7" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
+	<File name="src\experiences\complexity-ea.cpp" open="1" top="0" tabpos="5" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
 		<Cursor>
-			<Cursor1 position="248" topLine="0" />
+			<Cursor1 position="5267" topLine="145" />
 		</Cursor>
 	</File>
 </CodeBlocks_layout_file>

modeling.csv

@@ -0,0 +1,27 @@
+3;0.846933;18.0273
+4;1.86656;44.2355
+5;2.51544;84.9568
+6;2.52333;145.172
+7;2.23277;226.23
+8;1.88081;325.821
+9;1.15731;450.761
+10;0.295508;598.832
+11;0.4783;745.999
+12;-0.154983;930.085
+13;0.273917;1128.69
+14;0.704417;1330.4
+15;1.13992;1567.65
+16;1.182;1824.72
+17;1.64275;2153.95
+18;3.67625;2408.38
+19;4.0185;2703.91
+20;4.93592;3068.72
+21;5.22317;3450.11
+22;7.811;3831.13
+23;10.2672;4250.95
+24;12.8785;4636.37
+25;14.0149;5125.41
+26;17.4755;5603.19
+27;20.0083;6166.14
+28;24.013;6627.1
+29;28.7638;7216.38

src/EA.cpp

@@ -1,2 +0,0 @@
-#include "EA.h"
-

src/GA.cpp

@@ -1,5 +0,0 @@
-#include "GA.h"
-
-double GA::get_crossover_proba(double progress) {
-    return m_crossover_proba;
-}

src/algo-complexity.cpp

@@ -1,20 +0,0 @@
-#include "algo-complexity.h"
-
-std::vector<Statistic> compute_complexity(std::default_random_engine& randomizer, SearchHeuristic* algo, int n_initial, int n_final, int n_step, int nb_tests, double slq, bool displaying) {
-    std::vector<Statistic> stats;
-    for(int n=n_initial; n<n_final; n+=n_step) {
-        MasterMind mm(n, n, randomizer);
-        algo->set_problem(&mm);
-        Statistic stat = avg_calls(algo, nb_tests, -1, slq);
-        stat.label = n;
-        stats.push_back(stat);
-
-        std::cout << n << ": " << stat.average << " +- " << stat.alea << std::endl;
-    }
-}
-
-void save_in_file(std::string namefile, std::vector<Statistic> stats) {
-    std::ofstream outfile(namefile);
-    for(int i=0, s=stats.size(); i<s; i++)
-        outfile << (int) stats[i].label << ";" << stats[i].average << ";" << stats[i].alea << std::endl;
-}

src/ParameterOptimizer.cpp → src/analysis/ParameterOptimizer.cpp

@@ -1,4 +1,4 @@
-#include "ParameterOptimizer.h"
+#include "analysis/ParameterOptimizer.h"
 
 ParameterOptimizer::ParameterOptimizer(std::default_random_engine& randomizer) : m_randomizer{randomizer}, m_saving_in_csvfile{false} {
     // ctor

src/analysis.cpp → src/analysis/analysis.cpp

@@ -1,4 +1,4 @@
-#include "analysis.h"
+#include "analysis/analysis.h"
 
 std::chrono::time_point<std::chrono::system_clock> start_chrono() {
     return std::chrono::system_clock::now();
@@ -10,28 +10,11 @@ int interval_chrono(std::chrono::time_point<std::chrono::system_clock> start, st
     return std::chrono::duration_cast<std::chrono::milliseconds>(stop-start).count();
 }
 
-double student_law_quartiles[21] = {
-    0.,
-    12.7062047362,
-    4.3026527297,
-    3.1824463053,
-    2.7764451052,
-    2.5705818356,
-    2.4469118511,
-    2.3646242516,
-    2.3060041352,
-    2.2621571628,
-    2.228138852,
-    2.2009851601,
-    2.1788128297,
-    2.1603686565,
-    2.1447866879,
-    2.1314495456,
-    2.1199052992,
-    2.1098155778,
-    2.1009220402,
-    2.0930240544,
-    2.0859634473
+double student_law_quartiles[21] = { 0.,
+    12.7062047362, 4.3026527297, 3.1824463053, 2.7764451052, 2.5705818356,
+    2.4469118511, 2.3646242516, 2.3060041352, 2.2621571628, 2.228138852,
+    2.2009851601, 2.1788128297, 2.1603686565, 2.1447866879, 2.1314495456,
+    2.1199052992, 2.1098155778, 2.1009220402, 2.0930240544, 2.0859634473
 };
 
 Statistic avg_calls(SearchHeuristic* algo, int nb, double abortion_limit, double student_law_quartile) {
@@ -118,7 +101,7 @@ Statistic* avg_evolution(SearchHeuristic* algo, int max_evolution, int nb_tests)
 
 Statistic* derivate(Statistic* curve, unsigned int length) {
     Statistic* dcurve = new Statistic[length-1];
-    for(int i=0; i<length-1; i++) {
+    for(unsigned int i=0; i<length-1; i++) {
         Statistic p1 = curve[i];
         Statistic p2 = curve[i+1];
 
@@ -137,7 +120,7 @@ Statistic* derivate(Statistic* curve, unsigned int length) {
 
 Statistic* compress(Statistic* curve, unsigned int length) {
     Statistic* ccurve = new Statistic[(int) ceil(length/2.)-1];
-    for(int i=0; 2*i+2<length; i++) {
+    for(unsigned int i=0; 2*i+2<length; i++) {
         Statistic p1 = curve[2*i];
         Statistic p2 = curve[2*i+1];
         Statistic p3 = curve[2*i+2];
@@ -157,7 +140,7 @@ Statistic* compress(Statistic* curve, unsigned int length) {
 
 Statistic* smooth(Statistic* curve, unsigned int length) {
     Statistic* scurve = new Statistic[length];
-    for(int i=1; i<length-1; i++) {
+    for(unsigned int i=1; i<length-1; i++) {
         Statistic p1 = curve[i-1];
         Statistic p2 = curve[i];
         Statistic p3 = curve[i+1];
@@ -175,3 +158,43 @@ Statistic* smooth(Statistic* curve, unsigned int length) {
     return scurve;
 }
 
+std::vector<Statistic> compute_complexity(std::default_random_engine& randomizer, SearchHeuristic* algo, int n_initial, int n_final, int n_step, int nb_tests, double slq, bool displaying) {
+    std::vector<Statistic> stats;
+    for(int n=n_initial; n<n_final; n+=n_step) {
+        MasterMind mm(n, n, randomizer);
+        algo->set_problem(&mm);
+        Statistic stat = avg_calls(algo, nb_tests, -1, slq);
+        stat.label = n;
+        stats.push_back(stat);
+
+        if(displaying)
+            std::cout << n << ": " << stat.average << " +- " << stat.alea << std::endl;
+    }
+    return stats;
+}
+
+void save_in_file(std::string namefile, std::vector<Statistic> stats) {
+    std::ofstream outfile(namefile);
+    for(int i=0, s=stats.size(); i<s; i++)
+        outfile << (int) stats[i].label << ";" << stats[i].average-stats[i].alea << ";" << stats[i].average+stats[i].alea << std::endl;
+}
+
+void cmp_evolution(std::vector<SearchHeuristic*> algos, MasterMind& problem, std::string outfilename, int max_evolution, int nb_tests) {
+    int nb_algos = algos.size();
+    Statistic** values = new Statistic*[nb_algos];
+    for(int i=0; i<nb_algos; i++) {
+        algos[i]->set_problem(&problem);
+        values[i] = avg_evolution(algos[i], max_evolution, nb_tests);
+    }
+    std::ofstream statsfile(outfilename);
+    for(int i=0; i<max_evolution; i++) {
+        statsfile << i << ";";
+        for(int k=0; k<nb_algos; k++)
+            statsfile << values[k][i].average << ";";
+        statsfile << std::endl;
+    }
+
+    for(int i=0; i<nb_algos; i++)
+        delete[] values[i];
+    delete[] values;
+}

src/experiences/compare-evolutions.cpp

@@ -0,0 +1,21 @@
+#include "experiences/compare-evolutions.h"
+
+void script_cmp_evolution_algos(std::default_random_engine& randomizer) {
+    int n=20;
+    MasterMind mm(n, n, randomizer);
+    RLS algo1;
+    EA algo2(1, 1, PLUS, 1./n, randomizer);
+    GA algo3(1, 1, PLUS, 1./n, cr(n, 1), UNIFORM_CROSSOVER, GA_V1, randomizer);
+    GA algo4(1, 1, PLUS, 1./n, .8, UNIFORM_CROSSOVER, GA_V1, randomizer);
+    PEA algo5(1, 1, PLUS, {}, randomizer);
+    algo1.set_problem(&mm);
+    algo2.set_problem(&mm);
+    algo3.set_problem(&mm);
+    algo4.set_problem(&mm);
+    algo5.set_problem(&mm);
+    std::vector<SearchHeuristic*> algos = {&algo1, &algo2, &algo3, &algo4, &algo5};
+
+    Statistic stat = avg_calls(&algo1, 20, -1, 3.883);
+    int max_nb_calls = ceil(stat.average+stat.alea)*2;
+    cmp_evolution(algos, mm, "evolutions.csv", max_nb_calls, 100);
+}

src/experiences/complexity-ea.cpp

@@ -0,0 +1,250 @@
+#include "experiences/complexity-ea.h"
+
+void study_complexity_of_ea(std::default_random_engine& randomizer, int option, int argc, char** argv) {
+    switch(option) {
+    case 0:
+        {
+            int n_initial = (argc>=4) ? atoi(argv[3]) : 3;
+            std::stringstream ss;
+            ss << "complexity-ea-n-" << n_initial << ".csv";
+            study_complexity_of_ea_sample(randomizer, ss.str(), n_initial, 200, 10, true);
+            break;
+        }
+    case 1:
+        {
+            study_complexity_of_ea_filter(argv[3], argv[4], atoi(argv[5]), atoi(argv[6]), atoi(argv[7]));
+            break;
+        }
+    case 2:
+        {
+            study_complexity_of_ea_treat(randomizer, "complexity-ea.csv", 5, 30);
+            break;
+        }
+    }
+}
+
+void study_complexity_of_ea_sample(std::default_random_engine& randomizer, std::string filename, int n_initial, int n_final, int n_step, bool displaying) {
+    std::ofstream outfile(filename);
+    for(int n=n_initial; n<n_final; n+=n_step) {
+        MasterMind mm(n, n, randomizer);
+        for(int mu=1; mu<50; mu+=2) {
+            if(displaying) std::cout << " n=" << n << ": mu=" << mu << std::endl;
+            for(int lambda=1; lambda<50; lambda+=2) {
+                EA algo(mu, lambda, PLUS, 1./n, randomizer);
+                algo.set_problem(&mm);
+                Statistic stat = avg_calls(&algo, 1000, -1, 1.9623414611);
+                outfile << n << ";" << mu << ";" << lambda << ";" << stat.average << ";" << stat.alea << std::endl;
+            }
+        }
+    }
+}
+
+void study_complexity_of_ea_filter(std::string input, std::string output, int filtered_n, int filtered_mu, int filtered_lda) {
+    std::ifstream infile(input);
+    std::ofstream outfile(output);
+
+    std::string line;
+    while(getline(infile, line)) {
+        int n, mu, lda;
+        double avg, alea;
+        sscanf(line.c_str(), "%d;%d;%d;%lf;%lf", &n, &mu, &lda, &avg, &alea);
+
+        if((filtered_n==0 || n==filtered_n) && (filtered_mu==0 || mu==filtered_mu) && (filtered_lda==0 || lda==filtered_lda)) {
+            outfile << line << std::endl;
+        }
+    }
+
+    std::cout << "Filtering finished !" << std::endl;
+}
+
+struct Data {
+    Data() : r{0}, s{0}, t{0}, u{0}, nb_goods{0} {};
+
+    double r;
+    double s;
+    double t;
+    double u;
+
+    double a;
+    double b;
+    double c;
+    double d;
+
+    double alpha;
+    double beta;
+    double gamma;
+    double lambda;
+
+    int nb_goods;
+};
+struct StoredData {
+    StoredData(int n0, int mu0, int lda0, double avg0, double alea0) :
+        n{n0}, mu{mu0}, lda{lda0}, avg{avg0}, alea{alea0} {};
+    int n, mu, lda;
+    double avg, alea;
+};
+
+void study_complexity_of_ea_treat(std::default_random_engine& randomizer, std::string filename, int n_initial, int n_final) {
+    Data datas[n_final];
+    std::vector<StoredData> sdatas;
+
+    // Load datas
+    std::ifstream infile(filename);
+    std::string line;
+    while(getline(infile, line)) {
+        int n, mu, lda;
+        double avg, alea;
+        sscanf(line.c_str(), "%d;%d;%d;%lf;%lf", &n, &mu, &lda, &avg, &alea);
+        sdatas.push_back(StoredData(n, mu, lda, avg, alea));
+
+        if(3 <= mu && mu <= 7) {
+            if(3 <= lda && lda <= 7)
+                datas[n].r += avg;
+            else if(43 <= lda && lda <= 47)
+                datas[n].s += avg;
+        } else if(43 <= mu && mu <= 47) {
+            if(3 <= lda && lda <= 7)
+                datas[n].t += avg;
+            else if(43 <= lda && lda <= 47)
+                datas[n].u += avg;
+        }
+    }
+
+    // Make simplified regression
+    for(int n=n_initial; n<n_final; n++) {
+        datas[n].r /= 9.;
+        datas[n].s /= 9.;
+        datas[n].t /= 9.;
+        datas[n].u /= 9.;
+
+        Data dat = datas[n];
+        datas[n].a = (dat.s - dat.r) / (45. - 5.);
+        datas[n].b = dat.s - 45.*datas[n].a;
+        datas[n].c = (dat.u - dat.t) / (45. - 5.);
+        datas[n].d = dat.u - 45.*datas[n].c;
+    }
+
+    // Make models for n fixed
+    for(int n=n_initial; n<n_final; n++) {
+        Data dat = datas[n];
+        datas[n].alpha = (dat.c - dat.a) / (45. - 5.);
+        datas[n].gamma = dat.a - 5*datas[n].alpha;
+        datas[n].beta = (dat.d - dat.b) / (45. - 5.);
+        datas[n].lambda = dat.b - 5*datas[n].beta;
+    }
+    for(int i=0, s=sdatas.size(); i<s; i++) {
+        StoredData sd = sdatas[i];
+        Data d = datas[sd.n];
+        double prev = d.alpha*sd.mu*sd.lda + d.beta*sd.mu + d.gamma*sd.lda + d.lambda;
+
+        if(abs(sd.avg-prev) <= sd.alea)
+            datas[sd.n].nb_goods++;
+    }
+
+    std::ofstream outfile("filtered.csv");
+    for(int i=0, s=sdatas.size(); i<s; i++) {
+        StoredData sd = sdatas[i];
+        Data d = datas[sd.n];
+        double prev = d.alpha*sd.mu*sd.lda + d.beta*sd.mu + d.gamma*sd.lda + d.lambda;
+
+        if(sd.n==5 && sd.mu==25)
+            outfile << sd.n << ";" << sd.mu << ";" << sd.lda << ";" << sd.avg - sd.alea << ";" << sd.avg + sd.alea << ";" << prev << ";" << (int) (abs(sd.avg-prev) <= sd.alea) << std::endl;
+    }
+
+    std::ofstream out2file("modeling.csv");
+    for(int n=5; n<30; n++) {
+        Data d = datas[n];
+        std::cout << n << ": " << d.alpha << "*mu*lda + " << d.beta << "*mu + " << d.gamma << "*lda + " << d.lambda << " => " << 100*d.nb_goods/(625.) << "%" << std::endl;
+        out2file << n << ";" << d.alpha << ";" << d.beta << ";" << d.gamma << ";" << d.lambda << std::endl;
+    }
+
+    std::vector<double> coeffs({
+        0.0045748,
+        -0.0325175,
+        1.4444,
+        -3.83779,
+        1.03815,
+        -2.99155,
+        2.52103,
+        -6.58785,
+        16.965
+    });
+
+    bool ignoreSmall = true;
+
+    int global_nb_goods = 0;
+    for(int i=0, s=sdatas.size(); i<s; i++) {
+        StoredData sd = sdatas[i];
+        int n = sd.n;
+
+        if(n<9 && ignoreSmall) continue;
+
+        double alpha_n =(coeffs[0]*n + coeffs[1])*log(n);
+        double beta_n = (coeffs[2]*n+coeffs[3])*log(n);
+        double gamma_n = coeffs[4]*n + coeffs[5];
+        double lambda_n = (coeffs[6]*pow(n, 2) + coeffs[7]*n + coeffs[8])*log(n);
+
+        double prev = alpha_n*sd.mu*sd.lda + beta_n*sd.mu + gamma_n*sd.lda + lambda_n;
+
+        if(abs(sd.avg-prev) <= sd.alea)
+            global_nb_goods++;
+//        else
+//            cout << " - " << n << ", " << sd.mu << ", " << sd.lda << ": " << prev << " not in " << sd.avg << " +- " << sd.alea << " (" << (int) (sd.avg < prev) << ")" << endl;
+    }
+    std::cout << "GLOBAL: " << 100*global_nb_goods/(625.*(25.-4.*ignoreSmall)) << "%" << std::endl;
+
+    std::binomial_distribution<int> mutation = std::binomial_distribution<int>(8, 3./8);
+    std::vector<int> permutation(9);
+    iota(permutation.begin(), permutation.end(), 0);
+    std::bernoulli_distribution direction(1./2);
+
+    std::ofstream savefile("coeffs.csv", std::ios::app);
+
+    for(int depth=-5; depth<12; depth++) {
+        std::cout << std::endl << " !!! DEPTH = " << depth;
+        for(int stag=0; stag<10000; stag++) {
+            int r = 1+mutation(randomizer);
+            std::vector<double> coeffs2(coeffs);
+
+            std::shuffle(std::begin(permutation), std::end(permutation), randomizer);
+            //cout << "[" << permutation[0] << "," << permutation[1] << "]";
+            for(int i=0; i<r; i++)
+                coeffs2[permutation[i]] *= 1 + pow(-1, (int) direction(randomizer))*(0.2/pow(2, abs(depth)));
+
+            // Evaluate
+            int nb_goods = 0;
+            for(int i=0, s=sdatas.size(); i<s; i++) {
+                StoredData sd = sdatas[i];
+                int n = sd.n;
+
+                if(n<9 && ignoreSmall) continue;
+
+                double alpha_n = (coeffs2[0]*n + coeffs2[1])*log(n);
+                double beta_n = (coeffs2[2]*n+coeffs2[3])*log(n);
+                double gamma_n = coeffs2[4]*n + coeffs2[5];
+                double lambda_n = (coeffs2[6]*pow(n, 2) + coeffs2[7]*n + coeffs2[8])*log(n);
+
+                double prev = alpha_n*sd.mu*sd.lda + beta_n*sd.mu + gamma_n*sd.lda + lambda_n;
+
+                if(abs(sd.avg-prev) <= sd.alea)
+                    nb_goods++;
+            }
+
+            // Selection
+            if(nb_goods >= global_nb_goods) {
+                coeffs = coeffs2;
+                if(nb_goods > global_nb_goods) {
+                    stag = 0;
+                    double pourcent = 100*nb_goods/(625.*(25.-4.*ignoreSmall));
+                    std::cout << std::endl << "Improvement: " << pourcent << " ";
+                    // Saving
+                    savefile << pourcent << ";";
+                    for(int i=0, s=coeffs.size(); i<s; i++)
+                        savefile << coeffs[i] << ";";
+                    savefile << std::endl;
+                }
+                global_nb_goods = nb_goods;
+            }
+        }
+    }
+}

src/experiences/complexity-ga.cpp

@@ -0,0 +1,217 @@
+#include "experiences/complexity-ga.h"
+
+void study_complexity_of_ga(std::default_random_engine& randomizer, int option, int argc, char** argv) {
+    switch(option) {
+    case 0:
+        {
+            int n_initial = (argc>=4) ? atoi(argv[3]) : 10;
+            std::stringstream ss;
+            ss << "complexity-ga-n-" << n_initial << ".csv";
+            study_complexity_of_ga_sample(randomizer, ss.str(), n_initial, 200, 10, true);
+            break;
+        }
+    case 1:
+        {
+            int n_initial = (argc>=4) ? atoi(argv[3]) : 3;
+            std::stringstream ss;
+            ss << "complexity-ga-n-" << n_initial << ".csv";
+            study_complexity_of_ga_global_sample(randomizer, ss.str(), n_initial, 30, 1, true);
+            break;
+        }
+    case 2:
+        {
+            study_complexity_of_ga_treat(randomizer, argv[3], atoi(argv[4]), atoi(argv[5]));
+            break;
+        }
+    }
+}
+
+void study_complexity_of_ga_sample(std::default_random_engine& randomizer, std::string filename, int n_initial, int n_final, int n_step, bool displaying) {
+    std::ofstream outfile(filename);
+    for(int n=n_initial; n<=n_final; n+=n_step) {
+        if(displaying) std::cout << " - n=" << n << std::endl;
+        MasterMind mm(n, n, randomizer);
+        GA algo(1, 1, PLUS, 1./n, cr(n, 1), UNIFORM_CROSSOVER, GA_V1, randomizer);
+        algo.set_problem(&mm);
+        Statistic stat = avg_calls(&algo, 100, -1, 1.9842169516);
+        outfile << n << ";" << stat.average-stat.alea << ";" << stat.average+stat.alea << std::endl;
+    }
+}
+
+void study_complexity_of_ga_global_sample(std::default_random_engine& randomizer, std::string filename, int n_initial, int n_final, int n_step, bool displaying) {
+    std::ofstream outfile(filename);
+    for(int n=n_initial; n<n_final; n+=n_step) {
+        MasterMind mm(n, n, randomizer);
+        for(int lambda=1; lambda<50; lambda++) {
+            if(displaying) std::cout << " - n=" << n << ", lambda=" << lambda << std::endl;
+            GA algo(lambda, lambda, PLUS, 1./n, cr(n, lambda), UNIFORM_CROSSOVER, GA_V1, randomizer);
+            algo.set_problem(&mm);
+            Statistic stat = avg_calls(&algo, 1000, -1, 1.9623414611);
+            outfile << n << ";" << lambda << ";" << stat.average << ";" << stat.alea << std::endl;
+        }
+    }
+}
+
+struct Data {
+    Data() : r{0}, s{0}, nb_goods{0} {};
+
+    double r;
+    double s;
+
+    double a;
+    double b;
+
+    int nb_goods;
+};
+struct Stored2Data {
+    Stored2Data(int n0, int lda0, double avg0, double alea0) :
+        n{n0}, lda{lda0}, avg{avg0}, alea{alea0} {};
+    int n, lda;
+    double avg, alea;
+};
+
+void study_complexity_of_ga_treat(std::default_random_engine& randomizer, std::string filename, int n_initial, int n_final) {
+    Data datas[n_final];
+    std::vector<Stored2Data> sdatas;
+
+    // Load datas
+    std::ifstream infile(filename);
+    std::string line;
+    while(getline(infile, line)) {
+        int n, lda;
+        double avg, alea;
+        sscanf(line.c_str(), "%d;%d;%lf;%lf", &n, &lda, &avg, &alea);
+        sdatas.push_back(Stored2Data(n, lda, avg, alea));
+
+        if(4 <= lda && lda <= 6)
+            datas[n].r += avg;
+        else if(44 <= lda && lda <= 46)
+            datas[n].s += avg;
+    }
+
+    // Make simplified regression
+    for(int n=n_initial; n<n_final; n++) {
+        datas[n].r /= 3.;
+        datas[n].s /= 3.;
+
+        Data dat = datas[n];
+        datas[n].a = (dat.s - dat.r) / (45. - 5.);
+        datas[n].b = dat.s - 45.*datas[n].a;
+    }
+    for(int i=0, s=sdatas.size(); i<s; i++) {
+        Stored2Data sd = sdatas[i];
+        Data d = datas[sd.n];
+        double prev = d.a*sd.lda + d.b;
+
+        if(abs(sd.avg-prev) <= sd.alea)
+            datas[sd.n].nb_goods++;
+    }
+
+    std::ofstream outfile("filtered.csv");
+    for(int i=0, s=sdatas.size(); i<s; i++) {
+        Stored2Data sd = sdatas[i];
+        Data d = datas[sd.n];
+        double prev = d.a*sd.lda + d.b;
+
+        if(sd.n==21)
+            outfile << sd.n << ";" << sd.lda << ";" << sd.avg - sd.alea << ";" << sd.avg + sd.alea << ";" << prev << std::endl;
+    }
+
+    std::ofstream out2file("modeling.csv");
+    for(int n=n_initial; n<n_final; n++) {
+        Data d = datas[n];
+        std::cout << n << ": " << d.a << "*lda + " << d.b << " => " << 100*d.nb_goods/(50.) << "%" << std::endl;
+        out2file << n << ";" << d.a << ";" << d.b << std::endl;
+    }
+    return;
+
+    std::vector<double> coeffs({
+        0.0045748,
+        -0.0325175,
+        1.4444,
+        -3.83779,
+        1.03815,
+        -2.99155,
+        2.52103,
+        -6.58785,
+        16.965
+    });
+
+    bool ignoreSmall = true;
+
+    int global_nb_goods = 0;
+    for(int i=0, s=sdatas.size(); i<s; i++) {
+        Stored2Data sd = sdatas[i];
+        int n = sd.n;
+
+        if(n<9 && ignoreSmall) continue;
+
+        double alpha_n =(coeffs[0]*n + coeffs[1])*log(n);
+        double beta_n = (coeffs[2]*n+coeffs[3])*log(n);
+        double gamma_n = coeffs[4]*n + coeffs[5];
+        double lambda_n = (coeffs[6]*pow(n, 2) + coeffs[7]*n + coeffs[8])*log(n);
+
+        double prev = alpha_n*sd.lda + lambda_n;
+
+        if(abs(sd.avg-prev) <= sd.alea)
+            global_nb_goods++;
+//        else
+//            cout << " - " << n << ", " << sd.mu << ", " << sd.lda << ": " << prev << " not in " << sd.avg << " +- " << sd.alea << " (" << (int) (sd.avg < prev) << ")" << endl;
+    }
+    std::cout << "GLOBAL: " << 100*global_nb_goods/(625.*(25.-4.*ignoreSmall)) << "%" << std::endl;
+
+    std::binomial_distribution<int> mutation = std::binomial_distribution<int>(8, 3./8);
+    std::vector<int> permutation(9);
+    iota(permutation.begin(), permutation.end(), 0);
+    std::bernoulli_distribution direction(1./2);
+
+    std::ofstream savefile("coeffs.csv", std::ios::app);
+
+    for(int depth=-5; depth<12; depth++) {
+        std::cout << std::endl << " !!! DEPTH = " << depth;
+        for(int stag=0; stag<10000; stag++) {
+            int r = 1+mutation(randomizer);
+            std::vector<double> coeffs2(coeffs);
+
+            std::shuffle(std::begin(permutation), std::end(permutation), randomizer);
+            //cout << "[" << permutation[0] << "," << permutation[1] << "]";
+            for(int i=0; i<r; i++)
+                coeffs2[permutation[i]] *= 1 + pow(-1, (int) direction(randomizer))*(0.2/pow(2, abs(depth)));
+
+            // Evaluate
+            int nb_goods = 0;
+            for(int i=0, s=sdatas.size(); i<s; i++) {
+                Stored2Data sd = sdatas[i];
+                int n = sd.n;
+
+                if(n<9 && ignoreSmall) continue;
+
+                double alpha_n = (coeffs2[0]*n + coeffs2[1])*log(n);
+                double beta_n = (coeffs2[2]*n+coeffs2[3])*log(n);
+                double gamma_n = coeffs2[4]*n + coeffs2[5];
+                double lambda_n = (coeffs2[6]*pow(n, 2) + coeffs2[7]*n + coeffs2[8])*log(n);
+
+                double prev = gamma_n*sd.lda + lambda_n;
+
+                if(abs(sd.avg-prev) <= sd.alea)
+                    nb_goods++;
+            }
+
+            // Selection
+            if(nb_goods >= global_nb_goods) {
+                coeffs = coeffs2;
+                if(nb_goods > global_nb_goods) {
+                    stag = 0;
+                    double pourcent = 100*nb_goods/(625.*(25.-4.*ignoreSmall));
+                    std::cout << std::endl << "Improvement: " << pourcent << " ";
+                    // Saving
+                    savefile << pourcent << ";";
+                    for(int i=0, s=coeffs.size(); i<s; i++)
+                        savefile << coeffs[i] << ";";
+                    savefile << std::endl;
+                }
+                global_nb_goods = nb_goods;
+            }
+        }
+    }
+}

src/experiences/complexity-rls.cpp

@@ -0,0 +1,24 @@
+#include "experiences/complexity-rls.h"
+
+void study_complexity_of_rls(std::default_random_engine& randomizer, int option, int argc, char** argv) {
+    switch(option) {
+    case 0:
+        int n_initial = (argc>=4) ? atoi(argv[3]) : 10;
+        std::stringstream ss;
+        ss << "complexity-rls-n-" << n_initial << ".csv";
+        study_complexity_of_rls_sample(randomizer, ss.str(), n_initial, 500, 10, true);
+        break;
+    }
+}
+
+void study_complexity_of_rls_sample(std::default_random_engine& randomizer, std::string filename, int n_initial, int n_final, int n_step, bool displaying) {
+    std::ofstream outfile(filename);
+    for(int n=n_initial; n<=n_final; n+=n_step) {
+        if(displaying) std::cout << " - n=" << n << std::endl;
+        MasterMind mm(n, n, randomizer);
+        RLS algo;
+        algo.set_problem(&mm);
+        Statistic stat = avg_calls(&algo, 100, -1, 1.9842169516);
+        outfile << n << ";" << stat.average-stat.alea << ";" << stat.average+stat.alea << std::endl;
+    }
+}

src/crossover-rate.cpp → src/experiences/crossover-rate.cpp

@@ -1,4 +1,4 @@
-#include "crossover-rate.h"
+#include "experiences/crossover-rate.h"
 
 SearchHeuristic* CrossoverProbaFromLambdaOptimizer::get_context(unsigned int i, double parameter, std::default_random_engine& randomizer) {
     //GA* algo = new GA(lambda_initial+i, lambda_initial+i, PLUS, 1./n, parameter, UNIFORM_CROSSOVER, GA_V1, randomizer);
@@ -16,6 +16,29 @@ std::string CrossoverProbaFromLambdaOptimizer::get_context_for_csvfile(unsigned
    return std::to_string(lambda_initial+num_context);
 }
 
+void crossover_model(std::default_random_engine& randomizer, int option, int argc, char** argv) {
+    switch(atoi(argv[2])) {
+        case 0: // Start from beginning
+            script_crossover_proba_global_optim(randomizer, "global-crossover-proba.csv", false, 5, 5);
+            break;
+        case 1: // Restart from a specific point
+            {
+                std::stringstream ss;
+                ss << "global-crossover-proba-" << atoi(argv[3]) << "-" << atoi(argv[4]) << ".csv";
+                script_crossover_proba_global_optim(randomizer, ss.str(), true, atoi(argv[3]), atoi(argv[4]));
+            }break;
+        case 2: // Filtering
+            crossover_model_filtering(argv[3], argv[4], argv[5], atoi(argv[6]), atoi(argv[7]));
+            break;
+        case 3: // Local optimization of model
+            crossover_model_optimization(argv[3]);
+            break;
+        case 4: // Validation of model
+            crossover_model_validation(argv[3], atof(argv[4]), atof(argv[5]), atof(argv[6]), atof(argv[7]));
+            break;
+    }
+}
+
 void script_crossover_proba_global_optim(std::default_random_engine& randomizer, std::string namefile, bool restart, unsigned int restart_n, unsigned int restart_lambda) {
     if(! restart)
         std::ofstream savefile(namefile);
@@ -62,7 +85,7 @@ void crossover_model_filtering(std::string input, std::string output, std::strin
         double pmin, pbest, pmax, thresold;
         sscanf(line.c_str(),"%d;%d;%lf;%lf;%lf;%lf", &n, &lda, &pmin, &pbest, &pmax, &thresold);
 
-        if((filtered_n==0 | n == filtered_n) && (filtered_lda==0 | lda == filtered_lda)) {
+        if((filtered_n==0 || n == filtered_n) && (filtered_lda==0 || lda == filtered_lda)) {
             if(lda < 5) continue;
 
             outfile << line << std::endl;

src/experiences/mutation-rate.cpp

@@ -0,0 +1,50 @@
+#include "experiences/mutation-rate.h"
+
+void script_optimal_proba_2(int n_initial, int n_final, std::default_random_engine& randomizer, double p_init=0.05, double p_final=0.5, double p_step=0.01, std::vector<int> nb_tests_by_depth={}, std::vector<double> stq_by_depth={}) {
+    ProbaOptimizer po(n_initial, randomizer);
+    po.set_nb_contexts(n_final-n_initial);
+    po.set_study_interval(p_init, p_final, p_step);
+    for(unsigned int depth=0; depth<nb_tests_by_depth.size(); depth++)
+        po.add_test_wave(nb_tests_by_depth[depth], stq_by_depth[depth], depth);
+    po.run();
+}
+
+void script_optimal_proba(std::default_random_engine& randomizer) {
+    std::string namefile = "optimal-proba.csv";
+    {
+        int n_init=3, n_final=16;
+        double p_init=0.05, p_final=0.5, p_step=0.01;
+        ProbaOptimizer po(n_init, randomizer);
+        po.set_nb_contexts(n_final-n_init);
+        po.set_study_interval(p_init, p_final, p_step);
+        po.add_test_wave(20, 2.3362421597, 0);
+        po.add_test_wave(200, 2.3451370823, 1);
+        po.add_test_wave(2000, 2.2953981367, 2);
+        po.save_run(namefile);
+        po.run();
+    }
+    {
+        int n_init=16, n_final=28;
+        double p_init=0.03, p_final=0.2, p_step=0.01;
+        ProbaOptimizer po(n_init, randomizer);
+        po.set_nb_contexts(n_final-n_init);
+        po.set_study_interval(p_init, p_final, p_step);
+        po.add_test_wave(20, 2.6742086844, 0);
+        po.add_test_wave(100, 2.4755765532, 1);
+        po.add_test_wave(1000, 2.4365960683, 2);
+        po.save_run(namefile);
+        po.run();
+    }
+    {
+        int n_init=28, n_final=46;
+        double p_init=0.01, p_final=0.1, p_step=0.005;
+        ProbaOptimizer po(n_init, randomizer);
+        po.set_nb_contexts(n_final-n_init);
+        po.set_study_interval(p_init, p_final, p_step);
+        po.add_test_wave(20, 2.6742086844, 0);
+        po.add_test_wave(100, 2.4755765532, 1);
+        po.add_test_wave(1000, 2.4365960683, 2);
+        po.save_run(namefile);
+        po.run();
+    }
+}

src/heuristics/EA.cpp

@@ -0,0 +1,2 @@
+#include "heuristics/EA.h"
+

src/heuristics/GA.cpp

@@ -0,0 +1,8 @@
+#include "heuristics/GA.h"
+
+double GA::get_crossover_proba(double progress) {
+    return m_crossover_proba;
+}
+double GA::get_sbm_proba(double progress) {
+    return m_sbm_proba;
+}

src/GGA.cpp → src/heuristics/GGA.cpp

@@ -1,4 +1,4 @@
-#include "GGA.h"
+#include "heuristics/GGA.h"
 
 
 int* selector(int i, void* object) {
@@ -6,11 +6,10 @@ int* selector(int i, void* object) {
     return tab[i]->sol;
 }
 
-GGA::GGA(int mu, int lda, int selection, double sbm_proba, int crossover_method, int version, std::default_random_engine& randomizer) {
+GGA::GGA(int mu, int lda, int selection, int crossover_method, int version, std::default_random_engine& randomizer) {
     m_mu = mu;
     m_lambda = lda;
     m_selection = selection;
-    m_sbm_proba = sbm_proba;
     m_crossover_method = crossover_method;
     m_version = version;
 
@@ -33,7 +32,6 @@ void GGA::prepare_tab() {
         x_tab[i] = new Candidate(x, 0);
     }
 
-    m_binomial_dist = std::binomial_distribution<int>(m_problem->get_max_radius(), m_sbm_proba);
     m_uniform_dist  = std::uniform_int_distribution<int>(0, m_mu-1);
     m_is_prepared = true;
 }
@@ -56,6 +54,11 @@ Result GGA::run() {
     int nb_calls = m_mu;
 
     while(! pb->is_optimal(x_best->sol, x_best->value, m_objective)) {
+        double progress = pb->get_progress(x_best->sol, x_best->value);
+        double sbm_proba = get_sbm_proba(progress);
+        std::binomial_distribution<int> mutation = std::binomial_distribution<int>(m_problem->get_max_radius(), sbm_proba);
+        std::bernoulli_distribution crossover(get_crossover_proba(progress));
+
         // Evaluation fitness of the parent population
         std::vector<double> parent_fitness_dist_tab;
         for(int i=0; i<m_mu; i++)
@@ -63,10 +66,9 @@ Result GGA::run() {
         std::discrete_distribution<int> parent_fitness_dist(parent_fitness_dist_tab.begin(), parent_fitness_dist_tab.end());
 
         // Variation phase
-        std::bernoulli_distribution m_bernoulli_dist(get_crossover_proba(pb->get_progress(x_best->sol, x_best->value)));
         for(int i=0; i<m_lambda; i++) {
             Candidate* y = x_tab[m_mu+i];
-            bool crossover_step = m_bernoulli_dist(m_randomizer);
+            bool crossover_step = crossover(m_randomizer);
             switch(m_version) {
                 case GA_V1:
                     if(crossover_step) {
@@ -75,7 +77,9 @@ Result GGA::run() {
                         else
                             pb->crossover(y->sol, (void*) x_tab, m_mu, &selector, m_crossover_method);
                     } else {
-                        int r = m_binomial_dist(m_randomizer);
+                        int r = mutation(m_randomizer);
+                        if(sbm_proba < 0)
+                            r = round(m_problem->get_max_radius() * (-sbm_proba));
                         int parent_index = m_uniform_dist(m_randomizer);
                         pb->copy_candidate(x_tab[parent_index]->sol, y->sol);
                         pb->modify_with_radius(y->sol, r);
@@ -107,7 +111,7 @@ Result GGA::run() {
                         int parent_index = parent_fitness_dist(m_randomizer);
                         pb->copy_candidate(x_tab[parent_index]->sol, y->sol);
                     }
-                    int r = m_binomial_dist(m_randomizer);
+                    int r = mutation(m_randomizer);
                     pb->modify_with_radius(y->sol, r);
                     y->value = pb->try_candidate(y->sol);
                     break;