simplex.3.man

来自「COOOL：CWP面向对象最优化库（CWP Object Oriented Op」· MAN 代码 · 共 104 行

SIMPLEX(derived)  OPTIMIZATION ALGORITHM   SIMPLEX(derived)

                                                     Jun  1 15:20
NAME
    Simplex - non-gradient based optimizer

SYNOPSIS
    #include <Simplex.hh>

    class Simplex : public NonQuadraticOptima

        \fIPublic members\fP
            int				maxiters;
            double			alpha;
            double			beta;
            double			gamma;
            Simplex(ObjectiveFunction*, Model<double>*, int,
            double, double, double);
            Simplex(ObjectiveFunction*, Model<double>*, int,
            double, double, double, int);
            ~Simplex();
            Model<double>optimizer(Model<double>&)
            {return 0;}
                Model<long>	optimizer(Model<long>&)
                {return 0;}
                    Model<double> optimizer(const double atol);
                    Model<double> optimizer(Vector<double>& atollist);
                    double	bestValue() 	{return value;}
                        int		evaluations() 	{return fp->iterations();}
                            void reset(Vector<double>& lambda);
                        };
                        #endif

        \fIPrivate members\fP
            void			formPsum();
            double			tryNewPoint(int ihigh, const double lever);
            int				nd;
            Model<double>*		models;
            Vector<double>*		psum;
            Vector<double>*		fv;
            double			value;

DESCRIPTION
    Simplex()
    The downhill simplex -do not confuse this one with the
    simplex algorithm used in linear programming- is a direct
    search method that do not require information
    on the derivatives of the objective function (Nelder, J. 
    and Mead, R., The SIMPLEX method, Computer Journal, 7, 
    1087 - 1092). The basic idea is to build a polyhedron
    of dimension n+1, where n is the dimension of the objective
    function, with trial solutions to the problem assigned to 
    each one of its vertexes. During the optimization
    process this polyhedron is distorted to "move" in the 
    direction of the best solution.
    

DESCRIPTION
    Public Operations
    Constructors: 
     Simplex(ObjectiveFunction* f, Model<double>*models, 
    int iter, double alpha, double beta, 
    double gamma)
    Here:
     f: Defines a pointer to the objective function
     models: Defines a pointer to the n+1 initial models required
             by the Simplex class, where n is the dimension of 
             the objective function
     iter: Maximum number of iterations
     tol: Minimum accepted module of the gradient at optimum solution
     alpha: Reflection parameter (I recommend gamma = 1)
     beta: contraction parameter ( I recommend beta = .5)
     gamma: Expansion parameter (I recommend gamma = 2)
    
    Methods:
     optimizer(double atol)
    Here:
     atol: Stopping criterion. It defines te mimimum size of
           the polyhedron around the optimum solution. 
           Notice that as the optimization go the
           polyhedron tends to shrink arounf the minimizer.
    
      The optimum model is returned by the function.
    

CAVEATS
    The fact that n+1 initial guesses have to be provided to the
    Simplex algorithm almost rules out its application in large
    optimization problems. Also the Powell's derivative-free 
    conjugate gradient tend to be a more efficient algorithm. 
    The inclusion of the Simplex algorithm in the COOOL
    library is mainly for completeness purposes.

DEFINED MACROS
    SIMPLEX_HH

INCLUDED FILES
    "NonQuaOptima.hh"

SOURCE FILES
    Simplex.cc