unit_tests/neldermead/neldermead_rosensuzuki.dia.ref

// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
// Copyright (C) 2008-2009 - INRIA - Michael Baudin
// Copyright (C) 2011 - DIGITEO - Michael Baudin
//
// Copyright (C) 2012 - 2016 - Scilab Enterprises
//
// This file is hereby licensed under the terms of the GNU GPL v2.0,
// pursuant to article 5.3.4 of the CeCILL v.2.1.
// This file was originally licensed under the terms of the CeCILL v2.1,
// and continues to be available under such terms.
// For more information, see the COPYING file which you should have received
// along with this program.
// <-- CLI SHELL MODE -->
// <-- ENGLISH IMPOSED -->
//
//  Reference:
//
//    An extension of the simplex method to constrained
//    nonlinear optimization
//    M.B. Subrahmanyam
//    Journal of optimization theory and applications
//    Vol. 62, August 1989
//
//    Gould F.J.
//    Nonlinear Tolerance Programming
//    Numerical methods for Nonlinear optimization
//    Edited by F.A. Lootsma, pp 349-366, 1972
//
// optimtestcase --
//   Non linear inequality constraints are positive.
//
// Arguments
//   x: the point where to compute the function
//   index : what to compute
//     if index=2, returns f
//     if index=5, returns c
//     if index=6, returns f and c
// Note
//  The inequality constraints are expected to be positive.
//
function [ f , c , index ] = optimtestcase ( x , index )
  f = []
  c = []
  if ( ( index == 2 ) | ( index == 6 ) ) then
    f = x(1)^2 + x(2)^2 + 2.0 * x(3)^2 + x(4)^2 ...
      - 5.0 * x(1) - 5.0 * x(2) - 21.0 * x(3) + 7.0 * x(4)
  end
  if ( ( index == 5 ) | ( index == 6 ) ) then
    c1 = - x(1)^2 - x(2)^2 - x(3)^2 - x(4)^2 ...
              - x(1) + x(2) - x(3) + x(4) + 8
    c2 = - x(1)^2 - 2.0 * x(2)^2 - x(3)^2 - 2.0 * x(4)^2 ...
              + x(1) + x(4) + 10.0
    c3 = - 2.0 * x(1)^2 - x(2)^2 - x(3)^2 - 2.0 * x(1) ...
              + x(2) + x(4) + 5.0
    c = [c1 c2 c3]
  end
endfunction
function [ f , c , index ] = optimtestcase2 ( x , index )
  f = []
  c = []
  x2 = x.^2
  if ( ( index == 2 ) | ( index == 6 ) ) then
    f = [1 1 2 1]*x2 + [-5 -5 -21 7]*x
  end
  if ( ( index == 5 ) | ( index == 6 ) ) then
    c1 = [-1 -1 -1 -1]*x2 + [-1 1 -1 1]*x + 8
    c2 = [-1 -2 -1 -2]*x2 + [1 0 0 1]*x + 10
    c3 = [-2 -1 -1 0]*x2 + [-2 1 0 1]*x + 5
    c = [c1 c2 c3]
  end
endfunction
//
// Test the function.
//
xstar = [0.0 1.0 2.0 -1.0]';
fstar = -44;
[ f , c , index ] = optimtestcase ( xstar , 6 );
assert_checkequal ( f , fstar );
assert_checkequal ( c , [0 1 0] );
//
[ f , c , index ] = optimtestcase2 ( xstar , 6 );
assert_checkequal ( f , fstar );
assert_checkequal ( c , [0 1 0] );
//
// Test with Box algorithm and default axes initial simplex
//
nm = neldermead_new ();
nm = neldermead_configure(nm,"-numberofvariables",4);
nm = neldermead_configure(nm,"-function",optimtestcase2);
nm = neldermead_configure(nm,"-x0",[0.0 0.5 1.0 -0.5]');
nm = neldermead_configure(nm,"-maxiter",400);
nm = neldermead_configure(nm,"-maxfunevals",1000);
nm = neldermead_configure(nm,"-tolsimplexizerelative",1.e-2);
nm = neldermead_configure(nm,"-simplex0method","axes");
nm = neldermead_configure(nm,"-method","box");
nm = neldermead_configure(nm,"-nbineqconst",3);
nm = neldermead_search(nm);
// Check optimum point
xopt = neldermead_get(nm,"-xopt");
assert_checkalmostequal ( xopt , [0.0 1.0 2.0 -1.0]', 1e-1 , 1.e-1);
// Check optimum point value
fopt = neldermead_get(nm,"-fopt");
assert_checkalmostequal ( fopt , -44.0 , 1e-2 );
// Check status
status = neldermead_get(nm,"-status");
assert_checkequal ( status , "tolsize" );
nm = neldermead_destroy(nm);
//
// Test with Box algorithm and restart
//
nm = neldermead_new ();
nm = neldermead_configure(nm,"-numberofvariables",4);
nm = neldermead_configure(nm,"-function",optimtestcase2);
nm = neldermead_configure(nm,"-x0",[0.0 0.0 0.0 0.0]');
nm = neldermead_configure(nm,"-maxiter",200);
nm = neldermead_configure(nm,"-maxfunevals",300);
nm = neldermead_configure(nm,"-tolsimplexizerelative",1.e-1);
nm = neldermead_configure(nm,"-simplex0method","axes");
nm = neldermead_configure(nm,"-method","box");
nm = neldermead_configure(nm,"-nbineqconst",3);
nm = neldermead_search(nm);
nm = neldermead_restart(nm);
optimbase_terminate: Exiting: Maximum number of function evaluations has been exceeded
          - increase MaxFunEvals option.
// Check optimum point
xopt = neldermead_get(nm,"-xopt");
assert_checkalmostequal ( xopt , [0.0 1.0 2.0 -1.0]', 1e-1, 1e-1 );
// Check optimum point value
fopt = neldermead_get(nm,"-fopt");
assert_checkalmostequal ( fopt , -44.0 , 1e-2 );
// Check status
status = neldermead_get(nm,"-status");
assert_checkequal ( status , "maxfuneval" );
nm = neldermead_destroy(nm);
//
// Test with Box algorithm and default axes initial simplex
// Add bounds and simplex initial length so that there is a need
// for variable projection.
//
nm = neldermead_new ();
nm = neldermead_configure(nm,"-numberofvariables",4);
nm = neldermead_configure(nm,"-function",optimtestcase2);
nm = neldermead_configure(nm,"-x0",[0.0 0.0 0.0 0.0]');
nm = neldermead_configure(nm,"-maxiter",400);
nm = neldermead_configure(nm,"-maxfunevals",1000);
nm = neldermead_configure(nm,"-tolsimplexizerelative",1.e-2);
nm = neldermead_configure(nm,"-simplex0method","axes");
nm = neldermead_configure(nm,"-method","box");
nm = neldermead_configure(nm,"-nbineqconst",3);
nm = neldermead_configure(nm,"-boundsmin",[-10.0 -10.0 -10.0 -10.0]);
nm = neldermead_configure(nm,"-boundsmax",[10.0 10.0 10.0 10.0]);
nm = neldermead_configure(nm,"-simplex0length",20.0);
nm = neldermead_search(nm);
// Check optimum point
xopt = neldermead_get(nm,"-xopt");
assert_checkalmostequal ( xopt , [0.0 1.0 2.0 -1.0]', 1e-1, 1e-1 );
// Check optimum point value
fopt = neldermead_get(nm,"-fopt");
assert_checkalmostequal ( fopt , -44.0 , 1e-3 );
// Check status
status = neldermead_get(nm,"-status");
assert_checkequal ( status , "tolsize" );
nm = neldermead_destroy(nm);
//
// Test with Box algorithm and randomized bounds simplex.
// Add bounds and simplex initial length so that there is a need
// for variable projection.
// Here the initial simplex is computed with Box randomized bounds method
// and default number of points in the simplex, i.e. 2n = 2 * 4 = 8.
//
// The convergence is not accurate in this case, whatever the
// value of the relative tolerance on simplex size.
//
//
// Initialize the random number generator, so that the results are always the
// same.
//
rand("seed" , 0)
nm = neldermead_new ();
nm = neldermead_configure(nm,"-numberofvariables",4);
nm = neldermead_configure(nm,"-function",optimtestcase2);
nm = neldermead_configure(nm,"-x0",[0.0 0.0 0.0 0.0]');
nm = neldermead_configure(nm,"-maxiter",300);
nm = neldermead_configure(nm,"-maxfunevals",1000);
nm = neldermead_configure(nm,"-tolsimplexizerelative",1.e-2);
nm = neldermead_configure(nm,"-method","box");
nm = neldermead_configure(nm,"-nbineqconst",3);
nm = neldermead_configure(nm,"-boundsmin",[-10.0 -10.0 -10.0 -10.0]);
nm = neldermead_configure(nm,"-boundsmax",[10.0 10.0 10.0 10.0]);
nm = neldermead_configure(nm,"-simplex0length",20.0);
nm = neldermead_configure(nm,"-simplex0method","randbounds");
nm = neldermead_search(nm);
// Check optimum point
xopt = neldermead_get(nm,"-xopt");
assert_checkalmostequal ( xopt , [0.0 1.0 2.0 -1.0]', 1e-0 );
// Check optimum point value
fopt = neldermead_get(nm,"-fopt");
assert_checkalmostequal ( fopt , -44.0 , 1e-1 );
// Check status
status = neldermead_get(nm,"-status");
assert_checkequal ( status , "tolsize" );
// Check the optimum simplex
simplexopt = neldermead_get ( nm , "-simplexopt" );
nbve = optimsimplex_getnbve ( simplexopt );
assert_checkequal ( nbve , 8 );
nm = neldermead_destroy(nm);
//
// Test with Box algorithm and randomized bounds simplex.
// Add bounds and simplex initial length so that there is a need
// for variable projection.
// Here the initial simplex is computed with Box randomized bounds method
// and user-defined number of points in the simplex, i.e. 6
//
//
// Initialize the random number generator, so that the results are always the
// same.
//
rand("seed" , 0)
nm = neldermead_new ();
nm = neldermead_configure(nm,"-numberofvariables",4);
nm = neldermead_configure(nm,"-function",optimtestcase2);
nm = neldermead_configure(nm,"-x0",[0.0 0.0 0.0 0.0]');
nm = neldermead_configure(nm,"-maxiter",300);
nm = neldermead_configure(nm,"-maxfunevals",1000);
nm = neldermead_configure(nm,"-tolsimplexizerelative",1.e-2);
nm = neldermead_configure(nm,"-method","box");
nm = neldermead_configure(nm,"-nbineqconst",3);
nm = neldermead_configure(nm,"-boundsmin",[-10.0 -10.0 -10.0 -10.0]);
nm = neldermead_configure(nm,"-boundsmax",[10.0 10.0 10.0 10.0]);
nm = neldermead_configure(nm,"-simplex0length",20.0);
nm = neldermead_configure(nm,"-simplex0method","randbounds");
nm = neldermead_configure(nm,"-boxnbpoints",6);
nm = neldermead_search(nm);
// Check optimum point
xopt = neldermead_get(nm,"-xopt");
assert_checkalmostequal ( xopt , [0.0 1.0 2.0 -1.0]', 1e-1, 1e-1 );
// Check optimum point value
fopt = neldermead_get(nm,"-fopt");
assert_checkalmostequal ( fopt , -44.0 , 1e-2 );
// Check status
status = neldermead_get(nm,"-status");
assert_checkequal ( status , "tolsize" );
// Check the optimum simplex
simplexopt = neldermead_get ( nm , "-simplexopt" );
nbve = optimsimplex_getnbve ( simplexopt );
assert_checkequal ( nbve , 6 );
nm = neldermead_destroy(nm);
//
// Test with "tocenter"
//
rand("seed" , 0)
nm = neldermead_new ();
nm = neldermead_configure(nm,"-numberofvariables",4);
nm = neldermead_configure(nm,"-function",optimtestcase2);
nm = neldermead_configure(nm,"-x0",[0.0 0.0 0.0 0.0]');
nm = neldermead_configure(nm,"-maxiter",300);
nm = neldermead_configure(nm,"-maxfunevals",1000);
nm = neldermead_configure(nm,"-tolsimplexizerelative",1.e-2);
nm = neldermead_configure(nm,"-method","box");
nm = neldermead_configure(nm,"-nbineqconst",3);
nm = neldermead_configure(nm,"-boundsmin",[-10.0 -10.0 -10.0 -10.0]);
nm = neldermead_configure(nm,"-boundsmax",[10.0 10.0 10.0 10.0]);
nm = neldermead_configure(nm,"-simplex0length",20.0);
nm = neldermead_configure(nm,"-simplex0method","randbounds");
nm = neldermead_configure(nm,"-boxnbpoints",6);
nm = neldermead_configure(nm,"-scalingsimplex0","tocenter");
nm = neldermead_search(nm);
// Check optimum point
xopt = neldermead_get(nm,"-xopt");
assert_checkalmostequal ( xopt , [0.0 1.0 2.0 -1.0]', 1e-1, 1e-1 );
// Check optimum point value
fopt = neldermead_get(nm,"-fopt");
assert_checkalmostequal ( fopt , -44.0 , 1e-2 );
// Check status
status = neldermead_get(nm,"-status");
assert_checkequal ( status , "tolsize" );
// Check the optimum simplex
simplexopt = neldermead_get ( nm , "-simplexopt" );
nbve = optimsimplex_getnbve ( simplexopt );
assert_checkequal ( nbve , 6 );
nm = neldermead_destroy(nm);
//
// Test with Box algorithm and given simplex.
// Add bounds and simplex initial length so that there is a need
// for variable projection.
// Here the initial simplex is user-defined.
// Makes sure that all auxiliary computations are performed.
// I put the solution as the last point, to see what happens
//
nm = neldermead_new ();
nm = neldermead_configure(nm,"-numberofvariables",4);
nm = neldermead_configure(nm,"-function",optimtestcase2);
nm = neldermead_configure(nm,"-x0",[0.0 0.0 0.0 0.0]');
nm = neldermead_configure(nm,"-maxiter",300);
nm = neldermead_configure(nm,"-maxfunevals",1000);
nm = neldermead_configure(nm,"-tolsimplexizerelative",1.e-2);
nm = neldermead_configure(nm,"-method","box");
nm = neldermead_configure(nm,"-nbineqconst",3);
nm = neldermead_configure(nm,"-boundsmin",[-10.0 -10.0 -10.0 -10.0]);
nm = neldermead_configure(nm,"-boundsmax",[10.0 10.0 10.0 10.0]);
nm = neldermead_configure(nm,"-simplex0method","given");
coords = [
0.0 0.0 0.0 0.0
1.0 0.0 0.0 0.0
0.0 1.0 0.0 0.0
0.0 0.0 1.0 0.0
0.0 0.0 0.0 1.0
1.0 1.0 1.0 1.0
0.0 1.0 2.0 -1.0
];
nm = neldermead_configure(nm,"-coords0",coords);
nm = neldermead_search(nm);
// Check optimum point
xopt = neldermead_get(nm,"-xopt");
assert_checkalmostequal ( xopt , [0.0 1.0 2.0 -1.0]', 1e-2 );
// Check optimum point value
fopt = neldermead_get(nm,"-fopt");
assert_checkalmostequal ( fopt , -44.0 , 1e-4 );
// Check status
status = neldermead_get(nm,"-status");
assert_checkequal ( status , "tolsize" );
// Check the optimum simplex
simplexopt = neldermead_get ( nm , "-simplexopt" );
nbve = optimsimplex_getnbve ( simplexopt );
assert_checkequal ( nbve , 7 );
nm = neldermead_destroy(nm);
//
// Test with Box algorithm and randomized bounds simplex.
// Test that verbose mode works fine.
//
rand("seed" , 0)
nm = neldermead_new ();
nm = neldermead_configure(nm,"-numberofvariables",4);
nm = neldermead_configure(nm,"-function",optimtestcase2);
nm = neldermead_configure(nm,"-x0",[0.0 0.0 0.0 0.0]');
nm = neldermead_configure(nm,"-maxiter",5);
nm = neldermead_configure(nm,"-maxfunevals",1000);
nm = neldermead_configure(nm,"-tolsimplexizerelative",1.e-3);
nm = neldermead_configure(nm,"-method","box");
nm = neldermead_configure(nm,"-nbineqconst",3);
nm = neldermead_configure(nm,"-verbose",1);
nm = neldermead_configure(nm,"-verbosetermination",1);
nm = neldermead_configure(nm,"-boundsmin",[-10.0 -10.0 -10.0 -10.0]);
nm = neldermead_configure(nm,"-boundsmax",[10.0 10.0 10.0 10.0]);
nm = neldermead_configure(nm,"-simplex0method","randbounds");
nm = neldermead_search(nm, "off");
Function Evaluation #1, index=1, x= [0 0 0 0]
Function Evaluation #2, index=2, x= [0 0 0 0]
Function Evaluation #3, index=5, x= [0 0 0 0]
Function Evaluation #4, index=6, x= [0 0 0 0]
Function Evaluation #5, index=5, x= [0 0 0 0]
Scaling initial simplex into nonlinear inequality constraints...
Scaling vertex #2/8 at [-5.7735027 5.1208771 -9.9955773 -3.3934582]...
 > After projection into bounds p = [-5.7735027 5.1208771 -9.9955773 -3.3934582]
Function Evaluation #6, index=5, x= [-5.7735027 5.1208771 -9.9955773 -3.3934582]
Inequality constraint #1/3 is not satisfied for x
Scaling inequality constraint with alpha = 0.5
Function Evaluation #7, index=5, x= [-2.8867513 2.5604385 -4.9977887 -1.6967291]
Inequality constraint #1/3 is not satisfied for x
Scaling inequality constraint with alpha = 0.25
Function Evaluation #8, index=5, x= [-1.4433757 1.2802193 -2.4988943 -0.8483645]
Inequality constraint #2/3 is not satisfied for x
Scaling inequality constraint with alpha = 0.125
Function Evaluation #9, index=5, x= [-0.7216878 0.6401096 -1.2494472 -0.4241823]
 > After scaling into inequality constraints p = [-0.7216878 0.6401096 -1.2494472 -0.4241823]
Scaling vertex #3/8 at [3.3076221 2.5678358 6.9949047 3.7146204]...
 > After projection into bounds p = [3.3076221 2.5678358 6.9949047 3.7146204]
Function Evaluation #10, index=5, x= [3.3076221 2.5678358 6.9949047 3.7146204]
Inequality constraint #1/3 is not satisfied for x
Scaling inequality constraint with alpha = 0.5
Function Evaluation #11, index=5, x= [1.653811 1.2839179 3.4974524 1.8573102]
Inequality constraint #1/3 is not satisfied for x
Scaling inequality constraint with alpha = 0.25
Function Evaluation #12, index=5, x= [0.8269055 0.6419589 1.7487262 0.9286551]
 > After scaling into inequality constraints p = [0.8269055 0.6419589 1.7487262 0.9286551]
Scaling vertex #4/8 at [7.5643296 -8.6325193 1.2169721 3.2471387]...
 > After projection into bounds p = [7.5643296 -8.6325193 1.2169721 3.2471387]
Function Evaluation #13, index=5, x= [7.5643296 -8.6325193 1.2169721 3.2471387]
Inequality constraint #1/3 is not satisfied for x
Scaling inequality constraint with alpha = 0.5
Function Evaluation #14, index=5, x= [3.7821648 -4.3162596 0.6084861 1.6235694]
Inequality constraint #1/3 is not satisfied for x
Scaling inequality constraint with alpha = 0.25
Function Evaluation #15, index=5, x= [1.8910824 -2.1581298 0.304243 0.8117847]
Inequality constraint #1/3 is not satisfied for x
Scaling inequality constraint with alpha = 0.125
Function Evaluation #16, index=5, x= [0.9455412 -1.0790649 0.1521215 0.4058923]
Inequality constraint #3/3 is not satisfied for x
Scaling inequality constraint with alpha = 0.0625
Function Evaluation #17, index=5, x= [0.4727706 -0.5395325 0.0760608 0.2029462]
 > After scaling into inequality constraints p = [0.4727706 -0.5395325 0.0760608 0.2029462]
Scaling vertex #5/8 at [4.5270135 -6.0297123 0.8851463 -5.3585042]...
 > After projection into bounds p = [4.5270135 -6.0297123 0.8851463 -5.3585042]
Function Evaluation #18, index=5, x= [4.5270135 -6.0297123 0.8851463 -5.3585042]
Inequality constraint #1/3 is not satisfied for x
Scaling inequality constraint with alpha = 0.5
Function Evaluation #19, index=5, x= [2.2635068 -3.0148562 0.4425732 -2.6792521]
Inequality constraint #1/3 is not satisfied for x
Scaling inequality constraint with alpha = 0.25
Function Evaluation #20, index=5, x= [1.1317534 -1.5074281 0.2212866 -1.3396261]
Inequality constraint #1/3 is not satisfied for x
Scaling inequality constraint with alpha = 0.125
Function Evaluation #21, index=5, x= [0.5658767 -0.753714 0.1106433 -0.669813]
 > After scaling into inequality constraints p = [0.5658767 -0.753714 0.1106433 -0.669813]
Scaling vertex #6/8 at [-5.3755256 -5.6707347 7.6677756 3.0502699]...
 > After projection into bounds p = [-5.3755256 -5.6707347 7.6677756 3.0502699]
Function Evaluation #22, index=5, x= [-5.3755256 -5.6707347 7.6677756 3.0502699]
Inequality constraint #1/3 is not satisfied for x
Scaling inequality constraint with alpha = 0.5
Function Evaluation #23, index=5, x= [-2.6877628 -2.8353674 3.8338878 1.5251349]
Inequality constraint #1/3 is not satisfied for x
Scaling inequality constraint with alpha = 0.25
Function Evaluation #24, index=5, x= [-1.3438814 -1.4176837 1.9169439 0.7625675]
Inequality constraint #1/3 is not satisfied for x
Scaling inequality constraint with alpha = 0.125
Function Evaluation #25, index=5, x= [-0.6719407 -0.7088418 0.958472 0.3812837]
 > After scaling into inequality constraints p = [-0.6719407 -0.7088418 0.958472 0.3812837]
Scaling vertex #7/8 at [-3.8478185 8.6592324 -5.7079843 -3.7471601]...
 > After projection into bounds p = [-3.8478185 8.6592324 -5.7079843 -3.7471601]
Function Evaluation #26, index=5, x= [-3.8478185 8.6592324 -5.7079843 -3.7471601]
Inequality constraint #1/3 is not satisfied for x
Scaling inequality constraint with alpha = 0.5
Function Evaluation #27, index=5, x= [-1.9239093 4.3296162 -2.8539921 -1.87358]
Inequality constraint #1/3 is not satisfied for x
Scaling inequality constraint with alpha = 0.25
Function Evaluation #28, index=5, x= [-0.9619546 2.1648081 -1.4269961 -0.93679]
Inequality constraint #2/3 is not satisfied for x
Scaling inequality constraint with alpha = 0.125
Function Evaluation #29, index=5, x= [-0.4809773 1.0824041 -0.713498 -0.468395]
 > After scaling into inequality constraints p = [-0.4809773 1.0824041 -0.713498 -0.468395]
Scaling vertex #8/8 at [-2.767278 -4.1554667 1.3284976 -0.3470561]...
 > After projection into bounds p = [-2.767278 -4.1554667 1.3284976 -0.3470561]
Function Evaluation #30, index=5, x= [-2.767278 -4.1554667 1.3284976 -0.3470561]
Inequality constraint #1/3 is not satisfied for x
Scaling inequality constraint with alpha = 0.5
Function Evaluation #31, index=5, x= [-1.383639 -2.0777334 0.6642488 -0.173528]
Inequality constraint #1/3 is not satisfied for x
Scaling inequality constraint with alpha = 0.25
Function Evaluation #32, index=5, x= [-0.6918195 -1.0388667 0.3321244 -0.086764]
 > After scaling into inequality constraints p = [-0.6918195 -1.0388667 0.3321244 -0.086764]
Function Evaluation #33, index=2, x= [0 0 0 0]
Function Evaluation #34, index=2, x= [-0.7216878 0.6401096 -1.2494472 -0.4241823]
Function Evaluation #35, index=2, x= [0.8269055 0.6419589 1.7487262 0.9286551]
Function Evaluation #36, index=2, x= [0.4727706 -0.5395325 0.0760608 0.2029462]
Function Evaluation #37, index=2, x= [0.5658767 -0.753714 0.1106433 -0.669813]
Function Evaluation #38, index=2, x= [-0.6719407 -0.7088418 0.958472 0.3812837]
Function Evaluation #39, index=2, x= [-0.4809773 1.0824041 -0.713498 -0.468395]
Function Evaluation #40, index=2, x= [-0.6918195 -1.0388667 0.3321244 -0.086764]
Step #1 : order
=================================================================
Iteration #1 (total = 1)
Function Eval #40
Xopt : [0.8269055 0.6419589 1.7487262 0.9286551]
Fopt : -29.492616
DeltaFv : 57.402362
Center : [-0.0876091 -0.0845603 0.1578852 -0.0170337]
Size : 3.6355683
Optim Simplex Object:
=====================
nbve: 8
n: 4
x: 8-by-4 matrix
fv: 8-by-1 matrix
Reflect
xbar=[0.0029736 -0.1880846 0.3589327 0.0411304]
_boxlinesearch
> xhigh=[-0.7216878 0.6401096 -1.2494472 -0.4241823], fhigh=27.909746
> xbar=[0.0029736 -0.1880846 0.3589327 0.0411304]
> xr = [0.9450335 -1.264737 2.4498264 0.6460369]
Function Evaluation #41, index=5, x= [0.9450335 -1.264737 2.4498264 0.6460369]
Inequality constraint #1/3 is not satisfied for x
Function Evaluation #42, index=5, x= [0.4740036 -0.7264108 1.4043795 0.3435837]
Function Evaluation #43, index=2, x= [0.4740036 -0.7264108 1.4043795 0.3435837]
xr=[0.4740036 -0.7264108 1.4043795 0.3435837], f(xr)=-21.009883
  > Perform Reflection
Sort
=================================================================
Iteration #2 (total = 2)
Function Eval #43
Xopt : [0.8269055 0.6419589 1.7487262 0.9286551]
Fopt : -29.492616
DeltaFv : 40.830666
Center : [0.0618524 -0.2553754 0.4896135 0.0789371]
Size : 3.14942
Optim Simplex Object:
=====================
nbve: 8
n: 4
x: 8-by-4 matrix
fv: 8-by-1 matrix
  > Termination ?
  > iterations=2 >= maxiter=5
  > funevals=43 >= maxfunevals=1000
  > e(x)=0.413244 < 1.490D-08 * 0.5612439 + 0
  > Terminate = F, status = continue
  > simplex size=3.14942 < 0 + 0.001 * 2.239716
  > Terminate = F, status = continue
Reflect
xbar=[0.1393995 -0.4464867 0.6614866 0.1571274]
_boxlinesearch
> xhigh=[-0.4809773 1.0824041 -0.713498 -0.468395], fhigh=11.33805
> xbar=[0.1393995 -0.4464867 0.6614866 0.1571274]
> xr = [0.9458893 -2.4340447 2.4489666 0.9703065]
Function Evaluation #44, index=5, x= [0.9458893 -2.4340447 2.4489666 0.9703065]
Inequality constraint #1/3 is not satisfied for x
Function Evaluation #45, index=5, x= [0.5426444 -1.4402657 1.5552266 0.5637169]
Inequality constraint #1/3 is not satisfied for x
Function Evaluation #46, index=5, x= [0.3410219 -0.9433762 1.1083566 0.3604222]
Function Evaluation #47, index=2, x= [0.3410219 -0.9433762 1.1083566 0.3604222]
xr=[0.3410219 -0.9433762 1.1083566 0.3604222], f(xr)=-14.147695
  > Perform Reflection
Sort
=================================================================
Iteration #3 (total = 3)
Function Eval #47
Xopt : [0.8269055 0.6419589 1.7487262 0.9286551]
Fopt : -29.492616
DeltaFv : 32.350085
Center : [0.1646023 -0.5085979 0.7173453 0.1825392]
Size : 2.8582402
Optim Simplex Object:
=====================
nbve: 8
n: 4
x: 8-by-4 matrix
fv: 8-by-1 matrix
  > Termination ?
  > iterations=3 >= maxiter=5
  > funevals=47 >= maxfunevals=1000
  > e(x)=0.3705056 < 1.490D-08 * 0.9130556 + 0
  > Terminate = F, status = continue
  > simplex size=2.8582402 < 0 + 0.001 * 2.239716
  > Terminate = F, status = continue
Reflect
xbar=[0.2869482 -0.4328452 0.7723769 0.2210111]
_boxlinesearch
> xhigh=[-0.6918195 -1.0388667 0.3321244 -0.086764], fhigh=2.8574697
> xbar=[0.2869482 -0.4328452 0.7723769 0.2210111]
> xr = [1.5593463 0.3549827 1.3447051 0.6211188]
Function Evaluation #48, index=5, x= [1.5593463 0.3549827 1.3447051 0.6211188]
Inequality constraint #3/3 is not satisfied for x
Function Evaluation #49, index=5, x= [0.9231472 -0.0389312 1.058541 0.4210649]
Function Evaluation #50, index=2, x= [0.9231472 -0.0389312 1.058541 0.4210649]
xr=[0.9231472 -0.0389312 1.058541 0.4210649], f(xr)=-20.430956
  > Perform Reflection
Sort
=================================================================
Iteration #4 (total = 4)
Function Eval #50
Xopt : [0.8269055 0.6419589 1.7487262 0.9286551]
Fopt : -29.492616
DeltaFv : 30.217137
Center : [0.3664731 -0.383606 0.8081474 0.2460178]
Size : 2.6934096
Optim Simplex Object:
=====================
nbve: 8
n: 4
x: 8-by-4 matrix
fv: 8-by-1 matrix
  > Termination ?
  > iterations=4 >= maxiter=5
  > funevals=50 >= maxfunevals=1000
  > e(x)=0.2620103 < 1.490D-08 * 0.9975385 + 0
  > Terminate = F, status = continue
  > simplex size=2.6934096 < 0 + 0.001 * 2.239716
  > Terminate = F, status = continue
Reflect
xbar=[0.3512877 -0.3613307 0.9127312 0.2521709]
_boxlinesearch
> xhigh=[0.4727706 -0.5395325 0.0760608 0.2029462], fhigh=0.7245215
> xbar=[0.3512877 -0.3613307 0.9127312 0.2521709]
> xr = [0.19336 -0.1296685 2.0004028 0.3161631]
Function Evaluation #51, index=5, x= [0.19336 -0.1296685 2.0004028 0.3161631]
Function Evaluation #52, index=2, x= [0.19336 -0.1296685 2.0004028 0.3161631]
xr=[0.19336 -0.1296685 2.0004028 0.3161631], f(xr)=-31.956391
  > Perform Reflection
Sort
=================================================================
Iteration #5 (total = 5)
Function Eval #52
Xopt : [0.19336 -0.1296685 2.0004028 0.3161631]
Fopt : -31.956391
DeltaFv : 31.956391
Center : [0.3315468 -0.332373 1.0486902 0.26017]
Size : 2.2520083
Optim Simplex Object:
=====================
nbve: 8
n: 4
x: 8-by-4 matrix
fv: 8-by-1 matrix
  > Termination ?
  > iterations=5 >= maxiter=5
  > Terminate = T, status = maxiter
  > Terminate = T, status = maxiter
Terminate with status : maxiter
nm = neldermead_destroy(nm);