Volume.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------*/
/*--------------------------- File Volume.h --------------------------------*/
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
/*-------------------- DEFINITIONS & IMPLEMENTATION ------------------------*/
/*--------------------------------------------------------------------------*/
 
#ifndef __Volume
 #define __Volume  /* self-identification: #endif at the end of the file */
 
/*--------------------------------------------------------------------------*/
/*------------------------------- MACROS  ----------------------------------*/
/*--------------------------------------------------------------------------*/
 
#define LOG_VOL 0
 
/* If LOG_VOL > 0, the Volume class produces a log of its activities on the
   ostream object and at the "level of verbosity" set with the method
   SetVOLLog() [see below]. */
 
#if( LOG_VOL )
 #define VOLLOG( l , x ) if( VOLLLvl > l ) *VOLLog << x
 #define VOLLOG2( l , c , x ) if( ( VOLLLvl > l ) && c ) *VOLLog << x
#else
 #define VOLLOG( l , x )
 #define VOLLOG2( l , c , x )
#endif
 
/*--------------------------------------------------------------------------*/
/*------------------------------ INCLUDES ----------------------------------*/
/*--------------------------------------------------------------------------*/
 
#include "Deflection.h"
#include <algorithm>
 
/*--------------------------------------------------------------------------*/
/*----------------------------- NAMESPACE ----------------------------------*/
/*--------------------------------------------------------------------------*/
 
namespace NDO_di_unipi_it
{
 
/*--------------------------------------------------------------------------*/
/*--------------------------- GENERAL NOTES --------------------------------*/
/*--------------------------------------------------------------------------*/
class Volume : public Deflection
{
 
/*--------------------------------------------------------------------------*/
/*----------------------- PUBLIC PART OF THE CLASS -------------------------*/
/*--------------------------------------------------------------------------*/
 
 public:
 
/*--------------------------------------------------------------------------*/
/*--------------------- PUBLIC METHODS OF THE CLASS ------------------------*/
/*--------------------------------------------------------------------------*/
/*---------------------------- CONSTRUCTOR ---------------------------------*/
/*--------------------------------------------------------------------------*/
 Volume( SubGrad *slvr , std::istream *iStrm = 0 ) : Deflection( slvr )
 {
  DfltdSfInpt( iStrm , tauInit , HpNum( 1 ) );
  DfltdSfInpt( iStrm , tauMin , HpNum( 1e-4 ) );
  DfltdSfInpt( iStrm , tauFactor , HpNum( 0.5 ) );
  DfltdSfInpt( iStrm , tauIter , Index( 100 ) );
  DfltdSfInpt( iStrm , m , HpNum( 0.1 ) );
  }
 
/*--------------------------------------------------------------------------*/
/*-------------------------- OTHER INITIALIZATIONS -------------------------*/
/*--------------------------------------------------------------------------*/
 
 inline void SetVOLLog( ostream *outs = 0 , const char lvl = 0 );
 
/*--------------------------------------------------------------------------*/
 
 void Format( void )
 {
  Deflection::Format();
  alpha = lastvalue = Inf< HpNum >();  // deflection coefficient is unknown
  tau = tauInit;
  }
 
/*--------------------------------------------------------------------------*/
/*-------------------- METHODS FOR DEFLECTION COMPUTATION ------------------*/
/*--------------------------------------------------------------------------*/
 
 inline void NewDEF( void );
 
/*--------------------------------------------------------------------------*/
/*---------------------- METHODS FOR READING RESULTS -----------------------*/
/*--------------------------------------------------------------------------*/
 
 inline HpNum GetDFLCoeff( void );
 
 inline bool DoSS( void );
 
 inline HpNum Delta( void );
 
/*--------------------------------------------------------------------------*/
/*--------------------- PRIVATE PART OF THE CLASS --------------------------*/
/*--------------------------------------------------------------------------*/
 
 private:
 
/*--------------------------------------------------------------------------*/
/*--------------------------- PRIVATE METHODS ------------------------------*/
/*--------------------------------------------------------------------------*/
 
 inline void Solve( void );
 
/*--------------------------------------------------------------------------*/
/*----------------------- PRIVATE DATA STRUCTURES  -------------------------*/
/*--------------------------------------------------------------------------*/
 
 HpNum tauInit;     // initial tau
 HpNum tauMin;      // the minimum value of tau
 HpNum tauFactor;   // the decreasing factor
 Index tauIter;     // the number of iterations after a decrease
 HpNum m;           // descent parameter
 
 HpNum tau;         // the safeguarded parameter tau
 HpNum lastvalue;   // last function value Fi()
 HpNum alpha;       // deflection coefficient
 
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
 
 };  // end( class Volume )
 
/*--------------------------------------------------------------------------*/
/*------------------- inline methods implementation ------------------------*/
/*--------------------------------------------------------------------------*/
 
inline void Volume::SetVOLLog( ostream *outs , const char lvl )
{
 Deflection::SetVOLLog( outs , lvl );
 
 #if( LOG_VOL )
  if( VOLLLvl > 1 )
   *VOLLog << std::endl <<  "Volume: tau = " << tauInit << " in ["<< tauMin
       << " , -] with ( " << tauFactor << " , " << tauIter << " ) ~ m = "
       << m << std::endl;
 #endif
 }
 
/*--------------------------------------------------------------------------*/
 
inline void Volume::NewDEF(  void )
{
 // change tau if needed - - - - - - - - - - - - - - - - - - - - - - - - - - -
 //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 if( Solver->NrIter() <= 1 ) {
  alpha = 1;
  return;
  }
 
 HpNum FiRec = Solver->ReadBestFiVal();
 
 // tau should be decreased if after tauIter iterations Fi() is decreased
 // less than 1% - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 if( ! ( Solver->NrIter() % tauIter ) )
  if( tau > tauMin ) {
   cHpNum x = ( lastvalue - FiRec ) / ABS( FiRec );
   lastvalue = FiRec;
   if( x <= 0.01 ) {
    tau *= tauFactor;
    if( tau < tauMin )
     tau = tauMin;
    }
   }
 
 // solve a quadratic problem and get the deflection coefficient - - - - - - -
 //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 Solve();
 
 }  // end( Volume::NewDEF )
 
/*--------------------------------------------------------------------------*/
 
inline HpNum Volume::GetDFLCoeff( void )
{
 return( alpha );
 }
 
/*--------------------------------------------------------------------------*/
 
inline bool Volume::DoSS( void )
{
 bool serious;
 HpNum Delta;
 Solver->GetPar( NDOSolver::kEpsLin , Delta );
 Delta *= m * std::max( 1.0 , ABS( Solver->ReadBestFiVal() ) );
 
 // if there is an improvement of Fi(), a SS occurs; otherwise, a NS occurs
 if( ( Solver->ReadFiVal() - ReadFVal() ) >= Delta )
  serious = true;
 else
  serious = false;
 
 return( serious );
 
 }  // end( Volume::DoSS )
 
/*--------------------------------------------------------------------------*/
 
inline HpNum Volume::Delta( void )
{
 HpNum EpsLin;
 Solver->GetPar( NDOSolver::kEpsLin , EpsLin );
 return( m * EpsLin * std::max( 1.0 , ABS( Solver->ReadBestFiVal() ) ) );
 }
 
/*--------------------------------------------------------------------------*/
 
inline void Volume::Solve( void )
{
 HpNum GiNorm = GetGiNorm();
 HpNum DNorm = GetDNorm();
 HpNum GixD = GetdGk();
 HpNum Sigma = GetSigma();
 HpNum Epsilon = GetEpsilon();
 
 // compute the proximity parameter  - - - - - - - - - - - - - - - - - - - -
 //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 HpNum proximity = GetStepsize() == Inf< HpNum >() ? 1 : GetStepsize();
 
 // solving the cutting plane model  - - - - - - - - - - - - - - - - - - - - -
 //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 HpNum den = proximity * ( GiNorm + DNorm - 2.0 * GixD );
 
 if( den <= 1e-8 )
  alpha = 1;
 else
  alpha = ( Epsilon - Sigma - proximity * ( GixD - DNorm ) ) / den;
 
 // tau should be projected over [0,1] - - - - - - - - - - - - - - - - - - -
 //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 if( alpha > 1 )
  alpha = std::min( tau , 1.0 );
 else
  if( alpha < 1e-8 )
   alpha = tau / 10;
 
 }  // end ( void Solve )
 
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
 
};  // end( namespace NDO_di_unipi_it )
 
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
 
#endif  /* Volume.h included */
 
/*--------------------------------------------------------------------------*/
/*------------------------- End File Volume.h ------------------------------*/
/*--------------------------------------------------------------------------*/