FumeroTV.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------*/
/*--------------------------- File FumeroTV.h ------------------------------*/
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
/*-------------------- DEFINITIONS & IMPLEMENTATION ------------------------*/
/*--------------------------------------------------------------------------*/
 
#ifndef __FumeroTV
 #define __FumeroTV  /* self-identification: #endif at the end of the file */
 
/*--------------------------------------------------------------------------*/
/*------------------------------ INCLUDES ----------------------------------*/
/*--------------------------------------------------------------------------*/
 
#include "Stepsize.h"
 
/*--------------------------------------------------------------------------*/
/*------------------------------- MACROS  ----------------------------------*/
/*--------------------------------------------------------------------------*/
 
#define LOG_STP 0
 
/* If LOG_STP > 0, the FumeroTV class produces a log of its activities on the
   ostream object and at the "level of verbosity" set with the method
   SetSTPLog() [see below]. */
 
#if( LOG_STP )
 #define STPLOG( l , x ) if( STPLLvl > l ) *STPLog << x
 #define STPLOG2( l , c , x ) if( ( STPLLvl > l ) && c ) *STPLog << x
#else
 #define STPLOG( l , x )
 #define STPLOG2( l , c , x )
#endif
 
/*--------------------------------------------------------------------------*/
/*----------------------------- NAMESPACE ----------------------------------*/
/*--------------------------------------------------------------------------*/
 
namespace NDO_di_unipi_it
{
 
/*--------------------------------------------------------------------------*/
/*--------------------------- GENERAL NOTES --------------------------------*/
/*--------------------------------------------------------------------------*/
class FumeroTV : public Stepsize
{
 
/*--------------------------------------------------------------------------*/
/*----------------------- PUBLIC PART OF THE CLASS -------------------------*/
/*--------------------------------------------------------------------------*/
 
 public:
 
/*--------------------------------------------------------------------------*/
/*--------------------- PUBLIC METHODS OF THE CLASS ------------------------*/
/*--------------------------------------------------------------------------*/
/*---------------------------- CONSTRUCTOR ---------------------------------*/
/*--------------------------------------------------------------------------*/
 FumeroTV( SubGrad *slvr , std::istream *iStrm = NULL )
  : Stepsize( slvr , iStrm )
 {
  DfltdSfInpt( iStrm , sigmaMin , HpNum( 1e-4 ) );
  DfltdSfInpt( iStrm , r1 , Index( 5 ) );
  DfltdSfInpt( iStrm , BetaZero , HpNum( 1 ) );
  DfltdSfInpt( iStrm , eta1 , Index( 5 ) );
  DfltdSfInpt( iStrm , eta2 , Index( 5 ) );
  }
 
/*--------------------------------------------------------------------------*/
/*-------------------------- OTHER INITIALIZATIONS -------------------------*/
/*--------------------------------------------------------------------------*/
 
 inline void SetSTPLog( ostream *outs = 0 , const char lvl = 0 );
 
/*--------------------------------------------------------------------------*/
 
 inline void Format( void );
 
/*--------------------------------------------------------------------------*/
/*-------------------- METHODS FOR STEPSIZE COMPUTATION --------------------*/
/*--------------------------------------------------------------------------*/
 
 inline void NewStep( void );
 
/*--------------------------------------------------------------------------*/
/*---------------------- PROTECTED PART OF THE CLASS -----------------------*/
/*--------------------------------------------------------------------------*/
 
 protected:
 
 inline bool UpdateTargetLevel( void );
 
/*--------------------------------------------------------------------------*/
/*--------------------- PRIVATE PART OF THE CLASS --------------------------*/
/*--------------------------------------------------------------------------*/
 
 private:
 
/*--------------------------------------------------------------------------*/
/*-------------------------- PRIVATE METHODS -------------------------------*/
/*--------------------------------------------------------------------------*/
 
 inline HpNum ExpFun( Index ri );
 
/*--------------------------------------------------------------------------*/
/*----------------------- PRIVATE DATA STRUCTURES  -------------------------*/
/*--------------------------------------------------------------------------*/
 
 HpNum FiLambda;   
 
 HpNum LwrBnd;     
 HpNum FiRef;      
 
 HpNum sigma;      
 HpNum sigmaMin;   
 
 HpNum BetaZero;
 
 Index rc;         
 Index r1;
 Index r2;
 
 Index etac;       
 Index eta1;       
 Index eta2;
 
/*--------------------------------------------------------------------------*/
 
 }; // end( class FumeroTV )
 
/*--------------------------------------------------------------------------*/
/*------------------- inline methods implementation ------------------------*/
/*--------------------------------------------------------------------------*/
 
inline void FumeroTV::Format( void )
{
 Stepsize::Format();
 Beta = BetaZero;
 
 FiLambda = FiRef = Inf< HpNum >();
 // FiLambda and the reference value are not known
 LwrBnd = -Inf< HpNum >();  // no lower bound or target level is known
 
 etac = rc = 0;
 r2 = ceil( pow( ( - log( sigmaMin ) / 0.6933 ) , ( 1.0 / 3.26 ) ) * r1 );
 
 sigma = 1;
 
 }  // end ( FumeroTV::Format() )
 
/*--------------------------------------------------------------------------*/
 
inline void FumeroTV::NewStep( void )
{
 // get the function value   - - - - - - - - - - - - - - - - - - - - - - - - -
 //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 FiLambda = ReadFkVal();
 
 if( FiLambda == Inf< HpNum >() )
  throw( NDOException( "FumeroTV::GetStepsize: this should not happen" ) );
 
 // try to improve the target level - - - - - - - - - - - - - - - - - - - - -
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 bool TLchgd = UpdateTargetLevel();
 
 // update target level- - - - - - - - - - - - - - - - - - - - - - - - - - - -
 //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 if( TLchgd )
  FiLev = sigma * LwrBnd + ( 1 - sigma ) * FiRef;
 
 // fix beta - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 if( Beta < 1e-6 )
  Beta = 1e-6;
 
 // print the level - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 STPLOG( 1 , endl << "           " << " level  = " << -FiLev << " ~  beta = "
         << Beta << endl << "           " );
 
 }  // end( FumeroTV::NewStep )
 
/*--------------------------------------------------------------------------*/
 
inline void FumeroTV::SetSTPLog( ostream *outs , const char lvl )
{
 Stepsize::SetSTPLog( outs , lvl );
 
 #if( LOG_STP )
  if( STPLLvl > 1 ) {
   *STPLog << endl << "FumeroTV: ~ BetaZero = " << BetaZero
       << " ~ (Eps0 , r1) = (" << sigma << " , " << r1 << ")"
       << " ~  Eta = {" << eta1 << " , " << eta2 << "}" << endl;
   }
 #endif
 }  // end( FumeroTV::SetSTPLog )
 
/*--------------------------------------------------------------------------*/
 
inline bool FumeroTV::UpdateTargetLevel( void )
{
 bool TLchgd = false;
 
 // the target level is updated if any changes of the lower bound occurs - - -
 //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 cHpNum LwrBnd_ = GetOracle()->GetLowerBound();
 if( LwrBnd_ > LwrBnd ) {
  LwrBnd = LwrBnd_;
  TLchgd = true;
  }
 
 // some exception - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 if( LwrBnd == - Inf< HpNum >() )
  throw( NDOException(
               "FumeroTV::UpdateTargetLevel: no lower bound is given" ) );
 HpNum FiRef_;
 if( FiRef == Inf< HpNum >() )  // not initialized yet
  FiRef_ = Inf< HpNum >();
 else
  FiRef_ = FiRef - ( 1e-6 * std::max( HpNum( 1.0 ) , std::abs( FiRef ) ) );
 
 // beta updating- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 if( FiLambda <= FiRef_ ) {
  FiRef = FiLambda;
  if( rc >= r2 )
   Beta *= 2.0;
  etac = 0;
  TLchgd = true;
  }
 else  // FiLambda > FiRef_
  if( rc >= r2 ) {
   if( ++etac >= eta2 ) {
    Beta /= 2;
    etac = 0;
    }
   }
  else
   if( ++etac >= eta1 ) {
    Beta = Beta / ( 2.0 * Beta + 1.0 );
    sigma = ExpFun( ++rc );
    TLchgd = true;
    etac = 0;
    }
 
 // failure of the target level updating - - - - - - - - - - - - - - - - - - -
 //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 if( FiLev < LwrBnd ) {  // change the level
  FiLev = LwrBnd;
  TLchgd = true;
  }
 
 return( TLchgd );
 
 }  // end( FumeroTV::UpdateTargetLevel )
 
/*--------------------------------------------------------------------------*/
 
inline HpNum FumeroTV::ExpFun( Index ri )
{
 return( exp( -0.6933 * pow( HpNum( ri ) / HpNum( r1 ) , 3.26 ) ) );
 
 }  // end( FumeroTV::ExpFun )
 
/*--------------------------------------------------------------------------*/
 
};  // end( namespace NDO_di_unipi_it )
 
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
 
#endif  /* FumeroTV.h included */
 
/*--------------------------------------------------------------------------*/
/*------------------------- End File FumeroTV.h ----------------------------*/
/*--------------------------------------------------------------------------*/