optimization: Bug #7891 fixed: neldermead had too many options 88/3888/26
Michael Baudin [Tue, 26 Apr 2011 15:09:19 +0000 (17:09 +0200)]
Change-Id: I2de0416ffcdcab4d80979c8248941a09fc7c91f5

125 files changed:
scilab/CHANGES_5.4.X
scilab/modules/optimization/demos/neldermead/fminsearch_outputfunction.sce
scilab/modules/optimization/demos/neldermead/neldermead.dem.gateway.sce
scilab/modules/optimization/demos/neldermead/neldermead_boxbounds.sce
scilab/modules/optimization/demos/neldermead/neldermead_boxpost.sce
scilab/modules/optimization/demos/neldermead/neldermead_boxproblemA.sce
scilab/modules/optimization/demos/neldermead/neldermead_boxproblemB.sce
scilab/modules/optimization/demos/neldermead/neldermead_outputcmd.sce
scilab/modules/optimization/demos/neldermead/neldermead_summary.sci [new file with mode: 0644]
scilab/modules/optimization/demos/neldermead/nmplot_han1.sce
scilab/modules/optimization/demos/neldermead/nmplot_han2.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
scilab/modules/optimization/demos/neldermead/nmplot_quadratic.fixed2.sce
scilab/modules/optimization/demos/neldermead/nmplot_quadratic.variable.sce
scilab/modules/optimization/demos/neldermead/nmplot_quadratic.variable2.sce
scilab/modules/optimization/demos/neldermead/nmplot_rosenbrock.fixed.sce
scilab/modules/optimization/demos/neldermead/nmplot_rosenbrock.sce
scilab/modules/optimization/demos/neldermead/nmplot_summary.sci [new file with mode: 0644]
scilab/modules/optimization/help/en_US/neldermead/fminsearch.xml
scilab/modules/optimization/help/en_US/neldermead/neldermead.xml
scilab/modules/optimization/help/en_US/neldermead/neldermead_overview.xml
scilab/modules/optimization/help/en_US/neldermead/nmplot.xml
scilab/modules/optimization/help/en_US/optimbase/optimbase.xml
scilab/modules/optimization/macros/neldermead/%TNELDER_string.sci
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_new.sci
scilab/modules/optimization/macros/neldermead/neldermead_search.sci
scilab/modules/optimization/macros/neldermead/nmplot_contour.sci
scilab/modules/optimization/macros/neldermead/nmplot_historyplot.sci
scilab/modules/optimization/macros/neldermead/nmplot_new.sci
scilab/modules/optimization/macros/neldermead/nmplot_outputcmd.sci
scilab/modules/optimization/macros/neldermead/nmplot_search.sci
scilab/modules/optimization/macros/neldermead/nmplot_simplexhistory.sci
scilab/modules/optimization/macros/optimbase/%TOPTIM_string.sci
scilab/modules/optimization/macros/optimbase/optimbase_cget.sci
scilab/modules/optimization/macros/optimbase/optimbase_configure.sci
scilab/modules/optimization/macros/optimbase/optimbase_destroy.sci
scilab/modules/optimization/macros/optimbase/optimbase_function.sci
scilab/modules/optimization/macros/optimbase/optimbase_get.sci
scilab/modules/optimization/macros/optimbase/optimbase_isfeasible.sci
scilab/modules/optimization/macros/optimbase/optimbase_isinbounds.sci
scilab/modules/optimization/macros/optimbase/optimbase_log.sci
scilab/modules/optimization/macros/optimbase/optimbase_new.sci
scilab/modules/optimization/macros/optimbase/optimbase_outputcmd.sci
scilab/modules/optimization/macros/optimbase/optimbase_proj2bnds.sci
scilab/modules/optimization/macros/optimbase/optimbase_set.sci
scilab/modules/optimization/macros/optimbase/optimbase_terminate.sci
scilab/modules/optimization/macros/optimsimplex/%TSIMPLEX_string.sci
scilab/modules/optimization/macros/optimsimplex/optimsimplex_new.sci
scilab/modules/optimization/tests/unit_tests/neldermead/fminsearch.dia.ref [moved from scilab/modules/optimization/tests/unit_tests/neldermead/fminsearch.linux.dia.ref with 96% similarity]
scilab/modules/optimization/tests/unit_tests/neldermead/fminsearch.tst
scilab/modules/optimization/tests/unit_tests/neldermead/fminsearch.win.dia.ref [deleted file]
scilab/modules/optimization/tests/unit_tests/neldermead/fminsearch_output.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/fminsearch_output.tst
scilab/modules/optimization/tests/unit_tests/neldermead/fminsearch_output.unix.dia.ref [deleted file]
scilab/modules/optimization/tests/unit_tests/neldermead/fminsearch_outputobsolete.dia.ref [new file with mode: 0644]
scilab/modules/optimization/tests/unit_tests/neldermead/fminsearch_outputobsolete.tst [new file with mode: 0644]
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_configure.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_configure.linux.dia.ref [deleted file]
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_myterminate.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_myterminate.tst
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_myterminateobsolete.dia.ref [new file with mode: 0644]
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_myterminateobsolete.tst [new file with mode: 0644]
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_newdestroy.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_newdestroy.linux.dia.ref [deleted file]
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 [deleted file]
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_outputcmdobsolete.dia.ref [new file with mode: 0644]
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_outputcmdobsolete.tst [moved from scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_outputcmd2.tst with 52% similarity]
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_rosensuzuki.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_rosensuzuki.linux.dia.ref [deleted file]
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_rosensuzuki.tst
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_searchaddarg.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_searchaddarg.tst
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_searchaddarg3.dia.ref [deleted file]
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_searchaddarg3.tst [deleted file]
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_searchaddargobsolete.dia.ref [moved from scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_searchaddarg2.dia.ref with 52% similarity]
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_searchaddargobsolete.tst [moved from scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_searchaddarg2.tst with 58% similarity]
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_searchfixed.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_searchfixed.linux.dia.ref [deleted file]
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_searchfixed.tst
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_searchfixed2.dia.ref [deleted file]
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_searchfixed2.linux.dia.ref [deleted file]
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_searchfixed2.tst [deleted file]
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_searchvariable.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_searchvariable.linux.dia.ref [deleted file]
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
scilab/modules/optimization/tests/unit_tests/neldermead/nmplot_newdestroy.linux.dia.ref [deleted file]
scilab/modules/optimization/tests/unit_tests/neldermead/nmplot_newdestroy.tst
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/optimbase/optimbase_checkx0.dia.ref
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_checkx0.linux.dia.ref [deleted file]
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_function.dia.ref
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_function.tst
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_isfeasible.dia.ref
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_isfeasible.linux.dia.ref [deleted file]
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_isfeasible.tst
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_isinbounds.dia.ref
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_isinbounds.linux.dia.ref [deleted file]
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_isinbounds.tst
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_isinnonlincons.dia.ref
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_isinnonlincons.tst
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_newdestroy.dia.ref
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_newdestroy.linux.dia.ref [deleted file]
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_newdestroy.tst
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_proj2bnds.dia.ref
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_proj2bnds.linux.dia.ref [deleted file]
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_getset.dia.ref
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_getset.linux.dia.ref [deleted file]
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.linux.dia.ref [deleted file]
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_tostring.dia.ref [moved from scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_tostring.linux.dia.ref with 50% similarity]
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_tostring.tst
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_tostring.win.dia.ref [deleted file]

index 84a2dda..d1f7f90 100644 (file)
@@ -45,7 +45,33 @@ New functions
   "numerically almost equal", i.e. that the relative error is small.
   This automatically fixes the bug #4381.
 
+Optimization:
+=============
 
+* bug 7891 fixed - The neldermead component had too many options.
+  Tagged -costfargument option of optimbase as obsolete: will be 
+  maintained for backward compatibility until 5.4.1.
+  The -fun option can now be a list, where the element #1 is a 
+  function, and the elements #2 to the end are automatically appended to 
+  the calling sequence.
+  Tagged -outputcommandarg option of optimbase as obsolete: will be 
+  maintained for backward compatibility until 5.4.1.
+  The -outputcommand option can now be a list, where the element #1 is 
+  a function, and the elements #2 to the end are automatically appended 
+  to the calling sequence.
+  Tagged "outputfun(x,optimValues,state)" calling sequence of fminsearch 
+  as obsolete: will be maintained for backward compatibility until 
+  5.4.1.
+  The new calling sequence is "stop=outputfun(x,optimValues,state)"
+  Tagged "myoutputfun(state,data)" calling sequence of neldermead 
+  as obsolete: will be maintained for backward compatibility until 
+  5.4.1.
+  The new calling sequence is "stop=myoutputfun(state,data)"
+  Tagged "-myterminateflag" and "-myterminate" options as obsolete: 
+  will be maintained for backward compatibility until 5.4.1.
+  See the help page of neldermead for details to update your 
+  code, if required.
+  
 Xcos:
 =====
 
index 6da15d7..446bd5b 100644 (file)
@@ -1,5 +1,5 @@
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-// Copyright (C) 2009 - DIGITEO - Michael Baudin
+// Copyright (C) 2009 - 2011 - DIGITEO - Michael Baudin
 // Copyright (C) 2010 - DIGITEO - Allan CORNET
 //
 // This file must be used under the terms of the CeCILL.
@@ -16,12 +16,13 @@ function demo_outputfunction()
     y = 100*(x(2)-x(1)^2)^2 + (1-x(1))^2;
   endfunction
 
-  function outfun ( x , optimValues , state )
+  function stop = outfun ( x , optimValues , state )
     fc = optimValues.funccount;
     fv = optimValues.fval;
     it = optimValues.iteration;
     pr = optimValues.procedure;
     mprintf ( "%d %e %d -%s-\n" , fc , fv , it , pr )
+       stop = %f
   endfunction
   
   opt = optimset ( "OutputFcn" , outfun );
index 630490e..b2e3a73 100644 (file)
@@ -20,7 +20,9 @@ subdemolist = [_("fminsearch - Rosenbrock"),          "fminsearch_rosenbrock.sce
                _("nmplot - McKinnon #1"),             "nmplot_mckinnon.sce"; ...
                _("nmplot - McKinnon #2"),             "nmplot_mckinnon2.sce"; ...
                _("nmplot - Quadratic Fixed #1"),      "nmplot_quadratic.fixed.sce"; ...
+               _("nmplot - Quadratic Variable#1"),    "nmplot_quadratic.variable.sce"; ...
                _("nmplot - Quadratic Fixed #2"),      "nmplot_quadratic.fixed2.sce"; ...
+               _("nmplot - Quadratic Variable#2"),    "nmplot_quadratic.variable2.sce"; ...
                _("nmplot - Rosenbrock Fixed"),        "nmplot_rosenbrock.fixed.sce"; ...
                _("nmplot - Rosenbrock Variable"),     "nmplot_rosenbrock.sce"; ...
                _("neldermead - Box A"),               "neldermead_boxproblemA.sce"; ...
index b920fd4..ecd79fe 100644 (file)
 
 function demo_boxbounds()
 
+  filename = 'neldermead_boxbounds.sce';
+  dname = get_absolute_file_path(filename);
+
   mprintf(_("Illustrates Box'' algorithm on a simply bounds-constrained optimization problem.\n"));
 
   // A simple quadratic function
   function [ f , index ] = myquad ( x , index )
     f = x(1)^2 + x(2)^2
   endfunction
+  function y = myquadC ( x1 , x2 )
+    y = myquad ( [x1 , x2] , 2 )
+  endfunction
 
   //
   // Initialize the random number generator, so that the results are always the
@@ -51,7 +57,8 @@ function demo_boxbounds()
   // Check that the cost function is correctly connected.
   //
   [ nm , f ] = nmplot_function ( nm , x0 );
-  nm = nmplot_configure(nm,"-simplexfn",TMPDIR + "/history.simplex.txt");
+  simplexfn = fullfile(TMPDIR , "history.simplex.txt")
+  nm = nmplot_configure(nm,"-simplexfn",simplexfn);
   
   //
   // Perform optimization
@@ -59,15 +66,17 @@ function demo_boxbounds()
   mprintf(_("Searching (please wait) ...\n"));
   nm = nmplot_search(nm);
   mprintf(_("...Done\n"));
-  disp(nm);
+  //
+  // Print a summary
+  //
+  exec(fullfile(dname,"nmplot_summary.sci"),-1);
+  nmplot_summary(nm)
   mprintf("==========================\n");
   xcomp = nmplot_get(nm,"-xopt");
-  mprintf("x computed = %s\n",strcat(string(xcomp), " "));
   mprintf("x expected = %s\n",strcat(string(xopt), " "));
   shift = norm(xcomp-xopt)/norm(xopt);
   mprintf("Shift = %f\n",shift);
   fcomp = nmplot_get(nm,"-fopt");
-  mprintf("f computed = %f\n",fcomp);
   mprintf("f expected = %f\n",fopt);
   shift = abs(fcomp-fopt)/abs(fopt);
   mprintf("Shift =%f\n",shift);
@@ -76,19 +85,30 @@ function demo_boxbounds()
   // Plot
   //
   mprintf(_("Plot contour (please wait)...\n"));
-  [nm , xdata , ydata , zdata ] = nmplot_contour ( nm , xmin = 0.5 , xmax = 2.1 , ymin = 0.5 , ymax = 2.1 , nx = 50 , ny = 50 );
-  
-  my_handle = scf(100001);
-  clf(my_handle,"reset");
+  xmin = 0.5 ; 
+  xmax = 2.1 ; 
+  ymin = 0.5 ; 
+  ymax = 2.1 ; 
+  nx = 50 ; 
+  ny = 50;
+  xdata=linspace(xmin,xmax,nx);
+  ydata=linspace(ymin,ymax,ny);
+  scf();
   xset("fpf"," ")
   drawlater();
-  contour ( xdata , ydata , zdata , linspace(min(zdata),max(zdata),10) )
+  contour ( xdata , ydata , myquadC , 10 )
   nmplot_simplexhistory ( nm );
   drawnow();
-
+  //
+  // Cleanup
+  deletefile(simplexfn)
   nm = nmplot_destroy(nm);
   mprintf(_("End of demo.\n"));
 
+  //
+  // Load this script into the editor
+  //
+  editor ( dname + filename, "readonly" );
 endfunction
 
 demo_boxbounds();
index a8026e6..a4bf950 100644 (file)
@@ -18,6 +18,9 @@
 
 function demo_boxpost()
 
+  filename = 'neldermead_boxpost.sce';
+  dname = get_absolute_file_path(filename);
+
   mprintf(_("Illustrates Box'' algorithm on Rosenbrock''s Post Office Problem.\n"));
   mprintf(_("Defining Rosenbrock Post Office function...\n"));
 
@@ -67,7 +70,6 @@ function demo_boxpost()
       c = [c1 c2]
     end
   endfunction
-
   //
   // Initialize the random number generator, so that the results are always the
   // same.
@@ -121,14 +123,17 @@ function demo_boxpost()
   //
   mprintf(_("Searching (please wait) ...\n"));
   nm = neldermead_search(nm);
+  //
+  // Print a summary
+  //
+  exec(fullfile(dname,"neldermead_summary.sci"),-1);
+  neldermead_summary(nm)
   mprintf("==========================\n");
   xcomp = neldermead_get(nm,"-xopt");
-  mprintf("x computed = [%s]\n",strcat(string(xcomp)," "));
   mprintf("x expected = [%s]\n",strcat(string(xopt)," "));
   shift = norm(xcomp-xopt)/norm(xopt);
   mprintf("Shift = %f\n",shift);
   fcomp = neldermead_get(nm,"-fopt");
-  mprintf("f computed = %f\n",fcomp);
   mprintf("f expected = %f\n",fopt);
   shift = abs(fcomp-fopt)/abs(fopt);
   mprintf("Shift = %f\n",shift);
@@ -139,8 +144,6 @@ function demo_boxpost()
   //
   // Load this script into the editor
   //
-  filename = 'neldermead_boxpost.sce';
-  dname = get_absolute_file_path(filename);
   editor ( dname + filename, "readonly" );
 
 endfunction
index ee06653..4030a59 100644 (file)
@@ -17,6 +17,9 @@
 
 function demo_boxproblemA()
 
+  filename = 'neldermead_boxproblemA.sce';
+  dname = get_absolute_file_path(filename);
+
   mprintf(_("Illustrates Box'' algorithm on Box problem A.\n"));
 
   mprintf("M.J. Box, \n");
@@ -50,7 +53,7 @@ function demo_boxproblemA()
   //   index : the stuff to compute
   //   data : the parameters of Box cost function
   //
-  function [ f , c , index , data ] = boxproblemA ( x , index , data )
+  function [ f , c , index ] = boxproblemA ( x , index , data )
     f = []
     c = []
     b = x(2) + 0.01 * x(3)
@@ -142,18 +145,17 @@ function demo_boxproblemA()
 
   x0 = [2.52 2.0 37.5 9.25 6.8].';
   // Compute f(x0) : should be close to -2351244.0
-  [ fx0 , c , index , data ] = boxproblemA ( x0 , 2 , boxparams );
+  [ fx0 , c , index ] = boxproblemA ( x0 , 2 , boxparams );
   mprintf("Computed fx0 = %e (expected = %e)\n",fx0 , -2351244. );
 
   xopt = [4.53743 2.4 60.0 9.3 7.0].';
   // Compute f(xopt) : should be -5280334.0
-  [ fopt , c , index , data ] = boxproblemA ( xopt , 2 , boxparams );
+  [ fopt , c , index ] = boxproblemA ( xopt , 2 , boxparams );
   mprintf("Computed fopt = %e (expected = %e)\n", fopt , -5280334.0 );
 
   nm = neldermead_new ();
   nm = neldermead_configure(nm,"-numberofvariables",5);
-  nm = neldermead_configure(nm,"-function",boxproblemA);
-  nm = neldermead_configure(nm,"-costfargument",boxparams);
+  nm = neldermead_configure(nm,"-function",list(boxproblemA,boxparams));
   nm = neldermead_configure(nm,"-x0",x0);
   nm = neldermead_configure(nm,"-maxiter",300);
   nm = neldermead_configure(nm,"-maxfunevals",1000);
@@ -177,25 +179,26 @@ function demo_boxproblemA()
   mprintf(_("Searching (please wait)...\n"));
   nm = neldermead_search(nm);
   mprintf(_("...Done\n"));
+  //
+  // Print a summary
+  //
+  exec(fullfile(dname,"neldermead_summary.sci"),-1);
+  neldermead_summary(nm)
   mprintf("==========================\n");
   xcomp = neldermead_get(nm,"-xopt");
-  mprintf("x computed = [%s]\n",strcat(string(xcomp)," "));
   mprintf("x expected = [%s]\n",strcat(string(xopt)," "));
   shift = norm(xcomp-xopt)/norm(xopt);
-  mprintf(_("Relative error = %e\n"),shift);
+  mprintf(_("Relative error on x = %e\n"),shift);
   fcomp = neldermead_get(nm,"-fopt");
-  mprintf("f computed = %f\n",fcomp);
   mprintf("f expected = %f\n",fopt);
   shift = abs(fcomp-fopt)/abs(fopt);
-  mprintf("Relative error = %e\n",shift);
+  mprintf("Relative error on f = %e\n",shift);
   nm = neldermead_destroy(nm);
   mprintf(_("End of demo.\n"));
 
   //
   // Load this script into the editor
   //
-  filename = 'neldermead_boxproblemA.sce';
-  dname = get_absolute_file_path(filename);
   editor ( dname + filename, "readonly" );
 
 endfunction 
index 352107a..d3f2e79 100644 (file)
@@ -17,6 +17,9 @@
 
 function demo_boxproblemB()
 
+  filename = 'neldermead_boxproblemB.sce';
+  dname = get_absolute_file_path(filename);
+
   mprintf(_("Illustrates Box'' algorithm on Box problem B.\n"));
 
   mprintf("M.J. Box, \n");
@@ -131,25 +134,26 @@ function demo_boxproblemB()
   //
   mprintf(_("Searching (please wait) ...\n"));
   nm = neldermead_search(nm);
+  //
+  // Print a summary
+  //
+  exec(fullfile(dname,"neldermead_summary.sci"),-1);
+  neldermead_summary(nm)
   mprintf("==========================\n");
   xcomp = neldermead_get(nm,"-xopt");
-  mprintf("x computed = [%s]\n", strcat(string(xcomp), " "));
   mprintf("x expected = [%s]\n", strcat(string(xopt), " "));
   shift = norm(xcomp-xopt)/norm(xopt);
-  mprintf(_("Relative error = %e\n"), shift);
+  mprintf(_("Relative error on x = %e\n"), shift);
   fcomp = neldermead_get(nm,"-fopt");
-  mprintf(_("f computed = %f\n"), fcomp);
   mprintf(_("f expected = %f\n"), fopt);
   shift = abs(fcomp-fopt)/abs(fopt);
-  mprintf(_("Relative error = %e\n"), shift);
+  mprintf(_("Relative error on f = %e\n"), shift);
   nm = neldermead_destroy(nm);
   mprintf(_("End of demo.\n"));
 
   //
   // Load this script into the editor
   //
-  filename = 'neldermead_boxproblemB.sce';
-  dname = get_absolute_file_path(filename);
   editor ( dname + filename, "readonly" );
 
 endfunction
index bbf2679..833cfb2 100644 (file)
@@ -30,9 +30,10 @@ function demo_outputcmd()
   //    * simplex : the simplex, as a simplex object
   //    * iteration : the number of iterations performed
   //    * funccount : the number of function evaluations
+  // stop : set to %t to interrupt the algorithm
   //
   
-  function myoutputcmd ( state , data )
+  function stop = myoutputcmd ( state , data )
     iter = data.iteration
     if ( state == "init" ) then
       mprintf ( "=================================\n");
@@ -49,6 +50,7 @@ function demo_outputcmd()
     // by the optimsimplex class.
     ssize = optimsimplex_size ( simplex )
     mprintf ( "Iteration #%d, Feval #%d, Fval = %e, x = %s, Size = %e\n", iter, fc, fval, strcat(string(x)," "), ssize);
+       stop = %f
   endfunction
 
 
diff --git a/scilab/modules/optimization/demos/neldermead/neldermead_summary.sci b/scilab/modules/optimization/demos/neldermead/neldermead_summary.sci
new file mode 100644 (file)
index 0000000..a2e0ad5
--- /dev/null
@@ -0,0 +1,29 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2008-2009 - INRIA - Michael Baudin
+// Copyright (C) 2010 - DIGITEO - Allan CORNET
+// Copyright (C) 2011 - DIGITEO - 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
+
+function neldermead_summary(nm)
+function str = _strvec ( x )
+    str = strcat(string(x)," ")
+endfunction
+
+  xopt = neldermead_get(nm,"-xopt")
+  fopt = neldermead_get(nm,"-fopt")
+  funevals = neldermead_get(nm,"-funevals")
+  iter = neldermead_get(nm,"-iterations")
+  status = neldermead_get(nm,"-status")
+  restartnb = neldermead_get(nm,"-restartnb")
+  mprintf("Xopt: [%s]\n",_strvec(xopt));
+  mprintf("Fopt: %s\n",string(fopt));
+  mprintf("Function evaluations: %d\n",funevals);
+  mprintf("Iterations: %d\n",iter);
+  mprintf("Status: %s\n",status);
+  mprintf("Restartnb: %d\n",restartnb)
+endfunction 
index 7807259..1767290 100644 (file)
@@ -11,6 +11,9 @@
 
 function demo_nmplot_1()
 
+  filename = 'nmplot_han1.sce';
+  dname = get_absolute_file_path(filename);
+
   mprintf(_("Illustrates the 1st counter example given by Han et al.\n"));
 
   //
@@ -28,6 +31,9 @@ function demo_nmplot_1()
   function [ f , index ] = han1 ( x , index )
     f = x(1)^2 + x(2) * (x(2) + 2.0) * (x(2) - 0.5) * (x(2) - 2.0);
   endfunction
+  function y = han1C ( x1 , x2 )
+    y = han1 ( [x1 , x2] , 2 )
+  endfunction
 
 
   mprintf(_("Defining initial simplex coordinates...\n"));
@@ -56,30 +62,34 @@ function demo_nmplot_1()
   //
   mprintf(_("Setup output files...\n"));
   simplexfn = TMPDIR + filesep() + "history.simplex.txt";
-  fbarfn = TMPDIR + filesep() + "history.fbar.txt";
-  foptfn = TMPDIR + filesep() + "history.fopt.txt";
-  sigmafn = TMPDIR + filesep() + "history.sigma.txt";
   nm = nmplot_configure(nm, "-simplexfn", simplexfn);
-  nm = nmplot_configure(nm, "-fbarfn", fbarfn);
-  nm = nmplot_configure(nm, "-foptfn", foptfn);
-  nm = nmplot_configure(nm, "-sigmafn", sigmafn);
   
   //
   // Perform optimization
   //
   mprintf(_("Searching (please wait)...\n"));
   nm = nmplot_search(nm);
-  disp(nm);
+    //
+    // Print a summary
+    //
+    exec(fullfile(dname,"nmplot_summary.sci"),-1);
+    nmplot_summary(nm)
   
   //
   // Plot the history of the simplex
   //
   mprintf(_("Plotting contour (please wait)...\n"));
-  [nm , xdata , ydata , zdata ] = nmplot_contour ( nm , xmin = -0.2 , xmax = 1.2 , ymin = -2.0 , ymax = 2.0 , nx = 50 , ny = 50 );
-  my_handle = scf(100001);
-  clf(my_handle,"reset");
+  xmin = -0.2 ; 
+  xmax = 1.2 ; 
+  ymin = -2.0 ; 
+  ymax = 2.0 ; 
+  nx = 50 ; 
+  ny = 50;
+  xdata=linspace(xmin,xmax,nx);
+  ydata=linspace(ymin,ymax,ny);
+  scf();
   drawlater();
-  contour ( xdata , ydata , zdata , [-5 -4 -2 -1 0 1 1.5] )
+  contour ( xdata , ydata , han1C , [-5 -4 -2 -1 0 1 1.5] )
   nmplot_simplexhistory ( nm );
   drawnow();
   
@@ -87,17 +97,12 @@ function demo_nmplot_1()
   // Clean-up
   //
   deletefile(simplexfn);
-  deletefile(fbarfn);
-  deletefile(foptfn);
-  deletefile(sigmafn);
   nm = nmplot_destroy(nm);
   mprintf(_("End of demo.\n"));
   
   //
   // Load this script into the editor
   //
-  filename = 'nmplot_han1.sce';
-  dname = get_absolute_file_path(filename);
   editor ( dname + filename, "readonly" );
 
 endfunction
index 284eb25..cec5e5b 100644 (file)
@@ -11,6 +11,9 @@
 
 
 function demo_nmplot_2()
+  filename = 'nmplot_han2.sce';
+  dname = get_absolute_file_path(filename);
+
   mprintf(_("Illustrates the 2nd counter example given by Han et al.\n"));
 
   //
@@ -33,6 +36,9 @@ function demo_nmplot_2()
     end
     f = x(1)^2 + rho;
   endfunction
+  function y = han2C ( x1 , x2 )
+    y = han2 ( [x1 , x2] , 2 )
+  endfunction
 
 
   coords0 = [
@@ -63,19 +69,32 @@ function demo_nmplot_2()
   //
   mprintf(_("Searching (please wait) ...\n"));
   nm = nmplot_search(nm);
-  disp(nm);
+    //
+    // Print a summary
+    //
+    exec(fullfile(dname,"nmplot_summary.sci"),-1);
+    nmplot_summary(nm)
   
   //
   // Plot
   //
   mprintf(_("Plotting contour (please wait) ...\n"));
-  [nm , xdata , ydata , zdata ] = nmplot_contour ( nm , xmin = -0.2 , xmax = 1.2 , ymin = -1.5 , ymax = 1.5 , nx = 50 , ny = 50 );
-  f = scf(100001);
+  xmin = -0.2 ; 
+  xmax = 1.2 ; 
+  ymin = -1.5 ; 
+  ymax = 1.5 ; 
+  nx = 50 ; 
+  ny = 50;
+  scf();
   xset("fpf"," ")
   drawlater();
-  contour ( xdata , ydata , zdata , [0.1 0.2 0.5 1.0 1.5 1.9] )
+  xdata=linspace(xmin,xmax,nx);
+  ydata=linspace(ymin,ymax,ny);
+  contour ( xdata , ydata , han2C , [0.1 0.2 0.5 1.0 1.5 1.9] )
   nmplot_simplexhistory ( nm );
   drawnow();
+  //
+  // Cleanup
   deletefile(simplexfn);
   nm = nmplot_destroy(nm);
   mprintf(_("End of demo.\n"));
@@ -83,8 +102,6 @@ function demo_nmplot_2()
   //
   // Load this script into the editor
   //
-  filename = 'nmplot_han2.sce';
-  dname = get_absolute_file_path(filename);
   editor (dname + filename, 'readonly');
 
 endfunction
index c835c5b..490c063 100644 (file)
@@ -11,6 +11,9 @@
 
 function demo_mckinnon2()
 
+  filename = 'nmplot_mckinnon.sce';
+  dname = get_absolute_file_path(filename);
+
   mprintf(_("Defining McKinnon function...\n"));
   //% MCKINNON computes the McKinnon function.
   //
@@ -92,6 +95,9 @@ function demo_mckinnon2()
       f = theta     *     x(1).^tau   + x(2) * ( 1.0 + x(2) );
     end
   endfunction
+  function y = mckinnon3C ( x1 , x2 )
+    y = mckinnon3 ( [x1 , x2] , 2 )
+  endfunction
 
 
   lambda1 = (1.0 + sqrt(33.0))/8.0;
@@ -132,24 +138,42 @@ function demo_mckinnon2()
   //
   mprintf(_("Searching (please wait) ...\n"));
   nm = nmplot_search(nm);
-  disp(nm);
+    //
+    // Print a summary
+    //
+    exec(fullfile(dname,"nmplot_summary.sci"),-1);
+    nmplot_summary(nm)
   //
   // Plot
   //
   mprintf(_("Plot contour (please wait) ...\n"));
-  [nm , xdata , ydata , zdata ] = nmplot_contour ( nm , xmin = -0.2 , xmax = 1.2 , ymin = -2.0 , ymax = 2.0 , nx = 50 , ny = 50 );
-  f = scf(100001);
+  xmin = -0.2; 
+  xmax = 1.2 ; 
+  ymin = -2.0 ; 
+  ymax = 2.0 ; 
+  nx = 50 ; 
+  ny = 50;
+  xdata=linspace(xmin,xmax,nx);
+  ydata=linspace(ymin,ymax,ny);
+  scf();
+  subplot(2,2,1)
   xset("fpf"," ")
   drawlater();
-  contour ( xdata , ydata , zdata , [-0.2 0.0 1.0 2.0 5.0 10.0 20.0] )
+  contour ( xdata , ydata , mckinnon3C , [-0.2 0.0 1.0 2.0 5.0 10.0 20.0] )
   nmplot_simplexhistory ( nm );
   drawnow();
-  f = scf(100002);
-  nmplot_historyplot ( nm , fbarfn , mytitle = "Function Value Average" , myxlabel = "Iterations" );
-  f = scf(100003);
-  nmplot_historyplot ( nm , foptfn , mytitle = "Minimum Function Value" , myxlabel = "Iterations" );
-  f = scf(100004);
-  nmplot_historyplot ( nm , sigmafn , mytitle = "Maximum Oriented length" , myxlabel = "Iterations" );
+       subplot(2,2,2)
+       mytitle = _("Function Value Average"); 
+       myxlabel = _("Iterations");
+    nmplot_historyplot ( nm , fbarfn, mytitle , myxlabel );
+       subplot(2,2,3)
+       mytitle = _("Minimum Function Value") ; 
+       myxlabel = _("Iterations");
+    nmplot_historyplot ( nm , foptfn, mytitle , myxlabel );
+       subplot(2,2,4)
+       mytitle = _("Maximum Oriented length") ; 
+       myxlabel = _("Iterations") ;
+    nmplot_historyplot ( nm , sigmafn, mytitle , myxlabel );
   deletefile(simplexfn);
   deletefile(fbarfn);
   deletefile(foptfn);
@@ -160,8 +184,6 @@ function demo_mckinnon2()
   //
   // Load this script into the editor
   //
-  filename = 'nmplot_mckinnon.sce';
-  dname = get_absolute_file_path(filename);
   editor ( dname + filename, 'readonly' );
 
 endfunction
index ff009d2..a91742a 100644 (file)
@@ -12,6 +12,9 @@
 
 function demo_mckinnon2()
 
+    filename = 'nmplot_mckinnon2.sce';
+    dname = get_absolute_file_path(filename);
+
     mprintf(_("Defining McKinnon function...\n"));
 
     //% MCKINNON computes the McKinnon function.
@@ -94,6 +97,9 @@ function demo_mckinnon2()
             f = theta       *       x(1).^tau   + x(2) * ( 1.0 + x(2) );
         end
     endfunction
+  function y = mckinnon3C ( x1 , x2 )
+    y = mckinnon3 ( [x1 , x2] , 2 )
+  endfunction
 
     lambda1 = (1.0 + sqrt(33.0))/8.0;
     lambda2 = (1.0 - sqrt(33.0))/8.0;
@@ -141,19 +147,33 @@ function demo_mckinnon2()
     // Plot
     //
     mprintf(_("Plot contour (please wait) ...\n"));
-    [nm , xdata , ydata , zdata ] = nmplot_contour ( nm , xmin = -0.2 , xmax = 2.0 , ymin = -2.0 , ymax = 2.0 , nx = 50 , ny = 50 );
-    f = scf();
+  xmin = -0.2; 
+  xmax = 1.2 ; 
+  ymin = -2.0 ; 
+  ymax = 2.0 ; 
+  nx = 50 ; 
+  ny = 50;
+  xdata=linspace(xmin,xmax,nx);
+  ydata=linspace(ymin,ymax,ny);
+    scf();
+       subplot(2,2,1)
     xset("fpf"," ")
     drawlater();
-    contour ( xdata , ydata , zdata , [-0.2 0.0 1.0 2.0 5.0 10.0 20.0] )
+    contour ( xdata , ydata , mckinnon3C , [-0.2 0.0 1.0 2.0 5.0 10.0 20.0] )
     nmplot_simplexhistory ( nm );
     drawnow();
-    f = scf();
-    nmplot_historyplot ( nm , fbarfn, mytitle = _("Function Value Average") , myxlabel = _("Iterations") );
-    f = scf();
-    nmplot_historyplot ( nm , foptfn, mytitle = _("Minimum Function Value") , myxlabel = _("Iterations") );
-    f = scf();
-    nmplot_historyplot ( nm , sigmafn, mytitle = _("Maximum Oriented length") , myxlabel = _("Iterations") );
+       subplot(2,2,2)
+       mytitle = _("Function Value Average"); 
+       myxlabel = _("Iterations");
+    nmplot_historyplot ( nm , fbarfn, mytitle , myxlabel );
+       subplot(2,2,3)
+       mytitle = _("Minimum Function Value") ; 
+       myxlabel = _("Iterations");
+    nmplot_historyplot ( nm , foptfn, mytitle , myxlabel );
+       subplot(2,2,4)
+       mytitle = _("Maximum Oriented length") ; 
+       myxlabel = _("Iterations") ;
+    nmplot_historyplot ( nm , sigmafn, mytitle , myxlabel );
     deletefile(simplexfn);
     deletefile(fbarfn);
     deletefile(foptfn);
@@ -164,8 +184,6 @@ function demo_mckinnon2()
     //
     // Load this script into the editor
     //
-    filename = 'nmplot_mckinnon2.sce';
-    dname = get_absolute_file_path(filename);
     editor ( dname + filename, "readonly" );
 
 endfunction
index 5f45c11..dfe88f7 100644 (file)
 
 function demo_nmplot_qfixed()
 
+  filename = 'nmplot_quadratic.fixed.sce';
+  dname = get_absolute_file_path(filename);
+  
   mprintf(_("Illustrates that the fixed-shape Spendley et al. algorithm performs well on a quadratic test case.\n"));
   mprintf(_("Defining quadratic function ...\n"));
   
   function [ y , index ] = quadratic ( x , index )
     y = x(1)^2 + x(2)^2 - x(1) * x(2);
   endfunction
+  function y = quadraticC ( x1, x2 )
+    y = quadratic ( [x1, x2] , 2 )
+  endfunction
 
   mprintf(_("Creating nmplot object ...\n"));
   
@@ -34,66 +40,45 @@ function demo_nmplot_qfixed()
   // Setup output files
   //
   simplexfn = TMPDIR + filesep() + "history.simplex.txt";
-  fbarfn = TMPDIR + filesep() + "history.fbar.txt";
-  foptfn = TMPDIR + filesep() + "history.fopt.txt";
-  sigmafn = TMPDIR + filesep() + "history.sigma.txt";
   
   nm = nmplot_configure(nm, "-simplexfn",simplexfn);
-  nm = nmplot_configure(nm, "-fbarfn",fbarfn);
-  nm = nmplot_configure(nm, "-foptfn",foptfn);
-  nm = nmplot_configure(nm, "-sigmafn",sigmafn);
-  
   //
   // Perform optimization
   //
   mprintf(_("Searching (please wait) ...\n"));
   nm = nmplot_search(nm);
-  disp(nm);
-  // Plot various histories
-  mprintf(_("Plotting history of fbar ...\n"));
-  f = scf();
-  nmplot_historyplot ( nm , fbarfn, mytitle = _("Function Value Average") , myxlabel = _("Iterations") );
-  mprintf( _("Plotting history of fopt ...\n"));
-  f = scf();
-  nmplot_historyplot ( nm , foptfn, mytitle = _("Logarithm Minimum Function Value") , myxlabel = _("Iterations") );
-  f.children.log_flags = "nln";
-  newticks = tlist(["ticks","locations","labels"]);
-  newticks.labels = ["1.e-20" "1.e-10" "1.e-1"];
-  newticks.locations = [1.e-20 1.e-10 1.e-1];
-  f.children.y_ticks = newticks;
-  f.children.children(1).children.mark_mode = "on";
-  f.children.children(1).children.mark_style = 9;
-  mprintf(_("Plotting history of sigma ...\n"));
-  f = scf();
-  nmplot_historyplot ( nm , sigmafn, mytitle = _("Logarithm Maximum Oriented length") , myxlabel = _("Iterations") );
-  f.children.log_flags = "nln";
-  f.children.y_ticks = newticks;
-  f.children.children(1).children.mark_mode = "on";
-  f.children.children(1).children.mark_style = 9;
-  
+  //
+  // Print a summary
+  //
+  exec(fullfile(dname,"nmplot_summary.sci"),-1);
+  nmplot_summary(nm)
+
+  // Plot simplex history
+  scf();
   // Plot the contours of the cost function and the simplex history
   mprintf(_("Plotting contour (please wait) ...\n"));
   nm = nmplot_configure(nm, "-verbose",0);
-  [nm , xdata , ydata , zdata ] = nmplot_contour ( nm , xmin = -2.0 , xmax = 4.0 , ymin = -2.0 , ymax = 4.0 , nx = 50 , ny = 50 );
-  f = scf();
+  xmin = -2.0 ; 
+  xmax = 4.0 ; 
+  ymin = -2.0 ; 
+  ymax = 4.0 ; 
+  nx = 50 ; 
+  ny = 50;
+  xdata=linspace(xmin,xmax,nx);
+  ydata=linspace(ymin,ymax,ny);
   drawlater();
-  contour ( xdata , ydata , zdata , [0.1 1.0 2.0 5.0 10.0 15.0 20.0] )
+  contour ( xdata , ydata , quadraticC , [0.1 1.0 2.0 5.0 10.0 15.0 20.0] )
   nmplot_simplexhistory ( nm );
   drawnow();
   
   // Clean-up
   deletefile(simplexfn);
-  deletefile(fbarfn);
-  deletefile(foptfn);
-  deletefile(sigmafn);
   nm = nmplot_destroy(nm);
   mprintf("End of demo.\n");
 
   //
   // Load this script into the editor
   //
-  filename = 'nmplot_quadratic.fixed.sce';
-  dname = get_absolute_file_path(filename);
   editor ( dname + filename, "readonly" );
 
 endfunction 
index b89ae56..c73828c 100644 (file)
@@ -11,6 +11,9 @@
 
 function demo_nmplot_qfixed2()
 
+  filename = 'nmplot_quadratic.fixed2.sce';
+  dname = get_absolute_file_path(filename);
+
   mprintf(_("Illustrates that the fixed-shape Spendley et al. algorithm performs badly on a badly quadratic test case.\n"));
   mprintf(_("Defining quadratic function...\n"));
   a = 100;
@@ -18,6 +21,9 @@ function demo_nmplot_qfixed2()
   function [ y , index ] = quadratic ( x , index )
     y = a * x(1)^2 + x(2)^2;
   endfunction
+  function y = quadraticC ( x1 , x2 )
+    y = quadratic ( [x1 , x2] , 2 )
+  endfunction
 
   mprintf(_("Creating nmplot object ...\n"));
   nm = nmplot_new ();
@@ -35,64 +41,44 @@ function demo_nmplot_qfixed2()
   // Setup output files
   //
   simplexfn = TMPDIR + filesep() + "history.simplex.txt";
-  fbarfn = TMPDIR + filesep() + "history.fbar.txt";
-  foptfn = TMPDIR + filesep() + "history.fopt.txt";
-  sigmafn = TMPDIR + filesep() + "history.sigma.txt";
   nm = nmplot_configure(nm, "-simplexfn",simplexfn);
-  nm = nmplot_configure(nm, "-fbarfn",fbarfn);
-  nm = nmplot_configure(nm, "-foptfn",foptfn);
-  nm = nmplot_configure(nm, "-sigmafn",sigmafn);
   
   //
   // Perform optimization
   //
   mprintf(_("Searching (please wait) ...\n"));
   nm = nmplot_search(nm);
-  disp(nm);
-  // Plot various histories
-  mprintf(_("Plotting history of fbar ...\n"));
-  f = scf();
-  nmplot_historyplot ( nm ,fbarfn, mytitle = _("Function Value Average") , myxlabel = _("Iterations") );
-  mprintf(_("Plotting history of fopt ...\n"));
-  f = scf();
-  nmplot_historyplot ( nm , foptfn, mytitle = _("Logarithm Minimum Function Value") , myxlabel = _("Iterations") );
-  f.children.log_flags = "nln";
-  newticks = tlist(["ticks","locations","labels"]);
-  newticks.labels = ["1.e-20" "1.e-10" "1.e-1"];
-  newticks.locations = [1.e-20 1.e-10 1.e-1];
-  f.children.y_ticks = newticks;
-  f.children.children(1).children.mark_mode = "on";
-  f.children.children(1).children.mark_style = 9;
-  mprintf(_("Plotting history of sigma ...\n"));
-  f = scf();
-  nmplot_historyplot ( nm , sigmafn, mytitle = _("Logarithm Maximum Oriented length") , myxlabel = _("Iterations") );
-  f.children.log_flags = "nln";
-  f.children.y_ticks = newticks;
-  f.children.children(1).children.mark_mode = "on";
-  f.children.children(1).children.mark_style = 9;
+  //
+  // Print a summary
+  //
+  exec(fullfile(dname,"nmplot_summary.sci"),-1);
+  nmplot_summary(nm)
+  //
   // Plot the contours of the cost function and the simplex history
   mprintf(_("Plotting contour (please wait) ...\n"));
   nm = nmplot_configure(nm, "-verbose", 0);
-  [nm , xdata , ydata , zdata ] = nmplot_contour ( nm , xmin = -5.0 , xmax = 12.0 , ymin = -2.0 , ymax = 12.0 , nx = 50 , ny = 50 );
-  f = scf();
+  xmin = -5.0 ; 
+  xmax = 12.0 ; 
+  ymin = -2.0 ; 
+  ymax = 12.0 ; 
+  nx = 50 ; 
+  ny = 50;
+  scf()
   drawlater();
-  contour ( xdata , ydata , zdata , [10.0 50 100 1000 2000 5000 10000 20000] )
+  xdata=linspace(xmin,xmax,nx);
+  ydata=linspace(ymin,ymax,ny);
+  contour ( xdata , ydata , quadraticC , [10.0 50 100 1000 2000 5000 10000 20000] )
   nmplot_simplexhistory ( nm );
   drawnow();
   
   // Clean-up
   deletefile(simplexfn);
-  deletefile(fbarfn);
-  deletefile(foptfn);
-  deletefile(sigmafn);
   nm = nmplot_destroy(nm);
   mprintf("End of demo.\n");
 
   //
   // Load this script into the editor
   //
-  filename = 'nmplot_quadratic.fixed2.sce';
-  dname = get_absolute_file_path(filename);
   editor ( dname + filename, "readonly" );
 
 endfunction
index 25946fc..a3b3018 100644 (file)
 
 function demo_nmplot_qvariable()
 
+  filename = 'nmplot_quadratic.variable.sce';
+  dname = get_absolute_file_path(filename);
+
   mprintf(_("Illustrates that the variable-shape Nelder-Mead algorithm performs well on a quadratic test case.\n"));
   mprintf(_("Defining quadratic function ...\n"));
   function [ y , index ] = quadratic ( x , index )
     y = x(1)^2 + x(2)^2 - x(1) * x(2);
   endfunction
+  function y = quadraticC ( x1 , x2 )
+    y = quadratic ( [x1 , x2] , 2 )
+  endfunction
 
   mprintf(_("Creating nmplot object...\n"));
   nm = nmplot_new ();
@@ -32,64 +38,44 @@ function demo_nmplot_qvariable()
   // Setup output files
   //
   simplexfn = TMPDIR + filesep() + "history.simplex.txt";
-  fbarfn = TMPDIR + filesep() + "history.fbar.txt";
-  foptfn = TMPDIR + filesep() + "history.fopt.txt";
-  sigmafn = TMPDIR + filesep() + "history.sigma.txt";
   nm = nmplot_configure(nm, "-simplexfn",simplexfn);
-  nm = nmplot_configure(nm, "-fbarfn",fbarfn);
-  nm = nmplot_configure(nm, "-foptfn",foptfn);
-  nm = nmplot_configure(nm, "-sigmafn",sigmafn);
   
   //
   // Perform optimization
   //
   mprintf(_("Searching (please wait) ...\n"));
   nm = nmplot_search(nm);
-  disp(nm);
-  // Plot various histories
-  mprintf(_("Plotting history of fbar ...\n"));
-  f = scf();
-  nmplot_historyplot ( nm , fbarfn, mytitle = _("Function Value Average") , myxlabel = _("Iterations") );
-  mprintf(_("Plotting history of fopt ...\n"));
-  f = scf();
-  nmplot_historyplot ( nm , foptfn, mytitle = _("Logarithm Minimum Function Value") , myxlabel = _("Iterations") );
-  f.children.log_flags = "nln";
-  newticks = tlist(["ticks","locations","labels"]);
-  newticks.labels = ["1.e-20" "1.e-10" "1.e-1"];
-  newticks.locations = [1.e-20 1.e-10 1.e-1];
-  f.children.y_ticks = newticks;
-  f.children.children(1).children.mark_mode = "on";
-  f.children.children(1).children.mark_style = 9;
-  mprintf(_("Plotting history of sigma ...\n"));
-  f = scf();
-  nmplot_historyplot ( nm , sigmafn, mytitle = _("Logarithm Maximum Oriented length") , myxlabel = _("Iterations") );
-  f.children.log_flags = "nln";
-  f.children.y_ticks = newticks;
-  f.children.children(1).children.mark_mode = "on";
-  f.children.children(1).children.mark_style = 9;
+  //
+  // Print a summary
+  //
+  exec(fullfile(dname,"nmplot_summary.sci"),-1);
+  nmplot_summary(nm)
+  //
   // Plot the contours of the cost function and the simplex history
   mprintf(_("Plotting contour (please wait) ...\n"));
   nm = nmplot_configure(nm, "-verbose", 0);
-  [nm , xdata , ydata , zdata ] = nmplot_contour ( nm , xmin = -2.0 , xmax = 4.0 , ymin = -2.0 , ymax = 4.0 , nx = 50 , ny = 50 );
-  f = scf();
+  xmin = -2.0 ; 
+  xmax = 4.0 ; 
+  ymin = -2.0 ; 
+  ymax = 4.0 ; 
+  nx = 50 ; 
+  ny = 50;
+  xdata=linspace(xmin,xmax,nx);
+  ydata=linspace(ymin,ymax,ny);
+  scf()
   drawlater();
-  contour ( xdata , ydata , zdata , [0.1 1.0 2.0 5.0 10.0 15.0 20.0] )
+  contour ( xdata , ydata , quadraticC , [0.1 1.0 2.0 5.0 10.0 15.0 20.0] )
   nmplot_simplexhistory ( nm );
   drawnow();
   
   // Clean-up
   deletefile(simplexfn);
-  deletefile(fbarfn);
-  deletefile(foptfn);
-  deletefile(sigmafn);
   nm = nmplot_destroy(nm);
   mprintf(_("End of demo.\n"));
 
   //
   // Load this script into the editor
   //
-  filename = 'nmplot_quadratic.variable.sce';
-  dname = get_absolute_file_path(filename);
   editor ( dname + filename, "readonly" );
 
 endfunction
index 558bcc5..2f664d1 100644 (file)
 
 function demo_nmplot_qvariable2()
 
+  filename = 'nmplot_quadratic.variable2.sce';
+  dname = get_absolute_file_path(filename);
+
   mprintf(_("Illustrates that the Nelder-Mead algorithm performs correctly on a badly quadratic test case.\n"));
   mprintf(_("Defining quadratic function ...\n"));
   a = 100.0;
   function [ y , index ] = quadratic ( x , index )
     y = a * x(1)^2 + x(2)^2;
   endfunction
+  function y = quadraticC ( x1 , x2 )
+    [ y , index ] = quadratic ( [x1 , x2] , 2 )
+  endfunction
 
   mprintf(_("Creating nmplot object...\n"));
   nm = nmplot_new ();
@@ -30,19 +36,46 @@ function demo_nmplot_qvariable2()
   nm = nmplot_configure(nm, "-simplex0method","spendley");
   
   //
+  // Setup output files
+  //
+  simplexfn = TMPDIR + filesep() + "history.simplex.txt";
+  nm = nmplot_configure(nm, "-simplexfn",simplexfn);
+  //
   // Perform optimization
   //
   mprintf(_("Searching (please wait) ...\n"));
   nm = nmplot_search(nm);
-  disp(nm);
+  //
+  // Print a summary
+  //
+  exec(fullfile(dname,"nmplot_summary.sci"),-1);
+  nmplot_summary(nm)
+  //
+  // Plot the contours of the cost function and the simplex history
+  mprintf(_("Plotting contour (please wait) ...\n"));
+  nm = nmplot_configure(nm, "-verbose", 0);
+  xmin = -5.0 ; 
+  xmax = 12.0 ; 
+  ymin = -2.0 ; 
+  ymax = 12.0 ; 
+  nx = 50 ; 
+  ny = 50;
+  scf()
+  drawlater();
+  xdata=linspace(xmin,xmax,nx);
+  ydata=linspace(ymin,ymax,ny);
+  contour ( xdata , ydata , quadraticC , [10.0 50 100 1000 2000 5000 10000 20000] )
+  nmplot_simplexhistory ( nm );
+  drawnow();
+  //
+  // Clean-up
+  deletefile(simplexfn);
   nm = nmplot_destroy(nm);
   mprintf(_("End of demo.\n"));
 
   //
   // Load this script into the editor
   //
-  filename = 'nmplot_quadratic.variable2.sce';
-  dname = get_absolute_file_path(filename);
   editor ( dname + filename, "readonly" );
 
 endfunction
index 01576c5..712a065 100644 (file)
 
 function demo_nmplot_rosen()
 
+  filename = 'nmplot_rosenbrock.fixed.sce';
+  dname = get_absolute_file_path(filename);
+
   mprintf(_("Illustrates that the fixed-shape Spendley et al. algorithm does NOT perform well on Rosenbrock test case.\n"));
   mprintf(_("Defining Rosenbrock function...\n"));
   
   function [ y , index ] = rosenbrock ( x , index )
     y = 100*(x(2)-x(1)^2)^2 + (1-x(1))^2;
   endfunction
+  function [ y , index ] = rosenbrockC ( x1 , x2 )
+    y = rosenbrock ( [x1 , x2] , 2 )
+  endfunction
 
   mprintf(_("Creating nmplot object ...\n"));
   nm = nmplot_new ();
@@ -33,42 +39,36 @@ function demo_nmplot_rosen()
   // Setup output files
   //
   simplexfn = TMPDIR + filesep() + "history.simplex.txt";
-  fbarfn = TMPDIR + filesep() + "history.fbar.txt";
-  foptfn = TMPDIR + filesep() + "history.fopt.txt";
-  sigmafn = TMPDIR + filesep() + "history.sigma.txt";
   nm = nmplot_configure(nm, "-simplexfn",simplexfn);
-  nm = nmplot_configure(nm, "-fbarfn",fbarfn);
-  nm = nmplot_configure(nm, "-foptfn",foptfn);
-  nm = nmplot_configure(nm, "-sigmafn",sigmafn);
   
   //
   // Perform optimization
   //
   mprintf(_("Searching (please wait) ...\n"));
   nm = nmplot_search(nm);
-  disp(nm);
+  //
+  // Print a summary
+  //
+  exec(fullfile(dname,"nmplot_summary.sci"),-1);
+  nmplot_summary(nm)
   
   // Plot the contours of the cost function and the simplex history
   mprintf(_("Plotting contour (please wait) ...\n"));
-  [nm , xdata , ydata , zdata ] = nmplot_contour ( nm , xmin = -2.0 , xmax = 2.0 , ymin = -2.0 , ymax = 2.0 , nx = 50 , ny = 50 );
+  xmin = -2.0 ; 
+  xmax = 2.0 ; 
+  ymin = -2.0 ; 
+  ymax = 2.0 ; 
+  nx = 50 ; 
+  ny = 50;
+  xdata=linspace(xmin,xmax,nx);
+  ydata=linspace(ymin,ymax,ny);
   f = scf();
   drawlater();
-  contour ( xdata , ydata , zdata , [2 10 100 500 1000 2000] )
+  contour ( xdata , ydata , rosenbrockC , [2 10 100 500 1000 2000] )
   nmplot_simplexhistory ( nm );
   drawnow();
-  mprintf(_("Plotting history of fbar ...\n"));
-  f = scf();
-  nmplot_historyplot ( nm , fbarfn, mytitle = _("Function Value Average") , myxlabel = _("Iterations") );
-  mprintf(_("Plotting history of fopt ...\n"));
-  f = scf();
-  nmplot_historyplot ( nm , foptfn, mytitle = _("Minimum Function Value") , myxlabel = _("Iterations") );
-  mprintf(_("Plotting history of sigma ...\n"));
-  f = scf();
-  nmplot_historyplot ( nm , sigmafn, mytitle = _("Maximum Oriented length") , myxlabel = _("Iterations") );
+  //
   deletefile(simplexfn);
-  deletefile(fbarfn);
-  deletefile(foptfn);
-  deletefile(sigmafn);
   nm = nmplot_destroy(nm);
   mprintf(_("End of demo.\n"));
 
@@ -76,8 +76,6 @@ function demo_nmplot_rosen()
   // Load this script into the editor
   //
   
-  filename = 'nmplot_rosenbrock.fixed.sce';
-  dname = get_absolute_file_path(filename);
   editor ( dname + filename, "readonly" );
 
 endfunction
index 8b5647b..f09c1fa 100644 (file)
@@ -9,68 +9,71 @@
 // are also available at
 // http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
 
+function demo_nmplot_rosenvar()
 
-mprintf("Illustrates the Nelder-Mead algorithm on Rosenbrock test case.\n");
-mprintf("Defining Rosenbrock function...\n");
-function [ y , index ] = rosenbrock ( x , index )
-  y = 100*(x(2)-x(1)^2)^2 + (1-x(1))^2;
-endfunction
+    filename = 'nmplot_rosenbrock.sce';
+    dname = get_absolute_file_path(filename);
+    mprintf("Illustrates the Nelder-Mead algorithm on Rosenbrock test case.\n");
+    mprintf("Defining Rosenbrock function...\n");
+    function [ y , index ] = rosenbrock ( x , index )
+        y = 100*(x(2)-x(1)^2)^2 + (1-x(1))^2;
+    endfunction
+    function [ y , index ] = rosenbrockC ( x1 , x2 )
+        y = rosenbrock ( [x1 , x2] , 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,"-maxfunevals",300);
-nm = nmplot_configure(nm,"-tolfunrelative",10*%eps);
-nm = nmplot_configure(nm,"-tolxrelative",10*%eps);
-//
-// Setup output files
-//
-simplexfn = TMPDIR + filesep() + "history.simplex.txt";
-fbarfn = TMPDIR + filesep() + "history.fbar.txt";
-foptfn = TMPDIR + filesep() + "history.fopt.txt";
-sigmafn = TMPDIR + filesep() + "history.sigma.txt";
-nm = nmplot_configure(nm,"-simplexfn",simplexfn);
-nm = nmplot_configure(nm,"-fbarfn",fbarfn);
-nm = nmplot_configure(nm,"-foptfn",foptfn);
-nm = nmplot_configure(nm,"-sigmafn",sigmafn);
-//
-// Perform optimization
-//
-mprintf("Searching (please wait)...\n");
-nm = nmplot_search(nm);
-disp(nm);
-// Plot the contours of the cost function and the simplex history
-mprintf("Plotting contour (please wait)...\n");
-[nm , xdata , ydata , zdata ] = nmplot_contour ( nm , xmin = -2.0 , xmax = 2.0 , ymin = -1.0 , ymax = 2.5 , nx = 50 , ny = 50 );
-f = scf();
-drawlater();
-contour ( xdata , ydata , zdata , [2 10 100 500 1000 2000] )
-nmplot_simplexhistory ( nm );
-drawnow();
-mprintf("Plotting history of fbar...\n");
-f = scf();
-nmplot_historyplot ( nm , fbarfn, mytitle = "Function Value Average" , myxlabel = "Iterations" );
-mprintf("Plotting history of fopt...\n");
-f = scf();
-nmplot_historyplot ( nm , foptfn, mytitle = "Minimum Function Value" , myxlabel = "Iterations" );
-mprintf("Plotting history of sigma...\n");
-f = scf();
-nmplot_historyplot ( nm , sigmafn, mytitle = "Maximum Oriented length" , myxlabel = "Iterations" );
-mprintf("Cleaning up...\n");
-deletefile(simplexfn);
-deletefile(fbarfn);
-deletefile(foptfn);
-deletefile(sigmafn);
-nm = nmplot_destroy(nm);
-mprintf("End of demo.\n");
+    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,"-maxfunevals",300);
+    nm = nmplot_configure(nm,"-tolfunrelative",10*%eps);
+    nm = nmplot_configure(nm,"-tolxrelative",10*%eps);
+    //
+    // Setup output files
+    //
+    simplexfn = TMPDIR + filesep() + "history.simplex.txt";
+    nm = nmplot_configure(nm,"-simplexfn",simplexfn);
+    //
+    // Perform optimization
+    //
+    mprintf("Searching (please wait)...\n");
+    nm = nmplot_search(nm);
+    //
+    // Print a summary
+    //
+    exec(fullfile(dname,"nmplot_summary.sci"),-1);
+    nmplot_summary(nm)
+    //
+    // Plot the contours of the cost function and the simplex history
+    mprintf("Plotting contour (please wait)...\n");
+    xmin = -2.0; 
+    xmax = 2.0 ; 
+    ymin = -1.0 ; 
+    ymax = 2.5 ; 
+    nx = 50 ; 
+    ny = 50;
+    xdata=linspace(xmin,xmax,nx);
+    ydata=linspace(ymin,ymax,ny);
+    scf();
+    drawlater();
+    contour ( xdata , ydata , rosenbrockC , [2 10 100 500 1000 2000] )
+    nmplot_simplexhistory ( nm );
+    drawnow();
+    //
+    // Cleanup
+    deletefile(simplexfn);
+    nm = nmplot_destroy(nm);
+    mprintf("End of demo.\n");
 
-//
-// Load this script into the editor
-//
-filename = 'nmplot_rosenbrock.sce';
-dname = get_absolute_file_path(filename);
-editor ( dname + filename );
+    //
+    // Load this script into the editor
+    //
+    editor ( dname + filename );
+
+endfunction
 
+demo_nmplot_rosenvar()
+clear demo_nmplot_rosenvar;
diff --git a/scilab/modules/optimization/demos/neldermead/nmplot_summary.sci b/scilab/modules/optimization/demos/neldermead/nmplot_summary.sci
new file mode 100644 (file)
index 0000000..05b2293
--- /dev/null
@@ -0,0 +1,27 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2008-2009 - INRIA - Michael Baudin
+// Copyright (C) 2010 - DIGITEO - Allan CORNET
+// Copyright (C) 2011 - DIGITEO - 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
+
+function nmplot_summary(nm)
+function str = _strvec ( x )
+    str = strcat(string(x)," ")
+endfunction
+
+  xopt = nmplot_get(nm,"-xopt")
+  fopt = nmplot_get(nm,"-fopt")
+  funevals = nmplot_get(nm,"-funevals")
+  iter = nmplot_get(nm,"-iterations")
+  status = nmplot_get(nm,"-status")
+  mprintf("Xopt: [%s]\n",_strvec(xopt));
+  mprintf("Fopt: %s\n",string(fopt));
+  mprintf("Function evaluations: %d\n",funevals);
+  mprintf("Iterations: %d\n",iter);
+  mprintf("Status: %s\n",status);
+endfunction 
index 75b8fe5..a88abbd 100644 (file)
@@ -1,12 +1,12 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
  * Copyright (C) 2008-2009 - INRIA - Michael Baudin
- * Copyright (C) 2009-2010 - DIGITEO - Michael Baudin
+ * Copyright (C) 2009-2011 - DIGITEO - Michael Baudin
 -->
-<refentry 
-          version="5.0-subset Scilab" 
-          xml:id="fminsearch" 
-         xml:lang="fr"
+<refentry
+          version="5.0-subset Scilab"
+          xml:id="fminsearch"
+          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"
   <refnamediv>
     <refname>fminsearch</refname>
 
-    <refpurpose>Computes the unconstrained minimimum of given function with
-    the Nelder-Mead algorithm.</refpurpose>
+    <refpurpose>
+      Computes the unconstrained minimimum of given function with
+      the Nelder-Mead algorithm.
+    </refpurpose>
   </refnamediv>
 
   <refsynopsisdiv>
@@ -27,6 +29,8 @@
     <synopsis>
       x = fminsearch ( costf , x0 )
       x = fminsearch ( costf , x0 , options )
+      [x,fval] = fminsearch ( costf , x0 , options )
+      [x,fval,exitflag] = fminsearch ( costf , x0 , options )
       [x,fval,exitflag,output] = fminsearch ( costf , x0 , options )
     </synopsis>
   </refsynopsisdiv>
   <refsection>
     <title>Description</title>
 
-    <para>This function searches for the unconstrained minimum of a given cost
-    function.</para>
-
-    <para>The provided algorithm is a direct search algorithm, i.e. an
-    algorithm which does not use the derivative of the cost function. It is
-    based on the update of a simplex, which is a set of k&gt;=n+1 vertices,
-    where each vertex is associated with one point and one function value.
-    This algorithm is the Nelder-Mead algorithm.</para>
-    
-    <para>See the demonstrations, in the Optimization section, for an overview
-    of this component.</para>
-    
-    <para>See the "Nelder-Mead User's Manual" on Scilab's wiki and on the
-    Scilab forge for further informations.</para>
+    <para>
+      This function searches for the unconstrained minimum of a given cost
+      function.
+    </para>
+
+    <para>
+      The provided algorithm is a direct search algorithm, i.e. an
+      algorithm which does not use the derivative of the cost function. It is
+      based on the update of a simplex, which is a set of k&gt;=n+1 vertices,
+      where each vertex is associated with one point and one function value.
+      This algorithm is the Nelder-Mead algorithm.
+    </para>
+
+    <para>
+      See the demonstrations, in the Optimization section, for an overview
+      of this component.
+    </para>
+
+    <para>
+      See the "Nelder-Mead User's Manual" on Scilab's wiki and on the
+      Scilab forge for further informations.
+    </para>
   </refsection>
 
   <refsection>
     <title>Design</title>
 
-    <para>This function is based on a specialized use of the more general
-    <link linkend="neldermead">neldermead</link> component. Users which want
-    to have a more flexible solution based on direct search algorithms should
-    consider using the neldermead component instead of the fminsearch
-    function.</para>
+    <para>
+      This function is based on a specialized use of the more general
+      <link linkend="neldermead">neldermead</link> component. Users which want
+      to have a more flexible solution based on direct search algorithms should
+      consider using the neldermead component instead of the fminsearch
+      function.
+    </para>
   </refsection>
 
   <refsection>
         <term>options</term>
 
         <listitem>
-          <para>A struct which contains configurable options of the algorithm
-          (see below for details).</para>
+          <para>
+            A struct which contains configurable options of the algorithm
+            (see below for details).
+          </para>
         </listitem>
       </varlistentry>
 
               <term>-1</term>
 
               <listitem>
-                <para>The maximum number of iterations has been
-                reached.</para>
+                <para>
+                  The maximum number of iterations has been
+                  reached.
+                </para>
               </listitem>
             </varlistentry>
 
               <term>0</term>
 
               <listitem>
-                <para>The maximum number of function evaluations has been
-                reached.</para>
+                <para>
+                  The maximum number of function evaluations has been
+                  reached.
+                </para>
               </listitem>
             </varlistentry>
 
               <term>1</term>
 
               <listitem>
-                <para>The tolerance on the simplex size and function value
-                delta has been reached. This signifies that the algorithm has
-                converged, probably to a solution of the problem.</para>
+                <para>
+                  The tolerance on the simplex size and function value
+                  delta has been reached. This signifies that the algorithm has
+                  converged, probably to a solution of the problem.
+                </para>
               </listitem>
             </varlistentry>
           </variablelist>
         <term>output</term>
 
         <listitem>
-          <para>A struct which stores detailed information about the exit of
-          the algorithm. This struct contains the following fields.</para>
+          <para>
+            A struct which stores detailed information about the exit of
+            the algorithm. This struct contains the following fields.
+          </para>
 
           <variablelist>
             <varlistentry>
               <term>output.algorithm</term>
 
               <listitem>
-                <para>A string containing the definition of the algorithm
-                used, i.e. 'Nelder-Mead simplex direct search'.</para>
+                <para>
+                  A string containing the definition of the algorithm
+                  used, i.e. 'Nelder-Mead simplex direct search'.
+                </para>
               </listitem>
             </varlistentry>
 
   <refsection>
     <title>Options</title>
 
-    <para>In this section, we describe the options input argument which have
-    an effect on the algorithm used by fminsearch.</para>
+    <para>
+      In this section, we describe the options input argument which have
+      an effect on the algorithm used by fminsearch.
+    </para>
 
     <para>
-    The options input argument is a data structure which drives the
-    behaviour of fminsearch. It allows to handle several options in a
-    consistent and simple interface, without the problem of managing many
-    input arguments.
+      The options input argument is a data structure which drives the
+      behaviour of fminsearch. It allows to handle several options in a
+      consistent and simple interface, without the problem of managing many
+      input arguments.
     </para>
 
     <para>
-    These options must be set with the <link linkend="optimset">optimset</link> function.
-    See the <link linkend="optimset">optimset</link> help for details 
-    of the options managed by this function.
+      These options must be set with the <link linkend="optimset">optimset</link> function.
+      See the <link linkend="optimset">optimset</link> help for details
+      of the options managed by this function.
     </para>
 
     <para>
-    The fminsearch function is sensitive to the following
-    options.
+      The fminsearch function is sensitive to the following
+      options.
     </para>
 
     <variablelist>
         <term>options.MaxIter</term>
 
         <listitem>
-          <para>The maximum number of iterations. The default is 200 * n,
-          where n is the number of variables.</para>
+          <para>
+            The maximum number of iterations. The default is 200 * n,
+            where n is the number of variables.
+          </para>
         </listitem>
       </varlistentry>
 
         <term>options.MaxFunEvals</term>
 
         <listitem>
-          <para>The maximum number of evaluations of the cost function. The
-          default is 200 * n, where n is the number of variables.</para>
+          <para>
+            The maximum number of evaluations of the cost function. The
+            default is 200 * n, where n is the number of variables.
+          </para>
         </listitem>
       </varlistentry>
 
         <term>options.TolFun</term>
 
         <listitem>
-          <para>The absolute tolerance on function value. The default value is
-          1.e-4.</para>
+          <para>
+            The absolute tolerance on function value. The default value is
+            1.e-4.
+          </para>
         </listitem>
       </varlistentry>
 
         <term>options.TolX</term>
 
         <listitem>
-          <para>The absolute tolerance on simplex size. The default value is
-          1.e-4.</para>
+          <para>
+            The absolute tolerance on simplex size. The default value is
+            1.e-4.
+          </para>
         </listitem>
       </varlistentry>
 
 
         <listitem>
           <para>
-         The verbose level. 
-          Possible values are "notify", "iter", "final" and "off". 
-          The default value is "notify".
-         </para>
+            The verbose level.
+            Possible values are "notify", "iter", "final" and "off".
+            The default value is "notify".
+          </para>
         </listitem>
       </varlistentry>
 
         <term>options.OutputFcn</term>
 
         <listitem>
-          <para>The output function, or a list of output functions. The default 
-         value is empty.</para>
+          <para>
+            The output function, or a list of output functions. The default
+            value is empty.
+          </para>
         </listitem>
       </varlistentry>
 
         <term>options.PlotFcns</term>
 
         <listitem>
-          <para>The plot function, or a list of plotput functions. The default 
-         value is empty.</para>
+          <para>
+            The plot function, or a list of plotput functions. The default
+            value is empty.
+          </para>
         </listitem>
       </varlistentry>
 
   <refsection>
     <title>Termination criteria</title>
 
-    <para>In this section, we describe the termination criteria used by
-    fminsearch.</para>
+    <para>
+      In this section, we describe the termination criteria used by
+      fminsearch.
+    </para>
 
     <para>The criteria is based on the following variables:</para>
 
         <term>shiftfv</term>
 
         <listitem>
-          <para>the absolute value of the difference of function value between
-          the highest and lowest vertices.</para>
+          <para>
+            the absolute value of the difference of function value between
+            the highest and lowest vertices.
+          </para>
         </listitem>
       </varlistentry>
     </variablelist>
 
     <para>If both the following conditions</para>
 
-    <programlisting role="example"> 
-ssize &lt; options.TolX
- </programlisting>
+    <programlisting role="example">
+      ssize &lt; options.TolX
+    </programlisting>
 
     <para>and</para>
 
-    <programlisting role="example"> 
-shiftfv &lt; options.TolFun
- </programlisting>
+    <programlisting role="example">
+      shiftfv &lt; options.TolFun
+    </programlisting>
 
     <para>are true, then the iterations stop.</para>
 
-    <para>The size of the simplex is computed using the "sigmaplus" method of
-    the optimsimplex component. The "sigmamplus" size is the maximum length of
-    the vector from each vertex to the first vertex. It requires one loop over
-    the vertices of the simplex.</para>
+    <para>
+      The size of the simplex is computed using the "sigmaplus" method of
+      the optimsimplex component. The "sigmamplus" size is the maximum length of
+      the vector from each vertex to the first vertex. It requires one loop over
+      the vertices of the simplex.
+    </para>
   </refsection>
 
   <refsection>
     <title>The initial simplex</title>
 
-    <para>The fminsearch algorithm uses a special initial simplex, which is an
-    heuristic depending on the initial guess. The strategy chosen by
-    fminsearch corresponds to the -simplex0method flag of the neldermead
-    component, with the "pfeffer" method. It is associated with the
-    -simplex0deltausual = 0.05 and -simplex0deltazero = 0.0075 parameters.
-    Pfeffer's method is a heuristic which is presented in "Global
-    Optimization Of Lennard-Jones Atomic Clusters" by Ellen Fan. It is due to
-    L. Pfeffer at Stanford. See in the help of optimsimplex for more
-    details.</para>
+    <para>
+      The fminsearch algorithm uses a special initial simplex, which is an
+      heuristic depending on the initial guess. The strategy chosen by
+      fminsearch corresponds to the -simplex0method flag of the neldermead
+      component, with the "pfeffer" method. It is associated with the
+      -simplex0deltausual = 0.05 and -simplex0deltazero = 0.0075 parameters.
+      Pfeffer's method is a heuristic which is presented in "Global
+      Optimization Of Lennard-Jones Atomic Clusters" by Ellen Fan. It is due to
+      L. Pfeffer at Stanford. See in the help of optimsimplex for more
+      details.
+    </para>
   </refsection>
 
   <refsection>
     <title>The number of iterations</title>
 
     <para>
-    In this section, we present the default values for the number of
-    iterations in fminsearch.
+      In this section, we present the default values for the number of
+      iterations in fminsearch.
     </para>
 
-    <para>The <emphasis>options</emphasis> input argument is an optionnal data
-    structure which can contain the <emphasis>options.MaxIter</emphasis>
-    field. It stores the maximum number of iterations. The default value is
-    200n, where n is the number of variables. The factor 200 has not been
-    chosen by chance, but is the result of experiments performed against
-    quadratic functions with increasing space dimension.</para>
+    <para>
+      The <emphasis>options</emphasis> input argument is an optionnal data
+      structure which can contain the <emphasis>options.MaxIter</emphasis>
+      field. It stores the maximum number of iterations. The default value is
+      200n, where n is the number of variables. The factor 200 has not been
+      chosen by chance, but is the result of experiments performed against
+      quadratic functions with increasing space dimension.
+    </para>
 
     <para>
-    This result is presented in "Effect of dimensionality on the
-    nelder-mead simplex method" by Lixing Han and Michael Neumann. This paper
-    is based on Lixing Han's PhD, "Algorithms in Unconstrained Optimization".
-    The study is based on numerical experiment with a quadratic function where
-    the number of terms depends on the dimension of the space (i.e. the number
-    of variables). Their study shows that the number of iterations required to
-    reach the tolerance criteria is roughly 100n. Most iterations are based on
-    inside contractions. Since each step of the Nelder-Mead algorithm only
-    require one or two function evaluations, the number of required function
-    evaluations in this experiment is also roughly 100n.
+      This result is presented in "Effect of dimensionality on the
+      nelder-mead simplex method" by Lixing Han and Michael Neumann. This paper
+      is based on Lixing Han's PhD, "Algorithms in Unconstrained Optimization".
+      The study is based on numerical experiment with a quadratic function where
+      the number of terms depends on the dimension of the space (i.e. the number
+      of variables). Their study shows that the number of iterations required to
+      reach the tolerance criteria is roughly 100n. Most iterations are based on
+      inside contractions. Since each step of the Nelder-Mead algorithm only
+      require one or two function evaluations, the number of required function
+      evaluations in this experiment is also roughly 100n.
     </para>
   </refsection>
-  
+
   <refsection>
     <title>Output and plot functions</title>
 
     <para>
-    The <link linkend="optimset">optimset</link> function can be used to 
-    configure one or more output and plot functions. 
+      The <link linkend="optimset">optimset</link> function can be used to
+      configure one or more output and plot functions.
     </para>
     <para>
-    The output or plot function is expected to have the following definition:
+      The output function is expected to have the following header:
     </para>
-      <programlisting role="example">
+    <programlisting role="example">
       <![CDATA[ 
-function myfun ( x , optimValues , state )
+stop = myoutputfun ( x , optimValues , state )
  ]]>
- </programlisting>
-    <para>
-    The input arguments <literal>x</literal>, <literal>optimValues</literal>
-    and <literal>state</literal> are described in detail in the <link linkend="optimset">optimset</link> 
-    help page. The <literal>optimValues.procedure</literal> field represent the type of step
-    used during the current iteration and can be equal to one 
-    of the following strings</para>
-    
+    </programlisting>
+    <para>
+      The input arguments <literal>x</literal>, <literal>optimValues</literal>
+      and <literal>state</literal> are described in detail in the <link linkend="optimset">optimset</link>
+      help page.
+      Set the <literal>stop</literal> boolean variable to false to continue the optimization and
+      set it to true to interrupt the optimization.
+      The <literal>optimValues.procedure</literal> field represent the type of step
+      used during the current iteration and can be equal to one
+      of the following strings
+    </para>
+
     <itemizedlist>
-    
-    <listitem>
+
+      <listitem>
         <para>"" (the empty string),</para>
-    </listitem>
+      </listitem>
 
-    <listitem>
-    <para>"initial simplex",</para>
-    </listitem>
+      <listitem>
+        <para>"initial simplex",</para>
+      </listitem>
 
-    <listitem>
-    <para>"expand",</para>
-    </listitem>
+      <listitem>
+        <para>"expand",</para>
+      </listitem>
 
-    <listitem>
-    <para>"reflect",</para>
-    </listitem>
+      <listitem>
+        <para>"reflect",</para>
+      </listitem>
 
-    <listitem>
-    <para>"contract inside",</para>
-    </listitem>
+      <listitem>
+        <para>"contract inside",</para>
+      </listitem>
 
-    <listitem>
-    <para>"contract outside".</para>
-    </listitem>
+      <listitem>
+        <para>"contract outside".</para>
+      </listitem>
 
     </itemizedlist>
-    
+
+    <para>
+      The plot function is expected to have the following header:
+    </para>
+    <programlisting role="example">
+      <![CDATA[ 
+myplotfun ( x , optimValues , state )
+ ]]>
+    </programlisting>
+    <para>
+      where the input arguments <literal>x</literal>, <literal>optimValues</literal>
+      and <literal>state</literal> have the same definition as for the output function.
+    </para>
+
   </refsection>
 
   <refsection>
     <title>Example</title>
 
     <para>
-    In the following example, we use the fminsearch function to compute
-    the minimum of the Rosenbrock function. We first define the function
-    "banana", and then use the fminsearch function to search the minimum,
-    starting with the initial guess [-1.2 1.0].
-    In this particular case, 85 iterations are performed and 159 function 
-    evaluations are 
+      In the following example, we use the fminsearch function to compute
+      the minimum of the Rosenbrock function. We first define the function
+      "banana", and then use the fminsearch function to search the minimum,
+      starting with the initial guess [-1.2 1.0].
+      In this particular case, 85 iterations are performed and 159 function
+      evaluations are
     </para>
 
-    <programlisting role="example"> 
-     <![CDATA[ 
+    <programlisting role="example">
+      <![CDATA[ 
 function y = banana (x)
   y = 100*(x(2)-x(1)^2)^2 + (1-x(1))^2;
 endfunction
@@ -450,28 +517,28 @@ fval
 exitflag
 output
  ]]>
- </programlisting>
+    </programlisting>
   </refsection>
 
   <refsection>
     <title>Example with customized options</title>
 
     <para>
-    In the following example, we configure the absolute tolerance 
-    on the size of the simplex to a larger value, so that the algorithm
-    performs less iterations. Since the default value of "TolX" for the 
-    fminsearch function is 1.e-4, we decide to use 1.e-2.
-    The <link linkend="optimset">optimset</link> function is used to create an
-    optimization data structure and the field associated with the string "TolX" 
-    is set to 1.e-2. The <literal>opt</literal> data structure is then 
-    passed to the <literal>fminsearch</literal> function as the third 
-    input argument.
-    In this particular case, the number of iterations is 70
-    with 130 function evaluations.
+      In the following example, we configure the absolute tolerance
+      on the size of the simplex to a larger value, so that the algorithm
+      performs less iterations. Since the default value of "TolX" for the
+      fminsearch function is 1.e-4, we decide to use 1.e-2.
+      The <link linkend="optimset">optimset</link> function is used to create an
+      optimization data structure and the field associated with the string "TolX"
+      is set to 1.e-2. The <literal>opt</literal> data structure is then
+      passed to the <literal>fminsearch</literal> function as the third
+      input argument.
+      In this particular case, the number of iterations is 70
+      with 130 function evaluations.
     </para>
 
-    <programlisting role="example"> 
-     <![CDATA[ 
+    <programlisting role="example">
+      <![CDATA[ 
 function y = banana (x)
   y = 100*(x(2)-x(1)^2)^2 + (1-x(1))^2;
 endfunction
@@ -482,49 +549,57 @@ fval
 exitflag
 output
  ]]>
- </programlisting>
+    </programlisting>
   </refsection>
 
   <refsection>
     <title>Example with a pre-defined plot function</title>
 
-    <para>In the following example, we want to produce a graphic of the 
-      progression of the algorithm, so that we can include that graphic 
+    <para>
+      In the following example, we want to produce a graphic of the
+      progression of the algorithm, so that we can include that graphic
       into a report without defining a customized plot function.
-      The <literal>fminsearch</literal> function comes with the 
-      following 3 pre-defined functions :</para>
+      The <literal>fminsearch</literal> function comes with the
+      following 3 pre-defined functions :
+    </para>
     <itemizedlist>
       <listitem>
-       <para>optimplotfval, which plots the function value,</para>
+        <para>optimplotfval, which plots the function value,</para>
       </listitem>
       <listitem>
-       <para>optimplotx, which plots the current point <literal>x</literal>,</para>
+        <para>
+          optimplotx, which plots the current point <literal>x</literal>,
+        </para>
       </listitem>
       <listitem>
-       <para>optimplotfunccount, which plots the number of function evaluations.</para>
+        <para>optimplotfunccount, which plots the number of function evaluations.</para>
       </listitem>
     </itemizedlist>
-    <para>In the following example, we use the three pre-defined functions 
-    in order to create one graphic, representing the function value depending on 
-    the number of iterations.</para>
-    
-    <programlisting role="example"><![CDATA[ 
+    <para>
+      In the following example, we use the three pre-defined functions
+      in order to create one graphic, representing the function value depending on
+      the number of iterations.
+    </para>
+
+    <programlisting role="example">
+      <![CDATA[ 
 function y = banana (x)
   y = 100*(x(2)-x(1)^2)^2 + (1-x(1))^2;
 endfunction
 opt = optimset ( "PlotFcns" , optimplotfval );
 [x fval] = fminsearch ( banana , [-1.2 1] , opt );
- ]]></programlisting>
-     <para>
-     In the previous example, we could replace the "optimplotfval"
-     function with "optimplotx" or "optimplotfunccount" and obtain different
-     results. In fact, we can get all the figures at the same time, by 
-     setting the  "PlotFcns" to a list of functions, as in the following example.
+ ]]>
+    </programlisting>
+
+    <para>
+      In the previous example, we could replace the "optimplotfval"
+      function with "optimplotx" or "optimplotfunccount" and obtain different
+      results. In fact, we can get all the figures at the same time, by
+      setting the  "PlotFcns" to a list of functions, as in the following example.
     </para>
 
-    <programlisting role="example"> 
-     <![CDATA[ 
+    <programlisting role="example">
+      <![CDATA[ 
 function y = banana (x)
   y = 100*(x(2)-x(1)^2)^2 + (1-x(1))^2;
 endfunction
@@ -532,7 +607,7 @@ myfunctions = list ( optimplotfval , optimplotx , optimplotfunccount );
 opt = optimset ( "PlotFcns" , myfunctions );
 [x fval] = fminsearch ( banana , [-1.2 1] , opt );
  ]]>
- </programlisting>
+    </programlisting>
 
   </refsection>
 
@@ -540,272 +615,291 @@ opt = optimset ( "PlotFcns" , myfunctions );
     <title>Example with a customized output function</title>
 
     <para>
-    In the following example, we want to produce intermediate 
-    outputs of the algorithm. We define the <literal>outfun</literal> 
-    function, which takes the current point <literal>x</literal> as input argument. 
-    The function plots the current point into the current graphic window
-    with the <literal>plot</literal> function.
-    We use the "OutputFcn" feature of the <link linkend="optimset">optimset</link> function 
-    and set it to the output function. Then the option data structure is passed to the 
-    <literal>fminsearch</literal> function. At each iteration, the output 
-    function is called back, which creates and update an interactive plot.
-    While this example creates a 2D plot, the user may customized the 
-    output function so that it writes a message in the console, write some 
-    data into a data file, etc... The user can distinguish 
-    between the output function (associated with the "OutputFcn" option)
-    and the plot function (associated with the "PlotFcns" option). 
-    See the <link linkend="optimset">optimset</link> for more details on this feature.
-    </para>
-
-    <programlisting role="example"> 
-     <![CDATA[ 
+      In the following example, we want to produce intermediate
+      outputs of the algorithm. We define the <literal>outfun</literal>
+      function, which takes the current point <literal>x</literal> as input argument.
+      The function plots the current point into the current graphic window
+      with the <literal>plot</literal> function.
+      We use the "OutputFcn" feature of the <link linkend="optimset">optimset</link> function
+      and set it to the output function. Then the option data structure is passed to the
+      <literal>fminsearch</literal> function. At each iteration, the output
+      function is called back, which creates and update an interactive plot.
+      While this example creates a 2D plot, the user may customized the
+      output function so that it writes a message in the console, write some
+      data into a data file, etc... The user can distinguish
+      between the output function (associated with the "OutputFcn" option)
+      and the plot function (associated with the "PlotFcns" option).
+      See the <link linkend="optimset">optimset</link> for more details on this feature.
+    </para>
+
+    <programlisting role="example">
+      <![CDATA[ 
 function y = banana (x)
   y = 100*(x(2)-x(1)^2)^2 + (1-x(1))^2;
 endfunction
-function outfun ( x , optimValues , state )
+function stop = outfun ( x , optimValues , state )
   plot( x(1),x(2),'.');
+  stop = %f
 endfunction
 opt = optimset ( "OutputFcn" , outfun);
 [x fval] = fminsearch ( banana , [-1.2 1] , opt );
  ]]>
- </programlisting>
+    </programlisting>
+
   </refsection>
 
   <refsection>
     <title>Example with customized "Display" option</title>
 
     <para>
-    The "Display" option allows to get some input about the intermediate 
-    steps of the algorithm as well as to be warned in case of a convergence problem.
+      The "Display" option allows to get some input about the intermediate
+      steps of the algorithm as well as to be warned in case of a convergence problem.
     </para>
 
     <para>
-    In the following example, we present what happens in case of a convergence problem.
-    We set the number of iterations to 10, instead of the 
-    default 400 iterations. We know that 85 iterations are required to reach the convergence 
-    criteria. 
-    Therefore, the convergence criteria is not met and the maximum number of iterations is reached.
+      In the following example, we present what happens in case of a convergence problem.
+      We set the number of iterations to 10, instead of the
+      default 400 iterations. We know that 85 iterations are required to reach the convergence
+      criteria.
+      Therefore, the convergence criteria is not met and the maximum number of iterations is reached.
     </para>
 
-    <programlisting role="example"> 
-     <![CDATA[ 
+    <programlisting role="example">
+      <![CDATA[ 
 function y = banana (x)
   y = 100*(x(2)-x(1)^2)^2 + (1-x(1))^2;
 endfunction
 opt = optimset ( "MaxIter" , 10 );
 [x fval] = fminsearch ( banana , [-1.2 1] , opt );
  ]]>
- </programlisting>
+    </programlisting>
 
     <para>
-    Since the default value of the "Display" option is "notify", a message is generated,
-    which warns the user about a possible convergence problem.
-    The previous script produces the following output.
+      Since the default value of the "Display" option is "notify", a message is generated,
+      which warns the user about a possible convergence problem.
+      The previous script produces the following output.
     </para>
 
-    <programlisting role="example"> 
-Exiting: Maximum number of iterations has been exceeded
-         - increase MaxIter option.
-         Current function value: 4.1355598
- </programlisting>
+    <programlisting role="example">
+      Exiting: Maximum number of iterations has been exceeded
+      - increase MaxIter option.
+      Current function value: 4.1355598
+    </programlisting>
 
     <para>
-    Notice that if the "Display" option is now set to "off", no message is displayed at all.
-    Therefore, the user should be warned that turning the Display "off" should be used 
-    at your own risk...
+      Notice that if the "Display" option is now set to "off", no message is displayed at all.
+      Therefore, the user should be warned that turning the Display "off" should be used
+      at your own risk...
     </para>
 
     <para>
-    In the following example, we present how to display intermediate steps 
-    used by the algorithm. We simply set the "Display" option to the "iter" value.
+      In the following example, we present how to display intermediate steps
+      used by the algorithm. We simply set the "Display" option to the "iter" value.
     </para>
 
-    <programlisting role="example"> 
-     <![CDATA[ 
+    <programlisting role="example">
+      <![CDATA[ 
 function y = banana (x)
   y = 100*(x(2)-x(1)^2)^2 + (1-x(1))^2;
 endfunction
 opt = optimset ( "Display" , "iter" );
 [x fval] = fminsearch ( banana , [-1.2 1] , opt );
  ]]>
- </programlisting>
+    </programlisting>
 
     <para>
-    The previous script produces the following output. It allows to see the number of function 
-    evaluations, the minimum function value and which type of simplex step is used 
-    for the iteration.
+      The previous script produces the following output. It allows to see the number of function
+      evaluations, the minimum function value and which type of simplex step is used
+      for the iteration.
     </para>
 
-    <programlisting role="example"> 
- Iteration   Func-count     min f(x)         Procedure
-     0            3             24.2                             
-     1            3            20.05         initial simplex     
-     2            5         5.161796         expand              
-     3            7         4.497796         reflect             
-     4            9         4.497796         contract outside    
-     5           11        4.3813601         contract inside     
-     etc...
- </programlisting>
+    <programlisting role="example">
+      Iteration   Func-count     min f(x)         Procedure
+      0            3             24.2
+      1            3            20.05         initial simplex
+      2            5         5.161796         expand
+      3            7         4.497796         reflect
+      4            9         4.497796         contract outside
+      5           11        4.3813601         contract inside
+      etc...
+    </programlisting>
 
-</refsection>
+  </refsection>
 
   <refsection>
     <title>Example with customized output option</title>
 
     <para>
-    In this section, we present an example where all the fields from the <literal>optimValues</literal>
-    data structure are used to print a message at each iteration. 
+      In this section, we present an example where all the fields from the <literal>optimValues</literal>
+      data structure are used to print a message at each iteration.
     </para>
 
-    <programlisting role="example"> 
-     <![CDATA[ 
-function outfun ( x , optimValues , state )
+    <programlisting role="example">
+      <![CDATA[ 
+function stop = outfun ( x , optimValues , state )
   fc = optimValues.funccount;
   fv = optimValues.fval;
   it = optimValues.iteration;
   pr = optimValues.procedure;
   mprintf ( "%d %e %d -%s-\n" , fc , fv , it , pr )
+  stop = %f
 endfunction
 opt = optimset ( "OutputFcn" , outfun );
 [x fval] = fminsearch ( banana , [-1.2 1] , opt );
  ]]>
- </programlisting>
+    </programlisting>
+
     <para>
-    The previous script produces the following output. 
+      The previous script produces the following output.
     </para>
 
-    <programlisting role="example"> 
-3 2.420000e+001 0 --
-3 2.005000e+001 1 -initial simplex-
-5 5.161796e+000 2 -expand-
-7 4.497796e+000 3 -reflect-
-9 4.497796e+000 4 -contract outside-
-11 4.381360e+000 5 -contract inside-
-13 4.245273e+000 6 -contract inside-
-[...]
-157 1.107549e-009 84 -contract outside-
-159 8.177661e-010 85 -contract inside-
-159 8.177661e-010 85 --
- </programlisting>
+    <programlisting role="example">
+      3 2.420000e+001 0 --
+      3 2.005000e+001 1 -initial simplex-
+      5 5.161796e+000 2 -expand-
+      7 4.497796e+000 3 -reflect-
+      9 4.497796e+000 4 -contract outside-
+      11 4.381360e+000 5 -contract inside-
+      13 4.245273e+000 6 -contract inside-
+      [...]
+      157 1.107549e-009 84 -contract outside-
+      159 8.177661e-010 85 -contract inside-
+      159 8.177661e-010 85 --
+    </programlisting>
 
-</refsection>
+  </refsection>
 
   <refsection>
     <title>Some advices</title>
 
     <para>
-    In this section, we present some practical advices with respect 
-    to the Nelder-Mead method. A deeper analysis is provided 
-    in the bibliography at the end of this help page,
-    as well as in the "Nelder-Mead User's Manual" provided on Scilab's Wiki.
-    The following is a quick list of tips to overcome problems
-    that may happen with this algorithm.</para>
+      In this section, we present some practical advices with respect
+      to the Nelder-Mead method. A deeper analysis is provided
+      in the bibliography at the end of this help page,
+      as well as in the "Nelder-Mead User's Manual" provided on Scilab's Wiki.
+      The following is a quick list of tips to overcome problems
+      that may happen with this algorithm.
+    </para>
     <itemizedlist>
-    
-    <listitem>
-    <para>
-    We should consider the <link linkend="optim">optim</link> function before 
-    considering the <literal>fminsearch</literal> function.
-    Because <link linkend="optim">optim</link> uses the gradient of the 
-    function and uses this information to guess the local curvature
-    of the cost function, the number of iterations and function evaluations
-    is (much) lower with <link linkend="optim">optim</link>, when the 
-    function is sufficiently smooth. If the derivatives of the function are 
-    not available, it is still possible to use numerical derivatives combined 
-    with the <link linkend="optim">optim</link> function (this feature 
-    is provided by the <link linkend="derivative">derivative</link> and 
-    <link linkend="numdiff">numdiff</link> functions).
-    If the function has discontinuous derivatives, the <link linkend="optim">optim</link> 
-    function provides the <literal>nd</literal> solver which is very efficient.
-    Still, there are situations where the cost function is discontinuous or "noisy".
-    In these situations, the <literal>fminsearch</literal> function can perform
-    well.
-    </para>
-    </listitem>
-
-   <listitem>
-    <para>
-    We should not expected a fast convergence with 
-    many parameters, i.e. more that 10 to 20 parameters. It is known that the 
-    efficiency of this algorithm decreases rapidly when the number of 
-    parameters increases.
-    </para>
-    </listitem>
-
-    <listitem>
-    <para>
-    The default tolerances are set to pretty loose values.
-    We should not reduce the tolerances in the goal of getting 
-    very accurate results. Because the convergence rate of 
-    Nelder-Mead's algorithm is low (at most linear), getting a very
-    accurate solution will require a large number of iterations.
-    Instead, we can most of the time expect a "good reduction" 
-    of the cost function with this algorithm.
-    </para>
-    </listitem>
-
-    <listitem>
-    <para>
-    Although the algorithm practically converges in many situations, 
-    the Nelder-Mead algorithm is not a provably convergent algorithm.
-    There are several known counter-examples where the algorithm
-    fails to converge on a stationnary point and, instead, converge
-    to a non-stationnary point. This situation is often indicated by a 
-    repeated application of the contraction step. In that situation, we simply restart the 
-    algorithm with the final point as the new initial guess.
-    If the algorithm converges to the same point, there is a good
-    chance that this point is a "good" solution.
-    </para>
-    </listitem>
-
-    <listitem>
-    <para>
-    Taking into account for bounds constraints or non-linear inequality
-    constraints can be done by penalization methods, i.e.
-    setting the function value to a high value when the constraints 
-    are not satisfied. While this approach works in some situations,
-    it may also fail. In this case, users might be interested in Box's complex 
-    algorithm, provided by Scilab in the <literal>neldermead</literal>
-    component. If the problem is really serious, Box's complex algorithm will 
-    also fail and a more powerful solver is necessary.
-    </para>
-    </listitem>
-
-   </itemizedlist>
-</refsection>
+
+      <listitem>
+        <para>
+          We should consider the <link linkend="optim">optim</link> function before
+          considering the <literal>fminsearch</literal> function.
+          Because <link linkend="optim">optim</link> uses the gradient of the
+          function and uses this information to guess the local curvature
+          of the cost function, the number of iterations and function evaluations
+          is (much) lower with <link linkend="optim">optim</link>, when the
+          function is sufficiently smooth. If the derivatives of the function are
+          not available, it is still possible to use numerical derivatives combined
+          with the <link linkend="optim">optim</link> function (this feature
+          is provided by the <link linkend="derivative">derivative</link> and
+          <link linkend="numdiff">numdiff</link> functions).
+          If the function has discontinuous derivatives, the <link linkend="optim">optim</link>
+          function provides the <literal>nd</literal> solver which is very efficient.
+          Still, there are situations where the cost function is discontinuous or "noisy".
+          In these situations, the <literal>fminsearch</literal> function can perform
+          well.
+        </para>
+      </listitem>
+
+      <listitem>
+        <para>
+          We should not expected a fast convergence with
+          many parameters, i.e. more that 10 to 20 parameters. It is known that the
+          efficiency of this algorithm decreases rapidly when the number of
+          parameters increases.
+        </para>
+      </listitem>
+
+      <listitem>
+        <para>
+          The default tolerances are set to pretty loose values.
+          We should not reduce the tolerances in the goal of getting
+          very accurate results. Because the convergence rate of
+          Nelder-Mead's algorithm is low (at most linear), getting a very
+          accurate solution will require a large number of iterations.
+          Instead, we can most of the time expect a "good reduction"
+          of the cost function with this algorithm.
+        </para>
+      </listitem>
+
+      <listitem>
+        <para>
+          Although the algorithm practically converges in many situations,
+          the Nelder-Mead algorithm is not a provably convergent algorithm.
+          There are several known counter-examples where the algorithm
+          fails to converge on a stationnary point and, instead, converge
+          to a non-stationnary point. This situation is often indicated by a
+          repeated application of the contraction step. In that situation, we simply restart the
+          algorithm with the final point as the new initial guess.
+          If the algorithm converges to the same point, there is a good
+          chance that this point is a "good" solution.
+        </para>
+      </listitem>
+
+      <listitem>
+        <para>
+          Taking into account for bounds constraints or non-linear inequality
+          constraints can be done by penalization methods, i.e.
+          setting the function value to a high value when the constraints
+          are not satisfied. While this approach works in some situations,
+          it may also fail. In this case, users might be interested in Box's complex
+          algorithm, provided by Scilab in the <literal>neldermead</literal>
+          component. If the problem is really serious, Box's complex algorithm will
+          also fail and a more powerful solver is necessary.
+        </para>
+      </listitem>
+
+    </itemizedlist>
+  </refsection>
 
 
   <refsection>
     <title>Bibliography</title>
 
-    <para>"Sequential Application of Simplex Designs in Optimisation and
-    Evolutionary Operation", Spendley, W. and Hext, G. R. and Himsworth, F.
-    R., American Statistical Association and American Society for Quality,
-    1962</para>
+    <para>
+      "Sequential Application of Simplex Designs in Optimisation and
+      Evolutionary Operation", 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, 1965</para>
+    <para>
+      "A Simplex Method for Function Minimization", Nelder, J. A. and
+      Mead, R., The Computer Journal, 1965
+    </para>
 
-    <para>"Iterative Methods for Optimization", C. T. Kelley, SIAM Frontiers
-    in Applied Mathematics, 1999</para>
+    <para>
+      "Iterative Methods for Optimization", C. T. Kelley, SIAM Frontiers
+      in Applied Mathematics, 1999
+    </para>
 
-    <para>"Algorithm AS47 - Function minimization using a simplex procedure",
-    O'Neill, R., Applied Statistics, 1971</para>
+    <para>
+      "Algorithm AS47 - Function minimization using a simplex procedure",
+      O'Neill, R., Applied Statistics, 1971
+    </para>
 
-    <para>"Effect of dimensionality on the nelder-mead simplex method", Lixing
-    Han and Michael Neumann, Optimization Methods and Software, 21, 1, 1--16,
-    2006.</para>
+    <para>
+      "Effect of dimensionality on the nelder-mead simplex method", Lixing
+      Han and Michael Neumann, Optimization Methods and Software, 21, 1, 1--16,
+      2006.
+    </para>
+
+    <para>
+      "Algorithms in Unconstrained Optimization", Lixing Han, Ph.D., The
+      University of Connecticut, 2000.
+    </para>
 
-    <para>"Algorithms in Unconstrained Optimization", Lixing Han, Ph.D., The
-    University of Connecticut, 2000.</para>
+    <para>
+      "Global Optimization Of Lennard-Jones Atomic Clusters" Ellen Fan,
+      Thesis, February 26, 2002, McMaster University
+    </para>
 
-    <para>"Global Optimization Of Lennard-Jones Atomic Clusters" Ellen Fan,
-    Thesis, February 26, 2002, McMaster University</para>
-    
-    <para>"Nelder Mead's User Manual", Consortium Scilab - Digiteo, Michael 
-    Baudin, 2010</para>
+    <para>
+      "Nelder Mead's User Manual", Consortium Scilab - Digiteo, Michael
+      Baudin, 2010
+    </para>
   </refsection>
 
   <refsection>
@@ -817,13 +911,17 @@ opt = optimset ( "OutputFcn" , outfun );
       </listitem>
 
       <listitem>
-        <para>add a demo with an interactive output function, which draws the
-        plot during the optimization.</para>
+        <para>
+          add a demo with an interactive output function, which draws the
+          plot during the optimization.
+        </para>
       </listitem>
 
       <listitem>
-        <para>implement the stop of an optimization via the stop output
-        argument of the output function</para>
+        <para>
+          implement the stop of an optimization via the stop output
+          argument of the output function
+        </para>
       </listitem>
 
     </itemizedlist>
@@ -840,21 +938,37 @@ opt = optimset ( "OutputFcn" , outfun );
   <refsection>
     <title>Acknowledgements</title>
 
-    <para>Michael Baudin would like to thank Lixing Han, who kindly sent his
-    PhD thesis.</para>
+    <para>
+      Michael Baudin would like to thank Lixing Han, who kindly sent his
+      PhD thesis.
+    </para>
   </refsection>
 
   <refsection role="see also">
-<title>See Also</title>
+    <title>See Also</title>
 
     <simplelist type="inline">
-      <member><link linkend="optim">optim</link></member>
-      <member><link linkend="neldermead">neldermead</link></member>
-      <member><link linkend="optimset">optimset</link></member>
-      <member><link linkend="optimget">optimget</link></member>
-      <member><link linkend="optimplotfval">optimplotfval</link></member>
-      <member><link linkend="optimplotx">optimplotx</link></member>
-      <member><link linkend="optimplotfunccount">optimplotfunccount</link></member>
-</simplelist>
+      <member>
+        <link linkend="optim">optim</link>
+      </member>
+      <member>
+        <link linkend="neldermead">neldermead</link>
+      </member>
+      <member>
+        <link linkend="optimset">optimset</link>
+      </member>
+      <member>
+        <link linkend="optimget">optimget</link>
+      </member>
+      <member>
+        <link linkend="optimplotfval">optimplotfval</link>
+      </member>
+      <member>
+        <link linkend="optimplotx">optimplotx</link>
+      </member>
+      <member>
+        <link linkend="optimplotfunccount">optimplotfunccount</link>
+      </member>
+    </simplelist>
   </refsection>
 </refentry>
index 47fb186..d527d17 100644 (file)
       function, with bounds and nonlinear constraints
     </para>
 
-    <programlisting role="example"> 
+    <screen> 
 min f(x)
 l_i &lt;= x_i &lt;= h_i, i = 1,n
 g_i(x) &gt;= 0, i = 1,nbineq
- </programlisting>
+ </screen>
 
     <para>where</para>
 
@@ -260,7 +260,7 @@ g_i(x) &gt;= 0, i = 1,nbineq
 
                     <listitem>
                       <para>
-                        the maximum number of function evalutations
+                        the maximum number of function evaluations
                         (default is 100). If this criteria is triggered, the
                         status of the optimization is set to
                         "maxfuneval".
@@ -363,7 +363,8 @@ g_i(x) &gt;= 0, i = 1,nbineq
 
                     <listitem>
                       <para>
-                        the objective function, which computes the value
+                        a function or a list, the objective function.
+                        This function computes the value
                         of the cost and the non linear constraints, if
                         any.
                       </para>
@@ -377,21 +378,12 @@ g_i(x) &gt;= 0, i = 1,nbineq
                   </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>
+                                         a function or a list, a function which is called back for output.
+                                         </para>
 
                       <para>
                         See below for the details of the communication
@@ -402,17 +394,6 @@ g_i(x) &gt;= 0, i = 1,nbineq
                   </varlistentry>
 
                   <varlistentry>
-                    <term>-outputcommandarg</term>
-
-                    <listitem>
-                      <para>
-                        an additionnal argument, passed to the output
-                        command.
-                      </para>
-                    </listitem>
-                  </varlistentry>
-
-                  <varlistentry>
                     <term>-numberofvariables</term>
 
                     <listitem>
@@ -1223,27 +1204,6 @@ g_i(x) &gt;= 0, i = 1,nbineq
                     </listitem>
                   </varlistentry>
 
-                  <varlistentry>
-                    <term>-myterminate</term>
-
-                    <listitem>
-                      <para>
-                        a user-defined terminate function. See below for
-                        details (default is empty).
-                      </para>
-                    </listitem>
-                  </varlistentry>
-
-                  <varlistentry>
-                    <term>-myterminateflag</term>
-
-                    <listitem>
-                      <para>
-                        set to %t to enable the user-defined terminate
-                        function (default is %f).
-                      </para>
-                    </listitem>
-                  </varlistentry>
                 </variablelist>
               </listitem>
             </varlistentry>
@@ -1301,7 +1261,13 @@ g_i(x) &gt;= 0, i = 1,nbineq
             generates an error.
           </para>
 
-          <variablelist>
+                <para>
+                  Most fields are available only after an optimization has
+                  been performed with one call to the neldermead_search
+                  method.
+                </para>
+
+               <variablelist>
             <varlistentry>
               <term>this</term>
 
@@ -1456,11 +1422,6 @@ g_i(x) &gt;= 0, i = 1,nbineq
                   </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>
@@ -1562,19 +1523,13 @@ g_i(x) &gt;= 0, i = 1,nbineq
       function is used to compute the objective function value <literal>f</literal>.
       If the <literal>-nbineqconst</literal> option is configured to a non-zero value, the cost function
       must also compute the value of the nonlinear, positive, inequality constraints <literal>c</literal>.
-      The cost function can also take as input/output an additional
-      argument, if the <literal>-costfargument</literal> option is configured.
       Depending of these options, the cost function can have one of the following headers :
     </para>
 
-    <programlisting role="example">
-      //  Without additionnal data
+    <screen>
       [ f , index ] = costf ( x , index )
       [ f , c , index ] = costf ( x , index )
-      //  With -costfargument
-      [ f , index , data ] = costf ( x , index , data )
-      [ f , c , index , data ] = costf ( x , index , data )
-    </programlisting>
+    </screen>
 
     <para>where</para>
 
@@ -1611,14 +1566,6 @@ g_i(x) &gt;= 0, i = 1,nbineq
         </listitem>
       </varlistentry>
 
-      <varlistentry>
-        <term>data</term>
-
-        <listitem>
-          <para>an user-provided input/output argument</para>
-        </listitem>
-      </varlistentry>
-
     </variablelist>
 
     <para>
@@ -1662,35 +1609,22 @@ g_i(x) &gt;= 0, i = 1,nbineq
       In this case, the cost function is expected to have the following header
     </para>
 
-    <programlisting role="example">
-      function [ f , index ]= myfunction ( x , index )
-    </programlisting>
+    <screen>
+[ f , index ]= myfunction ( x , index )
+    </screen>
 
     <para>
-      The <literal>data</literal> argument is both input and output and the following paragraph
-      explains for what reason and how it works.
-    </para>
-    <para>
-      This feature may be used in the situation where the cost function has to update its
-      environment from call to call. Its simplest use is to count the
-      number of calls to the cost function, but this feature is already available directly.
-      Consider the more practical situation where the optimization requires the execution of
-      an underlying Newton method (a chemical solver for example).
-      This Newton method requires an initial guess x0. If the initial guess
-      for this underlying Newton method is kept constant, the Newton method may
-      have problems to converge when the current optimization point get far away from the
-      its initial point. If the <literal>-costfargument</literal> option is provided, the
-      initial guess for the Newton method can be updated so that it gets the
-      value of the previous call. This way, the Newton method will have less problems to
-      converge and the cost function evaluation may be faster.
-    </para>
-    <para>
-      We now present how the feature works.
-      Everytime the cost function is called back, the <literal>-costfargument</literal> option
-      is passed to the cost function as an input argument. If the cost function modifies its content
-      in the output argument, the content of the <literal>-costfargument</literal> option is updated accordingly.
-      Once the optimization is performed, the user may call the <literal>neldermead_cget</literal>
-      function and get back an updated <literal>-costfargument</literal> content.
+      It might happen that the function requires additionnal arguments to be evaluated.
+      In this case, we can use the following feature.
+      The argument <literal>fun</literal> can also be the list <literal>(f,a1,a2,...)</literal>.
+      In this case <literal>f</literal>, the first element in the list, must be a function and must
+      have the header:
+      <screen>
+      [ f , index ] = costf ( x , index , a1, a2, ... )
+      [ f , c , index ] = costf ( x , index , a1, a2, ...)
+      </screen>
+      where the input arguments <literal>a1, a2, ...</literal>
+      are automatically appended at the end of the calling sequence.
     </para>
 
   </refsection>
@@ -1706,16 +1640,16 @@ g_i(x) &gt;= 0, i = 1,nbineq
 
     <para>The output function must have the following header</para>
 
-    <programlisting role="example">
-      function outputcmd(state, data, myobj)
-    </programlisting>
+    <screen>
+stop = outputcmd(state, data)
+    </screen>
 
     <para>where</para>
 
     <variablelist>
+       
       <varlistentry>
         <term>state</term>
-
         <listitem>
           <para>
             a string representing the current state of the algorithm.
@@ -1726,9 +1660,8 @@ g_i(x) &gt;= 0, i = 1,nbineq
 
       <varlistentry>
         <term>data</term>
-
         <listitem>
-          <para>a tlist containing at least the following entries</para>
+          <para>a data structure containing at least the following entries</para>
 
           <variablelist>
             <varlistentry>
@@ -1787,26 +1720,35 @@ g_i(x) &gt;= 0, i = 1,nbineq
         </listitem>
       </varlistentry>
 
-      <varlistentry>
-        <term>myobj</term>
-
+       <varlistentry>
+        <term>stop</term>
         <listitem>
-          <para>a user-defined parameter.</para>
-
           <para>
-            This input parameter is defined with the -outputcommandarg
-            option.
+            a 1-by-1 matrix of booleans, set to true to stop the 
+                       algorithm, set to false to continue the optimization.
           </para>
         </listitem>
       </varlistentry>
+
     </variablelist>
 
     <para>
-      The output function may be used when debugging the specialized
-      optimization algorithm, so that a verbose logging is produced. It may also
-      be used to write one or several report files in a specialized format
-      (ASCII, LaTeX, Excel, Hdf5, etc...). The user-defined parameter may be
-      used in that case to store file names or logging options.
+      It might happen that the output function requires additionnal arguments to be evaluated.
+      In this case, we can use the following feature.
+      The argument <literal>outputcmd</literal> can also be the list <literal>(outf,a1,a2,...)</literal>.
+      In this case <literal>outf</literal>, the first element in the list, must be a function and must
+      have the header:
+      <screen>
+        stop = outf ( state, data, a1, a2, ... )
+      </screen>
+      where the input arguments <literal>a1, a2, ...</literal>
+      are automatically appended at the end of the calling sequence.
+    </para>
+
+    <para>
+       If the output function sets the <literal>stop</literal> variable to true, 
+       then the optimization alorithm stops and the status of the optimization is 
+       set to <literal>"userstop"</literal>.
     </para>
 
   </refsection>
@@ -1865,9 +1807,9 @@ g_i(x) &gt;= 0, i = 1,nbineq
           <literal>-maxiter</literal> option : if the following condition
         </para>
 
-        <programlisting role="example">
+        <screen>
           iterations &gt;= maxiter
-        </programlisting>
+        </screen>
 
         <para>
           is true, then the status is set to "maxiter" and terminate is
@@ -1881,9 +1823,9 @@ g_i(x) &gt;= 0, i = 1,nbineq
           <literal>-maxfunevals</literal> option is examined : if the following condition
         </para>
 
-        <programlisting role="example">
+        <screen>
           funevals &gt;= maxfunevals
-        </programlisting>
+        </screen>
 
         <para>
           is true, then the status is set to <literal>"maxfuneval"</literal> and <literal>terminate</literal> is
@@ -1912,9 +1854,9 @@ g_i(x) &gt;= 0, i = 1,nbineq
             <listitem>
               <para>if the following condition</para>
 
-              <programlisting role="example">
+              <screen>
                 abs(currentfopt) &lt; tolfunrelative * abs(previousfopt) + tolfunabsolute
-              </programlisting>
+              </screen>
 
               <para>
                 is true, then the status is set to "tolf" and terminate is
@@ -1962,9 +1904,9 @@ g_i(x) &gt;= 0, i = 1,nbineq
             <listitem>
               <para>if the following condition</para>
 
-              <programlisting role="example"> 
+              <screen> 
 norm(xopt - previousxopt) &lt; tolxrelative * norm(xopt) + tolxabsolute
- </programlisting>
+ </screen>
 
 
               <para>
@@ -2016,9 +1958,9 @@ norm(xopt - previousxopt) &lt; tolxrelative * norm(xopt) + tolxabsolute
             <listitem>
               <para>if the following condition</para>
 
-              <programlisting role="example">
+              <screen>
                 ssize &lt; tolsimplexizerelative * simplexsize0 + tolsimplexizeabsolute
-              </programlisting>
+              </screen>
 
               <para>
                 is true where <literal>simplexsize0</literal> is the size of the simplex at
@@ -2061,13 +2003,13 @@ norm(xopt - previousxopt) &lt; tolxrelative * norm(xopt) + tolxabsolute
             <listitem>
               <para>if both the following conditions</para>
 
-              <programlisting role="example">
+              <screen>
                 ssize &lt; tolsimplexizeabsolute
-              </programlisting>
+              </screen>
 
-              <programlisting role="example">
+              <screen>
                 shiftfv &lt; toldeltafv
-              </programlisting>
+              </screen>
 
               <para>
                 is true where <literal>ssize</literal> is the current simplex size and
@@ -2102,9 +2044,9 @@ norm(xopt - previousxopt) &lt; tolxrelative * norm(xopt) + tolxabsolute
             <listitem>
               <para>if the following condition</para>
 
-              <programlisting role="example">
+              <screen>
                 newfvmean &lt;= oldfvmean - alpha * sg' * sg
-              </programlisting>
+              </screen>
 
               <para>
                 is true where <literal>newfvmean</literal> (resp. <literal>oldfvmean</literal>) is the function
@@ -2140,13 +2082,13 @@ norm(xopt - previousxopt) &lt; tolxrelative * norm(xopt) + tolxabsolute
             <listitem>
               <para>if both the following conditions</para>
 
-              <programlisting role="example">
+              <screen>
                 shiftfv &lt; boxtolf
-              </programlisting>
+              </screen>
 
-              <programlisting role="example">
+              <screen>
                 boxkount == boxnbmatch
-              </programlisting>
+              </screen>
 
               <para>
                 is true where <literal>shiftfv </literal>is the difference of function value
@@ -2188,9 +2130,9 @@ norm(xopt - previousxopt) &lt; tolxrelative * norm(xopt) + tolxabsolute
             <listitem>
               <para>if the following condition</para>
 
-              <programlisting role="example">
+              <screen>
                 var &lt; tolrelativevariance * variancesimplex0 + tolabsolutevariance
-              </programlisting>
+              </screen>
 
               <para>
                 is true where <literal>var </literal>is the variance of the function values
@@ -2209,38 +2151,6 @@ norm(xopt - previousxopt) &lt; tolxrelative * norm(xopt) + tolxabsolute
         </variablelist>
       </listitem>
 
-      <listitem>
-        <para>
-          The user-defined termination condition
-          is examined depending on the value of the
-          <literal>-myterminateflag</literal> option.
-        </para>
-
-        <variablelist>
-          <varlistentry>
-            <term>%f</term>
-
-            <listitem>
-              <para>then the criteria is just ignored.</para>
-            </listitem>
-          </varlistentry>
-
-          <varlistentry>
-            <term>%t</term>
-
-            <listitem>
-              <para>
-                if the <literal>term</literal> output argument
-                boolean returned by the termination function is true,
-                then the status is set to the user-defined status and
-                <literal>terminate</literal> is set to %t.
-              </para>
-            </listitem>
-          </varlistentry>
-        </variablelist>
-      </listitem>
-
-
     </itemizedlist>
   </refsection>
 
@@ -2278,9 +2188,9 @@ norm(xopt - previousxopt) &lt; tolxrelative * norm(xopt) + tolxabsolute
             normalized alpha, computed from the following formula
           </para>
 
-          <programlisting role="example">
+          <screen>
             alpha = alpha0 * sigma0 / nsg
-          </programlisting>
+          </screen>
 
           <para>
             where sigma0 is the size of the initial simplex and nsg is the
@@ -2488,14 +2398,11 @@ norm(xopt - previousxopt) &lt; tolxrelative * norm(xopt) + tolxabsolute
       The value of the <literal>-mymethod</literal> option is expected to be
       a Scilab function with the following header
     </para>
-    <programlisting role="example">
-      <![CDATA[ 
-function this = myalgorithm ( this )
-endfunction
- ]]>
-    </programlisting>
+    <screen>
+this = myalgorithm ( this )
+    </screen>
     <para>
-      where <literal>-this</literal> is the current object.
+      where <literal>this</literal> is the current object.
     </para>
     <para>
       In order to use the user-defined algorithm, the <literal>-method</literal> option must
@@ -2513,47 +2420,6 @@ endfunction
   </refsection>
 
   <refsection>
-    <title>User-defined termination</title>
-    <para>
-      Many termination criteria are found in the bibliography.
-      Users which aim at reproducing the results exhibited in a particular
-      paper may find that that none of the provided termination criteria match the
-      one which is used in the paper. It may also happen that the provided termination
-      criteria are not suitable for the specific test case. In those situation the
-      <literal>-myterminate</literal> option allows to configure a user-defined
-      termination function.
-    </para>
-    <para>
-      The value of the <literal>-myterminate</literal> option is expected to be
-      a Scilab function with the following header
-    </para>
-    <programlisting role="example">
-      <![CDATA[ 
-function [ this , terminate , status ] = mystoppingrule ( this , simplex )
-endfunction
- ]]>
-    </programlisting>
-    <para>
-      where <literal>-this</literal> is the current object and <literal>-simplex</literal>
-      is the current simplex. The <literal>terminate</literal> output argument is
-      a boolean which is false if the algorithm must continue and true if the algorithm
-      must stop. The <literal>status</literal> output argument is
-      a string which is associated with the current termination criteria.
-    </para>
-    <para>
-      In order to enable the use of the user-defined termination function, the value of the
-      <literal>-myterminateflag</literal> must be set to true.
-      At each iteration, if the -myterminateflag option has been set to true,
-      the user-defined termination is called. If the <literal>terminate</literal>
-      output argument is true, then the algorithm is stopped.
-      In that case, the value of the <literal>-status</literal> option of the
-      <literal>neldermead_get</literal> is the value of the <literal>status</literal>
-      output argument of the user-defined termination function.
-    </para>
-
-  </refsection>
-
-  <refsection>
     <title>Example #1: basic use</title>
 
     <para>
@@ -2728,8 +2594,9 @@ endfunction
 //    * iteration : the number of iterations performed
 //    * funccount : the number of function evaluations
 //    * step : the type of step in the previous iteration
+//  stop : set to true to stop the optimization
 //
-function myoutputcmd ( state , data )
+function stop = myoutputcmd ( state , data )
   iter = data.iteration
   if ( state == "init" ) then
     mprintf ( "=================================\n");
@@ -2747,6 +2614,7 @@ function myoutputcmd ( state , data )
   ssize = optimsimplex_size ( simplex )
   mprintf ( "Iter. #%3d, Feval #%3d, Fval = %.1e, x = %s, S = %.1e\n", ..
     iter, fc, fval, strcat(string(x)," "), ssize);
+  stop = %f
 endfunction
 
 
@@ -2771,8 +2639,7 @@ nm = neldermead_destroy(nm);
 
     <para>The previous script produces the following output.</para>
 
-    <programlisting role="example">
-      <![CDATA[ 
+    <screen>
 =================================
 Initialization
 Iter. #  0, Feval #  5, Fval = 2.4e+001, x = -1.2 1, S = 1.0e+000
@@ -2788,8 +2655,7 @@ Iter. #157, Feval #301, Fval = 6.0e-027, x = 1 1, S = 2.8e-013
 =================================
 End of Optimization
 Iter. #157, Feval #301, Fval = 6.0e-027, x = 1 1, S = 2.8e-013
- ]]>
-</programlisting>
+</screen>
 </refsection>
 
   <refsection>
@@ -2951,7 +2817,192 @@ nm = neldermead_destroy(nm);
        </para>
 </refsection>
 
+  <refsection>
+    <title>Example #6: Passing extra parameters</title>
+
+    <para>
+      In the following example, we solve a simple quadratic test case. 
+         Notice that the objective function has two extra parameters 
+         <literal>a</literal> and <literal>b</literal>. 
+         This is why the "-function" option is set as a list,
+         where the first element is the function and the 
+         remaining elements are the extra parameters.
+    </para>
+
+    <programlisting role="example">
+      <![CDATA[ 
+function [ f , index ] = quadratic_ab ( x , index , a , b )
+  f = a * x(1)^2 + b * x(2)^2;
+endfunction
+x0 = [1.0 1.0].';
+nm = neldermead_new ();
+nm = neldermead_configure(nm,"-numberofvariables",2);
+a = 1;
+b = 2;
+nm = neldermead_configure(nm,"-function",list(quadratic_ab,a,b));
+nm = neldermead_configure(nm,"-x0",x0);
+nm = neldermead_search(nm);
+xopt = neldermead_get(nm,"-xopt")
+nm = neldermead_destroy(nm);
+ ]]>
+    </programlisting>
+  </refsection>
+
+  <refsection>
+    <title>Changes in Scilab 5.4.1</title>
+
+    <para>
+      Many changes have been done in Scilab 5.4.1, which simplify the use of the 
+      neldermead component.
+    </para>
+
+    <para>
+  Tagged -costfargument option of optimbase as obsolete: will be 
+  maintained for backward compatibility until 5.4.1.
+  The -fun option can now be a list, where the element #1 is a 
+  function, and the elements #2 to the end are automatically appended to 
+  the calling sequence.
+  To update your code, replace:
+    </para>
+
+    <screen>
+nm = neldermead_configure(nm,"-function",myfun);
+nm = neldermead_configure(nm,"-costfargument",mystuff);
+    </screen>
+
+    <para>
+with
+    </para>
+
+    <screen>
+nm = neldermead_configure(nm,"-function",list(myfun,mystuff));
+    </screen>
+
+    <para>
+  Tagged -outputcommandarg option of optimbase as obsolete: will be 
+  maintained for backward compatibility until 5.4.1.
+  The -outputcommand option can now be a list, where the element #1 is 
+  a function, and the elements #2 to the end are automatically appended 
+  to the calling sequence.
+  To update your code, replace:
+    </para>
+  
+    <screen>
+nm = neldermead_configure(nm,"-outputcommand",myoutputfun);
+nm = neldermead_configure(nm,"-outputcommandarg",mystuff);
+    </screen>
 
+    <para>
+  with:
+    </para>
+
+    <screen>
+nm = neldermead_configure(nm,"-outputcommand",list(myoutputfun,mystuff));
+    </screen>
+
+    <para>
+  Tagged "outputfun(x,optimValues,state)" calling sequence of fminsearch 
+  as obsolete: will be maintained for backward compatibility until 
+  5.4.1.
+  The new calling sequence is "stop=outputfun(x,optimValues,state)"
+  To update your code, replace:
+    </para>
+
+    <screen>
+function outfun ( x , optimValues , state )
+    [...]
+endfunction
+    </screen>
+
+    <para>
+  with:
+    </para>
+
+    <screen>
+function stop = outfun ( x , optimValues , state )
+    [...]
+    stop = %f
+endfunction
+    </screen>
+
+    <para>
+  Tagged "myoutputfun(state,data)" calling sequence of neldermead 
+  as obsolete: will be maintained for backward compatibility until 
+  5.4.1.
+  The new calling sequence is "stop=myoutputfun(state,data)"
+  To update your code, replace:
+    </para>
+
+    <screen>
+function myoutputfun ( state , data )
+  [...]
+endfunction
+    </screen>
+
+    <para>
+  with:
+    </para>
+
+    <screen>
+function stop = myoutputfun ( state , data )
+  [...]
+  stop = %f
+endfunction
+    </screen>
+  
+    <para>
+  Tagged "-myterminateflag" and "-myterminate" options as obsolete: 
+  will be maintained for backward compatibility until 5.4.1.
+  To update your code, replace:
+    </para>
+
+    <screen>
+function [ this , terminate , status ] = myoldterminate ( this , simplex )
+  ssize = optimsimplex_size ( simplex , "sigmaplus" );
+  if ( ssize &lt; 1.e-2 ) then
+    terminate = %t;
+    status = "mysize";
+  else
+    terminate = %f
+  end
+endfunction
+    </screen>
+
+    <para>
+with :
+    </para>
+
+    <screen>
+function stop = myoutputcmd ( state , data )
+  simplex = data.simplex
+  ssize = optimsimplex_size ( simplex , "sigmaplus" );
+  if ( ssize &lt; 1.e-2 ) then
+    stop = %t;
+  else
+    stop = %f
+  end
+endfunction
+    </screen>
+
+    <para>
+  and replace the configuration:
+    </para>
+
+    <screen>
+nm = neldermead_configure(nm,"-myterminateflag",%t);
+nm = neldermead_configure(nm,"-myterminate",myoldterminate);
+    </screen>
+
+    <para>
+  with:
+    </para>
+
+    <screen>
+nm = neldermead_configure(nm,"-outputcommand",myoutputcmd);
+    </screen>
+
+  </refsection>
+  
   <refsection>
     <title>Bibliography</title>
 
index d923a0b..6f90314 100644 (file)
     retrieved with quiery features.</para>
 
     <programlisting role="example"><![CDATA[ 
-function y = rosenbrock (x)
+function [f, index]=rosenbrock(x, index)
   y = 100*(x(2)-x(1)^2)^2 + (1-x(1))^2;
 endfunction
 
index d4edfba..ea33ad4 100644 (file)
 
               <listitem>
                 <para>
-                  the key to configure. The following keys are
-                  available.
+                  a 1-by-1 matrix of strings, the key to configure.
+                </para>
+                <para>
+                  The following keys are available and delegated to the <literal>neldermead</literal> component:
+                  -verbose, -verbosetermination, -x0, -maxfunevals, -maxiter, -tolfunabsolute,
+                  -tolfunrelative, -tolfunmethod, -tolxabsolute, -tolxrelative, -tolxmethod,
+                  -function, -outputcommand, -numberofvariables, -storehistory,
+                  -boundsmin, -boundsmax, -nbineqconst, -method, -simplex0method,
+                  -coords0, -simplex0length, -simplex0deltausual, -simplex0deltazero,
+                  -rho, -chi, -gamma, -sigma, -tolfstdeviationmethod,
+                  -tolfstdeviation, -tolsimplexizemethod, -tolsimplexizeabsolute,
+                  -tolsimplexizerelative, -tolssizedeltafvmethod, -toldeltafv,
+                  -kelleystagnationflag, -kelleynormalizationflag,
+                  -kelleystagnationalpha0, -restartflag, -restartdetection,
+                  -restartmax, -restarteps, -restartstep, -restartsimplexmethod,
+                  -boxnbpoints, -nbineqloops, -ineqscaling.
+                  These options are documented in the help page of the <literal>neldermead_configure</literal>
+                  function.
+                </para>
+                <para>
+                  The following specific 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 a 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 a 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>
-
+                <variablelist>
                   <varlistentry>
                     <term>-simplexfn</term>
 
                     <listitem>
                       <para>
                         the name of the file containing the history of the
-                        simplex. Default value is the empty string.
+                        simplex (default simplexfn="").
                       </para>
                     </listitem>
                   </varlistentry>
                     <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.
+                        function value, averaged on the vertices of the simplex (default fbarfn="").
                       </para>
                     </listitem>
                   </varlistentry>
                     <listitem>
                       <para>
                         the name of the file containing the history of the
-                        minimum function value in the simplex. Default value is
-                        the empty string.
+                        minimum function value in the simplex (default foptfn="").
                       </para>
                     </listitem>
                   </varlistentry>
                     <listitem>
                       <para>
                         the name of the file containing the history of the
-                        size of the simplex. Default value is the empty
-                        string.
+                        size of the simplex (default sigmafn="").
                       </para>
                     </listitem>
                   </varlistentry>
 
               <listitem>
                 <para>
-                  the name of the key to quiery. The list of available
-                  keys is the same as for the nmplot_configure function.
+                  a 1-by-1 matrix of strings, the name of the key to quiery. The list of available
+                  keys is the same as for the <literal>nmplot_configure</literal> function.
                 </para>
               </listitem>
             </varlistentry>
             generates an error.
           </para>
 
+          <para>
+            Most fields are available only after an optimization has
+            been performed with one call to the nmplot_search
+            method.
+          </para>
+
           <variablelist>
             <varlistentry>
               <term>this</term>
               <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>a 1-by-1 matrix of strings, the key to get.</para>
 
                 <para>
-                  Most fields are available only after an optimization has
-                  been performed with one call to the neldermead_search
-                  method.
+                  The following keys are available and delegated to the <literal>neldermead</literal> component:
+                  -funevals, -iterations, -xopt, -fopt, -historyxopt, -historyfopt,
+                  -fx0, -status, -historysimplex, -simplexopt, -restartnb.
+                  These options are documented in the help page of the <literal>neldermead_configure</literal> function.
                 </para>
+
+
               </listitem>
             </varlistentry>
           </variablelist>
 
               <listitem>
                 <para>
-                  the color of the foreground for the simplices. Default
-                  value is 5.
+                  the color of the foreground for the simplices (default colorforeground=5).
                 </para>
               </listitem>
             </varlistentry>
 
               <listitem>
                 <para>
-                  the foreground mark for the simplices. Default value is
-                  3.
+                  the foreground mark for the simplices (default markforeground = 3).
                 </para>
               </listitem>
             </varlistentry>
 
               <listitem>
                 <para>
-                  the mark style for the simplices. Default value is
-                  9.
+                  the mark style for the simplices (default markstyle = 9).
                 </para>
               </listitem>
             </varlistentry>
 
     <para>
       In the following example, we use the fixed shape Spendley et al.
-      simplex algorithm and find the minimum of a quadratic function. We begin
-      by defining a quadratic function associated with 2 input variables. We
-      then define an nmplot object and configure the object so that the "fixed"
+      simplex algorithm and find the minimum of a quadratic function.
+      We begin by defining a quadratic function associated with 2 input variables.
+      We then define an nmplot object and configure the object so that the "fixed"
       shape simplex algorithm is used with the regular initial simplex
-      associated with the "spendley" key. Four files are configured, which will
-      contain the history of the simplex, the history of fbar, fopt and sigma
-      through the iterations. The search is performed by the nmplot_search
-      function, which writes the 4 data files during the iterations. The
-      nmplot_contour function is called in order to compute the arrays xdata,
-      ydata and zdata which are required as input to the contour function. The
-      nmplot_simplexhistory then uses the history of the simplex, as stored in
-      the rosenbrock.fixed.history.simplex.txt data file, and plot the various
-      simplices on the contour plot. The nmplot_historyplot is used with the
-      files rosenbrock.fixed.history.fbar.txt, rosenbrock.fixed.history.fopt.txt
-      and rosenbrock.fixed.history.sigma.txt, which produces 3 plots of the
+      associated with the "spendley" key.
+      Four files are configured, which will contain the history of the simplex,
+      the history of fbar, fopt and sigma through the iterations.
+      The search is performed by the <literal>nmplot_search</literal>
+      function, which writes the 4 data files during the iterations.
+      The <literal>contour</literal> function is called in order to plot the level sets of
+      the objective function.
+      The <literal>nmplot_simplexhistory</literal> then uses the history of the simplex, as stored in
+      the "history.simplex.txt" data file, and plot the various
+      simplices on the contour plot.
+      The <literal>nmplot_historyplot</literal> function is used with the
+      files "history.fbar.txt", "history.fopt.txt"
+      and "history.sigma.txt", which produces 3 plots of the
       history of the optimization algorithm through the iterations.
     </para>
 
     <programlisting role="example">
-      mprintf("Defining quadratic function...\n");
-      function y = quadratic (x)
-      y = x(1)^2 + x(2)^2 - x(1) * x(2);
+      function [y, index] = quadratic ( x, index )
+          y = x(1)^2 + x(2)^2 - x(1) * x(2);
+      endfunction
+      function y = quadraticC ( x1 , x2 )
+          [y, index] = quadratic ( [x1,x2], 2 )
       endfunction
 
-      mprintf("Creating nmplot object...\n");
       nm = nmplot_new ();
       nm = nmplot_configure(nm,"-numberofvariables",2);
       nm = nmplot_configure(nm,"-function",quadratic);
       //
       // 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");
+      nm = nmplot_configure(nm,"-simplexfn","history.simplex.txt");
+      nm = nmplot_configure(nm,"-fbarfn","history.fbar.txt");
+      nm = nmplot_configure(nm,"-foptfn","history.fopt.txt");
+      nm = nmplot_configure(nm,"-sigmafn","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] )
+      xmin = -2.0;
+      xmax = 4.0;
+      ymin = -2.0;
+      ymax = 4.0;
+      nx = 100;
+      ny = 100;
+      xdata=linspace(xmin,xmax);
+      ydata=linspace(ymin,ymax);
+      scf();
+      subplot(2,2,1);
+      contour ( xdata , ydata , quadraticC , [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");
+      subplot(2,2,2);
+      mytitle = "Function Value Average";
+      myxlabel = "Iterations";
+      nmplot_historyplot ( nm , "history.fbar.txt" , mytitle , myxlabel );
+      subplot(2,2,3);
+      mytitle = "Minimum Function Value";
+      myxlabel = "Iterations";
+      nmplot_historyplot ( nm , "history.fopt.txt" , mytitle , myxlabel );
+      subplot(2,2,4);
+      mytitle = "Maximum Oriented length";
+      myxlabel = "Iterations";
+      nmplot_historyplot ( nm , "history.sigma.txt" , mytitle, myxlabel );
+      deletefile("history.simplex.txt");
+      deletefile("history.fbar.txt");
+      deletefile("history.fopt.txt");
+      deletefile("history.sigma.txt");
       nm = nmplot_destroy(nm);
 
 
   </refsection>
 
   <refsection>
-    <title>TODO</title>
-
-    <itemizedlist>
-      <listitem>
-        <para>add an example</para>
-      </listitem>
-    </itemizedlist>
-  </refsection>
-
-  <refsection>
     <title>Authors</title>
 
     <para>Michael Baudin - INRIA - 2008-2009</para>
 
-    <para>Michael Baudin - Digiteo - 2009</para>
+    <para>Michael Baudin - Digiteo - 2009 - 2011</para>
   </refsection>
 
   <refsection role="see also">
index 119b996..b37578d 100644 (file)
       this = optimbase_set ( this , key , value )
       [ this , isok ] = optimbase_checkbounds ( this )
       [ opt , isok ] = optimbase_checkx0 ( this )
-      [ this , f , index [ , data ] ] = optimbase_function ( this , x , index [ , data ] )
-      [ this , f , c , index [ , data ] ] = optimbase_function ( this , x , index [ , data ] )
-      [ this , f , g , index [ , data ] ] = optimbase_function ( this , x , index [ , data ] )
-      [ this , f , g , c , gc , index [ , data ] ] = optimbase_function ( this , x , index [ , data ] )
+      [ this , f , index ] = optimbase_function ( this , x , index [ , a1, a2, ... ] )
+      [ this , f , c , index ] = optimbase_function ( this , x , index [ , a1, a2, ... ] )
+      [ this , f , g , index ] = optimbase_function ( this , x , index [ , a1, a2, ... ] )
+      [ this , f , g , c , gc , index ] = optimbase_function ( this , x , index [ , a1, a2, ... ] )
       [ this , hasbounds ] = optimbase_hasbounds ( this )
       [ this , hascons ] = optimbase_hasconstraints ( this )
       [ this , hasnlcons ] = optimbase_hasnlcons ( this )
@@ -52,7 +52,7 @@
       this = optimbase_incriter ( this )
       [ this , isfeasible ] = optimbase_isfeasible ( this , x )
       this = optimbase_log (this,msg)
-      optimbase_outputcmd ( this , state , data )
+      stop = optimbase_outputcmd ( this , state , data )
       data = optimbase_outstruct ( this )
       [ this , p ] = optimbase_proj2bnds ( this ,  x )
       this = optimbase_stoplog ( this , msg )
 
                     <listitem>
                       <para>
-                        the objective function, which computes the value
+                        a function or a list, the objective function.
+                        This function computes the value
                         of the cost and the non linear constraints, if
                         any.
                       </para>
                   </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>
+                                         a function or a list, a function which is called back for output.
+                                         </para>
 
                       <para>
                         See below for the details of the communication
                   </varlistentry>
 
                   <varlistentry>
-                    <term>-outputcommandarg</term>
-
-                    <listitem>
-                      <para>
-                        an additionnal argument, passed to the output
-                        command.
-                      </para>
-                    </listitem>
-                  </varlistentry>
-
-                  <varlistentry>
                     <term>-numberofvariables</term>
 
                     <listitem>
       </varlistentry>
 
       <varlistentry>
-        <term xml:id="optimbase_function">[ this , f , index [ , data ] ] = optimbase_function ( this , x , index [ , data ] )</term>
-
-        <term>[ this , f , c , index [ , data ] ] = optimbase_function ( this , x , index [ , data ] )</term>
-
-        <term>[ this , f , g , index [ , data ] ] = optimbase_function ( this , x , index [ , data ] )</term>
+        <term xml:id="optimbase_function">
+          optimbase_function
+        </term>
 
-        <term>[ this , f , g , c , gc , index [ , data ] ] = optimbase_function ( this , x , index [ , data ] )</term>
 
         <listitem>
-          <para>Call the cost function and return the required results.</para>
+          <para>
+            Call the cost function and return the required results.
+          </para>
 
           <para>
             If a cost function additionnal argument is defined in current
-            object, pass it to the function as the last argument. See below for
-            details.
+            object, pass it to the function as the last argument.
+          </para>
+
+          <para>
+            The following calling sequences are available (see below for more details).
+          </para>
+          <programlisting role="example">
+            [ this , f , index ] = optimbase_function ( this , x , index )
+            [ this , f , c , index ] = optimbase_function ( this , x , index )
+            [ this , f , g , index ] = optimbase_function ( this , x , index )
+            [ this , f , g , c , gc , index ] = optimbase_function ( this , x , index )
+          </programlisting>
+
+          <para>
+
           </para>
 
           <variablelist>
               </listitem>
             </varlistentry>
 
-            <varlistentry>
-              <term>data</term>
-              <listitem>
-                <para>an optionnal user-provided argument</para>
-              </listitem>
-            </varlistentry>
-
           </variablelist>
         </listitem>
       </varlistentry>
       </varlistentry>
 
       <varlistentry>
-        <term xml:id="optimbase_outputcmd">optimbase_outputcmd ( this , state , data )</term>
+        <term xml:id="optimbase_outputcmd">stop = optimbase_outputcmd ( this , state , data )</term>
 
         <listitem>
-          <para>Calls back user's output command.</para>
+          <para>
+                 Calls back user's output command.
+                 See below for details, in the "The output function" section.
+                 </para>
 
           <variablelist>
+                 
             <varlistentry>
               <term>this</term>
-
               <listitem>
                 <para>The current object.</para>
               </listitem>
             </varlistentry>
+                       
+            <varlistentry>
+              <term>state</term>
+              <listitem>
+                <para>a 1-by-1 matrix of strings, the current state of the algorithm</para>
+              </listitem>
+            </varlistentry>
+                       
+            <varlistentry>
+              <term>data</term>
+              <listitem>
+                <para>
+                               a data structure with type T_OPTDATA. 
+                               This is typically the output of the <literal>optimbase_outstruct</literal> 
+                               function, with potentially additionnal fields.
+                               </para>
+              </listitem>
+            </varlistentry>
+                       
           </variablelist>
         </listitem>
       </varlistentry>
 
         <listitem>
           <para>
-            Returns a tlist with basic optimization fields. This tlist is
-            suitable for use as an input argument of the output function. This
-            tlist may be enriched by children (specialize) optimization
+            Returns a data structure with type T_OPTDATA. 
+                       This data structure contains basic optimization fields. 
+                       The output argument <literal>data</literal> is designed to be the input of the 
+                       <literal>optimbase_outputcmd</literal> function which, in turn, calls 
+                       back the output function.
+                       This data structure may be enriched by children (specialized) optimization
             methods.
           </para>
 
         <para>which corresponds to the cost functions</para>
         <programlisting role="example">
           <![CDATA[ 
-function [ f , index ] = costf ( x , index ) 
-function [ f , index , data ] = costf ( x , index , data ) // if there is a -costfargument
+[ f , index ] = costf ( x , index ) 
  ]]>
         </programlisting>
       </listitem>
@@ -1559,8 +1569,7 @@ function [ f , index , data ] = costf ( x , index , data ) // if there is a -cos
         <para>which corresponds to the cost functions</para>
         <programlisting role="example">
           <![CDATA[ 
-function [ f , c , index ] = costf ( x , index ) 
-function [ f , c , index , data ] = costf ( x , index , data ) // if there is a -costfargument
+[ f , c , index ] = costf ( x , index ) 
  ]]>
         </programlisting>
       </listitem>
@@ -1578,8 +1587,7 @@ function [ f , c , index , data ] = costf ( x , index , data ) // if there is a
         <para>which corresponds to the cost functions</para>
         <programlisting role="example">
           <![CDATA[ 
-function [ f , g , index ] = costf ( x , index ) 
-function [ f , g , index , data ] = costf ( x , index , data ) // if there is a -costfargument
+[ f , g , index ] = costf ( x , index ) 
  ]]>
         </programlisting>
       </listitem>
@@ -1597,8 +1605,7 @@ function [ f , g , index , data ] = costf ( x , index , data ) // if there is a
         <para>which corresponds to the cost functions</para>
         <programlisting role="example">
           <![CDATA[ 
-function [ f , g , c , gc , index ] = costf ( x , index ) 
-function [ f , g , c , gc , index , data ] = costf ( x , index , data ) // if there is a -costfargument
+[ f , g , c , gc , index ] = costf ( x , index ) 
  ]]>
         </programlisting>
       </listitem>
@@ -1684,6 +1691,23 @@ function [ f , g , c , gc , index , data ] = costf ( x , index , data ) // if th
         <para>index &lt; 0: one function could not be avaluated.</para>
       </listitem>
     </itemizedlist>
+
+    <para>
+      It might happen that the function requires additionnal arguments to be evaluated.
+      In this case, we can use the following feature.
+      The argument <literal>fun</literal> can also be the list <literal>(f,a1,a2,...)</literal>.
+      In this case <literal>f</literal>, the first element in the list, must be a function and must
+      have the header:
+      <programlisting>
+        [ f , index ] = f ( x , index , a1 , a2 , ... )
+        [ f , c , index ] = f ( x , index , a1 , a2 , ... )
+        [ f , g , index ] = f ( x , index , a1 , a2 , ... )
+        [ f , g , c , gc , index ] = f ( x , index , a1 , a2 , ... )
+      </programlisting>
+      where the input arguments <literal>a1, a2, ...</literal>
+      are automatically appended at the end of the calling sequence.
+    </para>
+
   </refsection>
 
   <refsection>
@@ -1698,18 +1722,19 @@ function [ f , g , c , gc , index , data ] = costf ( x , index , data ) // if th
     <para>The output function must have the following header</para>
 
     <programlisting role="example">
-      function outputcmd(state, data, myobj)
+      stop = outputcmd(state, data)
     </programlisting>
 
     <para>where</para>
 
     <variablelist>
+       
       <varlistentry>
         <term>state</term>
 
         <listitem>
           <para>
-            a string representing the current state of the algorithm.
+            a 1-by-1 matrix of strings, the current state of the algorithm.
             Available values are "init", "iter", "done".
           </para>
         </listitem>
@@ -1719,7 +1744,10 @@ function [ f , g , c , gc , index , data ] = costf ( x , index , data ) // if th
         <term>data</term>
 
         <listitem>
-          <para>a tlist containing at least the following entries</para>
+          <para>
+                 a data structure with type <literal>T_OPTDATA</literal> containing at 
+                 least the following fields
+                 </para>
 
           <variablelist>
             <varlistentry>
@@ -1757,35 +1785,33 @@ function [ f , g , c , gc , index , data ] = costf ( x , index , data ) // if th
         </listitem>
       </varlistentry>
 
-      <varlistentry>
-        <term>myobj</term>
+        <varlistentry>
+        <term>stop</term>
 
         <listitem>
-          <para>a user-defined parameter.</para>
-
           <para>
-            This input parameter is defined with the -outputcommandarg
-            option.
+            a 1-by-1 matrix of booleans, stop is true if the optimization algorithm 
+                       must be stopped, stop is false if the optimization algorithm must continue.
           </para>
         </listitem>
       </varlistentry>
+
+
     </variablelist>
 
     <para>
-      The output function may be used when debugging the specialized
-      optimization algorithm, so that a verbose logging is produced. It may also
-      be used to write one or several report files in a specialized format
-      (ASCII, LaTeX, Excel, Hdf5, etc...). The user-defined parameter may be
-      used in that case to store file names or logging options.
+      It might happen that the output function requires additionnal arguments to be evaluated.
+      In this case, we can use the following feature.
+      The argument <literal>outputcmd</literal> can also be the list <literal>(outf,a1,a2,...)</literal>.
+      In this case <literal>outf</literal>, the first element in the list, must be a function and must
+      have the header:
+      <programlisting>
+        stop = outf ( state, data, a1, a2, ... )
+      </programlisting>
+      where the input arguments <literal>a1, a2, ...</literal>
+      are automatically appended at the end of the calling sequence.
     </para>
 
-    <para>
-      The data tlist argument may contain more fields than the current
-      presented ones. These additionnal fields may contain values which are
-      specific to the specialized algorithm, such as the simplex in a
-      Nelder-Mead method, the gradient of the cost function in a BFGS method,
-      etc...
-    </para>
   </refsection>
 
   <refsection>
@@ -1965,7 +1991,35 @@ function [ f , g , c , gc , index , data ] = costf ( x , index , data ) // if th
       nbvar = optimbase_cget(opt,"-numberofvariables");
       opt = optimbase_configure(opt,"-function",rosenbrock);
       [ opt , f , index ] = optimbase_function ( opt , [0.0 0.0] , 1 );
-      opt
+         expectedf = 1
+         disp(f)
+      opt = optimbase_destroy(opt);
+    </programlisting>
+  </refsection>
+
+    <refsection>
+    <title>Example : Passing extra parameters</title>
+    <para>
+      In the following example, we consider a function which has two additionnal 
+         parameters <literal>a</literal> and <literal>b</literal>.
+         In this case, we can configure the "-function" option as a list, 
+         where the first element is the function and the two extra arguments are 
+         located at the end of the list.
+    </para>
+    <programlisting role="example">
+      function [ f , index ] = rosenbrock2 ( x , index , a , b )
+      f = a*(x(2)-x(1)^2)^2 + (b-x(1))^2;
+      endfunction
+
+      opt = optimbase_new();
+      opt = optimbase_configure(opt,"-numberofvariables",2);
+      nbvar = optimbase_cget(opt,"-numberofvariables");
+         a = 100;
+         b = 1;
+      opt = optimbase_configure(opt,"-function",list(rosenbrock2,a,b));
+      [ opt , f , index ] = optimbase_function ( opt , [0.0 0.0] , 1 );
+         expectedf = 1
+         disp(f)
       opt = optimbase_destroy(opt);
     </programlisting>
   </refsection>
@@ -1973,7 +2027,8 @@ function [ f , g , c , gc , index , data ] = costf ( x , index , data ) // if th
   <refsection>
     <title>Authors</title>
 
-    <para>Michael Baudin, 2008-2010</para>
+    <para>Copyright (C) 2008-2009 - INRIA - Michael Baudin</para>
+    <para>Copyright (C) 2009-2011 - DIGITEO - Michael Baudin</para>
   </refsection>
 
   <refsection>
index 99c1475..ed51ff4 100644 (file)
@@ -100,7 +100,7 @@ function str = %TNELDER_string ( this )
     k = k + 1
     str(k) = sprintf("Kelley Stagnation : %s\n", string(this.kelleystagnationflag));
     k = k + 1
-    str(k) = sprintf("Restart Epsilon : %e\n", this.restarteps);
+    str(k) = sprintf("Restart Epsilon : %s\n", string(this.restarteps));
     k = k + 1
     str(k) = sprintf("Restart Step : %s\n", _strvec(this.restartstep));
     k = k + 1
index 591e5ab..1e7594e 100644 (file)
 //  options : an optional struct, as provided by optimset
 //
 function [x,fval,exitflag,output] = fminsearch ( varargin )
-  [lhs,rhs]=argn();
-  if rhs<>2 & rhs<>3 then
-    errmsg = msprintf(gettext("%s: Wrong number of input arguments: %d or %d expected.\n"), "fminsearch", 2,3);
-    error(errmsg)
-  end
-  fun = varargin(1);
-  x0 = varargin(2);
-  // Get x0 and change it into a column vector
-  x0t = size(x0,"*");
-  x0 = matrix(x0,x0t,1);
-  defaultoptions = optimset ("fminsearch");
-  if rhs==2 then
-    // No options on the command line
-    // Set default values
-    options = defaultoptions;
-  elseif rhs==3 then
-    // One options struc on the command line : use it !
-    options = varargin(3);
-  end
-  // Compute options from the options struct
-  numberofvariables = size(x0,"*");
-  MaxFunEvals = optimget ( options , "MaxFunEvals" , defaultoptions.MaxFunEvals );
-  MaxIter = optimget ( options , "MaxIter" , defaultoptions.MaxIter );
-  TolFun = optimget ( options , "TolFun" , defaultoptions.TolFun );
-  TolX = optimget ( options , "TolX" , defaultoptions.TolX );
-  Display = optimget ( options , "Display" , defaultoptions.Display );
-  OutputFcn = optimget ( options , "OutputFcn" , defaultoptions.OutputFcn );
-  PlotFcns = optimget ( options , "PlotFcns" , defaultoptions.PlotFcns );
-  // If the MaxIter option is a string, we make the assumption that it is the default 200 value.
-  // If not, this is the actual value.
-  if ( type ( MaxIter ) == 10 ) then
-    if ( MaxIter == "200*numberofvariables" ) then
-      MaxIter = 200 * numberofvariables;
-    else
-      errmsg = msprintf(gettext("%s: Unexpected maximum number of iterations %s."), "fminsearch", MaxIter );
-      error(errmsg)
+    [lhs,rhs]=argn();
+    if rhs<>2 & rhs<>3 then
+        errmsg = msprintf(gettext("%s: Wrong number of input arguments: %d or %d expected.\n"), "fminsearch", 2,3);
+        error(errmsg)
     end
-  end
-  // If the MaxFunEvals option is a string, this is the default 200 value
-  // If not, this is the actual value.
-  if ( type ( MaxFunEvals ) == 10 ) then
-    if ( MaxFunEvals == "200*numberofvariables" ) then
-      MaxFunEvals = 200 * numberofvariables;
-    else
-      errmsg = msprintf(gettext("%s: Unexpected maximum number of function evaluations %s."), "fminsearch", MaxFunEvals );
-      error(errmsg)
+    fun = varargin(1);
+    x0 = varargin(2);
+    // Get x0 and change it into a column vector
+    x0t = size(x0,"*");
+    x0 = matrix(x0,x0t,1);
+    defaultoptions = optimset ("fminsearch");
+    if rhs==2 then
+        // No options on the command line
+        // Set default values
+        options = defaultoptions;
+    elseif rhs==3 then
+        // One options struc on the command line : use it !
+        options = varargin(3);
+    end
+    // Compute options from the options struct
+    numberofvariables = size(x0,"*");
+    MaxFunEvals = optimget ( options , "MaxFunEvals" , defaultoptions.MaxFunEvals );
+    MaxIter = optimget ( options , "MaxIter" , defaultoptions.MaxIter );
+    TolFun = optimget ( options , "TolFun" , defaultoptions.TolFun );
+    TolX = optimget ( options , "TolX" , defaultoptions.TolX );
+    Display = optimget ( options , "Display" , defaultoptions.Display );
+    OutputFcn = optimget ( options , "OutputFcn" , defaultoptions.OutputFcn );
+    PlotFcns = optimget ( options , "PlotFcns" , defaultoptions.PlotFcns );
+    // If the MaxIter option is a string, we make the assumption that it is the default 200 value.
+    // If not, this is the actual value.
+    if ( type ( MaxIter ) == 10 ) then
+        if ( MaxIter == "200*numberofvariables" ) then
+            MaxIter = 200 * numberofvariables;
+        else
+            errmsg = msprintf(gettext("%s: Unexpected maximum number of iterations %s."), "fminsearch", MaxIter );
+            error(errmsg)
+        end
+    end
+    // If the MaxFunEvals option is a string, this is the default 200 value
+    // If not, this is the actual value.
+    if ( type ( MaxFunEvals ) == 10 ) then
+        if ( MaxFunEvals == "200*numberofvariables" ) then
+            MaxFunEvals = 200 * numberofvariables;
+        else
+            errmsg = msprintf(gettext("%s: Unexpected maximum number of function evaluations %s."), "fminsearch", MaxFunEvals );
+            error(errmsg)
+        end
     end
-  end
-  if ( Display == "iter" ) then
-    mprintf ( "%10s   %10s   %10s %17s\n" , "Iteration", "Func-count" , "min f(x)" , "Procedure" );
-  end
-  // Prepare the data structure to pass to the output function
-  fmsdata = tlist(["T_FMINSEARCH" 
+    if ( Display == "iter" ) then
+        mprintf ( "%10s   %10s   %10s %17s\n" , "Iteration", "Func-count" , "min f(x)" , "Procedure" );
+    end
+    // Prepare the data structure to pass to the output function
+    fmsdata = tlist(["T_FMINSEARCH" 
     "Display" 
     "OutputFcn" 
     "PlotFcns" 
     ]);
-  fmsdata.Display = Display
-  fmsdata.OutputFcn = OutputFcn
-  fmsdata.PlotFcns = PlotFcns
-  // Prepare the data structure to pass to the cost function
-  fmsfundata = tlist(["T_FMINSEARCH" 
+    fmsdata.Display = Display
+    fmsdata.OutputFcn = OutputFcn
+    fmsdata.PlotFcns = PlotFcns
+    // Prepare the data structure to pass to the cost function
+    fmsfundata = tlist(["T_FMINSEARCH" 
     "Fun" 
     ]);
-  fmsfundata.Fun = fun
-  // Perform Optimization
-  nm = neldermead_new ();
-  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);
-  nm = neldermead_configure(nm,"-simplex0deltazero",0.0075);
-  nm = neldermead_configure(nm,"-method","variable");
-  nm = neldermead_configure(nm,"-function",fminsearch_function);
-  nm = neldermead_configure(nm,"-costfargument",fmsfundata);
-  nm = neldermead_configure(nm,"-maxiter",MaxIter);
-  nm = neldermead_configure(nm,"-maxfunevals",MaxFunEvals);
-  nm = neldermead_configure(nm,"-tolxmethod",%f);
-  nm = neldermead_configure(nm,"-tolfunmethod",%f);
-  nm = neldermead_configure(nm,"-tolssizedeltafvmethod",%t);
-  nm = neldermead_configure(nm,"-tolsimplexizemethod",%f);
-  nm = neldermead_configure(nm,"-toldeltafv",TolFun);
-  nm = neldermead_configure(nm,"-tolsimplexizeabsolute",TolX);
-  nm = neldermead_configure(nm,"-checkcostfunction",%f);
-  nm = neldermead_configure(nm,"-outputcommand",fminsearch_outputfun);
-  nm = neldermead_configure(nm,"-outputcommandarg",fmsdata);
-  //nm = neldermead_configure(nm,"-verbose",1);
-  //nm = neldermead_configure(nm,"-verbosetermination",1);
-  nm = neldermead_search(nm);
-  x = neldermead_get(nm,"-xopt").';
-  fval = neldermead_get(nm,"-fopt");
-  status = neldermead_get(nm,"-status");
-  select status
-  case "maxiter" then
-    if ( ( Display == "notify" ) | ( Display == "iter" ) | ( Display == "final" ) ) then
-      msg = "%s: Exiting: Maximum number of iterations has been exceeded\n" + ...
+    fmsfundata.Fun = fun
+    // Perform Optimization
+    nm = neldermead_new ();
+    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);
+    nm = neldermead_configure(nm,"-simplex0deltazero",0.0075);
+    nm = neldermead_configure(nm,"-method","variable");
+    nm = neldermead_configure(nm,"-function",list(fminsearch_function,fmsfundata));
+    nm = neldermead_configure(nm,"-maxiter",MaxIter);
+    nm = neldermead_configure(nm,"-maxfunevals",MaxFunEvals);
+    nm = neldermead_configure(nm,"-tolxmethod",%f);
+    nm = neldermead_configure(nm,"-tolfunmethod",%f);
+    nm = neldermead_configure(nm,"-tolssizedeltafvmethod",%t);
+    nm = neldermead_configure(nm,"-tolsimplexizemethod",%f);
+    nm = neldermead_configure(nm,"-toldeltafv",TolFun);
+    nm = neldermead_configure(nm,"-tolsimplexizeabsolute",TolX);
+    nm = neldermead_configure(nm,"-checkcostfunction",%f);
+    nm = neldermead_configure(nm,"-outputcommand",list(fminsearch_outputfun,fmsdata));
+    //nm = neldermead_configure(nm,"-verbose",1);
+    //nm = neldermead_configure(nm,"-verbosetermination",1);
+    nm = neldermead_search(nm);
+    x = neldermead_get(nm,"-xopt").';
+    fval = neldermead_get(nm,"-fopt");
+    status = neldermead_get(nm,"-status");
+    select status
+    case "maxiter" then
+        if ( ( Display == "notify" ) | ( Display == "iter" ) | ( Display == "final" ) ) then
+            msg = "%s: Exiting: Maximum number of iterations has been exceeded\n" + ...
             "         - increase MaxIter option.\n" + ...
             "         Current function value: %s\n"
-      mprintf(gettext(msg) , "fminsearch" , string(fval) )
-    end
-    exitflag = 0;
-  case "maxfuneval" then
-    if ( ( Display == "notify" ) | ( Display == "iter" ) | ( Display == "final" ) ) then
-      msg = "%s: Exiting: Maximum number of function evaluations has been exceeded\n" + ...
+            mprintf(gettext(msg) , "fminsearch" , string(fval) )
+        end
+        exitflag = 0;
+    case "maxfuneval" then
+        if ( ( Display == "notify" ) | ( Display == "iter" ) | ( Display == "final" ) ) then
+            msg = "%s: Exiting: Maximum number of function evaluations has been exceeded\n" + ...
             "          - increase MaxFunEvals option.\n" + ...
             "         Current function value: %s\n"
-      mprintf(gettext(msg) , "fminsearch" , string(fval) )
+            mprintf(gettext(msg) , "fminsearch" , string(fval) )
+        end
+        exitflag = 0;
+    case "tolsizedeltafv" then
+        exitflag = 1;
+    case "userstop" then
+        exitflag = -1;
+    else
+        errmsg = msprintf(gettext("%s: Unknown status %s"), "fminsearch", status)
+        error(errmsg)
     end
-    exitflag = 0;
-  case "tolsizedeltafv" then
-    exitflag = 1;
-  else
-    errmsg = msprintf(gettext("%s: Unknown status %s"), "fminsearch", status)
-    error(errmsg)
-  end
-  output = struct(...
-      "algorithm" ,[],...
-      "funcCount" ,[],...
-      "iterations" ,[],...
-      "message" , []);
-  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 %e\n%s %e", "Optimization terminated:",...
+    output = struct(...
+    "algorithm" ,[],...
+    "funcCount" ,[],...
+    "iterations" ,[],...
+    "message" , []);
+    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 %s\n%s %s", "Optimization terminated:",...
     " the current x satisfies the termination criteria using OPTIONS.TolX of",...
-    TolX,...
+    string(TolX),...
     " and F(X) satisfies the convergence criteria using OPTIONS.TolFun of",...
-    TolFun);
-  if ( ( Display == "final" ) | ( Display == "iter" ) ) then
-    if ( ( exitflag == 1 ) ) then
-      mprintf( "%s\n" , output.message(1) );
-      mprintf( "%s\n" , output.message(2) );
-      mprintf( "%s\n" , output.message(3) );
+    string(TolFun));
+    if ( ( Display == "final" ) | ( Display == "iter" ) ) then
+        if ( ( exitflag == 1 ) ) then
+            mprintf( "%s\n" , output.message(1) );
+            mprintf( "%s\n" , output.message(2) );
+            mprintf( "%s\n" , output.message(3) );
+        end
     end
-  end
-  nm = neldermead_destroy(nm);
+    nm = neldermead_destroy(nm);
 endfunction
 //
 // The output function called back by fminsearch
@@ -177,84 +177,99 @@ endfunction
 //    * Display : what to display
 //    * OutputFcn : the array of output functions
 //
-function fminsearch_outputfun ( state , data , fmsdata )
-  // 
-  // Compute procedure
-  //
-  select data.step
-  case "init" then
-      if ( data.iteration == 0 ) then
-        procedure = "";
-      else
-        procedure = "initial simplex";
-      end
-  case "done" then
-      procedure = ""
-  case "reflection" then
-      procedure = "reflect"
-  case "expansion" then
-      procedure = "expand"
-  case "insidecontraction" then
-      procedure = "contract inside"
-  case "outsidecontraction" then
-      procedure = "contract outside"
-  case "shrink" then
-      procedure = "shrink"
-  else
-      errmsg = msprintf(gettext("%s: Unknown step %s"), "fminsearch", data.step)
-      error(errmsg)
-  end
-  // 
-  // Display a message
-  //
-  if ( fmsdata.Display == "iter" ) then
-    if ( data.step <> "done" ) then
-      mprintf ( "%6s        %5s     %12s         %-20s\n", ...
-        string(data.iteration) , string(data.funccount) , string(data.fval) , procedure )
+function stop = fminsearch_outputfun ( state , data , fmsdata )
+    // 
+    // Compute procedure
+    //
+    select data.step
+    case "init" then
+        if ( data.iteration == 0 ) then
+            procedure = "";
+        else
+            procedure = "initial simplex";
+        end
+    case "done" then
+        procedure = ""
+    case "reflection" then
+        procedure = "reflect"
+    case "expansion" then
+        procedure = "expand"
+    case "insidecontraction" then
+        procedure = "contract inside"
+    case "outsidecontraction" then
+        procedure = "contract outside"
+    case "shrink" then
+        procedure = "shrink"
     else
-      mprintf ( "\n" )
+        errmsg = msprintf(gettext("%s: Unknown step %s"), "fminsearch", data.step)
+        error(errmsg)
     end
-  end
-  //
-  // Process output functions
-  //
-  optimValues = struct(...
-      "funccount" ,data.funccount , ...
-      "fval" ,data.fval , ...
-      "iteration" , data.iteration , ...
-      "procedure" , procedure ...
-      );
-  if ( fmsdata.OutputFcn <> [] ) then
-    if ( type ( fmsdata.OutputFcn ) == 13 ) then
-      // The output function is a macro
-      fmsdata.OutputFcn ( data.x , optimValues , state );
-    elseif ( type ( fmsdata.OutputFcn ) == 15 ) then
-      // The output function is a list of macros
-      for i = 1:length(fmsdata.OutputFcn)
-        fmsdata.OutputFcn(i) ( data.x , optimValues , state );
-      end
-    else
-      // The user did something wrong...
-      errmsg = msprintf(gettext("%s: The value of the ''OutputFcn'' option is neither a function nor a list."), "fminsearch")
-      error(errmsg)
+    // 
+    // Display a message
+    //
+    if ( fmsdata.Display == "iter" ) then
+        if ( data.step <> "done" ) then
+            mprintf ( "%6s        %5s     %12s         %-20s\n", ...
+            string(data.iteration) , string(data.funccount) , string(data.fval) , procedure )
+        else
+            mprintf ( "\n" )
+        end
     end
-  end
-  // Process plot functions
-  if ( fmsdata.PlotFcns <> [] ) then
-    if ( type ( fmsdata.PlotFcns ) == 13 ) then
-      // The output function is a macro
-      fmsdata.PlotFcns ( data.x , optimValues , state );
-    elseif ( type ( fmsdata.PlotFcns ) == 15 ) then
-      // The output function is a list of macros
-      for i = 1:length(fmsdata.PlotFcns)
-        fmsdata.PlotFcns(i) ( data.x , optimValues , state );
-      end
-    else
-      // The user did something wrong...
-      errmsg = msprintf(gettext("%s: The value of the ''PlotFcns'' option is neither a function nor a list."), "fminsearch")
-      error(errmsg)
+    //
+    // Process output functions
+    //
+    stop = %f
+    optimValues = struct(...
+    "funccount" ,data.funccount , ...
+    "fval" ,data.fval , ...
+    "iteration" , data.iteration , ...
+    "procedure" , procedure ...
+    );
+    if ( fmsdata.OutputFcn <> [] ) then
+        if ( type ( fmsdata.OutputFcn ) == 13 ) then
+            // The output function is a macro
+            stop = fmsdata.OutputFcn ( data.x , optimValues , state );
+               //
+               // Backward-compatibility: define the stop variable
+               //
+            if ( exists("stop")==0 ) then
+                fms_warnheaderobsolete ( "outputfun(x,optimValues , state )" , "stop=outputfun(x,optimValues , state )", "5.4.1" )
+                stop = %f
+            end
+        elseif ( type ( fmsdata.OutputFcn ) == 15 ) then
+            // The output function is a list of macros
+            for i = 1:length(fmsdata.OutputFcn)
+                stop = fmsdata.OutputFcn(i) ( data.x , optimValues , state );
+            end
+               //
+               // Backward-compatibility: define the stop variable
+               //
+            if ( exists("stop")==0 ) then
+                fms_warnheaderobsolete ( "outputfun(x,optimValues , state )" , "stop=outputfun(x,optimValues , state )", "5.4.1" )
+                stop = %f
+            end
+        else
+            // The user did something wrong...
+            errmsg = msprintf(gettext("%s: The value of the ''OutputFcn'' option is neither a function nor a list."), "fminsearch")
+            error(errmsg)
+        end
+    end
+    // Process plot functions
+    if ( fmsdata.PlotFcns <> [] ) then
+        if ( type ( fmsdata.PlotFcns ) == 13 ) then
+            // The output function is a macro
+            fmsdata.PlotFcns ( data.x , optimValues , state );
+        elseif ( type ( fmsdata.PlotFcns ) == 15 ) then
+            // The output function is a list of macros
+            for i = 1:length(fmsdata.PlotFcns)
+                fmsdata.PlotFcns(i) ( data.x , optimValues , state );
+            end
+        else
+            // The user did something wrong...
+            errmsg = msprintf(gettext("%s: The value of the ''PlotFcns'' option is neither a function nor a list."), "fminsearch")
+            error(errmsg)
+        end
     end
-  end
 endfunction
 //
 // fminsearch_function --
@@ -262,6 +277,14 @@ endfunction
 //   neldermead requirements.
 //
 function [ f , index , fmsfundata ] = fminsearch_function ( x , index , fmsfundata )
-  f = fmsfundata.Fun ( x )
+    f = fmsfundata.Fun ( x )
 endfunction
 
+function fms_warnheaderobsolete ( oldheader , newheader , removedVersion )
+    warnMessage = msprintf(_("Calling sequence %s is obsolete."),oldheader)
+    warnMessage = [warnMessage, msprintf(_("Please use %s instead."),newheader)]
+    warnMessage = [warnMessage, msprintf(_("This feature will be permanently removed in Scilab %s"), removedVersion)]
+    warning(warnMessage);
+endfunction
+
+
index 04a23f5..351f9e9 100644 (file)
@@ -1,6 +1,6 @@
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2008-2009 - INRIA - Michael Baudin
-// Copyright (C) 2009-2010 - DIGITEO - Michael Baudin
+// Copyright (C) 2009-2011 - DIGITEO - 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
@@ -84,10 +84,6 @@ function value = neldermead_cget (this,key)
     value = this.boxineqscaling;
   case "-mymethod" then
     value = this.mymethod
-  case "-myterminate" then
-    value = this.myterminate
-  case "-myterminateflag" then
-    value = this.myterminateflag
   case "-tolvarianceflag" then
     value = this.tolvarianceflag
   case "-tolabsolutevariance" then
index 312cbdc..873080c 100644 (file)
@@ -1,6 +1,6 @@
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2008-2009 - INRIA - Michael Baudin
-// Copyright (C) 2009-2010 - DIGITEO - Michael Baudin
+// Copyright (C) 2009-2011 - DIGITEO - 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
@@ -191,10 +191,27 @@ function this = neldermead_configure (this,key,value)
   case "-mymethod" then
     assert_typefunction ( value , "value" , 3 );
     this.mymethod = value
+  case "-tolvarianceflag" then
+    assert_typeboolean ( value , "value" , 3 )
+    this.tolvarianceflag = value
+  case "-tolabsolutevariance" then
+    assert_typereal ( value , "value" , 3 );
+    this.tolabsolutevariance = value
+  case "-tolrelativevariance" then
+    assert_typereal ( value , "value" , 3 );
+    this.tolrelativevariance = value
+  case "-greedy" then
+    assert_typeboolean ( value , "value" , 3 )
+    this.greedy = value
+//
+// Obsolete options.
+//
   case "-myterminate" then
+    neldmead_warnoptobs ( "-myterminate" , "-outputcommand" , "5.4.1" )
     assert_typefunction ( value , "value" , 3 );
     this.myterminate = value
   case "-myterminateflag" then
+    neldmead_warnoptobs ( "-myterminateflag" , "-outputcommand" , "5.4.1" )
     assert_typeboolean ( value , "value" , 3 );
     select value
     case %f then
@@ -204,18 +221,6 @@ function this = neldermead_configure (this,key,value)
     else
       unknownValueForOption ( value , "-myterminateflag" )
     end
-  case "-tolvarianceflag" then
-    assert_typeboolean ( value , "value" , 3 )
-    this.tolvarianceflag = value
-  case "-tolabsolutevariance" then
-    assert_typereal ( value , "value" , 3 );
-    this.tolabsolutevariance = value
-  case "-tolrelativevariance" then
-    assert_typereal ( value , "value" , 3 );
-    this.tolrelativevariance = value
-  case "-greedy" then
-    assert_typeboolean ( value , "value" , 3 )
-    this.greedy = value
   else
     // Delegate to the optimization object
     this.optbase = optimbase_configure ( this.optbase , key , value );
@@ -259,5 +264,13 @@ function unknownValueForOption ( value , optionname )
       error(errmsg);
 endfunction
 
+function neldmead_warnoptobs ( oldoption , newoption , removedVersion )
+    warnMessage = msprintf(_("Option %s is obsolete."),oldoption)
+    warnMessage = [warnMessage, msprintf(_("Please use %s instead."),newoption)]
+    warnMessage = [warnMessage, msprintf(_("This feature will be permanently removed in Scilab %s"), removedVersion)]
+    warning(warnMessage);
+endfunction
+
+
 
 
index 386be3f..573691c 100644 (file)
@@ -1,6 +1,6 @@
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2008-2009 - INRIA - Michael Baudin
-// Copyright (C) 2009-2010 - DIGITEO - Michael Baudin
+// Copyright (C) 2009-2011 - DIGITEO - 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
@@ -65,9 +65,12 @@ function newobj = neldermead_new ()
     "tolrelativevariance"
     "variancesimplex0"
     "mymethod"
+    "greedy"
+//
+// Obsolete options
+//
     "myterminate"
     "myterminateflag"
-    "greedy"
     ]);
 
   newobj.optbase = optimbase_new();
@@ -182,11 +185,15 @@ function newobj = neldermead_new ()
   newobj.variancesimplex0 = 0.0;
   // User-defined algorithm
   newobj.mymethod = []
+  // Set to %t to enable greedy Nelder-Mead
+  newobj.greedy = %f;
+  //
+  // Obsolete options
+  //
   // User-defined terimination criteria
   newobj.myterminate = []
   // Flag to enable the user-defined terimination criteria
   newobj.myterminateflag = %f
-  // Set to %t to enable greedy Nelder-Mead
-  newobj.greedy = %f;
+
 endfunction
 
index bc7cbb0..b436a74 100644 (file)
@@ -1,6 +1,6 @@
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2009 - INRIA - Michael Baudin
-// Copyright (C) 2009-2010 - DIGITEO - Michael Baudin
+// Copyright (C) 2009-2011 - DIGITEO - 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
 //   Search the minimum with Nelder-Mead algorithm.
 //
 function this = neldermead_search ( this )
-  withderivatives = optimbase_cget ( this.optbase , "-withderivatives" );
-  if ( withderivatives ) then
-    errmsg = msprintf(gettext("%s: The -withderivatives option is true but all algorithms in neldermead are derivative-free."), "neldermead_search")
-    error(errmsg)
-  end
-  if ( ~this.startupflag ) then
-    this = neldermead_startup ( this );
-    this.startupflag = %t;
-  end
-  neldermead_outputcmd ( this, "init" , this.simplex0 , "init" )
-  if ( this.restartflag ) then
-    this = neldermead_autorestart ( this )
-  else
-    this = neldermead_algo ( this );
-  end
-  neldermead_outputcmd ( this, "done" , this.simplexopt , "done" )
+    withderivatives = optimbase_cget ( this.optbase , "-withderivatives" );
+    if ( withderivatives ) then
+        errmsg = msprintf(gettext("%s: The -withderivatives option is true but all algorithms in neldermead are derivative-free."), "neldermead_search")
+        error(errmsg)
+    end
+    if ( ~this.startupflag ) then
+        this = neldermead_startup ( this );
+        this.startupflag = %t;
+    end
+    stop = neldermead_outputcmd ( this, "init" , this.simplex0 , "init" )
+    if ( stop ) then
+        this.optbase = optimbase_set ( this.optbase , "-status" , "userstop" );
+        verbose = optimbase_cget ( this.optbase , "-verbose" )
+        if ( verbose == 1 ) then
+            this = neldermead_log (this,sprintf("Terminate by user''s request"));
+        end
+        return
+    end
+
+    if ( this.restartflag ) then
+        this = neldermead_autorestart ( this )
+    else
+        this = neldermead_algo ( this );
+    end
+    stop = neldermead_outputcmd ( this, "done" , this.simplexopt , "done" )
+    if ( stop ) then
+        this.optbase = optimbase_set ( this.optbase , "-status" , "userstop" );
+        verbose = optimbase_cget ( this.optbase , "-verbose" )
+        if ( verbose == 1 ) then
+            this = neldermead_log (this,sprintf("Terminate by user''s request"));
+        end
+    end
 endfunction
 //
 // neldermead_algo --
@@ -62,16 +78,16 @@ endfunction
 function this = neldermead_algo ( this )
     select this.method
     case "fixed" then
-      this = neldermead_fixed (this);
+        this = neldermead_fixed (this);
     case "variable" then
-      this = neldermead_variable (this);
+        this = neldermead_variable (this);
     case "box" then
-      this = neldermead_box (this);
+        this = neldermead_box (this);
     case "mine" then
-      this = this.mymethod ( this );
+        this = this.mymethod ( this );
     else
-      errmsg = msprintf(gettext("%s: Unknown -method %s"), "neldermead_algo", this.method)
-      error(errmsg)
+        errmsg = msprintf(gettext("%s: Unknown -method %s"), "neldermead_algo", this.method)
+        error(errmsg)
     end
 endfunction
 //
@@ -127,39 +143,39 @@ endfunction
 //   restartnb = 3 (restarts are Tries #2, #3 and #4)
 //
 function this = neldermead_autorestart ( this )
-  restartmax = this.restartmax;
-  reached = %f;
-  for iloop = 1: restartmax + 1
-    this = neldermead_log (this,sprintf("*****************************************************************"));
-    this = neldermead_log (this,sprintf("Try #%d/%d.", iloop , restartmax + 1 ));
-    //
-    // Run algorithm
-    this = neldermead_algo ( this );
-    //
-    // Must we restart ?
-    [ this , istorestart ] = neldermead_istorestart ( this );
-    if ( istorestart ) then
-      this = neldermead_log (this,"Must restart.");
-    else
-      this = neldermead_log (this,"Must not restart.");
-    end
-    if ( ~istorestart ) then
-      reached = %t;
-      break
+    restartmax = this.restartmax;
+    reached = %f;
+    for iloop = 1: restartmax + 1
+        this = neldermead_log (this,sprintf("*****************************************************************"));
+        this = neldermead_log (this,sprintf("Try #%d/%d.", iloop , restartmax + 1 ));
+        //
+        // Run algorithm
+        this = neldermead_algo ( this );
+        //
+        // Must we restart ?
+        [ this , istorestart ] = neldermead_istorestart ( this );
+        if ( istorestart ) then
+            this = neldermead_log (this,"Must restart.");
+        else
+            this = neldermead_log (this,"Must not restart.");
+        end
+        if ( ~istorestart ) then
+            reached = %t;
+            break
+        end
+        if ( iloop < restartmax + 1 ) then
+            // We are going to perform a restart
+            this.restartnb = this.restartnb + 1;
+            this = neldermead_log (this,"Updating simplex.");
+            this = neldermead_updatesimp ( this );
+        end
     end
-    if ( iloop < restartmax + 1 ) then
-      // We are going to perform a restart
-      this.restartnb = this.restartnb + 1;
-      this = neldermead_log (this,"Updating simplex.");
-      this = neldermead_updatesimp ( this );
+    if ( reached ) then
+        this = neldermead_log (this, sprintf ( "Convergence reached after %d restarts." , this.restartnb ) );
+    else
+        this = neldermead_log (this, sprintf ( "Convergence not reached after maximum %d restarts." , this.restartnb ) );
+        this.optbase = optimbase_set ( this.optbase , "-status" , "maxrestart" );
     end
-  end
-  if ( reached ) then
-    this = neldermead_log (this, sprintf ( "Convergence reached after %d restarts." , this.restartnb ) );
-  else
-    this = neldermead_log (this, sprintf ( "Convergence not reached after maximum %d restarts." , this.restartnb ) );
-    this.optbase = optimbase_set ( this.optbase , "-status" , "maxrestart" );
-  end
 endfunction
 
 
@@ -168,221 +184,215 @@ endfunction
 //   The original Nelder-Mead algorithm, with variable-size simplex.
 //
 function this = neldermead_variable ( this )
-  // Check settings correspond to algo
-  [ this.optbase , hascons ] = optimbase_hasconstraints ( this.optbase );
-  if ( hascons ) then
-      errmsg = msprintf(gettext("%s: Problem has constraints, but variable algorithm ignores them."), "neldermead_variable")
-      error(errmsg)
-  end
-  verbose = optimbase_cget ( this.optbase , "-verbose" )
-  //
-  // Order the vertices for the first time
-  //
-  simplex = this.simplex0;
-  n = optimbase_cget ( this.optbase , "-numberofvariables" );
-  if (n==0) then
-    errmsg = msprintf(gettext("%s: The number of variable is zero."), "neldermead_variable")
-    error(errmsg)
-  end
-  fvinitial = optimbase_get ( this.optbase , "-fx0" );
-  // Sort function values and x points by increasing function value order
-  this = neldermead_log (this,"Step #1 : order");
-  simplex = optimsimplex_sort ( simplex );
-  // Transpose, because optimsimplex returns row vectors
-  currentcenter = optimsimplex_center ( simplex ).';
-  currentxopt = optimbase_cget ( this.optbase , "-x0" );
-  newfvmean = optimsimplex_fvmean ( simplex );
-  greedy = this.greedy;
-  //
-  // Initialize
-  //
-  terminate = %f;
-  iter = 0;
-  step = "init";
-  //
-  // Nelder-Mead Loop
-  //
-  while ( ~terminate )
-    this.optbase = optimbase_incriter ( this.optbase );
-    iter = iter + 1;
-    // Transpose, because optimsimplex returns row vectors
-    xlow = optimsimplex_getx ( simplex , 1 ).'
-    flow = optimsimplex_getfv ( simplex , 1 )
-    xhigh = optimsimplex_getx ( simplex , n+1 ).'
-    fhigh = optimsimplex_getfv ( simplex , n+1 )
-    xn = optimsimplex_getx ( simplex , n ).'
-    fn = optimsimplex_getfv ( simplex , n )
+    // Check settings correspond to algo
+    [ this.optbase , hascons ] = optimbase_hasconstraints ( this.optbase );
+    if ( hascons ) then
+        errmsg = msprintf(gettext("%s: Problem has constraints, but variable algorithm ignores them."), "neldermead_variable")
+        error(errmsg)
+    end
+    verbose = optimbase_cget ( this.optbase , "-verbose" )
     //
-    // Store history
+    // Order the vertices for the first time
     //
-    xcoords = optimsimplex_getallx ( simplex )
-    this = neldermead_storehistory ( this , n , flow , xlow , xcoords );
-    currentfopt = flow;
-    previousxopt = currentxopt;
-    currentxopt = xlow;
-    previouscenter = currentcenter;
+    simplex = this.simplex0;
+    n = optimbase_cget ( this.optbase , "-numberofvariables" );
+    if (n==0) then
+        errmsg = msprintf(gettext("%s: The number of variable is zero."), "neldermead_variable")
+        error(errmsg)
+    end
+    fvinitial = optimbase_get ( this.optbase , "-fx0" );
+    // Sort function values and x points by increasing function value order
+    this = neldermead_log (this,"Step #1 : order");
+    simplex = optimsimplex_sort ( simplex );
+    // Transpose, because optimsimplex returns row vectors
     currentcenter = optimsimplex_center ( simplex ).';
-    oldfvmean = newfvmean;
+    currentxopt = optimbase_cget ( this.optbase , "-x0" );
     newfvmean = optimsimplex_fvmean ( simplex );
-    if ( verbose == 1 ) then
-      deltafv = abs(optimsimplex_deltafvmax ( simplex ));
-      totaliter = optimbase_get ( this.optbase , "-iterations" );
-      funevals = optimbase_get ( this.optbase , "-funevals" );
-      ssize = optimsimplex_size ( simplex )
-      this = neldermead_log (this,sprintf("================================================================="));
-      this = neldermead_log (this,sprintf("Iteration #%d (total = %d)",iter,totaliter));
-      this = neldermead_log (this,sprintf("Function Eval #%d",funevals));
-      this = neldermead_log (this,sprintf("Xopt : %s",_strvec(xlow)));
-      this = neldermead_log (this,sprintf("Fopt : %e",flow));
-      this = neldermead_log (this,sprintf("DeltaFv : %e",deltafv));
-      this = neldermead_log (this,sprintf("Center : %s",_strvec(currentcenter)));
-      this = neldermead_log (this,sprintf("Size : %e",ssize));
-      str = string ( simplex )
-      for i = 1:n+1
-        this = neldermead_log (this,str(i));
-      end
-    end
-    this.optbase = optimbase_set ( this.optbase , "-xopt" , xlow );
-    this.optbase = optimbase_set ( this.optbase , "-fopt" , flow );
-    neldermead_outputcmd ( this, "iter" , simplex , step )
-
+    greedy = this.greedy;
     //
-    // Update termination flag
+    // Initialize
     //
-    if ( iter > 1 ) then
-      [ this , terminate , status ] = neldermead_termination (this , ...
-        fvinitial , oldfvmean , newfvmean , previouscenter , currentcenter , simplex );
-      if ( terminate ) then
-        this = neldermead_log (this,sprintf("Terminate with status : %s",status));
-        break
-      end
-    end
+    terminate = %f;
+    iter = 0;
+    step = "init";
     //
-    // Compute xbar, center of better vertices
+    // Nelder-Mead Loop
     //
-    if ( verbose == 1 ) then
-      this = neldermead_log (this,sprintf("Reflect"));
-    end
-    // Transpose, because optimsimplex returns row vectors
-    xbar   = optimsimplex_xbar ( simplex ).'; 
-    if ( verbose == 1 ) then
-      this = neldermead_log (this,sprintf("xbar="+_strvec(xbar)+""));
-    end
-    //
-    // Reflect the worst point with respect to center
-    //
-    xr = neldermead_interpolate ( xbar , xhigh , this.rho );
-    [ this.optbase , fr , index ] = optimbase_function ( this.optbase , xr , 2 );
-    if ( verbose == 1 ) then
-      this = neldermead_log (this,sprintf("xr=["+_strvec(xr)+"], f(xr)=%f",fr));
-    end
-    if ( fr >= flow & fr < fn ) then
-      if ( verbose == 1 ) then
-        this = neldermead_log (this,sprintf("  > Perform reflection"));
-      end
-      simplex = optimsimplex_setve ( simplex , n+1 , fr , xr.' )
-      step = "reflection";
-    elseif ( fr < flow ) then
-      // Expand
-      if ( verbose == 1 ) then
-        this = neldermead_log (this,sprintf("Expand"));
-      end
-      xe = neldermead_interpolate ( xbar , xhigh , this.rho*this.chi );
-      [ this.optbase , fe , index ] = optimbase_function ( this.optbase , xe , 2 );
-      if ( verbose == 1 ) then
-        this = neldermead_log (this,sprintf("xe="+_strvec(xe)+", f(xe)=%f",fe));
-      end
-      if ( greedy ) then
-        if ( fe < flow ) then
-          if ( verbose == 1 ) then
-            this = neldermead_log (this,sprintf("  > Perform Greedy Expansion"));
-          end
-          simplex = optimsimplex_setve ( simplex , n+1 , fe , xe.' )
-          step = "expansion";
-        else
-          if ( verbose == 1 ) then
-            this = neldermead_log (this,sprintf("  > Perform Greedy Reflection"));
-          end
-          simplex = optimsimplex_setve ( simplex , n+1 , fr , xr.' )
-          step = "reflection";
+    while ( ~terminate )
+        this.optbase = optimbase_incriter ( this.optbase );
+        iter = iter + 1;
+        // Transpose, because optimsimplex returns row vectors
+        xlow = optimsimplex_getx ( simplex , 1 ).'
+        flow = optimsimplex_getfv ( simplex , 1 )
+        xhigh = optimsimplex_getx ( simplex , n+1 ).'
+        fhigh = optimsimplex_getfv ( simplex , n+1 )
+        xn = optimsimplex_getx ( simplex , n ).'
+        fn = optimsimplex_getfv ( simplex , n )
+        //
+        // Store history
+
+
+        //
+        xcoords = optimsimplex_getallx ( simplex )
+        this = neldermead_storehistory ( this , n , flow , xlow , xcoords );
+        currentfopt = flow;
+        previousxopt = currentxopt;
+        currentxopt = xlow;
+        previouscenter = currentcenter;
+        currentcenter = optimsimplex_center ( simplex ).';
+        oldfvmean = newfvmean;
+        newfvmean = optimsimplex_fvmean ( simplex );
+        if ( verbose == 1 ) then
+            this = neldermead_logsummary ( this, iter,xlow,flow,currentcenter,simplex )
         end
-      else
-        if ( fe < fr ) then
-          if ( verbose == 1 ) then
-            this = neldermead_log (this,sprintf("  > Perform Expansion"));
-          end
-          simplex = optimsimplex_setve ( simplex , n+1 , fe , xe.' )
-          step = "expansion";
-        else
-          if ( verbose == 1 ) then
-            this = neldermead_log (this,sprintf("  > Perform Reflection"));
-          end
-          simplex = optimsimplex_setve ( simplex , n+1 , fr , xr.' )
-          step = "reflection";
+        this.optbase = optimbase_set ( this.optbase , "-xopt" , xlow );
+        this.optbase = optimbase_set ( this.optbase , "-fopt" , flow );
+        stop = neldermead_outputcmd ( this, "iter" , simplex , step )
+        if ( stop ) then
+            status = "userstop"
+            if ( verbose == 1 ) then
+                this = neldermead_log (this,sprintf("Terminate by user''s request"));
+            end
+            break
         end
-      end
-    elseif ( fr >= fn & fr < fhigh ) then
-      // Outside contraction
-      if ( verbose == 1 ) then
-        this = neldermead_log (this,sprintf("Contract - outside"));
-      end
-      xc = neldermead_interpolate ( xbar , xhigh , this.rho*this.gamma );
-      [ this.optbase , fc , index ] = optimbase_function ( this.optbase , xc , 2 );
-      if ( verbose == 1 ) then
-        this = neldermead_log (this,sprintf("xc="+_strvec(xc)+", f(xc)=%f",fc));
-      end
-      if ( fc <= fr ) then
+
+        //
+        // Update termination flag
+        //
+        if ( iter > 1 ) then
+            [ this , terminate , status ] = neldermead_termination (this , ...
+            fvinitial , oldfvmean , newfvmean , previouscenter , currentcenter , simplex );
+            if ( terminate ) then
+                this = neldermead_log (this,sprintf("Terminate with status : %s",status));
+                break
+            end
+        end
+        //
+        // Compute xbar, center of better vertices
+        //
         if ( verbose == 1 ) then
-          this = neldermead_log (this,sprintf("  > Perform Outside Contraction"));
+            this = neldermead_log (this,sprintf("Reflect"));
         end
-        simplex = optimsimplex_setve ( simplex , n+1 , fc , xc.' )
-        step = "outsidecontraction";
-      else
-        //  Shrink
+        // Transpose, because optimsimplex returns row vectors
+        xbar   = optimsimplex_xbar ( simplex ).'; 
         if ( verbose == 1 ) then
-          this = neldermead_log (this,sprintf("  > Perform Shrink"));
+            this = neldermead_log (this,sprintf("xbar="+_strvec(xbar)+""));
         end
-        [ simplex , this ] = optimsimplex_shrink ( simplex , costf_transposex , this.sigma , this );
-        step = "shrink";
-      end
-    else
-      // ( fr >= fn & fr >= fhigh )  
-      // Inside contraction
-      if ( verbose == 1 ) then
-        this = neldermead_log (this,sprintf("Contract - inside"));
-      end
-      xc = neldermead_interpolate ( xbar , xhigh , -this.gamma );
-      [ this.optbase , fc , index ] = optimbase_function ( this.optbase , xc , 2 );
-      if ( verbose == 1 ) then
-        this = neldermead_log (this,sprintf("xc="+_strvec(xc)+", f(xc)=%f",fc));
-      end
-      if ( fc < fhigh ) then
+        //
+        // Reflect the worst point with respect to center
+        //
+        xr = neldermead_interpolate ( xbar , xhigh , this.rho );
+        [ this.optbase , fr , index ] = optimbase_function ( this.optbase , xr , 2 );
         if ( verbose == 1 ) then
-          this = neldermead_log (this,sprintf("  > Perform Inside Contraction"));
+            this = neldermead_log (this,sprintf("xr=["+_strvec(xr)+"], f(xr)=%f",fr));
         end
-        simplex = optimsimplex_setve ( simplex , n+1 , fc , xc.' )
-        step = "insidecontraction";
-      else
-        //  Shrink
+        if ( fr >= flow & fr < fn ) then
+            if ( verbose == 1 ) then
+                this = neldermead_log (this,sprintf("  > Perform reflection"));
+            end
+            simplex = optimsimplex_setve ( simplex , n+1 , fr , xr.' )
+            step = "reflection";
+        elseif ( fr < flow ) then
+            // Expand
+            if ( verbose == 1 ) then
+                this = neldermead_log (this,sprintf("Expand"));
+            end
+            xe = neldermead_interpolate ( xbar , xhigh , this.rho*this.chi );
+            [ this.optbase , fe , index ] = optimbase_function ( this.optbase , xe , 2 );
+            if ( verbose == 1 ) then
+                this = neldermead_log (this,sprintf("xe="+_strvec(xe)+", f(xe)=%f",fe));
+            end
+            if ( greedy ) then
+                if ( fe < flow ) then
+                    if ( verbose == 1 ) then
+                        this = neldermead_log (this,sprintf("  > Perform Greedy Expansion"));
+                    end
+                    simplex = optimsimplex_setve ( simplex , n+1 , fe , xe.' )
+                    step = "expansion";
+                else
+                    if ( verbose == 1 ) then
+                        this = neldermead_log (this,sprintf("  > Perform Greedy Reflection"));
+                    end
+                    simplex = optimsimplex_setve ( simplex , n+1 , fr , xr.' )
+                    step = "reflection";
+                end
+            else
+                if ( fe < fr ) then
+                    if ( verbose == 1 ) then
+                        this = neldermead_log (this,sprintf("  > Perform Expansion"));
+                    end
+                    simplex = optimsimplex_setve ( simplex , n+1 , fe , xe.' )
+                    step = "expansion";
+                else
+                    if ( verbose == 1 ) then
+                        this = neldermead_log (this,sprintf("  > Perform Reflection"));
+                    end
+                    simplex = optimsimplex_setve ( simplex , n+1 , fr , xr.' )
+                    step = "reflection";
+                end
+            end
+        elseif ( fr >= fn & fr < fhigh ) then
+            // Outside contraction
+            if ( verbose == 1 ) then
+                this = neldermead_log (this,sprintf("Contract - outside"));
+            end
+            xc = neldermead_interpolate ( xbar , xhigh , this.rho*this.gamma );
+            [ this.optbase , fc , index ] = optimbase_function ( this.optbase , xc , 2 );
+            if ( verbose == 1 ) then
+                this = neldermead_log (this,sprintf("xc="+_strvec(xc)+", f(xc)=%f",fc));
+            end
+            if ( fc <= fr ) then
+                if ( verbose == 1 ) then
+                    this = neldermead_log (this,sprintf("  > Perform Outside Contraction"));
+                end
+                simplex = optimsimplex_setve ( simplex , n+1 , fc , xc.' )
+                step = "outsidecontraction";
+            else
+                //  Shrink
+                if ( verbose == 1 ) then
+                    this = neldermead_log (this,sprintf("  > Perform Shrink"));
+                end
+                [ simplex , this ] = optimsimplex_shrink ( simplex , costf_transposex , this.sigma , this );
+                step = "shrink";
+            end
+        else
+            // ( fr >= fn & fr >= fhigh )  
+            // Inside contraction
+            if ( verbose == 1 ) then
+                this = neldermead_log (this,sprintf("Contract - inside"));
+            end
+            xc = neldermead_interpolate ( xbar , xhigh , -this.gamma );
+            [ this.optbase , fc , index ] = optimbase_function ( this.optbase , xc , 2 );
+            if ( verbose == 1 ) then
+                this = neldermead_log (this,sprintf("xc="+_strvec(xc)+", f(xc)=%f",fc));
+            end
+            if ( fc < fhigh ) then
+                if ( verbose == 1 ) then
+                    this = neldermead_log (this,sprintf("  > Perform Inside Contraction"));
+                end
+                simplex = optimsimplex_setve ( simplex , n+1 , fc , xc.' )
+                step = "insidecontraction";
+            else
+                //  Shrink
+                if ( verbose == 1 ) then
+                    this = neldermead_log (this,sprintf("  > Perform Shrink"));
+                end
+                [ simplex , this ] = optimsimplex_shrink ( simplex , costf_transposex , this.sigma , this )
+                step = "shrink";
+            end
+        end
+        //
+        // Sort simplex
+        //
         if ( verbose == 1 ) then
-          this = neldermead_log (this,sprintf("  > Perform Shrink"));
+            this = neldermead_log (this,sprintf("Sort"));
         end
-        [ simplex , this ] = optimsimplex_shrink ( simplex , costf_transposex , this.sigma , this )
-        step = "shrink";
-      end
-    end
-    //
-    // Sort simplex
-    //
-    if ( verbose == 1 ) then
-      this = neldermead_log (this,sprintf("Sort"));
+        simplex  = optimsimplex_sort ( simplex );
     end
-    simplex  = optimsimplex_sort ( simplex );
-  end
-  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;
+    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;
 endfunction
 
 //
@@ -413,161 +423,153 @@ endfunction
 //   (which is also the second lowest reading in So)."
 //
 function this = neldermead_fixed (this)
-  // Check settings correspond to algo
-  [ this.optbase , hascons ] = optimbase_hasnlcons ( this.optbase );
-  if ( hascons ) then
-      errmsg = msprintf(gettext("%s: Problem has constraints, but fixed algorithm ignores them."), "neldermead_fixed")
-      error(errmsg)
-  end
-  verbose = optimbase_cget ( this.optbase , "-verbose" )
-  //
-  // Order the vertices for the first time
-  //
-  simplex = this.simplex0;
-  n = optimbase_cget ( this.optbase , "-numberofvariables" );
-  fvinitial = optimbase_get ( this.optbase , "-fx0" );
-  // Sort function values and x points by increasing function value order
-  this = neldermead_log (this,sprintf("Sort"));
-  simplex = optimsimplex_sort ( simplex );
-  //
-  // Compute center of simplex
-  //
-  // Transpose, because optimsimplex returns row vectors
-  currentcenter = optimsimplex_center ( simplex ).';
-  newfvmean = optimsimplex_fvmean ( simplex );
-  currentxopt = optimbase_cget ( this.optbase , "-x0" );
-  //
-  // Set indices for "clarity"
-  //
-  ilow = 1
-  ihigh = n + 1
-  inext = n
-  //
-  // Initialize
-  //
-  terminate = %f;
-  iter = 0;
-  step = "init";
-  //
-  // main N-M loop
-  //
-  while ( ~terminate )
-    this.optbase = optimbase_incriter ( this.optbase );
-    iter = iter + 1;
-    xlow = optimsimplex_getx ( simplex , ilow ).'
-    flow = optimsimplex_getfv ( simplex , ilow )
-    xhigh = optimsimplex_getx ( simplex , ihigh ).'
-    fhigh = optimsimplex_getfv ( simplex , ihigh )
+    // Check settings correspond to algo
+    [ this.optbase , hascons ] = optimbase_hasnlcons ( this.optbase );
+    if ( hascons ) then
+        errmsg = msprintf(gettext("%s: Problem has constraints, but fixed algorithm ignores them."), "neldermead_fixed")
+        error(errmsg)
+    end
+    verbose = optimbase_cget ( this.optbase , "-verbose" )
     //
-    // Store history
+    // Order the vertices for the first time
     //
-    xcoords = optimsimplex_getallx ( simplex )
-    this = neldermead_storehistory ( this , n , flow , xlow , xcoords );
-    currentfopt = flow;
-    previousxopt = currentxopt;
-    currentxopt = xlow;
-    previouscenter = currentcenter;
-    currentcenter = optimsimplex_center ( simplex ).';
-    oldfvmean = newfvmean;
-    newfvmean = optimsimplex_fvmean ( simplex );
-    if ( verbose == 1 ) then
-      deltafv = abs(optimsimplex_deltafvmax ( simplex ));
-      totaliter = optimbase_get ( this.optbase , "-iterations" );
-      funevals = optimbase_get ( this.optbase , "-funevals" );
-      ssize = optimsimplex_size ( simplex )
-      this = neldermead_log (this,sprintf("================================================================="));
-      this = neldermead_log (this,sprintf("Iteration #%d (total = %d)",iter,totaliter));
-      this = neldermead_log (this,sprintf("Function Eval #%d",funevals));
-      this = neldermead_log (this,sprintf("Xopt : %s",_strvec(xlow)));
-      this = neldermead_log (this,sprintf("Fopt : %e",flow));
-      this = neldermead_log (this,sprintf("DeltaFv : %e",deltafv));
-      this = neldermead_log (this,sprintf("Center : %s",_strvec(currentcenter)));
-      this = neldermead_log (this,sprintf("Size : %e",ssize));
-      str = string ( simplex )
-      for i = 1:n+1
-        this = neldermead_log (this,str(i));
-      end
-    end
-    this.optbase = optimbase_set ( this.optbase , "-xopt" , xlow );
-    this.optbase = optimbase_set ( this.optbase , "-fopt" , flow );
-    neldermead_outputcmd ( this, "iter" , simplex , step )
+    simplex = this.simplex0;
+    n = optimbase_cget ( this.optbase , "-numberofvariables" );
+    fvinitial = optimbase_get ( this.optbase , "-fx0" );
+    // Sort function values and x points by increasing function value order
+    this = neldermead_log (this,sprintf("Sort"));
+    simplex = optimsimplex_sort ( simplex );
     //
-    // Update termination flag
+    // Compute center of simplex
     //
-    if ( iter > 1 ) then
-      [ this , terminate , status] = neldermead_termination (this , ...
-        fvinitial , oldfvmean , newfvmean , previouscenter , currentcenter , simplex );
-      if ( terminate ) then
-        if ( verbose == 1 ) then
-          this = neldermead_log (this,sprintf("Terminate with status : %s",status));
-        end
-        break;
-      end
-    end
+    // Transpose, because optimsimplex returns row vectors
+    currentcenter = optimsimplex_center ( simplex ).';
+    newfvmean = optimsimplex_fvmean ( simplex );
+    currentxopt = optimbase_cget ( this.optbase , "-x0" );
     //
-    // Compute xbar, center of better vertices
+    // Set indices for "clarity"
     //
-    if ( verbose == 1 ) then
-      this = neldermead_log (this,sprintf("Reflect"));
-    end
-    xbar = optimsimplex_xbar ( simplex ).';
-    if ( verbose == 1 ) then
-      this = neldermead_log (this,sprintf("xbar="+_strvec(xbar)+""));
-    end
+    ilow = 1
+    ihigh = n + 1
+    inext = n
     //
-    // Reflect the worst point with respect to center
+    // Initialize
     //
-    xr = neldermead_interpolate ( xbar , xhigh , this.rho );
-    [ this.optbase , fr , index ] = optimbase_function ( this.optbase , xr , 2 );
-    if ( verbose == 1 ) then
-      this = neldermead_log (this,sprintf("xr="+_strvec(xr)+", f(xr)=%f",fr));
-    end
+    terminate = %f;
+    iter = 0;
+    step = "init";
     //
-    // Replace worst point by xr if it is better
+    // main N-M loop
     //
-    if ( fr < fhigh ) then
-      if ( verbose == 1 ) then
-      this = neldermead_log (this,sprintf("  > Perform reflect"));
-      end
-      simplex = optimsimplex_setve ( simplex , ihigh , fr , xr.' )
-      step = "reflection";
-    else
-      // Reflect / xnext
-      xnext = optimsimplex_getx ( simplex , inext ).';
-      fnext = optimsimplex_getfv ( simplex , inext );
-      xbar2 = optimsimplex_xbar ( simplex , inext ).';
-      if ( verbose == 1 ) then
-      this = neldermead_log (this,sprintf("xbar2="+_strvec(xbar2)+""));
-      end
-      xr2 = neldermead_interpolate ( xbar2 , xnext , this.rho );
-      [ this.optbase , fr2 , index ] = optimbase_function ( this.optbase , xr2 , 2 );
-      if ( verbose == 1 ) then
-      this = neldermead_log (this,sprintf("xr2="+_strvec(xr2)+", f(xr2)=%f",fr2));
-      end
-      if ( fr2 < fnext ) then
+    while ( ~terminate )
+        this.optbase = optimbase_incriter ( this.optbase );
+        iter = iter + 1;
+        xlow = optimsimplex_getx ( simplex , ilow ).'
+        flow = optimsimplex_getfv ( simplex , ilow )
+        xhigh = optimsimplex_getx ( simplex , ihigh ).'
+        fhigh = optimsimplex_getfv ( simplex , ihigh )
+        //
+        // Store history
+        //
+        xcoords = optimsimplex_getallx ( simplex )
+        this = neldermead_storehistory ( this , n , flow , xlow , xcoords );
+        currentfopt = flow;
+        previousxopt = currentxopt;
+        currentxopt = xlow;
+        previouscenter = currentcenter;
+        currentcenter = optimsimplex_center ( simplex ).';
+        oldfvmean = newfvmean;
+        newfvmean = optimsimplex_fvmean ( simplex );
+        if ( verbose == 1 ) then
+            this = neldermead_logsummary ( this, iter,xlow,flow,currentcenter,simplex )
+        end
+        this.optbase = optimbase_set ( this.optbase , "-xopt" , xlow );
+        this.optbase = optimbase_set ( this.optbase , "-fopt" , flow );
+        stop = neldermead_outputcmd ( this, "iter" , simplex , step )
+        if ( stop ) then
+            status = "userstop"
+            if ( verbose == 1 ) then
+                this = neldermead_log (this,sprintf("Terminate by user''s request"));
+            end
+            break
+        end
+        //
+        // Update termination flag
+        //
+        if ( iter > 1 ) then
+            [ this , terminate , status] = neldermead_termination (this , ...
+            fvinitial , oldfvmean , newfvmean , previouscenter , currentcenter , simplex );
+            if ( terminate ) then
+                if ( verbose == 1 ) then
+                    this = neldermead_log (this,sprintf("Terminate with status : %s",status));
+                end
+                break;
+            end
+        end
+        //
+        // Compute xbar, center of better vertices
+        //
         if ( verbose == 1 ) then
-        this = neldermead_log (this,sprintf("  > Perform reflect / next"));
+            this = neldermead_log (this,sprintf("Reflect"));
         end
-        simplex = optimsimplex_setve ( simplex , inext , fr2 , xr2.' )
-        step = "reflectionnext";
-      else
-        //  Shrink
+        xbar = optimsimplex_xbar ( simplex ).';
         if ( verbose == 1 ) then
-        this = neldermead_log (this,sprintf("  > Perform Shrink"));
+            this = neldermead_log (this,sprintf("xbar="+_strvec(xbar)+""));
         end
-        [ simplex , this ] = optimsimplex_shrink ( simplex , costf_transposex , this.sigma , this )
-        step = "shrink";
-      end
+        //
+        // Reflect the worst point with respect to center
+        //
+        xr = neldermead_interpolate ( xbar , xhigh , this.rho );
+        [ this.optbase , fr , index ] = optimbase_function ( this.optbase , xr , 2 );
+        if ( verbose == 1 ) then
+            this = neldermead_log (this,sprintf("xr="+_strvec(xr)+", f(xr)=%f",fr));
+        end
+        //
+        // Replace worst point by xr if it is better
+        //
+        if ( fr < fhigh ) then
+            if ( verbose == 1 ) then
+                this = neldermead_log (this,sprintf("  > Perform reflect"));
+            end
+            simplex = optimsimplex_setve ( simplex , ihigh , fr , xr.' )
+            step = "reflection";
+        else
+            // Reflect / xnext
+            xnext = optimsimplex_getx ( simplex , inext ).';
+            fnext = optimsimplex_getfv ( simplex , inext );
+            xbar2 = optimsimplex_xbar ( simplex , inext ).';
+            if ( verbose == 1 ) then
+                this = neldermead_log (this,sprintf("xbar2="+_strvec(xbar2)+""));
+            end
+            xr2 = neldermead_interpolate ( xbar2 , xnext , this.rho );
+            [ this.optbase , fr2 , index ] = optimbase_function ( this.optbase , xr2 , 2 );
+            if ( verbose == 1 ) then
+                this = neldermead_log (this,sprintf("xr2="+_strvec(xr2)+", f(xr2)=%f",fr2));
+            end
+            if ( fr2 < fnext ) then
+                if ( verbose == 1 ) then
+                    this = neldermead_log (this,sprintf("  > Perform reflect / next"));
+                end
+                simplex = optimsimplex_setve ( simplex , inext , fr2 , xr2.' )
+                step = "reflectionnext";
+            else
+                //  Shrink
+                if ( verbose == 1 ) then
+                    this = neldermead_log (this,sprintf("  > Perform Shrink"));
+                end
+                [ simplex , this ] = optimsimplex_shrink ( simplex , costf_transposex , this.sigma , this )
+                step = "shrink";
+            end
+        end
+        //
+        // Sort simplex
+        //
+        simplex = optimsimplex_sort ( simplex );
     end
-    //
-    // Sort simplex
-    //
-    simplex = optimsimplex_sort ( simplex );
-  end
-  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;
+    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;
 endfunction
 //
 // neldermead_interpolate --
@@ -575,7 +577,7 @@ endfunction
 //     xi = (1+fac)x1 - fac x2
 //
 function xi = neldermead_interpolate ( x1 , x2 , fac )
-  xi = (1 + fac)*x1 - fac*x2;
+    xi = (1 + fac)*x1 - fac*x2;
 endfunction
 
 //
@@ -603,7 +605,6 @@ endfunction
 //     "kelleystagnation"
 //     "tolboxf"
 //     "tolvariance"
-//     or the user-defined termination status
 // Notes
 //   Use the function average on the simplex instead of the best function value.
 //   This is because the function average changes at each iteration.
@@ -612,139 +613,148 @@ endfunction
 // TODO : set the fvinitial, oldfvmean, newfvmean.
 //
 function [ this , terminate , status ] = neldermead_termination (this , ...
-  fvinitial , oldfvmean , newfvmean , previousxopt , currentxopt , ...
-  simplex )
-  terminate = %f;
-  status = "continue";
-  verbose = optimbase_cget ( this.optbase , "-verbose" )
-  //
-  // Termination Criteria from parent optimization class
-  //
-  [ this.optbase , terminate , status ] = optimbase_terminate ( this.optbase , ...
+    fvinitial , oldfvmean , newfvmean , previousxopt , currentxopt , ...
+    simplex )
+    terminate = %f;
+    status = "continue";
+    verbose = optimbase_cget ( this.optbase , "-verbose" )
+    //
+    // Termination Criteria from parent optimization class
+    //
+    [ this.optbase , terminate , status ] = optimbase_terminate ( this.optbase , ...
     fvinitial , newfvmean , previousxopt , currentxopt );
-  //
-  // Criteria #6 : simplex absolute + relative size
-  //
-  if ( ~terminate ) then
-    if ( this.tolsimplexizemethod ) then
-      ssize = optimsimplex_size ( simplex , "sigmaplus" );
-      tolsa = this.tolsimplexizeabsolute;
-      tolsr = this.tolsimplexizerelative;
-      ssize0 = this.simplexsize0;
-      if ( verbose == 1 ) then 
-        this.optbase = optimbase_stoplog  ( this.optbase,sprintf("  > simplex size=%e < %e + %e * %e",...
-          ssize, tolsa , tolsr , ssize0 ));
-      end
-      if ( ssize < tolsa + tolsr * ssize0 ) then
-        terminate = %t;
-        status = "tolsize";
-      end
+    //
+    // Criteria #6 : simplex absolute + relative size
+    //
+    if ( ~terminate ) then
+        if ( this.tolsimplexizemethod ) then
+            ssize = optimsimplex_size ( simplex , "sigmaplus" );
+            tolsa = this.tolsimplexizeabsolute;
+            tolsr = this.tolsimplexizerelative;
+            ssize0 = this.simplexsize0;
+            if ( verbose == 1 ) then 
+                this.optbase = optimbase_stoplog  ( this.optbase,sprintf("  > simplex size=%s < %s + %s * %s",...
+                string(ssize), string(tolsa) , string(tolsr) , string(ssize0) ));
+            end
+            if ( ssize < tolsa + tolsr * ssize0 ) then
+                terminate = %t;
+                status = "tolsize";
+            end
+        end
     end
-  end
-  //
-  // Criteria #7 : simplex absolute size + difference in function values (Matlab-like)
-  //
-  if ( ~terminate ) then
-    if ( this.tolssizedeltafvmethod ) then
-      ssize = optimsimplex_size ( simplex , "sigmaplus" );
-      if ( verbose == 1 ) then 
-        this.optbase = optimbase_stoplog  ( this.optbase,sprintf("  > simplex size=%e < %e",...
-          ssize, this.tolsimplexizeabsolute));
-      end
-      shiftfv = abs(optimsimplex_deltafvmax( simplex ))
-      if ( verbose == 1 ) then 
-        this.optbase = optimbase_stoplog  ( this.optbase,sprintf("  > abs(fv(n+1) - fv(1))=%e < toldeltafv=%e",...
-          shiftfv, this.toldeltafv));
-      end
-      if ( ( ssize < this.tolsimplexizeabsolute ) & ( shiftfv < this.toldeltafv ) ) then
-        terminate = %t;
-        status = "tolsizedeltafv";
-      end
+    //
+    // Criteria #7 : simplex absolute size + difference in function values (Matlab-like)
+    //
+    if ( ~terminate ) then
+        if ( this.tolssizedeltafvmethod ) then
+            ssize = optimsimplex_size ( simplex , "sigmaplus" );
+            if ( verbose == 1 ) then 
+                this.optbase = optimbase_stoplog  ( this.optbase,sprintf("  > simplex size=%s < %s",...
+                string(ssize), string(this.tolsimplexizeabsolute)));
+            end
+            shiftfv = abs(optimsimplex_deltafvmax( simplex ))
+            if ( verbose == 1 ) then 
+                this.optbase = optimbase_stoplog  ( this.optbase,sprintf("  > abs(fv(n+1) - fv(1))=%s < toldeltafv=%s",...
+                string(shiftfv), string(this.toldeltafv)));
+            end
+            if ( ( ssize < this.tolsimplexizeabsolute ) & ( shiftfv < this.toldeltafv ) ) then
+                terminate = %t;
+                status = "tolsizedeltafv";
+            end
+        end
     end
-  end
-  //
-  // Criteria #8 : Kelley stagnation, based on
-  // a sufficient decrease condition
-  //
-  if ( ~terminate ) then
-    if ( this.kelleystagnationflag ) then
-      [ sg , this ] = optimsimplex_gradientfv ( simplex , neldermead_costf , "forward" , this );
-      nsg = sg.' * sg;
-      if ( verbose == 1 ) then
-        sgstr = _strvec(sg);
-        this.optbase = optimbase_stoplog ( this.optbase , sprintf ( "Test Stagnation : nsg = %e, sg = [%s]", nsg , sgstr ) );
-        this.optbase = optimbase_stoplog ( this.optbase , ...
-          sprintf ( "Test Stagnation : newfvmean=%e >= oldfvmean=%e - %e * %e" , newfvmean, oldfvmean , this.kelleyalpha , nsg ) );
-      end
-      if ( newfvmean >= oldfvmean - this.kelleyalpha * nsg ) then
-        terminate = %t;
-        status = "kelleystagnation";
-      end
+    //
+    // Criteria #8 : Kelley stagnation, based on
+    // a sufficient decrease condition
+    //
+    if ( ~terminate ) then
+        if ( this.kelleystagnationflag ) then
+            [ sg , this ] = optimsimplex_gradientfv ( simplex , neldermead_costf , "forward" , this );
+            nsg = sg.' * sg;
+            if ( verbose == 1 ) then
+                sgstr = _strvec(sg);
+                this.optbase = optimbase_stoplog ( this.optbase , sprintf ( "Test Stagnation : nsg = %s, sg = [%s]", ...
+                string(nsg) , sgstr ) );
+                this.optbase = optimbase_stoplog ( this.optbase , ...
+                sprintf ( "Test Stagnation : newfvmean=%s >= oldfvmean=%s - %s * %s" , ....
+                string(newfvmean), string(oldfvmean) , string(this.kelleyalpha) , string(nsg) ) );
+            end
+            if ( newfvmean >= oldfvmean - this.kelleyalpha * nsg ) then
+                terminate = %t;
+                status = "kelleystagnation";
+            end
+        end
     end
-  end
-  //
-  // Criteria #9 : Box termination criteria
-  // The number of consecutive time that an absolute tolerance on
-  // function value is met.
-  // From Algorithm 454, the tolerance is the difference between the
-  // max and the min function values in the simplex.
-  //
-  if ( ~terminate ) then
-    if ( this.boxtermination ) then
-      shiftfv = abs(optimsimplex_deltafvmax( simplex ))
-      if ( verbose == 1 ) then
-        this.optbase = optimbase_stoplog ( this.optbase , ...
-          sprintf ( "Test Box : shiftfv=%e < boxtolf=%e" , shiftfv , this.boxtolf ) );
-      end
-      if ( shiftfv < this.boxtolf ) then
-        this.boxkount = this.boxkount + 1
-        if ( verbose == 1 ) then
-          this.optbase = optimbase_stoplog ( this.optbase , ...
-            sprintf ( "Test Box : boxkount=%d == boxnbmatch=%d" , this.boxkount , this.boxnbmatch ) );
+    //
+    // Criteria #9 : Box termination criteria
+    // The number of consecutive time that an absolute tolerance on
+    // function value is met.
+    // From Algorithm 454, the tolerance is the difference between the
+    // max and the min function values in the simplex.
+    //
+    if ( ~terminate ) then
+        if ( this.boxtermination ) then
+            shiftfv = abs(optimsimplex_deltafvmax( simplex ))
+            if ( verbose == 1 ) then
+                this.optbase = optimbase_stoplog ( this.optbase , ...
+          &n