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