Added help for nmplot. Connected demos. Fixed demos. Fixed optimsimplex API.
Michaël Baudin [Tue, 22 Sep 2009 14:48:54 +0000 (16:48 +0200)]
139 files changed:
scilab/modules/optimization/demos/neldermead/fminsearch.sce
scilab/modules/optimization/demos/neldermead/neldermead_rosenbrock.sce
scilab/modules/optimization/demos/neldermead/nmplot_boxproblemA.sce
scilab/modules/optimization/demos/neldermead/nmplot_han1.sce
scilab/modules/optimization/demos/neldermead/nmplot_mckinnon.sce
scilab/modules/optimization/demos/neldermead/nmplot_mckinnon2.sce
scilab/modules/optimization/demos/neldermead/nmplot_quadratic.fixed.sce [new file with mode: 0644]
scilab/modules/optimization/demos/neldermead/nmplot_rosenbrock.fixed.sce
scilab/modules/optimization/demos/neldermead/nmplot_rosenbrock.sce
scilab/modules/optimization/demos/optimization.dem.gateway.sce
scilab/modules/optimization/help/en_US/neldermead/neldermead.xml
scilab/modules/optimization/help/en_US/neldermead/nmplot.xml [new file with mode: 0644]
scilab/modules/optimization/help/en_US/optimsimplex/optimsimplex.xml
scilab/modules/optimization/macros/neldermead/fminsearch.sci
scilab/modules/optimization/macros/neldermead/neldermead_cget.sci
scilab/modules/optimization/macros/neldermead/neldermead_configure.sci
scilab/modules/optimization/macros/neldermead/neldermead_contour.sci
scilab/modules/optimization/macros/neldermead/neldermead_new.sci
scilab/modules/optimization/macros/neldermead/neldermead_restart.sci
scilab/modules/optimization/macros/neldermead/neldermead_search.sci
scilab/modules/optimization/macros/neldermead/neldermead_updatesimp.sci
scilab/modules/optimization/macros/neldermead/nmplot_cget.sci
scilab/modules/optimization/macros/neldermead/nmplot_configure.sci
scilab/modules/optimization/macros/neldermead/nmplot_contour.sci
scilab/modules/optimization/macros/neldermead/nmplot_display.sci
scilab/modules/optimization/macros/neldermead/nmplot_historyplot.sci
scilab/modules/optimization/macros/neldermead/nmplot_log.sci
scilab/modules/optimization/macros/neldermead/nmplot_new.sci
scilab/modules/optimization/macros/neldermead/nmplot_outputcmd.sci
scilab/modules/optimization/macros/neldermead/nmplot_restart.sci [new file with mode: 0644]
scilab/modules/optimization/macros/neldermead/optimset.sci
scilab/modules/optimization/macros/optimbase/optimbase_cget.sci
scilab/modules/optimization/macros/optimbase/optimbase_checkbounds.sci
scilab/modules/optimization/macros/optimbase/optimbase_configure.sci
scilab/modules/optimization/macros/optimbase/optimbase_function.sci
scilab/modules/optimization/macros/optimbase/optimbase_get.sci
scilab/modules/optimization/macros/optimbase/optimbase_histget.sci
scilab/modules/optimization/macros/optimbase/optimbase_histset.sci
scilab/modules/optimization/macros/optimbase/optimbase_outstruct.sci
scilab/modules/optimization/macros/optimbase/optimbase_set.sci
scilab/modules/optimization/macros/optimbase/optimbase_terminate.sci
scilab/modules/optimization/macros/optimsimplex/newFile.txt [new file with mode: 0644]
scilab/modules/optimization/macros/optimsimplex/newFile2.txt [new file with mode: 0644]
scilab/modules/optimization/macros/optimsimplex/optimsimplex_axes.sci
scilab/modules/optimization/macros/optimsimplex/optimsimplex_center.sci
scilab/modules/optimization/macros/optimsimplex/optimsimplex_check.sci
scilab/modules/optimization/macros/optimsimplex/optimsimplex_computefv.sci
scilab/modules/optimization/macros/optimsimplex/optimsimplex_dirmat.sci
scilab/modules/optimization/macros/optimsimplex/optimsimplex_getall.sci
scilab/modules/optimization/macros/optimsimplex/optimsimplex_getallfv.sci
scilab/modules/optimization/macros/optimsimplex/optimsimplex_getallx.sci
scilab/modules/optimization/macros/optimsimplex/optimsimplex_getfv.sci
scilab/modules/optimization/macros/optimsimplex/optimsimplex_getve.sci
scilab/modules/optimization/macros/optimsimplex/optimsimplex_getx.sci
scilab/modules/optimization/macros/optimsimplex/optimsimplex_gradientfv.sci
scilab/modules/optimization/macros/optimsimplex/optimsimplex_new.sci
scilab/modules/optimization/macros/optimsimplex/optimsimplex_oriented.sci
scilab/modules/optimization/macros/optimsimplex/optimsimplex_pfeffer.sci
scilab/modules/optimization/macros/optimsimplex/optimsimplex_print.sci
scilab/modules/optimization/macros/optimsimplex/optimsimplex_randbounds.sci
scilab/modules/optimization/macros/optimsimplex/optimsimplex_reflect.sci
scilab/modules/optimization/macros/optimsimplex/optimsimplex_setall.sci
scilab/modules/optimization/macros/optimsimplex/optimsimplex_setallfv.sci
scilab/modules/optimization/macros/optimsimplex/optimsimplex_setallx.sci
scilab/modules/optimization/macros/optimsimplex/optimsimplex_setfv.sci
scilab/modules/optimization/macros/optimsimplex/optimsimplex_setve.sci
scilab/modules/optimization/macros/optimsimplex/optimsimplex_setx.sci
scilab/modules/optimization/macros/optimsimplex/optimsimplex_shrink.sci
scilab/modules/optimization/macros/optimsimplex/optimsimplex_size.sci
scilab/modules/optimization/macros/optimsimplex/optimsimplex_sort.sci
scilab/modules/optimization/macros/optimsimplex/optimsimplex_spendley.sci
scilab/modules/optimization/macros/optimsimplex/optimsimplex_tostring.sci
scilab/modules/optimization/macros/optimsimplex/optimsimplex_xbar.sci
scilab/modules/optimization/tests/unit_tests/neldermead/fminsearch.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/fminsearch.tst
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_configure.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_configure.tst
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_display.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_mckinnon.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_mckinnon.tst
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_outputcmd.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_outputcmd.tst
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_outputcmd2.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_outputcmd2.tst
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_rosensuzuki.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_rosensuzuki.tst
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_search.dia.ref [new file with mode: 0644]
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_search.tst [new file with mode: 0644]
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_searchaddarg.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_searchdefault.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_searchdefault.tst
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_searchfixed2.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_searchfixed2.tst
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_searchvariable.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_searchvariable.tst
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_simplex0.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_simplex0.tst
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_simplexaxes.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_simplexaxes.tst
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_simplexregular.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_simplexregular.tst
scilab/modules/optimization/tests/unit_tests/neldermead/nmplot_contour.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/nmplot_contour.tst
scilab/modules/optimization/tests/unit_tests/neldermead/nmplot_newdestroy.dia.ref [new file with mode: 0644]
scilab/modules/optimization/tests/unit_tests/neldermead/nmplot_newdestroy.tst [new file with mode: 0644]
scilab/modules/optimization/tests/unit_tests/neldermead/nmplot_rosenbrock.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/nmplot_rosenbrock.tst
scilab/modules/optimization/tests/unit_tests/neldermead/optimget.dia.ref [new file with mode: 0644]
scilab/modules/optimization/tests/unit_tests/neldermead/optimset.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/optimset.tst
scilab/modules/optimization/tests/unit_tests/optimbase.dia.ref [deleted file]
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_checkbounds.dia.ref
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_newdestroy.dia.ref
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_newdestroy.tst
scilab/modules/optimization/tests/unit_tests/optimsimplex.dia.ref [deleted file]
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_center.dia.ref
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_center.tst
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_check.dia.ref
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_check.tst
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_computefv.dia.ref
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_dirmat.dia.ref
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_fvstdev.dia.ref
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_getset.dia.ref
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_getset.tst
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_new.dia.ref
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_new.tst
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_pfeffer.dia.ref
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_print.dia.ref
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_print.tst
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_reflect.dia.ref
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_shrink.dia.ref
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_shrink.tst
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_size.dia.ref
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_size.tst
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_sort.dia.ref
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_sort.tst
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_spendley.dia.ref
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_xbar.dia.ref
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_xbar.tst

index 37314bc..802e495 100644 (file)
@@ -7,10 +7,25 @@
 // are also available at
 // http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
 
-
+mprintf("Defining Rosenbrock function...\n");
 function y = banana (x)
   y = 100*(x(2)-x(1)^2)^2 + (1-x(1))^2;
 endfunction
-[x , fval , exitflag , output] = fminsearch ( banana , [-1.2 1] );
+x0 = [-1.2 1]
+mprintf("x0=%s\n",strcat(string(x0)," "));
+mprintf("Running optimization...\n");
+[x , fval , exitflag , output] = fminsearch ( banana , x0 );
+mprintf("x=%s\n",strcat(string(x)," "));
+mprintf("fval=%e\n",fval);
+mprintf("exitflag=%d\n",exitflag);
+mprintf("output.message:\n");
+for i =1:3
+  mprintf(output.message(i));
+  mprintf("\n");
+end
+mprintf("output.algorithm:%s\n",output.algorithm);
+mprintf("output.funcCount:%d\n",output.funcCount);
+mprintf("output.iterations:%d\n",output.iterations);
+
 
 
index b418eb9..657715d 100644 (file)
@@ -7,14 +7,18 @@
 // are also available at
 // http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
 
+mprintf("Defining Rosenbrock function...\n");
 function y = rosenbrock (x)
 y = 100*(x(2)-x(1)^2)^2+(1-x(1))^2;
 endfunction
-
+x0 = [-1.2 1.0]';
+mprintf("x0=%s\n",strcat(string(x0)," "));
+mprintf("Creating object...\n");
 nm = neldermead_new ();
+mprintf("Configuring object...\n");
 nm = neldermead_configure(nm,"-numberofvariables",2);
 nm = neldermead_configure(nm,"-function",rosenbrock);
-nm = neldermead_configure(nm,"-x0",[-1.2 1.0]');
+nm = neldermead_configure(nm,"-x0",x0);
 nm = neldermead_configure(nm,"-maxiter",200);
 nm = neldermead_configure(nm,"-maxfunevals",300);
 nm = neldermead_configure(nm,"-tolfunrelative",10*%eps);
@@ -24,12 +28,26 @@ nm = neldermead_configure(nm,"-simplex0length",1.0);
 nm = neldermead_configure(nm,"-method","variable");
 nm = neldermead_configure(nm,"-verbose",0);
 nm = neldermead_configure(nm,"-verbosetermination",0);
+mprintf("Searching for minimum...\n");
 nm = neldermead_search(nm);
-
+neldermead_display(nm);
+mprintf("Plot contour...\n");
 [nm , xdata , ydata , zdata ] = neldermead_contour ( nm , xmin = -2.0 , xmax = 2.0 , ymin = -2.0 , ymax = 2.0 , nx = 100 , ny = 100 );
-contour ( xdata , ydata , zdata , 20 )
-
-
+wnum = 100001;
+my_handle             = scf(wnum);
+contour ( xdata , ydata , zdata , [1 10 100 500 1000 2000] )
+// Plot starting point
+mprintf("x0 : blue dot\n");
+plot(x0(1),x0(2));
+my_handle.children.children(1).children.mark_mode="on";
+my_handle.children.children(1).children.mark_size = 5;
+my_handle.children.children(1).children.mark_foreground = 2;
+mprintf("xopt : red dot\n");
+xopt = neldermead_get(nm,"-xopt");
+plot(xopt(1),xopt(2));
+my_handle.children.children(1).children.mark_mode="on";
+my_handle.children.children(1).children.mark_size = 5;
+my_handle.children.children(1).children.mark_foreground = 5;
 
 nm = neldermead_destroy(nm);
 clear nm;
index d711959..be5eab3 100644 (file)
@@ -142,7 +142,7 @@ nm = nmplot_configure(nm,"-tolsimplexizerelative",1.e-3);
 nm = nmplot_configure(nm,"-coords0",coords0);
 nm = nmplot_configure(nm,"-simplex0length",1.0);
 nm = nmplot_configure(nm,"-method","box");
-nm = nmplot_configure(nm,"-verbose",1);
+//nm = nmplot_configure(nm,"-verbose",1);
 nm = nmplot_configure(nm,"-verbosetermination",1);
 // Configure like Box
 nm = neldermead_configure(nm,"-boundsmin",[0.0 1.2 20.0 9.0 6.0]);
index 8eaa274..6d6a82c 100644 (file)
 //   2000
 //   Ph.D., The University of Connecticut
 //
+mprintf("Defining Han function...\n");
 function f = han1 ( x )
   f = x(1)^2 + x(2) * (x(2) + 2.0) * (x(2) - 0.5) * (x(2) - 2.0);
 endfunction
 
 
+mprintf("Defining initial simplex coordinates...\n");
 coords0 = [
-0.0 0.0 1.0
--1.0 1.0 0.0
+    0.  -1.  
+    0.   1.  
+    1.   0.  
 ]
 
 
+mprintf("Creating nmplot object...\n");
 nm = nmplot_new ();
+mprintf("Configuring nmplot object...\n");
 nm = nmplot_configure(nm,"-numberofvariables",2);
 nm = nmplot_configure(nm,"-function",han1);
 nm = nmplot_configure(nm,"-x0",[1.0 1.0]');
@@ -46,6 +51,7 @@ nm = nmplot_configure(nm,"-verbosetermination",1);
 //
 // Setup output files
 //
+mprintf("Setup output files...\n");
 nm = nmplot_configure(nm,"-simplexfn","han1-history-simplex.txt");
 nm = nmplot_configure(nm,"-fbarfn","han1-history-fbar.txt");
 nm = nmplot_configure(nm,"-foptfn","han1-history-fopt.txt");
@@ -53,17 +59,23 @@ nm = nmplot_configure(nm,"-sigmafn","han1-history-sigma.txt");
 //
 // Perform optimization
 //
+mprintf("Searching for minimum...\n");
 nm = nmplot_search(nm);
+nmplot_display(nm);
 //
-// Plot
+// Plot the history of the simplex
 //
+mprintf("Plotting contour...\n");
 [nm , xdata , ydata , zdata ] = nmplot_contour ( nm , xmin = -0.2 , xmax = 1.2 , ymin = -2.0 , ymax = 2.0 , nx = 50 , ny = 50 );
 //[nm , xdata , ydata , zdata ] = nmplot_contour ( nm , xmin = -0.2 , xmax = 1.2 , ymin = -1.2 , ymax = 1.2 , nx = 50 , ny = 50 );
-f = scf();
+wnum = 100001;
+f = scf(wnum);
 xset("fpf"," ")
-contour ( xdata , ydata , zdata , 40 )
+contour ( xdata , ydata , zdata , [-5 -4 -2 -1 0 1 1.5] )
 nmplot_simplexhistory ( nm );
-xs2png(0,"han1-history-simplex.png");
+//
+// Clean-up
+//
 deletefile("han1-history-simplex.txt");
 deletefile("han1-history-fbar.txt");
 deletefile("han1-history-fopt.txt");
index cdcfefa..fc1af7b 100644 (file)
@@ -124,6 +124,7 @@ nm = nmplot_configure(nm,"-sigmafn","mckinnon.history.sigma.txt");
 // Perform optimization
 //
 nm = nmplot_search(nm);
+nmplot_display(nm);
 //
 // Plot
 //
@@ -132,19 +133,15 @@ f = scf();
 xset("fpf"," ")
 contour ( xdata , ydata , zdata , 40 )
 nmplot_simplexhistory ( nm );
-xs2png(0,"mckinnon.history.simplex.png");
 f = scf();
 nmplot_historyplot ( nm , "mckinnon.history.fbar.txt" , ...
   mytitle = "Function Value Average" , myxlabel = "Iterations" );
-xs2png(1,"mckinnon.history.fbar.png");
 f = scf();
 nmplot_historyplot ( nm , "mckinnon.history.fopt.txt" , ...
   mytitle = "Minimum Function Value" , myxlabel = "Iterations" );
-xs2png(2,"mckinnon.history.fopt.png");
 f = scf();
 nmplot_historyplot ( nm , "mckinnon.history.sigma.txt" , ...
   mytitle = "Maximum Oriented length" , myxlabel = "Iterations" );
-xs2png(3,"mckinnon.history.sigma.png");
 deletefile("mckinnon.history.simplex.txt");
 deletefile("mckinnon.history.fbar.txt");
 deletefile("mckinnon.history.fopt.txt");
index ad455cd..9238927 100644 (file)
@@ -110,7 +110,7 @@ nm = nmplot_configure(nm,"-simplex0method","given");
 nm = nmplot_configure(nm,"-coords0",coords0);
 nm = nmplot_configure(nm,"-simplex0length",1.0);
 nm = nmplot_configure(nm,"-method","variable");
-nm = nmplot_configure(nm,"-verbose",0);
+//nm = nmplot_configure(nm,"-verbose",0);
 nm = nmplot_configure(nm,"-verbosetermination",0);
 nm = nmplot_configure(nm,"-kelleystagnationflag",1);
 nm = nmplot_configure(nm,"-restartflag",1);
@@ -126,6 +126,7 @@ nm = nmplot_configure(nm,"-sigmafn","mckinnon.history.restart.sigma.txt");
 // Perform optimization
 //
 nm = nmplot_search(nm);
+nmplot_display(nm);
 //
 // Plot
 //
@@ -134,19 +135,15 @@ f = scf();
 xset("fpf"," ")
 contour ( xdata , ydata , zdata , 40 )
 nmplot_simplexhistory ( nm );
-xs2png(0,"mckinnon.history.restart.simplex.png");
 f = scf();
 nmplot_historyplot ( nm , "mckinnon.history.restart.fbar.txt" , ...
   mytitle = "Function Value Average" , myxlabel = "Iterations" );
-xs2png(1,"mckinnon.history.restart.fbar.png");
 f = scf();
 nmplot_historyplot ( nm , "mckinnon.history.restart.fopt.txt" , ...
   mytitle = "Minimum Function Value" , myxlabel = "Iterations" );
-xs2png(2,"mckinnon.history.restart.fopt.png");
 f = scf();
 nmplot_historyplot ( nm , "mckinnon.history.restart.sigma.txt" , ...
   mytitle = "Maximum Oriented length" , myxlabel = "Iterations" );
-xs2png(3,"mckinnon.history.restart.sigma.png");
 deletefile("mckinnon.history.restart.simplex.txt");
 deletefile("mckinnon.history.restart.fbar.txt");
 deletefile("mckinnon.history.restart.fopt.txt");
diff --git a/scilab/modules/optimization/demos/neldermead/nmplot_quadratic.fixed.sce b/scilab/modules/optimization/demos/neldermead/nmplot_quadratic.fixed.sce
new file mode 100644 (file)
index 0000000..c7893bf
--- /dev/null
@@ -0,0 +1,67 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2008-2009 - INRIA - Michael Baudin
+//
+// This file must be used under the terms of the CeCILL.
+// This source file is licensed as described in the file COPYING, which
+// you should have received as part of this distribution.  The terms
+// are also available at
+// http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+
+
+mprintf("Defining quadratic function...\n");
+function y = quadratic (x)
+  y = x(1)^2 + x(2)^2 - x(1) * x(2);
+endfunction
+
+mprintf("Creating nmplot object...\n");
+nm = nmplot_new ();
+nm = nmplot_configure(nm,"-numberofvariables",2);
+nm = nmplot_configure(nm,"-function",quadratic);
+nm = nmplot_configure(nm,"-x0",[2.0 2.0]');
+nm = nmplot_configure(nm,"-maxiter",100);
+nm = nmplot_configure(nm,"-maxfunevals",300);
+//nm = nmplot_configure(nm,"-tolfunrelative",10*%eps);
+nm = nmplot_configure(nm,"-tolxrelative",1.e-8);
+nm = nmplot_configure(nm,"-simplex0method","spendley");
+//nm = nmplot_configure(nm,"-simplex0length",1.0);
+nm = nmplot_configure(nm,"-method","fixed");
+//nm = nmplot_configure(nm,"-verbose",1);
+nm = nmplot_configure(nm,"-verbosetermination",0);
+//
+// Setup output files
+//
+nm = nmplot_configure(nm,"-simplexfn","rosenbrock.fixed.history.simplex.txt");
+nm = nmplot_configure(nm,"-fbarfn","rosenbrock.fixed.history.fbar.txt");
+nm = nmplot_configure(nm,"-foptfn","rosenbrock.fixed.history.fopt.txt");
+nm = nmplot_configure(nm,"-sigmafn","rosenbrock.fixed.history.sigma.txt");
+//
+// Perform optimization
+//
+mprintf("Searching for minimum...\n");
+nm = nmplot_search(nm);
+nmplot_display(nm);
+// Plot the contours of the cost function and the simplex history
+mprintf("Plotting contour...\n");
+[nm , xdata , ydata , zdata ] = nmplot_contour ( nm , xmin = -2.0 , xmax = 4.0 , ymin = -2.0 , ymax = 4.0 , nx = 100 , ny = 100 );
+f = scf();
+contour ( xdata , ydata , zdata , [0.1 1.0 2.0 5.0 10.0 15.0 20.0] )
+nmplot_simplexhistory ( nm );
+mprintf("Plotting history of fbar...\n");
+f = scf();
+nmplot_historyplot ( nm , "rosenbrock.fixed.history.fbar.txt" , ...
+  mytitle = "Function Value Average" , myxlabel = "Iterations" );
+mprintf("Plotting history of fopt...\n");
+f = scf();
+nmplot_historyplot ( nm , "rosenbrock.fixed.history.fopt.txt" , ...
+  mytitle = "Minimum Function Value" , myxlabel = "Iterations" );
+mprintf("Plotting history of sigma...\n");
+f = scf();
+nmplot_historyplot ( nm , "rosenbrock.fixed.history.sigma.txt" , ...
+  mytitle = "Maximum Oriented length" , myxlabel = "Iterations" );
+deletefile("rosenbrock.fixed.history.simplex.txt");
+deletefile("rosenbrock.fixed.history.fbar.txt");
+deletefile("rosenbrock.fixed.history.fopt.txt");
+deletefile("rosenbrock.fixed.history.sigma.txt");
+nm = nmplot_destroy(nm);
+
+
index a285447..6d55904 100644 (file)
@@ -8,22 +8,24 @@
 // http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
 
 
+mprintf("Defining Rosenbrock function...\n");
 function y = rosenbrock (x)
   y = 100*(x(2)-x(1)^2)^2 + (1-x(1))^2;
 endfunction
 
+mprintf("Creating nmplot object...\n");
 nm = nmplot_new ();
 nm = nmplot_configure(nm,"-numberofvariables",2);
 nm = nmplot_configure(nm,"-function",rosenbrock);
 nm = nmplot_configure(nm,"-x0",[-1.2 1.0]');
-nm = nmplot_configure(nm,"-maxiter",200);
+nm = nmplot_configure(nm,"-maxiter",100);
 nm = nmplot_configure(nm,"-maxfunevals",300);
 nm = nmplot_configure(nm,"-tolfunrelative",10*%eps);
 nm = nmplot_configure(nm,"-tolxrelative",10*%eps);
 nm = nmplot_configure(nm,"-simplex0method","axes");
 nm = nmplot_configure(nm,"-simplex0length",1.0);
 nm = nmplot_configure(nm,"-method","fixed");
-nm = nmplot_configure(nm,"-verbose",1);
+//nm = nmplot_configure(nm,"-verbose",1);
 nm = nmplot_configure(nm,"-verbosetermination",0);
 //
 // Setup output files
@@ -35,25 +37,26 @@ nm = nmplot_configure(nm,"-sigmafn","rosenbrock.fixed.history.sigma.txt");
 //
 // Perform optimization
 //
+mprintf("Searching for minimum...\n");
 nm = nmplot_search(nm);
 // Plot the contours of the cost function and the simplex history
+mprintf("Plotting contour...\n");
 [nm , xdata , ydata , zdata ] = nmplot_contour ( nm , xmin = -2.0 , xmax = 2.0 , ymin = -2.0 , ymax = 2.0 , nx = 100 , ny = 100 );
 f = scf();
 contour ( xdata , ydata , zdata , 20 )
 nmplot_simplexhistory ( nm );
-xs2png(0,"rosenbrock.fixed.history.simplex.png");
+mprintf("Plotting history of fbar...\n");
 f = scf();
 nmplot_historyplot ( nm , "rosenbrock.fixed.history.fbar.txt" , ...
   mytitle = "Function Value Average" , myxlabel = "Iterations" );
-xs2png(1,"rosenbrock.fixed.history.fbar.png");
+mprintf("Plotting history of fopt...\n");
 f = scf();
 nmplot_historyplot ( nm , "rosenbrock.fixed.history.fopt.txt" , ...
   mytitle = "Minimum Function Value" , myxlabel = "Iterations" );
-xs2png(2,"rosenbrock.fixed.history.fopt.png");
+mprintf("Plotting history of sigma...\n");
 f = scf();
 nmplot_historyplot ( nm , "rosenbrock.fixed.history.sigma.txt" , ...
   mytitle = "Maximum Oriented length" , myxlabel = "Iterations" );
-xs2png(3,"rosenbrock.fixed.history.sigma.png");
 deletefile("rosenbrock.fixed.history.simplex.txt");
 deletefile("rosenbrock.fixed.history.fbar.txt");
 deletefile("rosenbrock.fixed.history.fopt.txt");
index f180860..040d5b8 100644 (file)
@@ -8,10 +8,12 @@
 // http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
 
 
+mprintf("Defining Rosenbrock function...\n");
 function y = rosenbrock (x)
   y = 100*(x(2)-x(1)^2)^2 + (1-x(1))^2;
 endfunction
 
+mprintf("Creating nmplot object...\n");
 nm = nmplot_new ();
 nm = nmplot_configure(nm,"-numberofvariables",2);
 nm = nmplot_configure(nm,"-function",rosenbrock);
@@ -23,7 +25,7 @@ nm = nmplot_configure(nm,"-tolxrelative",10*%eps);
 nm = nmplot_configure(nm,"-simplex0method","axes");
 nm = nmplot_configure(nm,"-simplex0length",1.0);
 nm = nmplot_configure(nm,"-method","variable");
-nm = nmplot_configure(nm,"-verbose",1);
+//nm = nmplot_configure(nm,"-verbose",1);
 nm = nmplot_configure(nm,"-verbosetermination",0);
 //
 // Setup output files
@@ -35,25 +37,28 @@ nm = nmplot_configure(nm,"-sigmafn","rosenbrock.history.sigma.txt");
 //
 // Perform optimization
 //
+mprintf("Searching for minimum...\n");
 nm = nmplot_search(nm);
+nmplot_display(nm);
 // Plot the contours of the cost function and the simplex history
+mprintf("Plotting contour...\n");
 [nm , xdata , ydata , zdata ] = nmplot_contour ( nm , xmin = -2.0 , xmax = 2.0 , ymin = -1.0 , ymax = 2.5 , nx = 100 , ny = 100 );
 f = scf();
-contour ( xdata , ydata , zdata , 30 )
+contour ( xdata , ydata , zdata , [1 10 100 500 1000 2000] )
 nmplot_simplexhistory ( nm );
-xs2png(0,"rosenbrock.history.simplex.png");
+mprintf("Plotting history of fbar...\n");
 f = scf();
 nmplot_historyplot ( nm , "rosenbrock.history.fbar.txt" , ...
   mytitle = "Function Value Average" , myxlabel = "Iterations" );
-xs2png(1,"rosenbrock.history.fbar.png");
+mprintf("Plotting history of fopt...\n");
 f = scf();
 nmplot_historyplot ( nm , "rosenbrock.history.fopt.txt" , ...
   mytitle = "Minimum Function Value" , myxlabel = "Iterations" );
-xs2png(2,"rosenbrock.history.fopt.png");
+mprintf("Plotting history of sigma...\n");
 f = scf();
 nmplot_historyplot ( nm , "rosenbrock.history.sigma.txt" , ...
   mytitle = "Maximum Oriented length" , myxlabel = "Iterations" );
-xs2png(3,"rosenbrock.history.sigma.png");
+mprintf("Cleaning up...\n");
 deletefile("rosenbrock.history.simplex.txt");
 deletefile("rosenbrock.history.fbar.txt");
 deletefile("rosenbrock.history.fopt.txt");
index caca1e2..9bb824c 100644 (file)
@@ -6,5 +6,19 @@
 //
 
 demopath = get_absolute_file_path("optimization.dem.gateway.sce");
-subdemolist = ["Non linear data fitting"       , "datafit/datafit.dem.sce"       ];
+subdemolist = [
+"Non linear data fitting"         "datafit/datafit.dem.sce"       
+"fminsearch"                      "neldermead/fminsearch.sce"       
+"neldermead/Rosenbrock Variable"  "neldermead/neldermead_rosenbrock.sce"       
+"nmplot/BoxA"               "neldermead/nmplot_boxproblemA.sce"       
+"nmplot/Han #1"             "neldermead/nmplot_han1.sce"       
+"nmplot/Han #2"             "neldermead/nmplot_han2.sce"       
+"nmplot/McKinnon #1"        "neldermead/nmplot_mckinnon.sce"       
+"nmplot/McKinnon #2"        "neldermead/nmplot_mckinnon2.sce"       
+"nmplot/Quadratic Fixed"   "neldermead/nmplot_quadratic.fixed.sce"       
+"nmplot/Rosenbrock Fixed"   "neldermead/nmplot_rosenbrock.fixed.sce"       
+"nmplot/Rosenbrock"         "neldermead/nmplot_rosenbrock.sce"       
+];
 subdemolist(:,2) = demopath + subdemolist(:,2)
+
+
index f5b4fb8..3640ef4 100644 (file)
@@ -30,8 +30,8 @@ this = neldermead_configure (this,key,value)
 value = neldermead_cget (this,key)
 this = neldermead_display ( this )
 value = neldermead_get ( this , key )
-this = neldermead_restart ( this )
 this = neldermead_search ( this )
+this = neldermead_restart ( this )
 [ this , xdata , ydata , zdata ] = neldermead_contour ( this , xmin , xmax , ymin , ymax , nx , ny )
 </synopsis>
   </refsynopsisdiv>
@@ -45,11 +45,11 @@ this = neldermead_search ( this )
     <para>The optimization problem to solve is the minimization of a cost
     function, with bounds and nonlinear constraints</para>
 
-    <programlisting role="example"><![CDATA[ 
+    <programlisting role="example"> 
 min f(x)
-l_i <= x_i <= h_i, i = 1,n
-g_i(x) <= 0, i = 1,nbineq
- ]]></programlisting>
+l_i &lt;= x_i &lt;= h_i, i = 1,n
+g_i(x) &lt;= 0, i = 1,nbineq
+ </programlisting>
 
     <para>where</para>
 
@@ -107,17 +107,15 @@ g_i(x) <= 0, i = 1,nbineq
           (k=2n is recommended by Box).</para>
         </listitem>
       </varlistentry>
-
     </variablelist>
   </refsection>
 
   <refsection>
     <title>Design</title>
 
-    <para>
-      The neldermead component is built on top of the <link linkend="optimbase">optimbase</link>
-      and <link linkend="optimsimplex">optimsimplex</link> components.
-    </para>
+    <para>The neldermead component is built on top of the <link
+    linkend="optimbase">optimbase</link> and <link
+    linkend="optimsimplex">optimsimplex</link> components.</para>
   </refsection>
 
   <refsection>
@@ -208,7 +206,8 @@ g_i(x) <= 0, i = 1,nbineq
                     <term>-x0</term>
 
                     <listitem>
-                      <para>the initial guess.</para>
+                      <para>the initial guess, as a n x 1 column vector, where
+                      n is the number of variables.</para>
                     </listitem>
                   </varlistentry>
 
@@ -519,7 +518,9 @@ g_i(x) <= 0, i = 1,nbineq
                       <para>the coordinates of the vertices of the initial
                       simplex. If the -simplex0method option is set to
                       "given", these coordinates are used to compute the
-                      initial simplex.</para>
+                      initial simplex. This matrix is expected to have shape
+                      nbve x n where nbve is the number of vertices and n is
+                      the number of variables.</para>
                     </listitem>
                   </varlistentry>
 
@@ -1000,7 +1001,8 @@ g_i(x) <= 0, i = 1,nbineq
                     <term>-xopt</term>
 
                     <listitem>
-                      <para>the x optimum</para>
+                      <para>the x optimum, as a n x 1 column vector, where n
+                      is the number of variables.</para>
                     </listitem>
                   </varlistentry>
 
@@ -1062,10 +1064,10 @@ g_i(x) <= 0, i = 1,nbineq
 
                     <listitem>
                       <para>a matrix containing the history of the simplex
-                      during the iterations. This matrix has rank nbiter x k x
-                      n, where nbiter is the number of iterations, k is the
-                      number of vertices in the simplex and n is the number of
-                      variables.</para>
+                      during the iterations. This matrix has rank nbiter x
+                      nbve x n, where nbiter is the number of iterations, nbve
+                      is the number of vertices in the simplex and n is the
+                      number of variables.</para>
                     </listitem>
                   </varlistentry>
 
@@ -1168,9 +1170,9 @@ g_i(x) <= 0, i = 1,nbineq
     <para>In the more general case, the cost function is expected to have the
     following header</para>
 
-    <programlisting role="example"><![CDATA[ 
+    <programlisting role="example"> 
 function y = myfunction(x, index, data)
- ]]></programlisting>
+ </programlisting>
 
     <para>where</para>
 
@@ -1245,9 +1247,9 @@ function y = myfunction(x, index, data)
     <para>In the most simple case, the cost function is expected to have the
     following header</para>
 
-    <programlisting role="example"><![CDATA[ 
+    <programlisting role="example"> 
 function y = myfunction(x)
- ]]></programlisting>
+ </programlisting>
 
     <para>where x is the current point and y is the value of the cost. This
     case is associated with an unconstrained problem without any additionnal
@@ -1263,9 +1265,9 @@ function y = myfunction(x)
 
     <para>The output function must have the following header</para>
 
-    <programlisting role="example"><![CDATA[ 
+    <programlisting role="example"> 
 function outputcmd(state, data, myobj)
- ]]></programlisting>
+ </programlisting>
 
     <para>where</para>
 
@@ -1371,9 +1373,9 @@ function outputcmd(state, data, myobj)
         <para>The number of iterations is examined and compared to the
         -maxiter option : if the following condition</para>
 
-        <programlisting role="example"><![CDATA[ 
-iterations >= maxiter
- ]]></programlisting>
+        <programlisting role="example"> 
+iterations &gt;= maxiter
+ </programlisting>
 
         <para>is true, then the status is set to "maxiter" and terminate is
         set to 1.</para>
@@ -1383,9 +1385,9 @@ iterations >= maxiter
         <para>The number of function evaluations and compared to the
         -maxfunevals option is examined : if the following condition</para>
 
-        <programlisting role="example"><![CDATA[ 
-funevals >= maxfunevals
- ]]></programlisting>
+        <programlisting role="example"> 
+funevals &gt;= maxfunevals
+ </programlisting>
 
         <para>is true, then the status is set to "maxfuneval" and terminate is
         set to 1.</para>
@@ -1410,9 +1412,9 @@ funevals >= maxfunevals
             <listitem>
               <para>if the following condition</para>
 
-              <programlisting role="example"><![CDATA[ 
-abs(currentfopt) < tolfunrelative * abs(previousfopt) + tolfunabsolute
- ]]></programlisting>
+              <programlisting role="example"> 
+abs(currentfopt) &lt; tolfunrelative * abs(previousfopt) + tolfunabsolute
+ </programlisting>
 
               <para>is true, then the status is set to "tolf" and terminate is
               set to 1.</para>
@@ -1448,9 +1450,9 @@ abs(currentfopt) < tolfunrelative * abs(previousfopt) + tolfunabsolute
             <listitem>
               <para>if the following condition</para>
 
-              <programlisting role="example"><![CDATA[ 
-norm(currentxopt - previousxopt) < tolxrelative * norm(currentxopt) + tolxabsolute
- ]]></programlisting>
+              <programlisting role="example"> 
+norm(currentxopt - previousxopt) &lt; tolxrelative * norm(currentxopt) + tolxabsolute
+ </programlisting>
 
               <para>is true, then the status is set to "tolx" and terminate is
               set to 1.</para>
@@ -1488,9 +1490,9 @@ norm(currentxopt - previousxopt) < tolxrelative * norm(currentxopt) + tolxabsolu
             <listitem>
               <para>if the following condition</para>
 
-              <programlisting role="example"><![CDATA[ 
-st_deviation(fv) < tolfstdeviation
- ]]></programlisting>
+              <programlisting role="example"> 
+st_deviation(fv) &lt; tolfstdeviation
+ </programlisting>
 
               <para>is true where fv is an array containing the function
               values in the simplex, then the status is set to "tolfstdev" and
@@ -1519,9 +1521,9 @@ st_deviation(fv) < tolfstdeviation
             <listitem>
               <para>if the following condition</para>
 
-              <programlisting role="example"><![CDATA[ 
-ssize < tolsimplexizerelative * simplexsize0 + tolsimplexizeabsolute
- ]]></programlisting>
+              <programlisting role="example"> 
+ssize &lt; tolsimplexizerelative * simplexsize0 + tolsimplexizeabsolute
+ </programlisting>
 
               <para>is true where simplexsize0 is the size of the simplex at
               iteration 0, then the status is set to "tolsize" and terminate
@@ -1551,13 +1553,13 @@ ssize < tolsimplexizerelative * simplexsize0 + tolsimplexizeabsolute
             <listitem>
               <para>if both the following conditions</para>
 
-              <programlisting role="example"><![CDATA[ 
-ssize < tolsimplexizeabsolute 
- ]]></programlisting>
+              <programlisting role="example"> 
+ssize &lt; tolsimplexizeabsolute 
+ </programlisting>
 
-              <programlisting role="example"><![CDATA[ 
-shiftfv < toldeltafv
- ]]></programlisting>
+              <programlisting role="example"> 
+shiftfv &lt; toldeltafv
+ </programlisting>
 
               <para>is true where ssize is the current simplex size and
               shiftfv is the absolute value of the difference of function
@@ -1588,9 +1590,9 @@ shiftfv < toldeltafv
             <listitem>
               <para>if the following condition</para>
 
-              <programlisting role="example"><![CDATA[ 
-newfvmean <= oldfvmean - alpha * sg' * sg
- ]]></programlisting>
+              <programlisting role="example"> 
+newfvmean &lt;= oldfvmean - alpha * sg' * sg
+ </programlisting>
 
               <para>is true where newfvmean (resp. oldfvmean) is the function
               value average in the current iteration (resp. in the previous
@@ -1632,9 +1634,9 @@ newfvmean <= oldfvmean - alpha * sg' * sg
           <para>in "Iterative Methods for Optimization", Kelley uses a
           normalized alpha, computed from the following formula</para>
 
-          <programlisting role="example"><![CDATA[ 
+          <programlisting role="example"> 
 alpha = alpha0 * sigma0 / nsg
- ]]></programlisting>
+ </programlisting>
 
           <para>where sigma0 is the size of the initial simplex and nsg is the
           norm of the simplex gradient for the initial guess point.</para>
@@ -1654,6 +1656,106 @@ alpha = alpha0 * sigma0 / nsg
   </refsection>
 
   <refsection>
+    <title>Example #1</title>
+
+    <para>In the following example, we solve the Rosenbrock test case. We
+    begin by defining the Rosenbrock function, which takes 2 input arguments
+    and returns the objective. The classical starting point [-1.2 1.0] is
+    used. The neldermead_new creates a new neldermead object. Then we use the
+    neldermead_configure method to configure the parameters of the problem.
+    The initial simplex is computed from the axes and the single length 1.0
+    (this is the default, but is explicitely written here as an example). The
+    variable simplex algorithm by Nelder and Mead is used, which corresponds
+    to the -method "variable" option. The neldermead_search function performs
+    the search for the minimum. Once the minimum is found, the
+    neldermead_contour allows to compute the data required by the contour
+    function. This is possible since our problem involves only 2 parameters.
+    This function uses the cost function previously configured to compute the
+    required data. The contour plot is directly drawn from the data provided
+    by neldermead_contour. Then we plot the initial guess on the contour plot
+    as a blue dot. The neldermead_get function is used to get the optimum,
+    which is associated with the -xopt option. The optimum is plot on the
+    contour plot as a red dot.</para>
+
+    <programlisting role="example">
+mprintf("Defining Rosenbrock function...\n");
+function y = rosenbrock (x)
+  y = 100*(x(2)-x(1)^2)^2+(1-x(1))^2;
+endfunction
+x0 = [-1.2 1.0]';
+mprintf("x0=%s\n",strcat(string(x0)," "));
+mprintf("Creating object...\n");
+nm = neldermead_new ();
+mprintf("Configuring object...\n");
+nm = neldermead_configure(nm,"-numberofvariables",2);
+nm = neldermead_configure(nm,"-function",rosenbrock);
+nm = neldermead_configure(nm,"-x0",x0);
+nm = neldermead_configure(nm,"-maxiter",200);
+nm = neldermead_configure(nm,"-maxfunevals",300);
+nm = neldermead_configure(nm,"-tolfunrelative",10*%eps);
+nm = neldermead_configure(nm,"-tolxrelative",10*%eps);
+nm = neldermead_configure(nm,"-simplex0method","axes");
+nm = neldermead_configure(nm,"-simplex0length",1.0);
+nm = neldermead_configure(nm,"-method","variable");
+nm = neldermead_configure(nm,"-verbose",0);
+nm = neldermead_configure(nm,"-verbosetermination",0);
+mprintf("Searching for minimum...\n");
+nm = neldermead_search(nm);
+mprintf("Plot contour...\n");
+[nm , xdata , ydata , zdata ] = neldermead_contour ( nm , xmin = -2.0 , xmax = 2.0 , ymin = -2.0 , ymax = 2.0 , nx = 100 , ny = 100 );
+wnum = 100001;
+my_handle             = scf(wnum);
+contour ( xdata , ydata , zdata , [1 10 100 500 1000 2000] )
+// Plot starting point
+mprintf("x0 : blue dot\n");
+plot(x0(1),x0(2));
+my_handle.children.children(1).children.mark_mode="on";
+my_handle.children.children(1).children.mark_size = 5;
+my_handle.children.children(1).children.mark_foreground = 2;
+mprintf("xopt : red dot\n");
+xopt = neldermead_get(nm,"-xopt");
+plot(xopt(1),xopt(2));
+my_handle.children.children(1).children.mark_mode="on";
+my_handle.children.children(1).children.mark_size = 5;
+my_handle.children.children(1).children.mark_foreground = 5;
+
+nm = neldermead_destroy(nm);
+</programlisting>
+
+    <para>The -verbose option allows to get detailed informations about the
+    current optimization process. The following is a sample output for an
+    optimization based on the Nelder and Mead variable-shape simplex
+    algorithm. Only the output corresponding to the iteration #156 is
+    displayed. In order to display specific outputs (or to create specific
+    output files and graphics), the -outputcommand option should be
+    used.</para>
+
+    <programlisting role="example">
+=================================================================
+Iteration #156 (total = 156)
+Function Eval #297
+Xopt : 1 1
+Fopt : 6.871176e-027
+DeltaFv : 2.880999e-026
+Center : 1 1
+Size : 2.548515e-013
+Vertex #1/3 : fv=0.000000, x=1.000000 1.000000
+Vertex #2/3 : fv=0.000000, x=1.000000 1.000000
+Vertex #3/3 : fv=0.000000, x=1.000000 1.000000
+nmplot_outputcmd (1)
+Reflect
+xbar=1 1
+Function Evaluation #298 is [1.155D-25] at [1 1]
+xr=[1 1], f(xr)=0.000000
+Contract - inside
+Function Evaluation #299 is [6.023D-27] at [1 1]
+xc=1 1, f(xc)=0.000000
+  &gt; Perform Inside Contraction
+Sort
+</programlisting>
+  </refsection>
+
+  <refsection>
     <title>TODO</title>
 
     <variablelist>
@@ -1663,20 +1765,19 @@ alpha = alpha0 * sigma0 / nsg
         <listitem>
           <para>add the Box-Guin algoritm as a 4th method</para>
 
-              <para>
-                This algorithm solves an constrained optimization problem with
-                a variable sized simplex made of an arbitrary k number of vertices.
-                This is an update of Box's algorithm.
-              </para>
+          <para>This algorithm solves an constrained optimization problem with
+          a variable sized simplex made of an arbitrary k number of vertices.
+          This is an update of Box's algorithm.</para>
         </listitem>
       </varlistentry>
 
       <varlistentry>
-        <term>add examples</term>
+        <term>add the optimization of the Rosenbrock test case, with the
+        interactive plot thanks to the -outputcommand option</term>
+      </varlistentry>
 
-        <listitem>
-          <para>add the optimization of the Rosenbrock test case</para>
-        </listitem>
+      <varlistentry>
+        <term>add a sample output with the verbose option.</term>
       </varlistentry>
     </variablelist>
   </refsection>
@@ -1716,16 +1817,16 @@ alpha = alpha0 * sigma0 / nsg
 
     <para>Michael Baudin, 2008-2009</para>
   </refsection>
+
   <refsection>
     <title>See Also</title>
 
     <simplelist type="inline">
-      <member>
-        <link linkend="optimbase">optimbase</link>
-      </member>
-      <member>
-        <link linkend="optimsimplex">optimsimplex</link>
-      </member>
+      <member><link linkend="optimbase">optimbase</link></member>
+
+      <member><link linkend="optimsimplex">optimsimplex</link></member>
+
+      <member><link linkend="optimsimplex">nmplot</link></member>
     </simplelist>
   </refsection>
 </refentry>
diff --git a/scilab/modules/optimization/help/en_US/neldermead/nmplot.xml b/scilab/modules/optimization/help/en_US/neldermead/nmplot.xml
new file mode 100644 (file)
index 0000000..afc0bb2
--- /dev/null
@@ -0,0 +1,1351 @@
+<?xml version="1.0" encoding="ISO-8859-1"?>
+<!--
+ * Ajouter ici d'éventuels commentaires sur le fichier XML
+-->
+<refentry version="5.0-subset Scilab" xml:id="nmplot" xml:lang="fr"
+          xmlns="http://docbook.org/ns/docbook"
+          xmlns:xlink="http://www.w3.org/1999/xlink"
+          xmlns:svg="http://www.w3.org/2000/svg"
+          xmlns:ns4="http://www.w3.org/1999/xhtml"
+          xmlns:mml="http://www.w3.org/1998/Math/MathML"
+          xmlns:db="http://docbook.org/ns/docbook">
+  <info>
+    <pubdate>$LastChangedDate: 16-12-2008 $</pubdate>
+  </info>
+
+  <refnamediv>
+    <refname>nmplot</refname>
+
+    <refpurpose>Provides several direct search optimization algorithms based
+    on the simplex method.</refpurpose>
+  </refnamediv>
+
+  <refsynopsisdiv>
+    <title>SYNOPSIS</title>
+
+    <synopsis>
+newobj = nmplot_new ()
+this = nmplot_destroy (this)
+this = nmplot_configure (this,key,value)
+value = nmplot_cget (this,key)
+this = nmplot_display ( this )
+value = nmplot_get ( this , key )
+this = nmplot_search ( this )
+this = nmplot_restart ( this )
+[ this , xdata , ydata , zdata ] = nmplot_contour ( this , xmin , xmax , ymin , ymax , nx , ny )
+this = nmplot_historyplot ( this , datafile  , mytitle , myxlabel , myylabel )
+this = nmplot_simplexhistory ( this , colorforeground , markforeground , markstyle )
+</synopsis>
+  </refsynopsisdiv>
+
+  <refsection>
+    <title>Description</title>
+
+    <para>This class provides several direct search optimization algorithms
+    based on the simplex method.</para>
+
+    <para>The goal of this class is to provide a neldermead component with
+    plotting features. It enables to make fast plots of the algorithm progress
+    through the iterations. </para>
+
+    <para>It is a specialized neldermead class, with a specific output
+    command. This output function allows to store the history of several datas
+    through the iterations of the algorithm. These datas are :</para>
+
+    <itemizedlist>
+      <listitem>
+        <para>the history of the coordinates of the simplex ,</para>
+      </listitem>
+
+      <listitem>
+        <para>the history of the function value (averaged on the
+        vertices),</para>
+      </listitem>
+
+      <listitem>
+        <para>the history of the minimum function value in the simplex,</para>
+      </listitem>
+
+      <listitem>
+        <para>the history of the size of the simplex (as computed with the
+        sigma+ method).</para>
+      </listitem>
+    </itemizedlist>
+
+    <para>These data are stored into several data files during the
+    optimization process. Several methods allows to plot the data stored into
+    these data files.</para>
+  </refsection>
+
+  <refsection>
+    <title>Design</title>
+
+    <para>The nmplot component is built on top of the <link
+    linkend="optimbase">neldermead</link> component. The -outputcommand option
+    (of the neldermead class) is not available since the nmplot class uses its
+    own output function. Additionnal options -simplexfn, -fbarfn, -foptfn and
+    -sigmafn are provided, which allows to configure the file names where the
+    data is stored.</para>
+
+    <para>The nmplot class can be considered as a sample test case of the
+    -outputcommand option of the neldermead class. It gives an example of the
+    situation where the user wants to get specialized outputs out of the
+    neldermead class.</para>
+  </refsection>
+
+  <refsection>
+    <title>Functions</title>
+
+    <para>The following functions are available.</para>
+
+    <variablelist>
+      <varlistentry>
+        <term>newobj = nmplot_new ()</term>
+
+        <listitem>
+          <para>Creates a new nmplot object.</para>
+
+          <variablelist>
+            <varlistentry>
+              <term>newobj</term>
+
+              <listitem>
+                <para>The new object.</para>
+              </listitem>
+            </varlistentry>
+          </variablelist>
+        </listitem>
+      </varlistentry>
+
+      <varlistentry>
+        <term>this = nmplot_destroy (this)</term>
+
+        <listitem>
+          <para>Destroy the given object.</para>
+
+          <variablelist>
+            <varlistentry>
+              <term>this</term>
+
+              <listitem>
+                <para>The current object.</para>
+              </listitem>
+            </varlistentry>
+          </variablelist>
+        </listitem>
+      </varlistentry>
+
+      <varlistentry>
+        <term>this = nmplot_configure (this,key,value)</term>
+
+        <listitem>
+          <para>Configure the current object with the given value for the
+          given key.</para>
+
+          <variablelist>
+            <varlistentry>
+              <term>this</term>
+
+              <listitem>
+                <para>The current object.</para>
+              </listitem>
+            </varlistentry>
+
+            <varlistentry>
+              <term>key</term>
+
+              <listitem>
+                <para>the key to configure. The following keys are
+                available.</para>
+
+                <variablelist>
+                  <varlistentry>
+                    <term>-verbose</term>
+
+                    <listitem>
+                      <para>set to 1 to enable verbose logging. (default is
+                      0)</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-verbosetermination</term>
+
+                    <listitem>
+                      <para>set to 1 to enable verbose termination logging.
+                      (default is 0)</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-x0</term>
+
+                    <listitem>
+                      <para>the initial guess, as a n x 1 column vector, where
+                      n is the number of variables.</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-maxfunevals</term>
+
+                    <listitem>
+                      <para>the maximum number of function evalutations
+                      (default is 100). If this criteria is triggered, the
+                      status of the optimization is set to
+                      "maxfuneval".</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-maxiter</term>
+
+                    <listitem>
+                      <para>the maximum number of iterations (default is 100).
+                      If this criteria is triggered, the status of the
+                      optimization is set to "maxiter".</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-tolfunabsolute</term>
+
+                    <listitem>
+                      <para>the absolute tolerance for the function value
+                      (default is 0.0).</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-tolfunrelative</term>
+
+                    <listitem>
+                      <para>the relative tolerance for the function value
+                      (default is %eps).</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-tolfunmethod</term>
+
+                    <listitem>
+                      <para>the method used for the tolerance on function
+                      value in the termination criteria.</para>
+
+                      <para>The following values are available :
+                      "absolute+relative", "relative", "absolute", "disabled"
+                      (default is "disabled"). If this criteria is triggered,
+                      the status of the optimization is set to "tolf".</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-tolxabsolute</term>
+
+                    <listitem>
+                      <para>the absolute tolerance on x (default is
+                      0.0).</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-tolxrelative</term>
+
+                    <listitem>
+                      <para>the relative tolerance on x (default is
+                      %eps).</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-tolxmethod</term>
+
+                    <listitem>
+                      <para>the method used for the tolerance on x in the
+                      termination criteria.</para>
+
+                      <para>The following values are available : "relative",
+                      "absolute", "disabled" (default is "relative"). If this
+                      criteria is triggered, the status of the optimization is
+                      set to "tolx".</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-function</term>
+
+                    <listitem>
+                      <para>the objective function, which computes the value
+                      of the cost and the non linear constraints, if
+                      any.</para>
+
+                      <para>See below for the details of the communication
+                      between the optimization system and the cost
+                      function.</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-costfargument</term>
+
+                    <listitem>
+                      <para>an additionnal argument, passed to the cost
+                      function.</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-outputcommand</term>
+
+                    <listitem>
+                      <para>a command which is called back for output.</para>
+
+                      <para>See below for the details of the communication
+                      between the optimization system and the output command
+                      function.</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-outputcommandarg</term>
+
+                    <listitem>
+                      <para>an additionnal argument, passed to the output
+                      command.</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-numberofvariables</term>
+
+                    <listitem>
+                      <para>the number of variables to optimize (default is
+                      0).</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-storehistory</term>
+
+                    <listitem>
+                      <para>set to 1 to enable the history storing (default is
+                      0).</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-boundsmin</term>
+
+                    <listitem>
+                      <para>the minimum bounds for the parameters, as an array
+                      of values (default is empty, i.e. there are no
+                      bounds).</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-boundsmax</term>
+
+                    <listitem>
+                      <para>the maximum bounds for the parameters, as an array
+                      of values (default is empty, i.e. there are no
+                      bounds).</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-nbineqconst</term>
+
+                    <listitem>
+                      <para>the number of inequality constraints (default is
+                      0)</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-method</term>
+
+                    <listitem>
+                      <para>the name of the algorithm to use. The following
+                      methods are available :</para>
+
+                      <variablelist>
+                        <varlistentry>
+                          <term>"fixed"</term>
+
+                          <listitem>
+                            <para>the Spendley et al. fixed simplex shape
+                            algorithm. This algorithm is for unconstrained
+                            problems (i.e. bounds and non linear constraints are
+                            not taken into account)</para>
+                          </listitem>
+                        </varlistentry>
+
+                        <varlistentry>
+                          <term>"variable"</term>
+
+                          <listitem>
+                            <para>the Nelder-Mead variable simplex shape
+                            algorithm. This algorithm is for unconstrained
+                            problems (i.e. bounds and non linear constraints are
+                            not taken into account)</para>
+                          </listitem>
+                        </varlistentry>
+
+                        <varlistentry>
+                          <term>"box"</term>
+
+                          <listitem>
+                            <para>the Box complex algorithm. This algorithm
+                            takes into account bounds and nonlinear inequality
+                            constraints.</para>
+                          </listitem>
+                        </varlistentry>
+                      </variablelist>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-simplex0method</term>
+
+                    <listitem>
+                      <para>the method to use to compute the initial simplex.
+                      The first vertex in the simplex is always the initial
+                      guess associated with the -x0 option. The following
+                      methods are available :</para>
+
+                      <variablelist>
+                        <varlistentry>
+                          <term>"given"</term>
+
+                          <listitem>
+                            <para>the coordinates associated with the -coords0
+                            option are used to compute the initial simplex, with
+                            arbitrary number of vertices.</para>
+
+                            <para>This allow the user to setup the initial
+                            simplex by a specific method which is not provided
+                            by the current component (for example with a simplex
+                            computed from a design of experiments). This allows
+                            also to configure the initial simplex so that a
+                            specific behaviour of the algorithm an be reproduced
+                            (for example the Mac Kinnon test case).</para>
+
+                            <para>The given matrix is expected to have n rows
+                            and k columns, where n is the dimension of the
+                            problem and k is the number of vertices.</para>
+                          </listitem>
+                        </varlistentry>
+
+                        <varlistentry>
+                          <term>"axes"</term>
+
+                          <listitem>
+                            <para>the simplex is computed from the coordinate
+                            axes and the length associated with the
+                            -simplex0length option.</para>
+                          </listitem>
+                        </varlistentry>
+
+                        <varlistentry>
+                          <term>"spendley"</term>
+
+                          <listitem>
+                            <para>the simplex is computed so that it is regular
+                            with the length associated with the -simplex0length
+                            option (i.e. all the edges have the same
+                            length).</para>
+                          </listitem>
+                        </varlistentry>
+
+                        <varlistentry>
+                          <term>"pfeffer"</term>
+
+                          <listitem>
+                            <para>the simplex is computed from an heuristic, in
+                            the neighborhood of the initial guess. This initial
+                            simplex depends on the -simplex0deltausual and
+                            -simplex0deltazero.</para>
+                          </listitem>
+                        </varlistentry>
+
+                        <varlistentry>
+                          <term>"randbounds"</term>
+
+                          <listitem>
+                            <para>the simplex is computed from the bounds and a
+                            random number. This option is available only if
+                            bounds are available : if bounds are not available,
+                            an error is generated. This method is usually
+                            associated with Box's algorithm. The number of
+                            vertices in the simplex is taken from the
+                            -boxnbpoints option.</para>
+                          </listitem>
+                        </varlistentry>
+                      </variablelist>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-coords0</term>
+
+                    <listitem>
+                      <para>the coordinates of the vertices of the initial
+                      simplex. If the -simplex0method option is set to
+                      "given", these coordinates are used to compute the
+                      initial simplex. This matrix is expected to have shape
+                      nbve x n where nbve is the number of vertices and n is
+                      the number of variables.</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-simplex0length</term>
+
+                    <listitem>
+                      <para>the length to use when the initial simplex is
+                      computed with the "axes" or "spendley" methods. If the
+                      initial simplex is computed from "spendley" method, the
+                      length is expected to be a scalar value. If the initial
+                      simplex is computed from "axes" method, it may be either
+                      a scalar value or a vector of values, with rank n, where
+                      n is the number of variables.</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-simplex0deltausual</term>
+
+                    <listitem>
+                      <para>the relative delta for non-zero parameters in
+                      "pfeffer" method. The default value is 0.05.</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-simplex0deltazero</term>
+
+                    <listitem>
+                      <para>the absolute delta for non-zero parameters in
+                      "pfeffer" method. The default value is 0.0075.</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-rho</term>
+
+                    <listitem>
+                      <para>the reflection coefficient. This parameter is used
+                      when the -method option is set to "fixed" or "variable".
+                      The default value is 1.0.</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-chi</term>
+
+                    <listitem>
+                      <para>the expansion coefficient. This parameter is used
+                      when the -method option is set to "variable". The
+                      default value is 2.0.</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-gamma</term>
+
+                    <listitem>
+                      <para>the contraction coefficient. This parameter is
+                      used when the -method option is set to "variable". The
+                      default value is 0.5.</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-sigma</term>
+
+                    <listitem>
+                      <para>the shrinkage coefficient. This parameter is used
+                      when the -method option is set to "fixed" or "variable".
+                      The default value is 0.5.</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-tolfstdeviationmethod</term>
+
+                    <listitem>
+                      <para>set to "enabled" to enable the termination
+                      criteria based on the standard deviation of the function
+                      values in the simplex. The default value is "disabled".
+                      If this criteria is triggered, the status of the
+                      optimization is set to "tolfstdev".</para>
+
+                      <para>This criteria is suggested by Nelder and
+                      Mead.</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-tolfstdeviation</term>
+
+                    <listitem>
+                      <para>the absolute tolerance on standard deviation. The
+                      default value is 0.0.</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-tolsimplexizemethod</term>
+
+                    <listitem>
+                      <para>set to "disabled" to disable the tolerance on the
+                      simplex size. The default value is "enabled". If this
+                      criteria is triggered, the status of the optimization is
+                      set to "tolsize".</para>
+
+                      <para>When this criteria is enabled, the values of the
+                      options -tolsimplexizeabsolute and
+                      -tolsimplexizerelative are used in the termination
+                      criteria. The method to compute the size is the
+                      "sigmaplus" method.</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-tolsimplexizeabsolute</term>
+
+                    <listitem>
+                      <para>the absolute tolerance on the simplex size. The
+                      default value is 0.0.</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-tolsimplexizerelative</term>
+
+                    <listitem>
+                      <para>the relative tolerance on the simplex size. The
+                      default value is %eps.</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-tolssizedeltafvmethod</term>
+
+                    <listitem>
+                      <para>set to "enabled" to enable the termination
+                      criteria based on the size of the simplex and the
+                      difference of function value in the simplex. The default
+                      value is "disabled". If this criteria is triggered, the
+                      status of the optimization is set to
+                      "tolsizedeltafv".</para>
+
+                      <para>This termination criteria uses the values of the
+                      options -tolsimplexizeabsolute and -toldeltafv. This
+                      criteria is identical to Matlab's fminsearch.</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-toldeltafv</term>
+
+                    <listitem>
+                      <para>the absolute tolerance on the difference between
+                      the highest and the lowest function values.</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-kelleystagnationflag</term>
+
+                    <listitem>
+                      <para>set to 1 to enable the termination criteria using
+                      Kelley's stagnation detection, based on sufficient
+                      decrease condition. The default value is 0. If this
+                      criteria is triggered, the status of the optimization is
+                      set to "kelleystagnation".</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-kelleynormalizationflag</term>
+
+                    <listitem>
+                      <para>set to 0 to disable the normalization of the alpha
+                      coefficient in Kelley's stagnation detection, i.e. use
+                      the value of the option -kelleystagnationalpha0 as is.
+                      Default value is 1, i.e. the simplex gradient of the
+                      initial simplex is taken into account in the stagnation
+                      detection.</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-kelleystagnationalpha0</term>
+
+                    <listitem>
+                      <para>the parameter used in Kelley's stagnation
+                      detection. The default value is 1.e-4.</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-restartflag</term>
+
+                    <listitem>
+                      <para>set to 1 to enable the automatic restart of the
+                      algorithm. Default value is 0.</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-restartdetection</term>
+
+                    <listitem>
+                      <para>the method to detect if the automatic restart must
+                      be performed. The following methods are available
+                      :</para>
+
+                      <variablelist>
+                        <varlistentry>
+                          <term>"oneill"</term>
+
+                          <listitem>
+                            <para>the factorial local optimality test by O'Neill
+                            is used. If the test finds a local point which is
+                            better than the computed optimum, a restart is
+                            performed.</para>
+                          </listitem>
+                        </varlistentry>
+
+                        <varlistentry>
+                          <term>"kelley"</term>
+
+                          <listitem>
+                            <para>the sufficient decrease condition by O'Neill
+                            is used. If the test finds that the status of the
+                            optimization is "kelleystagnation", a restart is
+                            performed. This status may be generated if the
+                            -kelleystagnationflag option is set to 1.</para>
+                          </listitem>
+                        </varlistentry>
+                      </variablelist>
+
+                      <para>The default method is "oneill".</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-restartmax</term>
+
+                    <listitem>
+                      <para>the maximum number of restarts, when automatic
+                      restart is enabled via the -restartflag option. Default
+                      value is 3.</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-restarteps</term>
+
+                    <listitem>
+                      <para>the absolute epsilon value used to check for
+                      optimality in the factorial O'Neill restart detection.
+                      The default value is %eps.</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-restartstep</term>
+
+                    <listitem>
+                      <para>the absolute step length used to check for
+                      optimality in the factorial O'Neill restart detection.
+                      The default value is 1.0.</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-restartsimplexmethod</term>
+
+                    <listitem>
+                      <para>the method to compute the initial simplex after a
+                      restart. The following methods are available.</para>
+
+                      <variablelist>
+                        <varlistentry>
+                          <term>"given"</term>
+
+                          <listitem>
+                            <para>the coordinates associated with the -coords0
+                            option are used to compute the initial simplex, with
+                            arbitrary number of vertices.</para>
+
+                            <para>This allow the user to setup the initial
+                            simplex by a specific method which is not provided
+                            by the current component (for example with a simplex
+                            computed from a design of experiments). This allows
+                            also to configure the initial simplex so that a
+                            specific behaviour of the algorithm an be reproduced
+                            (for example the Mac Kinnon test case).</para>
+
+                            <para>The given matrix is expected to have n rows
+                            and k columns, where n is the dimension of the
+                            problem and k is the number of vertices.</para>
+                          </listitem>
+                        </varlistentry>
+
+                        <varlistentry>
+                          <term>"axes"</term>
+
+                          <listitem>
+                            <para>the simplex is computed from the coordinate
+                            axes and the length associated with the
+                            -simplex0length option.</para>
+                          </listitem>
+                        </varlistentry>
+
+                        <varlistentry>
+                          <term>"spendley"</term>
+
+                          <listitem>
+                            <para>the simplex is computed so that it is regular
+                            with the length associated with the -simplex0length
+                            option (i.e. all the edges have the same
+                            length).</para>
+                          </listitem>
+                        </varlistentry>
+
+                        <varlistentry>
+                          <term>"pfeffer"</term>
+
+                          <listitem>
+                            <para>the simplex is computed from an heuristic, in
+                            the neighborhood of the initial guess. This initial
+                            simplex depends on the -simplex0deltausual and
+                            -simplex0deltazero.</para>
+                          </listitem>
+                        </varlistentry>
+
+                        <varlistentry>
+                          <term>"randbounds"</term>
+
+                          <listitem>
+                            <para>the simplex is computed from the bounds and a
+                            random number. This option is available only if
+                            bounds are available : if bounds are not available,
+                            an error is generated. This method is usually
+                            associated with Box's algorithm. The number of
+                            vertices in the simplex is taken from the
+                            -boxnbpoints option.</para>
+                          </listitem>
+                        </varlistentry>
+
+                        <varlistentry>
+                          <term>"oriented"</term>
+
+                          <listitem>
+                            <para>the simplex is computed so that it is
+                            oriented, as suggested by C.T. Kelley.</para>
+                          </listitem>
+                        </varlistentry>
+                      </variablelist>
+
+                      <para>The default method is "oriented".</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-boxnbpoints</term>
+
+                    <listitem>
+                      <para>the number of points in the initial simplex, when
+                      the -restartsimplexmethod option is set to "randbounds".
+                      The default value is so that the number of points is
+                      twice the number of variables of the problem.</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-nbineqloops</term>
+
+                    <listitem>
+                      <para>the number of loops to perform in Box and Box-Guin
+                      algorithms to scale the trial point for function
+                      improvement or into the constraints. Default value is
+                      10.</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-ineqscaling</term>
+
+                    <listitem>
+                      <para>the scaling coefficient used to scale the trial
+                      point for function improvement or into the constraints.
+                      Default value is 0.5</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-simplexfn</term>
+
+                    <listitem>
+                      <para>the name of the file containing the history of the
+                      simplex. Default value is the empty string.</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-fbarfn</term>
+
+                    <listitem>
+                      <para>the name of the file containing the history of the
+                      function value, averaged on the vertices of the simplex.
+                      Default value is the empty string.</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-foptfn</term>
+
+                    <listitem>
+                      <para>the name of the file containing the history of the
+                      minimum function value in the simplex. Default value is
+                      the empty string.</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-sigmafn</term>
+
+                    <listitem>
+                      <para>the name of the file containing the history of the
+                      size of the simplex. Default value is the empty
+                      string.</para>
+                    </listitem>
+                  </varlistentry>
+                </variablelist>
+              </listitem>
+            </varlistentry>
+
+            <varlistentry>
+              <term>value</term>
+
+              <listitem>
+                <para>the value.</para>
+              </listitem>
+            </varlistentry>
+          </variablelist>
+        </listitem>
+      </varlistentry>
+
+      <varlistentry>
+        <term>value = nmplot_cget (this,key)</term>
+
+        <listitem>
+          <para>Get the value for the given key. If the key is unknown,
+          generates an error.</para>
+
+          <variablelist>
+            <varlistentry>
+              <term>this</term>
+
+              <listitem>
+                <para>The current object.</para>
+              </listitem>
+            </varlistentry>
+
+            <varlistentry>
+              <term>key</term>
+
+              <listitem>
+                <para>the name of the key to quiery. The list of available
+                keys is the same as for the nmplot_configure function.</para>
+              </listitem>
+            </varlistentry>
+          </variablelist>
+        </listitem>
+      </varlistentry>
+
+      <varlistentry>
+        <term>value = nmplot_get ( this , key )</term>
+
+        <listitem>
+          <para>Get the value for the given key. If the key is unknown,
+          generates an error.</para>
+
+          <variablelist>
+            <varlistentry>
+              <term>this</term>
+
+              <listitem>
+                <para>The current object.</para>
+              </listitem>
+            </varlistentry>
+
+            <varlistentry>
+              <term>key</term>
+
+              <listitem>
+                <para>the key to get.</para>
+
+                <para>The following keys are available :</para>
+
+                <variablelist>
+                  <varlistentry>
+                    <term>-funevals</term>
+
+                    <listitem>
+                      <para>the number of function evaluations</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-iterations</term>
+
+                    <listitem>
+                      <para>the number of iterations</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-xopt</term>
+
+                    <listitem>
+                      <para>the x optimum, as a n x 1 column vector, where n
+                      is the number of variables.</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-fopt</term>
+
+                    <listitem>
+                      <para>the optimum cost function value</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-historyxopt</term>
+
+                    <listitem>
+                      <para>an array, with nbiter values, containing the
+                      history of x during the iterations.</para>
+
+                      <para>This array is available after optimization if the
+                      history storing was enabled with the -storehistory
+                      option.</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-historyfopt</term>
+
+                    <listitem>
+                      <para>an array, with nbiter values, containing the
+                      history of the function value during the
+                      iterations.</para>
+
+                      <para>This array is available after optimization if the
+                      history storing was enabled with the -storehistory
+                      option.</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-fx0</term>
+
+                    <listitem>
+                      <para>the function value for the initial guess</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-status</term>
+
+                    <listitem>
+                      <para>a string containing the status of the
+                      optimization. See below for details about the
+                      optimization status.</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-historysimplex</term>
+
+                    <listitem>
+                      <para>a matrix containing the history of the simplex
+                      during the iterations. This matrix has rank nbiter x
+                      nbve x n, where nbiter is the number of iterations, nbve
+                      is the number of vertices in the simplex and n is the
+                      number of variables.</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-simplexopt</term>
+
+                    <listitem>
+                      <para>the optimum simplex. This is a simplex object,
+                      which is suitable for processing with the simplex
+                      interface.</para>
+                    </listitem>
+                  </varlistentry>
+
+                  <varlistentry>
+                    <term>-restartnb</term>
+
+                    <listitem>
+                      <para>the number of actual restarts performed.</para>
+                    </listitem>
+                  </varlistentry>
+                </variablelist>
+
+                <para>Most fields are available only after an optimization has
+                been performed with one call to the neldermead_search
+                method.</para>
+              </listitem>
+            </varlistentry>
+          </variablelist>
+        </listitem>
+      </varlistentry>
+
+      <varlistentry>
+        <term>this = nmplot_display ( this )</term>
+
+        <listitem>
+          <para>Display the current settings in the console.</para>
+
+          <variablelist>
+            <varlistentry>
+              <term>this</term>
+
+              <listitem>
+                <para>The current object.</para>
+              </listitem>
+            </varlistentry>
+          </variablelist>
+        </listitem>
+      </varlistentry>
+
+      <varlistentry>
+        <term>this = nmplot_search ( this )</term>
+
+        <listitem>
+          <para>Performs the optimization associated with the method
+          associated with the -method option and find the optimum.</para>
+
+          <variablelist>
+            <varlistentry>
+              <term>this</term>
+
+              <listitem>
+                <para>The current object.</para>
+              </listitem>
+            </varlistentry>
+          </variablelist>
+
+          <para>If the -restartflag option is enabled, automatic restarts are
+          performed, based on the -restartdetection option.</para>
+        </listitem>
+      </varlistentry>
+
+      <varlistentry>
+        <term>this = nmplot_restart ( this )</term>
+
+        <listitem>
+          <para>Restarts the optimization by updating the simplex and
+          performing a new search.</para>
+
+          <variablelist>
+            <varlistentry>
+              <term>this</term>
+
+              <listitem>
+                <para>The current object.</para>
+              </listitem>
+            </varlistentry>
+          </variablelist>
+        </listitem>
+      </varlistentry>
+
+      <varlistentry>
+        <term>[ this , xdata , ydata , zdata ] = nmplot_contour ( this , xmin
+        , xmax , ymin , ymax , nx , ny )</term>
+
+        <listitem>
+          <para>Plot the contours of the cost function. The cost function must
+          be a function with two parameters.</para>
+
+          <variablelist>
+            <varlistentry>
+              <term>this</term>
+
+              <listitem>
+                <para>The current object.</para>
+              </listitem>
+            </varlistentry>
+
+            <varlistentry>
+              <term>xmin , xmax , ymin , ymax</term>
+
+              <listitem>
+                <para>the bounds for the contour plot</para>
+              </listitem>
+            </varlistentry>
+
+            <varlistentry>
+              <term>nx , ny</term>
+
+              <listitem>
+                <para>the number of points in the directions x, y</para>
+              </listitem>
+            </varlistentry>
+
+            <varlistentry>
+              <term>xdata , ydata , zdata</term>
+
+              <listitem>
+                <para>vectors of data, as required by the contour
+                function</para>
+              </listitem>
+            </varlistentry>
+          </variablelist>
+        </listitem>
+      </varlistentry>
+
+      <varlistentry>
+        <term>nmplot_simplexhistory ( this , colorforeground , markforeground
+        , markstyle )</term>
+
+        <listitem>
+          <para>Plots the simplex history on the current graphic window. The
+          colorforeground , markforeground , markstyle options are provided to
+          produce fast plots. Specific settings can still be applied with the
+          usual graphic features.</para>
+
+          <variablelist>
+            <varlistentry>
+              <term>this</term>
+
+              <listitem>
+                <para>The current object.</para>
+              </listitem>
+            </varlistentry>
+
+            <varlistentry>
+              <term>colorforeground</term>
+
+              <listitem>
+                <para>the color of the foreground for the simplices. Default
+                value is 5.</para>
+              </listitem>
+            </varlistentry>
+
+            <varlistentry>
+              <term>markforeground</term>
+
+              <listitem>
+                <para>the foreground mark for the simplices. Default value is
+                3.</para>
+              </listitem>
+            </varlistentry>
+
+            <varlistentry>
+              <term>markstyle</term>
+
+              <listitem>
+                <para>the mark style for the simplices. Default value is
+                9.</para>
+              </listitem>
+            </varlistentry>
+          </variablelist>
+        </listitem>
+      </varlistentry>
+
+      <varlistentry>
+        <term>nmplot_historyplot ( this , datafile , mytitle , myxlabel ,
+        myylabel )</term>
+
+        <listitem>
+          <para>Plots the history from the given data file on the current
+          graphic window. The mytitle, myxlabel, myylabel options are provided
+          as a way to produce plots faster. Specific settings can still be
+          applied with the usual graphic features.</para>
+
+          <variablelist>
+            <varlistentry>
+              <term>this</term>
+
+              <listitem>
+                <para>The current object.</para>
+              </listitem>
+            </varlistentry>
+
+            <varlistentry>
+              <term>datafile</term>
+
+              <listitem>
+                <para>the data file which contains the history. The file is
+                expected to be formatted in a way similar to the files
+                associated with the -fbarfn, -foptfn and -sigmafn files. The
+                default value is the value of the -foptfn option.</para>
+              </listitem>
+            </varlistentry>
+
+            <varlistentry>
+              <term>mytitle</term>
+
+              <listitem>
+                <para>the title of the plot. Default value is the empty
+                string.</para>
+              </listitem>
+            </varlistentry>
+
+            <varlistentry>
+              <term>myxlabel</term>
+
+              <listitem>
+                <para>the x label for the plot. Default value is the empty
+                string.</para>
+              </listitem>
+            </varlistentry>
+
+            <varlistentry>
+              <term>myylabel</term>
+
+              <listitem>
+                <para>the y label for the plot. Default value is the empty
+                string.</para>
+              </listitem>
+            </varlistentry>
+          </variablelist>
+        </listitem>
+      </varlistentry>
+    </variablelist>
+  </refsection>
+
+  <refsection>
+    <title>TODO</title>
+  </refsection>
+
+  <refsection>
+    <title>Bibliography</title>
+  </refsection>
+
+  <refsection>
+    <title>Authors</title>
+
+    <para>Michael Baudin, 2008-2009</para>
+  </refsection>
+
+  <refsection>
+    <title>See Also</title>
+
+    <simplelist type="inline">
+      <member><link linkend="optimbase">neldermead</link></member>
+    </simplelist>
+  </refsection>
+</refentry>
index e09f5b0..4fce9e5 100644 (file)
@@ -41,7 +41,7 @@ fv = optimsimplex_getallfv ( this )
 x = optimsimplex_getallx ( this )
 fv = optimsimplex_getfv ( this , ive )
 n = optimsimplex_getn ( this )
-n = optimsimplex_getnbve ( this )
+nbve = optimsimplex_getnbve ( this )
 vertex = optimsimplex_getve ( this , ive )
 x = optimsimplex_getx ( this , ive )
 sicenter = optimsimplex_center ( this )
@@ -68,30 +68,30 @@ cen = optimsimplex_xbar ( this , iexcl )</synopsis>
   <refsection>
     <title>Purpose</title>
 
-    <para>
-      The goal of this component is to provide a building block for
-      optimization algorithms based on a simplex. The optimsimplex package may
-      be used in the following optimization methods :</para>
+    <para>The goal of this component is to provide a building block for
+    optimization algorithms based on a simplex. The optimsimplex package may
+    be used in the following optimization methods :</para>
+
     <itemizedlist>
-        <listitem>
-          <para>the Spendley et al. simplex method,</para>
-        </listitem>
+      <listitem>
+        <para>the Spendley et al. simplex method,</para>
+      </listitem>
 
-        <listitem>
-          <para>the Nelder-Mead method,</para>
-        </listitem>
+      <listitem>
+        <para>the Nelder-Mead method,</para>
+      </listitem>
 
-        <listitem>
-          <para>the Box algorithm for constrained optimization,</para>
-        </listitem>
+      <listitem>
+        <para>the Box algorithm for constrained optimization,</para>
+      </listitem>
 
-        <listitem>
-          <para>the multi-dimensional search by Virginia Torczon,</para>
-        </listitem>
+      <listitem>
+        <para>the multi-dimensional search by Virginia Torczon,</para>
+      </listitem>
 
-        <listitem>
-          <para>etc ...</para>
-        </listitem>
+      <listitem>
+        <para>etc ...</para>
+      </listitem>
     </itemizedlist>
   </refsection>
 
@@ -177,14 +177,37 @@ cen = optimsimplex_xbar ( this , iexcl )</synopsis>
     simplex gradient can be computed with a order 1 forward formula and with a
     order 2 centered formula.</para>
 
-    <para>The optimsimplex_new function allows to create a simplex. If vertices
-    coordinates are given, there are registered in the simplex. If a function
-    is provided, it is evaluated at each vertex. The optimsimplex_destroy function
-    destroys the object and frees internal memory. Several functions allow to
-    create a simplex with special shapes, including axes-by-axes
-    (optimsimplex_axes), regular (optimsimplex_spendley), randomized bounds simplex with
-    arbitrary k vertices (optimsimplex_randbounds) and an heuristical small
-    variation around a given point (optimsimplex_pfeffer).</para>
+    <para>The optimsimplex_new function allows to create a simplex. If
+    vertices coordinates are given, there are registered in the simplex. If a
+    function is provided, it is evaluated at each vertex. The
+    optimsimplex_destroy function destroys the object and frees internal
+    memory. Several functions allow to create a simplex with special shapes,
+    including axes-by-axes (optimsimplex_axes), regular
+    (optimsimplex_spendley), randomized bounds simplex with arbitrary nbve
+    vertices (optimsimplex_randbounds) and an heuristical small variation
+    around a given point (optimsimplex_pfeffer).</para>
+
+    <para>In the following functions, simplices and vertices are, depending on
+    the functions either input or output arguments. The following general
+    principle have been used to manage the storing of the coordinates of the
+    points. </para>
+
+    <itemizedlist>
+      <listitem>
+        <para>The vertices are stored row by row, while the coordinates are
+        stored column by column. This implies the following rules.</para>
+      </listitem>
+
+      <listitem>
+        <para>The coordinates of a vertex are stored in a row vector, i.e. a 1
+        x n matrix where n is the dimension of the space.</para>
+      </listitem>
+
+      <listitem>
+        <para>The function values are stored in a column vector, i.e. a nbve x
+        1 matrix where nbve is the number of vertices.</para>
+      </listitem>
+    </itemizedlist>
   </refsection>
 
   <refsection>
@@ -194,7 +217,8 @@ cen = optimsimplex_xbar ( this , iexcl )</synopsis>
 
     <variablelist>
       <varlistentry>
-        <term>[ newobj , data ] = optimsimplex_new ( coords , fun , data )</term>
+        <term>[ newobj , data ] = optimsimplex_new ( coords , fun , data
+        )</term>
 
         <listitem>
           <para>Creates a new simplex object. All input arguments are
@@ -217,9 +241,9 @@ cen = optimsimplex_xbar ( this , iexcl )</synopsis>
                 <para>optional, matrix of point coordinates in the
                 simplex.</para>
 
-                <para>The coords matrix is expected to be a n x k matrix,
-                where n is the dimension of the space and k is the number of
-                vertices in the simplex, with k&gt;= n+1.</para>
+                <para>The coords matrix is expected to be a nbve x n matrix,
+                where n is the dimension of the space and nbve is the number
+                of vertices in the simplex, with nbve&gt;= n+1.</para>
               </listitem>
             </varlistentry>
 
@@ -232,9 +256,9 @@ cen = optimsimplex_xbar ( this , iexcl )</synopsis>
                 <para>The function is expected to have the following input and
                 output arguments :</para>
 
-                <programlisting role="example"><![CDATA[ 
+                <programlisting role="example"> 
 function y = myfunction (x)
- ]]></programlisting>
+ </programlisting>
               </listitem>
             </varlistentry>
 
@@ -249,9 +273,9 @@ function y = myfunction (x)
                 function both as an input and output argument. In that case,
                 the function must have the following header :</para>
 
-                <programlisting role="example"><![CDATA[ 
+                <programlisting role="example"> 
 function [ y , data ] = myfunction ( x , data )
- ]]></programlisting>
+ </programlisting>
 
                 <para>The data input parameter may be used if the function
                 uses some additionnal parameters. It is returned as an output
@@ -284,8 +308,8 @@ function [ y , data ] = myfunction ( x , data )
       </varlistentry>
 
       <varlistentry>
-        <term>[ this , data ] = optimsimplex_axes ( this , x0 , fun , len , data
-        )</term>
+        <term>[ this , data ] = optimsimplex_axes ( this , x0 , fun , len ,
+        data )</term>
 
         <listitem>
           <para>Configure the current simplex so that it is computed axis by
@@ -317,9 +341,9 @@ function [ y , data ] = myfunction ( x , data )
                 <para>The function is expected to have the following input and
                 output arguments :</para>
 
-                <programlisting role="example"><![CDATA[ 
+                <programlisting role="example"> 
 function y = myfunction (x)
- ]]></programlisting>
+ </programlisting>
               </listitem>
             </varlistentry>
 
@@ -345,9 +369,9 @@ function y = myfunction (x)
                 function both as an input and output argument. In that case,
                 the function must have the following header :</para>
 
-                <programlisting role="example"><![CDATA[ 
+                <programlisting role="example"> 
 function [ y , data ] = myfunction ( x , data )
- ]]></programlisting>
+ </programlisting>
 
                 <para>The data input parameter may be used if the function
                 uses some additionnal parameters. It is returned as an output
@@ -362,8 +386,8 @@ function [ y , data ] = myfunction ( x , data )
       </varlistentry>
 
       <varlistentry>
-        <term>[ this , data ] = optimsimplex_pfeffer ( this , x0 , fun , deltausual
-        , deltazero , data )</term>
+        <term>[ this , data ] = optimsimplex_pfeffer ( this , x0 , fun ,
+        deltausual , deltazero , data )</term>
 
         <listitem>
           <para>Configure the current simplex so that it is computed from
@@ -396,9 +420,9 @@ function [ y , data ] = myfunction ( x , data )
                 <para>The function is expected to have the following input and
                 output arguments :</para>
 
-                <programlisting role="example"><![CDATA[ 
+                <programlisting role="example"> 
 function y = myfunction (x)
- ]]></programlisting>
+ </programlisting>
               </listitem>
             </varlistentry>
 
@@ -431,9 +455,9 @@ function y = myfunction (x)
                 function both as an input and output argument. In that case,
                 the function must have the following header :</para>
 
-                <programlisting role="example"><![CDATA[ 
+                <programlisting role="example"> 
 function [ y , data ] = myfunction ( x , data )
- ]]></programlisting>
+ </programlisting>
 
                 <para>The data input parameter may be used if the function
                 uses some additionnal parameters. It is returned as an output
@@ -483,9 +507,9 @@ function [ y , data ] = myfunction ( x , data )
                 <para>The function is expected to have the following input and
                 output arguments :</para>
 
-                <programlisting role="example"><![CDATA[ 
+                <programlisting role="example"> 
 function y = myfunction (x)
- ]]></programlisting>
+ </programlisting>
               </listitem>
             </varlistentry>
 
@@ -503,12 +527,12 @@ function y = myfunction (x)
               <listitem>
                 <para>array of maximum bounds</para>
 
-                <para>Each component ix =1 , n of the vertex #jve = 2,k is
+                <para>Each component ix =1,n of the vertex #k = 2,nbve is
                 computed from the formula :</para>
 
-                <programlisting role="example"><![CDATA[ 
-x ( ix , jve ) = boundsmin( ix ) + rand() * (boundsmax( ix ) - boundsmin( ix ))
- ]]></programlisting>
+                <programlisting role="example"> 
+x ( k , ix ) = boundsmin( ix ) + rand() * (boundsmax( ix ) - boundsmin( ix ))
+ </programlisting>
               </listitem>
             </varlistentry>
 
@@ -531,9 +555,9 @@ x ( ix , jve ) = boundsmin( ix ) + rand() * (boundsmax( ix ) - boundsmin( ix ))
                 function both as an input and output argument. In that case,
                 the function must have the following header :</para>
 
-                <programlisting role="example"><![CDATA[ 
+                <programlisting role="example"> 
 function [ y , data ] = myfunction ( x , data )
- ]]></programlisting>
+ </programlisting>
 
                 <para>The data input parameter may be used if the function
                 uses some additionnal parameters. It is returned as an output
@@ -548,12 +572,12 @@ function [ y , data ] = myfunction ( x , data )
       </varlistentry>
 
       <varlistentry>
-        <term>[ this , data ] = optimsimplex_spendley ( this , x0 , fun , len ,
-        data )</term>
+        <term>[ this , data ] = optimsimplex_spendley ( this , x0 , fun , len
+        , data )</term>
 
         <listitem>
           <para>Configure the current simplex so that it is computed from
-          Spendley's et al. method, i.e. a regular simplex made of k = n+1
+          Spendley's et al. method, i.e. a regular simplex made of nbve = n+1
           vertices.</para>
 
           <variablelist>
@@ -582,9 +606,9 @@ function [ y , data ] = myfunction ( x , data )
                 <para>The function is expected to have the following input and
                 output arguments :</para>
 
-                <programlisting role="example"><![CDATA[ 
+                <programlisting role="example"> 
 function y = myfunction (x)
- ]]></programlisting>
+ </programlisting>
               </listitem>
             </varlistentry>
 
@@ -608,9 +632,9 @@ function y = myfunction (x)
                 function both as an input and output argument. In that case,
                 the function must have the following header :</para>
 
-                <programlisting role="example"><![CDATA[ 
+                <programlisting role="example"> 
 function [ y , data ] = myfunction ( x , data )
- ]]></programlisting>
+ </programlisting>
 
                 <para>The data input parameter may be used if the function
                 uses some additionnal parameters. It is returned as an output
@@ -674,7 +698,8 @@ function [ y , data ] = myfunction ( x , data )
 
         <listitem>
           <para>Set all the function values of all the vertices. The vertex #k
-          is expected to be stored in fv(k) with k = 1 , nbve</para>
+          is expected to be stored in fv(k) with k = 1 , nbve. The fv input
+          argument is expected to be a row vector.</para>
 
           <variablelist>
             <varlistentry>
@@ -701,7 +726,7 @@ function [ y , data ] = myfunction ( x , data )
 
         <listitem>
           <para>Set all the coordinates of all the vertices. The vertex #k is
-          expected to be stored in x(1:n,k) with k = 1 , nbve</para>
+          expected to be stored in x(k,1:n) with k = 1 , nbve</para>
 
           <variablelist>
             <varlistentry>
@@ -846,7 +871,7 @@ function [ y , data ] = myfunction ( x , data )
               <term>x</term>
 
               <listitem>
-                <para>the coordinates of the point, as a column vector</para>
+                <para>the coordinates of the point, as a row vector</para>
               </listitem>
             </varlistentry>
           </variablelist>
@@ -857,7 +882,7 @@ function [ y , data ] = myfunction ( x , data )
         <term>this = optimsimplex_setx ( this , ive , x )</term>
 
         <listitem>
-          <para>Set the coordinates of the vertex at given index, as a column
+          <para>Set the coordinates of the vertex at given index, as a row
           vector, into the current simplex.</para>
 
           <variablelist>
@@ -881,7 +906,7 @@ function [ y , data ] = myfunction ( x , data )
               <term>x</term>
 
               <listitem>
-                <para>the coordinates of the point, as a column vector</para>
+                <para>the coordinates of the point, as a row vector</para>
               </listitem>
             </varlistentry>
           </variablelist>
@@ -934,8 +959,8 @@ function [ y , data ] = myfunction ( x , data )
         <term>fv = optimsimplex_getallfv ( this )</term>
 
         <listitem>
-          <para>Returns all the function values of all the vertices, as a
-          column vector.</para>
+          <para>Returns all the function values of all the vertices, as a row
+          vector.</para>
 
           <variablelist>
             <varlistentry>
@@ -979,7 +1004,7 @@ function [ y , data ] = myfunction ( x , data )
               <listitem>
                 <para>the coordinates.</para>
 
-                <para>The vertex #k is stored in x(1:n,k) with k = 1 ,
+                <para>The vertex #k is stored in x(k,1:n) with k = 1 ,
                 nbve.</para>
               </listitem>
             </varlistentry>
@@ -1032,7 +1057,7 @@ function [ y , data ] = myfunction ( x , data )
       </varlistentry>
 
       <varlistentry>
-        <term>n = optimsimplex_getnbve ( this )</term>
+        <term>nbve = optimsimplex_getnbve ( this )</term>
 
         <listitem>
           <para>Returns the number of vertices in the simplex.</para>
@@ -1080,8 +1105,8 @@ function [ y , data ] = myfunction ( x , data )
         <term>x = optimsimplex_getx ( this , ive )</term>
 
         <listitem>
-          <para>Returns the coordinates of the vertex at given index, as a
-          column vector.</para>
+          <para>Returns the coordinates of the vertex at given index, as a row
+          vector.</para>
 
           <variablelist>
             <varlistentry>
@@ -1141,7 +1166,8 @@ function [ y , data ] = myfunction ( x , data )
       </varlistentry>
 
       <varlistentry>
-        <term>[ this , data ] = optimsimplex_computefv ( this , fun , data )</term>
+        <term>[ this , data ] = optimsimplex_computefv ( this , fun , data
+        )</term>
 
         <listitem>
           <para>Set the values of the function at vertices points.</para>
@@ -1164,9 +1190,9 @@ function [ y , data ] = myfunction ( x , data )
                 <para>The function is expected to have the following input and
                 output arguments :</para>
 
-                <programlisting role="example"><![CDATA[ 
+                <programlisting role="example"> 
 function y = myfunction (x)
- ]]></programlisting>
+ </programlisting>
               </listitem>
             </varlistentry>
 
@@ -1181,9 +1207,9 @@ function y = myfunction (x)
                 function both as an input and output argument. In that case,
                 the function must have the following header :</para>
 
-                <programlisting role="example"><![CDATA[ 
+                <programlisting role="example"> 
 function [ y , data ] = myfunction ( x , data )
- ]]></programlisting>
+ </programlisting>
 
                 <para>The data input parameter may be used if the function
                 uses some additionnal parameters. It is returned as an output
@@ -1296,8 +1322,8 @@ function [ y , data ] = myfunction ( x , data )
       </varlistentry>
 
       <varlistentry>
-        <term>[ g , data ] = optimsimplex_gradientfv ( this , fun , method , data
-        )</term>
+        <term>[ g , data ] = optimsimplex_gradientfv ( this , fun , method ,
+        data )</term>
 
         <listitem>
           <para>Returns the simplex gradient of the function.</para>
@@ -1320,9 +1346,9 @@ function [ y , data ] = myfunction ( x , data )
                 <para>The function is expected to have the following input and
                 output arguments :</para>
 
-                <programlisting role="example"><![CDATA[ 
+                <programlisting role="example"> 
 function y = myfunction (x)
- ]]></programlisting>
+ </programlisting>
               </listitem>
             </varlistentry>
 
@@ -1351,9 +1377,9 @@ function y = myfunction (x)
                 function both as an input and output argument. In that case,
                 the function must have the following header :</para>
 
-                <programlisting role="example"><![CDATA[ 
+                <programlisting role="example"> 
 function [ y , data ] = myfunction ( x , data )
- ]]></programlisting>
+ </programlisting>
 
                 <para>The data input parameter may be used if the function
                 uses some additionnal parameters. It is returned as an output
@@ -1368,7 +1394,8 @@ function [ y , data ] = myfunction ( x , data )
       </varlistentry>
 
       <varlistentry>
-        <term>[ ns , data ] = optimsimplex_oriented ( this , fun , data )</term>
+        <term>[ ns , data ] = optimsimplex_oriented ( this , fun , data
+        )</term>
 
         <listitem>
           <para>Returns a new oriented simplex, in sorted order. The new
@@ -1395,9 +1422,9 @@ function [ y , data ] = myfunction ( x , data )
                 <para>The function is expected to have the following input and
                 output arguments :</para>
 
-                <programlisting role="example"><![CDATA[ 
+                <programlisting role="example"> 
 function y = myfunction (x)
- ]]></programlisting>
+ </programlisting>
               </listitem>
             </varlistentry>
 
@@ -1412,9 +1439,9 @@ function y = myfunction (x)
                 function both as an input and output argument. In that case,
                 the function must have the following header :</para>
 
-                <programlisting role="example"><![CDATA[ 
+                <programlisting role="example"> 
 function [ y , data ] = myfunction ( x , data )
- ]]></programlisting>
+ </programlisting>
 
                 <para>The data input parameter may be used if the function
                 uses some additionnal parameters. It is returned as an output
@@ -1473,9 +1500,9 @@ function [ y , data ] = myfunction ( x , data )
                 <para>The function is expected to have the following input and
                 output arguments :</para>
 
-                <programlisting role="example"><![CDATA[ 
+                <programlisting role="example"> 
 function y = myfunction (x)
- ]]></programlisting>
+ </programlisting>
               </listitem>
             </varlistentry>
 
@@ -1490,9 +1517,9 @@ function y = myfunction (x)
                 function both as an input and output argument. In that case,
                 the function must have the following header :</para>
 
-                <programlisting role="example"><![CDATA[ 
+                <programlisting role="example"> 
 function [ y , data ] = myfunction ( x , data )
- ]]></programlisting>
+ </programlisting>
 
                 <para>The data input parameter may be used if the function
                 uses some additionnal parameters. It is returned as an output
@@ -1507,8 +1534,8 @@ function [ y , data ] = myfunction ( x , data )
       </varlistentry>
 
       <varlistentry>
-        <term>[ this , data ] = optimsimplex_shrink ( this , fun , sigma , data
-        )</term>
+        <term>[ this , data ] = optimsimplex_shrink ( this , fun , sigma ,
+        data )</term>
 
         <listitem>
           <para>Shrink the simplex with given coefficient sigma and returns an
@@ -1533,9 +1560,9 @@ function [ y , data ] = myfunction ( x , data )
                 <para>The function is expected to have the following input and
                 output arguments :</para>
 
-                <programlisting role="example"><![CDATA[ 
+                <programlisting role="example"> 
 function y = myfunction (x)
- ]]></programlisting>
+ </programlisting>
               </listitem>
             </varlistentry>
 
@@ -1559,9 +1586,9 @@ function y = myfunction (x)
                 function both as an input and output argument. In that case,
                 the function must have the following header :</para>
 
-                <programlisting role="example"><![CDATA[ 
+                <programlisting role="example"> 
 function [ y , data ] = myfunction ( x , data )
- ]]></programlisting>
+ </programlisting>
 
                 <para>The data input parameter may be used if the function
                 uses some additionnal parameters. It is returned as an output
@@ -1585,12 +1612,12 @@ function [ y , data ] = myfunction ( x , data )
           requires 2 nested loops over the vertices.</para>
 
           <para>The sigmaminus (resp. sigmamplus) size is the minimum (resp.
-          maximum) length of the vector from each vertex to the first
-          vertex. It requires one loop over the vertices.</para>
+          maximum) length of the vector from each vertex to the first vertex.
+          It requires one loop over the vertices.</para>
 
           <para>The "Nash" size is the sum of the norm of the length of the
-          vector from the given vertex to the first vertex. It requires one
-          loop over the vertices.</para>
+          vector from the given vertex to the first vertex. The 1-norm is
+          used. It requires one loop over the vertices.</para>
 
           <variablelist>
             <varlistentry>
@@ -1691,7 +1718,7 @@ function [ y , data ] = myfunction ( x , data )
     <para>In the following example, one creates a simplex with known vertices
     coordinates. The function values at the vertices are unset.</para>
 
-    <programlisting role="example"><![CDATA[ 
+    <programlisting role="example"> 
 coords = [
 0.0 1.0 0.0
 0.0 0.0 1.0
@@ -1701,7 +1728,7 @@ computed = optimsimplex_getallx ( s1 );
 computed = optimsimplex_getn(s1);
 computed = optimsimplex_getnbve (s1);
 s1 = optimsimplex_destroy(s1);
- ]]></programlisting>
+ </programlisting>
   </refsection>
 
   <refsection>
@@ -1715,7 +1742,7 @@ s1 = optimsimplex_destroy(s1);
     value of mydude.nb is 5, which is the expected result because there is one
     function call by vertex.</para>
 
-    <programlisting role="example"><![CDATA[ 
+    <programlisting role="example"> 
 function [ y , myobj ] = mycostf ( x , myobj )
   y = rosenbrock(x);
   myobj.nb = myobj.nb + 1
@@ -1727,52 +1754,48 @@ s1 = optimsimplex_new ();
 [ s1 , mydude ] = optimsimplex_randbounds ( s1 , x0 = [-1.2 1.0], fun = mycostf, ...
   boundsmin = [-5.0 -5.0] , boundsmax = [5.0 5.0], nbve=5 , data = mydude );
 s1 = optimsimplex_destroy ( s1 );
- ]]></programlisting>
+ </programlisting>
   </refsection>
 
   <refsection>
     <title>TODO</title>
 
     <itemizedlist>
-        <listitem>
-          <para>implement reflection and expansion as in multidimensional
-          search by Torczon</para>
-        </listitem>
+      <listitem>
+        <para>implement reflection and expansion as in multidimensional search
+        by Torczon</para>
+      </listitem>
+
+      <listitem>
+        <para>move optimsimplex_reflect into a proper method, not a weird
+        constructor</para>
+      </listitem>
     </itemizedlist>
   </refsection>
 
   <refsection>
     <title>Initial simplex strategies</title>
-    <para>
-      In this section, we analyse the various initial simplex which are provided in this 
-      component.
-    </para>
-    <para>
-      It is known that direct search methods based on simplex designs are very 
-      sensitive to the initial simplex. This is why the current component 
-      provides various ways to create such an initial simplex.
-    </para>
-
-    <para>
-      The first historical simplex-based algorithm is the one presented in 
-      "Sequential Application of Simplex Designs in Optimisation and
-      Evolutionary Operation" by W. Spendley, G. R. Hext and F. R. Himsworth.
-      The optimsimplex_spendley function creates the regular simplex which is presented in
-      this paper.
-    </para>
-
-    
-    <para>
-      The method used in the optimsimplex_randbounds function is due to M.J. Box
-      in "A New Method of Constrained Optimization and a Comparison With
-      Other Methods". 
-    </para>
-
-    <para>
-      Pfeffer's method is an heuristic which is presented in "Global Optimization Of Lennard-Jones Atomic Clusters" by
-      Ellen Fan. It is due to L. Pfeffer at Stanford and it is used in fminsearch.
-    </para>
-    
+
+    <para>In this section, we analyse the various initial simplex which are
+    provided in this component.</para>
+
+    <para>It is known that direct search methods based on simplex designs are
+    very sensitive to the initial simplex. This is why the current component
+    provides various ways to create such an initial simplex.</para>
+
+    <para>The first historical simplex-based algorithm is the one presented in
+    "Sequential Application of Simplex Designs in Optimisation and
+    Evolutionary Operation" by W. Spendley, G. R. Hext and F. R. Himsworth.
+    The optimsimplex_spendley function creates the regular simplex which is
+    presented in this paper.</para>
+
+    <para>The method used in the optimsimplex_randbounds function is due to
+    M.J. Box in "A New Method of Constrained Optimization and a Comparison
+    With Other Methods".</para>
+
+    <para>Pfeffer's method is an heuristic which is presented in "Global
+    Optimization Of Lennard-Jones Atomic Clusters" by Ellen Fan. It is due to
+    L. Pfeffer at Stanford and it is used in fminsearch.</para>
   </refsection>
 
   <refsection>
@@ -1784,75 +1807,51 @@ s1 = optimsimplex_destroy ( s1 );
   <refsection>
     <title>Bibliography</title>
 
-    <para>
-      &#8220;Sequential Application of Simplex Designs in Optimisation and
-      Evolutionary Operation&#8221;, Spendley, W. and Hext, G. R. and Himsworth,
-      F. R., American Statistical Association and American Society for Quality,
-      1962
-    </para>
-
-    <para>
-      "A Simplex Method for Function Minimization", Nelder, J. A. and
-      Mead, R. The Computer Journal, January, 1965, 308--313
-    </para>
-
-    <para>
-      "A New Method of Constrained Optimization and a Comparison With
-      Other Methods", M. J. Box, The Computer Journal 1965 8(1):42-52, 1965 by
-      British Computer Society
-    </para>
-
-    <para>
-      "Iterative Methods for Optimization", C.T. Kelley, 1999, Chapter 6.,
-      section 6.2
-    </para>
-
-    <para>
-      "Compact Numerical Methods For Computers - Linear Algebra and
-      Function Minimization", J.C. Nash, 1990, Chapter 14. Direct Search
-      Methods
-    </para>
-
-    <para>
-      "Sequential Application of Simplex Designs in Optimisation and
-      Evolutionary Operation", W. Spendley, G. R. Hext, F. R. Himsworth,
-      Technometrics, Vol. 4, No. 4 (Nov., 1962), pp. 441-461, Section 3.1
-    </para>
-
-    <para>
-      "A New Method of Constrained Optimization and a Comparison With
-      Other Methods", M. J. Box, The Computer Journal 1965 8(1):42-52, 1965 by
-      British Computer Society
-    </para>
-
-    <para>
-      &#8220;Detection and Remediation of Stagnation in the Nelder--Mead
-      Algorithm Using a Sufficient Decrease Condition&#8221;, SIAM J. on
-      Optimization, Kelley,, C. T., 1999
-    </para>
-
-    <para>
-      " Multi-Directional Search: A Direct Search Algorithm for Parallel
-      Machines", by E. Boyd, Kenneth W. Kennedy, Richard A. Tapia, Virginia
-      Joanne Torczon,, Virginia Joanne Torczon, 1989, Phd Thesis, Rice
-      University
-    </para>
-
-    <para>
-      "Grid Restrained Nelder-Mead Algorithm", Árpád B&#361;rmen, Janez
-      Puhan, Tadej Tuma, Computational Optimization and Applications, Volume 34
-      , Issue 3 (July 2006), Pages: 359 - 375
-    </para>
-
-    <para>
-      "A convergent variant of the Nelder-Mead algorithm", C. J. Price, I.
-      D. Coope, D. Byatt, Journal of Optimization Theory and Applications,
-      Volume 113 , Issue 1 (April 2002), Pages: 5 - 19,
-    </para>
-
-    <para>
-      "Global Optimization Of Lennard-Jones Atomic Clusters",
-      Ellen Fan, Thesis, February 26, 2002, McMaster University
-    </para>
+    <para>&#8220;Sequential Application of Simplex Designs in Optimisation and
+    Evolutionary Operation&#8221;, Spendley, W. and Hext, G. R. and Himsworth,
+    F. R., American Statistical Association and American Society for Quality,
+    1962</para>
+
+    <para>"A Simplex Method for Function Minimization", Nelder, J. A. and
+    Mead, R. The Computer Journal, January, 1965, 308--313</para>
+
+    <para>"A New Method of Constrained Optimization and a Comparison With
+    Other Methods", M. J. Box, The Computer Journal 1965 8(1):42-52, 1965 by
+    British Computer Society</para>
+
+    <para>"Iterative Methods for Optimization", C.T. Kelley, 1999, Chapter 6.,
+    section 6.2</para>
+
+    <para>"Compact Numerical Methods For Computers - Linear Algebra and
+    Function Minimization", J.C. Nash, 1990, Chapter 14. Direct Search
+    Methods</para>
+
+    <para>"Sequential Application of Simplex Designs in Optimisation and
+    Evolutionary Operation", W. Spendley, G. R. Hext, F. R. Himsworth,
+    Technometrics, Vol. 4, No. 4 (Nov., 1962), pp. 441-461, Section 3.1</para>
+
+    <para>"A New Method of Constrained Optimization and a Comparison With
+    Other Methods", M. J. Box, The Computer Journal 1965 8(1):42-52, 1965 by
+    British Computer Society</para>
+
+    <para>&#8220;Detection and Remediation of Stagnation in the Nelder--Mead
+    Algorithm Using a Sufficient Decrease Condition&#8221;, SIAM J. on
+    Optimization, Kelley,, C. T., 1999</para>
+
+    <para>" Multi-Directional Search: A Direct Search Algorithm for Parallel
+    Machines", by E. Boyd, Kenneth W. Kennedy, Richard A. Tapia, Virginia
+    Joanne Torczon,, Virginia Joanne Torczon, 1989, Phd Thesis, Rice
+    University</para>
+
+    <para>"Grid Restrained Nelder-Mead Algorithm", Árpád B&#361;rmen, Janez
+    Puhan, Tadej Tuma, Computational Optimization and Applications, Volume 34
+    , Issue 3 (July 2006), Pages: 359 - 375</para>
+
+    <para>"A convergent variant of the Nelder-Mead algorithm", C. J. Price, I.
+    D. Coope, D. Byatt, Journal of Optimization Theory and Applications,
+    Volume 113 , Issue 1 (April 2002), Pages: 5 - 19,</para>
+
+    <para>"Global Optimization Of Lennard-Jones Atomic Clusters", Ellen Fan,
+    Thesis, February 26, 2002, McMaster University</para>
   </refsection>
 </refentry>
index 5054f57..827d8ab 100644 (file)
@@ -22,7 +22,7 @@
 function [x,fval,exitflag,output] = fminsearch ( varargin )
   [lhs,rhs]=argn();
   if rhs<>2 & rhs<>3 then
-    errmsg = sprintf("Unexpected number of arguments : %d provided while 2 or 3 are expected.",rhs);
+    errmsg = msprintf(gettext("%s: Unexpected number of input arguments : %d provided while 2 or 3 are expected."), "fminsearch", rhs);
     error(errmsg)
   end
   fun = varargin(1);
@@ -34,9 +34,6 @@ function [x,fval,exitflag,output] = fminsearch ( varargin )
   elseif rhs==3 then
     // One options struc on the command line : use it !
     options = varargin(3);
-  else
-    errmsg = msprintf(gettext("%s: Unexpected number of input arguments %d instead of 2 to 3."), "fminsearch", rhs);
-    error(errmsg)
   end
   // Compute options from the options struct
   numberofvariables = size(x0,2);
@@ -60,7 +57,7 @@ function [x,fval,exitflag,output] = fminsearch ( varargin )
   options.MaxFunEvals
   // Perform Optimization
   nm = neldermead_new ();
-  nm = neldermead_configure(nm,"-x0",x0');
+  nm = neldermead_configure(nm,"-x0",x0.');
   nm = neldermead_configure(nm,"-numberofvariables",numberofvariables);
   nm = neldermead_configure(nm,"-simplex0method","pfeffer");
   nm = neldermead_configure(nm,"-simplex0deltausual",0.05);
@@ -76,7 +73,7 @@ function [x,fval,exitflag,output] = fminsearch ( varargin )
   nm = neldermead_configure(nm,"-toldeltafv",TolFun);
   nm = neldermead_configure(nm,"-tolsimplexizeabsolute",TolX);
   nm = neldermead_search(nm);
-  x = neldermead_get(nm,"-xopt")';
+  x = neldermead_get(nm,"-xopt").';
   fval = neldermead_get(nm,"-fopt");
   status = neldermead_get(nm,"-status");
   select status
@@ -98,10 +95,10 @@ function [x,fval,exitflag,output] = fminsearch ( varargin )
   output.algorithm = 'Nelder-Mead simplex direct search';
   output.funcCount = neldermead_get(nm,"-funevals");
   output.iterations = neldermead_get(nm,"-iterations");
-  output.message = sprintf("%s\n%s\n%s", "Optimization terminated:",...
-    "the current x satisfies the termination criteria using OPTIONS.TolX of %e",...
+  output.message = sprintf("%s\n%s %e\n%s %e", "Optimization terminated:",...
+    "the current x satisfies the termination criteria using OPTIONS.TolX of",...
     TolX,...
-    "and F(X) satisfies the convergence criteria using OPTIONS.TolFun of %e",...
+    "and F(X) satisfies the convergence criteria using OPTIONS.TolFun of",...
     TolFun);
   nm = neldermead_destroy(nm);
   clear nm;
index d745cd1..0349b8b 100644 (file)
@@ -75,8 +75,11 @@ function value = neldermead_cget (this,key)
     value = this.nbineqloops;
   case "-ineqscaling" then
     value = this.ineqscaling;
+  case "-vectorizefunction" then
+    value = this.vectorizefunction;
   else
     // Delegate to the optimization object
     value = optimbase_cget ( this.optbase , key );
   end
 endfunction
+
index 8bd4abd..5fde63b 100644 (file)
@@ -22,7 +22,7 @@ function this = neldermead_configure (this,key,value)
     case "box" then
       this.method = "box";
     else
-      errmsg = msprintf(gettext("%s: Unknown method %s"),"neldermead_configure",value);
+      errmsg = msprintf(gettext("%s: Unknown value %s for -method option"),"neldermead_configure",value);
       error(errmsg);
     end
   case "-coords0" then
@@ -40,7 +40,7 @@ function this = neldermead_configure (this,key,value)
     case "randbounds" then
       this.simplex0method = "randbounds";
     else
-      errmsg = msprintf(gettext("%s: Unknown -simplex0method %s"),"neldermead_configure", value);
+      errmsg = msprintf(gettext("%s: Unknown value %s for -simplex0method option"),"neldermead_configure", value);
       error(errmsg);
     end
   case "-simplex0length" then
@@ -66,7 +66,7 @@ function this = neldermead_configure (this,key,value)
     case "disabled" then
       this.tolfstdeviationmethod = value;
     else
-      errmsg = msprintf(gettext("%s: Unknown tolerance on function standard deviation method %s"),"neldermead_configure", value);
+      errmsg = msprintf(gettext("%s: Unknown value %s for -tolfstdeviationmethod option"),"neldermead_configure", value);
       error(errmsg);
     end
   case "-tolsimplexizeabsolute" then
@@ -80,7 +80,7 @@ function this = neldermead_configure (this,key,value)
     case "disabled" then
       this.tolsimplexizemethod = value;
     else
-      errmsg = msprintf(gettext("%s: Unknown tolerance on simplex size method %s"),"neldermead_configure", value);
+      errmsg = msprintf(gettext("%s: Unknown value %s for -tolsimplexizemethod option"),"neldermead_configure", value);
       error(errmsg);
     end
   case "-toldeltafv" then
@@ -92,7 +92,7 @@ function this = neldermead_configure (this,key,value)
     case "disabled" then
       this.tolssizedeltafvmethod = value;
     else
-      errmsg = msprintf(gettext("%s: Unknown tolerance on simplex size and delta function value method %s"),"neldermead_configure", value);
+      errmsg = msprintf(gettext("%s: Unknown value %s for -tolssizedeltafvmethod option"),"neldermead_configure", value);
       error(errmsg);
     end
   case "-restartmax" then
@@ -119,8 +119,20 @@ function this = neldermead_configure (this,key,value)
     this.nbineqloops = value;
   case "-ineqscaling" then
     this.ineqscaling = value;
+  case "-vectorizefunction" then
+    this.vectorizefunction = value;
+    select value
+    case 0 then
+      this.vectorizefunction = 0;
+    case 1 then
+      this.vectorizefunction = 1;
+    else
+      errmsg = msprintf(gettext("%s: Unknown value %s for -vectorizefunction option"),"neldermead_configure", value);
+      error(errmsg);
+    end
   else
     // Delegate to the optimization object
     this.optbase = optimbase_configure ( this.optbase , key , value );
   end
 endfunction
+
index 0cf0d23..be1f795 100644 (file)
 //   xdata , ydata , zdata : vectors of data, as required by the contour command
 //
 function [ this , xdata , ydata , zdata ] = neldermead_contour ( this , xmin , xmax , ymin , ymax , nx , ny )
+  // Check that there are only 2 parameters
+  n = neldermead_cget ( this , "-numberofvariables" );
+  if n <> 2 then
+    errmsg = msprintf(gettext("%s: Unexpected number of variables %d. Cannot draw contour plot for functions which do not have two parameters."),"nmplot_contour",n)
+    error(errmsg)
+  end
   stepx = (xmax - xmin)/nx
   xdata = xmin:stepx:xmax;
   stepy = (ymax - ymin)/ny
   ydata = ymin:stepy:ymax;
+  // 1. Compute the matrix of experiments
+  nexp = length(xdata) * length(ydata)
+  iexp = 1;
+  for ix = 1:length(xdata)
+    for iy = 1:length(ydata)
+      x(iexp,1:2) = [xdata(ix) ydata(iy)];
+      iexp = iexp + 1;
+    end
+  end
+  // 2. Perform the experiments
+  // Vectorize the call to the cost function if possible
+  vectorizefunction = neldermead_cget ( this , "-vectorizefunction" );
+  if vectorizefunction == 0 then
+    for iexp = 1:nexp
+      [ this , f(iexp) ] = neldermead_function ( this , x(iexp,1:2) );
+    end
+  else
+    [ this , f ] = neldermead_function ( this , x );
+  end
+  // 3. Store the experiments results in a matrix, suitable for input to the contour function
+  iexp = 1;
   for ix = 1:length(xdata)
     for iy = 1:length(ydata)
-      x = [xdata(ix) ydata(iy)]
-      [ this , f ] = neldermead_function ( this , x );
-      zdata ( ix , iy ) = f;
+      zdata ( ix , iy ) = f(iexp);
+      iexp = iexp + 1;
     end
   end
 endfunction
index 023c417..dd933aa 100644 (file)
@@ -28,7 +28,8 @@ function newobj = neldermead_new ()
     "kelleynormalizationflag","kelleystagnationalpha0", ...
     "kelleyalpha","restartnb","restartflag","restartdetection" , ...
     "startupflag" , ...
-    "boxnbpoints" , "boxnbpointseff" , "nbineqloops" , "ineqscaling" ]);
+    "boxnbpoints" , "boxnbpointseff" , "nbineqloops" , "ineqscaling" , ...
+    "vectorizefunction" ]);
   newobj.optbase = optimbase_new();
   // Possible values "variable", "fixed".
   newobj.method = "variable";
@@ -113,5 +114,7 @@ function newobj = neldermead_new ()
   // The scaling coefficient in nonlinear inequality constraints
   // in Box method, in (0,1) range
   newobj.ineqscaling = 0.5
+  // Set to 1 if the cost function is vectorized
+  newobj.vectorizefunction = 0
 endfunction
 
index d3f036b..9c8e423 100644 (file)
@@ -9,7 +9,7 @@
 
 //
 // neldermead_restart --
-//   Restarts optimization.
+//   Update the simplex and restart the search.
 //
 function this = neldermead_restart ( this )
   this = neldermead_updatesimp ( this );
index 6d012d0..63b39f3 100644 (file)
@@ -238,7 +238,7 @@ function this = neldermead_variable ( this )
     this = neldermead_log (this,sprintf("Sort"));
     simplex  = optimsimplex_sort ( simplex );
   end
-  this.optbase = optimbase_set ( this.optbase , "-xopt" , xlow );
+  this.optbase = optimbase_set ( this.optbase , "-xopt" , xlow.' );
   this.optbase = optimbase_set ( this.optbase , "-fopt" , flow );
   this.optbase = optimbase_set ( this.optbase , "-status" , status );
   this.simplexopt = simplex;
@@ -350,7 +350,7 @@ function this = neldermead_fixed (this)
     //
     simplex = optimsimplex_sort ( simplex );
   end
-  this.optbase = optimbase_set ( this.optbase , "-xopt" , xlow );
+  this.optbase = optimbase_set ( this.optbase , "-xopt" , xlow.' );
   this.optbase = optimbase_set ( this.optbase , "-fopt" , flow );
   this.optbase = optimbase_set ( this.optbase , "-status" , status );
   this.simplexopt = simplex;
@@ -457,7 +457,7 @@ function [this , terminate , status ] = neldermead_termination (this , ...
   if ( terminate == 0 ) then
     if ( this.kelleystagnationflag==1 ) then
       [ sg , this ] = optimsimplex_gradientfv ( simplex , neldermead_costf , "forward" , this );
-      nsg = sg' * sg;
+      nsg = sg.' * sg;
       sgstr = strcat(string(sg)," ");
       this.optbase = optimbase_stoplog ( this.optbase , sprintf ( "Test Stagnation : nsg = %e, sg = "+sgstr, nsg) );
       this.optbase = optimbase_stoplog ( this.optbase , ...
@@ -511,8 +511,8 @@ function this = neldermead_storehistory ( this , n , fopt , xopt , xcoords )
   iterations = optimbase_get ( this.optbase , "-iterations" );
   if storehistory == 1 then
     this.optbase = optimbase_histset ( this.optbase , iterations , "-fopt" , fopt );
-    this.optbase = optimbase_histset ( this.optbase , iterations , "-xopt" , xopt(1:n)' );
-    this.historysimplex ( iterations , 1:n+1,1:n) = xcoords(1:n,1:n+1)';
+    this.optbase = optimbase_histset ( this.optbase , iterations , "-xopt" , xopt(1:n).' );
+    this.historysimplex ( iterations , 1:n+1,1:n) = xcoords(1:n+1,1:n);
   end
 endfunction
 
@@ -529,7 +529,7 @@ function [ this , istorestart ] = neldermead_istorestart ( this )
   case "kelley"
     [ this , istorestart ] = neldermead_isrkelley ( this )
   else
-    errmsg = msprintf(gettext("%s: Unknown restart method %s"),"neldermead_istorestart", this.restartmethod)
+    errmsg = msprintf(gettext("%s: Unknown restart detection %s"),"neldermead_istorestart", this.restartdetection)
     error(errmsg)
   end
 endfunction
@@ -610,9 +610,9 @@ endfunction
 function this = neldermead_startup (this)
   [ this.optbase , hasbounds ] = optimbase_hasbounds ( this.optbase );
   if ( hasbounds ) then
-    [ this.optbase , isok ] = optimbase_checkbounds ( this.optbase );
+    [ this.optbase , isok , errmsg ] = optimbase_checkbounds ( this.optbase );
     if ( ~isok ) then
-      error ( msprintf(gettext("%s: Bounds are not consistent."), "neldermead_startup" ))
+      error ( msprintf(gettext("%s: %s"), "neldermead_startup" , errmsg ))
     end
   end
   x0 = optimbase_cget ( this.optbase , "-x0" );
@@ -623,22 +623,17 @@ function this = neldermead_startup (this)
   case "axes" then
     simplex0 = optimsimplex_new ( );
     [ simplex0 , this ] = optimsimplex_axes ( simplex0 , ...
-      x0' , neldermead_costf , this.simplex0length , this );
+      x0.' , neldermead_costf , this.simplex0length , this );
   case "spendley" then
     simplex0 = optimsimplex_new ( );
     [ simplex0 , this ] = optimsimplex_spendley ( simplex0 , ...
-      x0' , neldermead_costf , this.simplex0length , this );
+      x0.' , neldermead_costf , this.simplex0length , this );
   case "pfeffer" then
     simplex0 = optimsimplex_new ( );
     [ simplex0 , this ] = optimsimplex_pfeffer ( simplex0 , ...
-      x0' , neldermead_costf , this.simplex0deltausual , ...
+      x0.' , neldermead_costf , this.simplex0deltausual , ...
       this.simplex0deltazero , this );
   case "randbounds" then
-    //
-    // Initialize the random number generator, so that the results are always the
-    // same.
-    //
-    rand("seed" , 0)
     simplex0 = optimsimplex_new ( );
     if ( this.boxnbpoints == "2n" ) then
       this.boxnbpointseff = 2 * this.optbase.numberofvariables;
@@ -648,7 +643,7 @@ function this = neldermead_startup (this)
     if ( ~hasbounds ) then
       error ( msprintf(gettext("%s: Randomized bounds initial simplex is not available without bounds." ), "neldermead_startup"))
     end
-    [ simplex0 , this ] = optimsimplex_randbounds ( simplex0 , x0' , ...
+    [ simplex0 , this ] = optimsimplex_randbounds ( simplex0 , x0.' , ...
       neldermead_costf , this.optbase.boundsmin , this.optbase.boundsmax , ...
       this.boxnbpointseff  , this );
   else
@@ -662,11 +657,13 @@ function this = neldermead_startup (this)
     this = neldermead_log (this,sprintf("Scaling initial simplex into nonlinear inequality constraints..."));
     nbve = optimsimplex_getnbve ( simplex0 );
     for ive = 1 : nbve
+      // optimsimplex returns a row vector
       x = optimsimplex_getx ( simplex0 , ive );
       this = neldermead_log (this,sprintf("Scaling vertex #%d/%d at ["+...
         strcat(string(x)," ")+"]... " , ...
         ive , nbve ));
-      [ this , status , xp ] = _scaleinconstraints ( this , x , x0 );
+      // Transpose x, because x0 is a column vector
+      [ this , status , xp ] = _scaleinconstraints ( this , x.' , x0 );
       if ( ~status ) then
         errmsg = msprintf(gettext("%s: Impossible to scale the vertex #%d/%d at [%s] into inequality constraints"), ...
           "neldermead_startup", ive , nbve , strcat(string(x)," "));
@@ -674,7 +671,8 @@ function this = neldermead_startup (this)
       end
       if ( or ( x <> xp ) ) then
         [ this , fv ] = neldermead_function ( this , xp );
-        simplex0 = optimsimplex_setve ( simplex0 , ive , fv , xp );
+        // Transpose xp, which is a column vector
+        simplex0 = optimsimplex_setve ( simplex0 , ive , fv , xp.' );
       end
     end
   end
@@ -686,7 +684,7 @@ function this = neldermead_startup (this)
   this.simplexsize0 = optimsimplex_size ( simplex0 );
   fx0 = optimsimplex_getfv ( this.simplex0 , 1 );
   this.optbase = optimbase_set ( this.optbase , "-fx0" , fx0 );
-  this.optbase = optimbase_set ( this.optbase , "-xopt" , x0 );
+  this.optbase = optimbase_set ( this.optbase , "-xopt" , x0.' );
   this.optbase = optimbase_set ( this.optbase , "-fopt" , fx0 );
   this.optbase = optimbase_set ( this.optbase , "-iterations" , 0 );
   if ( this.kelleystagnationflag == 1 ) then
@@ -712,7 +710,7 @@ function this = neldermead_kelleystag ( this )
         this.kelleyalpha = this.kelleystagnationalpha0
       else
         [sg,this] = optimsimplex_gradientfv ( this.simplex0 , neldermead_costf , "forward" , this )
-        nsg = sg' * sg
+        nsg = sg.' * sg
         sigma0 = optimsimplex_size ( this.simplex0 , "sigmaplus" )
         if nsg==0.0 then 
           this.kelleyalpha = this.kelleystagnationalpha0
@@ -976,7 +974,7 @@ function this = neldermead_box ( this )
     this = neldermead_log (this,sprintf("Sort"));
     simplex  = optimsimplex_sort ( simplex );
   end
-  this.optbase = optimbase_set ( this.optbase , "-xopt" , xlow );
+  this.optbase = optimbase_set ( this.optbase , "-xopt" , xlow.' );
   this.optbase = optimbase_set ( this.optbase , "-fopt" , flow );
   this.optbase = optimbase_set ( this.optbase , "-status" , status );
   this.simplexopt = simplex;
index 8aa5398..afe6b70 100644 (file)
@@ -21,13 +21,13 @@ function this = neldermead_updatesimp ( this )
     [ simplex0 , this ] = optimsimplex_oriented ( this.simplexopt , neldermead_costf , this )
   case "axes" then
     [ simplex0 , this ] = optimsimplex_axes ( simplex0 , ...
-      xopt' , neldermead_costf , this.simplex0length , this );
+      xopt.' , neldermead_costf , this.simplex0length , this );
   case "spendley" then
     [ simplex0 , this ] = optimsimplex_spendley ( simplex0 , ...
-      xopt' , neldermead_costf , this.simplex0length , this );
+      xopt.' , neldermead_costf , this.simplex0length , this );
   case "pfeffer" then
     [ simplex0 , this ] = optimsimplex_pfeffer ( simplex0 , ...
-      xopt' , neldermead_costf , this.simplex0deltausual , ...
+      xopt.' , neldermead_costf , this.simplex0deltausual , ...
       this.simplex0deltazero , this );
   case "randbounds" then
     if ( this.boxnbpoints=="2n" ) then
@@ -39,7 +39,7 @@ function this = neldermead_updatesimp ( this )
       errmsg = msprintf ( gettext("%s: Randomized bounds initial simplex is not available without bounds." ) , "neldermead_updatesimp" )
       error ( errmsg )
     end
-    [ simplex0 , this ] = optimsimplex_randbounds ( simplex0 , xopt' , ...
+    [ simplex0 , this ] = optimsimplex_randbounds ( simplex0 , xopt.' , ...
       neldermead_costf , this.optbase.boundsmin , this.optbase.boundsmax , ...
       this.boxnbpointseff  , this )
   else
@@ -51,20 +51,22 @@ function this = neldermead_updatesimp ( this )
   //
   nbve = optimsimplex_getnbve ( simplex0 );
   this = neldermead_log (this,"Before scaling:");
-    str = optimsimplex_tostring ( simplex0 )
-    for i = 1:nbve
-      this = neldermead_log (this,str(i));
-    end
+  str = optimsimplex_tostring ( simplex0 )
+  for i = 1:nbve
+    this = neldermead_log (this,str(i));
+  end
   [ this.optbase , hasbounds ] = optimbase_hasbounds ( this.optbase );
   if ( hasbounds | this.optbase.nbineqconst > 0 ) then
     this = neldermead_log (this,sprintf("Scaling initial simplex into nonlinear inequality constraints..."));
     nbve = optimsimplex_getnbve ( simplex0 )
     for ive = 1 : nbve
+      // x is a row vector
       x = optimsimplex_getx ( simplex0 , ive )
       this = neldermead_log (this,sprintf("Scaling vertex #%d/%d at ["+...
         strcat(string(x)," ")+"]... " , ...
         ive , nbve ));
-      [ this , status , xp ] = _scaleinconstraints ( this , x , xopt )
+      // Transpose x because xopt is a column vector : xp is now a column vector
+      [ this , status , xp ] = _scaleinconstraints ( this , x.' , xopt )
       if ( ~status ) then
         errmsg = msprintf(gettext("Impossible to scale the vertex #%d/%d at [%s] into inequality constraints"), "neldermead_updatesimp", ...
           ive , nbve , strcat(string(x)," "));
@@ -72,15 +74,16 @@ function this = neldermead_updatesimp ( this )
       end
       if ( or(x <> xp) ) then
         [ this , fv ] = neldermead_function ( this , xp )
-        simplex0 = optimsimplex_setve ( simplex0 , ive , fv , xp )
+        // Transpose xp because optimsimplex takes row coordinate vectors.
+        simplex0 = optimsimplex_setve ( simplex0 , ive , fv , xp.' )
       end
     end
   end
   this = neldermead_log (this,"After scaling:");
-    str = optimsimplex_tostring ( simplex0 )
-    for i = 1:nbve
-      this = neldermead_log (this,str(i));
-    end
+  str = optimsimplex_tostring ( simplex0 )
+  for i = 1:nbve
+    this = neldermead_log (this,str(i));
+  end
   this.simplex0 = optimsimplex_destroy ( this.simplex0 )
   this.simplex0 = simplex0;
   this.simplexsize0 = optimsimplex_size ( simplex0 );
index 94f2415..eaae62d 100644 (file)
@@ -15,8 +15,6 @@
 //
 function value = nmplot_cget (this,key)
   select key
-  case "-verbose" then
-    value = this.verbose;
   case "-simplexfn" then
     value = this.simplexfn;
   case "-fbarfn" then
index 96fd548..7649c72 100644 (file)
@@ -13,9 +13,6 @@
 //
 function this = nmplot_configure (this,key,value)
   select key
-  case "-verbose" then
-    this.verbose = value;
-    this.nmbase = neldermead_configure ( this.nmbase , "-verbose" , value )
   case "-simplexfn" then
     this.simplexfn = value;
   case "-fbarfn" then
index 03fe734..98aab9b 100644 (file)
 //   nx , ny : the number of points in the directions x, y
 //   xdata , ydata , zdata : vectors of data, as required by the contour command
 //
-function [this , xdata , ydata , zdata ] = nmplot_contour ( this , xmin , xmax , ymin , ymax , nx , ny )
+function [ this , xdata , ydata , zdata ] = nmplot_contour ( this , xmin , xmax , ymin , ymax , nx , ny )
+  // Check that there are only 2 parameters
+  n = neldermead_cget ( this.nmbase , "-numberofvariables" );
+  if n <> 2 then
+    errmsg = msprintf(gettext("%s: Unexpected number of variables %d. Cannot draw contour plot for functions which do not have 2 parameters."),"nmplot_contour",n)
+    error(errmsg)
+  end
   stepx = (xmax - xmin)/nx
   xdata = xmin:stepx:xmax;
   stepy = (ymax - ymin)/ny
   ydata = ymin:stepy:ymax;
+  nexp = length(xdata) * length(ydata)
+  iexp = 1;
+  for ix = 1:length(xdata)
+    for iy = 1:length(ydata)
+      x(iexp,1:2) = [xdata(ix) ydata(iy)];
+      iexp = iexp + 1;
+    end
+  end
+  // 2. Perform the experiments
+  // Vectorize the call to the cost function if possible
+  vectorizefunction = neldermead_cget ( this.nmbase , "-vectorizefunction" );
+  if vectorizefunction == 0 then
+    for iexp = 1:nexp
+      [ this.nmbase , f(iexp) ] = neldermead_function ( this.nmbase , x(iexp,1:2) );
+    end
+  else
+    [ this.nmbase , f ] = neldermead_function ( this.nmbase , x );
+  end
+  // 3. Store the experiments results in a matrix, suitable for input to the contour function
+  iexp = 1;
   for ix = 1:length(xdata)
     for iy = 1:length(ydata)
-      x = [xdata(ix) ydata(iy)]
-      [this.nmbase,f] = neldermead_function ( this.nmbase , x );
-      zdata ( ix , iy ) = f;
+      zdata ( ix , iy ) = f(iexp);
+      iexp = iexp + 1;
     end
   end
 endfunction
index 63abb86..81978f4 100644 (file)
 // Arguments
 //
 function this = nmplot_display ( this )
+  mprintf("Nelder-Mead Plot Object\n");
   this.nmbase = neldermead_display ( this.nmbase )
+  mprintf("Simplex data file : %s\n", this.simplexfn);
+  mprintf("Fbar data file : %s\n", this.fbarfn);
+  mprintf("Fopt data file : %s\n", this.foptfn);
+  mprintf("Sigma data file : %s\n", this.sigmafn);
 endfunction
 
index 33a4528..55ae8aa 100644 (file)
@@ -16,6 +16,9 @@
 //  mytitle , myxlabel , myylabel : the parameters of the plot
 //
 function nmplot_historyplot ( this , datafile  , mytitle , myxlabel , myylabel )
+  if (~isdef('datafile','local')) then
+    datafile = this.foptfn;
+  end
   if (~isdef('mytitle','local')) then
     mytitle = "";
   end
index 9888b32..7ac65cc 100644 (file)
@@ -12,8 +12,6 @@
 //   Prints the given message.
 //
 function this = nmplot_log (this,msg)
-  if this.verbose == 1 then
-     mprintf("%s\n",msg);
-  end
+  this.nmbase = neldermead_log ( this.nmbase , msg )
 endfunction
 
index ff213ea..bac3ac4 100644 (file)
@@ -13,9 +13,8 @@
 //
 function newobj = nmplot_new ()
   newobj = tlist(["T_NELDERMEADPLOT",...
-    "verbose","simplexfn","fbarfn","foptfn","sigmafn","nmbase",...
+    "simplexfn","fbarfn","foptfn","sigmafn","nmbase",...
     "simplexhandle","fbarhandle","fopthandle","sigmahandle"]);
-  newobj.verbose = 0;
   newobj.simplexfn = "";
   newobj.fbarfn = "";
   newobj.foptfn = "";
index 4124ae9..3d6a278 100644 (file)
@@ -29,14 +29,14 @@ function nmplot_outputcmd ( state , data , this )
   // Print simplex
   x = optimsimplex_getallx ( data.simplex )
   if this.simplexfn <> "" then
-    nbve = size(x,2)
-    n = nbve - 1
+    nbve = optimsimplex_getnbve ( data.simplex )
+    n = optimsimplex_getn ( data.simplex )
     mfprintf ( this.simplexhandle , "// Iteration #%d\n", iter )
     mfprintf ( this.simplexhandle , "history($+1) = [\n" )
     for ive = 1:nbve
       mfprintf ( this.simplexhandle , "// Vertex #%d\n", ive )
       for ix = 1:n
-        mfprintf ( this.simplexhandle , "%e ", x(ix,ive))
+        mfprintf ( this.simplexhandle , "%e ", x(ive,ix))
       end
       mfprintf ( this.simplexhandle , "\n")
     end
diff --git a/scilab/modules/optimization/macros/neldermead/nmplot_restart.sci b/scilab/modules/optimization/macros/neldermead/nmplot_restart.sci
new file mode 100644 (file)
index 0000000..5662bba
--- /dev/null
@@ -0,0 +1,19 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2009 - INRIA - Michael Baudin
+//
+// This file must be used under the terms of the CeCILL.
+// This source file is licensed as described in the file COPYING, which
+// you should have received as part of this distribution.  The terms
+// are also available at
+// http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+
+//
+// nmplot_restart --
+//   Update the simplex and restart the search.
+//
+function this = nmplot_restart (this)
+  this.nmbase = neldermead_updatesimp ( this.nmbase );
+  this = nmplot_search ( this )
+endfunction
+
+
index fb1731d..5b4943a 100644 (file)
@@ -106,7 +106,7 @@ function options = optimset_configure ( options , key , value )
     case "TolX" then
       options.TolX = value;
     else
-      errmsg = msprintf(gettext("%s: Unknown key %s"), "optimset", key)
+      errmsg = msprintf(gettext("%s: Unrecognized parameter name ''%s''."), "optimset", key)
       error(errmsg)
     end
 endfunction
@@ -143,7 +143,7 @@ function options = optimset_method ( method )
       options = optimset_configure ( options , "TolFun" , 1.e-4 );
       options = optimset_configure ( options , "TolX" , 1.e-4 );
     else
-      errmsg = msprintf(gettext("%s: Unknown method %s"), "optimset", method)
+      errmsg = msprintf(gettext("%s: No default options available: the function ''%s'' does not exist on the path."), "optimset", method)
       error(errmsg)
     end
 endfunction
index b602eb7..29843ca 100644 (file)
@@ -58,7 +58,7 @@ function value = optimbase_cget (this,key)
   case "-nbineqconst" then
     value = this.nbineqconst;
   else
-    errmsg = sprintf("Unknown key %s",key)
+    errmsg = msprintf(gettext("%s: Unknown key %s") , "optimbase_cget" , key)
     error(errmsg)
   end
 endfunction
index 873cf1a..e8de488 100644 (file)
 // Arguments
 //   isok : %T or %F
 //
-function [ this , isok ] = optimbase_checkbounds ( this )
+function [ this , isok , errmsg ] = optimbase_checkbounds ( this )
     maxl = length ( this.boundsmax )
     minl = length ( this.boundsmin )
     isok = %T
+    errmsg = ""
     if ( maxl > 0 | minl > 0 ) then
       if ( isok & this.numberofvariables <> maxl ) then
         errmsg = sprintf("The number of variables %d does not match the number of max bounds %d from ["+...
           strcat(string(this.boundsmax)," ")+"]\n" , ...
           this.numberofvariables , maxl )
-        mprintf(errmsg)
         isok = %F
       end
       if ( isok & this.numberofvariables <> minl ) then
         errmsg = sprintf("The number of variables %d does not match the number of min bounds %d from ["+...
           strcat(string(this.boundsmin)," ")+"]\n" , ...
           this.numberofvariables , minl )
-        mprintf(errmsg)
         isok = %F
       end
       if ( isok ) then
@@ -39,9 +38,8 @@ function [ this , isok ] = optimbase_checkbounds ( this )
           xmin = this.boundsmin ( ix )
           xmax = this.boundsmax ( ix )
           if ( xmax < xmin ) then
-            errmsg = sprintf("The max bound %e for index %d is lower than the min bound %e.\n", ...
+            errmsg = sprintf("The max bound %e for variable #%d is lower than the min bound %e.\n", ...
               xmax , ix , xmin )
-            mprintf(errmsg)
             isok = %F
             break
           end
index e9bf6a9..b95cabf 100644 (file)
@@ -20,8 +20,8 @@ function this = optimbase_configure (this,key,value)
   case "-x0" then
     [n,m] = size(value);
     if m<>1 then
-      msg = sprintf("The x0 vector is expected to be a column matrix, but current shape is %d x %d",n,m);
-      error(msg);
+      errmsg = msprintf(gettext("%s: The x0 vector is expected to be a column matrix, but current shape is %d x %d"),"optimbase_configure",n,m);
+      error(errmsg);
     end
     this.x0 = value;
   case "-maxfunevals" then
@@ -43,7 +43,7 @@ function this = optimbase_configure (this,key,value)
     case "disabled" then
       this.tolxmethod = "disabled";
     else
-      errmsg = sprintf("Unknown tolx method %s",value);
+      errmsg = msprintf(gettext("%s: Unknown value %s for -tolxmethod option"),"optimbase_configure",value);
       error(errmsg);
     end
   case "-tolfunmethod" then
@@ -53,7 +53,7 @@ function this = optimbase_configure (this,key,value)
     case "disabled" then
       this.tolfunmethod = "disabled";
     else
-      errmsg = sprintf("Unknown tolfun method %s",value);
+      errmsg = msprintf(gettext("%s: Unknown value %s for -tolfunmethod"),"optimbase_configure",value);
       error(errmsg);
     end
   case "-function" then
@@ -65,7 +65,14 @@ function this = optimbase_configure (this,key,value)
   case "-numberofvariables" then
     this.numberofvariables = value;
   case "-storehistory" then
-    this.storehistory = value;
+    if value == 0 then
+      this.storehistory = 0;
+    elseif value == 1 then
+      this.storehistory = 1;
+    else
+      errmsg = msprintf(gettext("%s: Unexpected value %s for -storehistory option. O or 1 expected"),"optimbase_configure",string(value))
+      error(errmsg)
+    end
   case "-costfargument" then
     this.costfargument = value;
   case "-boundsmin" then
@@ -75,7 +82,7 @@ function this = optimbase_configure (this,key,value)
   case "-nbineqconst" then
     this.nbineqconst = value;
   else
-    errmsg = sprintf("Unknown key %s",key)
+    errmsg = msprintf(gettext("%s: Unknown key %s"),"optimbase_configure",key)
     error(errmsg)
   end
 endfunction
index 2079580..4d76705 100644 (file)
@@ -35,7 +35,7 @@
 //
 function [ this , result ] = optimbase_function ( this , x , index )
   if this.fun == "" then
-    errmsg = sprintf("Empty function (use -fun option).")
+    errmsg = msprintf(gettext("%s: Empty function (use -function option)."), "optimbase_function")
     error(errmsg)
   end
   if typeof(this.costfargument)=="string" then
@@ -52,7 +52,10 @@ function [ this , result ] = optimbase_function ( this , x , index )
     end
   end
   this.funevals = this.funevals + 1;
-  optimbase_log ( this , sprintf ( "Function Evaluation #%d is [%s] at [%s]" , ...
-    this.funevals , strcat(string(result)," ") , strcat(string(x)," ") ))
+  if this.verbose == 1 then
+    msg = sprintf ( "Function Evaluation #%d is [%s] at [%s]" , ...
+      this.funevals , strcat(string(result)," ") , strcat(string(x)," ") )
+    optimbase_log ( this , msg )
+  end
 endfunction
 
index 1c0ab0d..9360b66 100644 (file)
@@ -27,14 +27,14 @@ function value = optimbase_get (this,key)
     value = this.fopt;
   case "-historyxopt" then
     if this.storehistory == 0 then
-      errmsg = sprintf("History disabled ; turn on -storehistory option.")
+      errmsg = msprintf(gettext("%s: History disabled ; enable -storehistory option."),"optimbase_get")
       error(errmsg)
     else
       value = this.historyxopt;
     end
   case "-historyfopt" then
     if this.storehistory == 0 then
-      errmsg = sprintf("History disabled ; turn on -storehistory option.")
+      errmsg = msprintf(gettext("%s: History disabled ; enable -storehistory option."),"optimbase_get")
       error(errmsg)
     else
       value = this.historyfopt;
@@ -44,7 +44,7 @@ function value = optimbase_get (this,key)
   case "-status" then
     value = this.status;
   else
-    errmsg = sprintf("Unknown key %s",key)
+    errmsg = msprintf(gettext("%s: Unknown key %s"),"optimbase_get",key)
     error(errmsg)
   end
 endfunction
index 76161aa..ef83a10 100644 (file)
 //
 function value = optimbase_histget ( this , iter , key )
   if this.storehistory == 0 then
-    errmsg = sprintf("History disabled ; turn on -storehistory option.")
+    errmsg = msprintf(gettext("%s: History disabled ; turn on -storehistory option.") , "optimbase_histget" )
     error(errmsg)
   end
   if iter < 1 then
-    errmsg = sprintf("Negative iteration index are not allowed.")
+    errmsg = msprintf(gettext("%s: Negative iteration index %d is not allowed.") , "optimbase_histget" , iter )
     error(errmsg)
   end
   select key
@@ -31,7 +31,8 @@ function value = optimbase_histget ( this , iter , key )
   case "-fopt" then
     value = this.historyfopt ( iter );
   else
-    errmsg = sprintf("Unknown key %s",key)
+    errmsg = msprintf(gettext("%s: Unknown key %s") , "optimbase_histget" ,key)
     error(errmsg)
   end
 endfunction
+
index 29d1b27..6a3b0f3 100644 (file)
 //
 function this = optimbase_histset ( this , iter , key , value )
   if this.storehistory == 0 then
-    errmsg = sprintf("History disabled ; turn on -storehistory option.")
+    errmsg = msprintf(gettext("%s: History disabled ; turn on -storehistory option.") , "optimbase_histset" )
     error(errmsg)
   end
   if iter < 1 then
-    errmsg = sprintf("Negative iteration index are not allowed.")
+    errmsg = msprintf(gettext("%s: Negative iteration index are not allowed.") , "optimbase_histset" )
     error(errmsg)
   end
   select key
@@ -32,7 +32,7 @@ function this = optimbase_histset ( this , iter , key , value )
   case "-fopt" then
     this.historyfopt ( iter ) = value;
   else
-    errmsg = sprintf("Unknown key %s",key)
+    errmsg = msprintf(gettext("%s: Unknown key %s" ) , "optimbase_histset" , key )
     error(errmsg)
   end
 endfunction
index bba8354..4b2e0be 100644 (file)
@@ -16,7 +16,7 @@
 //
 function  data = optimbase_outstruct ( this )
   if this.outputcommand == "" then
-    errmsg = sprintf("No output command is defined.")
+    errmsg = msprintf( gettext ( "%s: No output command is defined.") , "optimbase_outstruct" )
     error(errmsg)
   else
     data = tlist(["T_OPTDATA",...
index 2e6c514..f0be493 100644 (file)
@@ -23,14 +23,14 @@ function this = optimbase_set ( this , key , value )
     this.fopt = value;
   case "-historyxopt" then
     if this.storehistory == 0 then
-      errmsg = sprintf("History disabled ; turn on -storehistory option.")
+      errmsg = msprintf( gettext ( "%s: History disabled ; turn on -storehistory option.") , "optimbase_set" )
       error(errmsg)
     else
       this.historyxopt = value;
     end
   case "-historyfopt" then
     if this.storehistory == 0 then
-      errmsg = sprintf("History disabled ; turn on -storehistory option.")
+      errmsg = msprintf(gettext ( "%s: History disabled ; turn on -storehistory option.") , "optimbase_set" )
       error(errmsg)
     else
       this.historyfopt = value;
@@ -40,7 +40,7 @@ function this = optimbase_set ( this , key , value )
   case "-status" then
     this.status = value;
   else
-    errmsg = sprintf("Unknown key %s",key)
+    errmsg = msprintf(gettext ( "%s: Unknown key %s") , "optimbase_set", key )
     error(errmsg)
   end
 endfunction
index 710d0ce..4ea4b6e 100644 (file)
@@ -76,7 +76,7 @@ function [this , terminate , status] = optimbase_terminate (this , ...
     case "disabled" then
       // Nothing to do.
     else
-      errmsg = sprintf("Unknown tolf method %s",this.tolfunmethod);
+      errmsg = msprintf(gettext ( "%s: Unknown tolf method %s") , "optimbase_terminate" ,this.tolfunmethod);
       error(errmsg);
     end
   end
@@ -103,7 +103,7 @@ function [this , terminate , status] = optimbase_terminate (this , ...
    case "disabled" then
       // Nothing to do.
     else
-      errmsg = sprintf("Unknown tolx method %s",this.tolxmethod);
+      errmsg = msprintf(gettext ( "%s: Unknown tolx method %s") , "optimbase_terminate" , this.tolxmethod );
       error(errmsg);
     end
   end
diff --git a/scilab/modules/optimization/macros/optimsimplex/newFile.txt b/scilab/modules/optimization/macros/optimsimplex/newFile.txt
new file mode 100644 (file)
index 0000000..84e1796
--- /dev/null
@@ -0,0 +1,5 @@
+for ifile = 8:23;
+mprintf("%s...\n",lf(ifile));
+exec(lf(ifile));
+end
+
diff --git a/scilab/modules/optimization/macros/optimsimplex/newFile2.txt b/scilab/modules/optimization/macros/optimsimplex/newFile2.txt
new file mode 100644 (file)
index 0000000..28a1ea9
--- /dev/null
@@ -0,0 +1,5 @@
+for ifile=12:23
+  mprintf("%s...\n",lf(ifile));
+  exec(lf(ifile));
+end
+
index 5b6a973..391fdfe 100644 (file)
@@ -34,18 +34,18 @@ function [ this , data ] = optimsimplex_axes ( this , x0 , fun , len , data )
   else
     xlen = len
   end
-  this.x = zeros ( n , this.nbve )
-  this.fv = zeros ( this.nbve )
+  this.x = zeros ( this.nbve , n )
+  this.fv = zeros ( this.nbve , 1 )
   //
   // Set 1st point
   //
-  this.x ( 1:n,1 ) = x0 (1:n)'
+  this.x ( 1 , 1:n ) = x0 (1:n)
   //
   // Set points #2 to #n+1
   //
   for j = 2 : this.nbve
-    this.x ( 1:n,j ) = x0 (1:n)'
-    this.x ( j-1,j ) = this.x ( j-1,j ) + xlen(j-1)
+    this.x ( j , 1:n ) = x0 (1:n)
+    this.x ( j , j-1 ) = this.x ( j , j-1 ) + xlen(j-1)
   end
   // Compute Function Value
   if (~isdef('data','local')) then
index 9a635d7..4449e0e 100644 (file)
@@ -14,6 +14,6 @@
 //   <no arg>
 //
 function sicenter = optimsimplex_center ( this )
-  sicenter = mean(this.x,'c');
+  sicenter = mean(this.x,'r');
 endfunction
 
index cc25521..cb10ca8 100644 (file)
 function optimsimplex_check ( this )
   nx1 = size(this.x,1)
   nx2 = size(this.x,2)
-  nf1 = size(this.fv,1)
-  nf2 = size(this.fv,2)
-  if this.n<> 0 & nx1 <> this.n then
-    error(sprintf("Dimension #1 of x is %d is different from dimension = %d\n" , nx1 , this.n ));
+  if this.nbve<> 0 & nx1 <> this.nbve then
+    error(msprintf(gettext("%s: Number of rows of x is %d is different from number of vertices = %d."),"optimsimplex_check" , nx1 , this.nbve ));
   end
-  if this.nbve<> 0 & nx2 <> this.nbve then
-    error(sprintf("Dimension #2 of x is %d is different from dimension + 1 = %d\n" , nx2 , this.n + 1));
+  if this.n<> 0 & nx2 <> this.n then
+    error(msprintf(gettext("%s: Number of columns of x is %d is different from dimension = %d."),"optimsimplex_check" , nx2 , this.n ));
   end
-  if this.nbve<> 0 & nf1 <> this.nbve then
-    error(sprintf("Dimension #1 of fv is %d is different from dimension = %d\n" , nf1 , this.n + 1));
+  nf1 = size(this.fv,1)
+  nf2 = size(this.fv,2)
+  if this.n<> 0 & nf1 <> this.nbve then
+    error(msprintf(gettext("%s: Number of rows of fv is %d is different from number of vertices = %d."),"optimsimplex_check" , nf1 , this.nbve ));
   end
-  if this.n<> 0 & nf2 <> 1 then
-    error(sprintf("Dimension #2 of fv is %d is different from 1\n" , nf2 ));
+  if this.nbve<> 0 & nf2 <> 1 then
+    error(msprintf(gettext("%s: Number of columns of fv is %d is different from 1."),"optimsimplex_check" , nf2 ));
   end
 endfunction
 
index 60dd490..54f0d96 100644 (file)
@@ -17,9 +17,9 @@
 function [ this , data ] = optimsimplex_computefv ( this , fun , data )
   for j = 1 : this.nbve;
     if (~isdef('data','local')) then
-       this.fv(j)  = fun (this.x(:,j));
+       this.fv(j)  = fun (this.x(j,:));
      else
-       [ this.fv(j) , data ]  = fun (this.x(:,j) , data );
+       [ this.fv(j) , data ]  = fun (this.x(j,:) , data );
      end
   end
 endfunction
index 42607c2..9224dd4 100644 (file)
@@ -18,7 +18,7 @@
 function m = optimsimplex_dirmat ( this )
   m = zeros(this.n,this.n)
   for i=1:this.nbve-1
-    m(1:this.n,i) = this.x(1:this.n,i+1) - this.x(1:this.n,1)
+    m(1:this.n,i) = (this.x(i+1,1:this.n) - this.x(1,1:this.n)).'
   end
 endfunction
 
index e5c5396..c8ca938 100644 (file)
@@ -18,8 +18,8 @@
 //   <no arg>
 //
 function simplex = optimsimplex_getall ( this )
-  simplex = zeros( this.nbve , this.n+1 );
-  simplex ( 1:this.nbve , 1 ) = this.fv ( 1:this.nbve )
-  simplex ( 1:this.nbve , 2:this.n+1 ) = this.x ( 1:this.n , 1:this.nbve )'
+  simplex = zeros ( this.nbve , this.n+1 );
+  simplex ( 1:this.nbve , 1 ) = this.fv ( 1:this.nbve , 1 )
+  simplex ( 1:this.nbve , 2:this.n+1 ) = this.x ( 1:this.nbve , 1:this.n )
 endfunction
 
index b4a071f..dee4336 100644 (file)
@@ -17,6 +17,6 @@
 //   <no arg>
 //
 function fv = optimsimplex_getallfv ( this )
-  fv = this.fv ( 1:this.nbve )
+  fv = this.fv ( 1:this.nbve , 1 )
 endfunction
 
index 1759a8d..9689fdb 100644 (file)
@@ -16,6 +16,6 @@
 //   <no arg>
 //
 function x = optimsimplex_getallx ( this )
-  x = this.x (1:this.n , 1:this.nbve )
+  x = this.x ( 1:this.nbve , 1:this.n )
 endfunction
 
index dc2c28b..b2b69d7 100644 (file)
@@ -14,6 +14,6 @@
 //   ive : vertex index
 //
 function fv = optimsimplex_getfv ( this , ive )
-  fv = this.fv ( ive )
+  fv = this.fv ( ive , 1 )
 endfunction
 
index 2e0e077..8557c99 100644 (file)
@@ -17,7 +17,7 @@
 function vertex = optimsimplex_getve ( this , ive )
   vertex = tlist(["T_VERTEX","x","n","fv"]);
   vertex.n = this.n;
-  vertex.x = this.x ( : , ive );
+  vertex.x = this.x ( ive , : );
   vertex.fv = this.fv ( ive );
 endfunction
 
index bba7345..3d45419 100644 (file)
 //
 // optimsimplex_getx --
 //   Returns the coordinates of the vertex at given index,
-//   as a column vector.
+//   as a row vector.
 // Arguments
 //   ive : vertex index
 //
 function x = optimsimplex_getx ( this , ive )
-  x = this.x ( : , ive )
+  x = this.x ( ive , : )
 endfunction
 
index c2fc3f4..b6e2412 100644 (file)
@@ -17,7 +17,7 @@
 //
 function [ g , data ] = optimsimplex_gradientfv ( this , fun , method , data )
   if ( this.nbve <> this.n+1 ) then
-    errmsg = sprintf("The gradient can be applied only with a simplex made of n+1 points, but the dimension is %d and the number of vertices is %d", this.n , this.nbve)
+    errmsg = msprintf(gettext("%s: The gradient can be applied only with a simplex made of n+1 points, but the dimension is %d and the number of vertices is %d"), "optimsimplex_gradientfv" , this.n , this.nbve)
     error(errmsg)
   end
   if (~isdef('method','local')) then
@@ -33,7 +33,7 @@ function [ g , data ] = optimsimplex_gradientfv ( this , fun , method , data )
       [ g , data ] = optimsimplex_gradcenter ( this , fun , data )
     end
   else
-    errmsg = sprintf("Unknown method %s",method)
+    errmsg = msprintf(gettext("%s: Unknown method %s"),"optimsimplex_gradientfv",method)
     error(errmsg)
   end
 endfunction
@@ -46,7 +46,7 @@ endfunction
 function g = optimsimplex_gradforward ( this )
   v = optimsimplex_dirmat ( this )
   d = optimsimplex_deltafv ( this )
-  g = v'\d
+  g = v.'\d
 endfunction
 //
 // optimsimplex_gradcenter --
index 43ad7fe..24907f6 100644 (file)
@@ -18,7 +18,7 @@
 //   * the simplex is made of k>=n+1 vertices
 //   * the function value for vertex #kve is in fv(kve),
 //     with kve = 1 , k
-//   * the vertex #kve is stored in x(1:n,kve)
+//   * the vertex #kve is stored in x(kve,1:n)
 //     with kve = 1 , k
 // Arguments
 //   coords : list of point coordinates in the simplex
@@ -39,29 +39,29 @@ function [ newobj , data ] = optimsimplex_new ( coords , fun , data )
   newobj.n = 0;
   // The number of vertices
   newobj.nbve = 0;
-  // The coordinates of the vertices, with size n x nbve
+  // The coordinates of the vertices, with size nbve x n
   newobj.x = [];
-  // The function values, with size nbve
+  // The function values, with size nbve x 1 
   newobj.fv = [];
   //
   // Take input arguments into account
   //
   if coords<>[] then
-    n = size(coords,1)
-    nbve = size(coords,2)
+    nbve = size(coords,1)
+    n = size(coords,2)
     if nbve < n + 1 then
-      error(sprintf("The numbers of columns of coords is %d but is expected to be at least %d",...
-        nbve , n + 1))
+      error(msprintf(gettext("%s: The numbers of columns of coords is %d but is expected to be at least %d"),...
+        "optimsimplex_new" , nbve , n + 1))
     end
     newobj.n = n;
     newobj.nbve = nbve;
-    newobj.x(1:n,1:nbve) = coords(1:n,1:nbve);
+    newobj.x(1:nbve,1:n) = coords(1:nbve,1:n);
     if fun<>[] then
       for j = 1 : nbve
         if (~isdef('data','local')) then
-          newobj.fv(j)  = fun (newobj.x(1:newobj.n,j));
+          newobj.fv(j)  = fun (newobj.x(j,1:newobj.n));
         else
-          [ newobj.fv(j) , data ]  = fun (newobj.x(1:newobj.n,j) , data );
+          [ newobj.fv(j) , data ]  = fun (newobj.x(j,1:newobj.n) , data );
         end
       end
     end
index 5948f4d..52f68d4 100644 (file)
@@ -18,7 +18,7 @@
 //
 function [ ns , data ] = optimsimplex_oriented ( this , fun , data )
   if ( this.nbve <> this.n+1 ) then
-    errmsg = sprintf("The oriented simplex can be computed only with a simplex made of n+1 points, but the dimension is %d and the number of vertices is %d", this.n , this.nbve)
+    errmsg = msprintf(gettext ( "%s: The oriented simplex can be computed only with a simplex made of n+1 points, but the dimension is %d and the number of vertices is %d") , "optimsimplex_oriented", this.n , this.nbve)
     error(errmsg)
   end
   sgrad = optimsimplex_gradientfv ( this )
@@ -45,18 +45,18 @@ function [ ns , data ] = optimsimplex_oriented ( this , fun , data )
   ns = optimsimplex_new()
   ns.n = this.n
   ns.nbve = this.n+1
-  ns.x = zeros ( n , n+1 )
+  ns.x = zeros ( n+1 , n )
   ns.fv = zeros ( n+1 , 1 )
   // Store 1st point
-  ns.x ( 1:n , 1 ) = this.x ( 1:n , 1 )
+  ns.x ( 1 , 1:n ) = this.x ( 1 , 1:n )
   ns.fv ( 1 ) = this.fv ( 1 )
-  x1 = this.x ( 1:n , 1 )
+  x1 = this.x ( 1 , 1:n )
   for i = 2:n+1
-    ns.x ( 1:n , i ) = mid ( 1:n , i-1 ) + x1 ( 1:n , 1 )
+    ns.x ( i, 1:n ) = mid ( i-1 , 1:n ) + x1 ( 1 , 1:n )
     if (~isdef('data','local')) then
-       ns.fv(i)  = fun (ns.x(:,i));
+       ns.fv(i)  = fun (ns.x(i,:));
      else
-       [ ns.fv(i) , data ]  = fun (ns.x(:,i) , data );
+       [ ns.fv(i) , data ]  = fun (ns.x(i,:) , data );
      end
   end
 endfunction
index 4a513f7..4852d5d 100644 (file)
@@ -33,21 +33,21 @@ function [ this , data ] = optimsimplex_pfeffer ( this , x0 , fun , deltausual ,
   n = length(x0);
   this.n = n;
   this.nbve = n + 1;
-  this.x = zeros ( n , n+1 )
-  this.fv = zeros ( n+1 )
+  this.x = zeros ( n+1 , n )
+  this.fv = zeros ( n+1 , 1 )
   //
   // Set 1st point
   //
-  this.x ( 1:n,1 ) = x0 (1:n)'
+  this.x ( 1 , 1:n ) = x0 (1:n)
   //
   // Set points #2 to #n+1
   //
   for j = 2 : this.n+1
-    this.x ( 1:n,j ) = x0 (1:n)'
+    this.x ( j,1:n ) = x0 (1:n)
     if x0( j-1 ) == 0.0 then
-      this.x ( j-1,j ) = deltazero
+      this.x ( j , j-1 ) = deltazero
     else
-      this.x ( j-1,j ) = this.x ( j-1,j ) + deltausual * x0( j-1 )
+      this.x ( j , j-1 ) = this.x ( j , j-1 ) + deltausual * x0( j-1 )
     end
   end
   // Compute Function Value
index 5e44151..703d348 100644 (file)
@@ -24,11 +24,13 @@ function optimsimplex_print ( this )
   elseif this.fv == [] then
     mprintf("Empty simplex (zero function values)\n");
   else
+  mprintf("Dimension : %d\n" , this.n );
+  mprintf("Number of vertices : %d\n" , this.nbve );
   for k = 1:this.nbve
     // Compute a string for x
-    ss = sprintf("%f", this.x(1,k));
+    ss = sprintf("%f", this.x(k,1));
     for i = 2:this.n
-      ss = ss + " " + sprintf("%f", this.x(i,k));
+      ss = ss + " " + sprintf("%f", this.x(k,i));
     end
     mprintf("Vertex #%d/%d : fv=%f, x=%s\n" , k , this.n+1 , this.fv(k), ss );
   end
index 5993fac..58c6a7d 100644 (file)
@@ -25,12 +25,12 @@ function [ this , data ] = optimsimplex_randbounds ( this , x0 , fun , boundsmin
     n = length ( x0 )
     this.n = n;
     this.nbve = nbve;
-    this.x = zeros ( n , nbve )
-    this.fv = zeros ( nbve )
+    this.x = zeros ( nbve , n )
+    this.fv = zeros ( nbve , 1 )
     //
     // Set 1st point
     //
-    this.x ( 1:n,1 ) = x0 (1:n)'
+    this.x ( 1 , 1:n ) = x0 (1:n)
     //
     // Set points #2 to #nbve, by randomizing the bounds
     //
@@ -40,7 +40,7 @@ function [ this , data ] = optimsimplex_randbounds ( this , x0 , fun , boundsmin
       // between min and max bounds.
       //
       for ix  = 1 : n
-        this.x ( ix , ive ) = boundsmin( ix ) + rand() * (boundsmax( ix ) - boundsmin( ix ))
+        this.x ( ive , ix ) = boundsmin( ix ) + rand() * (boundsmax( ix ) - boundsmin( ix ))
       end
     end
   // Compute Function Value
index d5d746c..b98d98e 100644 (file)
@@ -20,18 +20,18 @@ function [ r , data ] = optimsimplex_reflect ( this , fun , data )
   r = optimsimplex_new ( )
   r.n = this.n
   r.nbve = this.nbve
-  r.x = zeros(r.n, r.nbve )
-  r.fv = zeros( r.nbve )
-  r.x(1:r.n,1) = this.x(1:r.n,1)
+  r.x = zeros ( r.nbve , r.n )
+  r.fv = zeros( r.nbve , 1 )
+  r.x(1,1:r.n) = this.x(1,1:r.n)
   r.fv(1) = this.fv(1)
-  x1 = this.x(1:r.n,1)
+  x1 = this.x(1,1:r.n)
   twox1 = 2*x1
   for i = 2:r.nbve
-    r.x(1:r.n,i) = twox1 - this.x(1:r.n,i)
+    r.x(i,1:r.n) = twox1 - this.x(i,1:r.n)
     if (~isdef('data','local')) then
-       r.fv(i)  = fun (r.x(:,i));
+       r.fv(i)  = fun (r.x(i,:));
      else
-       [ r.fv(i) , data ]  = fun (r.x(:,i) , data );
+       [ r.fv(i) , data ]  = fun (r.x(i,:) , data );
      end
   end
 endfunction
index 9a2c2db..ffcecef 100644 (file)
@@ -22,11 +22,12 @@ function this = optimsimplex_setall ( this , simplex )
   nbve = size(simplex,1)
   np1 = size(simplex,2)
   if np1 > nbve then
-    error(sprintf("The number of vertices (i.e. the number of rows) is %d which is smaller than the number of columns (i.e. n+1) %d",nbve,np1));
+    errmsg = msprintf(gettext ( "%s: The number of vertices (i.e. the number of rows) is %d which is smaller than the number of columns %d (i.e. n+1).") , "optimsimplex_setall",nbve,np1);
+    error(errmsg);
   end
   this.n = np1 - 1;
   this.nbve = nbve;
-  this.fv ( 1:nbve ) = simplex ( 1:nbve , 1 )
-  this.x ( 1:this.n , 1:nbve ) = simplex ( 1:nbve , 2:this.n+1 )'
+  this.fv ( 1:nbve , 1 ) = simplex ( 1:nbve , 1 )
+  this.x ( 1:nbve , 1:this.n ) = simplex ( 1:nbve , 2:this.n+1 )
 endfunction
 
index bcd73b0..a6fc7b2 100644 (file)
 //   fv : the array of function values
 //
 function this = optimsimplex_setallfv ( this , fv )
-  this.fv ( 1:this.nbve ) = fv ( 1:this.nbve );
+  fv1 = size ( fv , 1 );
+  if fv1 <> this.nbve then
+    error ( msprintf ( gettext ( "%s: The number of rows in the function value array is %d, while expected %d." ), "optimsimplex_setallfv" , fv1 , this.nbve ))
+  end
+  fv2 = size ( fv , 2 );
+  if fv2 <> 1 then
+    error ( msprintf ( gettext ( "%s: The number of columns in the function value array is %d, while expected 1." ), "optimsimplex_setallfv" , fv2 ))
+  end
+  this.fv ( 1:this.nbve , 1 ) = fv ( 1:this.nbve );
 endfunction
 
index 9cbd789..686ebb5 100644 (file)
 //
 // optimsimplex_setallx --
 //   Set all the coordinates of all the vertices.
-//   The vertex #k is expected to be stored in x(1:n,k)
+//   The vertex #k is expected to be stored in x(k,1:n)
 //   with k = 1 , nbve
 // Arguments
 //   x : the coordinates of the vertices.
 //
 function this = optimsimplex_setallx ( this , x )
-  this.x (1:this.n , 1:this.nbve ) = x (1:this.n , 1:this.nbve );
+  nx1 = size ( x , 1 );
+  if nx1 <> this.nbve then
+    error ( msprintf ( gettext ( "%s: The number of rows is %d, while expected %d." ), "optimsimplex_setallx" , nx1 , this.nbve ))
+  end
+  nx2 = size ( x , 2 );
+  if nx2 <> this.n then
+    error ( msprintf ( gettext ( "%s: The number of columns is %d, while expected %d." ), "optimsimplex_setallx" , nx2 , this.n ))
+  end
+  this.x ( 1:this.nbve , 1:this.n ) = x ( 1:this.nbve , 1:this.n );
 endfunction
 
index 5a9262c..223141f 100644 (file)
@@ -16,6 +16,6 @@
 //   fv : the function value
 //
 function this = optimsimplex_setfv ( this , ive , fv )
-  this.fv ( ive ) = fv;
+  this.fv ( ive , 1 ) = fv;
 endfunction
 
index b1a7a9c..63ab30a 100644 (file)
 // Arguments
 //   ive : vertex index
 //   fv : the function value
-//   x : the coordinates of the point, as a column vector
+//   x : the coordinates of the point, as a row vector
 //
 function this = optimsimplex_setve ( this , ive , fv , x )
-  this.x(:,ive) = x;
-  this.fv(ive) = fv;
+  this.x(ive,:) = x;
+  this.fv(ive,1) = fv;
 endfunction
 
index a9ef702..11b4a26 100644 (file)
 //
 // optimsimplex_setx --
 //   Set the coordinates of the vertex at given index,
-//   as a column vector, into the current simplex.
+//   as a row vector, into the current simplex.
 // Arguments
 //   ive : vertex index
 //
 function this = optimsimplex_setx ( this , ive , x )
-  this.x (1:this.n , ive ) = x(1:this.n);
+  this.x ( ive , 1:this.n ) = x(1:this.n);
 endfunction
 
index f284142..a40567f 100644 (file)
@@ -23,11 +23,11 @@ function [ this , data ] = optimsimplex_shrink ( this , fun , sigma , data )
     sigma = 0.5;
   end
   for j = 2 : this.nbve;
-     this.x(:,j) = this.x(:,1) + sigma * (this.x(:,j) - this.x(:,1));
+     this.x(j,:) = this.x(1,:) + sigma * (this.x(j,:) - this.x(1,:));
      if (~isdef('data','local')) then
-       this.fv(j)  = fun (this.x(:,j));
+       this.fv(j)  = fun (this.x(j,:));
      else
-       [ this.fv(j) , data ] = fun (this.x(:,j) , data );
+       [ this.fv(j) , data ] = fun (this.x(j,:) , data );
      end
   end
 endfunction
index 17fd32f..073b88e 100644 (file)
@@ -31,30 +31,29 @@ function ssize = optimsimplex_size ( this , method )
   end
   select method
   case "Nash" then
-    // TODO : fix the formula and use norm - 1 instead of euclidian norm (check that Nash indeed use norm 1)
     ssize = 0.0;
     for iv = 2:this.nbve
-      ssize = ssize + norm(this.x(:,iv) - this.x(:,1));
+      ssize = ssize + norm ( this.x(iv,:) - this.x(1,:) , 1 );
     end
   case "diameter" then
     ssize = 0.0;
     for i = 1:this.nbve
       for j = 1:this.nbve
-        ssize = max(ssize , norm(this.x(:,i) - this.x(:,j)));
+        ssize = max(ssize , norm(this.x(i,:) - this.x(j,:)));
       end
     end
   case "sigmaplus" then
     ssize = 0.0;
     for j = 2:this.nbve
-      ssize = max(ssize , norm(this.x(:,j) - this.x(:,1)));
+      ssize = max(ssize , norm(this.x(j,:) - this.x(1,:)));
     end
   case "sigmaminus" then
     ssize = 1.e307;
     for j = 2:this.nbve
-      ssize = min(ssize , norm(this.x(:,j) - this.x(:,1)));
+      ssize = min(ssize , norm(this.x(j,:) - this.x(1,:)));
     end
   else
-    errmsg = sprintf("Unknown simplex size method %s",method)
+    errmsg = msprintf(gettext ( "%s: Unknown simplex size method %s") , "optimsimplex_size",method)
     error(errmsg)
   end
 endfunction
index 6a8f4a4..f2e7e12 100644 (file)
@@ -17,6 +17,6 @@
 //
 function this = optimsimplex_sort ( this )
   [this.fv,is] = gsort(this.fv,"r","i");
-  this.x = this.x( : , is );
+  this.x = this.x ( is , : );
 endfunction
 
index cb14c7a..b85d7de 100644 (file)
@@ -24,8 +24,8 @@ function [ this , data ] = optimsimplex_spendley ( this , x0 , fun , len , data
   n = length(x0);
   this.n = n;
   this.nbve = n + 1;
-  this.x = zeros ( n , n+1 )
-  this.fv = zeros ( n+1 )
+  this.x = zeros ( n+1  , n )
+  this.fv = zeros ( n+1 , 1 )
   //
   // Compute p (diagonal term) , q (off-diagonal term)
   //
@@ -34,15 +34,15 @@ function [ this , data ] = optimsimplex_spendley ( this , x0 , fun , len , data
   //
   // Set 1st point
   //
-  this.x ( 1:n,1 ) = x0 (1:n)'
+  this.x ( 1 , 1:n ) = x0 (1:n)
   //
   // Set points #2 to #n+1
   //
   for j = 2 : this.n+1
     // Note : Vectorize when possible
     // In order to vectorize, add q everywhere, then substract p just for one diagonal term j-1
-    this.x ( 1:n,j ) = x0 (1:n)' + len * q * ones(n,1)
-    this.x ( j-1,j ) = this.x ( j-1,j ) - len * q + len * p
+    this.x ( j , 1:n ) = x0 (1:n) + len * q * ones(1,n)
+    this.x ( j , j-1 ) = this.x ( j , j-1 ) - len * q + len * p
   end
   // Compute Function Value
   if (~isdef('data','local')) then
index 73ec4a7..44ac919 100644 (file)
@@ -27,9 +27,9 @@ function str = optimsimplex_tostring ( this )
   str = []
   for k = 1:this.nbve
     // Compute a string for x
-    ss = sprintf("%f", this.x(1,k));
+    ss = sprintf("%f", this.x(k,1));
     for i = 2:this.n
-      ss = ss + " " + sprintf("%f", this.x(i,k));
+      ss = ss + " " + sprintf("%f", this.x(k,i));
     end
     str(k) = sprintf("Vertex #%d/%d : fv=%f, x=%s\n" , k , this.n+1 , this.fv(k), ss );
   end
index 736962f..16dffd3 100644 (file)
@@ -23,8 +23,8 @@ function cen = optimsimplex_xbar ( this , iexcl )
     iexcl = this.nbve;
   end
   // Vectorize by making the sum of all, substracting only one vector
-  cen = sum(this.x(1:this.n,1:this.nbve),'c')
-  cen = cen - this.x(1:this.n,iexcl)
+  cen = sum(this.x(1:this.nbve,1:this.n),'r')
+  cen = cen - this.x(iexcl,1:this.n)
   cen = cen / ( this.nbve - 1)
 endfunction
 
index 4c3d1da..d3aebc1 100644 (file)
@@ -52,5 +52,13 @@ assert_equal ( output.iterations , 85 );
 assert_equal ( output.algorithm , "Nelder-Mead simplex direct search" );
 assert_equal ( output.funcCount , 159 );
 assert_equal ( output.message(1) , "Optimization terminated:");
-assert_equal ( output.message(2) , "the current x satisfies the termination criteria using OPTIONS.TolX of 1.000000e-04");
-assert_equal ( output.message(3) , "and F(X) satisfies the convergence criteria using OPTIONS.TolFun of 1.000000e-04");
+assert_equal ( output.message(2) , "the current x satisfies the termination criteria using OPTIONS.TolX of 1.000000e-004");
+assert_equal ( output.message(3) , "and F(X) satisfies the convergence criteria using OPTIONS.TolFun of 1.000000e-004");
+// 
+// fminsearch with incorrect number of input arguments
+//
+cmd = "fminsearch ( )";
+execstr(cmd,"errcatch");
+computed = lasterror();
+expected = "fminsearch: Unexpected number of input arguments : 0 provided while 2 or 3 are expected.";
+assert_equal ( computed , expected );
index 47e3aca..aeeca9f 100644 (file)
@@ -53,8 +53,16 @@ assert_equal ( output.iterations , 85 );
 assert_equal ( output.algorithm , "Nelder-Mead simplex direct search" );
 assert_equal ( output.funcCount , 159 );
 assert_equal ( output.message(1) , "Optimization terminated:");
-assert_equal ( output.message(2) , "the current x satisfies the termination criteria using OPTIONS.TolX of 1.000000e-04");
-assert_equal ( output.message(3) , "and F(X) satisfies the convergence criteria using OPTIONS.TolFun of 1.000000e-04");
+assert_equal ( output.message(2) , "the current x satisfies the termination criteria using OPTIONS.TolX of 1.000000e-004");
+assert_equal ( output.message(3) , "and F(X) satisfies the convergence criteria using OPTIONS.TolFun of 1.000000e-004");
 
+// 
+// fminsearch with incorrect number of input arguments
+//
+cmd = "fminsearch ( )";
+execstr(cmd,"errcatch");
+computed = lasterror();
+expected = "fminsearch: Unexpected number of input arguments : 0 provided while 2 or 3 are expected.";
+assert_equal ( computed , expected );
 
 
index 6440c98..5fdcce2 100644 (file)
@@ -83,3 +83,73 @@ iterations = neldermead_get(nm,"-iterations");
 assert_equal ( iterations , 10 );
 // Cleanup
 nm = neldermead_destroy(nm);
+// Wrong -method flag
+nm = neldermead_new ();
+cmd = "nm = neldermead_configure(nm,''-method'',''foo'')";
+execstr(cmd,"errcatch");
+computed = lasterror();
+expected = "neldermead_configure: Unknown value foo for -method option";
+assert_equal ( computed , expected );
+nm = neldermead_destroy(nm);
+// Wrong -simplex0method flag
+nm = neldermead_new ();
+cmd = "nm = neldermead_configure(nm,''-simplex0method'',''foo'')";
+execstr(cmd,"errcatch");
+computed = lasterror();
+expected = "neldermead_configure: Unknown value foo for -simplex0method option";
+assert_equal ( computed , expected );
+nm = neldermead_destroy(nm);
+// Wrong -tolfstdeviationmethod flag
+nm = neldermead_new ();
+cmd = "nm = neldermead_configure(nm,''-tolfstdeviationmethod'',''foo'')";
+execstr(cmd,"errcatch");
+computed = lasterror();
+expected = "neldermead_configure: Unknown value foo for -tolfstdeviationmethod option";
+assert_equal ( computed , expected );
+nm = neldermead_destroy(nm);
+// Wrong -tolsimplexizemethod flag
+nm = neldermead_new ();
+cmd = "nm = neldermead_configure(nm,''-tolsimplexizemethod'',''foo'')";
+execstr(cmd,"errcatch");
+computed = lasterror();
+expected = "neldermead_configure: Unknown value foo for -tolsimplexizemethod option";
+assert_equal ( computed , expected );
+nm = neldermead_destroy(nm);
+// Wrong -tolssizedeltafvmethod flag
+nm = neldermead_new ();
+cmd = "nm = neldermead_configure(nm,''-tolssizedeltafvmethod'',''foo'')";
+execstr(cmd,"errcatch");
+computed = lasterror();
+expected = "neldermead_configure: Unknown value foo for -tolssizedeltafvmethod option";
+assert_equal ( computed , expected );
+nm = neldermead_destroy(nm);
+//
+// Check wrong key for get method
+//
+nm = neldermead_new ();
+nm = neldermead_configure(nm,"-numberofvariables",2);
+nm = neldermead_configure(nm,"-x0",[1.1 1.1]');
+nm = neldermead_configure(nm,"-simplex0method","axes");
+nm = neldermead_configure(nm,"-simplex0length",0.1);
+nm = neldermead_configure(nm,"-method","variable");
+nm = neldermead_configure(nm,"-verbose",0);
+nm = neldermead_configure(nm,"-function",rosenbrock);
+nm = neldermead_configure(nm,"-maxfunevals",2);
+nm = neldermead_search(nm);
+cmd = "funevals = neldermead_get(nm,''-foo'')";
+execstr(cmd,"errcatch");
+computed = lasterror();
+expected = "optimbase_get: Unknown key -foo";
+assert_equal ( computed , expected );
+nm = neldermead_destroy(nm);
+//
+// Check that x0 is forced to be a column vector
+//
+nm = neldermead_new ();
+nm = neldermead_configure(nm,"-numberofvariables",2);
+cmd = "nm = neldermead_configure(nm,''-x0'',[-1.2 1.0]);";
+execstr(cmd,"errcatch");
+computed = lasterror();
+expected = "optimbase_configure: The x0 vector is expected to be a column matrix, but current shape is 1 x 2";
+assert_equal ( computed , expected );
+nm = neldermead_destroy(nm);
index 5876224..5596125 100644 (file)
@@ -89,4 +89,82 @@ assert_equal ( iterations , 10 );
 // Cleanup
 nm = neldermead_destroy(nm);
 
+// Wrong -method flag
+nm = neldermead_new ();
+cmd = "nm = neldermead_configure(nm,''-method'',''foo'')";
+execstr(cmd,"errcatch");
+computed = lasterror();
+expected = "neldermead_configure: Unknown value foo for -method option";
+assert_equal ( computed , expected );
+nm = neldermead_destroy(nm);
+
+// Wrong -simplex0method flag
+nm = neldermead_new ();
+cmd = "nm = neldermead_configure(nm,''-simplex0method'',''foo'')";
+execstr(cmd,"errcatch");
+computed = lasterror();
+expected = "neldermead_configure: Unknown value foo for -simplex0method option";
+assert_equal ( computed , expected );
+nm = neldermead_destroy(nm);
+
+// Wrong -tolfstdeviationmethod flag
+nm = neldermead_new ();
+cmd = "nm = neldermead_configure(nm,''-tolfstdeviationmethod'',''foo'')";
+execstr(cmd,"errcatch");
+computed = lasterror();
+expected = "neldermead_configure: Unknown value foo for -tolfstdeviationmethod option";
+assert_equal ( computed , expected );
+nm = neldermead_destroy(nm);
+
+// Wrong -tolsimplexizemethod flag
+nm = neldermead_new ();
+cmd = "nm = neldermead_configure(nm,''-tolsimplexizemethod'',''foo'')";
+execstr(cmd,"errcatch");
+computed = lasterror();
+expected = "neldermead_configure: Unknown value foo for -tolsimplexizemethod option";
+assert_equal ( computed , expected );
+nm = neldermead_destroy(nm);
+
+// Wrong -tolssizedeltafvmethod flag
+nm = neldermead_new ();
+cmd = "nm = neldermead_configure(nm,''-tolssizedeltafvmethod'',''foo'')";
+execstr(cmd,"errcatch");
+computed = lasterror();
+expected = "neldermead_configure: Unknown value foo for -tolssizedeltafvmethod option";
+assert_equal ( computed , expected );
+nm = neldermead_destroy(nm);
+
+//
+// Check wrong key for get method
+//
+nm = neldermead_new ();
+nm = neldermead_configure(nm,"-numberofvariables",2);
+nm = neldermead_configure(nm,"-x0",[1.1 1.1]');
+nm = neldermead_configure(nm,"-simplex0method","axes");
+nm = neldermead_configure(nm,"-simplex0length",0.1);
+nm = neldermead_configure(nm,"-method","variable");
+nm = neldermead_configure(nm,"-verbose",0);
+nm = neldermead_configure(nm,"-function",rosenbrock);
+nm = neldermead_configure(nm,"-maxfunevals",2);
+nm = neldermead_search(nm);
+cmd = "funevals = neldermead_get(nm,''-foo'')";
+execstr(cmd,"errcatch");
+computed = lasterror();
+expected = "optimbase_get: Unknown key -foo";
+assert_equal ( computed , expected );
+nm = neldermead_destroy(nm);
+
+
+//
+// Check that x0 is forced to be a column vector
+//
+nm = neldermead_new ();
+nm = neldermead_configure(nm,"-numberofvariables",2);
+cmd = "nm = neldermead_configure(nm,''-x0'',[-1.2 1.0]);";
+execstr(cmd,"errcatch");
+computed = lasterror();
+expected = "optimbase_configure: The x0 vector is expected to be a column matrix, but current shape is 1 x 2";
+assert_equal ( computed , expected );
+nm = neldermead_destroy(nm);
+
 
index ba997cc..c684e0a 100644 (file)
@@ -37,49 +37,90 @@ nm = neldermead_configure(nm,"-simplex0method","axes");
 nm = neldermead_configure(nm,"-simplex0length",1.0);
 nm = neldermead_display(nm);
 Nelder-Mead Object
+
 Optimization Object
+
 Verbose logging : 0
+
 Verbose Termination : 0
+
 Store History : 0
+
 Number of variables : 2
+
 Initial Guess :
+
  
     1.  
     2.  
 Initial Function Value :0.000000e+000
+
 Optimum Parameters :
+
  
     0.  
 Optimum Function Value :0.000000e+000
+
 Number of iterations : 0
+
 Maximum number of iterations : 100
+
 Number function evaluations : 0
+
 Maximum number of function evaluations : 100
+
 Termination Method on function value : disabled
+
 Termination Absolute Tolerance on function value : 0
+
 Termination Relative Tolerance on function value : 2.220D-16
+
 Termination Method on x : enabled
+
 Termination Absolute Tolerance on x : 0
+
 Termination Relative Tolerance on x : 2.220D-16
+
 Optimization Status : 
+
 Simplex0 : 
+
 Empty simplex (zero dimension)
+
 Simplex0 Method : axes
+
 Simplex0 Length : 1
+
 Termination Method on simplex size : enabled
+
 Termination Absolute Tolerance on simplex size : 0
+
 Termination Relative Tolerance on simplex size : 2.220D-16
+
 Termination Method on standard deviation of function value : disabled
+
 Termination Tolerance on standard deviation of function value : 0
+
 Termination Method on simplex size + shift of function value : disabled
+
 Termination Tolerance on shift of function value : 2.220D-16
+
 Method : variable
+
 Reflection Factor (rho) : 1
+
 Expansion Factor (chi) : 2
+
 Contraction Factor (gamma) : 0.5
+
 Shrinkage Factor (sigma) : 0.5
+
 Kelley Stagnation : 0
+
 Restart Epsilon : 2.220446e-016
+
 Restart Step : 1
+
 Restart Maximum : 3
+
 nm = neldermead_destroy(nm);
index 68812e5..550341f 100644 (file)
@@ -61,7 +61,7 @@ endfunction
 //    algorithm to "converge" to a point which is not the minimizer
 //    of the function F.
 //
-//    Sample parameter values which cause problems for Nelder-Mead
+//    Sample parameter values which cause problems for Nelder-Mead 
 //    include:
 //
 //      TAU = 1, THETA = 15, PHI =  10;
@@ -72,9 +72,9 @@ endfunction
 //
 //      X1 = (0,0),
 //      X2 = (1,1),
-//      X3 = (A,B),
+//      X3 = (A,B), 
 //
-//    where
+//    where 
 //
 //      A = (1+sqrt(33))/8 =  0.84307...
 //      B = (1-sqrt(33))/8 = -0.59307...
@@ -118,22 +118,13 @@ function f = mckinnon3 ( x )
     f = theta       *       x(1).^tau   + x(2) * ( 1.0 + x(2) );
   end
 endfunction
-lambda1 = (1.0 + sqrt(33.0))/8.0
- lambda1  =
-    0.8430703  
-lambda2 = (1.0 - sqrt(33.0))/8.0
- lambda2  =
-  - 0.5930703  
+lambda1 = (1.0 + sqrt(33.0))/8.0;
+lambda2 = (1.0 - sqrt(33.0))/8.0;
 coords0 = [
-1.0 0.0 lambda1
-1.0 0.0 lambda2
-]
- coords0  =
-    1.    0.    0.8430703  
-    1.    0.  - 0.5930703  
+1.0  1.0
+0.0  0.0 
+lambda1 lambda2
+];
 //
 // Test with default NM
 //
@@ -183,9 +174,9 @@ nm = neldermead_configure(nm,"-verbose",0);
 nm = neldermead_configure(nm,"-verbosetermination",0);
 nm = neldermead_search(nm);
 nm = neldermead_restart ( nm );
-Warning :
-matrix is close to singular or badly scaled. rcond =    6.6651D-13
-computing least squares solution. (see lsq).
+Attention:
+la matrice est presque singulière ou mal conditionnée. rcond =    6.6651D-13
+calcul de la solution des moindres carrés. (voir lsq).
 
 // Check optimum point
 xopt = neldermead_get(nm,"-xopt");
@@ -278,9 +269,9 @@ nm = neldermead_configure(nm,"-tolsimplexizerelative",1.e-6);
 nm = neldermead_configure(nm,"-restartflag",1);
 nm = neldermead_configure(nm,"-restartdetection","oneill");
 nm = neldermead_search(nm);
-Warning :
-matrix is close to singular or badly scaled. rcond =    6.6651D-13
-computing least squares solution. (see lsq).
+Attention:
+la matrice est presque singulière ou mal conditionnée. rcond =    6.6651D-13
+calcul de la solution des moindres carrés. (voir lsq).
 
 // Check status
 status = neldermead_get(nm,"-status");
@@ -380,7 +371,7 @@ nm = neldermead_destroy(nm);
 // Test with auto-restart, Kelley stagnation detection and Kelley restart method
 // Use pfeffer simplex for restart.
 // Use a reduced alpha0 so that restart occur earlier.
-// Pfeffer's initial simplex is the best for restart, since it
+// Pfeffer's initial simplex is the best for restart, since it 
 // respects the optimal point computed so far. It saves tens of iterations.
 //
 nm = neldermead_new ();
index ac224b6..573efc4 100644 (file)
@@ -127,12 +127,13 @@ function f = mckinnon3 ( x )
   end
 endfunction
 
-lambda1 = (1.0 + sqrt(33.0))/8.0
-lambda2 = (1.0 - sqrt(33.0))/8.0
+lambda1 = (1.0 + sqrt(33.0))/8.0;
+lambda2 = (1.0 - sqrt(33.0))/8.0;
 coords0 = [
-1.0 0.0 lambda1
-1.0 0.0 lambda2
-]
+1.0  1.0
+0.0  0.0 
+lambda1 lambda2
+];
 
 //
 // Test with default NM
@@ -418,3 +419,4 @@ assert_equal ( restartnb , 3 );
 nm = neldermead_destroy(nm);
 
 
+
index 6b68358..fa7455e 100644 (file)
@@ -74,11 +74,8 @@ function myoutputcmd ( state , data )
   condv = cond ( v )
   _OUTPUCMDFLAG_ = 1
 endfunction
-global _OUTPUCMDFLAG_
-_OUTPUCMDFLAG_ = 0
- _OUTPUCMDFLAG_  =
-    0.  
+global _OUTPUCMDFLAG_;
+_OUTPUCMDFLAG_ = 0;
 nm = neldermead_new ();
 nm = neldermead_configure(nm,"-numberofvariables",2);
 nm = neldermead_configure(nm,"-function",rosenbrock);
index 40f184e..03c3f03 100644 (file)
@@ -79,8 +79,8 @@ function myoutputcmd ( state , data )
   _OUTPUCMDFLAG_ = 1
 endfunction
 
-global _OUTPUCMDFLAG_
-_OUTPUCMDFLAG_ = 0
+global _OUTPUCMDFLAG_;
+_OUTPUCMDFLAG_ = 0;
 
 nm = neldermead_new ();
 nm = neldermead_configure(nm,"-numberofvariables",2);
index a4c8ef5..33f3119 100644 (file)
@@ -75,11 +75,8 @@ function myoutputcmd ( state , data , myobj )
   condv = cond ( v )
   _OUTPUCMDFLAG_ = myobj.myarg
 endfunction
-global _OUTPUCMDFLAG_
-_OUTPUCMDFLAG_ = 0
- _OUTPUCMDFLAG_  =
-    0.  
+global _OUTPUCMDFLAG_;
+_OUTPUCMDFLAG_ = 0;
 myobj = tlist(["T_MYSTUFF","myarg"]);
 myobj.myarg = 12;
 nm = neldermead_new ();
index c96113f..340270e 100644 (file)
@@ -80,8 +80,8 @@ function myoutputcmd ( state , data , myobj )
   _OUTPUCMDFLAG_ = myobj.myarg
 endfunction
 
-global _OUTPUCMDFLAG_
-_OUTPUCMDFLAG_ = 0
+global _OUTPUCMDFLAG_;
+_OUTPUCMDFLAG_ = 0;
 
 myobj = tlist(["T_MYSTUFF","myarg"]);
 myobj.myarg = 12;
index 73c7556..37f0960 100644 (file)
@@ -45,21 +45,22 @@ endfunction
 //
 // optimtestcase --
 //   Non linear inequality constraints are positive.
-//
+//    
 // Arguments
 //   x: the point where to compute the function
 //   index : the stuff to compute
 // Note
 //  The following protocol is used
-//  * if index=1, or no index, returns the value of the cost
+//  * if index=1, or no index, returns the value of the cost 
 //    function (default case)
-//  * if index=2, returns the value of the nonlinear inequality
+//  * if index=2, returns the value of the nonlinear inequality 
 //    constraints, as a row array
 //  * if index=3, returns an array which contains
-//    at index #0, the value of the cost function
-//    at index #1 to the end is the list of the values of the nonlinear
+//    at index #0, the value of the cost function  
+//    at index #1 to the end is the list of the values of the nonlinear 
 //    constraints
 //  The inequality constraints are expected to be positive.
+//
 function result = optimtestcase ( x , index )
   if (~isdef('index','local')) then
     index = 1
@@ -104,381 +105,6 @@ nm = neldermead_configure(nm,"-nbineqconst",3);
 //nm = neldermead_configure(nm,"-verbose",1);
 nm = neldermead_configure(nm,"-verbosetermination",1);
 nm = neldermead_search(nm);
-  > Termination ?
-  > iterations=2 >= maxiter=200
-  > funevals=15 >= maxfunevals=400
-  > e(x)=4.358899e-001 < tolxrelative = 2.220446e-016 * 5.567764e-001 + 0.000000e+000
-  > simplex size=1.322876e+000 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=3 >= maxiter=200
-  > funevals=20 >= maxfunevals=400
-  > e(x)=2.783882e-001 < tolxrelative = 2.220446e-016 * 8.351647e-001 + 0.000000e+000
-  > simplex size=1.198958e+000 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=4 >= maxiter=200
-  > funevals=23 >= maxfunevals=400
-  > e(x)=3.348857e-001 < tolxrelative = 2.220446e-016 * 9.976339e-001 + 0.000000e+000
-  > simplex size=1.198958e+000 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=5 >= maxiter=200
-  > funevals=28 >= maxfunevals=400
-  > e(x)=4.352509e-001 < tolxrelative = 2.220446e-016 * 1.249496e+000 + 0.000000e+000
-  > simplex size=1.326470e+000 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=6 >= maxiter=200
-  > funevals=31 >= maxfunevals=400
-  > e(x)=3.148639e-001 < tolxrelative = 2.220446e-016 * 1.461238e+000 + 0.000000e+000
-  > simplex size=1.326470e+000 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=7 >= maxiter=200
-  > funevals=34 >= maxfunevals=400
-  > e(x)=1.639206e-001 < tolxrelative = 2.220446e-016 * 1.542140e+000 + 0.000000e+000
-  > simplex size=1.326470e+000 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=8 >= maxiter=200
-  > funevals=39 >= maxfunevals=400
-  > e(x)=3.288705e-001 < tolxrelative = 2.220446e-016 * 1.738147e+000 + 0.000000e+000
-  > simplex size=1.145384e+000 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=9 >= maxiter=200
-  > funevals=46 >= maxfunevals=400
-  > e(x)=2.344701e-001 < tolxrelative = 2.220446e-016 * 1.905021e+000 + 0.000000e+000
-  > simplex size=8.307518e-001 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=10 >= maxiter=200
-  > funevals=51 >= maxfunevals=400
-  > e(x)=2.995587e-001 < tolxrelative = 2.220446e-016 * 2.026916e+000 + 0.000000e+000
-  > simplex size=1.182004e+000 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=11 >= maxiter=200
-  > funevals=55 >= maxfunevals=400
-  > e(x)=2.114067e-001 < tolxrelative = 2.220446e-016 * 2.170119e+000 + 0.000000e+000
-  > simplex size=8.723381e-001 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=12 >= maxiter=200
-  > funevals=58 >= maxfunevals=400
-  > e(x)=1.264653e-001 < tolxrelative = 2.220446e-016 * 2.257854e+000 + 0.000000e+000
-  > simplex size=8.723381e-001 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=13 >= maxiter=200
-  > funevals=65 >= maxfunevals=400
-  > e(x)=1.574793e-001 < tolxrelative = 2.220446e-016 * 2.289552e+000 + 0.000000e+000
-  > simplex size=5.254687e-001 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=14 >= maxiter=200
-  > funevals=72 >= maxfunevals=400
-  > e(x)=1.511584e-001 < tolxrelative = 2.220446e-016 * 2.358510e+000 + 0.000000e+000
-  > simplex size=4.609911e-001 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=15 >= maxiter=200
-  > funevals=79 >= maxfunevals=400
-  > e(x)=6.744531e-002 < tolxrelative = 2.220446e-016 * 2.386364e+000 + 0.000000e+000
-  > simplex size=4.459763e-001 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=16 >= maxiter=200
-  > funevals=82 >= maxfunevals=400
-  > e(x)=1.403441e-001 < tolxrelative = 2.220446e-016 * 2.403719e+000 + 0.000000e+000
-  > simplex size=2.663117e-001 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=17 >= maxiter=200
-  > funevals=85 >= maxfunevals=400
-  > e(x)=3.238584e-002 < tolxrelative = 2.220446e-016 * 2.417932e+000 + 0.000000e+000
-  > simplex size=2.663117e-001 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=18 >= maxiter=200
-  > funevals=92 >= maxfunevals=400
-  > e(x)=7.454087e-002 < tolxrelative = 2.220446e-016 * 2.447937e+000 + 0.000000e+000
-  > simplex size=2.130283e-001 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=19 >= maxiter=200
-  > funevals=95 >= maxfunevals=400
-  > e(x)=4.380698e-002 < tolxrelative = 2.220446e-016 * 2.444115e+000 + 0.000000e+000
-  > simplex size=2.130283e-001 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=20 >= maxiter=200
-  > funevals=100 >= maxfunevals=400
-  > e(x)=7.643638e-002 < tolxrelative = 2.220446e-016 * 2.450120e+000 + 0.000000e+000
-  > simplex size=2.786995e-001 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=21 >= maxiter=200
-  > funevals=105 >= maxfunevals=400
-  > e(x)=4.339215e-002 < tolxrelative = 2.220446e-016 * 2.457592e+000 + 0.000000e+000
-  > simplex size=2.018382e-001 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=22 >= maxiter=200
-  > funevals=112 >= maxfunevals=400
-  > e(x)=2.416666e-002 < tolxrelative = 2.220446e-016 * 2.469797e+000 + 0.000000e+000
-  > simplex size=1.923748e-001 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=23 >= maxiter=200
-  > funevals=117 >= maxfunevals=400
-  > e(x)=7.254334e-002 < tolxrelative = 2.220446e-016 * 2.487622e+000 + 0.000000e+000
-  > simplex size=2.354536e-001 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=24 >= maxiter=200
-  > funevals=122 >= maxfunevals=400
-  > e(x)=5.539105e-002 < tolxrelative = 2.220446e-016 * 2.487855e+000 + 0.000000e+000
-  > simplex size=2.374834e-001 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=25 >= maxiter=200
-  > funevals=125 >= maxfunevals=400
-  > e(x)=3.932503e-002 < tolxrelative = 2.220446e-016 * 2.495953e+000 + 0.000000e+000
-  > simplex size=2.374834e-001 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=26 >= maxiter=200
-  > funevals=128 >= maxfunevals=400
-  > e(x)=2.963071e-002 < tolxrelative = 2.220446e-016 * 2.504500e+000 + 0.000000e+000
-  > simplex size=2.374834e-001 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=27 >= maxiter=200
-  > funevals=132 >= maxfunevals=400
-  > e(x)=4.548522e-002 < tolxrelative = 2.220446e-016 * 2.511878e+000 + 0.000000e+000
-  > simplex size=1.749915e-001 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=28 >= maxiter=200
-  > funevals=136 >= maxfunevals=400
-  > e(x)=3.588222e-002 < tolxrelative = 2.220446e-016 * 2.499451e+000 + 0.000000e+000
-  > simplex size=1.558143e-001 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=29 >= maxiter=200
-  > funevals=139 >= maxfunevals=400
-  > e(x)=3.797535e-002 < tolxrelative = 2.220446e-016 * 2.497421e+000 + 0.000000e+000
-  > simplex size=1.509918e-001 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=30 >= maxiter=200
-  > funevals=141 >= maxfunevals=400
-  > e(x)=3.234005e-002 < tolxrelative = 2.220446e-016 * 2.487518e+000 + 0.000000e+000
-  > simplex size=1.340705e-001 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=31 >= maxiter=200
-  > funevals=145 >= maxfunevals=400
-  > e(x)=2.764833e-002 < tolxrelative = 2.220446e-016 * 2.479074e+000 + 0.000000e+000
-  > simplex size=1.129096e-001 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=32 >= maxiter=200
-  > funevals=152 >= maxfunevals=400
-  > e(x)=1.865953e-002 < tolxrelative = 2.220446e-016 * 2.474460e+000 + 0.000000e+000
-  > simplex size=9.487730e-002 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=33 >= maxiter=200
-  > funevals=159 >= maxfunevals=400
-  > e(x)=2.642599e-002 < tolxrelative = 2.220446e-016 * 2.467001e+000 + 0.000000e+000
-  > simplex size=7.150052e-002 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=34 >= maxiter=200
-  > funevals=163 >= maxfunevals=400
-  > e(x)=2.852273e-002 < tolxrelative = 2.220446e-016 * 2.463238e+000 + 0.000000e+000
-  > simplex size=1.172304e-001 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=35 >= maxiter=200
-  > funevals=168 >= maxfunevals=400
-  > e(x)=1.248065e-002 < tolxrelative = 2.220446e-016 * 2.461798e+000 + 0.000000e+000
-  > simplex size=1.084977e-001 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=36 >= maxiter=200
-  > funevals=173 >= maxfunevals=400
-  > e(x)=1.621389e-002 < tolxrelative = 2.220446e-016 * 2.458571e+000 + 0.000000e+000
-  > simplex size=7.814969e-002 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=37 >= maxiter=200
-  > funevals=176 >= maxfunevals=400
-  > e(x)=1.994018e-002 < tolxrelative = 2.220446e-016 * 2.455128e+000 + 0.000000e+000
-  > simplex size=5.119603e-002 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=38 >= maxiter=200
-  > funevals=180 >= maxfunevals=400
-  > e(x)=1.162791e-002 < tolxrelative = 2.220446e-016 * 2.454514e+000 + 0.000000e+000
-  > simplex size=5.119603e-002 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=39 >= maxiter=200
-  > funevals=189 >= maxfunevals=400
-  > e(x)=1.235758e-002 < tolxrelative = 2.220446e-016 * 2.452559e+000 + 0.000000e+000
-  > simplex size=3.618087e-002 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=40 >= maxiter=200
-  > funevals=194 >= maxfunevals=400
-  > e(x)=3.057777e-003 < tolxrelative = 2.220446e-016 * 2.453452e+000 + 0.000000e+000
-  > simplex size=2.732934e-002 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=41 >= maxiter=200
-  > funevals=196 >= maxfunevals=400
-  > e(x)=3.425909e-003 < tolxrelative = 2.220446e-016 * 2.453154e+000 + 0.000000e+000
-  > simplex size=2.732934e-002 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=42 >= maxiter=200
-  > funevals=199 >= maxfunevals=400
-  > e(x)=9.484081e-003 < tolxrelative = 2.220446e-016 * 2.452604e+000 + 0.000000e+000
-  > simplex size=2.479885e-002 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=43 >= maxiter=200
-  > funevals=204 >= maxfunevals=400
-  > e(x)=9.073482e-003 < tolxrelative = 2.220446e-016 * 2.452744e+000 + 0.000000e+000
-  > simplex size=3.861699e-002 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=44 >= maxiter=200
-  > funevals=208 >= maxfunevals=400
-  > e(x)=3.106971e-003 < tolxrelative = 2.220446e-016 * 2.453285e+000 + 0.000000e+000
-  > simplex size=3.861699e-002 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=45 >= maxiter=200
-  > funevals=210 >= maxfunevals=400
-  > e(x)=7.684907e-004 < tolxrelative = 2.220446e-016 * 2.453642e+000 + 0.000000e+000
-  > simplex size=3.861699e-002 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=46 >= maxiter=200
-  > funevals=213 >= maxfunevals=400
-  > e(x)=7.030344e-003 < tolxrelative = 2.220446e-016 * 2.454321e+000 + 0.000000e+000
-  > simplex size=2.316374e-002 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=47 >= maxiter=200
-  > funevals=218 >= maxfunevals=400
-  > e(x)=2.466125e-003 < tolxrelative = 2.220446e-016 * 2.454066e+000 + 0.000000e+000
-  > simplex size=2.316374e-002 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=48 >= maxiter=200
-  > funevals=223 >= maxfunevals=400
-  > e(x)=3.215696e-003 < tolxrelative = 2.220446e-016 * 2.454173e+000 + 0.000000e+000
-  > simplex size=2.017449e-002 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=49 >= maxiter=200
-  > funevals=226 >= maxfunevals=400
-  > e(x)=4.263304e-003 < tolxrelative = 2.220446e-016 * 2.454118e+000 + 0.000000e+000
-  > simplex size=1.104169e-002 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=50 >= maxiter=200
-  > funevals=231 >= maxfunevals=400
-  > e(x)=1.900429e-003 < tolxrelative = 2.220446e-016 * 2.453549e+000 + 0.000000e+000
-  > simplex size=8.826010e-003 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=51 >= maxiter=200
-  > funevals=236 >= maxfunevals=400
-  > e(x)=3.454449e-003 < tolxrelative = 2.220446e-016 * 2.453355e+000 + 0.000000e+000
-  > simplex size=1.386425e-002 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=52 >= maxiter=200
-  > funevals=241 >= maxfunevals=400
-  > e(x)=3.523397e-003 < tolxrelative = 2.220446e-016 * 2.452929e+000 + 0.000000e+000
-  > simplex size=1.267193e-002 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=53 >= maxiter=200
-  > funevals=246 >= maxfunevals=400
-  > e(x)=1.921832e-003 < tolxrelative = 2.220446e-016 * 2.452367e+000 + 0.000000e+000
-  > simplex size=8.777985e-003 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=54 >= maxiter=200
-  > funevals=249 >= maxfunevals=400
-  > e(x)=1.559366e-003 < tolxrelative = 2.220446e-016 * 2.452085e+000 + 0.000000e+000
-  > simplex size=8.777985e-003 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=55 >= maxiter=200
-  > funevals=252 >= maxfunevals=400
-  > e(x)=3.019163e-003 < tolxrelative = 2.220446e-016 * 2.451967e+000 + 0.000000e+000
-  > simplex size=7.248830e-003 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=56 >= maxiter=200
-  > funevals=257 >= maxfunevals=400
-  > e(x)=1.782925e-003 < tolxrelative = 2.220446e-016 * 2.451463e+000 + 0.000000e+000
-  > simplex size=5.608443e-003 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=57 >= maxiter=200
-  > funevals=264 >= maxfunevals=400
-  > e(x)=8.588946e-004 < tolxrelative = 2.220446e-016 * 2.451228e+000 + 0.000000e+000
-  > simplex size=5.178978e-003 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=58 >= maxiter=200
-  > funevals=268 >= maxfunevals=400
-  > e(x)=3.159263e-003 < tolxrelative = 2.220446e-016 * 2.450791e+000 + 0.000000e+000
-  > simplex size=1.225140e-002 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=59 >= maxiter=200
-  > funevals=271 >= maxfunevals=400
-  > e(x)=1.207485e-003 < tolxrelative = 2.220446e-016 * 2.450447e+000 + 0.000000e+000
-  > simplex size=1.225140e-002 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=60 >= maxiter=200
-  > funevals=276 >= maxfunevals=400
-  > e(x)=1.345284e-003 < tolxrelative = 2.220446e-016 * 2.450047e+000 + 0.000000e+000
-  > simplex size=7.178130e-003 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=61 >= maxiter=200
-  > funevals=281 >= maxfunevals=400
-  > e(x)=2.538992e-003 < tolxrelative = 2.220446e-016 * 2.449846e+000 + 0.000000e+000
-  > simplex size=1.121680e-002 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=62 >= maxiter=200
-  > funevals=285 >= maxfunevals=400
-  > e(x)=1.967072e-003 < tolxrelative = 2.220446e-016 * 2.449516e+000 + 0.000000e+000
-  > simplex size=7.391759e-003 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=63 >= maxiter=200
-  > funevals=290 >= maxfunevals=400
-  > e(x)=1.076738e-003 < tolxrelative = 2.220446e-016 * 2.449384e+000 + 0.000000e+000
-  > simplex size=7.391759e-003 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=64 >= maxiter=200
-  > funevals=297 >= maxfunevals=400
-  > e(x)=8.154450e-004 < tolxrelative = 2.220446e-016 * 2.449286e+000 + 0.000000e+000
-  > simplex size=4.167291e-003 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=65 >= maxiter=200
-  > funevals=299 >= maxfunevals=400
-  > e(x)=5.403283e-004 < tolxrelative = 2.220446e-016 * 2.449302e+000 + 0.000000e+000
-  > simplex size=4.167291e-003 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=66 >= maxiter=200
-  > funevals=306 >= maxfunevals=400
-  > e(x)=6.455706e-004 < tolxrelative = 2.220446e-016 * 2.449294e+000 + 0.000000e+000
-  > simplex size=5.123374e-003 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=67 >= maxiter=200
-  > funevals=313 >= maxfunevals=400
-  > e(x)=1.174043e-003 < tolxrelative = 2.220446e-016 * 2.449312e+000 + 0.000000e+000
-  > simplex size=3.599816e-003 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=68 >= maxiter=200
-  > funevals=318 >= maxfunevals=400
-  > e(x)=8.705936e-004 < tolxrelative = 2.220446e-016 * 2.449273e+000 + 0.000000e+000
-  > simplex size=3.599816e-003 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=69 >= maxiter=200
-  > funevals=323 >= maxfunevals=400
-  > e(x)=3.839780e-004 < tolxrelative = 2.220446e-016 * 2.449242e+000 + 0.000000e+000
-  > simplex size=2.308333e-003 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=70 >= maxiter=200
-  > funevals=330 >= maxfunevals=400
-  > e(x)=2.166809e-004 < tolxrelative = 2.220446e-016 * 2.449274e+000 + 0.000000e+000
-  > simplex size=1.982587e-003 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=71 >= maxiter=200
-  > funevals=335 >= maxfunevals=400
-  > e(x)=8.648287e-004 < tolxrelative = 2.220446e-016 * 2.449270e+000 + 0.000000e+000
-  > simplex size=3.534877e-003 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=72 >= maxiter=200
-  > funevals=338 >= maxfunevals=400
-  > e(x)=6.772983e-004 < tolxrelative = 2.220446e-016 * 2.449276e+000 + 0.000000e+000
-  > simplex size=2.351940e-003 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=73 >= maxiter=200
-  > funevals=347 >= maxfunevals=400
-  > e(x)=1.185077e-004 < tolxrelative = 2.220446e-016 * 2.449257e+000 + 0.000000e+000
-  > simplex size=1.236535e-003 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=74 >= maxiter=200
-  > funevals=352 >= maxfunevals=400
-  > e(x)=4.607701e-004 < tolxrelative = 2.220446e-016 * 2.449295e+000 + 0.000000e+000
-  > simplex size=2.526158e-003 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=75 >= maxiter=200
-  > funevals=356 >= maxfunevals=400
-  > e(x)=5.110641e-004 < tolxrelative = 2.220446e-016 * 2.449289e+000 + 0.000000e+000
-  > simplex size=1.473988e-003 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
-  > Termination ?
-  > iterations=76 >= maxiter=200
-  > funevals=360 >= maxfunevals=400
-  > e(x)=3.968131e-005 < tolxrelative = 2.220446e-016 * 2.449293e+000 + 0.000000e+000
-  > simplex size=9.170352e-004 < 0.000000e+000 + 1.000000e-003 * 1.000000e+000
 // Check optimum point
 xopt = neldermead_get(nm,"-xopt");
 assert_close ( xopt , [0.0 1.0 2.0 -1.0]', 1e-3 );
@@ -505,300 +131,7 @@ nm = neldermead_configure(nm,"-nbineqconst",3);
 //nm = neldermead_configure(nm,"-verbose",1);
 nm = neldermead_configure(nm,"-verbosetermination",1);
 nm = neldermead_search(nm);
-  > Termination ?
-  > iterations=2 >= maxiter=200
-  > funevals=15 >= maxfunevals=300
-  > e(x)=4.358899e-001 < tolxrelative = 2.220446e-016 * 5.567764e-001 + 0.000000e+000
-  > simplex size=1.322876e+000 < 0.000000e+000 + 1.000000e-001 * 1.000000e+000
-  > Termination ?
-  > iterations=3 >= maxiter=200
-  > funevals=20 >= maxfunevals=300
-  > e(x)=2.783882e-001 < tolxrelative = 2.220446e-016 * 8.351647e-001 + 0.000000e+000
-  > simplex size=1.198958e+000 < 0.000000e+000 + 1.000000e-001 * 1.000000e+000
-  > Termination ?
-  > iterations=4 >= maxiter=200
-  > funevals=23 >= maxfunevals=300
-  > e(x)=3.348857e-001 < tolxrelative = 2.220446e-016 * 9.976339e-001 + 0.000000e+000
-  > simplex size=1.198958e+000 < 0.000000e+000 + 1.000000e-001 * 1.000000e+000
-  > Termination ?
-  > iterations=5 >= maxiter=200
-  > funevals=28 >= maxfunevals=300
-  > e(x)=4.352509e-001 < tolxrelative = 2.220446e-016 * 1.249496e+000 + 0.000000e+000
-  > simplex size=1.326470e+000 < 0.000000e+000 + 1.000000e-001 * 1.000000e+000
-  > Termination ?
-  > iterations=6 >= maxiter=200
-  > funevals=31 >= maxfunevals=300
-  > e(x)=3.148639e-001 < tolxrelative = 2.220446e-016 * 1.461238e+000 + 0.000000e+000
-  > simplex size=1.326470e+000 < 0.000000e+000 + 1.000000e-001 * 1.000000e+000
-  > Termination ?
-  > iterations=7 >= maxiter=200
-  > funevals=34 >= maxfunevals=300
-  > e(x)=1.639206e-001 < tolxrelative = 2.220446e-016 * 1.542140e+000 + 0.000000e+000
-  > simplex size=1.326470e+000 < 0.000000e+000 + 1.000000e-001 * 1.000000e+000
-  > Termination ?
-  > iterations=8 >= maxiter=200
-  > funevals=39 >= maxfunevals=300
-  > e(x)=3.288705e-001 < tolxrelative = 2.220446e-016 * 1.738147e+000 + 0.000000e+000
-  > simplex size=1.145384e+000 < 0.000000e+000 + 1.000000e-001 * 1.000000e+000
-  > Termination ?
-  > iterations=9 >= maxiter=200
-  > funevals=46 >= maxfunevals=300
-  > e(x)=2.344701e-001 < tolxrelative = 2.220446e-016 * 1.905021e+000 + 0.000000e+000
-  > simplex size=8.307518e-001 < 0.000000e+000 + 1.000000e-001 * 1.000000e+000
-  > Termination ?
-  > iterations=10 >= maxiter=200
-  > funevals=51 >= maxfunevals=300
-  > e(x)=2.995587e-001 < tolxrelative = 2.220446e-016 * 2.026916e+000 + 0.000000e+000
-  > simplex size=1.182004e+000 < 0.000000e+000 + 1.000000e-001 * 1.000000e+000
-  > Termination ?
-  > iterations=11 >= maxiter=200
-  > funevals=55 >= maxfunevals=300
-  > e(x)=2.114067e-001 < tolxrelative = 2.220446e-016 * 2.170119e+000 + 0.000000e+000
-  > simplex size=8.723381e-001 < 0.000000e+000 + 1.000000e-001 * 1.000000e+000
-  > Termination ?
-  > iterations=12 >= maxiter=200
-  > funevals=58 >= maxfunevals=300
-  > e(x)=1.264653e-001 < tolxrelative = 2.220446e-016 * 2.257854e+000 + 0.000000e+000
-  > simplex size=8.723381e-001 < 0.000000e+000 + 1.000000e-001 * 1.000000e+000
-  > Termination ?
-  > iterations=13 >= maxiter=200
-  > funevals=65 >= maxfunevals=300
-  > e(x)=1.574793e-001 < tolxrelative = 2.220446e-016 * 2.289552e+000 + 0.000000e+000
-  > simplex size=5.254687e-001 < 0.000000e+000 + 1.000000e-001 * 1.000000e+000
-  > Termination ?
-  > iterations=14 >= maxiter=200
-  > funevals=72 >= maxfunevals=300
-  > e(x)=1.511584e-001 < tolxrelative = 2.220446e-016 * 2.358510e+000 + 0.000000e+000
-  > simplex size=4.609911e-001 < 0.000000e+000 + 1.000000e-001 * 1.000000e+000
-  > Termination ?
-  > iterations=15 >= maxiter=200
-  > funevals=79 >= maxfunevals=300
-  > e(x)=6.744531e-002 < tolxrelative = 2.220446e-016 * 2.386364e+000 + 0.000000e+000
-  > simplex size=4.459763e-001 < 0.000000e+000 + 1.000000e-001 * 1.000000e+000
-  > Termination ?
-  > iterations=16 >= maxiter=200
-  > funevals=82 >= maxfunevals=300
-  > e(x)=1.403441e-001 < tolxrelative = 2.220446e-016 * 2.403719e+000 + 0.000000e+000
-  > simplex size=2.663117e-001 < 0.000000e+000 + 1.000000e-001 * 1.000000e+000
-  > Termination ?
-  > iterations=17 >= maxiter=200
-  > funevals=85 >= maxfunevals=300
-  > e(x)=3.238584e-002 < tolxrelative = 2.220446e-016 * 2.417932e+000 + 0.000000e+000
-  > simplex size=2.663117e-001 < 0.000000e+000 + 1.000000e-001 * 1.000000e+000
-  > Termination ?
-  > iterations=18 >= maxiter=200
-  > funevals=92 >= maxfunevals=300
-  > e(x)=7.454087e-002 < tolxrelative = 2.220446e-016 * 2.447937e+000 + 0.000000e+000
-  > simplex size=2.130283e-001 < 0.000000e+000 + 1.000000e-001 * 1.000000e+000
-  > Termination ?
-  > iterations=19 >= maxiter=200
-  > funevals=95 >= maxfunevals=300
-  > e(x)=4.380698e-002 < tolxrelative = 2.220446e-016 * 2.444115e+000 + 0.000000e+000
-  > simplex size=2.130283e-001 < 0.000000e+000 + 1.000000e-001 * 1.000000e+000
-  > Termination ?
-  > iterations=20 >= maxiter=200
-  > funevals=100 >= maxfunevals=300
-  > e(x)=7.643638e-002 < tolxrelative = 2.220446e-016 * 2.450120e+000 + 0.000000e+000
-  > simplex size=2.786995e-001 < 0.000000e+000 + 1.000000e-001 * 1.000000e+000
-  > Termination ?
-  > iterations=21 >= maxiter=200
-  > funevals=105 >= maxfunevals=300
-  > e(x)=4.339215e-002 < tolxrelative = 2.220446e-016 * 2.457592e+000 + 0.000000e+000
-  > simplex size=2.018382e-001 < 0.000000e+000 + 1.000000e-001 * 1.000000e+000
-  > Termination ?
-  > iterations=22 >= maxiter=200
-  > funevals=112 >= maxfunevals=300
-  > e(x)=2.416666e-002 < tolxrelative = 2.220446e-016 * 2.469797e+000 + 0.000000e+000
-  > simplex size=1.923748e-001 < 0.000000e+000 + 1.000000e-001 * 1.000000e+000
-  > Termination ?
-  > iterations=23 >= maxiter=200
-  > funevals=117 >= maxfunevals=300
-  > e(x)=7.254334e-002 < tolxrelative = 2.220446e-016 * 2.487622e+000 + 0.000000e+000
-  > simplex size=2.354536e-001 < 0.000000e+000 + 1.000000e-001 * 1.000000e+000
-  > Termination ?
-  > iterations=24 >= maxiter=200
-  > funevals=122 >= maxfunevals=300
-  > e(x)=5.539105e-002 < tolxrelative = 2.220446e-016 * 2.487855e+000 + 0.000000e+000
-  > simplex size=2.374834e-001 < 0.000000e+000 + 1.000000e-001 * 1.000000e+000
-  > Termination ?
-  > iterations=25 >= maxiter=200
-  > funevals=125 >= maxfunevals=300
-  > e(x)=3.932503e-002 < tolxrelative = 2.220446e-016 * 2.495953e+000 + 0.000000e+000
-  > simplex size=2.374834e-001 < 0.000000e+000 + 1.000000e-001 * 1.000000e+000
-  > Termination ?
-  > iterations=26 >= maxiter=200
-  > funevals=128 >= maxfunevals=300
-  > e(x)=2.963071e-002 < tolxrelative = 2.220446e-016 * 2.504500e+000 + 0.000000e+000
-  > simplex size=2.374834e-001 < 0.000000e+000 + 1.000000e-001 * 1.000000e+000
-  > Termination ?
-  > iterations=27 >= maxiter=200
-  > funevals=132 >= maxfunevals=300
-  > e(x)=4.548522e-002 < tolxrelative = 2.220446e-016 * 2.511878e+000 + 0.000000e+000
-  > simplex size=1.749915e-001 < 0.000000e+000 + 1.000000e-001 * 1.000000e+000
-  > Termination ?
-  > iterations=28 >= maxiter=200
-  > funevals=136 >= maxfunevals=300
-  > e(x)=3.588222e-002 < tolxrelative = 2.220446e-016 * 2.499451e+000 + 0.000000e+000
-  > simplex size=1.558143e-001 < 0.000000e+000 + 1.000000e-001 * 1.000000e+000
-  > Termination ?
-  > iterations=29 >= maxiter=200
-  > funevals=139 >= maxfunevals=300
-  > e(x)=3.797535e-002 < tolxrelative = 2.220446e-016 * 2.497421e+000 + 0.000000e+000
-  > simplex size=1.509918e-001 < 0.000000e+000 + 1.000000e-001 * 1.000000e+000
-  > Termination ?
-  > iterations=30 >= maxiter=200
-  > funevals=141 >= maxfunevals=300
-  > e(x)=3.234005e-002 < tolxrelative = 2.220446e-016 * 2.487518e+000 + 0.000000e+000
-  > simplex size=1.340705e-001 < 0.000000e+000 + 1.000000e-001 * 1.000000e+000
-  > Termination ?
-  > iterations=31 >= maxiter=200
-  > funevals=145 >= maxfunevals=300
-  > e(x)=2.764833e-002 < tolxrelative = 2.220446e-016 * 2.479074e+000 + 0.000000e+000
-  > simplex size=1.129096e-001 < 0.000000e+000 + 1.000000e-001 * 1.000000e+000
-  > Termination ?
-  > iterations=32 >= maxiter=200
-  > funevals=152 >= maxfunevals=300
-  > e(x)=1.865953e-002 < tolxrelative = 2.220446e-016 * 2.474460e+000 + 0.000000e+000
-  > simplex size=9.487730e-002 < 0.000000e+000 + 1.000000e-001 * 1.000000e+000
 nm = neldermead_restart(nm);
-  > Termination ?
-  > iterations=34 >= maxiter=200
-  > funevals=184 >= maxfunevals=300
-  > e(x)=1.124638e-004 < tolxrelative = 2.220446e-016 * 2.468844e+000 + 0.000000e+000
-  > simplex size=1.673428e-003 < 0.000000e+000 + 1.000000e-001 * 1.183292e-003
-  > Termination ?
-  > iterations=35 >= maxiter=200
-  > funevals=188 >= maxfunevals=300
-  > e(x)=4.680050e-004 < tolxrelative = 2.220446e-016 * 2.469089e+000 + 0.000000e+000
-  > simplex size=1.950589e-003 < 0.000000e+000 + 1.000000e-001 * 1.183292e-003
-  > Termination ?
-  > iterations=36 >= maxiter=200
-  > funevals=192 >= maxfunevals=300
-  > e(x)=6.507066e-004 < tolxrelative = 2.220446e-016 * 2.469120e+000 + 0.000000e+000
-  > simplex size=2.576293e-003 < 0.000000e+000 + 1.000000e-001 * 1.183292e-003
-  > Termination ?
-  > iterations=37 >= maxiter=200
-  > funevals=197 >= maxfunevals=300
-  > e(x)=5.007163e-004 < tolxrelative = 2.220446e-016 * 2.469306e+000 + 0.000000e+000
-  > simplex size=2.226975e-003 < 0.000000e+000 + 1.000000e-001 * 1.183292e-003
-  > Termination ?
-  > iterations=38 >= maxiter=200
-  > funevals=201 >= maxfunevals=300
-  > e(x)=9.519262e-004 < tolxrelative = 2.220446e-016 * 2.469605e+000 + 0.000000e+000
-  > simplex size=3.934950e-003 < 0.000000e+000 + 1.000000e-001 * 1.183292e-003
-  > Termination ?
-  > iterations=39 >= maxiter=200
-  > funevals=206 >= maxfunevals=300
-  > e(x)=7.134623e-004 < tolxrelative = 2.220446e-016 * 2.469908e+000 + 0.000000e+000
-  > simplex size=3.273174e-003 < 0.000000e+000 + 1.000000e-001 * 1.183292e-003
-  > Termination ?
-  > iterations=40 >= maxiter=200
-  > funevals=210 >= maxfunevals=300
-  > e(x)=1.570939e-003 < tolxrelative = 2.220446e-016 * 2.470035e+000 + 0.000000e+000
-  > simplex size=6.392796e-003 < 0.000000e+000 + 1.000000e-001 * 1.183292e-003
-  > Termination ?
-  > iterations=41 >= maxiter=200
-  > funevals=212 >= maxfunevals=300
-  > e(x)=1.067205e-003 < tolxrelative = 2.220446e-016 * 2.470451e+000 + 0.000000e+000
-  > simplex size=6.392796e-003 < 0.000000e+000 + 1.000000e-001 * 1.183292e-003
-  > Termination ?
-  > iterations=42 >= maxiter=200
-  > funevals=216 >= maxfunevals=300
-  > e(x)=2.370302e-003 < tolxrelative = 2.220446e-016 * 2.471033e+000 + 0.000000e+000
-  > simplex size=9.836926e-003 < 0.000000e+000 + 1.000000e-001 * 1.183292e-003
-  > Termination ?
-  > iterations=43 >= maxiter=200
-  > funevals=218 >= maxfunevals=300
-  > e(x)=1.495362e-003 < tolxrelative = 2.220446e-016 * 2.471348e+000 + 0.000000e+000
-  > simplex size=9.836926e-003 < 0.000000e+000 + 1.000000e-001 * 1.183292e-003
-  > Termination ?
-  > iterations=44 >= maxiter=200
-  > funevals=221 >= maxfunevals=300
-  > e(x)=1.901234e-003 < tolxrelative = 2.220446e-016 * 2.471663e+000 + 0.000000e+000
-  > simplex size=6.850012e-003 < 0.000000e+000 + 1.000000e-001 * 1.183292e-003
-  > Termination ?
-  > iterations=45 >= maxiter=200
-  > funevals=228 >= maxfunevals=300
-  > e(x)=1.511841e-003 < tolxrelative = 2.220446e-016 * 2.471807e+000 + 0.000000e+000
-  > simplex size=6.091023e-003 < 0.000000e+000 + 1.000000e-001 * 1.183292e-003
-  > Termination ?
-  > iterations=46 >= maxiter=200
-  > funevals=239 >= maxfunevals=300
-  > e(x)=1.201675e-003 < tolxrelative = 2.220446e-016 * 2.472210e+000 + 0.000000e+000
-  > simplex size=2.026149e-003 < 0.000000e+000 + 1.000000e-001 * 1.183292e-003
-  > Termination ?
-  > iterations=47 >= maxiter=200
-  > funevals=248 >= maxfunevals=300
-  > e(x)=4.737696e-004 < tolxrelative = 2.220446e-016 * 2.472282e+000 + 0.000000e+000
-  > simplex size=1.029709e-003 < 0.000000e+000 + 1.000000e-001 * 1.183292e-003
-  > Termination ?
-  > iterations=48 >= maxiter=200
-  > funevals=255 >= maxfunevals=300
-  > e(x)=2.618109e-004 < tolxrelative = 2.220446e-016 * 2.472356e+000 + 0.000000e+000
-  > simplex size=9.826365e-004 < 0.000000e+000 + 1.000000e-001 * 1.183292e-003
-  > Termination ?
-  > iterations=49 >= maxiter=200
-  > funevals=259 >= maxfunevals=300
-  > e(x)=6.363410e-004 < tolxrelative = 2.220446e-016 * 2.472176e+000 + 0.000000e+000
-  > simplex size=2.508893e-003 < 0.000000e+000 + 1.000000e-001 * 1.183292e-003
-  > Termination ?
-  > iterations=50 >= maxiter=200
-  > funevals=262 >= maxfunevals=300
-  > e(x)=1.345360e-004 < tolxrelative = 2.220446e-016 * 2.472242e+000 + 0.000000e+000
-  > simplex size=2.508893e-003 < 0.000000e+000 + 1.000000e-001 * 1.183292e-003
-  > Termination ?
-  > iterations=51 >= maxiter=200
-  > funevals=265 >= maxfunevals=300
-  > e(x)=2.916854e-004 < tolxrelative = 2.220446e-016 * 2.472186e+000 + 0.000000e+000
-  > simplex size=2.321572e-003 < 0.000000e+000 + 1.000000e-001 * 1.183292e-003
-  > Termination ?
-  > iterations=52 >= maxiter=200
-  > funevals=269 >= maxfunevals=300
-  > e(x)=2.189269e-004 < tolxrelative = 2.220446e-016 * 2.472139e+000 + 0.000000e+000
-  > simplex size=2.321572e-003 < 0.000000e+000 + 1.000000e-001 * 1.183292e-003
-  > Termination ?
-  > iterations=53 >= maxiter=200
-  > funevals=273 >= maxfunevals=300
-  > e(x)=7.736780e-004 < tolxrelative = 2.220446e-016 * 2.471901e+000 + 0.000000e+000
-  > simplex size=3.403339e-003 < 0.000000e+000 + 1.000000e-001 * 1.183292e-003
-  > Termination ?
-  > iterations=54 >= maxiter=200
-  > funevals=275 >= maxfunevals=300
-  > e(x)=6.748210e-004 < tolxrelative = 2.220446e-016 * 2.471688e+000 + 0.000000e+000
-  > simplex size=2.694106e-003 < 0.000000e+000 + 1.000000e-001 * 1.183292e-003
-  > Termination ?
-  > iterations=55 >= maxiter=200
-  > funevals=279 >= maxfunevals=300
-  > e(x)=9.755855e-004 < tolxrelative = 2.220446e-016 * 2.471369e+000 + 0.000000e+000
-  > simplex size=4.854902e-003 < 0.000000e+000 + 1.000000e-001 * 1.183292e-003
-  > Termination ?
-  > iterations=56 >= maxiter=200
-  > funevals=283 >= maxfunevals=300
-  > e(x)=1.690332e-003 < tolxrelative = 2.220446e-016 * 2.470822e+000 + 0.000000e+000
-  > simplex size=7.324300e-003 < 0.000000e+000 + 1.000000e-001 * 1.183292e-003
-  > Termination ?
-  > iterations=57 >= maxiter=200
-  > funevals=287 >= maxfunevals=300
-  > e(x)=2.113511e-003 < tolxrelative = 2.220446e-016 * 2.470169e+000 + 0.000000e+000
-  > simplex size=9.073382e-003 < 0.000000e+000 + 1.000000e-001 * 1.183292e-003
-  > Termination ?
-  > iterations=58 >= maxiter=200
-  > funevals=290 >= maxfunevals=300
-  > e(x)=1.290298e-003 < tolxrelative = 2.220446e-016 * 2.469761e+000 + 0.000000e+000
-  > simplex size=9.023750e-003 < 0.000000e+000 + 1.000000e-001 * 1.183292e-003
-  > Termination ?
-  > iterations=59 >= maxiter=200
-  > funevals=293 >= maxfunevals=300
-  > e(x)=1.754453e-003 < tolxrelative = 2.220446e-016 * 2.469197e+000 + 0.000000e+000
-  > simplex size=6.843233e-003 < 0.000000e+000 + 1.000000e-001 * 1.183292e-003
-  > Termination ?
-  > iterations=60 >= maxiter=200
-  > funevals=297 >= maxfunevals=300
-  > e(x)=1.327273e-003 < tolxrelative = 2.220446e-016 * 2.468784e+000 + 0.000000e+000
-  > simplex size=3.249848e-003 < 0.000000e+000 + 1.000000e-001 * 1.183292e-003
-  > Termination ?
-  > iterations=61 >= maxiter=200
-  > funevals=304 >= maxfunevals=300
 // Check optimum point
 xopt = neldermead_get(nm,"-xopt");
 assert_close ( xopt , [0.0 1.0 2.0 -1.0]', 1e-1 );
@@ -811,7 +144,7 @@ assert_equal ( status , "maxfuneval" );
 nm = neldermead_destroy(nm);
 //
 // Test with Box algorithm and default axes initial simplex
-// Add bounds and simplex initial length so that there is a need
+// Add bounds and simplex initial length so that there is a need 
 // for variable projection.
 //
 nm = neldermead_new ();
@@ -830,686 +163,6 @@ nm = neldermead_configure(nm,"-boundsmin",[-10.0 -10.0 -10.0 -10.0]);
 nm = neldermead_configure(nm,"-boundsmax",[10.0 10.0 10.0 10.0]);
 nm = neldermead_configure(nm,"-simplex0length",20.0);
 nm = neldermead_search(nm);
-  > Termination ?
-  > iterations=2 >= maxiter=200
-  > funevals=29 >= maxfunevals=1000
-  > e(x)=7.630697e-001 < tolxrelative = 2.220446e-016 * 5.730350e-001 + 0.000000e+000
-  > simplex size=1.767767e+000 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=3 >= maxiter=200
-  > funevals=34 >= maxfunevals=1000
-  > e(x)=2.865175e-001 < tolxrelative = 2.220446e-016 * 8.595525e-001 + 0.000000e+000
-  > simplex size=1.380515e+000 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=4 >= maxiter=200
-  > funevals=39 >= maxfunevals=1000
-  > e(x)=4.492188e-001 < tolxrelative = 2.220446e-016 * 1.232204e+000 + 0.000000e+000
-  > simplex size=1.621094e+000 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=5 >= maxiter=200
-  > funevals=46 >= maxfunevals=1000
-  > e(x)=4.016584e-001 < tolxrelative = 2.220446e-016 * 1.446825e+000 + 0.000000e+000
-  > simplex size=1.139677e+000 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=6 >= maxiter=200
-  > funevals=51 >= maxfunevals=1000
-  > e(x)=3.918518e-001 < tolxrelative = 2.220446e-016 * 1.603794e+000 + 0.000000e+000
-  > simplex size=1.343497e+000 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=7 >= maxiter=200
-  > funevals=58 >= maxfunevals=1000
-  > e(x)=3.209602e-001 < tolxrelative = 2.220446e-016 * 1.824417e+000 + 0.000000e+000
-  > simplex size=1.170179e+000 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=8 >= maxiter=200
-  > funevals=65 >= maxfunevals=1000
-  > e(x)=2.526313e-001 < tolxrelative = 2.220446e-016 * 2.010245e+000 + 0.000000e+000
-  > simplex size=8.691085e-001 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=9 >= maxiter=200
-  > funevals=68 >= maxfunevals=1000
-  > e(x)=2.058352e-001 < tolxrelative = 2.220446e-016 * 2.025785e+000 + 0.000000e+000
-  > simplex size=8.691085e-001 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=10 >= maxiter=200
-  > funevals=75 >= maxfunevals=1000
-  > e(x)=2.360624e-001 < tolxrelative = 2.220446e-016 * 2.141580e+000 + 0.000000e+000
-  > simplex size=8.069246e-001 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=11 >= maxiter=200
-  > funevals=82 >= maxfunevals=1000
-  > e(x)=2.139363e-001 < tolxrelative = 2.220446e-016 * 2.192006e+000 + 0.000000e+000
-  > simplex size=6.921128e-001 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=12 >= maxiter=200
-  > funevals=87 >= maxfunevals=1000
-  > e(x)=2.350660e-001 < tolxrelative = 2.220446e-016 * 2.245969e+000 + 0.000000e+000
-  > simplex size=9.324031e-001 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=13 >= maxiter=200
-  > funevals=90 >= maxfunevals=1000
-  > e(x)=1.391288e-001 < tolxrelative = 2.220446e-016 * 2.321051e+000 + 0.000000e+000
-  > simplex size=9.324031e-001 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=14 >= maxiter=200
-  > funevals=95 >= maxfunevals=1000
-  > e(x)=8.816075e-002 < tolxrelative = 2.220446e-016 * 2.347201e+000 + 0.000000e+000
-  > simplex size=6.706970e-001 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=15 >= maxiter=200
-  > funevals=100 >= maxfunevals=1000
-  > e(x)=1.288280e-001 < tolxrelative = 2.220446e-016 * 2.369018e+000 + 0.000000e+000
-  > simplex size=5.500473e-001 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=16 >= maxiter=200
-  > funevals=104 >= maxfunevals=1000
-  > e(x)=1.505887e-001 < tolxrelative = 2.220446e-016 * 2.413347e+000 + 0.000000e+000
-  > simplex size=5.500473e-001 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=17 >= maxiter=200
-  > funevals=108 >= maxfunevals=1000
-  > e(x)=8.834345e-002 < tolxrelative = 2.220446e-016 * 2.414928e+000 + 0.000000e+000
-  > simplex size=5.500473e-001 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=18 >= maxiter=200
-  > funevals=113 >= maxfunevals=1000
-  > e(x)=1.318806e-001 < tolxrelative = 2.220446e-016 * 2.423334e+000 + 0.000000e+000
-  > simplex size=4.574567e-001 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=19 >= maxiter=200
-  > funevals=120 >= maxfunevals=1000
-  > e(x)=9.240782e-002 < tolxrelative = 2.220446e-016 * 2.435367e+000 + 0.000000e+000
-  > simplex size=3.488770e-001 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=20 >= maxiter=200
-  > funevals=125 >= maxfunevals=1000
-  > e(x)=1.102566e-001 < tolxrelative = 2.220446e-016 * 2.433052e+000 + 0.000000e+000
-  > simplex size=5.156569e-001 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=21 >= maxiter=200
-  > funevals=129 >= maxfunevals=1000
-  > e(x)=9.541395e-002 < tolxrelative = 2.220446e-016 * 2.445407e+000 + 0.000000e+000
-  > simplex size=3.200077e-001 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=22 >= maxiter=200
-  > funevals=133 >= maxfunevals=1000
-  > e(x)=8.192473e-002 < tolxrelative = 2.220446e-016 * 2.458145e+000 + 0.000000e+000
-  > simplex size=4.406945e-001 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=23 >= maxiter=200
-  > funevals=137 >= maxfunevals=1000
-  > e(x)=5.120428e-002 < tolxrelative = 2.220446e-016 * 2.459382e+000 + 0.000000e+000
-  > simplex size=4.406945e-001 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=24 >= maxiter=200
-  > funevals=140 >= maxfunevals=1000
-  > e(x)=8.175282e-002 < tolxrelative = 2.220446e-016 * 2.465350e+000 + 0.000000e+000
-  > simplex size=3.397314e-001 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=25 >= maxiter=200
-  > funevals=145 >= maxfunevals=1000
-  > e(x)=4.103975e-002 < tolxrelative = 2.220446e-016 * 2.470083e+000 + 0.000000e+000
-  > simplex size=2.280540e-001 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=26 >= maxiter=200
-  > funevals=148 >= maxfunevals=1000
-  > e(x)=5.862091e-002 < tolxrelative = 2.220446e-016 * 2.482558e+000 + 0.000000e+000
-  > simplex size=2.206454e-001 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=27 >= maxiter=200
-  > funevals=151 >= maxfunevals=1000
-  > e(x)=7.163431e-002 < tolxrelative = 2.220446e-016 * 2.494318e+000 + 0.000000e+000
-  > simplex size=1.472891e-001 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=28 >= maxiter=200
-  > funevals=155 >= maxfunevals=1000
-  > e(x)=3.555386e-002 < tolxrelative = 2.220446e-016 * 2.500617e+000 + 0.000000e+000
-  > simplex size=1.472891e-001 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=29 >= maxiter=200
-  > funevals=162 >= maxfunevals=1000
-  > e(x)=2.112232e-002 < tolxrelative = 2.220446e-016 * 2.499325e+000 + 0.000000e+000
-  > simplex size=7.927358e-002 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=30 >= maxiter=200
-  > funevals=167 >= maxfunevals=1000
-  > e(x)=1.966868e-002 < tolxrelative = 2.220446e-016 * 2.498603e+000 + 0.000000e+000
-  > simplex size=1.035577e-001 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=31 >= maxiter=200
-  > funevals=172 >= maxfunevals=1000
-  > e(x)=3.213114e-002 < tolxrelative = 2.220446e-016 * 2.491949e+000 + 0.000000e+000
-  > simplex size=1.253450e-001 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=32 >= maxiter=200
-  > funevals=179 >= maxfunevals=1000
-  > e(x)=2.732984e-002 < tolxrelative = 2.220446e-016 * 2.487208e+000 + 0.000000e+000
-  > simplex size=9.304604e-002 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=33 >= maxiter=200
-  > funevals=184 >= maxfunevals=1000
-  > e(x)=1.744415e-002 < tolxrelative = 2.220446e-016 * 2.490211e+000 + 0.000000e+000
-  > simplex size=1.010491e-001 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=34 >= maxiter=200
-  > funevals=189 >= maxfunevals=1000
-  > e(x)=1.383679e-002 < tolxrelative = 2.220446e-016 * 2.486483e+000 + 0.000000e+000
-  > simplex size=8.207293e-002 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=35 >= maxiter=200
-  > funevals=192 >= maxfunevals=1000
-  > e(x)=2.262400e-002 < tolxrelative = 2.220446e-016 * 2.482671e+000 + 0.000000e+000
-  > simplex size=6.433698e-002 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=36 >= maxiter=200
-  > funevals=196 >= maxfunevals=1000
-  > e(x)=1.373422e-002 < tolxrelative = 2.220446e-016 * 2.483715e+000 + 0.000000e+000
-  > simplex size=6.433698e-002 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=37 >= maxiter=200
-  > funevals=201 >= maxfunevals=1000
-  > e(x)=1.067936e-002 < tolxrelative = 2.220446e-016 * 2.484971e+000 + 0.000000e+000
-  > simplex size=6.832413e-002 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=38 >= maxiter=200
-  > funevals=204 >= maxfunevals=1000
-  > e(x)=1.785258e-002 < tolxrelative = 2.220446e-016 * 2.480842e+000 + 0.000000e+000
-  > simplex size=6.832413e-002 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=39 >= maxiter=200
-  > funevals=209 >= maxfunevals=1000
-  > e(x)=1.670224e-002 < tolxrelative = 2.220446e-016 * 2.482480e+000 + 0.000000e+000
-  > simplex size=7.125421e-002 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=40 >= maxiter=200
-  > funevals=214 >= maxfunevals=1000
-  > e(x)=6.114099e-003 < tolxrelative = 2.220446e-016 * 2.481439e+000 + 0.000000e+000
-  > simplex size=4.206530e-002 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=41 >= maxiter=200
-  > funevals=219 >= maxfunevals=1000
-  > e(x)=6.912106e-003 < tolxrelative = 2.220446e-016 * 2.482566e+000 + 0.000000e+000
-  > simplex size=5.903646e-002 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=42 >= maxiter=200
-  > funevals=223 >= maxfunevals=1000
-  > e(x)=1.425794e-002 < tolxrelative = 2.220446e-016 * 2.484934e+000 + 0.000000e+000
-  > simplex size=2.047915e-002 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=43 >= maxiter=200
-  > funevals=226 >= maxfunevals=1000
-  > e(x)=4.278056e-003 < tolxrelative = 2.220446e-016 * 2.483940e+000 + 0.000000e+000
-  > simplex size=2.047915e-002 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=44 >= maxiter=200
-  > funevals=233 >= maxfunevals=1000
-  > e(x)=5.997035e-003 < tolxrelative = 2.220446e-016 * 2.483160e+000 + 0.000000e+000
-  > simplex size=2.241418e-002 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=45 >= maxiter=200
-  > funevals=235 >= maxfunevals=1000
-  > e(x)=7.838422e-003 < tolxrelative = 2.220446e-016 * 2.481333e+000 + 0.000000e+000
-  > simplex size=1.810695e-002 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=46 >= maxiter=200
-  > funevals=242 >= maxfunevals=1000
-  > e(x)=3.387568e-003 < tolxrelative = 2.220446e-016 * 2.482065e+000 + 0.000000e+000
-  > simplex size=2.329937e-002 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=47 >= maxiter=200
-  > funevals=246 >= maxfunevals=1000
-  > e(x)=8.423113e-003 < tolxrelative = 2.220446e-016 * 2.481677e+000 + 0.000000e+000
-  > simplex size=3.570538e-002 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=48 >= maxiter=200
-  > funevals=250 >= maxfunevals=1000
-  > e(x)=1.085350e-002 < tolxrelative = 2.220446e-016 * 2.479331e+000 + 0.000000e+000
-  > simplex size=5.146165e-002 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=49 >= maxiter=200
-  > funevals=253 >= maxfunevals=1000
-  > e(x)=2.876255e-003 < tolxrelative = 2.220446e-016 * 2.479930e+000 + 0.000000e+000
-  > simplex size=5.146165e-002 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=50 >= maxiter=200
-  > funevals=257 >= maxfunevals=1000
-  > e(x)=1.168008e-002 < tolxrelative = 2.220446e-016 * 2.478334e+000 + 0.000000e+000
-  > simplex size=6.596546e-002 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=51 >= maxiter=200
-  > funevals=261 >= maxfunevals=1000
-  > e(x)=2.618126e-002 < tolxrelative = 2.220446e-016 * 2.475116e+000 + 0.000000e+000
-  > simplex size=1.070430e-001 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=52 >= maxiter=200
-  > funevals=266 >= maxfunevals=1000
-  > e(x)=1.407594e-002 < tolxrelative = 2.220446e-016 * 2.472398e+000 + 0.000000e+000
-  > simplex size=7.929867e-002 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=53 >= maxiter=200
-  > funevals=273 >= maxfunevals=1000
-  > e(x)=1.924739e-002 < tolxrelative = 2.220446e-016 * 2.469539e+000 + 0.000000e+000
-  > simplex size=6.831674e-002 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=54 >= maxiter=200
-  > funevals=282 >= maxfunevals=1000
-  > e(x)=1.343681e-002 < tolxrelative = 2.220446e-016 * 2.468518e+000 + 0.000000e+000
-  > simplex size=5.200090e-002 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=55 >= maxiter=200
-  > funevals=291 >= maxfunevals=1000
-  > e(x)=1.291393e-002 < tolxrelative = 2.220446e-016 * 2.466837e+000 + 0.000000e+000
-  > simplex size=2.869941e-002 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=56 >= maxiter=200
-  > funevals=293 >= maxfunevals=1000
-  > e(x)=6.520867e-003 < tolxrelative = 2.220446e-016 * 2.466345e+000 + 0.000000e+000
-  > simplex size=2.869941e-002 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=57 >= maxiter=200
-  > funevals=296 >= maxfunevals=1000
-  > e(x)=4.800448e-003 < tolxrelative = 2.220446e-016 * 2.466044e+000 + 0.000000e+000
-  > simplex size=2.848232e-002 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=58 >= maxiter=200
-  > funevals=301 >= maxfunevals=1000
-  > e(x)=4.788532e-004 < tolxrelative = 2.220446e-016 * 2.466087e+000 + 0.000000e+000
-  > simplex size=1.786433e-002 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=59 >= maxiter=200
-  > funevals=306 >= maxfunevals=1000
-  > e(x)=2.449448e-003 < tolxrelative = 2.220446e-016 * 2.465258e+000 + 0.000000e+000
-  > simplex size=1.813655e-002 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=60 >= maxiter=200
-  > funevals=309 >= maxfunevals=1000
-  > e(x)=6.517373e-003 < tolxrelative = 2.220446e-016 * 2.465232e+000 + 0.000000e+000
-  > simplex size=1.589767e-002 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=61 >= maxiter=200
-  > funevals=313 >= maxfunevals=1000
-  > e(x)=5.066667e-004 < tolxrelative = 2.220446e-016 * 2.465099e+000 + 0.000000e+000
-  > simplex size=1.589767e-002 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=62 >= maxiter=200
-  > funevals=320 >= maxfunevals=1000
-  > e(x)=1.758811e-003 < tolxrelative = 2.220446e-016 * 2.464936e+000 + 0.000000e+000
-  > simplex size=1.247360e-002 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=63 >= maxiter=200
-  > funevals=324 >= maxfunevals=1000
-  > e(x)=3.189065e-003 < tolxrelative = 2.220446e-016 * 2.464854e+000 + 0.000000e+000
-  > simplex size=5.107345e-003 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=64 >= maxiter=200
-  > funevals=329 >= maxfunevals=1000
-  > e(x)=2.503126e-003 < tolxrelative = 2.220446e-016 * 2.464789e+000 + 0.000000e+000
-  > simplex size=8.432008e-003 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=65 >= maxiter=200
-  > funevals=333 >= maxfunevals=1000
-  > e(x)=3.205258e-003 < tolxrelative = 2.220446e-016 * 2.463754e+000 + 0.000000e+000
-  > simplex size=1.271906e-002 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=66 >= maxiter=200
-  > funevals=336 >= maxfunevals=1000
-  > e(x)=5.113366e-004 < tolxrelative = 2.220446e-016 * 2.463810e+000 + 0.000000e+000
-  > simplex size=1.271906e-002 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=67 >= maxiter=200
-  > funevals=340 >= maxfunevals=1000
-  > e(x)=2.529885e-003 < tolxrelative = 2.220446e-016 * 2.463076e+000 + 0.000000e+000
-  > simplex size=1.387500e-002 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=68 >= maxiter=200
-  > funevals=342 >= maxfunevals=1000
-  > e(x)=3.766253e-003 < tolxrelative = 2.220446e-016 * 2.462262e+000 + 0.000000e+000
-  > simplex size=1.112343e-002 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=69 >= maxiter=200
-  > funevals=347 >= maxfunevals=1000
-  > e(x)=3.663420e-003 < tolxrelative = 2.220446e-016 * 2.461068e+000 + 0.000000e+000
-  > simplex size=1.630221e-002 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=70 >= maxiter=200
-  > funevals=352 >= maxfunevals=1000
-  > e(x)=4.604129e-003 < tolxrelative = 2.220446e-016 * 2.459671e+000 + 0.000000e+000
-  > simplex size=1.478059e-002 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=71 >= maxiter=200
-  > funevals=355 >= maxfunevals=1000
-  > e(x)=2.173376e-003 < tolxrelative = 2.220446e-016 * 2.459171e+000 + 0.000000e+000
-  > simplex size=1.383299e-002 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=72 >= maxiter=200
-  > funevals=360 >= maxfunevals=1000
-  > e(x)=2.696847e-003 < tolxrelative = 2.220446e-016 * 2.458435e+000 + 0.000000e+000
-  > simplex size=1.290907e-002 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=73 >= maxiter=200
-  > funevals=363 >= maxfunevals=1000
-  > e(x)=3.170038e-003 < tolxrelative = 2.220446e-016 * 2.457431e+000 + 0.000000e+000
-  > simplex size=7.591860e-003 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=74 >= maxiter=200
-  > funevals=370 >= maxfunevals=1000
-  > e(x)=1.764306e-003 < tolxrelative = 2.220446e-016 * 2.456960e+000 + 0.000000e+000
-  > simplex size=6.793846e-003 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=75 >= maxiter=200
-  > funevals=375 >= maxfunevals=1000
-  > e(x)=2.495793e-003 < tolxrelative = 2.220446e-016 * 2.456190e+000 + 0.000000e+000
-  > simplex size=8.008945e-003 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=76 >= maxiter=200
-  > funevals=379 >= maxfunevals=1000
-  > e(x)=1.002258e-003 < tolxrelative = 2.220446e-016 * 2.455968e+000 + 0.000000e+000
-  > simplex size=7.296152e-003 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=77 >= maxiter=200
-  > funevals=383 >= maxfunevals=1000
-  > e(x)=1.277492e-003 < tolxrelative = 2.220446e-016 * 2.455872e+000 + 0.000000e+000
-  > simplex size=7.513150e-003 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=78 >= maxiter=200
-  > funevals=386 >= maxfunevals=1000
-  > e(x)=1.414716e-003 < tolxrelative = 2.220446e-016 * 2.455461e+000 + 0.000000e+000
-  > simplex size=7.513150e-003 < 0.000000e+000 + 1.000000e-004 * 2.500000e+000
-  > Termination ?
-  > iterations=79 >= maxiter=200
-  > funevals=391 >= maxfunevals=1000
-  > e(x)=2.118827e-003 < tolxrelative = 2.220446e-016 * 2.455027e+000 + 0.000000e+000
-  > simplex size=7.145650e-003 < 0.000000e+000