SubGrad.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------*/
/*-------------------------- File SubGrad.h --------------------------------*/
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
/*----------------------------- DEFINITIONS --------------------------------*/
/*--------------------------------------------------------------------------*/
 
#ifndef __SubGrad
 #define __SubGrad  /* self-identification: #endif at the end of the file */
 
/*--------------------------------------------------------------------------*/
/*-------------------------------- MACROS ----------------------------------*/
/*--------------------------------------------------------------------------*/
#define SubGrad_HANDLES_CONSTRAINTS 0
 
/*--------------------------------------------------------------------------*/
/*------------------------------ INCLUDES ----------------------------------*/
/*--------------------------------------------------------------------------*/
 
#include "NDOSlver.h" // NDOSolver is the base class
 
#include "Deflection.h"  // These classes are defined as friend classes, in
#include "Stepsize.h"    // order to allow them to use directly SubgGrad's
                         // data structures [see below].
/* Note: a few methods of Stepsize and Deflection are implemented at the end of
   SubGrad.C. These are the methods that allow to read protected data of
   SubGrad, which may be useful to the objects. The methods are implemented
   here for the base classes, so that any derived class can use them to
   access to these data. This is crucial, as derived classes from friend
   classes are not friend, and therefore they cannot access data of SubGrad
   unless this capability is explicitly provided by the base classes, who are
   friends. */
 
#include "math.h"
 
#include <vector>
#include <random>
 
#if SubGrad_HANDLES_CONSTRAINTS
 #include "CQKnPClass.h"  //  used for managing the projection probelm
#endif
 
/*--------------------------------------------------------------------------*/
/*----------------------------- NAMESPACE ----------------------------------*/
/*--------------------------------------------------------------------------*/
 
namespace NDO_di_unipi_it
{
 
 #if SubGrad_HANDLES_CONSTRAINTS
  using namespace CQKnPClass_di_unipi_it;
 
  // class CQKnPClass;  // forward definition of CQKnPClass
 #endif
 
/*--------------------------------------------------------------------------*/
/*----------------------------- CLASSES ------------------------------------*/
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
/*--------------------------- CLASS SubGrad  -------------------------------*/
/*--------------------------------------------------------------------------*/
/*--------------------------- GENERAL NOTES --------------------------------*/
/*--------------------------------------------------------------------------*/
class SubGrad : public NDOSolver
{
 
/*--------------------------------------------------------------------------*/
/*----------------------- PUBLIC PART OF THE CLASS -------------------------*/
/*--------------------------------------------------------------------------*/
 
 public:
 
/*--------------------------------------------------------------------------*/
/*---------------------------- FRIEND CLASSES ------------------------------*/
/*--------------------------------------------------------------------------*/
  friend class Stepsize;
  friend class Deflection;
 
/*---------------------------- PUBLIC TYPES --------------------------------*/
/*--------------------------------------------------------------------------*/
   enum SGParam{ kSGPar1 = kLastNDOParam ,
         kSGPar2 , kSGPar3 , kSGPar4 , kSGPar5 };
 
/*--------------------- PUBLIC METHODS OF THE CLASS ------------------------*/
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
/*---------------------------- CONSTRUCTOR ---------------------------------*/
/*--------------------------------------------------------------------------*/
   SubGrad( std::istream *iStrm = 0 );
 
/*-------------------------- OTHER INITIALIZATIONS -------------------------*/
/*--------------------------------------------------------------------------*/
   void SetStepsize( Stepsize *STP = nullptr );
 
/*--------------------------------------------------------------------------*/
 
   void SetDeflection( Deflection *Vol = nullptr );
 
/*--------------------------------------------------------------------------*/
 
#if SubGrad_HANDLES_CONSTRAINTS
 
   void SetQKNP( CQKnPClass *KNP = nullptr );
 
#endif
 
/*--------------------------------------------------------------------------*/
 
   void SetFiOracle( FiOracle *Fi = nullptr );
 
/*--------------------------------------------------------------------------*/
 
   void SetLambda( cLMRow tLambda = nullptr );
 
/*--------------------------------------------------------------------------*/
 
   void KeepBestLambda( const bool KBL = true );
 
/*--------------------------------------------------------------------------*/
 
   void SetPar( const int wp , const int value );
 
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
 
   void SetPar( const int wp , cHpNum value );
 
/*--------------------------------------------------------------------------*/
 
   void SetPar( const int wp , const bool value );
 
/*--------------------------------------------------------------------------*/
 
   void SetNDOLog( std::ostream *outs = 0 , const char lvl = 0 );
 
/*-------------------- METHODS FOR SOLVING THE PROBLEM ---------------------*/
/*--------------------------------------------------------------------------*/
   NDOStatus Solve( void );
 
/*--------------------------------------------------------------------------*/
 
   void ReSetAlg( unsigned char RstLvl = 0 );
 
/*---------------------- METHODS FOR READING RESULTS -----------------------*/
/*--------------------------------------------------------------------------*/
   cLMRow ReadBestSol( cIndex_Set &I , Index &D );
 
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
 
   HpNum ReadBestFiVal( cIndex wFi = Inf< Index >() );
 
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
 
   cLMRow ReadSol( cIndex_Set &I , Index &D );
 
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
 
   HpNum ReadFiVal( cIndex wFi = Inf< Index >() );
 
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
 
   HpNum ReadHatFiVal( void );
 
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
 
   bool IsOptimal( HpNum eps = 0 );
 
/*--------------------------------------------------------------------------*/
 
   cHpRow ReadMult( cIndex_Set &I , Index &D , cIndex wFi = Inf< Index >() );
 
   HpNum ReadLBMult( cIndex wFi = Inf< Index >() );
 
/*-------------- METHODS FOR READING THE DATA OF THE PROBLEM ---------------*/
/*--------------------------------------------------------------------------*/
   inline void GetPar( const int wp , int &value );
 
   inline void GetPar( const int wp , HpNum &value );
 
   inline void GetPar( const int wp , bool &value );
 
/*------------- METHODS FOR ADDING / REMOVING / CHANGING DATA --------------*/
/*--------------------------------------------------------------------------*/
   void AddVariables( Index NNwVrs , cLMRow IVs = 0 );
 
   void RemoveVariables( cIndex_Set whch = 0 , Index hwmny = 0 );
 
   void ChgFiV( cIndex wFi = Inf< Index >() );
 
   void ChgSbG( cIndex strt = 0 , Index stp = Inf< Index >() ,
           cIndex wFi = Inf< Index >() );
 
/*------------------------------ DESTRUCTOR --------------------------------*/
/*--------------------------------------------------------------------------*/
   ~SubGrad();
 
/*---------------------- PROTECTED PART OF THE CLASS -----------------------*/
/*--------------------------------------------------------------------------*/
 
 protected:
 
/*--------------------------------------------------------------------------*/
/*-------------------------- PROTECTED METHODS -----------------------------*/
/*--------------------------------------------------------------------------*/
 
   void FiAndGi( cIndex wFi = Inf< Index >() );
 
/*--------------------------------------------------------------------------*/
 
   void FormD( void );
 
/*--------------------------------------------------------------------------*/
 
   void SaveDir( void );
 
/*--------------------------------------------------------------------------*/
 
   void GotoLambda1( void );
 
/*--------------------------------------------------------------------------*/
 
   void FormLambda1( void );
 
/*--------------------------------------------------------------------------*/
/*----------------------- PROTECTED DATA STRUCTURES  -----------------------*/
/*--------------------------------------------------------------------------*/
 
   Index SGPar1;       
 
   HpNum SGPar2;       
 
   Index SGPar3;       
 
   bool SGPar4;        
 
   Index SGPar5;       
 
   Stepsize *stepsize;       
 
   Deflection *deflection;   
 
   Index MaxNumVar;     
 
   LMRow LambdaBar;     
   HpNum FiBar;         
 
   LMRow Lambda;        
   HpNum FiLambda;      
 
   LMRow LambdaHat;     
   HpNum FiHat;         
 
 
   bool LHasChgd;       
   bool LHasProj;       
   bool KpBstL;         
   HpNum FiBest;        
   LMRow LambdaBest;    
 
   HpNum LowerBound;    
   bool TrueLB;         
   SgRow Gi;            
   SgRow dir;           
 
   HpNum alpha;         
   HpNum step;          
 
   HpNum Sigma;         
   HpNum Epsilon;       
   HpNum SigmaHat;      
   HpNum HatEpsilon;    
   Index_Set SGBase;    
 
   HpNum NrmGi;         
   HpNum NrmDir;        
 
   HpNum dGk;           
   HpNum dM1Gk;         
 
   bool dM1GkDone;      
   LMRow ub;            
   LMRow lb;            
 
   #if SubGrad_HANDLES_CONSTRAINTS
    Index MaxNCnst;      
    Index MaxName;       
 
    CQKnPClass *Q2KNP;   
 
    Index_Set CnstBeg;   
    HpRow CnstVol;       
    SIndex_Set CnstNxt;  
   #endif
 
   std::mt19937 myrandom;  
 
   bool ZeroComp;       
   Index NItIncr;       
   bool InnIter;        
 
   vector< Index > Seq;   
   bool DirPos;         
   Index_Set MultBse;
 
   Index CSSCntr;       
   Index CNSCntr;       
 
   Index CSmallStep;    
   bool DoSS;           
 
   FiOracle::FiStatus fs;  
   bool EmptySet;       
 
/*--------------------------------------------------------------------------*/
/*--------------------- PRIVATE PART OF THE CLASS --------------------------*/
/*--------------------------------------------------------------------------*/
 
 private:
 
/*--------------------------------------------------------------------------*/
/*-------------------------- PRIVATE METHODS -------------------------------*/
/*--------------------------------------------------------------------------*/
 
   inline void Log1( void );
 
   inline void Log2( void );
 
   inline void Log3( void );
 
   inline void Log4( void );
 
/*--------------------------------------------------------------------------*/
 
   void AllocateUBLB( cIndex strt , cIndex num );
 
/*--------------------------------------------------------------------------*/
 
   inline LMNum lbnd( cIndex i ) {
    return( lb ? lb[ i ] : - Inf< LMNum >() );
    }
 
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
 
   inline LMNum ubnd( cIndex i ) {
    return( ub ? ub[ i ] : Inf< LMNum >() );
    }
 
/*--------------------------------------------------------------------------*/
 
  #if SubGrad_HANDLES_CONSTRAINTS
   void EvalConst( void );
  #endif
 
   void EvalGi( Index wFi = Inf< Index >() );
 
/*--------------------------------------------------------------------------*/
 
   bool ProjFsb( LMRow Lpt , bool & EmptySet );
 
   void ProjTng( SgRow Gpt , cLMRow Lpt ,
         cIndex strt = 0 , Index stp = Inf< Index >() );
 
/*--------------------------------------------------------------------------*/
 
   void InitStepsize( void );
 
   void InitDeflection( void );
 
/*--------------------------------------------------------------------------*/
 
   void ChgLambdaHat( void );
 
/*--------------------------------------------------------------------------*/
 
   void UpdateSigma( void );
 
/*--------------------------------------------------------------------------*/
 
   void UpdtLowerBound( void );
 
/*--------------------------------------------------------------------------*/
 
   void MemDealloc( void );
 
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
 
 };  // end( class SubGrad )
 
/*--------------------------------------------------------------------------*/
/*------------------- inline methods implementation ------------------------*/
/*--------------------------------------------------------------------------*/
 
inline void SubGrad::GetPar( const int wp , int &value )
{
 switch( wp ) {
  case( kSGPar1 ): value = SGPar1; break;
  case( kSGPar3 ): value = SGPar3; break;
  case( kSGPar5 ): value = SGPar5; break;
  default:  NDOSolver::GetPar( wp , value );
  }
 }  // end( SubGrad::GetPar( Index ) )
 
/*--------------------------------------------------------------------------*/
 
inline void SubGrad::GetPar( const int wp , HpNum &value )
{
 switch( wp ) {
  case( kSGPar2 ): value = SGPar2; break;
  default:  NDOSolver::GetPar( wp , value );
  }
 }  // end( SubGrad::GetPar( HpNum ) )
 
/*--------------------------------------------------------------------------*/
 
inline void SubGrad::GetPar( const int wp , bool &value )
{
 switch( wp ) {
  case( kSGPar4 ): value = SGPar4; break;
  default: throw( NDOException( "GetPar( bool ): unknown parameter" ) );
  }
 }  // end( SubGrad::GetPar( HpNum ) )
 
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
 
};  // end( namespace NDO_di_unipi_it )
 
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
 
#endif /* __SubGrad */
 
/*--------------------------------------------------------------------------*/
/*------------------------- End File SubGrad.h -----------------------------*/
/*--------------------------------------------------------------------------*/