Stepsize.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------*/
/*--------------------------- File Stepsize.h ------------------------------*/
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
/*----------------------------- DEFINITIONS --------------------------------*/
/*--------------------------------------------------------------------------*/
 
#ifndef __Stepsize
 #define __Stepsize /* self-identification: #endif at the end of the file */
 
/*--------------------------------------------------------------------------*/
/*------------------------------ INCLUDES ----------------------------------*/
/*--------------------------------------------------------------------------*/
 
#include "SubGrad.h"
#include "OPTvect.h"
 
#include <algorithm>
 
/*--------------------------------------------------------------------------*/
/*----------------------------- NAMESPACE ----------------------------------*/
/*--------------------------------------------------------------------------*/
 
namespace NDO_di_unipi_it
{
 
 class SubGrad;     // forward declaration of class SubGrad
 
/*--------------------------------------------------------------------------*/
/*-------------------------- CLASS Stepsize --------------------------------*/
/*--------------------------------------------------------------------------*/
/*--------------------------- GENERAL NOTES --------------------------------*/
/*--------------------------------------------------------------------------*/
class Stepsize
{
 
/*--------------------------------------------------------------------------*/
/*----------------------- PUBLIC PART OF THE CLASS -------------------------*/
/*--------------------------------------------------------------------------*/
 
 public:
 
/*--------------------------------------------------------------------------*/
/*--------------------- PUBLIC METHODS OF THE CLASS ------------------------*/
/*--------------------------------------------------------------------------*/
/*---------------------------- CONSTRUCTOR ---------------------------------*/
/*--------------------------------------------------------------------------*/
   Stepsize( SubGrad *slvr , istream *iStrm = 0 )
   {
    if( ! slvr )
     throw NDOException("Stepsize::Stepsize: no subgradient solver ");
    Solver = slvr;
 
    if( iStrm )
     DfltdSfInpt( iStrm , LpsFct , HpNum( 1 ) );
 
    STPLog = 0;
    STPLLvl = 0;
 
    }  // end( Stepsize::Stepsize )
 
/*-------------------------- OTHER INITIALIZATIONS -------------------------*/
/*--------------------------------------------------------------------------*/
   virtual void SetSTPLog( std::ostream *outs = 0 , const char lvl = 0 )
   {
    if( ( STPLog = outs ) )
     STPLLvl = lvl;
    else
     STPLLvl = 0;
    }
 
/*--------------------------------------------------------------------------*/
   virtual void Format( void )
   {
    Beta = MaxBeta = Inf< HpNum >();
    FiLev = - Inf< HpNum >();
    }
 
/*-------------------- METHODS FOR STEPSIZE COMPUTATION --------------------*/
/*--------------------------------------------------------------------------*/
   virtual void NewStep( void ) = 0;
 
/*--------------------------------------------------------------------------*/
   virtual bool NeedsdkM1Gk( void ) { return( false ); }
 
/*---------------------- METHODS FOR READING RESULTS -----------------------*/
/*--------------------------------------------------------------------------*/
   virtual HpNum GetStepsize( bool StepIsIncr = false )
   {
    HpNum denomin, step;
    const HpNum STEpZro = 1e-8;
 
    if( StepIsIncr ) {
     HpNum LipCns = GetOracle()->GetGlobalLipschitz();
     denomin = LipCns * LipCns * HpNum( LpsFct * GetNItIcr() );
     }
    else
     denomin = GetDNorm();
 
    if( denomin <= ( STEpZro * std::max( ABS( ReadFiBar() ) , HpNum(1) ) ) )
     step = 1;
    else {
     HpNum Beta_ = Beta;
     if( Beta_ >= std::min( 2.0 , MaxBeta ) )
      Beta_ = std::min( 2.0 - STEpZro , MaxBeta );
     step = Beta_ * ( ReadFiBar() - FiLev ) / denomin;
     }
 
    return( step );
 
    }  // end( GetStepsize )
    
/*--------------------------------------------------------------------------*/
   virtual HpNum GetLev( void ) { return( FiLev ); }
 
/*--------------------------------------------------------------------------*/
   virtual HpNum GetBeta( void ) { return( Beta ); }
 
/*------------- METHODS FOR ADDING / REMOVING / CHANGING DATA --------------*/
/*--------------------------------------------------------------------------*/
   virtual void SetMaxBeta( const HpNum alpha )
   {
    MaxBeta = alpha;
    }
 
/*------------------------------ DESTRUCTOR --------------------------------*/
/*--------------------------------------------------------------------------*/
   virtual ~Stepsize() {}
 
/*---------------------- PROTECTED PART OF THE CLASS -----------------------*/
/*--------------------------------------------------------------------------*/
 
  protected:
 
/*--------------------------------------------------------------------------*/
/*-------------------------- PROTECTED METHODS -----------------------------*/
/*--------------------------------------------------------------------------*/
   virtual bool UpdateTargetLevel( void ) { return( false ); }
 
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
   HpNum GetCoeffDefl( void );
 
/*--------------------------------------------------------------------------*/
   FiOracle* GetOracle( void );
 
/*--------------------------------------------------------------------------*/
   HpNum GetGiNorm( void );
 
/*--------------------------------------------------------------------------*/
   HpNum GetDNorm( void );
 
/*--------------------------------------------------------------------------*/
   HpNum GetdGk( void );
 
/*--------------------------------------------------------------------------*/
  HpNum GetdkM1Gk( void );
 
/*--------------------------------------------------------------------------*/
   Index GetNItIcr( void );
 
/*--------------------------------------------------------------------------*/
   HpNum ReadFkVal( void );
    
/*--------------------------------------------------------------------------*/
   HpNum ReadFiBar( void );
 
/*----------------------- PROTECTED DATA STRUCTURES  -----------------------*/
/*--------------------------------------------------------------------------*/
  
  SubGrad *Solver;  
  std::ostream *STPLog;  
  char STPLLvl;     
 
  HpNum FiLev;      
  HpNum Beta;       
  HpNum MaxBeta;    
 
  HpNum LpsFct;     
 
/*--------------------------------------------------------------------------*/
 
 }; // end( class Stepsize )
 
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
 
};  // end( namespace NDO_di_unipi_it )
 
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
 
#endif  /* Stepsize.h included */
 
/*--------------------------------------------------------------------------*/
/*------------------------ End File Stepsize.h -----------------------------*/
/*--------------------------------------------------------------------------*/