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