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