Added step type in output command.
Michaƫl Baudin [Fri, 25 Sep 2009 14:46:56 +0000 (16:46 +0200)]
scilab/modules/optimization/demos/optimization.dem.gateway.sce
scilab/modules/optimization/help/en_US/neldermead/neldermead.xml
scilab/modules/optimization/help/en_US/neldermead/nmplot.xml
scilab/modules/optimization/macros/neldermead/neldermead_cget.sci
scilab/modules/optimization/macros/neldermead/neldermead_costf.sci
scilab/modules/optimization/macros/neldermead/neldermead_get.sci
scilab/modules/optimization/macros/neldermead/neldermead_search.sci
scilab/modules/optimization/macros/neldermead/nmplot_function.sci [new file with mode: 0644]

index 98abe49..39fe769 100644 (file)
@@ -10,6 +10,7 @@ subdemolist = [
 "Non linear data fitting"         "datafit/datafit.dem.sce"       
 "fminsearch"                      "neldermead/fminsearch.sce"       
 "neldermead/Rosenbrock Variable"  "neldermead/neldermead_rosenbrock.sce"       
+"neldermead/Output Command"       "neldermead/neldermead_outputcmd.sce"       
 "neldermead/Box A"                "neldermead/neldermead_boxproblemA.sce"       
 "nmplot/Han #1"             "neldermead/nmplot_han1.sce"       
 "nmplot/Han #2"             "neldermead/nmplot_han2.sce"       
index 5ae7e0f..802e90d 100644 (file)
@@ -32,6 +32,7 @@ this = neldermead_display ( this )
 value = neldermead_get ( this , key )
 this = neldermead_search ( this )
 this = neldermead_restart ( this )
+[ this , result ] = neldermead_function ( this , x , index )
 </synopsis>
   </refsynopsisdiv>
 
@@ -1071,12 +1072,22 @@ g_i(x) &lt;= 0, i = 1,nbineq
                   </varlistentry>
 
                   <varlistentry>
+                    <term>-simplex0</term>
+
+                    <listitem>
+                      <para>the initial simplex. This is a simplex object,
+                      which is suitable for processing with the optimsimplex
+                      component.</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>
+                      which is suitable for processing with the optimsimplex
+                      component.</para>
                     </listitem>
                   </varlistentry>
 
@@ -1156,6 +1167,43 @@ g_i(x) &lt;= 0, i = 1,nbineq
           </variablelist>
         </listitem>
       </varlistentry>
+
+      <varlistentry>
+        <term>[ this , result ] = neldermead_function ( this , x , index
+        )</term>
+
+        <listitem>
+          <para>Call the cost function and return the value.</para>
+
+          <variablelist>
+            <varlistentry>
+              <term>this</term>
+
+              <listitem>
+                <para>The current object.</para>
+              </listitem>
+            </varlistentry>
+
+            <varlistentry>
+              <term>x</term>
+
+              <listitem>
+                <para>the point where the function is to be evaluated</para>
+              </listitem>
+            </varlistentry>
+
+            <varlistentry>
+              <term>index</term>
+
+              <listitem>
+                <para>optionnal, a flag to pass to the cost function (default
+                = 1). See the section "The cost function" for available values
+                of index.</para>
+              </listitem>
+            </varlistentry>
+          </variablelist>
+        </listitem>
+      </varlistentry>
     </variablelist>
   </refsection>
 
@@ -1318,6 +1366,14 @@ function outputcmd(state, data, myobj)
                 <para>the number of function evaluations</para>
               </listitem>
             </varlistentry>
+
+            <varlistentry>
+              <term>simplex</term>
+
+              <listitem>
+                <para>the current simplex</para>
+              </listitem>
+            </varlistentry>
           </variablelist>
         </listitem>
       </varlistentry>
@@ -1703,7 +1759,7 @@ alpha = alpha0 * sigma0 / nsg
 
       <listitem>
         <para>Rule 3 is applied, ie reflection with respect to next to high
-        point. </para>
+        point.</para>
       </listitem>
     </itemizedlist>
 
@@ -1831,6 +1887,95 @@ Sort
   </refsection>
 
   <refsection>
+    <title>Example #2</title>
+
+    <para>In the following example, we show how to use the output command to
+    create specialized outputs. These outputs may be used to create specific
+    data files or make interactive graphic outputs.</para>
+
+    <para>We define the function "myoutputcmd", which takes the current state
+    as its first argument. The state is a string which can contain "init",
+    "iter" or "done", depending on the status of the optimization. The data
+    input argument is a tlist, which contains the data associated with the
+    current iteration. In this case, we use the fields to print a message in
+    the console. As another example of use, we could format the message so
+    that it uses LaTeX formatting rules, which may allow the user to directly
+    copy and paste the output into a LaTeX report.</para>
+
+    <programlisting role="example">
+function y = rosenbrock (x)
+  y = 100*(x(2)-x(1)^2)^2 + (1-x(1))^2;
+endfunction
+
+
+//
+// myoutputcmd --
+//  This command is called back by the Nelder-Mead
+//  algorithm.
+// Arguments
+//  state : the current state of the algorithm
+//    "init", "iter", "done"
+//  data : the data at the current state
+//
+function myoutputcmd ( state , data )
+  iter = data.iteration
+  if ( state == "init" ) then
+    mprintf ( "=================================\n");
+    mprintf ( "Initialization\n");
+  elseif ( state == "done" ) then
+    mprintf ( "=================================\n");
+    mprintf ( "End of Optimization\n");
+  end
+  fc = data.funccount
+  fval = data.fval
+  x = data.x
+  simplex = data.simplex
+  // Simplex is a data structure, which can be managed
+  // 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);
+endfunction
+
+
+nm = neldermead_new ();
+nm = neldermead_configure(nm,"-numberofvariables",2);
+nm = neldermead_configure(nm,"-function",rosenbrock);
+nm = neldermead_configure(nm,"-x0",[-1.2 1.0]');
+nm = neldermead_configure(nm,"-maxiter",200);
+nm = neldermead_configure(nm,"-maxfunevals",300);
+nm = neldermead_configure(nm,"-tolfunrelative",10*%eps);
+nm = neldermead_configure(nm,"-tolxrelative",10*%eps);
+nm = neldermead_configure(nm,"-simplex0method","axes");
+nm = neldermead_configure(nm,"-simplex0length",1.0);
+nm = neldermead_configure(nm,"-method","variable");
+nm = neldermead_configure(nm,"-verbose",0);
+nm = neldermead_configure(nm,"-verbosetermination",0);
+nm = neldermead_configure(nm,"-outputcommand",myoutputcmd);
+nm = neldermead_search(nm);
+nm = neldermead_destroy(nm);
+</programlisting>
+
+    <para>The previous script produces the following output.</para>
+
+    <programlisting role="example">
+=================================
+Initialization
+Iteration #0, Feval #4, Fval = 2.420000e+001, x = -1.2 1, Size = 1.000000e+000
+Iteration #1, Feval #4, Fval = 2.420000e+001, x = -1.2 1, Size = 1.000000e+000
+Iteration #2, Feval #6, Fval = 2.420000e+001, x = -1.2 1, Size = 1.000000e+000
+Iteration #3, Feval #8, Fval = 2.420000e+001, x = -1.2 1, Size = 1.000000e+000
+Iteration #4, Feval #10, Fval = 9.999182e+000, x = -1.0125 0.78125, Size = 5.970304e-001
+...
+Iteration #155, Feval #296, Fval = 2.024754e-026, x = 1 1, Size = 4.601219e-013
+Iteration #156, Feval #298, Fval = 6.871176e-027, x = 1 1, Size = 2.548515e-013
+Iteration #157, Feval #300, Fval = 6.023002e-027, x = 1 1, Size = 2.814328e-013
+=================================
+End of Optimization
+Iteration #157, Feval #300, Fval = 6.023002e-027, x = 1 1, Size = 2.814328e-013
+</programlisting>
+  </refsection>
+
+  <refsection>
     <title>TODO</title>
 
     <itemizedlist>
index 0ba83cd..e8872f6 100644 (file)
@@ -1324,6 +1324,42 @@ this = nmplot_simplexhistory ( this , colorforeground , markforeground , marksty
           </variablelist>
         </listitem>
       </varlistentry>
+
+      <varlistentry>
+        <term>[ this , result ] = nmplot_function ( this , x , index )</term>
+
+        <listitem>
+          <para>Call the cost function and return the value.</para>
+
+          <variablelist>
+            <varlistentry>
+              <term>this</term>
+
+              <listitem>
+                <para>The current object.</para>
+              </listitem>
+            </varlistentry>
+
+            <varlistentry>
+              <term>x</term>
+
+              <listitem>
+                <para>the point where the function is to be evaluated</para>
+              </listitem>
+            </varlistentry>
+
+            <varlistentry>
+              <term>index</term>
+
+              <listitem>
+                <para>optionnal, a flag to pass to the cost function (default
+                = 1). See the section "The cost function" of the neldermead
+                component for available values of index.</para>
+              </listitem>
+            </varlistentry>
+          </variablelist>
+        </listitem>
+      </varlistentry>
     </variablelist>
   </refsection>
 
index ae01ffe..1ef16a9 100644 (file)
@@ -19,8 +19,6 @@ function value = neldermead_cget (this,key)
     value = this.method;
   case "-coords0" then
     value = this.coords0;
-  case "-simplex0" then
-    value = this.simplex0;
   case "-simplex0method" then
     value = this.simplex0method;
   case "-simplex0length" then
index a823ca6..e63cb2f 100644 (file)
 //   the requirements of simplex methods.
 //
 function [ f , this ] = neldermead_costf ( x , this )
-  nbnlc = optimbase_cget ( this.optbase , "-nbineqconst" )
-  if ( nbnlc == 0 ) then
-    [this.optbase , f] = optimbase_function ( this.optbase , x );
-  else
-    // Set the index, so that, if an additionnal cost function argument is provided,
-    // it can be appended at the end.
-    index = 1;
-    [this.optbase , f] = optimbase_function ( this.optbase , x , index );
-  end
+  [ this.optbase , f ] = optimbase_function ( this.optbase , x );
 endfunction
 
index 150b143..a5c66be 100644 (file)
@@ -25,6 +25,8 @@ function value = neldermead_get ( this , key )
     end
   case "-simplexopt" then
     value = this.simplexopt;
+  case "-simplex0" then
+    value = this.simplex0;
   case "-restartnb" then
     value = this.restartnb;
   else
index a9d55ce..c5e7516 100644 (file)
@@ -41,13 +41,13 @@ function this = neldermead_search ( this )
     this = neldermead_startup ( this );
     this.startupflag = 1;
   end
-  neldermead_outputcmd ( this, "init" , this.simplex0 )
+  neldermead_outputcmd ( this, "init" , this.simplex0 , "init" )
   if this.restartflag == 1 then
     this = neldermead_autorestart ( this )
   else
     this = neldermead_algo ( this );
   end
-  neldermead_outputcmd ( this, "done" , this.simplexopt )
+  neldermead_outputcmd ( this, "done" , this.simplexopt , "done" )
 endfunction
 //
 // neldermead_algo --
@@ -119,6 +119,7 @@ function this = neldermead_variable ( this )
   //
   terminate = 0;
   iter = 0;
+  step = "init";
   //
   // Nelder-Mead Loop
   //
@@ -161,7 +162,7 @@ function this = neldermead_variable ( this )
     end
     this.optbase = optimbase_set ( this.optbase , "-xopt" , xlow );
     this.optbase = optimbase_set ( this.optbase , "-fopt" , flow );
-    neldermead_outputcmd ( this, "iter" , simplex )
+    neldermead_outputcmd ( this, "iter" , simplex , step )
 
     //
     // Update termination flag
@@ -189,6 +190,7 @@ function this = neldermead_variable ( this )
     if ( fr >= flow & fr < fn ) then
       this = neldermead_log (this,sprintf("  > Perform reflection"));
       simplex = optimsimplex_setve ( simplex , n+1 , fr , xr )
+      step = "reflection";
     elseif ( fr < flow ) then
       // Expand
       this = neldermead_log (this,sprintf("Expand"));
@@ -198,9 +200,11 @@ function this = neldermead_variable ( this )
       if (fe < fr) then
         this = neldermead_log (this,sprintf("  > Perform Expansion"));
         simplex = optimsimplex_setve ( simplex , n+1 , fe , xe )
+        step = "expansion";
       else
         this = neldermead_log (this,sprintf("  > Perform reflection"));
         simplex = optimsimplex_setve ( simplex , n+1 , fr , xr )
+        step = "reflection";
       end
     elseif ( fr >= fn & fr < fhigh ) then
       // Outside contraction
@@ -211,10 +215,12 @@ function this = neldermead_variable ( this )
       if ( fc <= fr ) then
         this = neldermead_log (this,sprintf("  > Perform Outside Contraction"));
         simplex = optimsimplex_setve ( simplex , n+1 , fc , xc )
+        step = "outsidecontraction";
       else
         //  Shrink
         this = neldermead_log (this,sprintf("  > Perform Shrink"));
         [ simplex , this ] = optimsimplex_shrink ( simplex , neldermead_costf , this.sigma , this );
+        step = "shrink";
       end
     else
       // ( fr >= fn & fr >= fhigh )  
@@ -226,10 +232,12 @@ function this = neldermead_variable ( this )
       if ( fc < fhigh ) then
         this = neldermead_log (this,sprintf("  > Perform Inside Contraction"));
         simplex = optimsimplex_setve ( simplex , n+1 , fc , xc )
+        step = "insidecontraction";
       else
         //  Shrink
         this = neldermead_log (this,sprintf("  > Perform Shrink"));
         [ simplex , this ] = optimsimplex_shrink ( simplex , neldermead_costf , this.sigma , this )
+        step = "shrink";
       end
     end
     //
@@ -281,7 +289,7 @@ function this = neldermead_fixed (this)
   // Sort function values and x points by increasing function value order
   this = neldermead_log (this,sprintf("Sort"));
   simplex = optimsimplex_sort ( simplex );
-  neldermead_outputcmd ( this, "init" , simplex )
+  neldermead_outputcmd ( this, "init" , simplex , "init" )
   //
   // Compute center of simplex
   //
@@ -299,6 +307,7 @@ function this = neldermead_fixed (this)
   //
   terminate = 0;
   iter = 0;
+  step = "init";
   //
   // main N-M loop
   //
@@ -339,7 +348,7 @@ function this = neldermead_fixed (this)
     end
     this.optbase = optimbase_set ( this.optbase , "-xopt" , xlow );
     this.optbase = optimbase_set ( this.optbase , "-fopt" , flow );
-    neldermead_outputcmd ( this, "iter" , simplex )
+    neldermead_outputcmd ( this, "iter" , simplex , step )
     //
     // Update termination flag
     //
@@ -369,6 +378,7 @@ function this = neldermead_fixed (this)
     if ( fr < fhigh ) then
       this = neldermead_log (this,sprintf("  > Perform reflect"));
       simplex = optimsimplex_setve ( simplex , ihigh , fr , xr )
+      step = "reflection";
     else
       // Reflect / xnext
       xnext = optimsimplex_getx ( simplex , inext );
@@ -381,10 +391,12 @@ function this = neldermead_fixed (this)
       if ( fr2 < fnext ) then
         this = neldermead_log (this,sprintf("  > Perform reflect / next"));
         simplex = optimsimplex_setve ( simplex , inext , fr2 , xr2 )
+        step = "reflectionnext";
       else
         //  Shrink
         this = neldermead_log (this,sprintf("  > Perform Shrink"));
         [ simplex , this ] = optimsimplex_shrink ( simplex , neldermead_costf , this.sigma , this )
+        step = "shrink";
       end
     end
     //
@@ -521,20 +533,24 @@ endfunction
 //   state : the state of the algorithm,
 //     "init", "done", "iter"
 //   simplex : the current simplex
+//   step : the type of step performed during the iteration
+//     "init", "done", "reflection", "expansion", "insidecontraction", "outsidecontraction"
+//     "reflectionnext", "shrink"
 //
 function  neldermead_outputcmd ( this, ...
-   state , simplex )
+   state , simplex , step )
   outputcmd = optimbase_cget ( this.optbase , "-outputcommand" );
   if typeof(outputcmd) <> "string" then
     brutedata = optimbase_outstruct ( this.optbase );
     data = tlist(["T_NMDATA",...
       "x","fval","iteration","funccount",...
-      "simplex"]);
+      "simplex" , "step" ]);
     data.x = brutedata.x;
     data.fval = brutedata.fval;
     data.iteration = brutedata.iteration;
     data.funccount = brutedata.funccount;
     data.simplex = simplex;
+    data.step = step;
     optimbase_outputcmd ( this.optbase , state , data );
   end
 endfunction
@@ -650,6 +666,21 @@ endfunction
 //   Computes the initial simplex, depending on the -simplex0method.
 //
 function this = neldermead_startup (this)
+  // 5. Store initial data into the base optimization component
+  // Note: this call to the cost function is not used, but helps the
+  // user while he is tuning his object.
+  x0 = optimbase_cget ( this.optbase , "-x0" );
+  cmd = "[ this , fx0 ] = neldermead_function ( this , x0 )";
+  ierr=execstr(cmd,"errcatch");
+  if ierr <> 0 then
+    errmsg = msprintf ( gettext ( "%s: Cannot evaluate cost function (use neldermead_function to check your configuration)." ) , "neldermead_startup" )
+    error ( errmsg );
+  end
+  this.optbase = optimbase_set ( this.optbase , "-fx0" , fx0 );
+  this.optbase = optimbase_set ( this.optbase , "-xopt" , x0.' );
+  this.optbase = optimbase_set ( this.optbase , "-fopt" , fx0 );
+  this.optbase = optimbase_set ( this.optbase , "-iterations" , 0 );
+  // 1. If the problem has bounds, check that they are consistent
   [ this.optbase , hasbounds ] = optimbase_hasbounds ( this.optbase );
   if ( hasbounds ) then
     [ this.optbase , isok , errmsg ] = optimbase_checkbounds ( this.optbase );
@@ -657,7 +688,7 @@ function this = neldermead_startup (this)
       error ( msprintf(gettext("%s: %s"), "neldermead_startup" , errmsg ))
     end
   end
-  x0 = optimbase_cget ( this.optbase , "-x0" );
+  // 2. Get the initial guess and compute the initial simplex
   select this.simplex0method
   case "given" then
     [ simplex0 , this ] = optimsimplex_new ( this.coords0 , ...
@@ -693,7 +724,7 @@ function this = neldermead_startup (this)
     error(errmsg);
   end
   //
-  // Scale the simplex into the bounds and the nonlinear inequality constraints, if any
+  // 3. Scale the simplex into the bounds and the nonlinear inequality constraints, if any
   //
   if ( hasbounds | this.optbase.nbineqconst > 0 ) then
     this = neldermead_log (this,sprintf("Scaling initial simplex into nonlinear inequality constraints..."));
@@ -712,26 +743,19 @@ function this = neldermead_startup (this)
         error(errmsg);
       end
       if ( or ( x <> xp ) ) then
-        // Set the index, so that, if an additionnal cost function argument is provided,
-        // it can be appended at the end.
-        index = 1;
-        [ this , fv ] = neldermead_function ( this , xp , index );
+        [ this , fv ] = neldermead_function ( this , xp );
         // Transpose xp, which is a column vector
         simplex0 = optimsimplex_setve ( simplex0 , ive , fv , xp.' );
       end
     end
   end
   //
-  // Store the simplex
+  // 4. Store the simplex
   //
   this.simplex0 = optimsimplex_destroy ( this.simplex0 );
   this.simplex0 = simplex0;
   this.simplexsize0 = optimsimplex_size ( simplex0 );
-  fx0 = optimsimplex_getfv ( this.simplex0 , 1 );
-  this.optbase = optimbase_set ( this.optbase , "-fx0" , fx0 );
-  this.optbase = optimbase_set ( this.optbase , "-xopt" , x0.' );
-  this.optbase = optimbase_set ( this.optbase , "-fopt" , fx0 );
-  this.optbase = optimbase_set ( this.optbase , "-iterations" , 0 );
+  // 6. If Kelley's stagnation is enabled, initialize Kelley's stagnation detection system.
   if ( this.kelleystagnationflag == 1 ) then
     this = neldermead_kelleystag ( this );
   end
@@ -870,6 +894,7 @@ function this = neldermead_box ( this )
   //
   terminate = 0;
   iter = 0;
+  step = "init";
   //
   // Nelder-Mead Loop
   //
@@ -910,7 +935,7 @@ function this = neldermead_box ( this )
     for i = 1:nbve
       this = neldermead_log (this,str(i));
     end
-    neldermead_outputcmd ( this, "iter" , simplex )
+    neldermead_outputcmd ( this, "iter" , simplex , step )
 
     //
     // Update termination flag
@@ -941,18 +966,12 @@ function this = neldermead_box ( this )
         break
       end
     end
-    if ( nbnlc > 0 ) then
-      // Set the index, so that, if an additionnal cost function argument is provided,
-      // it can be appended at the end.
-      index = 1;
-      [ this , fr ] = neldermead_function ( this , xr , index );
-    else
-      [ this , fr ] = neldermead_function ( this , xr );
-    end
+    [ this , fr ] = neldermead_function ( this , xr );
     this = neldermead_log (this,sprintf("xr=[%s], f(xr)=%f", strcat(string(xr)," ") , fr));
     if ( fr >= flow & fr < fn ) then
       this = neldermead_log (this,sprintf("  > Perform reflection"));
       simplex = optimsimplex_setve ( simplex , ihigh , fr , xr )
+      step = "reflection";
     elseif ( fr < flow ) then
       // Expand
       this = neldermead_log (this,sprintf("Expand"));
@@ -965,21 +984,16 @@ function this = neldermead_box ( this )
           break
         end
       end
-      if ( nbnlc > 0 ) then
-        // Set the index, so that, if an additionnal cost function argument is provided,
-        // it can be appended at the end.
-        index = 1;
-        [ this , fe ] = neldermead_function ( this , xe , index );
-      else
-        [ this , fe ] = neldermead_function ( this , xe );
-      end
+      [ this , fe ] = neldermead_function ( this , xe );
       this = neldermead_log (this,sprintf("xe=[%s], f(xe)=%f", strcat(string(xe)," ") , fe ));
       if (fe < fr) then
         this = neldermead_log (this,sprintf("  > Perform Expansion"));
         simplex = optimsimplex_setve ( simplex , ihigh , fe , xe )
+        step = "expansion";
       else
         this = neldermead_log (this,sprintf("  > Perform reflection"));
         simplex = optimsimplex_setve ( simplex , ihigh , fr , xr )
+        step = "reflection";
       end
     elseif ( fr >= fn & fr < fhigh ) then
       // Outside contraction
@@ -993,22 +1007,17 @@ function this = neldermead_box ( this )
           break
         end
       end
-      if ( nbnlc > 0 ) then
-        // Set the index, so that, if an additionnal cost function argument is provided,
-        // it can be appended at the end.
-        index = 1;
-        [ this , fc ] = neldermead_function ( this , xc , index );
-      else
-        [ this , fc ] = neldermead_function ( this , xc );
-      end
+      [ this , fc ] = neldermead_function ( this , xc );
       this = neldermead_log (this,sprintf("xc=[%s], f(xc)=%f", strcat(string(xc)," ") , fc));
       if ( fc <= fr ) then
         this = neldermead_log (this,sprintf("  > Perform Outside Contraction"));
         simplex = optimsimplex_setve ( simplex , ihigh , fc , xc )
+        step = "outsidecontraction";
       else
         //  Shrink
         this = neldermead_log (this,sprintf("  > Perform Shrink"));
         [ simplex , this ] = optimsimplex_shrink ( simplex , neldermead_costf , this.sigma , this );
+        step = "shrink";
       end
     else
       // ( fr >= fn & fr >= fhigh )  
@@ -1023,22 +1032,17 @@ function this = neldermead_box ( this )
           break
         end
       end
-      if ( nbnlc > 0 ) then
-        // Set the index, so that, if an additionnal cost function argument is provided,
-        // it can be appended at the end.
-        index = 1;
-        [ this , fc ] = neldermead_function ( this , xc , index );
-      else
-        [ this , fc ] = neldermead_function ( this , xc );
-      end
+      [ this , fc ] = neldermead_function ( this , xc );
       this = neldermead_log (this,sprintf("xc=[%s], f(xc)=%f", strcat(string(xc)," ") , fc));
       if ( fc < fhigh ) then
         this = neldermead_log (this,sprintf("  > Perform Inside Contraction"));
         simplex = optimsimplex_setve ( simplex , ihigh , fc , xc )
+        step = "insidecontraction";
       else
         //  Shrink
         this = neldermead_log (this,sprintf("  > Perform Shrink"));
         [ simplex , this ] = optimsimplex_shrink ( simplex , neldermead_costf , this.sigma , this )
+        step = "shrink";
       end
     end
     //
diff --git a/scilab/modules/optimization/macros/neldermead/nmplot_function.sci b/scilab/modules/optimization/macros/neldermead/nmplot_function.sci
new file mode 100644 (file)
index 0000000..2121a72
--- /dev/null
@@ -0,0 +1,42 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2009 - INRIA - Michael Baudin
+//
+// This file must be used under the terms of the CeCILL.
+// This source file is licensed as described in the file COPYING, which
+// you should have received as part of this distribution.  The terms
+// are also available at
+// http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+
+//
+// nmplot_function --
+//   Call the cost function and return the value.
+// Arguments
+//   x : the point where the function is to be evaluated.
+//   index : a flag to pass to the cost function (default = 1)
+//   result : the result of the cost function
+//     This result may be the value of the cost function, the 
+//     values are the inequality constraints, the values of the 
+//     gradient of f or of the constraints, etc...
+// Note
+//  The following protocol is used
+//  * if index=1, or no index, returns the value of the cost 
+//    function (default case)
+//  * if index=2, returns the value of the nonlinear inequality 
+//    constraints, as a row array
+//  * if index=3, returns an array which contains
+//    at index #0, the value of the cost function  
+//    at index #1 to the end is the list of the values of the nonlinear 
+//    constraints
+//  The inequality constraints are expected to be positive.
+//
+// Note
+//   This is the function which is used internally
+//   by the neldermead class.
+//
+function [ this , result ] = nmplot_function ( this , x , index )
+  if (~isdef('index','local')) then
+    [ this.nmbase , result ] = neldermead_function ( this.nmbase , x )
+  else
+    [ this.nmbase , result ] = neldermead_function ( this.nmbase , x , index )
+  end
+endfunction