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