NDOSlver.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------*/
/*--------------------------- File NDOSlver.h ------------------------------*/
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
/*----------------------------- DEFINITIONS --------------------------------*/
/*--------------------------------------------------------------------------*/
 
#ifndef __NDOSolver
 #define __NDOSolver  /* self-identification: #endif at the end of the file */
 
/*--------------------------------------------------------------------------*/
/*------------------------------ INCLUDES ----------------------------------*/
/*--------------------------------------------------------------------------*/
 
#include "FiOracle.h"
 
/*--------------------------------------------------------------------------*/
/*----------------------------- NAMESPACE ----------------------------------*/
/*--------------------------------------------------------------------------*/
namespace NDO_di_unipi_it
{
/*--------------------------------------------------------------------------*/
/*-------------------------- CLASS NDOSolver -------------------------------*/
/*--------------------------------------------------------------------------*/
/*--------------------------- GENERAL NOTES --------------------------------*/
/*--------------------------------------------------------------------------*/
class NDOSolver
{
/*--------------------------------------------------------------------------*/
/*----------------------- PUBLIC PART OF THE CLASS -------------------------*/
/*--------------------------------------------------------------------------*/
 
 public:
 
/*--------------------------------------------------------------------------*/
/*---------------------------- PUBLIC TYPES --------------------------------*/
/*--------------------------------------------------------------------------*/
   enum NDOParam { kMaxItr = 0 , kMaxTme ,
           ktStar , kEpsLin ,
           kEInit , kEFnal , kEDcrs , kEStps ,
           kLastNDOParam
                   };
 
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
 
   enum NDOStatus { kOK = 0 ,
            kUnbndd , kUnfsbl ,
            kStopped , kLwPrcsn , kStpIter , kStpTime ,
            kError
                    };
 
/*--------------------- PUBLIC METHODS OF THE CLASS ------------------------*/
/*--------------------------------------------------------------------------*/
/*---------------------------- CONSTRUCTOR ---------------------------------*/
/*--------------------------------------------------------------------------*/
   NDOSolver( std::istream *iStrm = 0 );
 
/*-------------------------- OTHER INITIALIZATIONS -------------------------*/
/*--------------------------------------------------------------------------*/
   virtual void SetFiOracle( FiOracle *Fi = 0 ) {
    if( ( Oracle = Fi ) ) {
     NrFi = Fi->GetNrFi();
     NumVar = Fi->GetNumVar();
 
     SCalls = ParIter = FiEvaltns = GiEvaltns = 0;
     }
    }
 
/*--------------------------------------------------------------------------*/
 
   virtual void SetLambda( cLMRow tLambda = 0 ) = 0;
 
/*--------------------------------------------------------------------------*/
 
   virtual void KeepBestLambda( const bool KBL = true ) {};
 
/*--------------------------------------------------------------------------*/
 
   virtual void SetPar( const int wp , const int value );
 
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
 
   virtual void SetPar( const int wp , cHpNum value );
 
/*--------------------------------------------------------------------------*/
   virtual void SetNDOLog( ostream *outs = 0 , const char lvl = 0 ) {
    if( ( NDOLog = outs ) )
     NDOLLvl = lvl;
    else
     NDOLLvl = 0;
    }
 
/*--------------------------------------------------------------------------*/
   virtual void SetNDOTime( const bool TimeIt = true ) {
    if( TimeIt )
     if( NDOt )
      NDOt->ReSet();
     else
      NDOt = new OPTtimers();
    else {
     delete NDOt;
     NDOt = 0;
     }
    }
 
/*-------------------- METHODS FOR SOLVING THE PROBLEM ---------------------*/
/*--------------------------------------------------------------------------*/
   virtual NDOStatus Solve( void ) = 0;
 
/*--------------------------------------------------------------------------*/
 
   virtual void ReSetAlg( unsigned char RstLvl = 0 ) {}
 
/*---------------------- METHODS FOR READING RESULTS -----------------------*/
/*--------------------------------------------------------------------------*/
   virtual cLMRow ReadSol( cIndex_Set &I , Index &D ) = 0;
 
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
   virtual cLMRow ReadBestSol( cIndex_Set &I , Index &D ) {
    return( ReadSol( I , D ) );
    }
 
/*--------------------------------------------------------------------------*/
 
   virtual HpNum ReadFiVal( cIndex wFi = Inf< Index >() ) = 0;
 
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
   virtual HpNum ReadBestFiVal( cIndex wFi = Inf< Index >() ) {
    return( ReadFiVal( wFi ) );
    }
 
/*--------------------------------------------------------------------------*/
   virtual bool IsOptimal( HpNum eps = 0 ) const {
    return( ( Result == kOK ) );  // a standard very naive implementation is
                                  // provided, but it should probably be
                                  // redefined in real classes
    }
 
/*--------------------------------------------------------------------------*/
   virtual cHpRow ReadMult( cIndex_Set &I , Index &D ,
                cIndex wFi = Inf< Index >() ) {
    I = nullptr; D = 0; return( 0 );
    }
 
/*--------------------------------------------------------------------------*/
   virtual HpNum ReadLBMult( cIndex wFi = Inf< Index >() ) { return( 0 ); }
 
/*--------------------------------------------------------------------------*/
   Index FiEval( void ) const { return( FiEvaltns ); }
 
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
   Index GiEval( void ) const { return( GiEvaltns ); }
 
/*--------------------------------------------------------------------------*/
   Index NrCalls( void ) const { return( SCalls ); }
 
/*--------------------------------------------------------------------------*/
   Index NrIter( void ) const { return( ParIter ); }
 
/*--------------------------------------------------------------------------*/
   void NDOTime( double & t_us , double & t_ss ) {
    t_us = t_ss = 0;
    if( NDOt )
     NDOt->Read( t_us , t_ss ); 
    }
 
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
   double NDOTime( void ) { return( NDOt ? NDOt->Read() : 0 ); }
 
/*-------------- METHODS FOR READING THE DATA OF THE PROBLEM ---------------*/
/*--------------------------------------------------------------------------*/
   Index GetNumVar( void ) const { return( NumVar ); }
 
/*--------------------------------------------------------------------------*/
 
   virtual void GetPar( const int wp , int &value );
 
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
 
   virtual void GetPar( const int wp , HpNum &value );
 
/*------------- METHODS FOR ADDING / REMOVING / CHANGING DATA --------------*/
/*--------------------------------------------------------------------------*/
   virtual void AddVariables( Index NNwVrs , cLMRow IVs = 0 ) {
    throw( NDOException( "AddVariables: adding variables is not supported" )
       );
    }
 
/*--------------------------------------------------------------------------*/
   virtual void RemoveVariables( cIndex_Set whch = 0 , Index hwmny = 0 ) {
    throw( NDOException(
           "RemoveVariables: removing variables is not supported" ) );
    }
 
/*--------------------------------------------------------------------------*/
   virtual void ChgFiV( cIndex wFi = Inf< Index >() ) {
    throw( NDOException( "ChgFiV: changing Fi-values is not supported" ) );
    }
 
/*--------------------------------------------------------------------------*/
   virtual void ChgSbG( cIndex strt = 0 , Index stp = Inf< Index >() ,
            cIndex wFi = Inf< Index >() ) {
    throw( NDOException( "ChgSbG: changing subgradients is not supported" ) );
    }
 
/*------------------------------ DESTRUCTOR --------------------------------*/
/*--------------------------------------------------------------------------*/
  virtual ~NDOSolver() { delete NDOt; }
 
/*-------------------- PROTECTED PART OF THE CLASS -------------------------*/
/*--------------------------------------------------------------------------*/
 
 protected:
 
/*--------------------------------------------------------------------------*/
/*----------------------- PROTECTED DATA STRUCTURES  -----------------------*/
/*--------------------------------------------------------------------------*/
  FiOracle *Oracle;  
 
  Index MaxIter;     
  HpNum MaxTime;     
 
  HpNum tStar;       
  HpNum EpsLin;      
 
  HpNum EInit;       
  HpNum EFnal;       
  HpNum EDcrs;       
  int EStps;         
 
  NDOStatus Result;  
 
  Index NumVar;      
  Index NrFi;        
 
  Index SCalls;      
  Index ParIter;     
  Index FiEvaltns;   
  Index GiEvaltns;   
 
 
  ostream *NDOLog;   
  char NDOLLvl;      
 
  OPTtimers *NDOt;   
 
/*--------------------------------------------------------------------------*/
 
 };  // end( class NDOSolver )
 
/*--------------------------------------------------------------------------*/
/*------------------- inline methods implementation ------------------------*/
/*--------------------------------------------------------------------------*/
 
inline NDOSolver::NDOSolver( std::istream *iStrm  )
{
 // initialize algorithmic parameters - - - - - - - - - - - - - - - - - - - -
 
 DfltdSfInpt( iStrm , MaxIter , Index( 0 ) );
 DfltdSfInpt( iStrm , MaxTime , HpNum( 0 ) );
 
 DfltdSfInpt( iStrm , tStar  , HpNum( 100 ) );
 DfltdSfInpt( iStrm , EpsLin , HpNum( 1e-6 ) );
 
 DfltdSfInpt( iStrm , EInit , HpNum( 1e-2 ) );
 DfltdSfInpt( iStrm , EFnal , HpNum( 1e-6 ) );
 DfltdSfInpt( iStrm , EDcrs , HpNum( .95 ) );
 DfltdSfInpt( iStrm , EStps , int( 0 ) );
 
 // other little initializations- - - - - - - - - - - - - - - - - - - - - - -
 
 Result = kOK;
 
 Oracle = 0;
 NumVar = NrFi = 0;
 
 NDOLog = 0;
 NDOLLvl = 0;
 
 NDOt = 0;
 
 }  // end( NDOSolver::NDOSolver )
 
/*--------------------------------------------------------------------------*/
 
inline void NDOSolver::SetPar( const int wp , const int value )
{
 switch( wp ) {
  case( kMaxItr ): MaxIter = Index( value ); break;
  case( kEStps ):  EStps = value; break;
  default:         throw(
            NDOException( "SetPar( Index ): unknown parameter" ) );
  }
 }  // end( NDOSolver::SetPar( Index ) )
 
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
 
inline void NDOSolver::SetPar( const int wp , cHpNum value )
{
 switch( wp ) {
  case( kMaxTme ): MaxTime = value; break;
  case( ktStar ):  tStar = value; break;
  case( kEpsLin ): EpsLin = value; break;
  case( kEInit ):  EInit = value; break;
  case( kEFnal ):  EFnal = value; break;
  case( kEDcrs ):  EDcrs = value; break;
  default:         throw(
            NDOException( "SetPar( HpNum ): unknown parameter" ) );
  }
 }  // end( NDOSolver::SetPar( HpNum ) )
 
/*--------------------------------------------------------------------------*/
 
inline void NDOSolver::GetPar( const int wp , int &value )
{
 switch( wp ) {
  case( kMaxItr ): value = int( MaxIter ); break;
  case( kEStps ):  value = EStps; break;
  default:         throw(
            NDOException( "GetPar( Index ): unknown parameter" ) );
  }
 }  // end( NDOSolver::GetPar( Index ) )
 
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
 
inline void NDOSolver::GetPar( const int wp , HpNum &value )
{
 switch( wp ) {
  case( kMaxTme ): value = MaxTime; break;
  case( ktStar ):  value = tStar; break;
  case( kEpsLin ): value = EpsLin; break;
  case( kEInit ):  value = EInit; break;
  case( kEFnal ):  value = EFnal; break;
  case( kEDcrs ):  value = EDcrs; break;
  default:         throw(
            NDOException( "GetPar( HpNum ): unknown parameter" ) );
  }
 }  // end( NDOSolver::GetPar( HpNum ) )
 
/*--------------------------------------------------------------------------*/
 
 }  // end( namespace NDO_di_unipi_it )
 
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
 
#endif  /* NDOSlver.h included */
 
/*--------------------------------------------------------------------------*/
/*------------------------- End File NDOSlver.h ----------------------------*/
/*--------------------------------------------------------------------------*/