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