various corrections on help pages
[scilab.git] / scilab / modules / optimization / help / en_US / optimsimplex / optimsimplex.xml
1 <?xml version="1.0" encoding="ISO-8859-1"?>
2 <!--
3  * Ajouter ici d'éventuels commentaires sur le fichier XML
4 -->
5 <refentry version="5.0-subset Scilab" xml:id="optimsimplex" xml:lang="fr"
6           xmlns="http://docbook.org/ns/docbook"
7           xmlns:xlink="http://www.w3.org/1999/xlink"
8           xmlns:svg="http://www.w3.org/2000/svg"
9           xmlns:ns4="http://www.w3.org/1999/xhtml"
10           xmlns:mml="http://www.w3.org/1998/Math/MathML"
11           xmlns:db="http://docbook.org/ns/docbook">
12   <info>
13     <pubdate>$LastChangedDate: 16-12-2008 $</pubdate>
14   </info>
15
16   <refnamediv>
17     <refname>optimsimplex</refname>
18
19     <refpurpose>Manage a simplex with arbitrary number of points.</refpurpose>
20   </refnamediv>
21
22   <refsynopsisdiv>
23     <title>SYNOPSIS</title>
24
25     <synopsis>[ newobj , data ] = optimsimplex_new ( coords , fun , data )
26 this = optimsimplex_destroy (this)
27 [ this , data ] = optimsimplex_axes ( this , x0 , fun , len , data )
28 [ this , data ] = optimsimplex_pfeffer ( this , x0 , fun , deltausual , deltazero , data )
29 [ this , data ] = optimsimplex_randbounds ( this , x0 , fun , boundsmin , boundsmax , nbpoints  , data )
30 [ this , data ] = optimsimplex_spendley ( this , x0 , fun , len , data )
31 this = optimsimplex_setall ( this , simplex )
32 this = optimsimplex_setallfv ( this , fv )
33 this = optimsimplex_setallx ( this , x )
34 this = optimsimplex_setfv ( this , ive , fv )
35 this = optimsimplex_setn ( this , n )
36 this = optimsimplex_setnbve ( this , nbve )
37 this = optimsimplex_setve ( this , ive , fv , x )
38 this = optimsimplex_setx ( this , ive , x )
39 simplex = optimsimplex_getall ( this )
40 fv = optimsimplex_getallfv ( this )
41 x = optimsimplex_getallx ( this )
42 fv = optimsimplex_getfv ( this , ive )
43 n = optimsimplex_getn ( this )
44 n = optimsimplex_getnbve ( this )
45 vertex = optimsimplex_getve ( this , ive )
46 x = optimsimplex_getx ( this , ive )
47 sicenter = optimsimplex_center ( this )
48 optimsimplex_check ( this )
49 [ this , data ] = optimsimplex_computefv ( this , fun , data )
50 df = optimsimplex_deltafv ( this )
51 dfm = optimsimplex_deltafvmax ( this )
52 m = optimsimplex_dirmat ( this )
53 sd = optimsimplex_fvmean ( this )
54 sd = optimsimplex_fvstdev ( this )
55 [ g , data ] = optimsimplex_gradientfv ( this , fun , method , data )
56 g = optimsimplex_gradforward ( this )
57 [ g , data ] = optimsimplex_gradcentered ( this , fun , data )
58 [ ns , data ] = optimsimplex_oriented ( this , fun , data )
59 optimsimplex_print ( this )
60 [ r , data ] = optimsimplex_reflect ( this , fun , data )
61 [ this , data ] = optimsimplex_shrink ( this , fun , sigma , data )
62 ssize = optimsimplex_size ( this , method )
63 this = optimsimplex_sort ( this )
64 str = optimsimplex_tostring ( this )
65 cen = optimsimplex_xbar ( this , iexcl )</synopsis>
66   </refsynopsisdiv>
67
68   <refsection>
69     <title>Purpose</title>
70
71     <para>
72       The goal of this component is to provide a building block for
73       optimization algorithms based on a simplex. The optimsimplex package may
74       be used in the following optimization methods :</para>
75     <itemizedlist>
76         <listitem>
77           <para>the Spendley et al. simplex method,</para>
78         </listitem>
79
80         <listitem>
81           <para>the Nelder-Mead method,</para>
82         </listitem>
83
84         <listitem>
85           <para>the Box algorithm for constrained optimization,</para>
86         </listitem>
87
88         <listitem>
89           <para>the multi-dimensional search by Virginia Torczon,</para>
90         </listitem>
91
92         <listitem>
93           <para>etc ...</para>
94         </listitem>
95     </itemizedlist>
96   </refsection>
97
98   <refsection>
99     <title>Design</title>
100
101     <para>This toolbox is designed with Oriented Object ideas in mind.</para>
102   </refsection>
103
104   <refsection>
105     <title>Features</title>
106
107     <para>The following is a list of features the Nelder-Mead prototype
108     algorithm currently provides :</para>
109
110     <itemizedlist>
111       <listitem>
112         <para>Manage various simplex initializations</para>
113
114         <itemizedlist>
115           <listitem>
116             <para>initial simplex given by user,</para>
117           </listitem>
118
119           <listitem>
120             <para>initial simplex computed with a length and along the
121             coordinate axes,</para>
122           </listitem>
123
124           <listitem>
125             <para>initial regular simplex computed with Spendley et al.
126             formula,</para>
127           </listitem>
128
129           <listitem>
130             <para>initial simplex computed by a small perturbation around the
131             initial guess point,</para>
132           </listitem>
133
134           <listitem>
135             <para>initial simplex computed from randomized bounds.</para>
136           </listitem>
137         </itemizedlist>
138       </listitem>
139
140       <listitem>
141         <para>sort the vertices by increasing function values,</para>
142       </listitem>
143
144       <listitem>
145         <para>compute the standard deviation of the function values in the
146         simplex,</para>
147       </listitem>
148
149       <listitem>
150         <para>compute the simplex gradient with forward or centered
151         differences,</para>
152       </listitem>
153
154       <listitem>
155         <para>shrink the simplex toward the best vertex,</para>
156       </listitem>
157
158       <listitem>
159         <para>etc...</para>
160       </listitem>
161     </itemizedlist>
162   </refsection>
163
164   <refsection>
165     <title>Description</title>
166
167     <para>This set of commands allows to manage a simplex made of k&gt;=n+1
168     points in a n-dimensional space. This component is the building block for
169     a class of direct search optimization methods such as the Nelder-Mead
170     algorithm or Torczon's Multi-Dimensionnal Search.</para>
171
172     <para>A simplex is designed as a collection of k&gt;=n+1 vertices. Each
173     vertex is made of a point and a function value at that point.</para>
174
175     <para>The simplex can be created with various shapes. It can be configured
176     and quieried at will. The simplex can also be reflected or shrinked. The
177     simplex gradient can be computed with a order 1 forward formula and with a
178     order 2 centered formula.</para>
179
180     <para>The optimsimplex_new function allows to create a simplex. If vertices
181     coordinates are given, there are registered in the simplex. If a function
182     is provided, it is evaluated at each vertex. The optimsimplex_destroy function
183     destroys the object and frees internal memory. Several functions allow to
184     create a simplex with special shapes, including axes-by-axes
185     (optimsimplex_axes), regular (optimsimplex_spendley), randomized bounds simplex with
186     arbitrary k vertices (optimsimplex_randbounds) and an heuristical small
187     variation around a given point (optimsimplex_pfeffer).</para>
188   </refsection>
189
190   <refsection>
191     <title>Functions</title>
192
193     <para>The following functions are available.</para>
194
195     <variablelist>
196       <varlistentry>
197         <term>[ newobj , data ] = optimsimplex_new ( coords , fun , data )</term>
198
199         <listitem>
200           <para>Creates a new simplex object. All input arguments are
201           optional. If no input argument is provided, returns an empty simplex
202           object.</para>
203
204           <variablelist>
205             <varlistentry>
206               <term>newobj</term>
207
208               <listitem>
209                 <para>The new object.</para>
210               </listitem>
211             </varlistentry>
212
213             <varlistentry>
214               <term>coords</term>
215
216               <listitem>
217                 <para>optional, matrix of point coordinates in the
218                 simplex.</para>
219
220                 <para>The coords matrix is expected to be a n x k matrix,
221                 where n is the dimension of the space and k is the number of
222                 vertices in the simplex, with k&gt;= n+1.</para>
223               </listitem>
224             </varlistentry>
225
226             <varlistentry>
227               <term>fun</term>
228
229               <listitem>
230                 <para>optional, the function to compute at vertices.</para>
231
232                 <para>The function is expected to have the following input and
233                 output arguments :</para>
234
235                 <programlisting role="example"><![CDATA[ 
236 function y = myfunction (x)
237  ]]></programlisting>
238               </listitem>
239             </varlistentry>
240
241             <varlistentry>
242               <term>data</term>
243
244               <listitem>
245                 <para>optional, user-defined data passed to the
246                 function.</para>
247
248                 <para>If data is provided, it is passed to the callback
249                 function both as an input and output argument. In that case,
250                 the function must have the following header :</para>
251
252                 <programlisting role="example"><![CDATA[ 
253 function [ y , data ] = myfunction ( x , data )
254  ]]></programlisting>
255
256                 <para>The data input parameter may be used if the function
257                 uses some additionnal parameters. It is returned as an output
258                 parameter because the function may modify the data while
259                 computing the function value. This feature may be used, for
260                 example, to count the number of times that the function has
261                 been called.</para>
262               </listitem>
263             </varlistentry>
264           </variablelist>
265         </listitem>
266       </varlistentry>
267
268       <varlistentry>
269         <term>this = optimsimplex_destroy (this)</term>
270
271         <listitem>
272           <para>Destroy the given object.</para>
273
274           <variablelist>
275             <varlistentry>
276               <term>this</term>
277
278               <listitem>
279                 <para>The current simplex object.</para>
280               </listitem>
281             </varlistentry>
282           </variablelist>
283         </listitem>
284       </varlistentry>
285
286       <varlistentry>
287         <term>[ this , data ] = optimsimplex_axes ( this , x0 , fun , len , data
288         )</term>
289
290         <listitem>
291           <para>Configure the current simplex so that it is computed axis by
292           axis, with the given length.</para>
293
294           <variablelist>
295             <varlistentry>
296               <term>this</term>
297
298               <listitem>
299                 <para>The current simplex object.</para>
300               </listitem>
301             </varlistentry>
302
303             <varlistentry>
304               <term>x0</term>
305
306               <listitem>
307                 <para>the initial point, as a row vector.</para>
308               </listitem>
309             </varlistentry>
310
311             <varlistentry>
312               <term>fun</term>
313
314               <listitem>
315                 <para>optional, the function to compute at vertices.</para>
316
317                 <para>The function is expected to have the following input and
318                 output arguments :</para>
319
320                 <programlisting role="example"><![CDATA[ 
321 function y = myfunction (x)
322  ]]></programlisting>
323               </listitem>
324             </varlistentry>
325
326             <varlistentry>
327               <term>len</term>
328
329               <listitem>
330                 <para>optional, the length of the simplex. The default length
331                 is 1.0. If length is a value, that unique length is used in
332                 all directions. If length is a vector with n values, each
333                 length is used with the corresponding direction.</para>
334               </listitem>
335             </varlistentry>
336
337             <varlistentry>
338               <term>data</term>
339
340               <listitem>
341                 <para>optional, user-defined data passed to the
342                 function.</para>
343
344                 <para>If data is provided, it is passed to the callback
345                 function both as an input and output argument. In that case,
346                 the function must have the following header :</para>
347
348                 <programlisting role="example"><![CDATA[ 
349 function [ y , data ] = myfunction ( x , data )
350  ]]></programlisting>
351
352                 <para>The data input parameter may be used if the function
353                 uses some additionnal parameters. It is returned as an output
354                 parameter because the function may modify the data while
355                 computing the function value. This feature may be used, for
356                 example, to count the number of times that the function has
357                 been called.</para>
358               </listitem>
359             </varlistentry>
360           </variablelist>
361         </listitem>
362       </varlistentry>
363
364       <varlistentry>
365         <term>[ this , data ] = optimsimplex_pfeffer ( this , x0 , fun , deltausual
366         , deltazero , data )</term>
367
368         <listitem>
369           <para>Configure the current simplex so that it is computed from
370           Pfeffer's method, i.e. a relative delta for non-zero values and an
371           absolute delta for zero values.</para>
372
373           <variablelist>
374             <varlistentry>
375               <term>this</term>
376
377               <listitem>
378                 <para>The current simplex object.</para>
379               </listitem>
380             </varlistentry>
381
382             <varlistentry>
383               <term>x0</term>
384
385               <listitem>
386                 <para>the initial point, as a row vector.</para>
387               </listitem>
388             </varlistentry>
389
390             <varlistentry>
391               <term>fun</term>
392
393               <listitem>
394                 <para>optional, the function to compute at vertices.</para>
395
396                 <para>The function is expected to have the following input and
397                 output arguments :</para>
398
399                 <programlisting role="example"><![CDATA[ 
400 function y = myfunction (x)
401  ]]></programlisting>
402               </listitem>
403             </varlistentry>
404
405             <varlistentry>
406               <term>deltausual</term>
407
408               <listitem>
409                 <para>optional, the absolute delta for non-zero values. The
410                 default value is 0.05.</para>
411               </listitem>
412             </varlistentry>
413
414             <varlistentry>
415               <term>deltazero</term>
416
417               <listitem>
418                 <para>optional, the absolute delta for zero values. The
419                 default value is 0.0075.</para>
420               </listitem>
421             </varlistentry>
422
423             <varlistentry>
424               <term>data</term>
425
426               <listitem>
427                 <para>optional, user-defined data passed to the
428                 function.</para>
429
430                 <para>If data is provided, it is passed to the callback
431                 function both as an input and output argument. In that case,
432                 the function must have the following header :</para>
433
434                 <programlisting role="example"><![CDATA[ 
435 function [ y , data ] = myfunction ( x , data )
436  ]]></programlisting>
437
438                 <para>The data input parameter may be used if the function
439                 uses some additionnal parameters. It is returned as an output
440                 parameter because the function may modify the data while
441                 computing the function value. This feature may be used, for
442                 example, to count the number of times that the function has
443                 been called.</para>
444               </listitem>
445             </varlistentry>
446           </variablelist>
447         </listitem>
448       </varlistentry>
449
450       <varlistentry>
451         <term>[ this , data ] = optimsimplex_randbounds ( this , x0 , fun ,
452         boundsmin , boundsmax , nbpoints , data )</term>
453
454         <listitem>
455           <para>Configure the current simplex so that it is computed by taking
456           the bounds into account with random scaling. The number of vertices
457           in the simplex is arbitrary.</para>
458
459           <variablelist>
460             <varlistentry>
461               <term>this</term>
462
463               <listitem>
464                 <para>The current simplex object.</para>
465               </listitem>
466             </varlistentry>
467
468             <varlistentry>
469               <term>x0</term>
470
471               <listitem>
472                 <para>the initial point, as a row vector. It is the first
473                 vertex in the simplex.</para>
474               </listitem>
475             </varlistentry>
476
477             <varlistentry>
478               <term>fun</term>
479
480               <listitem>
481                 <para>optional, the function to compute at vertices.</para>
482
483                 <para>The function is expected to have the following input and
484                 output arguments :</para>
485
486                 <programlisting role="example"><![CDATA[ 
487 function y = myfunction (x)
488  ]]></programlisting>
489               </listitem>
490             </varlistentry>
491
492             <varlistentry>
493               <term>boundsmin</term>
494
495               <listitem>
496                 <para>array of minimum bounds</para>
497               </listitem>
498             </varlistentry>
499
500             <varlistentry>
501               <term>boundsmax</term>
502
503               <listitem>
504                 <para>array of maximum bounds</para>
505
506                 <para>Each component ix =1 , n of the vertex #jve = 2,k is
507                 computed from the formula :</para>
508
509                 <programlisting role="example"><![CDATA[ 
510 x ( ix , jve ) = boundsmin( ix ) + rand() * (boundsmax( ix ) - boundsmin( ix ))
511  ]]></programlisting>
512               </listitem>
513             </varlistentry>
514
515             <varlistentry>
516               <term>nbpoints</term>
517
518               <listitem>
519                 <para>total number of points in the simplex</para>
520               </listitem>
521             </varlistentry>
522
523             <varlistentry>
524               <term>data</term>
525
526               <listitem>
527                 <para>optional, user-defined data passed to the
528                 function.</para>
529
530                 <para>If data is provided, it is passed to the callback
531                 function both as an input and output argument. In that case,
532                 the function must have the following header :</para>
533
534                 <programlisting role="example"><![CDATA[ 
535 function [ y , data ] = myfunction ( x , data )
536  ]]></programlisting>
537
538                 <para>The data input parameter may be used if the function
539                 uses some additionnal parameters. It is returned as an output
540                 parameter because the function may modify the data while
541                 computing the function value. This feature may be used, for
542                 example, to count the number of times that the function has
543                 been called.</para>
544               </listitem>
545             </varlistentry>
546           </variablelist>
547         </listitem>
548       </varlistentry>
549
550       <varlistentry>
551         <term>[ this , data ] = optimsimplex_spendley ( this , x0 , fun , len ,
552         data )</term>
553
554         <listitem>
555           <para>Configure the current simplex so that it is computed from
556           Spendley's et al. method, i.e. a regular simplex made of k = n+1
557           vertices.</para>
558
559           <variablelist>
560             <varlistentry>
561               <term>this</term>
562
563               <listitem>
564                 <para>The current simplex object.</para>
565               </listitem>
566             </varlistentry>
567
568             <varlistentry>
569               <term>x0</term>
570
571               <listitem>
572                 <para>the initial point, as a row vector.</para>
573               </listitem>
574             </varlistentry>
575
576             <varlistentry>
577               <term>fun</term>
578
579               <listitem>
580                 <para>optional, the function to compute at vertices.</para>
581
582                 <para>The function is expected to have the following input and
583                 output arguments :</para>
584
585                 <programlisting role="example"><![CDATA[ 
586 function y = myfunction (x)
587  ]]></programlisting>
588               </listitem>
589             </varlistentry>
590
591             <varlistentry>
592               <term>len</term>
593
594               <listitem>
595                 <para>optional, the length of the simplex. The default length
596                 is 1.0.</para>
597               </listitem>
598             </varlistentry>
599
600             <varlistentry>
601               <term>data</term>
602
603               <listitem>
604                 <para>optional, user-defined data passed to the
605                 function.</para>
606
607                 <para>If data is provided, it is passed to the callback
608                 function both as an input and output argument. In that case,
609                 the function must have the following header :</para>
610
611                 <programlisting role="example"><![CDATA[ 
612 function [ y , data ] = myfunction ( x , data )
613  ]]></programlisting>
614
615                 <para>The data input parameter may be used if the function
616                 uses some additionnal parameters. It is returned as an output
617                 parameter because the function may modify the data while
618                 computing the function value. This feature may be used, for
619                 example, to count the number of times that the function has
620                 been called.</para>
621               </listitem>
622             </varlistentry>
623           </variablelist>
624         </listitem>
625       </varlistentry>
626
627       <varlistentry>
628         <term>this = optimsimplex_setall ( this , simplex )</term>
629
630         <listitem>
631           <para>Set all the coordinates and and the function values of all the
632           vertices.</para>
633
634           <variablelist>
635             <varlistentry>
636               <term>this</term>
637
638               <listitem>
639                 <para>The current simplex object.</para>
640               </listitem>
641             </varlistentry>
642
643             <varlistentry>
644               <term>simplex</term>
645
646               <listitem>
647                 <para>the simplex to set.</para>
648
649                 <para>The given matrix is expected to be a nbve x n+1 matrix
650                 where n is the dimension of the space, nbve is the number of
651                 vertices and with the following content (where the data is
652                 organized by row with function value first, and x
653                 coordinates)</para>
654
655                 <itemizedlist>
656                   <listitem>
657                     <para>simplex(k,1) is the function value of the vertex #k,
658                     with k = 1 , nbve</para>
659                   </listitem>
660
661                   <listitem>
662                     <para>simplex(k,2:n+1) is the coordinates of the vertex
663                     #k, with k = 1 , nbve</para>
664                   </listitem>
665                 </itemizedlist>
666               </listitem>
667             </varlistentry>
668           </variablelist>
669         </listitem>
670       </varlistentry>
671
672       <varlistentry>
673         <term>this = optimsimplex_setallfv ( this , fv )</term>
674
675         <listitem>
676           <para>Set all the function values of all the vertices. The vertex #k
677           is expected to be stored in fv(k) with k = 1 , nbve</para>
678
679           <variablelist>
680             <varlistentry>
681               <term>this</term>
682
683               <listitem>
684                 <para>The current simplex object.</para>
685               </listitem>
686             </varlistentry>
687
688             <varlistentry>
689               <term>fv</term>
690
691               <listitem>
692                 <para>the array of function values</para>
693               </listitem>
694             </varlistentry>
695           </variablelist>
696         </listitem>
697       </varlistentry>
698
699       <varlistentry>
700         <term>this = optimsimplex_setallx ( this , x )</term>
701
702         <listitem>
703           <para>Set all the coordinates of all the vertices. The vertex #k is
704           expected to be stored in x(1:n,k) with k = 1 , nbve</para>
705
706           <variablelist>
707             <varlistentry>
708               <term>this</term>
709
710               <listitem>
711                 <para>The current simplex object.</para>
712               </listitem>
713             </varlistentry>
714
715             <varlistentry>
716               <term>x</term>
717
718               <listitem>
719                 <para>the coordinates of the vertices.</para>
720               </listitem>
721             </varlistentry>
722           </variablelist>
723         </listitem>
724       </varlistentry>
725
726       <varlistentry>
727         <term>this = optimsimplex_setfv ( this , ive , fv )</term>
728
729         <listitem>
730           <para>Set the function value at given index and // returns an
731           updated simplex.</para>
732
733           <variablelist>
734             <varlistentry>
735               <term>this</term>
736
737               <listitem>
738                 <para>The current simplex object.</para>
739               </listitem>
740             </varlistentry>
741
742             <varlistentry>
743               <term>ive</term>
744
745               <listitem>
746                 <para>vertex index</para>
747               </listitem>
748             </varlistentry>
749
750             <varlistentry>
751               <term>fv</term>
752
753               <listitem>
754                 <para>the function value</para>
755               </listitem>
756             </varlistentry>
757           </variablelist>
758         </listitem>
759       </varlistentry>
760
761       <varlistentry>
762         <term>this = optimsimplex_setn ( this , n )</term>
763
764         <listitem>
765           <para>Set the dimension of the space of the simplex.</para>
766
767           <variablelist>
768             <varlistentry>
769               <term>this</term>
770
771               <listitem>
772                 <para>The current simplex object.</para>
773               </listitem>
774             </varlistentry>
775
776             <varlistentry>
777               <term>n</term>
778
779               <listitem>
780                 <para>the dimension</para>
781               </listitem>
782             </varlistentry>
783           </variablelist>
784         </listitem>
785       </varlistentry>
786
787       <varlistentry>
788         <term>this = optimsimplex_setnbve ( this , nbve )</term>
789
790         <listitem>
791           <para>Set the number of vertices of the simplex.</para>
792
793           <variablelist>
794             <varlistentry>
795               <term>this</term>
796
797               <listitem>
798                 <para>The current simplex object.</para>
799               </listitem>
800             </varlistentry>
801
802             <varlistentry>
803               <term>nbve</term>
804
805               <listitem>
806                 <para>the number of vertices</para>
807               </listitem>
808             </varlistentry>
809           </variablelist>
810         </listitem>
811       </varlistentry>
812
813       <varlistentry>
814         <term>this = optimsimplex_setve ( this , ive , fv , x )</term>
815
816         <listitem>
817           <para>Sets the coordinates of the vertex and the function value at
818           given index in the current simplex.</para>
819
820           <variablelist>
821             <varlistentry>
822               <term>this</term>
823
824               <listitem>
825                 <para>The current simplex object.</para>
826               </listitem>
827             </varlistentry>
828
829             <varlistentry>
830               <term>ive</term>
831
832               <listitem>
833                 <para>the vertex index</para>
834               </listitem>
835             </varlistentry>
836
837             <varlistentry>
838               <term>fv</term>
839
840               <listitem>
841                 <para>the function value</para>
842               </listitem>
843             </varlistentry>
844
845             <varlistentry>
846               <term>x</term>
847
848               <listitem>
849                 <para>the coordinates of the point, as a column vector</para>
850               </listitem>
851             </varlistentry>
852           </variablelist>
853         </listitem>
854       </varlistentry>
855
856       <varlistentry>
857         <term>this = optimsimplex_setx ( this , ive , x )</term>
858
859         <listitem>
860           <para>Set the coordinates of the vertex at given index, as a column
861           vector, into the current simplex.</para>
862
863           <variablelist>
864             <varlistentry>
865               <term>this</term>
866
867               <listitem>
868                 <para>The current simplex object.</para>
869               </listitem>
870             </varlistentry>
871
872             <varlistentry>
873               <term>ive</term>
874
875               <listitem>
876                 <para>the vertex index</para>
877               </listitem>
878             </varlistentry>
879
880             <varlistentry>
881               <term>x</term>
882
883               <listitem>
884                 <para>the coordinates of the point, as a column vector</para>
885               </listitem>
886             </varlistentry>
887           </variablelist>
888         </listitem>
889       </varlistentry>
890
891       <varlistentry>
892         <term>simplex = optimsimplex_getall ( this )</term>
893
894         <listitem>
895           <para>Returns all the coordinates of all the vertices and the
896           function values in the same matrix.</para>
897
898           <variablelist>
899             <varlistentry>
900               <term>this</term>
901
902               <listitem>
903                 <para>The current simplex object.</para>
904               </listitem>
905             </varlistentry>
906
907             <varlistentry>
908               <term>simplex</term>
909
910               <listitem>
911                 <para>the simplex data.</para>
912
913                 <para>The simplex matrix has size nbve x n+1, and is organized
914                 by row by row as follows :</para>
915
916                 <itemizedlist>
917                   <listitem>
918                     <para>simplex(k,1) is the function value of the vertex #k,
919                     with k = 1 , nbve</para>
920                   </listitem>
921
922                   <listitem>
923                     <para>simplex(k,2:n+1) is the coordinates of the vertex
924                     #k, with k = 1 , nbve</para>
925                   </listitem>
926                 </itemizedlist>
927               </listitem>
928             </varlistentry>
929           </variablelist>
930         </listitem>
931       </varlistentry>
932
933       <varlistentry>
934         <term>fv = optimsimplex_getallfv ( this )</term>
935
936         <listitem>
937           <para>Returns all the function values of all the vertices, as a
938           column vector.</para>
939
940           <variablelist>
941             <varlistentry>
942               <term>this</term>
943
944               <listitem>
945                 <para>The current simplex object.</para>
946               </listitem>
947             </varlistentry>
948
949             <varlistentry>
950               <term>fv</term>
951
952               <listitem>
953                 <para>The array of function values. The function value of
954                 vertex #k is stored in fv(k) with k = 1 , nbve.</para>
955               </listitem>
956             </varlistentry>
957           </variablelist>
958         </listitem>
959       </varlistentry>
960
961       <varlistentry>
962         <term>x = optimsimplex_getallx ( this )</term>
963
964         <listitem>
965           <para>Returns all the coordinates of all the vertices.</para>
966
967           <variablelist>
968             <varlistentry>
969               <term>this</term>
970
971               <listitem>
972                 <para>The current simplex object.</para>
973               </listitem>
974             </varlistentry>
975
976             <varlistentry>
977               <term>x</term>
978
979               <listitem>
980                 <para>the coordinates.</para>
981
982                 <para>The vertex #k is stored in x(1:n,k) with k = 1 ,
983                 nbve.</para>
984               </listitem>
985             </varlistentry>
986           </variablelist>
987         </listitem>
988       </varlistentry>
989
990       <varlistentry>
991         <term>fv = optimsimplex_getfv ( this , ive )</term>
992
993         <listitem>
994           <para>Returns the function value at given index</para>
995
996           <variablelist>
997             <varlistentry>
998               <term>this</term>
999
1000               <listitem>
1001                 <para>The current simplex object.</para>
1002               </listitem>
1003             </varlistentry>
1004
1005             <varlistentry>
1006               <term>ive</term>
1007
1008               <listitem>
1009                 <para>the vertex index</para>
1010               </listitem>
1011             </varlistentry>
1012           </variablelist>
1013         </listitem>
1014       </varlistentry>
1015
1016       <varlistentry>
1017         <term>n = optimsimplex_getn ( this )</term>
1018
1019         <listitem>
1020           <para>Returns the dimension of the space of the simplex</para>
1021
1022           <variablelist>
1023             <varlistentry>
1024               <term>this</term>
1025
1026               <listitem>
1027                 <para>The current simplex object.</para>
1028               </listitem>
1029             </varlistentry>
1030           </variablelist>
1031         </listitem>
1032       </varlistentry>
1033
1034       <varlistentry>
1035         <term>n = optimsimplex_getnbve ( this )</term>
1036
1037         <listitem>
1038           <para>Returns the number of vertices in the simplex.</para>
1039
1040           <variablelist>
1041             <varlistentry>
1042               <term>this</term>
1043
1044               <listitem>
1045                 <para>The current simplex object.</para>
1046               </listitem>
1047             </varlistentry>
1048           </variablelist>
1049         </listitem>
1050       </varlistentry>
1051
1052       <varlistentry>
1053         <term>vertex = optimsimplex_getve ( this , ive )</term>
1054
1055         <listitem>
1056           <para>Returns the vertex at given index as a tlist, with fields n, x
1057           and fv</para>
1058
1059           <variablelist>
1060             <varlistentry>
1061               <term>this</term>
1062
1063               <listitem>
1064                 <para>The current simplex object.</para>
1065               </listitem>
1066             </varlistentry>
1067
1068             <varlistentry>
1069               <term>ive</term>
1070
1071               <listitem>
1072                 <para>the vertex index</para>
1073               </listitem>
1074             </varlistentry>
1075           </variablelist>
1076         </listitem>
1077       </varlistentry>
1078
1079       <varlistentry>
1080         <term>x = optimsimplex_getx ( this , ive )</term>
1081
1082         <listitem>
1083           <para>Returns the coordinates of the vertex at given index, as a
1084           column vector.</para>
1085
1086           <variablelist>
1087             <varlistentry>
1088               <term>this</term>
1089
1090               <listitem>
1091                 <para>The current simplex object.</para>
1092               </listitem>
1093             </varlistentry>
1094
1095             <varlistentry>
1096               <term>ive</term>
1097
1098               <listitem>
1099                 <para>the vertex index</para>
1100               </listitem>
1101             </varlistentry>
1102           </variablelist>
1103         </listitem>
1104       </varlistentry>
1105
1106       <varlistentry>
1107         <term>sicenter = optimsimplex_center ( this )</term>
1108
1109         <listitem>
1110           <para>Returns the center of the given simplex</para>
1111
1112           <variablelist>
1113             <varlistentry>
1114               <term>this</term>
1115
1116               <listitem>
1117                 <para>The current simplex object.</para>
1118               </listitem>
1119             </varlistentry>
1120           </variablelist>
1121         </listitem>
1122       </varlistentry>
1123
1124       <varlistentry>
1125         <term>optimsimplex_check ( this )</term>
1126
1127         <listitem>
1128           <para>Check the consistency of the internal data. Generates an error
1129           if necessary.</para>
1130
1131           <variablelist>
1132             <varlistentry>
1133               <term>this</term>
1134
1135               <listitem>
1136                 <para>The current simplex object.</para>
1137               </listitem>
1138             </varlistentry>
1139           </variablelist>
1140         </listitem>
1141       </varlistentry>
1142
1143       <varlistentry>
1144         <term>[ this , data ] = optimsimplex_computefv ( this , fun , data )</term>
1145
1146         <listitem>
1147           <para>Set the values of the function at vertices points.</para>
1148
1149           <variablelist>
1150             <varlistentry>
1151               <term>this</term>
1152
1153               <listitem>
1154                 <para>The current simplex object.</para>
1155               </listitem>
1156             </varlistentry>
1157
1158             <varlistentry>
1159               <term>fun</term>
1160
1161               <listitem>
1162                 <para>optional, the function to compute at vertices.</para>
1163
1164                 <para>The function is expected to have the following input and
1165                 output arguments :</para>
1166
1167                 <programlisting role="example"><![CDATA[ 
1168 function y = myfunction (x)
1169  ]]></programlisting>
1170               </listitem>
1171             </varlistentry>
1172
1173             <varlistentry>
1174               <term>data</term>
1175
1176               <listitem>
1177                 <para>optional, user-defined data passed to the
1178                 function.</para>
1179
1180                 <para>If data is provided, it is passed to the callback
1181                 function both as an input and output argument. In that case,
1182                 the function must have the following header :</para>
1183
1184                 <programlisting role="example"><![CDATA[ 
1185 function [ y , data ] = myfunction ( x , data )
1186  ]]></programlisting>
1187
1188                 <para>The data input parameter may be used if the function
1189                 uses some additionnal parameters. It is returned as an output
1190                 parameter because the function may modify the data while
1191                 computing the function value. This feature may be used, for
1192                 example, to count the number of times that the function has
1193                 been called.</para>
1194               </listitem>
1195             </varlistentry>
1196           </variablelist>
1197         </listitem>
1198       </varlistentry>
1199
1200       <varlistentry>
1201         <term>df = optimsimplex_deltafv ( this )</term>
1202
1203         <listitem>
1204           <para>Returns the vector of difference of function values with
1205           respect to the function value at vertex #1.</para>
1206
1207           <variablelist>
1208             <varlistentry>
1209               <term>this</term>
1210
1211               <listitem>
1212                 <para>The current simplex object.</para>
1213               </listitem>
1214             </varlistentry>
1215           </variablelist>
1216         </listitem>
1217       </varlistentry>
1218
1219       <varlistentry>
1220         <term>dfm = optimsimplex_deltafvmax ( this )</term>
1221
1222         <listitem>
1223           <para>Returns the difference of function value between the high and
1224           the low vertices. It is expected that the vertex #1 is associated
1225           with the smallest function value and that the vertex #nbve is
1226           associated with the highest function value. Since vertices are
1227           ordered, the high is greater than the low.</para>
1228
1229           <variablelist>
1230             <varlistentry>
1231               <term>this</term>
1232
1233               <listitem>
1234                 <para>The current simplex object.</para>
1235               </listitem>
1236             </varlistentry>
1237           </variablelist>
1238         </listitem>
1239       </varlistentry>
1240
1241       <varlistentry>
1242         <term>m = optimsimplex_dirmat ( this )</term>
1243
1244         <listitem>
1245           <para>Returns the n x n matrix of simplex directions i.e. the matrix
1246           of differences of vertices coordinates with respect to the vertex
1247           #1.</para>
1248
1249           <variablelist>
1250             <varlistentry>
1251               <term>this</term>
1252
1253               <listitem>
1254                 <para>The current simplex object.</para>
1255               </listitem>
1256             </varlistentry>
1257           </variablelist>
1258         </listitem>
1259       </varlistentry>
1260
1261       <varlistentry>
1262         <term>sd = optimsimplex_fvmean ( this )</term>
1263
1264         <listitem>
1265           <para>Returns the mean of the function value on the simplex.</para>
1266
1267           <variablelist>
1268             <varlistentry>
1269               <term>this</term>
1270
1271               <listitem>
1272                 <para>The current simplex object.</para>
1273               </listitem>
1274             </varlistentry>
1275           </variablelist>
1276         </listitem>
1277       </varlistentry>
1278
1279       <varlistentry>
1280         <term>sd = optimsimplex_fvstdev ( this )</term>
1281
1282         <listitem>
1283           <para>Returns the standard deviation of the function value on the
1284           simplex.</para>
1285
1286           <variablelist>
1287             <varlistentry>
1288               <term>this</term>
1289
1290               <listitem>
1291                 <para>The current simplex object.</para>
1292               </listitem>
1293             </varlistentry>
1294           </variablelist>
1295         </listitem>
1296       </varlistentry>
1297
1298       <varlistentry>
1299         <term>[ g , data ] = optimsimplex_gradientfv ( this , fun , method , data
1300         )</term>
1301
1302         <listitem>
1303           <para>Returns the simplex gradient of the function.</para>
1304
1305           <variablelist>
1306             <varlistentry>
1307               <term>this</term>
1308
1309               <listitem>
1310                 <para>The current simplex object.</para>
1311               </listitem>
1312             </varlistentry>
1313
1314             <varlistentry>
1315               <term>fun</term>
1316
1317               <listitem>
1318                 <para>optional, the function to compute at vertices.</para>
1319
1320                 <para>The function is expected to have the following input and
1321                 output arguments :</para>
1322
1323                 <programlisting role="example"><![CDATA[ 
1324 function y = myfunction (x)
1325  ]]></programlisting>
1326               </listitem>
1327             </varlistentry>
1328
1329             <varlistentry>
1330               <term>method</term>
1331
1332               <listitem>
1333                 <para>optional, the method to use to compute the simplex
1334                 gradient. Two methods are available : "forward" or "centered".
1335                 The forward method uses the current simplex to compute the
1336                 simplex gradient. The centered method creates an intermediate
1337                 reflected simplex and computes the average.</para>
1338
1339                 <para>If not provided, the default method is "forward".</para>
1340               </listitem>
1341             </varlistentry>
1342
1343             <varlistentry>
1344               <term>data</term>
1345
1346               <listitem>
1347                 <para>optional, user-defined data passed to the
1348                 function.</para>
1349
1350                 <para>If data is provided, it is passed to the callback
1351                 function both as an input and output argument. In that case,
1352                 the function must have the following header :</para>
1353
1354                 <programlisting role="example"><![CDATA[ 
1355 function [ y , data ] = myfunction ( x , data )
1356  ]]></programlisting>
1357
1358                 <para>The data input parameter may be used if the function
1359                 uses some additionnal parameters. It is returned as an output
1360                 parameter because the function may modify the data while
1361                 computing the function value. This feature may be used, for
1362                 example, to count the number of times that the function has
1363                 been called.</para>
1364               </listitem>
1365             </varlistentry>
1366           </variablelist>
1367         </listitem>
1368       </varlistentry>
1369
1370       <varlistentry>
1371         <term>[ ns , data ] = optimsimplex_oriented ( this , fun , data )</term>
1372
1373         <listitem>
1374           <para>Returns a new oriented simplex, in sorted order. The new
1375           simplex has the same sigma- length of the base simplex, but is
1376           "oriented" depending on the function value. This simplex may be
1377           used, as Kelley suggests, for a restart of Nelder-Mead
1378           algorithm.</para>
1379
1380           <variablelist>
1381             <varlistentry>
1382               <term>this</term>
1383
1384               <listitem>
1385                 <para>The current simplex object.</para>
1386               </listitem>
1387             </varlistentry>
1388
1389             <varlistentry>
1390               <term>fun</term>
1391
1392               <listitem>
1393                 <para>optional, the function to compute at vertices.</para>
1394
1395                 <para>The function is expected to have the following input and
1396                 output arguments :</para>
1397
1398                 <programlisting role="example"><![CDATA[ 
1399 function y = myfunction (x)
1400  ]]></programlisting>
1401               </listitem>
1402             </varlistentry>
1403
1404             <varlistentry>
1405               <term>data</term>
1406
1407               <listitem>
1408                 <para>optional, user-defined data passed to the
1409                 function.</para>
1410
1411                 <para>If data is provided, it is passed to the callback
1412                 function both as an input and output argument. In that case,
1413                 the function must have the following header :</para>
1414
1415                 <programlisting role="example"><![CDATA[ 
1416 function [ y , data ] = myfunction ( x , data )
1417  ]]></programlisting>
1418
1419                 <para>The data input parameter may be used if the function
1420                 uses some additionnal parameters. It is returned as an output
1421                 parameter because the function may modify the data while
1422                 computing the function value. This feature may be used, for
1423                 example, to count the number of times that the function has
1424                 been called.</para>
1425               </listitem>
1426             </varlistentry>
1427           </variablelist>
1428         </listitem>
1429       </varlistentry>
1430
1431       <varlistentry>
1432         <term>optimsimplex_print ( this )</term>
1433
1434         <listitem>
1435           <para>Display the current simplex, with coordinates and function
1436           values.</para>
1437
1438           <variablelist>
1439             <varlistentry>
1440               <term>this</term>
1441
1442               <listitem>
1443                 <para>The current simplex object.</para>
1444               </listitem>
1445             </varlistentry>
1446           </variablelist>
1447         </listitem>
1448       </varlistentry>
1449
1450       <varlistentry>
1451         <term>[ r , data ] = optimsimplex_reflect ( this , fun , data )</term>
1452
1453         <listitem>
1454           <para>Returns a new simplex by reflexion of current simplex, by
1455           reflection with respect to the first vertex in the simplex. This
1456           move is used in the centered simplex gradient.</para>
1457
1458           <variablelist>
1459             <varlistentry>
1460               <term>this</term>
1461
1462               <listitem>
1463                 <para>The current simplex object.</para>
1464               </listitem>
1465             </varlistentry>
1466
1467             <varlistentry>
1468               <term>fun</term>
1469
1470               <listitem>
1471                 <para>optional, the function to compute at vertices.</para>
1472
1473                 <para>The function is expected to have the following input and
1474                 output arguments :</para>
1475
1476                 <programlisting role="example"><![CDATA[ 
1477 function y = myfunction (x)
1478  ]]></programlisting>
1479               </listitem>
1480             </varlistentry>
1481
1482             <varlistentry>
1483               <term>data</term>
1484
1485               <listitem>
1486                 <para>optional, user-defined data passed to the
1487                 function.</para>
1488
1489                 <para>If data is provided, it is passed to the callback
1490                 function both as an input and output argument. In that case,
1491                 the function must have the following header :</para>
1492
1493                 <programlisting role="example"><![CDATA[ 
1494 function [ y , data ] = myfunction ( x , data )
1495  ]]></programlisting>
1496
1497                 <para>The data input parameter may be used if the function
1498                 uses some additionnal parameters. It is returned as an output
1499                 parameter because the function may modify the data while
1500                 computing the function value. This feature may be used, for
1501                 example, to count the number of times that the function has
1502                 been called.</para>
1503               </listitem>
1504             </varlistentry>
1505           </variablelist>
1506         </listitem>
1507       </varlistentry>
1508
1509       <varlistentry>
1510         <term>[ this , data ] = optimsimplex_shrink ( this , fun , sigma , data
1511         )</term>
1512
1513         <listitem>
1514           <para>Shrink the simplex with given coefficient sigma and returns an
1515           updated simplex. The shrink is performed with respect to the first
1516           point in the simplex.</para>
1517
1518           <variablelist>
1519             <varlistentry>
1520               <term>this</term>
1521
1522               <listitem>
1523                 <para>The current simplex object.</para>
1524               </listitem>
1525             </varlistentry>
1526
1527             <varlistentry>
1528               <term>fun</term>
1529
1530               <listitem>
1531                 <para>optional, the function to compute at vertices.</para>
1532
1533                 <para>The function is expected to have the following input and
1534                 output arguments :</para>
1535
1536                 <programlisting role="example"><![CDATA[ 
1537 function y = myfunction (x)
1538  ]]></programlisting>
1539               </listitem>
1540             </varlistentry>
1541
1542             <varlistentry>
1543               <term>sigma</term>
1544
1545               <listitem>
1546                 <para>optional, the shrinkage coefficient. The default value
1547                 is 0.5.</para>
1548               </listitem>
1549             </varlistentry>
1550
1551             <varlistentry>
1552               <term>data</term>
1553
1554               <listitem>
1555                 <para>optional, user-defined data passed to the
1556                 function.</para>
1557
1558                 <para>If data is provided, it is passed to the callback
1559                 function both as an input and output argument. In that case,
1560                 the function must have the following header :</para>
1561
1562                 <programlisting role="example"><![CDATA[ 
1563 function [ y , data ] = myfunction ( x , data )
1564  ]]></programlisting>
1565
1566                 <para>The data input parameter may be used if the function
1567                 uses some additionnal parameters. It is returned as an output
1568                 parameter because the function may modify the data while
1569                 computing the function value. This feature may be used, for
1570                 example, to count the number of times that the function has
1571                 been called.</para>
1572               </listitem>
1573             </varlistentry>
1574           </variablelist>
1575         </listitem>
1576       </varlistentry>
1577
1578       <varlistentry>
1579         <term>ssize = optimsimplex_size ( this , method )</term>
1580
1581         <listitem>
1582           <para>Returns the size of the simplex.</para>
1583
1584           <para>The diameter is the maximum length of all the vertices. It
1585           requires 2 nested loops over the vertices.</para>
1586
1587           <para>The sigmaminus (resp. sigmamplus) size is the minimum (resp.
1588           maximum) length of the vector from each vertex to the first
1589           vertex. It requires one loop over the vertices.</para>
1590
1591           <para>The "Nash" size is the sum of the norm of the length of the
1592           vector from the given vertex to the first vertex. It requires one
1593           loop over the vertices.</para>
1594
1595           <variablelist>
1596             <varlistentry>
1597               <term>this</term>
1598
1599               <listitem>
1600                 <para>The current simplex object.</para>
1601               </listitem>
1602             </varlistentry>
1603
1604             <varlistentry>
1605               <term>method</term>
1606
1607               <listitem>
1608                 <para>optional, the method to use to compute the size. The
1609                 available methods are "Nash", "diameter", "sigmaplus" or
1610                 "sigmaminus" (default is "sigmaplus").</para>
1611               </listitem>
1612             </varlistentry>
1613           </variablelist>
1614         </listitem>
1615       </varlistentry>
1616
1617       <varlistentry>
1618         <term>this = optimsimplex_sort ( this )</term>
1619
1620         <listitem>
1621           <para>Sorts the simplex with increasing function value order so that
1622           the smallest function value is at vertex #1</para>
1623
1624           <variablelist>
1625             <varlistentry>
1626               <term>this</term>
1627
1628               <listitem>
1629                 <para>The current simplex object.</para>
1630               </listitem>
1631             </varlistentry>
1632           </variablelist>
1633         </listitem>
1634       </varlistentry>
1635
1636       <varlistentry>
1637         <term>str = optimsimplex_tostring ( this )</term>
1638
1639         <listitem>
1640           <para>Returns the current simplex as a string.</para>
1641
1642           <variablelist>
1643             <varlistentry>
1644               <term>this</term>
1645
1646               <listitem>
1647                 <para>The current simplex object.</para>
1648               </listitem>
1649             </varlistentry>
1650           </variablelist>
1651         </listitem>
1652       </varlistentry>
1653
1654       <varlistentry>
1655         <term>cen = optimsimplex_xbar ( this , iexcl )</term>
1656
1657         <listitem>
1658           <para>Returns the center of n vertices, by excluding the vertex with
1659           index iexcl.</para>
1660
1661           <variablelist>
1662             <varlistentry>
1663               <term>this</term>
1664
1665               <listitem>
1666                 <para>The current simplex object.</para>
1667               </listitem>
1668             </varlistentry>
1669
1670             <varlistentry>
1671               <term>iexcl</term>
1672
1673               <listitem>
1674                 <para>the index of the vertex to exclude in center
1675                 computation. The default value of iexcl is the number of
1676                 vertices : in that case, if the simplex is sorted in
1677                 increasing function value order, the worst vertex is
1678                 excluded.</para>
1679               </listitem>
1680             </varlistentry>
1681           </variablelist>
1682         </listitem>
1683       </varlistentry>
1684     </variablelist>
1685   </refsection>
1686
1687   <refsection>
1688     <title>Example : Creating a simplex with given vertices
1689     coordinates</title>
1690
1691     <para>In the following example, one creates a simplex with known vertices
1692     coordinates. The function values at the vertices are unset.</para>
1693
1694     <programlisting role="example"><![CDATA[ 
1695 coords = [
1696 0.0 1.0 0.0
1697 0.0 0.0 1.0
1698 ];
1699 s1 = optimsimplex_new ( coords );
1700 computed = optimsimplex_getallx ( s1 );
1701 computed = optimsimplex_getn(s1);
1702 computed = optimsimplex_getnbve (s1);
1703 s1 = optimsimplex_destroy(s1);
1704  ]]></programlisting>
1705   </refsection>
1706
1707   <refsection>
1708     <title>Example : Creating a simplex with randomized bounds</title>
1709
1710     <para>In the following example, one creates a simplex with in the 2D
1711     domain [-5 5]^2, with [-1.2 1.0] as the first vertex. One uses the
1712     randomized bounds method to generate a simplex with 5 vertices. The
1713     function takes an additionnal argument myobj, which is counts the number
1714     of times the function is called. After the creation of the simplex, the
1715     value of mydude.nb is 5, which is the expected result because there is one
1716     function call by vertex.</para>
1717
1718     <programlisting role="example"><![CDATA[ 
1719 function [ y , myobj ] = mycostf ( x , myobj )
1720   y = rosenbrock(x);
1721   myobj.nb = myobj.nb + 1
1722 endfunction
1723
1724 mydude = tlist(["T_MYSTUFF","nb"]);
1725 mydude.nb = 0;
1726 s1 = optimsimplex_new ();
1727 [ s1 , mydude ] = optimsimplex_randbounds ( s1 , x0 = [-1.2 1.0], fun = mycostf, ...
1728   boundsmin = [-5.0 -5.0] , boundsmax = [5.0 5.0], nbve=5 , data = mydude );
1729 s1 = optimsimplex_destroy ( s1 );
1730  ]]></programlisting>
1731   </refsection>
1732
1733   <refsection>
1734     <title>TODO</title>
1735
1736     <itemizedlist>
1737         <listitem>
1738           <para>implement reflection and expansion as in multidimensional
1739           search by Torczon</para>
1740         </listitem>
1741     </itemizedlist>
1742   </refsection>
1743
1744   <refsection>
1745     <title>Initial simplex strategies</title>
1746     <para>
1747       In this section, we analyse the various initial simplex which are provided in this 
1748       component.
1749     </para>
1750     <para>
1751       It is known that direct search methods based on simplex designs are very 
1752       sensitive to the initial simplex. This is why the current component 
1753       provides various ways to create such an initial simplex.
1754     </para>
1755
1756     <para>
1757       The first historical simplex-based algorithm is the one presented in 
1758       "Sequential Application of Simplex Designs in Optimisation and
1759       Evolutionary Operation" by W. Spendley, G. R. Hext and F. R. Himsworth.
1760       The optimsimplex_spendley function creates the regular simplex which is presented in
1761       this paper.
1762     </para>
1763
1764     
1765     <para>
1766       The method used in the optimsimplex_randbounds function is due to M.J. Box
1767       in "A New Method of Constrained Optimization and a Comparison With
1768       Other Methods". 
1769     </para>
1770
1771     <para>
1772       Pfeffer's method is an heuristic which is presented in "Global Optimization Of Lennard-Jones Atomic Clusters" by
1773       Ellen Fan. It is due to L. Pfeffer at Stanford and it is used in fminsearch.
1774     </para>
1775     
1776   </refsection>
1777
1778   <refsection>
1779     <title>Authors</title>
1780
1781     <para>Michael Baudin, 2008-2009</para>
1782   </refsection>
1783
1784   <refsection>
1785     <title>Bibliography</title>
1786
1787     <para>
1788       &#8220;Sequential Application of Simplex Designs in Optimisation and
1789       Evolutionary Operation&#8221;, Spendley, W. and Hext, G. R. and Himsworth,
1790       F. R., American Statistical Association and American Society for Quality,
1791       1962
1792     </para>
1793
1794     <para>
1795       "A Simplex Method for Function Minimization", Nelder, J. A. and
1796       Mead, R. The Computer Journal, January, 1965, 308--313
1797     </para>
1798
1799     <para>
1800       "A New Method of Constrained Optimization and a Comparison With
1801       Other Methods", M. J. Box, The Computer Journal 1965 8(1):42-52, 1965 by
1802       British Computer Society
1803     </para>
1804
1805     <para>
1806       "Iterative Methods for Optimization", C.T. Kelley, 1999, Chapter 6.,
1807       section 6.2
1808     </para>
1809
1810     <para>
1811       "Compact Numerical Methods For Computers - Linear Algebra and
1812       Function Minimization", J.C. Nash, 1990, Chapter 14. Direct Search
1813       Methods
1814     </para>
1815
1816     <para>
1817       "Sequential Application of Simplex Designs in Optimisation and
1818       Evolutionary Operation", W. Spendley, G. R. Hext, F. R. Himsworth,
1819       Technometrics, Vol. 4, No. 4 (Nov., 1962), pp. 441-461, Section 3.1
1820     </para>
1821
1822     <para>
1823       "A New Method of Constrained Optimization and a Comparison With
1824       Other Methods", M. J. Box, The Computer Journal 1965 8(1):42-52, 1965 by
1825       British Computer Society
1826     </para>
1827
1828     <para>
1829       &#8220;Detection and Remediation of Stagnation in the Nelder--Mead
1830       Algorithm Using a Sufficient Decrease Condition&#8221;, SIAM J. on
1831       Optimization, Kelley,, C. T., 1999
1832     </para>
1833
1834     <para>
1835       " Multi-Directional Search: A Direct Search Algorithm for Parallel
1836       Machines", by E. Boyd, Kenneth W. Kennedy, Richard A. Tapia, Virginia
1837       Joanne Torczon,, Virginia Joanne Torczon, 1989, Phd Thesis, Rice
1838       University
1839     </para>
1840
1841     <para>
1842       "Grid Restrained Nelder-Mead Algorithm", Árpád B&#361;rmen, Janez
1843       Puhan, Tadej Tuma, Computational Optimization and Applications, Volume 34
1844       , Issue 3 (July 2006), Pages: 359 - 375
1845     </para>
1846
1847     <para>
1848       "A convergent variant of the Nelder-Mead algorithm", C. J. Price, I.
1849       D. Coope, D. Byatt, Journal of Optimization Theory and Applications,
1850       Volume 113 , Issue 1 (April 2002), Pages: 5 - 19,
1851     </para>
1852
1853     <para>
1854       "Global Optimization Of Lennard-Jones Atomic Clusters",
1855       Ellen Fan, Thesis, February 26, 2002, McMaster University
1856     </para>
1857   </refsection>
1858 </refentry>