MATH_StiefelOptimizer.h

Go to the documentation of this file.

#ifndef MATH_StiefelOptimizer_H
#define MATH_StiefelOptimizer_H


#include "LAP_DoubleFullGeneralMatrix.h"
#include "LAP_DoubleFullSymmetricMatrix.h"
#include "MATH_StiefelFunction.h"

DEFINE_SPTR(MATH_StiefelOptimizer);
DEFINE_SVPTR(MATH_StiefelOptimizer);
class MATH_StiefelOptimizer: public virtual CORE_Object {
    SP_OBJECT(MATH_StiefelOptimizer);
    // ATTRIBUTES

private:
    // indicates if output is printed
    tBoolean mIsVerbose;
    // max number of iterations
    int mMaxIterationsNumber;
    // X control stopping criterium
    // ||X_{k+1}-X_{k}|| < mEpsX
    double mEpsX; 
    // function control stopping criterium
    //|F_{k+1} - F_{k}|/(1+|F_{k}|) < mEpsF
    double mEpsF;
    // Gradient control stopping criterium
    // 
    double mEpsG;

    // linear approximation factor
    // parameters for control the linear approximation in line search
    double mRho;
  
    // step control
    // factor for decreasing the step size in the backtracking line search
    double mEta;
    
    //parameters for updating C by HongChao, Zhang
    double mGamma;

 
    double mTau;
    
    //interations number to compute mean of xDiff & fDiff during iterations
    int mStoredIterationsNumber;

    // number of iterations used in the algorithm
    int mIterationsNumber;

    //number of  calls to function
    int mFunctionCallsNumber;

    // error of projection on X on orthogonal space
    double mXProjError;

    // projection G type
    tFlag mGProjectType;


    // internal matrices
    LAP_DoubleFullGeneralMatrix mGradient,mXtG,mU,mV,mH,mM,mHX;
    LAP_DoubleFullGeneralMatrix mX_old,mDtX_old;
    LAP_DoubleFullSymmetricMatrix mtXX;

private:

    // ASSOCIATIONS
    SP::MATH_StiefelFunction mFunction;
  
protected: 
    // METHODS
  
    // CONSTRUCTORS 
  
    MATH_StiefelOptimizer(void);
  
  
  
    // DESTRUCTORS 
  
  
    virtual ~MATH_StiefelOptimizer(void);   
  

public:
   
   
    static inline SP::MATH_StiefelOptimizer New() {
        SP::MATH_StiefelOptimizer p(new MATH_StiefelOptimizer(),
                                    MATH_StiefelOptimizer::Delete());
        p->setThis(p);
        return p;
    }
 
    // SET methods 

public:

    inline void setIsVerbose(const tBoolean& v) {
        mIsVerbose=v;
    }
    inline void setMaxIterationsNumber(const int& n) {
        mMaxIterationsNumber=n;
    }
    inline int getMaxIterationsNumber() const {
        return mMaxIterationsNumber;
    }
    inline void setPrecisions(const double& epsX,const double& epsF,const double& epsG) {
        mEpsX=epsX;
        mEpsF=epsF;
        mEpsG=epsG;
    }
    inline void getPrecisions(double& epsX,double& epsF,double& epsG)const {
        epsX=mEpsX;
        epsF=mEpsF;
        epsG=mEpsG;
    }
  

    inline void setGProjectionType(const tFlag& f) {
        mGProjectType=f;
    }
     
    inline void setFunction(SP::MATH_StiefelFunction f) {
        mFunction=f;
    }
 



    inline void resetFunction() {
        mFunction.reset();
    }
  


    inline tBoolean hasFunction() const {
        return (mFunction.get()!=null);
    };
    inline const MATH_StiefelFunction* getFunction() const {
        return mFunction.get();
    }; 
    inline MATH_StiefelFunction* getFunction() {
        return mFunction.get();
    };

    inline int getFunctionCallsNumber() const {
        return mFunctionCallsNumber;
    }
     

    tBoolean minimize(LAP_DoubleFullGeneralMatrix& X,double& FValue,double& GNorm);
     
 
    virtual tString toString() const;

private:

    static void verbose(const int& iter,const double& tau,const double& F,const double& GNorm,
                        const double& xDiff,const double& fDiff,const int& nls);
    
    void computeNewXWithHInverse(double& tau,LAP_DoubleFullGeneralMatrix& X,LAP_DoubleFullGeneralMatrix& G,double& F,int& nls,
                                 const LAP_DoubleFullGeneralMatrix& X_old,const LAP_DoubleFullGeneralMatrix& XtG,
                                 LAP_DoubleFullGeneralMatrix& H,LAP_DoubleFullGeneralMatrix& HX,LAP_DoubleFullGeneralMatrix& M,
                                 const double& step,const double& F_ref,const double& eta, int& ncalls);
    
    void computeNewXWithGProject(double& tau,LAP_DoubleFullGeneralMatrix& X,LAP_DoubleFullGeneralMatrix& G,double& F,
                                 const tFlag& GProjectType,int& nls,
                                 const LAP_DoubleFullGeneralMatrix& X_old,LAP_DoubleFullGeneralMatrix& U,LAP_DoubleFullGeneralMatrix& V,
                                 LAP_DoubleFullGeneralMatrix& H,LAP_DoubleFullGeneralMatrix& tVX,LAP_DoubleFullGeneralMatrix& M,
                                 const double& step,const double& F_ref,const double& eta, int& ncalls);

    static void transform(const tFlag& transformType,
                          LAP_DoubleFullGeneralMatrix& G,
                          const LAP_DoubleFullGeneralMatrix& X,
                          LAP_DoubleFullGeneralMatrix& work);
    
};


#endif