model.3.man

COOOL：CWP面向对象最优化库（CWP Object Oriented Optimization Library） COOOL是C++类的一个集合

MODEL(base)     MODEL SPACE REPRESENTATION      MODEL(base)

                                                     Jun  1 15:19
NAME
    Model - a simple class for model parameters

SYNOPSIS
    #include <Vector.hh>

    class Model

        \fIPublic members\fP
            Model();
            Model(int n);
            Model(Vector<Type>& maxp, Vector<Type>& minp,
            Vector<Type>& initmod);
            Model(Vector<Type>& maxp, Vector<Type>& minp,
            Vector<Type>& initmod, Type deltmod);
            Model(Vector<Type>& maxp, Vector<Type>& minp);
            Model(Vector<Type>& initmod);
            Model(Model<Type>& initmod);
            ~Model();
            int modSize();
            const Type oneMax(int);
            const Type oneMin(int);
            Vector<Type>& modMax();
            Vector<Type>& modMin();
            void setModMax(const Vector<Type>&);
            void setModMin(const Vector<Type>&);
            const Vector<Type>  modParam() const;
            Type&	grid();
            Type	norm(int p);
            Model<Type> normalize();
            Type	range(int);
            Type& operator[](int);
            Model<Type>	update(Type, Type, Vector<Type>&);
            operator Model<int>();
            operator Model<long>();
            operator Model<float>();
            operator Model<double>();
            Model<Type>& operator=(Vector<Type>&);
            Model<Type>& operator=(Model<Type>&);
            Model<Type>& operator=(Type);
            Model<Type>& operator*=( Type);
            Model<Type>& operator+=( Vector<Type>&);
            Model<Type>& operator-=( Vector<Type>&);
            Model<Type>& operator+=( Model<Type>&);
            Model<Type>& operator-=( Model<Type>&);
            Model<Type>& chaSize(int);

        \fIFriends\fP
            ostream& operator<<(ostream&, const Model<Type>&);
            istream& operator>>(istream&, Model<Type>&);
            Model<Type> operator*(Model<Type>&, Type);
            Model<Type> operator*(Type,  Model<Type>&);
            Model<Type> operator+(Model<Type>&, Model<Type>&);
            Model<Type> operator+(Model<Type>&, Vector<Type>&);
            Model<Type> operator+(Vector<Type>&, Model<Type>&);
            Model<Type> operator-(Model<Type>&, Model<Type>&);
            Model<Type> operator-(Model<Type>&, Vector<Type>&);
            Model<Type> operator-(Vector<Type>&, Model<Type>&);

        \fIPrivate members\fP
            int	ndim;
            Type	deltmod;
            Vector<Type>*	mp;
            Vector<Type>*	maxParam;
            Vector<Type>*	minParam;

DESCRIPTION
    Model<Type>
       is a simple representation for parameters in model space.
     Unknown parameters are represented by a simple Vector. 
     This class is one of the three major inputs of optimization
     algorithms in COOOL. Search constraints in model space 
     of the optimizations are carried only by Model class; 
     Boundary or grid information are specified using 
     constructors with different arguments;
    

DESCRIPTION
    Constructors:
      Model(): construct a Model with size of 1 with 
        infinite range;
      Model(n): construct a Model with size of n with 
        infinite range;
      Model(maxp, minp, init): a Model with value of Vector init; 
        the Model parameters are in the range of [minp, maxp];
      Model(maxp, minp, initmod, deltmod): a Model with value of 
        Vector init, the Model parameters are in [minp, maxp], 
        descretized grid spacing is deltmod;
      Model(maxp, minp): construct a Model with boundary 
        [minp, maxp], and 0 initial values;
      Model(initv), Model(initm): construct a new Model the same
        as Model initm, or with values of Vector initv;
    
    Fetching information of the Model:
      int modSize(): returns number of dimensions of the 
        model space;
      Type oneMax(i): returns the upper limit of the ith 
        parameter;
      Type oneMin(i); returns the lower limit of the ith 
        parameter;
      Vector<Type>& modMax(): returns the upper limit of Model 
         parameters as a Vector;
      Vector<Type>& modMin(): returns the lower limit of Model 
         parameters as a Vector;
      Vector<Type> modParam(): returns model parameters as 
         a Vector;
      Type norm(p): returns the p-norm of model parameters;
      Model<Type> normalize(): returns the normalizes Model;
      Type range(i): returns the range (difference of the upper 
        and lower limits) of the ith parameter;
      Model<Type> update(a, b, d): update to a new Model by 
        a linear search, a*m+b*d. m is the current Model 
        parameter vector, Vector d is usually the new searching 
        direction in optimizations, scalars a b are scalings of 
        the current Model parameters and searching Vector, 
        respectively.
    
    Modifying the Model:
      Type& operator[](i): access the ith parameter of the Model;
      Type& grid(): access the grid spacing of the Model;
      void setModMax(maxp): set the upper limit of the Model;
      void setModMin(minp): set the lower limit of the Model; 
      Model<Type>& chaSize(n): change size of the Model to n;
    
    Arithmatics:
      Operators -, =, +=, -=, *= /=, +, -, *, /,
        arithmatics with other Models, Vectors, a single number;
    I/O operators: <<, >>
    

CAVEATS

DEFINED MACROS
    MODEL_HH

INCLUDED FILES
    <iostream.h>
    "Vector.hh"

SOURCE FILES
    Model.hh